ipmi_powernv.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * PowerNV OPAL IPMI driver
  4 *
  5 * Copyright 2014 IBM Corp.
  6 */
  7
  8#define pr_fmt(fmt)        "ipmi-powernv: " fmt
  9
 10#include <linux/ipmi_smi.h>
 11#include <linux/list.h>
 12#include <linux/module.h>
 13#include <linux/of.h>
 14#include <linux/of_irq.h>
 15#include <linux/interrupt.h>
 16
 17#include <asm/opal.h>
 18
 19
 20struct ipmi_smi_powernv {
 21	u64			interface_id;
 22	struct ipmi_smi		*intf;
 23	unsigned int		irq;
 24
 25	/**
 26	 * We assume that there can only be one outstanding request, so
 27	 * keep the pending message in cur_msg. We protect this from concurrent
 28	 * updates through send & recv calls, (and consequently opal_msg, which
 29	 * is in-use when cur_msg is set) with msg_lock
 30	 */
 31	spinlock_t		msg_lock;
 32	struct ipmi_smi_msg	*cur_msg;
 33	struct opal_ipmi_msg	*opal_msg;
 34};
 35
 36static int ipmi_powernv_start_processing(void *send_info, struct ipmi_smi *intf)
 37{
 38	struct ipmi_smi_powernv *smi = send_info;
 39
 40	smi->intf = intf;
 41	return 0;
 42}
 43
 44static void send_error_reply(struct ipmi_smi_powernv *smi,
 45		struct ipmi_smi_msg *msg, u8 completion_code)
 46{
 47	msg->rsp[0] = msg->data[0] | 0x4;
 48	msg->rsp[1] = msg->data[1];
 49	msg->rsp[2] = completion_code;
 50	msg->rsp_size = 3;
 51	ipmi_smi_msg_received(smi->intf, msg);
 52}
 53
 54static int ipmi_powernv_send(void *send_info, struct ipmi_smi_msg *msg)
 55{
 56	struct ipmi_smi_powernv *smi = send_info;
 57	struct opal_ipmi_msg *opal_msg;
 58	unsigned long flags;
 59	int comp, rc;
 60	size_t size;
 61
 62	/* ensure data_len will fit in the opal_ipmi_msg buffer... */
 63	if (msg->data_size > IPMI_MAX_MSG_LENGTH) {
 64		comp = IPMI_REQ_LEN_EXCEEDED_ERR;
 65		goto err;
 66	}
 67
 68	/* ... and that we at least have netfn and cmd bytes */
 69	if (msg->data_size < 2) {
 70		comp = IPMI_REQ_LEN_INVALID_ERR;
 71		goto err;
 72	}
 73
 74	spin_lock_irqsave(&smi->msg_lock, flags);
 75
 76	if (smi->cur_msg) {
 77		comp = IPMI_NODE_BUSY_ERR;
 78		goto err_unlock;
 79	}
 80
 81	/* format our data for the OPAL API */
 82	opal_msg = smi->opal_msg;
 83	opal_msg->version = OPAL_IPMI_MSG_FORMAT_VERSION_1;
 84	opal_msg->netfn = msg->data[0];
 85	opal_msg->cmd = msg->data[1];
 86	if (msg->data_size > 2)
 87		memcpy(opal_msg->data, msg->data + 2, msg->data_size - 2);
 88
 89	/* data_size already includes the netfn and cmd bytes */
 90	size = sizeof(*opal_msg) + msg->data_size - 2;
 91
 92	pr_devel("%s: opal_ipmi_send(0x%llx, %p, %ld)\n", __func__,
 93			smi->interface_id, opal_msg, size);
 94	rc = opal_ipmi_send(smi->interface_id, opal_msg, size);
 95	pr_devel("%s:  -> %d\n", __func__, rc);
 96	if (rc) {
 97		comp = IPMI_ERR_UNSPECIFIED;
 98		goto err_unlock;
 99	}
100
101	smi->cur_msg = msg;
102	spin_unlock_irqrestore(&smi->msg_lock, flags);
103	return IPMI_CC_NO_ERROR;
104
105err_unlock:
106	spin_unlock_irqrestore(&smi->msg_lock, flags);
107err:
108	return comp;
109}
110
111static int ipmi_powernv_recv(struct ipmi_smi_powernv *smi)
112{
113	struct opal_ipmi_msg *opal_msg;
114	struct ipmi_smi_msg *msg;
115	unsigned long flags;
116	uint64_t size;
117	int rc;
118
119	pr_devel("%s: opal_ipmi_recv(%llx, msg, sz)\n", __func__,
120			smi->interface_id);
121
122	spin_lock_irqsave(&smi->msg_lock, flags);
123
124	if (!smi->cur_msg) {
125		spin_unlock_irqrestore(&smi->msg_lock, flags);
126		pr_warn("no current message?\n");
127		return 0;
128	}
129
130	msg = smi->cur_msg;
131	opal_msg = smi->opal_msg;
132
133	size = cpu_to_be64(sizeof(*opal_msg) + IPMI_MAX_MSG_LENGTH);
134
135	rc = opal_ipmi_recv(smi->interface_id,
136			opal_msg,
137			&size);
138	size = be64_to_cpu(size);
139	pr_devel("%s:   -> %d (size %lld)\n", __func__,
140			rc, rc == 0 ? size : 0);
141	if (rc) {
142		/* If came via the poll, and response was not yet ready */
143		if (rc == OPAL_EMPTY) {
144			spin_unlock_irqrestore(&smi->msg_lock, flags);
145			return 0;
146		}
147
148		smi->cur_msg = NULL;
149		spin_unlock_irqrestore(&smi->msg_lock, flags);
150		send_error_reply(smi, msg, IPMI_ERR_UNSPECIFIED);
151		return 0;
152	}
153
154	if (size < sizeof(*opal_msg)) {
155		spin_unlock_irqrestore(&smi->msg_lock, flags);
156		pr_warn("unexpected IPMI message size %lld\n", size);
157		return 0;
158	}
159
160	if (opal_msg->version != OPAL_IPMI_MSG_FORMAT_VERSION_1) {
161		spin_unlock_irqrestore(&smi->msg_lock, flags);
162		pr_warn("unexpected IPMI message format (version %d)\n",
163				opal_msg->version);
164		return 0;
165	}
166
167	msg->rsp[0] = opal_msg->netfn;
168	msg->rsp[1] = opal_msg->cmd;
169	if (size > sizeof(*opal_msg))
170		memcpy(&msg->rsp[2], opal_msg->data, size - sizeof(*opal_msg));
171	msg->rsp_size = 2 + size - sizeof(*opal_msg);
172
173	smi->cur_msg = NULL;
174	spin_unlock_irqrestore(&smi->msg_lock, flags);
175	ipmi_smi_msg_received(smi->intf, msg);
176	return 0;
177}
178
179static void ipmi_powernv_request_events(void *send_info)
180{
181}
182
183static void ipmi_powernv_set_run_to_completion(void *send_info,
184		bool run_to_completion)
185{
186}
187
188static void ipmi_powernv_poll(void *send_info)
189{
190	struct ipmi_smi_powernv *smi = send_info;
191
192	ipmi_powernv_recv(smi);
193}
194
195static const struct ipmi_smi_handlers ipmi_powernv_smi_handlers = {
196	.owner			= THIS_MODULE,
197	.start_processing	= ipmi_powernv_start_processing,
198	.sender			= ipmi_powernv_send,
199	.request_events		= ipmi_powernv_request_events,
200	.set_run_to_completion	= ipmi_powernv_set_run_to_completion,
201	.poll			= ipmi_powernv_poll,
202};
203
204static irqreturn_t ipmi_opal_event(int irq, void *data)
205{
206	struct ipmi_smi_powernv *smi = data;
207
208	ipmi_powernv_recv(smi);
209	return IRQ_HANDLED;
210}
211
212static int ipmi_powernv_probe(struct platform_device *pdev)
213{
214	struct ipmi_smi_powernv *ipmi;
215	struct device *dev;
216	u32 prop;
217	int rc;
218
219	if (!pdev || !pdev->dev.of_node)
220		return -ENODEV;
221
222	dev = &pdev->dev;
223
224	ipmi = devm_kzalloc(dev, sizeof(*ipmi), GFP_KERNEL);
225	if (!ipmi)
226		return -ENOMEM;
227
228	spin_lock_init(&ipmi->msg_lock);
229
230	rc = of_property_read_u32(dev->of_node, "ibm,ipmi-interface-id",
231			&prop);
232	if (rc) {
233		dev_warn(dev, "No interface ID property\n");
234		goto err_free;
235	}
236	ipmi->interface_id = prop;
237
238	rc = of_property_read_u32(dev->of_node, "interrupts", &prop);
239	if (rc) {
240		dev_warn(dev, "No interrupts property\n");
241		goto err_free;
242	}
243
244	ipmi->irq = irq_of_parse_and_map(dev->of_node, 0);
245	if (!ipmi->irq) {
246		dev_info(dev, "Unable to map irq from device tree\n");
247		ipmi->irq = opal_event_request(prop);
248	}
249
250	rc = request_irq(ipmi->irq, ipmi_opal_event, IRQ_TYPE_LEVEL_HIGH,
251			 "opal-ipmi", ipmi);
252	if (rc) {
253		dev_warn(dev, "Unable to request irq\n");
254		goto err_dispose;
255	}
256
257	ipmi->opal_msg = devm_kmalloc(dev,
258			sizeof(*ipmi->opal_msg) + IPMI_MAX_MSG_LENGTH,
259			GFP_KERNEL);
260	if (!ipmi->opal_msg) {
261		rc = -ENOMEM;
262		goto err_unregister;
263	}
264
265	rc = ipmi_register_smi(&ipmi_powernv_smi_handlers, ipmi, dev, 0);
266	if (rc) {
267		dev_warn(dev, "IPMI SMI registration failed (%d)\n", rc);
268		goto err_free_msg;
269	}
270
271	dev_set_drvdata(dev, ipmi);
272	return 0;
273
274err_free_msg:
275	devm_kfree(dev, ipmi->opal_msg);
276err_unregister:
277	free_irq(ipmi->irq, ipmi);
278err_dispose:
279	irq_dispose_mapping(ipmi->irq);
280err_free:
281	devm_kfree(dev, ipmi);
282	return rc;
283}
284
285static void ipmi_powernv_remove(struct platform_device *pdev)
286{
287	struct ipmi_smi_powernv *smi = dev_get_drvdata(&pdev->dev);
288
289	ipmi_unregister_smi(smi->intf);
290	free_irq(smi->irq, smi);
291	irq_dispose_mapping(smi->irq);
292}
293
294static const struct of_device_id ipmi_powernv_match[] = {
295	{ .compatible = "ibm,opal-ipmi" },
296	{ },
297};
298
299
300static struct platform_driver powernv_ipmi_driver = {
301	.driver = {
302		.name		= "ipmi-powernv",
303		.of_match_table	= ipmi_powernv_match,
304	},
305	.probe	= ipmi_powernv_probe,
306	.remove = ipmi_powernv_remove,
307};
308
309
310module_platform_driver(powernv_ipmi_driver);
311
312MODULE_DEVICE_TABLE(of, ipmi_powernv_match);
313MODULE_DESCRIPTION("powernv IPMI driver");
314MODULE_AUTHOR("Jeremy Kerr <jk@ozlabs.org>");
315MODULE_LICENSE("GPL");