]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/pci/xen-pcifront.c
Merge branch 'stable/late-swiotlb.v3.3' into stable/for-linus-3.7
[~shefty/rdma-dev.git] / drivers / pci / xen-pcifront.c
1 /*
2  * Xen PCI Frontend.
3  *
4  *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
5  */
6 #include <linux/module.h>
7 #include <linux/init.h>
8 #include <linux/mm.h>
9 #include <xen/xenbus.h>
10 #include <xen/events.h>
11 #include <xen/grant_table.h>
12 #include <xen/page.h>
13 #include <linux/spinlock.h>
14 #include <linux/pci.h>
15 #include <linux/msi.h>
16 #include <xen/interface/io/pciif.h>
17 #include <asm/xen/pci.h>
18 #include <linux/interrupt.h>
19 #include <linux/atomic.h>
20 #include <linux/workqueue.h>
21 #include <linux/bitops.h>
22 #include <linux/time.h>
23
24 #include <asm/xen/swiotlb-xen.h>
25 #define INVALID_GRANT_REF (0)
26 #define INVALID_EVTCHN    (-1)
27
28 struct pci_bus_entry {
29         struct list_head list;
30         struct pci_bus *bus;
31 };
32
33 #define _PDEVB_op_active                (0)
34 #define PDEVB_op_active                 (1 << (_PDEVB_op_active))
35
36 struct pcifront_device {
37         struct xenbus_device *xdev;
38         struct list_head root_buses;
39
40         int evtchn;
41         int gnt_ref;
42
43         int irq;
44
45         /* Lock this when doing any operations in sh_info */
46         spinlock_t sh_info_lock;
47         struct xen_pci_sharedinfo *sh_info;
48         struct work_struct op_work;
49         unsigned long flags;
50
51 };
52
53 struct pcifront_sd {
54         int domain;
55         struct pcifront_device *pdev;
56 };
57
58 static inline struct pcifront_device *
59 pcifront_get_pdev(struct pcifront_sd *sd)
60 {
61         return sd->pdev;
62 }
63
64 static inline void pcifront_init_sd(struct pcifront_sd *sd,
65                                     unsigned int domain, unsigned int bus,
66                                     struct pcifront_device *pdev)
67 {
68         sd->domain = domain;
69         sd->pdev = pdev;
70 }
71
72 static DEFINE_SPINLOCK(pcifront_dev_lock);
73 static struct pcifront_device *pcifront_dev;
74
75 static int verbose_request;
76 module_param(verbose_request, int, 0644);
77
78 static int errno_to_pcibios_err(int errno)
79 {
80         switch (errno) {
81         case XEN_PCI_ERR_success:
82                 return PCIBIOS_SUCCESSFUL;
83
84         case XEN_PCI_ERR_dev_not_found:
85                 return PCIBIOS_DEVICE_NOT_FOUND;
86
87         case XEN_PCI_ERR_invalid_offset:
88         case XEN_PCI_ERR_op_failed:
89                 return PCIBIOS_BAD_REGISTER_NUMBER;
90
91         case XEN_PCI_ERR_not_implemented:
92                 return PCIBIOS_FUNC_NOT_SUPPORTED;
93
94         case XEN_PCI_ERR_access_denied:
95                 return PCIBIOS_SET_FAILED;
96         }
97         return errno;
98 }
99
100 static inline void schedule_pcifront_aer_op(struct pcifront_device *pdev)
101 {
102         if (test_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags)
103                 && !test_and_set_bit(_PDEVB_op_active, &pdev->flags)) {
104                 dev_dbg(&pdev->xdev->dev, "schedule aer frontend job\n");
105                 schedule_work(&pdev->op_work);
106         }
107 }
108
109 static int do_pci_op(struct pcifront_device *pdev, struct xen_pci_op *op)
110 {
111         int err = 0;
112         struct xen_pci_op *active_op = &pdev->sh_info->op;
113         unsigned long irq_flags;
114         evtchn_port_t port = pdev->evtchn;
115         unsigned irq = pdev->irq;
116         s64 ns, ns_timeout;
117         struct timeval tv;
118
119         spin_lock_irqsave(&pdev->sh_info_lock, irq_flags);
120
121         memcpy(active_op, op, sizeof(struct xen_pci_op));
122
123         /* Go */
124         wmb();
125         set_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags);
126         notify_remote_via_evtchn(port);
127
128         /*
129          * We set a poll timeout of 3 seconds but give up on return after
130          * 2 seconds. It is better to time out too late rather than too early
131          * (in the latter case we end up continually re-executing poll() with a
132          * timeout in the past). 1s difference gives plenty of slack for error.
133          */
134         do_gettimeofday(&tv);
135         ns_timeout = timeval_to_ns(&tv) + 2 * (s64)NSEC_PER_SEC;
136
137         xen_clear_irq_pending(irq);
138
139         while (test_bit(_XEN_PCIF_active,
140                         (unsigned long *)&pdev->sh_info->flags)) {
141                 xen_poll_irq_timeout(irq, jiffies + 3*HZ);
142                 xen_clear_irq_pending(irq);
143                 do_gettimeofday(&tv);
144                 ns = timeval_to_ns(&tv);
145                 if (ns > ns_timeout) {
146                         dev_err(&pdev->xdev->dev,
147                                 "pciback not responding!!!\n");
148                         clear_bit(_XEN_PCIF_active,
149                                   (unsigned long *)&pdev->sh_info->flags);
150                         err = XEN_PCI_ERR_dev_not_found;
151                         goto out;
152                 }
153         }
154
155         /*
156         * We might lose backend service request since we
157         * reuse same evtchn with pci_conf backend response. So re-schedule
158         * aer pcifront service.
159         */
160         if (test_bit(_XEN_PCIB_active,
161                         (unsigned long *)&pdev->sh_info->flags)) {
162                 dev_err(&pdev->xdev->dev,
163                         "schedule aer pcifront service\n");
164                 schedule_pcifront_aer_op(pdev);
165         }
166
167         memcpy(op, active_op, sizeof(struct xen_pci_op));
168
169         err = op->err;
170 out:
171         spin_unlock_irqrestore(&pdev->sh_info_lock, irq_flags);
172         return err;
173 }
174
175 /* Access to this function is spinlocked in drivers/pci/access.c */
176 static int pcifront_bus_read(struct pci_bus *bus, unsigned int devfn,
177                              int where, int size, u32 *val)
178 {
179         int err = 0;
180         struct xen_pci_op op = {
181                 .cmd    = XEN_PCI_OP_conf_read,
182                 .domain = pci_domain_nr(bus),
183                 .bus    = bus->number,
184                 .devfn  = devfn,
185                 .offset = where,
186                 .size   = size,
187         };
188         struct pcifront_sd *sd = bus->sysdata;
189         struct pcifront_device *pdev = pcifront_get_pdev(sd);
190
191         if (verbose_request)
192                 dev_info(&pdev->xdev->dev,
193                          "read dev=%04x:%02x:%02x.%d - offset %x size %d\n",
194                          pci_domain_nr(bus), bus->number, PCI_SLOT(devfn),
195                          PCI_FUNC(devfn), where, size);
196
197         err = do_pci_op(pdev, &op);
198
199         if (likely(!err)) {
200                 if (verbose_request)
201                         dev_info(&pdev->xdev->dev, "read got back value %x\n",
202                                  op.value);
203
204                 *val = op.value;
205         } else if (err == -ENODEV) {
206                 /* No device here, pretend that it just returned 0 */
207                 err = 0;
208                 *val = 0;
209         }
210
211         return errno_to_pcibios_err(err);
212 }
213
214 /* Access to this function is spinlocked in drivers/pci/access.c */
215 static int pcifront_bus_write(struct pci_bus *bus, unsigned int devfn,
216                               int where, int size, u32 val)
217 {
218         struct xen_pci_op op = {
219                 .cmd    = XEN_PCI_OP_conf_write,
220                 .domain = pci_domain_nr(bus),
221                 .bus    = bus->number,
222                 .devfn  = devfn,
223                 .offset = where,
224                 .size   = size,
225                 .value  = val,
226         };
227         struct pcifront_sd *sd = bus->sysdata;
228         struct pcifront_device *pdev = pcifront_get_pdev(sd);
229
230         if (verbose_request)
231                 dev_info(&pdev->xdev->dev,
232                          "write dev=%04x:%02x:%02x.%d - "
233                          "offset %x size %d val %x\n",
234                          pci_domain_nr(bus), bus->number,
235                          PCI_SLOT(devfn), PCI_FUNC(devfn), where, size, val);
236
237         return errno_to_pcibios_err(do_pci_op(pdev, &op));
238 }
239
240 static struct pci_ops pcifront_bus_ops = {
241         .read = pcifront_bus_read,
242         .write = pcifront_bus_write,
243 };
244
245 #ifdef CONFIG_PCI_MSI
246 static int pci_frontend_enable_msix(struct pci_dev *dev,
247                                     int vector[], int nvec)
248 {
249         int err;
250         int i;
251         struct xen_pci_op op = {
252                 .cmd    = XEN_PCI_OP_enable_msix,
253                 .domain = pci_domain_nr(dev->bus),
254                 .bus = dev->bus->number,
255                 .devfn = dev->devfn,
256                 .value = nvec,
257         };
258         struct pcifront_sd *sd = dev->bus->sysdata;
259         struct pcifront_device *pdev = pcifront_get_pdev(sd);
260         struct msi_desc *entry;
261
262         if (nvec > SH_INFO_MAX_VEC) {
263                 dev_err(&dev->dev, "too much vector for pci frontend: %x."
264                                    " Increase SH_INFO_MAX_VEC.\n", nvec);
265                 return -EINVAL;
266         }
267
268         i = 0;
269         list_for_each_entry(entry, &dev->msi_list, list) {
270                 op.msix_entries[i].entry = entry->msi_attrib.entry_nr;
271                 /* Vector is useless at this point. */
272                 op.msix_entries[i].vector = -1;
273                 i++;
274         }
275
276         err = do_pci_op(pdev, &op);
277
278         if (likely(!err)) {
279                 if (likely(!op.value)) {
280                         /* we get the result */
281                         for (i = 0; i < nvec; i++) {
282                                 if (op.msix_entries[i].vector <= 0) {
283                                         dev_warn(&dev->dev, "MSI-X entry %d is invalid: %d!\n",
284                                                 i, op.msix_entries[i].vector);
285                                         err = -EINVAL;
286                                         vector[i] = -1;
287                                         continue;
288                                 }
289                                 vector[i] = op.msix_entries[i].vector;
290                         }
291                 } else {
292                         printk(KERN_DEBUG "enable msix get value %x\n",
293                                 op.value);
294                         err = op.value;
295                 }
296         } else {
297                 dev_err(&dev->dev, "enable msix get err %x\n", err);
298         }
299         return err;
300 }
301
302 static void pci_frontend_disable_msix(struct pci_dev *dev)
303 {
304         int err;
305         struct xen_pci_op op = {
306                 .cmd    = XEN_PCI_OP_disable_msix,
307                 .domain = pci_domain_nr(dev->bus),
308                 .bus = dev->bus->number,
309                 .devfn = dev->devfn,
310         };
311         struct pcifront_sd *sd = dev->bus->sysdata;
312         struct pcifront_device *pdev = pcifront_get_pdev(sd);
313
314         err = do_pci_op(pdev, &op);
315
316         /* What should do for error ? */
317         if (err)
318                 dev_err(&dev->dev, "pci_disable_msix get err %x\n", err);
319 }
320
321 static int pci_frontend_enable_msi(struct pci_dev *dev, int vector[])
322 {
323         int err;
324         struct xen_pci_op op = {
325                 .cmd    = XEN_PCI_OP_enable_msi,
326                 .domain = pci_domain_nr(dev->bus),
327                 .bus = dev->bus->number,
328                 .devfn = dev->devfn,
329         };
330         struct pcifront_sd *sd = dev->bus->sysdata;
331         struct pcifront_device *pdev = pcifront_get_pdev(sd);
332
333         err = do_pci_op(pdev, &op);
334         if (likely(!err)) {
335                 vector[0] = op.value;
336                 if (op.value <= 0) {
337                         dev_warn(&dev->dev, "MSI entry is invalid: %d!\n",
338                                 op.value);
339                         err = -EINVAL;
340                         vector[0] = -1;
341                 }
342         } else {
343                 dev_err(&dev->dev, "pci frontend enable msi failed for dev "
344                                     "%x:%x\n", op.bus, op.devfn);
345                 err = -EINVAL;
346         }
347         return err;
348 }
349
350 static void pci_frontend_disable_msi(struct pci_dev *dev)
351 {
352         int err;
353         struct xen_pci_op op = {
354                 .cmd    = XEN_PCI_OP_disable_msi,
355                 .domain = pci_domain_nr(dev->bus),
356                 .bus = dev->bus->number,
357                 .devfn = dev->devfn,
358         };
359         struct pcifront_sd *sd = dev->bus->sysdata;
360         struct pcifront_device *pdev = pcifront_get_pdev(sd);
361
362         err = do_pci_op(pdev, &op);
363         if (err == XEN_PCI_ERR_dev_not_found) {
364                 /* XXX No response from backend, what shall we do? */
365                 printk(KERN_DEBUG "get no response from backend for disable MSI\n");
366                 return;
367         }
368         if (err)
369                 /* how can pciback notify us fail? */
370                 printk(KERN_DEBUG "get fake response frombackend\n");
371 }
372
373 static struct xen_pci_frontend_ops pci_frontend_ops = {
374         .enable_msi = pci_frontend_enable_msi,
375         .disable_msi = pci_frontend_disable_msi,
376         .enable_msix = pci_frontend_enable_msix,
377         .disable_msix = pci_frontend_disable_msix,
378 };
379
380 static void pci_frontend_registrar(int enable)
381 {
382         if (enable)
383                 xen_pci_frontend = &pci_frontend_ops;
384         else
385                 xen_pci_frontend = NULL;
386 };
387 #else
388 static inline void pci_frontend_registrar(int enable) { };
389 #endif /* CONFIG_PCI_MSI */
390
391 /* Claim resources for the PCI frontend as-is, backend won't allow changes */
392 static int pcifront_claim_resource(struct pci_dev *dev, void *data)
393 {
394         struct pcifront_device *pdev = data;
395         int i;
396         struct resource *r;
397
398         for (i = 0; i < PCI_NUM_RESOURCES; i++) {
399                 r = &dev->resource[i];
400
401                 if (!r->parent && r->start && r->flags) {
402                         dev_info(&pdev->xdev->dev, "claiming resource %s/%d\n",
403                                 pci_name(dev), i);
404                         if (pci_claim_resource(dev, i)) {
405                                 dev_err(&pdev->xdev->dev, "Could not claim resource %s/%d! "
406                                         "Device offline. Try using e820_host=1 in the guest config.\n",
407                                         pci_name(dev), i);
408                         }
409                 }
410         }
411
412         return 0;
413 }
414
415 static int __devinit pcifront_scan_bus(struct pcifront_device *pdev,
416                                 unsigned int domain, unsigned int bus,
417                                 struct pci_bus *b)
418 {
419         struct pci_dev *d;
420         unsigned int devfn;
421
422         /* Scan the bus for functions and add.
423          * We omit handling of PCI bridge attachment because pciback prevents
424          * bridges from being exported.
425          */
426         for (devfn = 0; devfn < 0x100; devfn++) {
427                 d = pci_get_slot(b, devfn);
428                 if (d) {
429                         /* Device is already known. */
430                         pci_dev_put(d);
431                         continue;
432                 }
433
434                 d = pci_scan_single_device(b, devfn);
435                 if (d)
436                         dev_info(&pdev->xdev->dev, "New device on "
437                                  "%04x:%02x:%02x.%d found.\n", domain, bus,
438                                  PCI_SLOT(devfn), PCI_FUNC(devfn));
439         }
440
441         return 0;
442 }
443
444 static int __devinit pcifront_scan_root(struct pcifront_device *pdev,
445                                  unsigned int domain, unsigned int bus)
446 {
447         struct pci_bus *b;
448         struct pcifront_sd *sd = NULL;
449         struct pci_bus_entry *bus_entry = NULL;
450         int err = 0;
451
452 #ifndef CONFIG_PCI_DOMAINS
453         if (domain != 0) {
454                 dev_err(&pdev->xdev->dev,
455                         "PCI Root in non-zero PCI Domain! domain=%d\n", domain);
456                 dev_err(&pdev->xdev->dev,
457                         "Please compile with CONFIG_PCI_DOMAINS\n");
458                 err = -EINVAL;
459                 goto err_out;
460         }
461 #endif
462
463         dev_info(&pdev->xdev->dev, "Creating PCI Frontend Bus %04x:%02x\n",
464                  domain, bus);
465
466         bus_entry = kmalloc(sizeof(*bus_entry), GFP_KERNEL);
467         sd = kmalloc(sizeof(*sd), GFP_KERNEL);
468         if (!bus_entry || !sd) {
469                 err = -ENOMEM;
470                 goto err_out;
471         }
472         pcifront_init_sd(sd, domain, bus, pdev);
473
474         b = pci_scan_bus_parented(&pdev->xdev->dev, bus,
475                                   &pcifront_bus_ops, sd);
476         if (!b) {
477                 dev_err(&pdev->xdev->dev,
478                         "Error creating PCI Frontend Bus!\n");
479                 err = -ENOMEM;
480                 goto err_out;
481         }
482
483         bus_entry->bus = b;
484
485         list_add(&bus_entry->list, &pdev->root_buses);
486
487         /* pci_scan_bus_parented skips devices which do not have a have
488         * devfn==0. The pcifront_scan_bus enumerates all devfn. */
489         err = pcifront_scan_bus(pdev, domain, bus, b);
490
491         /* Claim resources before going "live" with our devices */
492         pci_walk_bus(b, pcifront_claim_resource, pdev);
493
494         /* Create SysFS and notify udev of the devices. Aka: "going live" */
495         pci_bus_add_devices(b);
496
497         return err;
498
499 err_out:
500         kfree(bus_entry);
501         kfree(sd);
502
503         return err;
504 }
505
506 static int __devinit pcifront_rescan_root(struct pcifront_device *pdev,
507                                    unsigned int domain, unsigned int bus)
508 {
509         int err;
510         struct pci_bus *b;
511
512 #ifndef CONFIG_PCI_DOMAINS
513         if (domain != 0) {
514                 dev_err(&pdev->xdev->dev,
515                         "PCI Root in non-zero PCI Domain! domain=%d\n", domain);
516                 dev_err(&pdev->xdev->dev,
517                         "Please compile with CONFIG_PCI_DOMAINS\n");
518                 return -EINVAL;
519         }
520 #endif
521
522         dev_info(&pdev->xdev->dev, "Rescanning PCI Frontend Bus %04x:%02x\n",
523                  domain, bus);
524
525         b = pci_find_bus(domain, bus);
526         if (!b)
527                 /* If the bus is unknown, create it. */
528                 return pcifront_scan_root(pdev, domain, bus);
529
530         err = pcifront_scan_bus(pdev, domain, bus, b);
531
532         /* Claim resources before going "live" with our devices */
533         pci_walk_bus(b, pcifront_claim_resource, pdev);
534
535         /* Create SysFS and notify udev of the devices. Aka: "going live" */
536         pci_bus_add_devices(b);
537
538         return err;
539 }
540
541 static void free_root_bus_devs(struct pci_bus *bus)
542 {
543         struct pci_dev *dev;
544
545         while (!list_empty(&bus->devices)) {
546                 dev = container_of(bus->devices.next, struct pci_dev,
547                                    bus_list);
548                 dev_dbg(&dev->dev, "removing device\n");
549                 pci_stop_and_remove_bus_device(dev);
550         }
551 }
552
553 static void pcifront_free_roots(struct pcifront_device *pdev)
554 {
555         struct pci_bus_entry *bus_entry, *t;
556
557         dev_dbg(&pdev->xdev->dev, "cleaning up root buses\n");
558
559         list_for_each_entry_safe(bus_entry, t, &pdev->root_buses, list) {
560                 list_del(&bus_entry->list);
561
562                 free_root_bus_devs(bus_entry->bus);
563
564                 kfree(bus_entry->bus->sysdata);
565
566                 device_unregister(bus_entry->bus->bridge);
567                 pci_remove_bus(bus_entry->bus);
568
569                 kfree(bus_entry);
570         }
571 }
572
573 static pci_ers_result_t pcifront_common_process(int cmd,
574                                                 struct pcifront_device *pdev,
575                                                 pci_channel_state_t state)
576 {
577         pci_ers_result_t result;
578         struct pci_driver *pdrv;
579         int bus = pdev->sh_info->aer_op.bus;
580         int devfn = pdev->sh_info->aer_op.devfn;
581         struct pci_dev *pcidev;
582         int flag = 0;
583
584         dev_dbg(&pdev->xdev->dev,
585                 "pcifront AER process: cmd %x (bus:%x, devfn%x)",
586                 cmd, bus, devfn);
587         result = PCI_ERS_RESULT_NONE;
588
589         pcidev = pci_get_bus_and_slot(bus, devfn);
590         if (!pcidev || !pcidev->driver) {
591                 dev_err(&pdev->xdev->dev, "device or AER driver is NULL\n");
592                 if (pcidev)
593                         pci_dev_put(pcidev);
594                 return result;
595         }
596         pdrv = pcidev->driver;
597
598         if (pdrv) {
599                 if (pdrv->err_handler && pdrv->err_handler->error_detected) {
600                         dev_dbg(&pcidev->dev,
601                                 "trying to call AER service\n");
602                         if (pcidev) {
603                                 flag = 1;
604                                 switch (cmd) {
605                                 case XEN_PCI_OP_aer_detected:
606                                         result = pdrv->err_handler->
607                                                  error_detected(pcidev, state);
608                                         break;
609                                 case XEN_PCI_OP_aer_mmio:
610                                         result = pdrv->err_handler->
611                                                  mmio_enabled(pcidev);
612                                         break;
613                                 case XEN_PCI_OP_aer_slotreset:
614                                         result = pdrv->err_handler->
615                                                  slot_reset(pcidev);
616                                         break;
617                                 case XEN_PCI_OP_aer_resume:
618                                         pdrv->err_handler->resume(pcidev);
619                                         break;
620                                 default:
621                                         dev_err(&pdev->xdev->dev,
622                                                 "bad request in aer recovery "
623                                                 "operation!\n");
624
625                                 }
626                         }
627                 }
628         }
629         if (!flag)
630                 result = PCI_ERS_RESULT_NONE;
631
632         return result;
633 }
634
635
636 static void pcifront_do_aer(struct work_struct *data)
637 {
638         struct pcifront_device *pdev =
639                 container_of(data, struct pcifront_device, op_work);
640         int cmd = pdev->sh_info->aer_op.cmd;
641         pci_channel_state_t state =
642                 (pci_channel_state_t)pdev->sh_info->aer_op.err;
643
644         /*If a pci_conf op is in progress,
645                 we have to wait until it is done before service aer op*/
646         dev_dbg(&pdev->xdev->dev,
647                 "pcifront service aer bus %x devfn %x\n",
648                 pdev->sh_info->aer_op.bus, pdev->sh_info->aer_op.devfn);
649
650         pdev->sh_info->aer_op.err = pcifront_common_process(cmd, pdev, state);
651
652         /* Post the operation to the guest. */
653         wmb();
654         clear_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags);
655         notify_remote_via_evtchn(pdev->evtchn);
656
657         /*in case of we lost an aer request in four lines time_window*/
658         smp_mb__before_clear_bit();
659         clear_bit(_PDEVB_op_active, &pdev->flags);
660         smp_mb__after_clear_bit();
661
662         schedule_pcifront_aer_op(pdev);
663
664 }
665
666 static irqreturn_t pcifront_handler_aer(int irq, void *dev)
667 {
668         struct pcifront_device *pdev = dev;
669         schedule_pcifront_aer_op(pdev);
670         return IRQ_HANDLED;
671 }
672 static int pcifront_connect_and_init_dma(struct pcifront_device *pdev)
673 {
674         int err = 0;
675
676         spin_lock(&pcifront_dev_lock);
677
678         if (!pcifront_dev) {
679                 dev_info(&pdev->xdev->dev, "Installing PCI frontend\n");
680                 pcifront_dev = pdev;
681         } else {
682                 dev_err(&pdev->xdev->dev, "PCI frontend already installed!\n");
683                 err = -EEXIST;
684         }
685         spin_unlock(&pcifront_dev_lock);
686
687         if (!err && !swiotlb_nr_tbl()) {
688                 err = pci_xen_swiotlb_init_late();
689                 if (err)
690                         dev_err(&pdev->xdev->dev, "Could not setup SWIOTLB!\n");
691         }
692         return err;
693 }
694
695 static void pcifront_disconnect(struct pcifront_device *pdev)
696 {
697         spin_lock(&pcifront_dev_lock);
698
699         if (pdev == pcifront_dev) {
700                 dev_info(&pdev->xdev->dev,
701                          "Disconnecting PCI Frontend Buses\n");
702                 pcifront_dev = NULL;
703         }
704
705         spin_unlock(&pcifront_dev_lock);
706 }
707 static struct pcifront_device *alloc_pdev(struct xenbus_device *xdev)
708 {
709         struct pcifront_device *pdev;
710
711         pdev = kzalloc(sizeof(struct pcifront_device), GFP_KERNEL);
712         if (pdev == NULL)
713                 goto out;
714
715         pdev->sh_info =
716             (struct xen_pci_sharedinfo *)__get_free_page(GFP_KERNEL);
717         if (pdev->sh_info == NULL) {
718                 kfree(pdev);
719                 pdev = NULL;
720                 goto out;
721         }
722         pdev->sh_info->flags = 0;
723
724         /*Flag for registering PV AER handler*/
725         set_bit(_XEN_PCIB_AERHANDLER, (void *)&pdev->sh_info->flags);
726
727         dev_set_drvdata(&xdev->dev, pdev);
728         pdev->xdev = xdev;
729
730         INIT_LIST_HEAD(&pdev->root_buses);
731
732         spin_lock_init(&pdev->sh_info_lock);
733
734         pdev->evtchn = INVALID_EVTCHN;
735         pdev->gnt_ref = INVALID_GRANT_REF;
736         pdev->irq = -1;
737
738         INIT_WORK(&pdev->op_work, pcifront_do_aer);
739
740         dev_dbg(&xdev->dev, "Allocated pdev @ 0x%p pdev->sh_info @ 0x%p\n",
741                 pdev, pdev->sh_info);
742 out:
743         return pdev;
744 }
745
746 static void free_pdev(struct pcifront_device *pdev)
747 {
748         dev_dbg(&pdev->xdev->dev, "freeing pdev @ 0x%p\n", pdev);
749
750         pcifront_free_roots(pdev);
751
752         cancel_work_sync(&pdev->op_work);
753
754         if (pdev->irq >= 0)
755                 unbind_from_irqhandler(pdev->irq, pdev);
756
757         if (pdev->evtchn != INVALID_EVTCHN)
758                 xenbus_free_evtchn(pdev->xdev, pdev->evtchn);
759
760         if (pdev->gnt_ref != INVALID_GRANT_REF)
761                 gnttab_end_foreign_access(pdev->gnt_ref, 0 /* r/w page */,
762                                           (unsigned long)pdev->sh_info);
763         else
764                 free_page((unsigned long)pdev->sh_info);
765
766         dev_set_drvdata(&pdev->xdev->dev, NULL);
767
768         kfree(pdev);
769 }
770
771 static int pcifront_publish_info(struct pcifront_device *pdev)
772 {
773         int err = 0;
774         struct xenbus_transaction trans;
775
776         err = xenbus_grant_ring(pdev->xdev, virt_to_mfn(pdev->sh_info));
777         if (err < 0)
778                 goto out;
779
780         pdev->gnt_ref = err;
781
782         err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn);
783         if (err)
784                 goto out;
785
786         err = bind_evtchn_to_irqhandler(pdev->evtchn, pcifront_handler_aer,
787                 0, "pcifront", pdev);
788
789         if (err < 0)
790                 return err;
791
792         pdev->irq = err;
793
794 do_publish:
795         err = xenbus_transaction_start(&trans);
796         if (err) {
797                 xenbus_dev_fatal(pdev->xdev, err,
798                                  "Error writing configuration for backend "
799                                  "(start transaction)");
800                 goto out;
801         }
802
803         err = xenbus_printf(trans, pdev->xdev->nodename,
804                             "pci-op-ref", "%u", pdev->gnt_ref);
805         if (!err)
806                 err = xenbus_printf(trans, pdev->xdev->nodename,
807                                     "event-channel", "%u", pdev->evtchn);
808         if (!err)
809                 err = xenbus_printf(trans, pdev->xdev->nodename,
810                                     "magic", XEN_PCI_MAGIC);
811
812         if (err) {
813                 xenbus_transaction_end(trans, 1);
814                 xenbus_dev_fatal(pdev->xdev, err,
815                                  "Error writing configuration for backend");
816                 goto out;
817         } else {
818                 err = xenbus_transaction_end(trans, 0);
819                 if (err == -EAGAIN)
820                         goto do_publish;
821                 else if (err) {
822                         xenbus_dev_fatal(pdev->xdev, err,
823                                          "Error completing transaction "
824                                          "for backend");
825                         goto out;
826                 }
827         }
828
829         xenbus_switch_state(pdev->xdev, XenbusStateInitialised);
830
831         dev_dbg(&pdev->xdev->dev, "publishing successful!\n");
832
833 out:
834         return err;
835 }
836
837 static int __devinit pcifront_try_connect(struct pcifront_device *pdev)
838 {
839         int err = -EFAULT;
840         int i, num_roots, len;
841         char str[64];
842         unsigned int domain, bus;
843
844
845         /* Only connect once */
846         if (xenbus_read_driver_state(pdev->xdev->nodename) !=
847             XenbusStateInitialised)
848                 goto out;
849
850         err = pcifront_connect_and_init_dma(pdev);
851         if (err) {
852                 xenbus_dev_fatal(pdev->xdev, err,
853                                  "Error setting up PCI Frontend");
854                 goto out;
855         }
856
857         err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend,
858                            "root_num", "%d", &num_roots);
859         if (err == -ENOENT) {
860                 xenbus_dev_error(pdev->xdev, err,
861                                  "No PCI Roots found, trying 0000:00");
862                 err = pcifront_scan_root(pdev, 0, 0);
863                 num_roots = 0;
864         } else if (err != 1) {
865                 if (err == 0)
866                         err = -EINVAL;
867                 xenbus_dev_fatal(pdev->xdev, err,
868                                  "Error reading number of PCI roots");
869                 goto out;
870         }
871
872         for (i = 0; i < num_roots; i++) {
873                 len = snprintf(str, sizeof(str), "root-%d", i);
874                 if (unlikely(len >= (sizeof(str) - 1))) {
875                         err = -ENOMEM;
876                         goto out;
877                 }
878
879                 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str,
880                                    "%x:%x", &domain, &bus);
881                 if (err != 2) {
882                         if (err >= 0)
883                                 err = -EINVAL;
884                         xenbus_dev_fatal(pdev->xdev, err,
885                                          "Error reading PCI root %d", i);
886                         goto out;
887                 }
888
889                 err = pcifront_scan_root(pdev, domain, bus);
890                 if (err) {
891                         xenbus_dev_fatal(pdev->xdev, err,
892                                          "Error scanning PCI root %04x:%02x",
893                                          domain, bus);
894                         goto out;
895                 }
896         }
897
898         err = xenbus_switch_state(pdev->xdev, XenbusStateConnected);
899
900 out:
901         return err;
902 }
903
904 static int pcifront_try_disconnect(struct pcifront_device *pdev)
905 {
906         int err = 0;
907         enum xenbus_state prev_state;
908
909
910         prev_state = xenbus_read_driver_state(pdev->xdev->nodename);
911
912         if (prev_state >= XenbusStateClosing)
913                 goto out;
914
915         if (prev_state == XenbusStateConnected) {
916                 pcifront_free_roots(pdev);
917                 pcifront_disconnect(pdev);
918         }
919
920         err = xenbus_switch_state(pdev->xdev, XenbusStateClosed);
921
922 out:
923
924         return err;
925 }
926
927 static int __devinit pcifront_attach_devices(struct pcifront_device *pdev)
928 {
929         int err = -EFAULT;
930         int i, num_roots, len;
931         unsigned int domain, bus;
932         char str[64];
933
934         if (xenbus_read_driver_state(pdev->xdev->nodename) !=
935             XenbusStateReconfiguring)
936                 goto out;
937
938         err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend,
939                            "root_num", "%d", &num_roots);
940         if (err == -ENOENT) {
941                 xenbus_dev_error(pdev->xdev, err,
942                                  "No PCI Roots found, trying 0000:00");
943                 err = pcifront_rescan_root(pdev, 0, 0);
944                 num_roots = 0;
945         } else if (err != 1) {
946                 if (err == 0)
947                         err = -EINVAL;
948                 xenbus_dev_fatal(pdev->xdev, err,
949                                  "Error reading number of PCI roots");
950                 goto out;
951         }
952
953         for (i = 0; i < num_roots; i++) {
954                 len = snprintf(str, sizeof(str), "root-%d", i);
955                 if (unlikely(len >= (sizeof(str) - 1))) {
956                         err = -ENOMEM;
957                         goto out;
958                 }
959
960                 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str,
961                                    "%x:%x", &domain, &bus);
962                 if (err != 2) {
963                         if (err >= 0)
964                                 err = -EINVAL;
965                         xenbus_dev_fatal(pdev->xdev, err,
966                                          "Error reading PCI root %d", i);
967                         goto out;
968                 }
969
970                 err = pcifront_rescan_root(pdev, domain, bus);
971                 if (err) {
972                         xenbus_dev_fatal(pdev->xdev, err,
973                                          "Error scanning PCI root %04x:%02x",
974                                          domain, bus);
975                         goto out;
976                 }
977         }
978
979         xenbus_switch_state(pdev->xdev, XenbusStateConnected);
980
981 out:
982         return err;
983 }
984
985 static int pcifront_detach_devices(struct pcifront_device *pdev)
986 {
987         int err = 0;
988         int i, num_devs;
989         unsigned int domain, bus, slot, func;
990         struct pci_bus *pci_bus;
991         struct pci_dev *pci_dev;
992         char str[64];
993
994         if (xenbus_read_driver_state(pdev->xdev->nodename) !=
995             XenbusStateConnected)
996                 goto out;
997
998         err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, "num_devs", "%d",
999                            &num_devs);
1000         if (err != 1) {
1001                 if (err >= 0)
1002                         err = -EINVAL;
1003                 xenbus_dev_fatal(pdev->xdev, err,
1004                                  "Error reading number of PCI devices");
1005                 goto out;
1006         }
1007
1008         /* Find devices being detached and remove them. */
1009         for (i = 0; i < num_devs; i++) {
1010                 int l, state;
1011                 l = snprintf(str, sizeof(str), "state-%d", i);
1012                 if (unlikely(l >= (sizeof(str) - 1))) {
1013                         err = -ENOMEM;
1014                         goto out;
1015                 }
1016                 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, "%d",
1017                                    &state);
1018                 if (err != 1)
1019                         state = XenbusStateUnknown;
1020
1021                 if (state != XenbusStateClosing)
1022                         continue;
1023
1024                 /* Remove device. */
1025                 l = snprintf(str, sizeof(str), "vdev-%d", i);
1026                 if (unlikely(l >= (sizeof(str) - 1))) {
1027                         err = -ENOMEM;
1028                         goto out;
1029                 }
1030                 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str,
1031                                    "%x:%x:%x.%x", &domain, &bus, &slot, &func);
1032                 if (err != 4) {
1033                         if (err >= 0)
1034                                 err = -EINVAL;
1035                         xenbus_dev_fatal(pdev->xdev, err,
1036                                          "Error reading PCI device %d", i);
1037                         goto out;
1038                 }
1039
1040                 pci_bus = pci_find_bus(domain, bus);
1041                 if (!pci_bus) {
1042                         dev_dbg(&pdev->xdev->dev, "Cannot get bus %04x:%02x\n",
1043                                 domain, bus);
1044                         continue;
1045                 }
1046                 pci_dev = pci_get_slot(pci_bus, PCI_DEVFN(slot, func));
1047                 if (!pci_dev) {
1048                         dev_dbg(&pdev->xdev->dev,
1049                                 "Cannot get PCI device %04x:%02x:%02x.%d\n",
1050                                 domain, bus, slot, func);
1051                         continue;
1052                 }
1053                 pci_stop_and_remove_bus_device(pci_dev);
1054                 pci_dev_put(pci_dev);
1055
1056                 dev_dbg(&pdev->xdev->dev,
1057                         "PCI device %04x:%02x:%02x.%d removed.\n",
1058                         domain, bus, slot, func);
1059         }
1060
1061         err = xenbus_switch_state(pdev->xdev, XenbusStateReconfiguring);
1062
1063 out:
1064         return err;
1065 }
1066
1067 static void __init_refok pcifront_backend_changed(struct xenbus_device *xdev,
1068                                                   enum xenbus_state be_state)
1069 {
1070         struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev);
1071
1072         switch (be_state) {
1073         case XenbusStateUnknown:
1074         case XenbusStateInitialising:
1075         case XenbusStateInitWait:
1076         case XenbusStateInitialised:
1077         case XenbusStateClosed:
1078                 break;
1079
1080         case XenbusStateConnected:
1081                 pcifront_try_connect(pdev);
1082                 break;
1083
1084         case XenbusStateClosing:
1085                 dev_warn(&xdev->dev, "backend going away!\n");
1086                 pcifront_try_disconnect(pdev);
1087                 break;
1088
1089         case XenbusStateReconfiguring:
1090                 pcifront_detach_devices(pdev);
1091                 break;
1092
1093         case XenbusStateReconfigured:
1094                 pcifront_attach_devices(pdev);
1095                 break;
1096         }
1097 }
1098
1099 static int pcifront_xenbus_probe(struct xenbus_device *xdev,
1100                                  const struct xenbus_device_id *id)
1101 {
1102         int err = 0;
1103         struct pcifront_device *pdev = alloc_pdev(xdev);
1104
1105         if (pdev == NULL) {
1106                 err = -ENOMEM;
1107                 xenbus_dev_fatal(xdev, err,
1108                                  "Error allocating pcifront_device struct");
1109                 goto out;
1110         }
1111
1112         err = pcifront_publish_info(pdev);
1113         if (err)
1114                 free_pdev(pdev);
1115
1116 out:
1117         return err;
1118 }
1119
1120 static int pcifront_xenbus_remove(struct xenbus_device *xdev)
1121 {
1122         struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev);
1123         if (pdev)
1124                 free_pdev(pdev);
1125
1126         return 0;
1127 }
1128
1129 static const struct xenbus_device_id xenpci_ids[] = {
1130         {"pci"},
1131         {""},
1132 };
1133
1134 static DEFINE_XENBUS_DRIVER(xenpci, "pcifront",
1135         .probe                  = pcifront_xenbus_probe,
1136         .remove                 = pcifront_xenbus_remove,
1137         .otherend_changed       = pcifront_backend_changed,
1138 );
1139
1140 static int __init pcifront_init(void)
1141 {
1142         if (!xen_pv_domain() || xen_initial_domain())
1143                 return -ENODEV;
1144
1145         pci_frontend_registrar(1 /* enable */);
1146
1147         return xenbus_register_frontend(&xenpci_driver);
1148 }
1149
1150 static void __exit pcifront_cleanup(void)
1151 {
1152         xenbus_unregister_driver(&xenpci_driver);
1153         pci_frontend_registrar(0 /* disable */);
1154 }
1155 module_init(pcifront_init);
1156 module_exit(pcifront_cleanup);
1157
1158 MODULE_DESCRIPTION("Xen PCI passthrough frontend.");
1159 MODULE_LICENSE("GPL");
1160 MODULE_ALIAS("xen:pci");