cbdma: add support for Intel CBDMA/IOAT
[akaros.git] / kern / drivers / dev / cbdma.c
1 /* Copyright (c) 2019 Google Inc
2  * Aditya Basu <mitthu@google.com>
3  * See LICENSE for details.
4  *
5  * Useful resources:
6  *   - Intel Xeon E7 2800/4800/8800 Datasheet Vol. 2
7  *   - Purley Programmer's Guide
8  *
9  * Acronyms:
10  *   - IOAT: (Intel) I/O Acceleration Technology
11  *   - CDMA: Crystal Beach DMA
12  *
13  * CBDMA Notes
14  * ===========
15  * Every CBDMA PCI function has one MMIO address space (so only BAR0). Each
16  * function can have multiple channels. Currently these devices only have one
17  * channel per function. This can be read from the CHANCNT register (8-bit)
18  * at offset 0x0.
19  *
20  * Each channel be independently configured for DMA. The MMIO config space of
21  * every channel is 0x80 bytes. The first channel (or CHANNEL_0) starts at 0x80
22  * offset.
23  *
24  * CHAINADDR points to a descriptor (desc) ring buffer. More precisely it points
25  * to the first desc in the ring buffer. Each desc represents a single DMA
26  * operation. Look at "struct desc" for it's structure.
27  *
28  * Each desc is 0x40 bytes (or 64 bytes) in size. A 4k page will be able to hold
29  * 4k/64 = 64 entries. Note that the lower 6 bits of CHANADDR should be zero. So
30  * the first desc's address needs to be aligned accordingly. Page-aligning the
31  * first desc address will work because 4k page-aligned addresses will have
32  * the last 12 bits as zero.
33  *
34  * TODO
35  * ====
36  * *MAJOR*
37  *   - Update to the correct struct desc (from Linux kernel)
38  *   - Make the status field embedded in the channel struct (no ptr business)
39  *   - Add file for errors
40  *   - Add locks to guard desc access
41  *   - Freeze VA->PA page mappings till DMA is completed (esp. for ucbdma)
42  * *MINOR*
43  *   - Replace all CBDMA_* constants with IOAT_*
44  *   - Initializes only the first found CBDMA device
45  */
46
47 #include <kmalloc.h>
48 #include <string.h>
49 #include <stdio.h>
50 #include <assert.h>
51 #include <error.h>
52 #include <net/ip.h>
53 #include <linux_compat.h>
54 #include <arch/pci.h>
55 #include <page_alloc.h>
56 #include <pmap.h>
57 #include <cbdma_regs.h>
58 #include <arch/pci_regs.h>
59
60 #define NDESC 1 // initialize these many descs
61 #define BUFFERSZ 8192
62
63 struct dev                cbdmadevtab;
64 static struct pci_device  *pci;
65 static void               *mmio;
66 static uint64_t           mmio_phy; /* physical addr */
67 static uint32_t           mmio_sz;
68 static uint8_t            chancnt; /* Total number of channels per function */
69 static bool               iommu_enabled;
70 static bool               cbdma_break_loop; /* toggle_foo functionality */
71
72 /* PCIe Config Space; from Intel Xeon E7 2800/4800/8800 Datasheet Vol. 2 */
73 enum {
74         DEVSTS = 0x9a, // 16-bit
75         PMCSR  = 0xe4, // 32-bit
76
77         DMAUNCERRSTS = 0x148, // 32-bit (DMA Cluster Uncorrectable Error Status)
78         DMAUNCERRMSK = 0x14c, // 32-bit
79         DMAUNCERRSEV = 0x150, // 32-bit
80         DMAUNCERRPTR = 0x154, // 8-bit
81         DMAGLBERRPTR = 0x160, // 8-bit
82
83         CHANERR_INT    = 0x180, // 32-bit
84         CHANERRMSK_INT = 0x184, // 32-bit
85         CHANERRSEV_INT = 0x188, // 32-bit
86         CHANERRPTR     = 0x18c, // 8-bit
87 };
88
89 /* QID Path */
90 enum {
91         Qdir           = 0,
92         Qcbdmaktest    = 1,
93         Qcbdmastats    = 2,
94         Qcbdmareset    = 3,
95         Qcbdmaucopy    = 4,
96         Qcbdmaiommu    = 5,
97 };
98
99 /* supported ioat devices */
100 enum {
101         ioat2021 = (0x2021 << 16) | 0x8086,
102         ioat2f20 = (0x2f20 << 16) | 0x8086,
103 };
104
105 static struct dirtab cbdmadir[] = {
106         {".",         {Qdir, 0, QTDIR}, 0, 0555},
107         {"ktest",     {Qcbdmaktest, 0, QTFILE}, 0, 0555},
108         {"stats",     {Qcbdmastats, 0, QTFILE}, 0, 0555},
109         {"reset",     {Qcbdmareset, 0, QTFILE}, 0, 0755},
110         {"ucopy",     {Qcbdmaucopy, 0, QTFILE}, 0, 0755},
111         {"iommu",     {Qcbdmaiommu, 0, QTFILE}, 0, 0755},
112 };
113
114 /* Descriptor structue as defined in the programmer's guide.
115  * It describes a single DMA transfer
116  */
117 struct desc {
118         uint32_t  xfer_size;
119         uint32_t  descriptor_control;
120         uint64_t  src_addr;
121         uint64_t  dest_addr;
122         uint64_t  next_desc_addr;
123         uint64_t  next_source_address;
124         uint64_t  next_destination_address;
125         uint64_t  reserved0;
126         uint64_t  reserved1;
127 } __attribute__((packed));
128
129 /* The channels are indexed starting from 0 */
130 static struct channel {
131         uint8_t                number; // channel number
132         struct desc            *pdesc; // desc ptr
133         int                    ndesc;  // num. of desc
134         uint64_t               *status; // reg: CHANSTS, needs to be 64B aligned
135         uint8_t                ver;    // reg: CBVER
136
137 /* DEPRECATED */
138 /* MMIO address space; from Intel Xeon E7 2800/4800/8800 Datasheet Vol. 2
139  * Every channel 0x80 bytes in size.
140  */
141         uint8_t  chancmd;
142         uint8_t  xrefcap;
143         uint16_t chanctrl;
144         uint16_t dmacount;
145         uint32_t chanerr;
146         uint64_t chansts;
147         uint64_t chainaddr;
148 } cbdmadev, channel0;
149
150 #define KTEST_SIZE 64
151 static struct {
152         char    printbuf[4096];
153         char    src[KTEST_SIZE];
154         char    dst[KTEST_SIZE];
155         char    srcfill;
156         char    dstfill;
157 } ktest;    /* TODO: needs locking */
158
159 /* struct passed from the userspace */
160 struct ucbdma {
161         struct desc desc;
162         uint64_t    status;
163         uint16_t    ndesc;
164 };
165
166 /* for debugging via kfunc; break out of infinite polling loops */
167 void toggle_cbdma_break_loop(void)
168 {
169         cbdma_break_loop = !cbdma_break_loop;
170         printk("cbdma: cbdma_break_loop = %d\n", cbdma_break_loop);
171 }
172
173 /* Function definitions start here */
174 static inline bool is_initialized(void)
175 {
176         if (!pci || !mmio)
177                 return false;
178         else
179                 return true;
180 }
181
182 static void *get_register(struct channel *c, int offset)
183 {
184         uint64_t base = (c->number + 1) * IOAT_CHANNEL_MMIO_SIZE;
185
186         return (char *) mmio + base + offset;
187 }
188
189 static char *devname(void)
190 {
191         return cbdmadevtab.name;
192 }
193
194 static struct chan *cbdmaattach(char *spec)
195 {
196         if (!is_initialized())
197                 error(ENODEV, "no cbdma device detected");
198         return devattach(devname(), spec);
199 }
200
201 struct walkqid *cbdmawalk(struct chan *c, struct chan *nc, char **name,
202                          unsigned int nname)
203 {
204         return devwalk(c, nc, name, nname, cbdmadir,
205                        ARRAY_SIZE(cbdmadir), devgen);
206 }
207
208 static size_t cbdmastat(struct chan *c, uint8_t *dp, size_t n)
209 {
210         return devstat(c, dp, n, cbdmadir, ARRAY_SIZE(cbdmadir), devgen);
211 }
212
213 /* return string representation of chansts */
214 char *cbdma_str_chansts(uint64_t chansts)
215 {
216         char *status = "unrecognized status";
217
218         switch (chansts & IOAT_CHANSTS_STATUS) {
219         case IOAT_CHANSTS_ACTIVE:
220                 status = "ACTIVE";
221                 break;
222         case IOAT_CHANSTS_DONE:
223                 status = "DONE";
224                 break;
225         case IOAT_CHANSTS_SUSPENDED:
226                 status = "SUSPENDED";
227                 break;
228         case IOAT_CHANSTS_HALTED:
229                 status = "HALTED";
230                 break;
231         case IOAT_CHANSTS_ARMED:
232                 status = "ARMED";
233                 break;
234         default:
235                 break;
236         }
237         return status;
238 }
239
240 /* print descriptors on console (for debugging) */
241 static void dump_desc(struct desc *d, int count)
242 {
243         printk("dumping descriptors (count = %d):\n", count);
244
245         while (count > 0) {
246                 printk("desc: 0x%x, size: %d bytes\n",
247                         d, sizeof(struct desc));
248                 printk("[32] desc->xfer_size: 0x%x\n",
249                         d->xfer_size);
250                 printk("[32] desc->descriptor_control: 0x%x\n",
251                         d->descriptor_control);
252                 printk("[64] desc->src_addr: %p\n",
253                         d->src_addr);
254                 printk("[64] desc->dest_addr: %p\n",
255                         d->dest_addr);
256                 printk("[64] desc->next_desc_addr: %p\n",
257                         d->next_desc_addr);
258                 printk("[64] desc->next_source_address: %p\n",
259                         d->next_source_address);
260                 printk("[64] desc->next_destination_address: %p\n",
261                         d->next_destination_address);
262                 printk("[64] desc->reserved0: %p\n",
263                         d->reserved0);
264                 printk("[64] desc->reserved1: %p\n",
265                         d->reserved1);
266
267                 count--;
268                 if (count > 0)
269                         d = (struct desc *) KADDR(d->next_desc_addr);
270                 printk("\n");
271         }
272 }
273
274 /* initialize desc ring
275  *
276  - Can be called multiple times, with different "ndesc" values.
277  - NOTE: We only create _one_ valid desc. The next field points back itself
278          (ring buffer).
279  */
280 static void init_desc(struct channel *c, int ndesc)
281 {
282         struct desc *d, *tmp;
283         int i;
284         const int max_ndesc = PGSIZE / sizeof(struct desc);
285
286         /* sanity checks */
287         if (ndesc > max_ndesc) {
288                 printk("cbdma: allocating only %d desc instead of %d desc\n",
289                         max_ndesc, ndesc);
290                 ndesc = max_ndesc;
291         }
292
293         c->ndesc = ndesc;
294
295         /* allocate pages for descriptors, last 6-bits must be zero */
296         if (!c->pdesc)
297                 c->pdesc = kpage_zalloc_addr();
298
299         if (!c->pdesc) { /* error does not return */
300                 printk("cbdma: cannot alloc page for desc\n");
301                 return; /* TODO: return "false" */
302         }
303
304         /* preparing descriptors */
305         d = c->pdesc;
306         d->xfer_size = 1;
307         d->descriptor_control = CBDMA_DESC_CTRL_NULL_DESC;
308         d->next_desc_addr = PADDR(d);
309 }
310
311 /* struct channel is only used for get_register */
312 static inline void cleanup_post_copy(struct channel *c)
313 {
314         uint64_t value;
315
316         /* mmio_reg: DMACOUNT */
317         value = read16(get_register(c, IOAT_CHAN_DMACOUNT_OFFSET));
318         if (value != 0) {
319                 printk("cbdma: info: DMACOUNT = %d\n", value); /* should be 0 */
320                 write16(0, mmio + CBDMA_DMACOUNT_OFFSET);
321         }
322
323         /* mmio_reg: CHANERR */
324         value = read32(get_register(c, IOAT_CHANERR_OFFSET));
325         if (value != 0) {
326                 printk("cbdma: error: CHANERR = 0x%x\n", value);
327                 write32(value, get_register(c, IOAT_CHANERR_OFFSET));
328         }
329
330         /* ack errors */
331         if (ACCESS_PCIE_CONFIG_SPACE) {
332                 /* PCIe_reg: CHANERR_INT */
333                 value = pcidev_read32(pci, CHANERR_INT);
334                 if (value != 0) {
335                         printk("cbdma: error: CHANERR_INT = 0x%x\n", value);
336                         pcidev_write32(pci, CHANERR_INT, value);
337                 }
338
339                 /* PCIe_reg: DMAUNCERRSTS */
340                 value = pcidev_read32(pci, IOAT_PCI_DMAUNCERRSTS_OFFSET);
341                 if (value != 0) {
342                         printk("cbdma: error: DMAUNCERRSTS = 0x%x\n", value);
343                         pcidev_write32(pci, IOAT_PCI_DMAUNCERRSTS_OFFSET,
344                                        value);
345                 }
346         }
347 }
348
349 /* struct channel is only used for get_register */
350 static inline void perform_dma(struct channel *c, physaddr_t completion_sts,
351                                physaddr_t desc, uint16_t count)
352 {
353         void __iomem *offset;
354
355         /* Set channel completion register where CBDMA will write content of
356          * CHANSTS register upon successful DMA completion or error condition
357          */
358         offset = get_register(c, IOAT_CHANCMP_OFFSET);
359         write64(completion_sts, offset);
360
361         /* write locate of first desc to register CHAINADDR */
362         offset = get_register(c, IOAT_CHAINADDR_OFFSET(c->ver));
363         write64(desc, offset);
364         wmb_f();
365
366         /* writing valid number of descs: starts the DMA */
367         offset = get_register(c, IOAT_CHAN_DMACOUNT_OFFSET);
368         write16(count, offset);
369 }
370
371 static inline void wait_for_dma_completion(uint64_t *cmpsts)
372 {
373         uint64_t sts;
374
375         do {
376                 cpu_relax();
377                 sts = *cmpsts;
378                 if (cbdma_break_loop) {
379                         printk("cbdma: cmpsts: %p = 0x%llx\n", cmpsts, sts);
380                         break;
381                 }
382         } while ((sts & IOAT_CHANSTS_STATUS) == IOAT_CHANSTS_ACTIVE);
383 }
384
385 /* cbdma_ktest: performs functional test on CBDMA
386  *
387  - Allocates 2 kernel pages: ktest_src and ktest_dst.
388  - memsets the ktest_src page
389  - Prepare descriptors for DMA transfer (need to be aligned)
390  - Initiate the transfer
391  - Prints results
392  */
393 static void cbdma_ktest(void)
394 {
395         static struct desc *d;
396         uint64_t value;
397         struct channel *c = &channel0;
398
399         /* initialize src and dst address */
400         memset(ktest.src, ktest.srcfill, KTEST_SIZE);
401         memset(ktest.dst, ktest.dstfill, KTEST_SIZE);
402         ktest.src[KTEST_SIZE-1] = '\0';
403         ktest.dst[KTEST_SIZE-1] = '\0';
404
405         /* for subsequent ktests */
406         ktest.srcfill += 1;
407
408         /* preparing descriptors */
409         d = channel0.pdesc;
410         d->xfer_size            = (uint32_t) KTEST_SIZE;
411         d->src_addr             = (uint64_t) PADDR(ktest.src);
412         d->dest_addr            = (uint64_t) PADDR(ktest.dst);
413         d->descriptor_control   = CBDMA_DESC_CTRL_INTR_ON_COMPLETION |
414                                   CBDMA_DESC_CTRL_WRITE_CHANCMP_ON_COMPLETION;
415
416         memset((uint64_t *)c->status, 0, sizeof(c->status));
417
418         /* perform actual DMA */
419         perform_dma(c, PADDR(c->status), PADDR(c->pdesc), 1);
420         wait_for_dma_completion(c->status);
421         cleanup_post_copy(c);
422 }
423
424 /* convert a userspace pointer to kaddr based pointer
425  * TODO: this is dangerous and the pages are not pinned. Debugging only! */
426 static inline void *uptr_to_kptr(void *ptr)
427 {
428         return (void *) uva2kva(current, ptr, 1, PROT_WRITE);
429 }
430
431 /* function that uses kernel addresses to perform DMA.
432  * Note: does not perform error checks for src / dest addr.
433  * TODO: this only works if ktest is not run. Still it fails on alternate runs.
434  *       Likely some error in setting up the desc from userspace.
435  */
436 static void issue_dma_kaddr(struct ucbdma *u)
437 {
438         struct ucbdma *u_kaddr = uptr_to_kptr(u);
439         /* first field is struct desc */
440         struct desc *d = (struct desc *) u_kaddr;
441         struct channel *c = &channel0;
442         uint64_t value;
443
444         if (!u_kaddr) {
445                 printk("[kern] cannot get kaddr for useraddr: %p\n", u);
446                 return;
447         }
448         printk("[kern] ucbdma: user: %p kern: %p\n", u, u_kaddr);
449
450         /* preparing descriptors */
451         d->src_addr   = (uint64_t) PADDR(uptr_to_kptr((void*) d->src_addr));
452         d->dest_addr  = (uint64_t) PADDR(uptr_to_kptr((void*) d->dest_addr));
453         d->next_desc_addr = (uint64_t)
454                             PADDR(uptr_to_kptr((void*) d->next_desc_addr));
455
456         /* perform actual DMA */
457         perform_dma(c, PADDR(&u_kaddr->status), PADDR(d), u_kaddr->ndesc);
458         wait_for_dma_completion(&u_kaddr->status);
459         cleanup_post_copy(c);
460 }
461
462 /* function that uses virtual (process) addresses to perform DMA; IOMMU = ON
463  * TODO: Verify once the IOMMU is setup and enabled.
464  */
465 static void issue_dma_vaddr(struct ucbdma *u)
466 {
467         struct ucbdma *u_kaddr = uptr_to_kptr(u);
468         struct channel *c = &channel0;
469         uint64_t value;
470
471         printk("[kern] IOMMU = ON\n");
472         printk("[kern] ucbdma: user: %p kern: %p ndesc: %d\n", u,
473                 &u_kaddr->desc, u_kaddr->ndesc);
474
475         /* perform actual DMA */
476         perform_dma(c, (physaddr_t) &u->status, (physaddr_t) &u->desc,
477                     u_kaddr->ndesc);
478         wait_for_dma_completion(&u_kaddr->status);
479         cleanup_post_copy(&channel0);
480 }
481
482 /* cbdma_stats: get stats about the device and driver
483  */
484 static struct sized_alloc *open_stats(void)
485 {
486         struct sized_alloc *sza = sized_kzmalloc(BUFFERSZ, MEM_WAIT);
487         uint64_t value;
488
489         sza_printf(sza,
490                 "Intel CBDMA [%x:%x] registered at %02x:%02x.%x\n",
491                 pci->ven_id, pci->dev_id, pci->bus, pci->dev, pci->func);
492
493         /* driver info. */
494         sza_printf(sza, "    Driver Information:\n");
495         sza_printf(sza,
496                 "\tmmio: %p\n"
497                 "\tmmio_phy: 0x%x\n"
498                 "\tmmio_sz: %lu\n"
499                 "\ttotal_channels: %d\n"
500                 "\tdesc_kaddr: %p\n"
501                 "\tdesc_paddr: %p\n"
502                 "\tdesc_num: %d\n"
503                 "\tver: 0x%x\n"
504                 "\tstatus_kaddr: %p\n"
505                 "\tstatus_paddr: %p\n"
506                 "\tstatus_value: 0x%x\n",
507                 mmio, mmio_phy, mmio_sz, chancnt,
508                 channel0.pdesc, PADDR(channel0.pdesc), channel0.ndesc,
509                 channel0.ver, channel0.status, PADDR(channel0.status),
510                 *(uint64_t *)channel0.status);
511
512         /* print the PCI registers */
513         sza_printf(sza, "    PCIe Config Registers:\n");
514
515         value = pcidev_read16(pci, PCI_CMD_REG);
516         sza_printf(sza, "\tPCICMD: 0x%x\n", value);
517
518         value = pcidev_read16(pci, PCI_STATUS_REG);
519         sza_printf(sza, "\tPCISTS: 0x%x\n", value);
520
521         value = pcidev_read16(pci, PCI_REVID_REG);
522         sza_printf(sza, "\tRID: 0x%x\n", value);
523
524         value = pcidev_read32(pci, PCI_BAR0_STD);
525         sza_printf(sza, "\tCB_BAR: 0x%x\n", value);
526
527         value = pcidev_read16(pci, DEVSTS);
528         sza_printf(sza, "\tDEVSTS: 0x%x\n", value);
529
530         value = pcidev_read32(pci, PMCSR);
531         sza_printf(sza, "\tPMCSR: 0x%x\n", value);
532
533         value = pcidev_read32(pci, DMAUNCERRSTS);
534         sza_printf(sza, "\tDMAUNCERRSTS: 0x%x\n", value);
535
536         value = pcidev_read32(pci, DMAUNCERRMSK);
537         sza_printf(sza, "\tDMAUNCERRMSK: 0x%x\n", value);
538
539         value = pcidev_read32(pci, DMAUNCERRSEV);
540         sza_printf(sza, "\tDMAUNCERRSEV: 0x%x\n", value);
541
542         value = pcidev_read8(pci, DMAUNCERRPTR);
543         sza_printf(sza, "\tDMAUNCERRPTR: 0x%x\n", value);
544
545         value = pcidev_read8(pci, DMAGLBERRPTR);
546         sza_printf(sza, "\tDMAGLBERRPTR: 0x%x\n", value);
547
548         value = pcidev_read32(pci, CHANERR_INT);
549         sza_printf(sza, "\tCHANERR_INT: 0x%x\n", value);
550
551         value = pcidev_read32(pci, CHANERRMSK_INT);
552         sza_printf(sza, "\tCHANERRMSK_INT: 0x%x\n", value);
553
554         value = pcidev_read32(pci, CHANERRSEV_INT);
555         sza_printf(sza, "\tCHANERRSEV_INT: 0x%x\n", value);
556
557         value = pcidev_read8(pci, CHANERRPTR);
558         sza_printf(sza, "\tCHANERRPTR: 0x%x\n", value);
559
560         sza_printf(sza, "    CHANNEL_0 MMIO Registers:\n");
561
562         value = read8(mmio + CBDMA_CHANCMD_OFFSET);
563         sza_printf(sza, "\tCHANCMD: 0x%x\n", value);
564
565         value = read8(mmio + IOAT_VER_OFFSET);
566         sza_printf(sza, "\tCBVER: 0x%x major=%d minor=%d\n",
567                    value,
568                    GET_IOAT_VER_MAJOR(value),
569                    GET_IOAT_VER_MINOR(value));
570
571         value = read16(mmio + CBDMA_CHANCTRL_OFFSET);
572         sza_printf(sza, "\tCHANCTRL: 0x%llx\n", value);
573
574         value = read64(mmio + CBDMA_CHANSTS_OFFSET);
575         sza_printf(sza, "\tCHANSTS: 0x%x [%s], desc_addr: %p, raw: 0x%llx\n",
576                    (value & IOAT_CHANSTS_STATUS),
577                    cbdma_str_chansts(value),
578                    (value & IOAT_CHANSTS_COMPLETED_DESCRIPTOR_ADDR),
579                    value);
580
581         value = read64(mmio + CBDMA_CHAINADDR_OFFSET);
582         sza_printf(sza, "\tCHAINADDR: %p\n", value);
583
584         value = read64(mmio + CBDMA_CHANCMP_OFFSET);
585         sza_printf(sza, "\tCHANCMP: %p\n", value);
586
587         value = read16(mmio + CBDMA_DMACOUNT_OFFSET);
588         sza_printf(sza, "\tDMACOUNT: %d\n", value);
589
590         value = read32(mmio + CBDMA_CHANERR_OFFSET);
591         sza_printf(sza, "\tCHANERR: 0x%x\n", value);
592
593         return sza;
594 }
595
596 static struct sized_alloc *open_reset(void)
597 {
598         struct sized_alloc *sza = sized_kzmalloc(BUFFERSZ, MEM_WAIT);
599
600         if (cbdma_is_reset_pending())
601                 sza_printf(sza, "Status: Reset is pending\n");
602         else
603                 sza_printf(sza, "Status: No pending reset\n");
604
605         sza_printf(sza, "Write '1' to perform reset!\n");
606
607         return sza;
608 }
609
610 static struct sized_alloc *open_iommu(void)
611 {
612         struct sized_alloc *sza = sized_kzmalloc(BUFFERSZ, MEM_WAIT);
613
614         sza_printf(sza, "IOMMU enabled = %s\n", iommu_enabled ? "yes":"no");
615         sza_printf(sza, "Write '0' to disable or '1' to enable the IOMMU\n");
616
617         return sza;
618 }
619
620 /* targets channel0 */
621 static struct sized_alloc *open_ktest(void)
622 {
623         struct sized_alloc *sza = sized_kzmalloc(BUFFERSZ, MEM_WAIT);
624
625         /* run the test */
626         cbdma_ktest();
627
628         sza_printf(sza,
629            "Self-test Intel CBDMA [%x:%x] registered at %02x:%02x.%x\n",
630            pci->ven_id, pci->dev_id, pci->bus, pci->dev, pci->func);
631
632         sza_printf(sza, "\tChannel Status: %s (raw: 0x%x)\n",
633                 cbdma_str_chansts(*((uint64_t *)channel0.status)),
634                 (*((uint64_t *)channel0.status) & IOAT_CHANSTS_STATUS));
635
636         sza_printf(sza, "\tCopy Size: %d (0x%x)\n", KTEST_SIZE, KTEST_SIZE);
637         sza_printf(sza, "\tsrcfill: %c (0x%x)\n", ktest.srcfill, ktest.srcfill);
638         sza_printf(sza, "\tdstfill: %c (0x%x)\n", ktest.dstfill, ktest.dstfill);
639         sza_printf(sza, "\tsrc_str (after copy): %s\n", ktest.src);
640         sza_printf(sza, "\tdst_str (after copy): %s\n", ktest.dst);
641
642         return sza;
643 }
644
645 /* cbdma_reset_device: this fixes any programming errors done before
646  */
647 void cbdma_reset_device(void)
648 {
649         int cbdmaver;
650         uint32_t error;
651
652         /* make sure the driver is initialized */
653         if (!mmio)
654                 error(EIO, "cbdma: mmio addr not set");
655
656         pcidev_write16(pci, PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MEMORY
657                                                         | PCI_COMMAND_MASTER);
658         /* fetch version */
659         cbdmaver = read8(mmio + IOAT_VER_OFFSET);
660
661         /* ack channel errros */
662         error = read32(mmio + CBDMA_CHANERR_OFFSET);
663         write32(error, mmio + CBDMA_CHANERR_OFFSET);
664
665         if (ACCESS_PCIE_CONFIG_SPACE) {
666                 /* ack pci device level errros */
667                 /* clear DMA Cluster Uncorrectable Error Status */
668                 error = pcidev_read32(pci, IOAT_PCI_DMAUNCERRSTS_OFFSET);
669                 pcidev_write32(pci, IOAT_PCI_DMAUNCERRSTS_OFFSET, error);
670
671                 /* clear DMA Channel Error Status */
672                 error = pcidev_read32(pci, IOAT_PCI_CHANERR_INT_OFFSET);
673                 pcidev_write32(pci, IOAT_PCI_CHANERR_INT_OFFSET, error);
674         }
675
676         /* reset */
677         write8(IOAT_CHANCMD_RESET, mmio
678                                    + IOAT_CHANNEL_MMIO_SIZE
679                                    + IOAT_CHANCMD_OFFSET(cbdmaver));
680
681         pcidev_write16(pci, PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MEMORY
682                         | PCI_COMMAND_MASTER | PCI_COMMAND_INTX_DISABLE);
683
684         printk("cbdma: reset performed\n");
685 }
686
687 /* cbdma_is_reset_pending: returns true if reset is pending
688  */
689 bool cbdma_is_reset_pending(void)
690 {
691         int cbdmaver;
692         int status;
693
694         /* make sure the driver is initialized */
695         if (!mmio) {
696                 error(EPERM, "cbdma: mmio addr not set");
697                 return false; /* does not reach */
698         }
699
700         /* fetch version */
701         cbdmaver = read8(mmio + IOAT_VER_OFFSET);
702
703         status = read8(mmio + IOAT_CHANNEL_MMIO_SIZE
704                         + IOAT_CHANCMD_OFFSET(cbdmaver));
705
706         return (status & IOAT_CHANCMD_RESET) == IOAT_CHANCMD_RESET;
707 }
708
709 ///////// SYS INTERFACE ////////////////////////////////////////////////////////
710
711 static struct chan *cbdmaopen(struct chan *c, int omode)
712 {
713         switch (c->qid.path) {
714         case Qcbdmastats:
715                 c->synth_buf = open_stats();
716                 break;
717         case Qcbdmareset:
718                 c->synth_buf = open_reset();
719                 break;
720         case Qcbdmaiommu:
721                 c->synth_buf = open_iommu();
722                 break;
723         case Qcbdmaktest:
724                 c->synth_buf = open_ktest();
725                 break;
726         case Qdir:
727         case Qcbdmaucopy:
728                 break;
729         default:
730                 error(EIO, "cbdma: qid 0x%x is impossible", c->qid.path);
731         }
732
733         return devopen(c, omode, cbdmadir, ARRAY_SIZE(cbdmadir), devgen);
734 }
735
736 static void cbdmaclose(struct chan *c)
737 {
738         switch (c->qid.path) {
739         case Qcbdmastats:
740         case Qcbdmareset:
741         case Qcbdmaiommu:
742         case Qcbdmaktest:
743                 kfree(c->synth_buf);
744                 c->synth_buf = NULL;
745                 break;
746         case Qdir:
747         case Qcbdmaucopy:
748                 break;
749         default:
750                 error(EIO, "cbdma: qid 0x%x is impossible", c->qid.path);
751         }
752 }
753
754 static size_t cbdmaread(struct chan *c, void *va, size_t n, off64_t offset)
755 {
756         struct sized_alloc *sza = c->synth_buf;
757
758         switch (c->qid.path) {
759         case Qcbdmaktest:
760         case Qcbdmastats:
761         case Qcbdmareset:
762         case Qcbdmaiommu:
763                 return readstr(offset, va, n, sza->buf);
764         case Qcbdmaucopy:
765                 return readstr(offset, va, n,
766                         "Write address of struct ucopy to issue DMA\n");
767         case Qdir:
768                 return devdirread(c, va, n, cbdmadir, ARRAY_SIZE(cbdmadir),
769                                         devgen);
770         default:
771                 error(EIO, "cbdma: qid 0x%x is impossible", c->qid.path);
772         }
773
774         return -1;      /* not reached */
775 }
776
777 static void init_channel(struct channel *c, int cnum, int ndesc)
778 {
779         c->number = cnum;
780         c->pdesc = NULL;
781         init_desc(c, ndesc);
782
783         /* this is a writeback field; the hardware will update this value */
784         if (c->status == 0)
785                 c->status = kmalloc_align(sizeof(uint64_t), MEM_WAIT, 8);
786         assert(c->status != 0);
787
788         /* cbdma version */
789         c->ver = read8(mmio + IOAT_VER_OFFSET);
790
791         /* Set "Any Error Abort Enable": enables abort for any error encountered
792          * Set "Error Completion Enable": enables completion write to address in
793                                           CHANCMP for any error
794          * Reset "Interrupt Disable": W1C, when clear enables interrupt to fire
795                                     for next descriptor that specifies interrupt
796         */
797         write8(IOAT_CHANCTRL_ANY_ERR_ABORT_EN | IOAT_CHANCTRL_ERR_COMPLETION_EN,
798                get_register(c, IOAT_CHANCTRL_OFFSET));
799 }
800
801 static size_t cbdmawrite(struct chan *c, void *va, size_t n, off64_t offset)
802 {
803         switch (c->qid.path) {
804         case Qdir:
805                 error(EPERM, "writing not permitted");
806         case Qcbdmaktest:
807         case Qcbdmastats:
808                 error(EPERM, ERROR_FIXME);
809         case Qcbdmareset:
810                 if (offset == 0 && n > 0 && *(char *)va == '1') {
811                         cbdma_reset_device();
812                         init_channel(&channel0, 0, NDESC);
813                 } else {
814                         error(EINVAL, "cannot be empty string");
815                 }
816                 return n;
817         case Qcbdmaucopy:
818                 if (offset == 0 && n > 0) {
819                         printk("[kern] value from userspace: %p\n", va);
820                         if (iommu_enabled)
821                                 issue_dma_vaddr(va);
822                         else
823                                 issue_dma_kaddr(va);
824                         return sizeof(8);
825                 }
826                 return 0;
827         case Qcbdmaiommu:
828                 if (offset == 0 && n > 0 && *(char *)va == '1')
829                         iommu_enabled = true;
830                 else if (offset == 0 && n > 0 && *(char *)va == '0')
831                         iommu_enabled = false;
832                 else
833                         error(EINVAL, "cannot be empty string");
834                 return n;
835         default:
836                 error(EIO, "cbdma: qid 0x%x is impossible", c->qid.path);
837         }
838
839         return -1;      /* not reached */
840 }
841
842 static void cbdma_interrupt(struct hw_trapframe *hw_tf, void *arg)
843 {
844         uint16_t value;
845
846         value = read16(get_register(&channel0, IOAT_CHANCTRL_OFFSET));
847         write16(value | IOAT_CHANCTRL_INT_REARM,
848                 get_register(&channel0, IOAT_CHANCTRL_OFFSET));
849 }
850
851 void cbdmainit(void)
852 {
853         int tbdf;
854         int i;
855         int id;
856         struct pci_device *pci_iter;
857
858         /* assigning global variables */
859         pci             = NULL;
860         mmio            = NULL;
861         mmio_sz         = -1;
862
863         /* initialize cbdmadev */
864         memset(&cbdmadev, 0x0, sizeof(cbdmadev));
865
866         /* search for the device 00:04.0 */
867         STAILQ_FOREACH(pci_iter, &pci_devices, all_dev) {
868                 id = pci_iter->dev_id << 16 | pci_iter->ven_id;
869                 switch (id) {
870                 default:
871                         continue;
872                 case ioat2021:
873                 case ioat2f20:
874                         /* hack: bus 0 is the PCI_ALL iommu.
875                          * Can remove this once we add code for scoped IOMMU */
876                         if (pci_iter->bus != 0)
877                                 continue;
878                         pci = pci_iter;
879                         break;
880                 }
881         }
882
883         if (pci == NULL) {
884                 printk("cbdma: no Intel CBDMA device found\n");
885                 return;
886         }
887
888         /* search and find the mapped mmio region */
889         for (i = 0; i < COUNT_OF(pci->bar); i++) {
890                 if (pci->bar[i].mmio_sz == 0)
891                         continue;
892                 mmio_phy = (pci->bar[0].mmio_base32
893                          ? pci->bar[0].mmio_base32
894                          : pci->bar[0].mmio_base64);
895                 mmio_sz  = pci->bar[i].mmio_sz;
896                 mmio     = (void *) vmap_pmem_nocache(mmio_phy, mmio_sz);
897                 break;
898         }
899
900         /* handle any errors */
901         if (mmio_sz == -1) {
902                 printk("cbdma: invalid mmio_sz\n");
903                 return;
904         }
905
906         if (mmio == NULL) {
907                 printk("cbdma: cannot map %p\n", mmio_phy);
908                 return;
909         }
910
911         /* performance related stuff */
912         pci_set_cacheline_size(pci);
913
914         /* Get the channel count. Top 3 bits of the register are reserved. */
915         chancnt = read8(mmio + IOAT_CHANCNT_OFFSET) & 0x1F;
916
917         /* initialization successful; print stats */
918         printk("cbdma: registered [%x:%x] at %02x:%02x.%x // "
919                "mmio:%p mmio_sz:%lu\n",
920                pci->ven_id, pci->dev_id, pci->bus, pci->dev, pci->func,
921                mmio, mmio_sz);
922
923         tbdf = MKBUS(BusPCI, pci->bus, pci->dev, pci->func);
924         register_irq(pci->irqline, cbdma_interrupt, NULL, tbdf);
925
926         /* reset device */
927         cbdma_reset_device();
928
929         /* initialize channel(s) */
930         init_channel(&channel0, 0, NDESC);
931
932         /* setup ktest struct */
933         ktest.srcfill = '1';
934         ktest.dstfill = '0';
935 }
936
937 struct dev cbdmadevtab __devtab = {
938         .name       = "cbdma",
939         .reset      = devreset,
940         .init       = cbdmainit,
941         .shutdown   = devshutdown,
942         .attach     = cbdmaattach,
943         .walk       = cbdmawalk,
944         .stat       = cbdmastat,
945         .open       = cbdmaopen,
946         .create     = devcreate,
947         .close      = cbdmaclose,
948         .read       = cbdmaread,
949         .bread      = devbread,
950         .write      = cbdmawrite,
951         .bwrite     = devbwrite,
952         .remove     = devremove,
953         .wstat      = devwstat,
954 };