drivers/s390/char/sclp_pci.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PCI I/O adapter configuration related functions.
   4  *
   5  * Copyright IBM Corp. 2016
   6  */
   7 #define KMSG_COMPONENT "sclp_cmd"
   8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
   9
  10 #include <linux/completion.h>
  11 #include <linux/export.h>
  12 #include <linux/mutex.h>
  13 #include <linux/errno.h>
  14 #include <linux/slab.h>
  15 #include <linux/init.h>
  16 #include <linux/err.h>
  17
  18 #include <asm/sclp.h>
  19
  20 #include "sclp.h"
  21
  22 #define SCLP_CMDW_CONFIGURE_PCI                 0x001a0001
  23 #define SCLP_CMDW_DECONFIGURE_PCI               0x001b0001
  24
  25 #define SCLP_ATYPE_PCI                          2
  26
  27 #define SCLP_ERRNOTIFY_AQ_RESET                 0
  28 #define SCLP_ERRNOTIFY_AQ_REPAIR                1
  29 #define SCLP_ERRNOTIFY_AQ_INFO_LOG              2
  30
  31 static DEFINE_MUTEX(sclp_pci_mutex);
  32 static struct sclp_register sclp_pci_event = {
  33         .send_mask = EVTYP_ERRNOTIFY_MASK,
  34 };
  35
  36 struct err_notify_evbuf {
  37         struct evbuf_header header;
  38         u8 action;
  39         u8 atype;
  40         u32 fh;
  41         u32 fid;
  42         u8 data[];
  43 } __packed;
  44
  45 struct err_notify_sccb {
  46         struct sccb_header header;
  47         struct err_notify_evbuf evbuf;
  48 } __packed;
  49
  50 struct pci_cfg_sccb {
  51         struct sccb_header header;
  52         u8 atype;               /* adapter type */
  53         u8 reserved1;
  54         u16 reserved2;
  55         u32 aid;                /* adapter identifier */
  56 } __packed;
  57
  58 static int do_pci_configure(sclp_cmdw_t cmd, u32 fid)
  59 {
  60         struct pci_cfg_sccb *sccb;
  61         int rc;
  62
  63         if (!SCLP_HAS_PCI_RECONFIG)
  64                 return -EOPNOTSUPP;
  65
  66         sccb = (struct pci_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
  67         if (!sccb)
  68                 return -ENOMEM;
  69
  70         sccb->header.length = PAGE_SIZE;
  71         sccb->atype = SCLP_ATYPE_PCI;
  72         sccb->aid = fid;
  73         rc = sclp_sync_request(cmd, sccb);
  74         if (rc)
  75                 goto out;
  76         switch (sccb->header.response_code) {
  77         case 0x0020:
  78         case 0x0120:
  79                 break;
  80         default:
  81                 pr_warn("configure PCI I/O adapter failed: cmd=0x%08x  response=0x%04x\n",
  82                         cmd, sccb->header.response_code);
  83                 rc = -EIO;
  84                 break;
  85         }
  86 out:
  87         free_page((unsigned long) sccb);
  88         return rc;
  89 }
  90
  91 int sclp_pci_configure(u32 fid)
  92 {
  93         return do_pci_configure(SCLP_CMDW_CONFIGURE_PCI, fid);
  94 }
  95 EXPORT_SYMBOL(sclp_pci_configure);
  96
  97 int sclp_pci_deconfigure(u32 fid)
  98 {
  99         return do_pci_configure(SCLP_CMDW_DECONFIGURE_PCI, fid);
 100 }
 101 EXPORT_SYMBOL(sclp_pci_deconfigure);
 102
 103 static void sclp_pci_callback(struct sclp_req *req, void *data)
 104 {
 105         struct completion *completion = data;
 106
 107         complete(completion);
 108 }
 109
 110 static int sclp_pci_check_report(struct zpci_report_error_header *report)
 111 {
 112         if (report->version != 1)
 113                 return -EINVAL;
 114
 115         switch (report->action) {
 116         case SCLP_ERRNOTIFY_AQ_RESET:
 117         case SCLP_ERRNOTIFY_AQ_REPAIR:
 118         case SCLP_ERRNOTIFY_AQ_INFO_LOG:
 119                 break;
 120         default:
 121                 return -EINVAL;
 122         }
 123
 124         if (report->length > (PAGE_SIZE - sizeof(struct err_notify_sccb)))
 125                 return -EINVAL;
 126
 127         return 0;
 128 }
 129
 130 int sclp_pci_report(struct zpci_report_error_header *report, u32 fh, u32 fid)
 131 {
 132         DECLARE_COMPLETION_ONSTACK(completion);
 133         struct err_notify_sccb *sccb;
 134         struct sclp_req req;
 135         int ret;
 136
 137         ret = sclp_pci_check_report(report);
 138         if (ret)
 139                 return ret;
 140
 141         mutex_lock(&sclp_pci_mutex);
 142         ret = sclp_register(&sclp_pci_event);
 143         if (ret)
 144                 goto out_unlock;
 145
 146         if (!(sclp_pci_event.sclp_receive_mask & EVTYP_ERRNOTIFY_MASK)) {
 147                 ret = -EOPNOTSUPP;
 148                 goto out_unregister;
 149         }
 150
 151         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 152         if (!sccb) {
 153                 ret = -ENOMEM;
 154                 goto out_unregister;
 155         }
 156
 157         memset(&req, 0, sizeof(req));
 158         req.callback_data = &completion;
 159         req.callback = sclp_pci_callback;
 160         req.command = SCLP_CMDW_WRITE_EVENT_DATA;
 161         req.status = SCLP_REQ_FILLED;
 162         req.sccb = sccb;
 163
 164         sccb->evbuf.header.length = sizeof(sccb->evbuf) + report->length;
 165         sccb->evbuf.header.type = EVTYP_ERRNOTIFY;
 166         sccb->header.length = sizeof(sccb->header) + sccb->evbuf.header.length;
 167
 168         sccb->evbuf.action = report->action;
 169         sccb->evbuf.atype = SCLP_ATYPE_PCI;
 170         sccb->evbuf.fh = fh;
 171         sccb->evbuf.fid = fid;
 172
 173         memcpy(sccb->evbuf.data, report->data, report->length);
 174
 175         ret = sclp_add_request(&req);
 176         if (ret)
 177                 goto out_free_req;
 178
 179         wait_for_completion(&completion);
 180         if (req.status != SCLP_REQ_DONE) {
 181                 pr_warn("request failed (status=0x%02x)\n",
 182                         req.status);
 183                 ret = -EIO;
 184                 goto out_free_req;
 185         }
 186
 187         if (sccb->header.response_code != 0x0020) {
 188                 pr_warn("request failed with response code 0x%x\n",
 189                         sccb->header.response_code);
 190                 ret = -EIO;
 191         }
 192
 193 out_free_req:
 194         free_page((unsigned long) sccb);
 195 out_unregister:
 196         sclp_unregister(&sclp_pci_event);
 197 out_unlock:
 198         mutex_unlock(&sclp_pci_mutex);
 199         return ret;
 200 }