xref: /openbmc/linux/drivers/char/ipmi/ipmi_ipmb.c (revision e64c82b8)
1 // SPDX-License-Identifier: GPL-2.0
2 
3 /*
4  * Driver to talk to a remote management controller on IPMB.
5  */
6 
7 #include <linux/acpi.h>
8 #include <linux/errno.h>
9 #include <linux/i2c.h>
10 #include <linux/miscdevice.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/poll.h>
14 #include <linux/slab.h>
15 #include <linux/spinlock.h>
16 #include <linux/semaphore.h>
17 #include <linux/kthread.h>
18 #include <linux/wait.h>
19 #include <linux/ipmi_msgdefs.h>
20 #include <linux/ipmi_smi.h>
21 
22 #define DEVICE_NAME "ipmi-ipmb"
23 
24 static int bmcaddr = 0x20;
25 module_param(bmcaddr, int, 0644);
26 MODULE_PARM_DESC(bmcaddr, "Address to use for BMC.");
27 
28 static unsigned int retry_time_ms = 250;
29 module_param(retry_time_ms, uint, 0644);
30 MODULE_PARM_DESC(retry_time_ms, "Timeout time between retries, in milliseconds.");
31 
32 static unsigned int max_retries = 1;
33 module_param(max_retries, uint, 0644);
34 MODULE_PARM_DESC(max_retries, "Max resends of a command before timing out.");
35 
36 /* Add room for the two slave addresses, two checksums, and rqSeq. */
37 #define IPMB_MAX_MSG_LEN (IPMI_MAX_MSG_LENGTH + 5)
38 
39 struct ipmi_ipmb_dev {
40 	struct ipmi_smi *intf;
41 	struct i2c_client *client;
42 	struct i2c_client *slave;
43 
44 	struct ipmi_smi_handlers handlers;
45 
46 	bool ready;
47 
48 	u8 curr_seq;
49 
50 	u8 bmcaddr;
51 	u32 retry_time_ms;
52 	u32 max_retries;
53 
54 	struct ipmi_smi_msg *next_msg;
55 	struct ipmi_smi_msg *working_msg;
56 
57 	/* Transmit thread. */
58 	struct task_struct *thread;
59 	struct semaphore wake_thread;
60 	struct semaphore got_rsp;
61 	spinlock_t lock;
62 	bool stopping;
63 
64 	u8 xmitmsg[IPMB_MAX_MSG_LEN];
65 	unsigned int xmitlen;
66 
67 	u8 rcvmsg[IPMB_MAX_MSG_LEN];
68 	unsigned int rcvlen;
69 	bool overrun;
70 };
71 
valid_ipmb(struct ipmi_ipmb_dev * iidev)72 static bool valid_ipmb(struct ipmi_ipmb_dev *iidev)
73 {
74 	u8 *msg = iidev->rcvmsg;
75 	u8 netfn;
76 
77 	if (iidev->overrun)
78 		return false;
79 
80 	/* Minimum message size. */
81 	if (iidev->rcvlen < 7)
82 		return false;
83 
84 	/* Is it a response? */
85 	netfn = msg[1] >> 2;
86 	if (netfn & 1) {
87 		/* Response messages have an added completion code. */
88 		if (iidev->rcvlen < 8)
89 			return false;
90 	}
91 
92 	if (ipmb_checksum(msg, 3) != 0)
93 		return false;
94 	if (ipmb_checksum(msg + 3, iidev->rcvlen - 3) != 0)
95 		return false;
96 
97 	return true;
98 }
99 
ipmi_ipmb_check_msg_done(struct ipmi_ipmb_dev * iidev)100 static void ipmi_ipmb_check_msg_done(struct ipmi_ipmb_dev *iidev)
101 {
102 	struct ipmi_smi_msg *imsg = NULL;
103 	u8 *msg = iidev->rcvmsg;
104 	bool is_cmd;
105 	unsigned long flags;
106 
107 	if (iidev->rcvlen == 0)
108 		return;
109 	if (!valid_ipmb(iidev))
110 		goto done;
111 
112 	is_cmd = ((msg[1] >> 2) & 1) == 0;
113 
114 	if (is_cmd) {
115 		/* Ignore commands until we are up. */
116 		if (!iidev->ready)
117 			goto done;
118 
119 		/* It's a command, allocate a message for it. */
120 		imsg = ipmi_alloc_smi_msg();
121 		if (!imsg)
122 			goto done;
123 		imsg->type = IPMI_SMI_MSG_TYPE_IPMB_DIRECT;
124 		imsg->data_size = 0;
125 	} else {
126 		spin_lock_irqsave(&iidev->lock, flags);
127 		if (iidev->working_msg) {
128 			u8 seq = msg[4] >> 2;
129 			bool xmit_rsp = (iidev->working_msg->data[0] >> 2) & 1;
130 
131 			/*
132 			 * Responses should carry the sequence we sent
133 			 * them with.  If it's a transmitted response,
134 			 * ignore it.  And if the message hasn't been
135 			 * transmitted, ignore it.
136 			 */
137 			if (!xmit_rsp && seq == iidev->curr_seq) {
138 				iidev->curr_seq = (iidev->curr_seq + 1) & 0x3f;
139 
140 				imsg = iidev->working_msg;
141 				iidev->working_msg = NULL;
142 			}
143 		}
144 		spin_unlock_irqrestore(&iidev->lock, flags);
145 	}
146 
147 	if (!imsg)
148 		goto done;
149 
150 	if (imsg->type == IPMI_SMI_MSG_TYPE_IPMB_DIRECT) {
151 		imsg->rsp[0] = msg[1]; /* NetFn/LUN */
152 		/*
153 		 * Keep the source address, rqSeq.  Drop the trailing
154 		 * checksum.
155 		 */
156 		memcpy(imsg->rsp + 1, msg + 3, iidev->rcvlen - 4);
157 		imsg->rsp_size = iidev->rcvlen - 3;
158 	} else {
159 		imsg->rsp[0] = msg[1]; /* NetFn/LUN */
160 		/*
161 		 * Skip the source address, rqSeq.  Drop the trailing
162 		 * checksum.
163 		 */
164 		memcpy(imsg->rsp + 1, msg + 5, iidev->rcvlen - 6);
165 		imsg->rsp_size = iidev->rcvlen - 5;
166 	}
167 	ipmi_smi_msg_received(iidev->intf, imsg);
168 	if (!is_cmd)
169 		up(&iidev->got_rsp);
170 
171 done:
172 	iidev->overrun = false;
173 	iidev->rcvlen = 0;
174 }
175 
176 /*
177  * The IPMB protocol only supports i2c writes so there is no need to
178  * support I2C_SLAVE_READ* events, except to know if the other end has
179  * issued a read without going to stop mode.
180  */
ipmi_ipmb_slave_cb(struct i2c_client * client,enum i2c_slave_event event,u8 * val)181 static int ipmi_ipmb_slave_cb(struct i2c_client *client,
182 			      enum i2c_slave_event event, u8 *val)
183 {
184 	struct ipmi_ipmb_dev *iidev = i2c_get_clientdata(client);
185 
186 	switch (event) {
187 	case I2C_SLAVE_WRITE_REQUESTED:
188 		ipmi_ipmb_check_msg_done(iidev);
189 		/*
190 		 * First byte is the slave address, to ease the checksum
191 		 * calculation.
192 		 */
193 		iidev->rcvmsg[0] = client->addr << 1;
194 		iidev->rcvlen = 1;
195 		break;
196 
197 	case I2C_SLAVE_WRITE_RECEIVED:
198 		if (iidev->rcvlen >= sizeof(iidev->rcvmsg))
199 			iidev->overrun = true;
200 		else
201 			iidev->rcvmsg[iidev->rcvlen++] = *val;
202 		break;
203 
204 	case I2C_SLAVE_READ_REQUESTED:
205 	case I2C_SLAVE_STOP:
206 		ipmi_ipmb_check_msg_done(iidev);
207 		break;
208 
209 	case I2C_SLAVE_READ_PROCESSED:
210 		break;
211 	}
212 
213 	return 0;
214 }
215 
ipmi_ipmb_send_response(struct ipmi_ipmb_dev * iidev,struct ipmi_smi_msg * msg,u8 cc)216 static void ipmi_ipmb_send_response(struct ipmi_ipmb_dev *iidev,
217 				    struct ipmi_smi_msg *msg, u8 cc)
218 {
219 	if ((msg->data[0] >> 2) & 1) {
220 		/*
221 		 * It's a response being sent, we need to return a
222 		 * response to the response.  Fake a send msg command
223 		 * response with channel 0.  This will always be ipmb
224 		 * direct.
225 		 */
226 		msg->data[0] = (IPMI_NETFN_APP_REQUEST | 1) << 2;
227 		msg->data[3] = IPMI_SEND_MSG_CMD;
228 		msg->data[4] = cc;
229 		msg->data_size = 5;
230 	}
231 	msg->rsp[0] = msg->data[0] | (1 << 2);
232 	if (msg->type == IPMI_SMI_MSG_TYPE_IPMB_DIRECT) {
233 		msg->rsp[1] = msg->data[1];
234 		msg->rsp[2] = msg->data[2];
235 		msg->rsp[3] = msg->data[3];
236 		msg->rsp[4] = cc;
237 		msg->rsp_size = 5;
238 	} else {
239 		msg->rsp[1] = msg->data[1];
240 		msg->rsp[2] = cc;
241 		msg->rsp_size = 3;
242 	}
243 	ipmi_smi_msg_received(iidev->intf, msg);
244 }
245 
ipmi_ipmb_format_for_xmit(struct ipmi_ipmb_dev * iidev,struct ipmi_smi_msg * msg)246 static void ipmi_ipmb_format_for_xmit(struct ipmi_ipmb_dev *iidev,
247 				      struct ipmi_smi_msg *msg)
248 {
249 	if (msg->type == IPMI_SMI_MSG_TYPE_IPMB_DIRECT) {
250 		iidev->xmitmsg[0] = msg->data[1];
251 		iidev->xmitmsg[1] = msg->data[0];
252 		memcpy(iidev->xmitmsg + 4, msg->data + 2, msg->data_size - 2);
253 		iidev->xmitlen = msg->data_size + 2;
254 	} else {
255 		iidev->xmitmsg[0] = iidev->bmcaddr;
256 		iidev->xmitmsg[1] = msg->data[0];
257 		iidev->xmitmsg[4] = 0;
258 		memcpy(iidev->xmitmsg + 5, msg->data + 1, msg->data_size - 1);
259 		iidev->xmitlen = msg->data_size + 4;
260 	}
261 	iidev->xmitmsg[3] = iidev->slave->addr << 1;
262 	if (((msg->data[0] >> 2) & 1) == 0)
263 		/* If it's a command, put in our own sequence number. */
264 		iidev->xmitmsg[4] = ((iidev->xmitmsg[4] & 0x03) |
265 				     (iidev->curr_seq << 2));
266 
267 	/* Now add on the final checksums. */
268 	iidev->xmitmsg[2] = ipmb_checksum(iidev->xmitmsg, 2);
269 	iidev->xmitmsg[iidev->xmitlen] =
270 		ipmb_checksum(iidev->xmitmsg + 3, iidev->xmitlen - 3);
271 	iidev->xmitlen++;
272 }
273 
ipmi_ipmb_thread(void * data)274 static int ipmi_ipmb_thread(void *data)
275 {
276 	struct ipmi_ipmb_dev *iidev = data;
277 
278 	while (!kthread_should_stop()) {
279 		long ret;
280 		struct i2c_msg i2c_msg;
281 		struct ipmi_smi_msg *msg = NULL;
282 		unsigned long flags;
283 		unsigned int retries = 0;
284 
285 		/* Wait for a message to send */
286 		ret = down_interruptible(&iidev->wake_thread);
287 		if (iidev->stopping)
288 			break;
289 		if (ret)
290 			continue;
291 
292 		spin_lock_irqsave(&iidev->lock, flags);
293 		if (iidev->next_msg) {
294 			msg = iidev->next_msg;
295 			iidev->next_msg = NULL;
296 		}
297 		spin_unlock_irqrestore(&iidev->lock, flags);
298 		if (!msg)
299 			continue;
300 
301 		ipmi_ipmb_format_for_xmit(iidev, msg);
302 
303 retry:
304 		i2c_msg.len = iidev->xmitlen - 1;
305 		if (i2c_msg.len > 32) {
306 			ipmi_ipmb_send_response(iidev, msg,
307 						IPMI_REQ_LEN_EXCEEDED_ERR);
308 			continue;
309 		}
310 
311 		i2c_msg.addr = iidev->xmitmsg[0] >> 1;
312 		i2c_msg.flags = 0;
313 		i2c_msg.buf = iidev->xmitmsg + 1;
314 
315 		/* Rely on i2c_transfer for a barrier. */
316 		iidev->working_msg = msg;
317 
318 		ret = i2c_transfer(iidev->client->adapter, &i2c_msg, 1);
319 
320 		if ((msg->data[0] >> 2) & 1) {
321 			/*
322 			 * It's a response, nothing will be returned
323 			 * by the other end.
324 			 */
325 
326 			iidev->working_msg = NULL;
327 			ipmi_ipmb_send_response(iidev, msg,
328 						ret < 0 ? IPMI_BUS_ERR : 0);
329 			continue;
330 		}
331 		if (ret < 0) {
332 			iidev->working_msg = NULL;
333 			ipmi_ipmb_send_response(iidev, msg, IPMI_BUS_ERR);
334 			continue;
335 		}
336 
337 		/* A command was sent, wait for its response. */
338 		ret = down_timeout(&iidev->got_rsp,
339 				   msecs_to_jiffies(iidev->retry_time_ms));
340 
341 		/*
342 		 * Grab the message if we can.  If the handler hasn't
343 		 * already handled it, the message will still be there.
344 		 */
345 		spin_lock_irqsave(&iidev->lock, flags);
346 		msg = iidev->working_msg;
347 		iidev->working_msg = NULL;
348 		spin_unlock_irqrestore(&iidev->lock, flags);
349 
350 		if (!msg && ret) {
351 			/*
352 			 * If working_msg is not set and we timed out,
353 			 * that means the message grabbed by
354 			 * check_msg_done before we could grab it
355 			 * here.  Wait again for check_msg_done to up
356 			 * the semaphore.
357 			 */
358 			down(&iidev->got_rsp);
359 		} else if (msg && ++retries <= iidev->max_retries) {
360 			spin_lock_irqsave(&iidev->lock, flags);
361 			iidev->working_msg = msg;
362 			spin_unlock_irqrestore(&iidev->lock, flags);
363 			goto retry;
364 		}
365 
366 		if (msg)
367 			ipmi_ipmb_send_response(iidev, msg, IPMI_TIMEOUT_ERR);
368 	}
369 
370 	if (iidev->next_msg)
371 		/* Return an unspecified error. */
372 		ipmi_ipmb_send_response(iidev, iidev->next_msg, 0xff);
373 
374 	return 0;
375 }
376 
ipmi_ipmb_start_processing(void * send_info,struct ipmi_smi * new_intf)377 static int ipmi_ipmb_start_processing(void *send_info,
378 				      struct ipmi_smi *new_intf)
379 {
380 	struct ipmi_ipmb_dev *iidev = send_info;
381 
382 	iidev->intf = new_intf;
383 	iidev->ready = true;
384 	return 0;
385 }
386 
ipmi_ipmb_stop_thread(struct ipmi_ipmb_dev * iidev)387 static void ipmi_ipmb_stop_thread(struct ipmi_ipmb_dev *iidev)
388 {
389 	if (iidev->thread) {
390 		struct task_struct *t = iidev->thread;
391 
392 		iidev->thread = NULL;
393 		iidev->stopping = true;
394 		up(&iidev->wake_thread);
395 		up(&iidev->got_rsp);
396 		kthread_stop(t);
397 	}
398 }
399 
ipmi_ipmb_shutdown(void * send_info)400 static void ipmi_ipmb_shutdown(void *send_info)
401 {
402 	struct ipmi_ipmb_dev *iidev = send_info;
403 
404 	ipmi_ipmb_stop_thread(iidev);
405 }
406 
ipmi_ipmb_sender(void * send_info,struct ipmi_smi_msg * msg)407 static void ipmi_ipmb_sender(void *send_info,
408 			     struct ipmi_smi_msg *msg)
409 {
410 	struct ipmi_ipmb_dev *iidev = send_info;
411 	unsigned long flags;
412 
413 	spin_lock_irqsave(&iidev->lock, flags);
414 	BUG_ON(iidev->next_msg);
415 
416 	iidev->next_msg = msg;
417 	spin_unlock_irqrestore(&iidev->lock, flags);
418 
419 	up(&iidev->wake_thread);
420 }
421 
ipmi_ipmb_request_events(void * send_info)422 static void ipmi_ipmb_request_events(void *send_info)
423 {
424 	/* We don't fetch events here. */
425 }
426 
ipmi_ipmb_cleanup(struct ipmi_ipmb_dev * iidev)427 static void ipmi_ipmb_cleanup(struct ipmi_ipmb_dev *iidev)
428 {
429 	if (iidev->slave) {
430 		i2c_slave_unregister(iidev->slave);
431 		if (iidev->slave != iidev->client)
432 			i2c_unregister_device(iidev->slave);
433 	}
434 	iidev->slave = NULL;
435 	iidev->client = NULL;
436 	ipmi_ipmb_stop_thread(iidev);
437 }
438 
ipmi_ipmb_remove(struct i2c_client * client)439 static void ipmi_ipmb_remove(struct i2c_client *client)
440 {
441 	struct ipmi_ipmb_dev *iidev = i2c_get_clientdata(client);
442 
443 	ipmi_ipmb_cleanup(iidev);
444 	ipmi_unregister_smi(iidev->intf);
445 }
446 
ipmi_ipmb_probe(struct i2c_client * client)447 static int ipmi_ipmb_probe(struct i2c_client *client)
448 {
449 	struct device *dev = &client->dev;
450 	struct ipmi_ipmb_dev *iidev;
451 	struct device_node *slave_np;
452 	struct i2c_adapter *slave_adap = NULL;
453 	struct i2c_client *slave = NULL;
454 	int rv;
455 
456 	iidev = devm_kzalloc(&client->dev, sizeof(*iidev), GFP_KERNEL);
457 	if (!iidev)
458 		return -ENOMEM;
459 
460 	if (of_property_read_u8(dev->of_node, "bmcaddr", &iidev->bmcaddr) != 0)
461 		iidev->bmcaddr = bmcaddr;
462 	if (iidev->bmcaddr == 0 || iidev->bmcaddr & 1) {
463 		/* Can't have the write bit set. */
464 		dev_notice(&client->dev,
465 			   "Invalid bmc address value %2.2x\n", iidev->bmcaddr);
466 		return -EINVAL;
467 	}
468 
469 	if (of_property_read_u32(dev->of_node, "retry-time",
470 				 &iidev->retry_time_ms) != 0)
471 		iidev->retry_time_ms = retry_time_ms;
472 
473 	if (of_property_read_u32(dev->of_node, "max-retries",
474 				 &iidev->max_retries) != 0)
475 		iidev->max_retries = max_retries;
476 
477 	slave_np = of_parse_phandle(dev->of_node, "slave-dev", 0);
478 	if (slave_np) {
479 		slave_adap = of_get_i2c_adapter_by_node(slave_np);
480 		of_node_put(slave_np);
481 		if (!slave_adap) {
482 			dev_notice(&client->dev,
483 				   "Could not find slave adapter\n");
484 			return -EINVAL;
485 		}
486 	}
487 
488 	iidev->client = client;
489 
490 	if (slave_adap) {
491 		struct i2c_board_info binfo;
492 
493 		memset(&binfo, 0, sizeof(binfo));
494 		strscpy(binfo.type, "ipmb-slave", I2C_NAME_SIZE);
495 		binfo.addr = client->addr;
496 		binfo.flags = I2C_CLIENT_SLAVE;
497 		slave = i2c_new_client_device(slave_adap, &binfo);
498 		i2c_put_adapter(slave_adap);
499 		if (IS_ERR(slave)) {
500 			rv = PTR_ERR(slave);
501 			dev_notice(&client->dev,
502 				   "Could not allocate slave device: %d\n", rv);
503 			return rv;
504 		}
505 		i2c_set_clientdata(slave, iidev);
506 	} else {
507 		slave = client;
508 	}
509 	i2c_set_clientdata(client, iidev);
510 	slave->flags |= I2C_CLIENT_SLAVE;
511 
512 	rv = i2c_slave_register(slave, ipmi_ipmb_slave_cb);
513 	if (rv)
514 		goto out_err;
515 	iidev->slave = slave;
516 	slave = NULL;
517 
518 	iidev->handlers.flags = IPMI_SMI_CAN_HANDLE_IPMB_DIRECT;
519 	iidev->handlers.start_processing = ipmi_ipmb_start_processing;
520 	iidev->handlers.shutdown = ipmi_ipmb_shutdown;
521 	iidev->handlers.sender = ipmi_ipmb_sender;
522 	iidev->handlers.request_events = ipmi_ipmb_request_events;
523 
524 	spin_lock_init(&iidev->lock);
525 	sema_init(&iidev->wake_thread, 0);
526 	sema_init(&iidev->got_rsp, 0);
527 
528 	iidev->thread = kthread_run(ipmi_ipmb_thread, iidev,
529 				    "kipmb%4.4x", client->addr);
530 	if (IS_ERR(iidev->thread)) {
531 		rv = PTR_ERR(iidev->thread);
532 		dev_notice(&client->dev,
533 			   "Could not start kernel thread: error %d\n", rv);
534 		goto out_err;
535 	}
536 
537 	rv = ipmi_register_smi(&iidev->handlers,
538 			       iidev,
539 			       &client->dev,
540 			       iidev->bmcaddr);
541 	if (rv)
542 		goto out_err;
543 
544 	return 0;
545 
546 out_err:
547 	if (slave && slave != client)
548 		i2c_unregister_device(slave);
549 	ipmi_ipmb_cleanup(iidev);
550 	return rv;
551 }
552 
553 #ifdef CONFIG_OF
554 static const struct of_device_id of_ipmi_ipmb_match[] = {
555 	{ .type = "ipmi", .compatible = DEVICE_NAME },
556 	{},
557 };
558 MODULE_DEVICE_TABLE(of, of_ipmi_ipmb_match);
559 #else
560 #define of_ipmi_ipmb_match NULL
561 #endif
562 
563 static const struct i2c_device_id ipmi_ipmb_id[] = {
564 	{ DEVICE_NAME, 0 },
565 	{},
566 };
567 MODULE_DEVICE_TABLE(i2c, ipmi_ipmb_id);
568 
569 static struct i2c_driver ipmi_ipmb_driver = {
570 	.class		= I2C_CLASS_HWMON,
571 	.driver = {
572 		.name = DEVICE_NAME,
573 		.of_match_table = of_ipmi_ipmb_match,
574 	},
575 	.probe		= ipmi_ipmb_probe,
576 	.remove		= ipmi_ipmb_remove,
577 	.id_table	= ipmi_ipmb_id,
578 };
579 module_i2c_driver(ipmi_ipmb_driver);
580 
581 MODULE_AUTHOR("Corey Minyard");
582 MODULE_DESCRIPTION("IPMI IPMB driver");
583 MODULE_LICENSE("GPL v2");
584