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 } 203