cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sclp_pci.c (4287B)

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