tests/linux: use Akaros's CFLAGS
[akaros.git] / kern / arch / x86 / pci.h
1 /* Copyright (c) 2009, 2010 The Regents of the University of California
2  * See LICENSE for details.
3  *
4  * Barret Rhoden <brho@cs.berkeley.edu>
5  * Original by Paul Pearce <pearce@eecs.berkeley.edu> */
6
7 #pragma once
8
9 #include <ros/common.h>
10 #include <sys/queue.h>
11 #include <atomic.h>
12 #include <kthread.h>
13 #include <arch/pci_regs.h>
14
15 #define pci_debug(...)  printk(__VA_ARGS__)
16
17 #define PCI_CONFIG_ADDR     0xCF8
18 #define PCI_CONFIG_DATA     0xCFC
19 #define INVALID_VENDOR_ID   0xFFFF
20
21 /* TODO: gut this (when the IOAPIC is fixed) */
22 #define INVALID_BUS                     0xFFFF
23
24 #define PCI_NOINT                       0x00
25 #define PCI_INTA                        0x01
26 #define PCI_INTB                        0x02
27 #define PCI_INTC                        0x03
28 #define PCI_INTD                        0x04
29
30 /* PCI Register Config Space */
31 #define PCI_DEV_VEND_REG        0x00    /* for the 32 bit read of dev/vend */
32 #define PCI_VENDID_REG          0x00
33 #define PCI_DEVID_REG           0x02
34 #define PCI_CMD_REG             0x04
35 #define PCI_STATUS_REG          0x06
36 #define PCI_REVID_REG           0x08
37 #define PCI_PROGIF_REG          0x09
38 #define PCI_SUBCLASS_REG        0x0a
39 #define PCI_CLASS_REG           0x0b
40 #define PCI_CLSZ_REG            0x0c
41 #define PCI_LATTIM_REG          0x0d
42 #define PCI_HEADER_REG          0x0e
43 #define PCI_BIST_REG            0x0f
44 /* Config space for header type 0x00  (Standard) */
45 #define PCI_BAR0_STD            0x10
46 #define PCI_BAR1_STD            0x14
47 #define PCI_BAR2_STD            0x18
48 #define PCI_BAR3_STD            0x1c
49 #define PCI_BAR4_STD            0x20
50 #define PCI_BAR5_STD            0x24
51 #define PCI_BAR_OFF             0x04
52 #define PCI_CARDBUS_STD         0x28
53 #define PCI_SUBSYSVEN_STD       0x2c
54 #define PCI_SUBSYSID_STD        0x2e
55 #define PCI_EXPROM_STD          0x30
56 #define PCI_CAPAB_STD           0x34
57 #define PCI_IRQLINE_STD         0x3c
58 #define PCI_IRQPIN_STD          0x3d
59 #define PCI_MINGRNT_STD         0x3e
60 #define PCI_MAXLAT_STD          0x3f
61 /* Config space for header type 0x01 (PCI-PCI bridge) */
62 /* None of these have been used, so if you use them, check them against
63  * http://wiki.osdev.org/PCI#PCI_Device_Structure */
64 #define PCI_BAR0_BR             0x10
65 #define PCI_BAR1_BR             0x14
66 #define PCI_BUS1_BR             0x18
67 #define PCI_BUS2_BR             0x19
68 #define PCI_SUBBUS_BR           0x1a
69 #define PCI_LATTIM2_BR          0x1b
70 #define PCI_IOBASE_BR           0x1c
71 #define PCI_IOLIM_BR            0x1d
72 #define PCI_STATUS2_BR          0x1e
73 #define PCI_MEMBASE_BR          0x20
74 #define PCI_MEMLIM_BR           0x22
75 #define PCI_PREMEMBASE_BR       0x24
76 #define PCI_PREMEMLIM_BR        0x26
77 #define PCI_PREBASEUP32_BR      0x28
78 #define PCI_PRELIMUP32_BR       0x2c
79 #define PCI_IOBASEUP16_BR       0x30
80 #define PCI_IOLIMUP16_BR        0x32
81 #define PCI_CAPAB_BR            0x34
82 #define PCI_EXPROM_BR           0x38
83 #define PCI_IRQLINE_BR          0x3c
84 #define PCI_IRQPIN_BR           0x3d
85 #define PCI_BDGCTL_BR           0x3e
86 /* Config space for header type 0x02 (PCI-Cardbus bridge) */
87 /* None of these have been used, so if you use them, check them against
88  * http://wiki.osdev.org/PCI#PCI_Device_Structure */
89 #define PCI_SOC_BASE_CB         0x10
90 #define PCI_OFF_CAP_CB          0x14
91 #define PCI_SEC_STAT_CB         0x16
92 #define PCI_BUS_NR_CB           0x18
93 #define PCI_CARDBUS_NR_CB       0x19
94 #define PCI_SUBBUS_NR_CB        0x1a
95 #define PCI_CARD_LAT_CB         0x1b
96 #define PCI_MEM_BASE0_CB        0x1c
97 #define PCI_MEM_LIMIT0_CB       0x20
98 #define PCI_MEM_BASE1_CB        0x24
99 #define PCI_MEM_LIMIT1_CB       0x28
100 #define PCI_IO_BASE0_CB         0x2c
101 #define PCI_IO_LIMIT0_CB        0x30
102 #define PCI_IO_BASE1_CB         0x34
103 #define PCI_IO_LIMIT1_CB        0x38
104 #define PCI_IRQLINE_CB          0x3c
105 #define PCI_IRQPIN_CB           0x3d
106 #define PCI_BDGCTL_CB           0x3e
107 #define PCI_SUBDEVID_CB         0x40
108 #define PCI_SUBVENID_CB         0x42
109 #define PCI_16BIT_CB            0x44
110
111 /* Command Register Flags */
112 #define PCI_CMD_IO_SPC          (1 << 0)
113 #define PCI_CMD_MEM_SPC         (1 << 1)
114 #define PCI_CMD_BUS_MAS         (1 << 2)
115 #define PCI_CMD_SPC_CYC         (1 << 3)
116 #define PCI_CMD_WR_EN           (1 << 4)
117 #define PCI_CMD_VGA             (1 << 5)
118 #define PCI_CMD_PAR_ERR         (1 << 6)
119 /* #define PCI_CMD_XXX          (1 << 7) Reserved */
120 #define PCI_CMD_SERR            (1 << 8)
121 #define PCI_CMD_FAST_EN         (1 << 9)
122 #define PCI_CMD_IRQ_DIS         (1 << 10)
123
124 /* Status Register Flags (Bits 9 and 10 are one field) */
125 /* Bits 0, 1, and 2 are reserved */
126 #define PCI_ST_IRQ_STAT         (1 << 3)
127 #define PCI_ST_CAP_LIST         (1 << 4)
128 #define PCI_ST_66MHZ            (1 << 5)
129 /* #define PCI_CMD_XXX          (1 << 6)  Reserved */
130 #define PCI_ST_FAST_CAP         (1 << 7)
131 #define PCI_ST_MASPAR_ERR       (1 << 8)
132 #define PCI_ST_DEVSEL_TIM       (3 << 9)        /* 2 bits */
133 #define PCI_ST_SIG_TAR_ABRT     (1 << 11)
134 #define PCI_ST_REC_TAR_ABRT     (1 << 12)
135 #define PCI_ST_REC_MAS_ABRT     (1 << 13)
136 #define PCI_ST_SIG_SYS_ERR      (1 << 14)
137 #define PCI_ST_PAR_ERR          (1 << 15)
138
139 /* BARS: Base Address Registers */
140 #define PCI_BAR_IO              0x1     /* 1 == IO, 0 == Mem */
141 #define PCI_BAR_IO_MASK         0xfffffffc
142 #define PCI_BAR_MEM_MASK        0xfffffff0
143 #define PCI_MEMBAR_TYPE         (3 << 1)
144 #define PCI_MEMBAR_32BIT        0x0
145 #define PCI_MEMBAR_RESV         0x2     /* type 0x1 shifted to MEMBAR_TYPE */
146 #define PCI_MEMBAR_64BIT        0x4     /* type 0x2 shifted to MEMBAR_TYPE */
147
148 #define PCI_MAX_BUS             256
149 #define PCI_MAX_DEV             32
150 #define PCI_MAX_FUNC            8
151
152 // Run the PCI Code to loop over the PCI BARs. For now we don't use the BARs,
153 // dont check em.
154 #define CHECK_BARS              0
155
156 #define MAX_PCI_BAR             6
157
158 /* Nothing yet, but this helps with Linux drivers. */
159 struct device {
160 };
161
162 struct pci_bar {
163         uint32_t                        raw_bar;
164         uint32_t                        pio_base;
165         uint32_t                        mmio_base32;
166         uint64_t                        mmio_base64;
167         uint32_t                        mmio_sz;
168         void                            *mmio_kva;
169 };
170
171 /* Half-baked and optional PCI ops.  These are purposefully not Linux's
172  * pci_driver, since our driver init is different.  For now.  Our drivers all
173  * scan the PCI list looking for their devices.  Some do it in init_func_3
174  * (IOAT).  The NICs do it by devether with its pnp registration mechanism.
175  *
176  * Furthermore, this device state / init business is really only used for
177  * devices that can get assigned to userspace and need some methods run before
178  * and after that assignment.
179  *
180  * So most devices still auto-init themselves, around the same time that they
181  * post their pci_ops (if they support runtime reset & init).  Then later, we
182  * can reset the device, then init again.  So the usual pattern is Boot ->
183  * {Reset -> Init}*.  Now this is up to the driver - drivers don't have to
184  * pre-init.  They can leave it in an unassigned state if they want.  Again,
185  * this is only used for the hokey user assignment with a kernel driver.
186  *
187  * And only make these transitions with one caller at a time, particularly after
188  * boot.  These drivers are no set up for concurrent changes.  YMMV.
189  *
190  * And it's up to the caller to make sure no one is using the device anymore
191  * before resetting.  For proc-assigned devices, this won't be too hard - wait
192  * until proc_free() (refcnt is 0, all syscalls are done, etc).  For
193  * kernel-assigned devices, YMMV.  The IOAT driver / DMA engine prints a warning
194  * if there was a concurrent user.
195  *
196  * Bus mastering needs some thought, esp w.r.t. assigning/unassigning a device.
197  * All PCI devices currently manage this on their own.  Probe is done on their
198  * own too - PCI doesn't call a device probe method, so we don't know it failed,
199  * and thus don't know to clear BME.
200  */
201 struct pci_device;
202 struct pci_ops {
203         const char *driver_name;
204         bool (*init)(struct pci_device *);
205         bool (*reset)(struct pci_device *);
206 };
207
208 enum {
209         DEV_STATE_UNKNOWN = 0,
210         DEV_STATE_BROKEN = 1,
211         DEV_STATE_UNASSIGNED = 2,
212         DEV_STATE_ASSIGNED_KERNEL = 3,
213         DEV_STATE_ASSIGNED_USER = 4,
214 };
215
216 struct pci_device {
217         STAILQ_ENTRY(pci_device)        all_dev; /* list of all devices */
218         char                            name[9];
219         spinlock_t                      lock;
220         qlock_t                         qlock;
221         struct pci_ops                  *_ops;  /* don't access directly */
222         int                             state;
223         uintptr_t                       mmio_cfg;
224         void                            *dev_data; /* device private pointer */
225         struct iommu                    *iommu; /* ptr to controlling iommu */
226         struct device                   linux_dev;
227         int                             domain; /* legacy size was 16-bits */
228         uint8_t                         bus;
229         uint8_t                         dev;
230         uint8_t                         func;
231         uint16_t                        dev_id;
232         uint16_t                        ven_id;
233         uint8_t                         irqline;
234         uint8_t                         irqpin;
235         char                            *header_type;
236         uint8_t                         class;
237         uint8_t                         subclass;
238         uint8_t                         progif;
239         bool                            msi_ready;
240         uint32_t                        msi_msg_addr_hi;
241         uint32_t                        msi_msg_addr_lo;
242         uint32_t                        msi_msg_data;
243         uint8_t                         nr_bars;
244         struct pci_bar                  bar[MAX_PCI_BAR];
245         uint32_t                        caps[PCI_CAP_ID_MAX + 1];
246         uintptr_t                       msix_tbl_paddr;
247         uintptr_t                       msix_tbl_vaddr;
248         uintptr_t                       msix_pba_paddr;
249         uintptr_t                       msix_pba_vaddr;
250         unsigned int                    msix_nr_vec;
251         bool                            msix_ready;
252         TAILQ_ENTRY(pci_device)         iommu_link;
253         TAILQ_ENTRY(pci_device)         proc_link;
254         struct proc                     *proc_owner;
255 };
256
257 struct msix_entry {
258         uint32_t addr_lo, addr_hi, data, vector;
259 };
260
261 struct msix_irq_vector {
262         struct pci_device               *pcidev;
263         struct msix_entry               *entry;
264         uint32_t                        addr_lo;
265         uint32_t                        addr_hi;
266         uint32_t                        data;
267 };
268
269 /* List of all discovered devices */
270 TAILQ_HEAD(pcidev_tq, pci_device);
271 STAILQ_HEAD(pcidev_stailq, pci_device);
272 extern struct pcidev_stailq pci_devices;
273
274 /* Sync rules for PCI: once a device is added to the list, it is never removed,
275  * and its read-only fields can be accessed at any time.  There is no need for
276  * refcnts or things like that.
277  *
278  * The device list is built early on when we're single threaded, so I'm not
279  * bothering with locks for that yet.  Append-only, singly-linked-list reads
280  * don't need a lock either.
281  *
282  * Other per-device accesses (like read-modify-writes to config space or MSI
283  * fields) require the device's lock.  If we ever want to unplug, we'll probably
284  * work out an RCU-like scheme for the pci_devices list.
285  *
286  * Note this is in addition to the config space global locking done by every
287  * pci_read or write call. */
288
289 void pci_init(void);
290 void pcidev_print_info(struct pci_device *pcidev, int verbosity);
291 uint32_t pci_config_addr(uint8_t bus, uint8_t dev, uint8_t func, uint32_t reg);
292
293 uint32_t pcidev_read32(struct pci_device *pcidev, uint32_t offset);
294 void pcidev_write32(struct pci_device *pcidev, uint32_t offset, uint32_t value);
295 uint16_t pcidev_read16(struct pci_device *pcidev, uint32_t offset);
296 void pcidev_write16(struct pci_device *pcidev, uint32_t offset, uint16_t value);
297 uint8_t pcidev_read8(struct pci_device *pcidev, uint32_t offset);
298 void pcidev_write8(struct pci_device *pcidev, uint32_t offset, uint8_t value);
299
300 /* Other common PCI functions */
301 void pci_set_bus_master(struct pci_device *pcidev);
302 void pci_clr_bus_master(struct pci_device *pcidev);
303 struct pci_device *pci_match_tbdf(int tbdf);
304 struct pci_device *pci_match_string(const char *bdf);
305 uintptr_t pci_get_membar(struct pci_device *pcidev, int bir);
306 uintptr_t pci_get_iobar(struct pci_device *pcidev, int bir);
307 bool pci_bar_is_mem32(struct pci_device *pdev, int bar);
308 uint32_t pci_get_membar_sz(struct pci_device *pcidev, int bir);
309 uint16_t pci_get_vendor(struct pci_device *pcidev);
310 uint16_t pci_get_device(struct pci_device *pcidev);
311 uint16_t pci_get_subvendor(struct pci_device *pcidev);
312 uint16_t pci_get_subdevice(struct pci_device *pcidev);
313 void pci_dump_config(struct pci_device *pcidev, size_t len);
314 int pci_find_cap(struct pci_device *pcidev, uint8_t cap_id, uint32_t *cap_reg);
315 unsigned int pci_to_tbdf(struct pci_device *pcidev);
316 uintptr_t pci_map_membar(struct pci_device *dev, int bir);
317 int pci_set_cacheline_size(struct pci_device *dev);
318 int pci_set_mwi(struct pci_device *dev);
319 void pci_clear_mwi(struct pci_device *dev);
320 void pci_set_ops(struct pci_device *pdev, struct pci_ops *ops);
321 void pci_device_assign(struct pci_device *pdev, struct proc *proc);
322 void pci_device_unassign_known(struct pci_device *pdev, struct proc *proc);
323 void pci_device_unassign(struct pci_device *pdev, struct proc *proc);
324
325 static inline void pci_set_drvdata(struct pci_device *pcidev, void *data);
326 static inline void *pci_get_drvdata(struct pci_device *pcidev);
327 static inline void *pci_get_mmio_bar_kva(struct pci_device *pdev, int bar);
328
329 /* MSI functions, msi.c */
330 int pci_msi_enable(struct pci_device *p, uint64_t vec);
331 int pci_msix_init(struct pci_device *p);
332 struct msix_irq_vector *pci_msix_enable(struct pci_device *p, uint64_t vec);
333 void pci_msi_mask(struct pci_device *p);
334 void pci_msi_unmask(struct pci_device *p);
335 void pci_msi_route(struct pci_device *p, int dest);
336 void pci_msi_reset_vector(struct pci_device *p);
337 void pci_msix_mask_vector(struct msix_irq_vector *linkage);
338 void pci_msix_unmask_vector(struct msix_irq_vector *linkage);
339 void pci_msix_route_vector(struct msix_irq_vector *linkage, int dest);
340 void pci_msix_reset_vector(struct msix_irq_vector *linkage);
341
342 /* TODO: this is quite the Hacke */
343 #define explode_tbdf(tbdf) {pcidev.bus = tbdf >> 16;\
344                 pcidev.dev = (tbdf>>11)&0x1f;\
345                 pcidev.func = (tbdf>>8)&3;}
346
347 static inline void pci_set_drvdata(struct pci_device *pcidev, void *data)
348 {
349         pcidev->dev_data = data;
350 }
351
352 static inline void *pci_get_drvdata(struct pci_device *pcidev)
353 {
354         return pcidev->dev_data;
355 }
356
357 static inline void *pci_get_mmio_bar_kva(struct pci_device *pdev, int bir)
358 {
359         return pdev->bar[bir].mmio_kva;
360 }