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