arch/s390/pci/pci_event.c

   1 /*
   2  *  Copyright IBM Corp. 2012
   3  *
   4  *  Author(s):
   5  *    Jan Glauber <jang@linux.vnet.ibm.com>
   6  */
   7
   8 #define KMSG_COMPONENT "zpci"
   9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  10
  11 #include <linux/kernel.h>
  12 #include <linux/pci.h>
  13 #include <asm/pci_debug.h>
  14 #include <asm/sclp.h>
  15
  16 /* Content Code Description for PCI Function Error */
  17 struct zpci_ccdf_err {
  18         u32 reserved1;
  19         u32 fh;                         /* function handle */
  20         u32 fid;                        /* function id */
  21         u32 ett         :  4;           /* expected table type */
  22         u32 mvn         : 12;           /* MSI vector number */
  23         u32 dmaas       :  8;           /* DMA address space */
  24         u32             :  6;
  25         u32 q           :  1;           /* event qualifier */
  26         u32 rw          :  1;           /* read/write */
  27         u64 faddr;                      /* failing address */
  28         u32 reserved3;
  29         u16 reserved4;
  30         u16 pec;                        /* PCI event code */
  31 } __packed;
  32
  33 /* Content Code Description for PCI Function Availability */
  34 struct zpci_ccdf_avail {
  35         u32 reserved1;
  36         u32 fh;                         /* function handle */
  37         u32 fid;                        /* function id */
  38         u32 reserved2;
  39         u32 reserved3;
  40         u32 reserved4;
  41         u32 reserved5;
  42         u16 reserved6;
  43         u16 pec;                        /* PCI event code */
  44 } __packed;
  45
  46 static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
  47 {
  48         struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
  49         struct pci_dev *pdev = NULL;
  50
  51         zpci_err("error CCDF:\n");
  52         zpci_err_hex(ccdf, sizeof(*ccdf));
  53
  54         if (zdev)
  55                 pdev = pci_get_slot(zdev->bus, ZPCI_DEVFN);
  56
  57         pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
  58                pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
  59
  60         if (!pdev)
  61                 return;
  62
  63         pdev->error_state = pci_channel_io_perm_failure;
  64         pci_dev_put(pdev);
  65 }
  66
  67 void zpci_event_error(void *data)
  68 {
  69         if (zpci_is_enabled())
  70                 __zpci_event_error(data);
  71 }
  72
  73 static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
  74 {
  75         struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
  76         struct pci_dev *pdev = NULL;
  77         enum zpci_state state;
  78         int ret;
  79
  80         if (zdev)
  81                 pdev = pci_get_slot(zdev->bus, ZPCI_DEVFN);
  82
  83         pr_info("%s: Event 0x%x reconfigured PCI function 0x%x\n",
  84                 pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
  85         zpci_err("avail CCDF:\n");
  86         zpci_err_hex(ccdf, sizeof(*ccdf));
  87
  88         switch (ccdf->pec) {
  89         case 0x0301: /* Reserved|Standby -> Configured */
  90                 if (!zdev) {
  91                         ret = clp_add_pci_device(ccdf->fid, ccdf->fh, 0);
  92                         if (ret)
  93                                 break;
  94                         zdev = get_zdev_by_fid(ccdf->fid);
  95                 }
  96                 if (!zdev || zdev->state != ZPCI_FN_STATE_STANDBY)
  97                         break;
  98                 zdev->state = ZPCI_FN_STATE_CONFIGURED;
  99                 zdev->fh = ccdf->fh;
 100                 ret = zpci_enable_device(zdev);
 101                 if (ret)
 102                         break;
 103                 pci_lock_rescan_remove();
 104                 pci_rescan_bus(zdev->bus);
 105                 pci_unlock_rescan_remove();
 106                 break;
 107         case 0x0302: /* Reserved -> Standby */
 108                 if (!zdev)
 109                         clp_add_pci_device(ccdf->fid, ccdf->fh, 0);
 110                 break;
 111         case 0x0303: /* Deconfiguration requested */
 112                 if (!zdev)
 113                         break;
 114                 if (pdev)
 115                         pci_stop_and_remove_bus_device_locked(pdev);
 116
 117                 ret = zpci_disable_device(zdev);
 118                 if (ret)
 119                         break;
 120
 121                 ret = sclp_pci_deconfigure(zdev->fid);
 122                 zpci_dbg(3, "deconf fid:%x, rc:%d\n", zdev->fid, ret);
 123                 if (!ret)
 124                         zdev->state = ZPCI_FN_STATE_STANDBY;
 125
 126                 break;
 127         case 0x0304: /* Configured -> Standby|Reserved */
 128                 if (!zdev)
 129                         break;
 130                 if (pdev) {
 131                         /* Give the driver a hint that the function is
 132                          * already unusable. */
 133                         pdev->error_state = pci_channel_io_perm_failure;
 134                         pci_stop_and_remove_bus_device_locked(pdev);
 135                 }
 136
 137                 zdev->fh = ccdf->fh;
 138                 zpci_disable_device(zdev);
 139                 zdev->state = ZPCI_FN_STATE_STANDBY;
 140                 if (!clp_get_state(ccdf->fid, &state) &&
 141                     state == ZPCI_FN_STATE_RESERVED) {
 142                         zpci_remove_device(zdev);
 143                 }
 144                 break;
 145         case 0x0306: /* 0x308 or 0x302 for multiple devices */
 146                 clp_rescan_pci_devices();
 147                 break;
 148         case 0x0308: /* Standby -> Reserved */
 149                 if (!zdev)
 150                         break;
 151                 zpci_remove_device(zdev);
 152                 break;
 153         default:
 154                 break;
 155         }
 156         pci_dev_put(pdev);
 157 }
 158
 159 void zpci_event_availability(void *data)
 160 {
 161         if (zpci_is_enabled())
 162                 __zpci_event_availability(data);
 163 }