arch/s390/pci/pci_event.c

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