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
 32static DEFINE_MUTEX(sclp_pci_mutex);
 33static struct sclp_register sclp_pci_event = {
 34	.send_mask = EVTYP_ERRNOTIFY_MASK,
 35};
 36
 37struct 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
 46struct err_notify_sccb {
 47	struct sccb_header header;
 48	struct err_notify_evbuf evbuf;
 49} __packed;
 50
 51struct 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
 59static 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	}
 87out:
 88	free_page((unsigned long) sccb);
 89	return rc;
 90}
 91
 92int sclp_pci_configure(u32 fid)
 93{
 94	return do_pci_configure(SCLP_CMDW_CONFIGURE_PCI, fid);
 95}
 96EXPORT_SYMBOL(sclp_pci_configure);
 97
 98int sclp_pci_deconfigure(u32 fid)
 99{
100	return do_pci_configure(SCLP_CMDW_DECONFIGURE_PCI, fid);
101}
102EXPORT_SYMBOL(sclp_pci_deconfigure);
103
104static void sclp_pci_callback(struct sclp_req *req, void *data)
105{
106	struct completion *completion = data;
107
108	complete(completion);
109}
110
111static 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
132int 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
195out_free_req:
196	free_page((unsigned long) sccb);
197out_unregister:
198	sclp_unregister(&sclp_pci_event);
199out_unlock:
200	mutex_unlock(&sclp_pci_mutex);
201	return ret;
202}