1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * The driver for BMC side of SSIF interface
4 *
5 * Copyright (c) 2022, Ampere Computing LLC
6 *
7 */
8
9 #include <linux/i2c.h>
10 #include <linux/miscdevice.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/platform_device.h>
14 #include <linux/poll.h>
15 #include <linux/sched.h>
16 #include <linux/mutex.h>
17 #include <linux/spinlock.h>
18 #include <linux/timer.h>
19 #include <linux/jiffies.h>
20 #include <linux/ipmi_ssif_bmc.h>
21
22 #define DEVICE_NAME "ipmi-ssif-host"
23
24 #define GET_8BIT_ADDR(addr_7bit) (((addr_7bit) << 1) & 0xff)
25
26 /* A standard SMBus Transaction is limited to 32 data bytes */
27 #define MAX_PAYLOAD_PER_TRANSACTION 32
28 /* Transaction includes the address, the command, the length and the PEC byte */
29 #define MAX_TRANSACTION (MAX_PAYLOAD_PER_TRANSACTION + 4)
30
31 #define MAX_IPMI_DATA_PER_START_TRANSACTION 30
32 #define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION 31
33
34 #define SSIF_IPMI_SINGLEPART_WRITE 0x2
35 #define SSIF_IPMI_SINGLEPART_READ 0x3
36 #define SSIF_IPMI_MULTIPART_WRITE_START 0x6
37 #define SSIF_IPMI_MULTIPART_WRITE_MIDDLE 0x7
38 #define SSIF_IPMI_MULTIPART_WRITE_END 0x8
39 #define SSIF_IPMI_MULTIPART_READ_START 0x3
40 #define SSIF_IPMI_MULTIPART_READ_MIDDLE 0x9
41
42 /*
43 * IPMI 2.0 Spec, section 12.7 SSIF Timing,
44 * Request-to-Response Time is T6max(250ms) - T1max(20ms) - 3ms = 227ms
45 * Recover ssif_bmc from busy state if it takes up to 500ms
46 */
47 #define RESPONSE_TIMEOUT 500 /* ms */
48
49 struct ssif_part_buffer {
50 u8 address;
51 u8 smbus_cmd;
52 u8 length;
53 u8 payload[MAX_PAYLOAD_PER_TRANSACTION];
54 u8 pec;
55 u8 index;
56 };
57
58 /*
59 * SSIF internal states:
60 * SSIF_READY 0x00 : Ready state
61 * SSIF_START 0x01 : Start smbus transaction
62 * SSIF_SMBUS_CMD 0x02 : Received SMBus command
63 * SSIF_REQ_RECVING 0x03 : Receiving request
64 * SSIF_RES_SENDING 0x04 : Sending response
65 * SSIF_ABORTING 0x05 : Aborting state
66 */
67 enum ssif_state {
68 SSIF_READY,
69 SSIF_START,
70 SSIF_SMBUS_CMD,
71 SSIF_REQ_RECVING,
72 SSIF_RES_SENDING,
73 SSIF_ABORTING,
74 SSIF_STATE_MAX
75 };
76
77 struct ssif_bmc_ctx {
78 struct i2c_client *client;
79 struct miscdevice miscdev;
80 int msg_idx;
81 bool pec_support;
82 /* ssif bmc spinlock */
83 spinlock_t lock;
84 wait_queue_head_t wait_queue;
85 u8 running;
86 enum ssif_state state;
87 /* Timeout waiting for response */
88 struct timer_list response_timer;
89 bool response_timer_inited;
90 /* Flag to identify a Multi-part Read Transaction */
91 bool is_singlepart_read;
92 u8 nbytes_processed;
93 u8 remain_len;
94 u8 recv_len;
95 /* Block Number of a Multi-part Read Transaction */
96 u8 block_num;
97 bool request_available;
98 bool response_in_progress;
99 bool busy;
100 bool aborting;
101 /* Buffer for SSIF Transaction part*/
102 struct ssif_part_buffer part_buf;
103 struct ipmi_ssif_msg response;
104 struct ipmi_ssif_msg request;
105 };
106
to_ssif_bmc(struct file * file)107 static inline struct ssif_bmc_ctx *to_ssif_bmc(struct file *file)
108 {
109 return container_of(file->private_data, struct ssif_bmc_ctx, miscdev);
110 }
111
state_to_string(enum ssif_state state)112 static const char *state_to_string(enum ssif_state state)
113 {
114 switch (state) {
115 case SSIF_READY:
116 return "SSIF_READY";
117 case SSIF_START:
118 return "SSIF_START";
119 case SSIF_SMBUS_CMD:
120 return "SSIF_SMBUS_CMD";
121 case SSIF_REQ_RECVING:
122 return "SSIF_REQ_RECVING";
123 case SSIF_RES_SENDING:
124 return "SSIF_RES_SENDING";
125 case SSIF_ABORTING:
126 return "SSIF_ABORTING";
127 default:
128 return "SSIF_STATE_UNKNOWN";
129 }
130 }
131
132 /* Handle SSIF message that will be sent to user */
ssif_bmc_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)133 static ssize_t ssif_bmc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
134 {
135 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
136 struct ipmi_ssif_msg msg;
137 unsigned long flags;
138 ssize_t ret;
139
140 spin_lock_irqsave(&ssif_bmc->lock, flags);
141 while (!ssif_bmc->request_available) {
142 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
143 if (file->f_flags & O_NONBLOCK)
144 return -EAGAIN;
145 ret = wait_event_interruptible(ssif_bmc->wait_queue,
146 ssif_bmc->request_available);
147 if (ret)
148 return ret;
149 spin_lock_irqsave(&ssif_bmc->lock, flags);
150 }
151
152 if (count < min_t(ssize_t,
153 sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
154 sizeof(struct ipmi_ssif_msg))) {
155 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
156 ret = -EINVAL;
157 } else {
158 count = min_t(ssize_t,
159 sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
160 sizeof(struct ipmi_ssif_msg));
161 memcpy(&msg, &ssif_bmc->request, count);
162 ssif_bmc->request_available = false;
163 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
164
165 ret = copy_to_user(buf, &msg, count);
166 }
167
168 return (ret < 0) ? ret : count;
169 }
170
171 /* Handle SSIF message that is written by user */
ssif_bmc_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)172 static ssize_t ssif_bmc_write(struct file *file, const char __user *buf, size_t count,
173 loff_t *ppos)
174 {
175 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
176 struct ipmi_ssif_msg msg;
177 unsigned long flags;
178 ssize_t ret;
179
180 if (count < sizeof(msg.len) ||
181 count > sizeof(struct ipmi_ssif_msg))
182 return -EINVAL;
183
184 if (copy_from_user(&msg, buf, count))
185 return -EFAULT;
186
187 if (!msg.len || msg.len > IPMI_SSIF_PAYLOAD_MAX ||
188 count < sizeof_field(struct ipmi_ssif_msg, len) + msg.len)
189 return -EINVAL;
190
191 spin_lock_irqsave(&ssif_bmc->lock, flags);
192 while (ssif_bmc->response_in_progress) {
193 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
194 if (file->f_flags & O_NONBLOCK)
195 return -EAGAIN;
196 ret = wait_event_interruptible(ssif_bmc->wait_queue,
197 !ssif_bmc->response_in_progress);
198 if (ret)
199 return ret;
200 spin_lock_irqsave(&ssif_bmc->lock, flags);
201 }
202
203 /*
204 * The write must complete before the response timeout fired, otherwise
205 * the response is aborted and wait for next request
206 * Return -EINVAL if the response is aborted
207 */
208 ret = (ssif_bmc->response_timer_inited) ? 0 : -EINVAL;
209 if (ret)
210 goto exit;
211
212 del_timer(&ssif_bmc->response_timer);
213 ssif_bmc->response_timer_inited = false;
214
215 memcpy(&ssif_bmc->response, &msg, count);
216 ssif_bmc->is_singlepart_read = (msg.len <= MAX_PAYLOAD_PER_TRANSACTION);
217
218 ssif_bmc->response_in_progress = true;
219
220 /* ssif_bmc not busy */
221 ssif_bmc->busy = false;
222
223 /* Clean old request buffer */
224 memset(&ssif_bmc->request, 0, sizeof(struct ipmi_ssif_msg));
225 exit:
226 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
227
228 return (ret < 0) ? ret : count;
229 }
230
ssif_bmc_open(struct inode * inode,struct file * file)231 static int ssif_bmc_open(struct inode *inode, struct file *file)
232 {
233 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
234 int ret = 0;
235
236 spin_lock_irq(&ssif_bmc->lock);
237 if (!ssif_bmc->running)
238 ssif_bmc->running = 1;
239 else
240 ret = -EBUSY;
241 spin_unlock_irq(&ssif_bmc->lock);
242
243 return ret;
244 }
245
ssif_bmc_poll(struct file * file,poll_table * wait)246 static __poll_t ssif_bmc_poll(struct file *file, poll_table *wait)
247 {
248 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
249 __poll_t mask = 0;
250
251 poll_wait(file, &ssif_bmc->wait_queue, wait);
252
253 spin_lock_irq(&ssif_bmc->lock);
254 /* The request is available, userspace application can get the request */
255 if (ssif_bmc->request_available)
256 mask |= EPOLLIN;
257
258 spin_unlock_irq(&ssif_bmc->lock);
259
260 return mask;
261 }
262
ssif_bmc_release(struct inode * inode,struct file * file)263 static int ssif_bmc_release(struct inode *inode, struct file *file)
264 {
265 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
266
267 spin_lock_irq(&ssif_bmc->lock);
268 ssif_bmc->running = 0;
269 spin_unlock_irq(&ssif_bmc->lock);
270
271 return 0;
272 }
273
274 /*
275 * System calls to device interface for user apps
276 */
277 static const struct file_operations ssif_bmc_fops = {
278 .owner = THIS_MODULE,
279 .open = ssif_bmc_open,
280 .read = ssif_bmc_read,
281 .write = ssif_bmc_write,
282 .release = ssif_bmc_release,
283 .poll = ssif_bmc_poll,
284 };
285
286 /* Called with ssif_bmc->lock held. */
complete_response(struct ssif_bmc_ctx * ssif_bmc)287 static void complete_response(struct ssif_bmc_ctx *ssif_bmc)
288 {
289 /* Invalidate response in buffer to denote it having been sent. */
290 ssif_bmc->response.len = 0;
291 ssif_bmc->response_in_progress = false;
292 ssif_bmc->nbytes_processed = 0;
293 ssif_bmc->remain_len = 0;
294 ssif_bmc->busy = false;
295 wake_up_all(&ssif_bmc->wait_queue);
296 }
297
response_timeout(struct timer_list * t)298 static void response_timeout(struct timer_list *t)
299 {
300 struct ssif_bmc_ctx *ssif_bmc = from_timer(ssif_bmc, t, response_timer);
301 unsigned long flags;
302
303 spin_lock_irqsave(&ssif_bmc->lock, flags);
304
305 /* Do nothing if the response is in progress */
306 if (!ssif_bmc->response_in_progress) {
307 /* Recover ssif_bmc from busy */
308 ssif_bmc->busy = false;
309 ssif_bmc->response_timer_inited = false;
310 /* Set aborting flag */
311 ssif_bmc->aborting = true;
312 }
313
314 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
315 }
316
317 /* Called with ssif_bmc->lock held. */
handle_request(struct ssif_bmc_ctx * ssif_bmc)318 static void handle_request(struct ssif_bmc_ctx *ssif_bmc)
319 {
320 /* set ssif_bmc to busy waiting for response */
321 ssif_bmc->busy = true;
322 /* Request message is available to process */
323 ssif_bmc->request_available = true;
324 /* Clean old response buffer */
325 memset(&ssif_bmc->response, 0, sizeof(struct ipmi_ssif_msg));
326 /* This is the new READ request.*/
327 wake_up_all(&ssif_bmc->wait_queue);
328
329 /* Armed timer to recover slave from busy state in case of no response */
330 if (!ssif_bmc->response_timer_inited) {
331 timer_setup(&ssif_bmc->response_timer, response_timeout, 0);
332 ssif_bmc->response_timer_inited = true;
333 }
334 mod_timer(&ssif_bmc->response_timer, jiffies + msecs_to_jiffies(RESPONSE_TIMEOUT));
335 }
336
calculate_response_part_pec(struct ssif_part_buffer * part)337 static void calculate_response_part_pec(struct ssif_part_buffer *part)
338 {
339 u8 addr = part->address;
340
341 /* PEC - Start Read Address */
342 part->pec = i2c_smbus_pec(0, &addr, 1);
343 /* PEC - SSIF Command */
344 part->pec = i2c_smbus_pec(part->pec, &part->smbus_cmd, 1);
345 /* PEC - Restart Write Address */
346 addr = addr | 0x01;
347 part->pec = i2c_smbus_pec(part->pec, &addr, 1);
348 part->pec = i2c_smbus_pec(part->pec, &part->length, 1);
349 if (part->length)
350 part->pec = i2c_smbus_pec(part->pec, part->payload, part->length);
351 }
352
set_singlepart_response_buffer(struct ssif_bmc_ctx * ssif_bmc)353 static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
354 {
355 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
356
357 part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
358 part->length = (u8)ssif_bmc->response.len;
359
360 /* Clear the rest to 0 */
361 memset(part->payload + part->length, 0, MAX_PAYLOAD_PER_TRANSACTION - part->length);
362 memcpy(&part->payload[0], &ssif_bmc->response.payload[0], part->length);
363 }
364
set_multipart_response_buffer(struct ssif_bmc_ctx * ssif_bmc)365 static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
366 {
367 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
368 u8 part_len = 0;
369
370 part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
371 switch (part->smbus_cmd) {
372 case SSIF_IPMI_MULTIPART_READ_START:
373 /*
374 * Read Start length is 32 bytes.
375 * Read Start transfer first 30 bytes of IPMI response
376 * and 2 special code 0x00, 0x01.
377 */
378 ssif_bmc->nbytes_processed = 0;
379 ssif_bmc->block_num = 0;
380 part->length = MAX_PAYLOAD_PER_TRANSACTION;
381 part_len = MAX_IPMI_DATA_PER_START_TRANSACTION;
382 ssif_bmc->remain_len = ssif_bmc->response.len - part_len;
383
384 part->payload[0] = 0x00; /* Start Flag */
385 part->payload[1] = 0x01; /* Start Flag */
386
387 memcpy(&part->payload[2], &ssif_bmc->response.payload[0], part_len);
388 break;
389
390 case SSIF_IPMI_MULTIPART_READ_MIDDLE:
391 /*
392 * IPMI READ Middle or READ End messages can carry up to 31 bytes
393 * IPMI data plus block number byte.
394 */
395 if (ssif_bmc->remain_len <= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) {
396 /*
397 * This is READ End message
398 * Return length is the remaining response data length
399 * plus block number
400 * Block number 0xFF is to indicate this is last message
401 *
402 */
403 /* Clean the buffer */
404 memset(&part->payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
405 part->length = ssif_bmc->remain_len + 1;
406 part_len = ssif_bmc->remain_len;
407 ssif_bmc->block_num = 0xFF;
408 part->payload[0] = ssif_bmc->block_num;
409 } else {
410 /*
411 * This is READ Middle message
412 * Response length is the maximum SMBUS transfer length
413 * Block number byte is incremented
414 * Return length is maximum SMBUS transfer length
415 */
416 part->length = MAX_PAYLOAD_PER_TRANSACTION;
417 part_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION;
418 part->payload[0] = ssif_bmc->block_num;
419 ssif_bmc->block_num++;
420 }
421
422 ssif_bmc->remain_len -= part_len;
423 memcpy(&part->payload[1], ssif_bmc->response.payload + ssif_bmc->nbytes_processed,
424 part_len);
425 break;
426
427 default:
428 /* Do not expect to go to this case */
429 dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
430 __func__, part->smbus_cmd);
431 break;
432 }
433
434 ssif_bmc->nbytes_processed += part_len;
435 }
436
supported_read_cmd(u8 cmd)437 static bool supported_read_cmd(u8 cmd)
438 {
439 if (cmd == SSIF_IPMI_SINGLEPART_READ ||
440 cmd == SSIF_IPMI_MULTIPART_READ_START ||
441 cmd == SSIF_IPMI_MULTIPART_READ_MIDDLE)
442 return true;
443
444 return false;
445 }
446
supported_write_cmd(u8 cmd)447 static bool supported_write_cmd(u8 cmd)
448 {
449 if (cmd == SSIF_IPMI_SINGLEPART_WRITE ||
450 cmd == SSIF_IPMI_MULTIPART_WRITE_START ||
451 cmd == SSIF_IPMI_MULTIPART_WRITE_MIDDLE ||
452 cmd == SSIF_IPMI_MULTIPART_WRITE_END)
453 return true;
454
455 return false;
456 }
457
458 /* Process the IPMI response that will be read by master */
handle_read_processed(struct ssif_bmc_ctx * ssif_bmc,u8 * val)459 static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
460 {
461 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
462
463 /* msg_idx start from 0 */
464 if (part->index < part->length)
465 *val = part->payload[part->index];
466 else if (part->index == part->length && ssif_bmc->pec_support)
467 *val = part->pec;
468 else
469 *val = 0;
470
471 part->index++;
472 }
473
handle_write_received(struct ssif_bmc_ctx * ssif_bmc,u8 * val)474 static void handle_write_received(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
475 {
476 /*
477 * The msg_idx must be 1 when first enter SSIF_REQ_RECVING state
478 * And it would never exceeded 36 bytes included the 32 bytes max payload +
479 * the address + the command + the len and the PEC.
480 */
481 if (ssif_bmc->msg_idx < 1 || ssif_bmc->msg_idx > MAX_TRANSACTION)
482 return;
483
484 if (ssif_bmc->msg_idx == 1) {
485 ssif_bmc->part_buf.length = *val;
486 ssif_bmc->part_buf.index = 0;
487 } else {
488 ssif_bmc->part_buf.payload[ssif_bmc->part_buf.index++] = *val;
489 }
490
491 ssif_bmc->msg_idx++;
492 }
493
validate_request_part(struct ssif_bmc_ctx * ssif_bmc)494 static bool validate_request_part(struct ssif_bmc_ctx *ssif_bmc)
495 {
496 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
497 bool ret = true;
498 u8 cpec;
499 u8 addr;
500
501 if (part->index == part->length) {
502 /* PEC is not included */
503 ssif_bmc->pec_support = false;
504 ret = true;
505 goto exit;
506 }
507
508 if (part->index != part->length + 1) {
509 ret = false;
510 goto exit;
511 }
512
513 /* PEC is included */
514 ssif_bmc->pec_support = true;
515 part->pec = part->payload[part->length];
516 addr = GET_8BIT_ADDR(ssif_bmc->client->addr);
517 cpec = i2c_smbus_pec(0, &addr, 1);
518 cpec = i2c_smbus_pec(cpec, &part->smbus_cmd, 1);
519 cpec = i2c_smbus_pec(cpec, &part->length, 1);
520 /*
521 * As SMBus specification does not allow the length
522 * (byte count) in the Write-Block protocol to be zero.
523 * Therefore, it is illegal to have the last Middle
524 * transaction in the sequence carry 32-byte and have
525 * a length of ‘0’ in the End transaction.
526 * But some users may try to use this way and we should
527 * prevent ssif_bmc driver broken in this case.
528 */
529 if (part->length)
530 cpec = i2c_smbus_pec(cpec, part->payload, part->length);
531
532 if (cpec != part->pec)
533 ret = false;
534
535 exit:
536 return ret;
537 }
538
process_request_part(struct ssif_bmc_ctx * ssif_bmc)539 static void process_request_part(struct ssif_bmc_ctx *ssif_bmc)
540 {
541 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
542 unsigned int len;
543
544 switch (part->smbus_cmd) {
545 case SSIF_IPMI_SINGLEPART_WRITE:
546 /* save the whole part to request*/
547 ssif_bmc->request.len = part->length;
548 memcpy(ssif_bmc->request.payload, part->payload, part->length);
549
550 break;
551 case SSIF_IPMI_MULTIPART_WRITE_START:
552 ssif_bmc->request.len = 0;
553
554 fallthrough;
555 case SSIF_IPMI_MULTIPART_WRITE_MIDDLE:
556 case SSIF_IPMI_MULTIPART_WRITE_END:
557 len = ssif_bmc->request.len + part->length;
558 /* Do the bound check here, not allow the request len exceed 254 bytes */
559 if (len > IPMI_SSIF_PAYLOAD_MAX) {
560 dev_warn(&ssif_bmc->client->dev,
561 "Warn: Request exceeded 254 bytes, aborting");
562 /* Request too long, aborting */
563 ssif_bmc->aborting = true;
564 } else {
565 memcpy(ssif_bmc->request.payload + ssif_bmc->request.len,
566 part->payload, part->length);
567 ssif_bmc->request.len += part->length;
568 }
569 break;
570 default:
571 /* Do not expect to go to this case */
572 dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
573 __func__, part->smbus_cmd);
574 break;
575 }
576 }
577
process_smbus_cmd(struct ssif_bmc_ctx * ssif_bmc,u8 * val)578 static void process_smbus_cmd(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
579 {
580 /* SMBUS command can vary (single or multi-part) */
581 ssif_bmc->part_buf.smbus_cmd = *val;
582 ssif_bmc->msg_idx = 1;
583 memset(&ssif_bmc->part_buf.payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
584
585 if (*val == SSIF_IPMI_SINGLEPART_WRITE || *val == SSIF_IPMI_MULTIPART_WRITE_START) {
586 /*
587 * The response maybe not come in-time, causing host SSIF driver
588 * to timeout and resend a new request. In such case check for
589 * pending response and clear it
590 */
591 if (ssif_bmc->response_in_progress)
592 complete_response(ssif_bmc);
593
594 /* This is new request, flip aborting flag if set */
595 if (ssif_bmc->aborting)
596 ssif_bmc->aborting = false;
597 }
598 }
599
on_read_requested_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)600 static void on_read_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
601 {
602 if (ssif_bmc->state == SSIF_READY ||
603 ssif_bmc->state == SSIF_START ||
604 ssif_bmc->state == SSIF_REQ_RECVING ||
605 ssif_bmc->state == SSIF_RES_SENDING) {
606 dev_warn(&ssif_bmc->client->dev,
607 "Warn: %s unexpected READ REQUESTED in state=%s\n",
608 __func__, state_to_string(ssif_bmc->state));
609 ssif_bmc->state = SSIF_ABORTING;
610 *val = 0;
611 return;
612
613 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
614 if (!supported_read_cmd(ssif_bmc->part_buf.smbus_cmd)) {
615 dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x",
616 ssif_bmc->part_buf.smbus_cmd);
617 ssif_bmc->aborting = true;
618 }
619
620 if (ssif_bmc->aborting)
621 ssif_bmc->state = SSIF_ABORTING;
622 else
623 ssif_bmc->state = SSIF_RES_SENDING;
624 }
625
626 ssif_bmc->msg_idx = 0;
627
628 /* Send 0 if there is nothing to send */
629 if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
630 *val = 0;
631 return;
632 }
633
634 if (ssif_bmc->is_singlepart_read)
635 set_singlepart_response_buffer(ssif_bmc);
636 else
637 set_multipart_response_buffer(ssif_bmc);
638
639 calculate_response_part_pec(&ssif_bmc->part_buf);
640 ssif_bmc->part_buf.index = 0;
641 *val = ssif_bmc->part_buf.length;
642 }
643
on_read_processed_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)644 static void on_read_processed_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
645 {
646 if (ssif_bmc->state == SSIF_READY ||
647 ssif_bmc->state == SSIF_START ||
648 ssif_bmc->state == SSIF_REQ_RECVING ||
649 ssif_bmc->state == SSIF_SMBUS_CMD) {
650 dev_warn(&ssif_bmc->client->dev,
651 "Warn: %s unexpected READ PROCESSED in state=%s\n",
652 __func__, state_to_string(ssif_bmc->state));
653 ssif_bmc->state = SSIF_ABORTING;
654 *val = 0;
655 return;
656 }
657
658 /* Send 0 if there is nothing to send */
659 if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
660 *val = 0;
661 return;
662 }
663
664 handle_read_processed(ssif_bmc, val);
665 }
666
on_write_requested_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)667 static void on_write_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
668 {
669 if (ssif_bmc->state == SSIF_READY || ssif_bmc->state == SSIF_SMBUS_CMD) {
670 ssif_bmc->state = SSIF_START;
671
672 } else if (ssif_bmc->state == SSIF_START ||
673 ssif_bmc->state == SSIF_REQ_RECVING ||
674 ssif_bmc->state == SSIF_RES_SENDING) {
675 dev_warn(&ssif_bmc->client->dev,
676 "Warn: %s unexpected WRITE REQUEST in state=%s\n",
677 __func__, state_to_string(ssif_bmc->state));
678 ssif_bmc->state = SSIF_ABORTING;
679 return;
680 }
681
682 ssif_bmc->msg_idx = 0;
683 ssif_bmc->part_buf.address = *val;
684 }
685
on_write_received_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)686 static void on_write_received_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
687 {
688 if (ssif_bmc->state == SSIF_READY ||
689 ssif_bmc->state == SSIF_RES_SENDING) {
690 dev_warn(&ssif_bmc->client->dev,
691 "Warn: %s unexpected WRITE RECEIVED in state=%s\n",
692 __func__, state_to_string(ssif_bmc->state));
693 ssif_bmc->state = SSIF_ABORTING;
694
695 } else if (ssif_bmc->state == SSIF_START) {
696 ssif_bmc->state = SSIF_SMBUS_CMD;
697
698 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
699 if (!supported_write_cmd(ssif_bmc->part_buf.smbus_cmd)) {
700 dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x",
701 ssif_bmc->part_buf.smbus_cmd);
702 ssif_bmc->aborting = true;
703 }
704
705 if (ssif_bmc->aborting)
706 ssif_bmc->state = SSIF_ABORTING;
707 else
708 ssif_bmc->state = SSIF_REQ_RECVING;
709 }
710
711 /* This is response sending state */
712 if (ssif_bmc->state == SSIF_REQ_RECVING)
713 handle_write_received(ssif_bmc, val);
714 else if (ssif_bmc->state == SSIF_SMBUS_CMD)
715 process_smbus_cmd(ssif_bmc, val);
716 }
717
on_stop_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)718 static void on_stop_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
719 {
720 if (ssif_bmc->state == SSIF_READY ||
721 ssif_bmc->state == SSIF_START ||
722 ssif_bmc->state == SSIF_SMBUS_CMD ||
723 ssif_bmc->state == SSIF_ABORTING) {
724 dev_warn(&ssif_bmc->client->dev,
725 "Warn: %s unexpected SLAVE STOP in state=%s\n",
726 __func__, state_to_string(ssif_bmc->state));
727 ssif_bmc->state = SSIF_READY;
728
729 } else if (ssif_bmc->state == SSIF_REQ_RECVING) {
730 if (validate_request_part(ssif_bmc)) {
731 process_request_part(ssif_bmc);
732 if (ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_SINGLEPART_WRITE ||
733 ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_MULTIPART_WRITE_END)
734 handle_request(ssif_bmc);
735 ssif_bmc->state = SSIF_READY;
736 } else {
737 /*
738 * A BMC that receives an invalid request drop the data for the write
739 * transaction and any further transactions (read or write) until
740 * the next valid read or write Start transaction is received
741 */
742 dev_err(&ssif_bmc->client->dev, "Error: invalid pec\n");
743 ssif_bmc->aborting = true;
744 }
745 } else if (ssif_bmc->state == SSIF_RES_SENDING) {
746 if (ssif_bmc->is_singlepart_read || ssif_bmc->block_num == 0xFF) {
747 memset(&ssif_bmc->part_buf, 0, sizeof(struct ssif_part_buffer));
748 /* Invalidate response buffer to denote it is sent */
749 complete_response(ssif_bmc);
750 }
751 ssif_bmc->state = SSIF_READY;
752 }
753
754 /* Reset message index */
755 ssif_bmc->msg_idx = 0;
756 }
757
758 /*
759 * Callback function to handle I2C slave events
760 */
ssif_bmc_cb(struct i2c_client * client,enum i2c_slave_event event,u8 * val)761 static int ssif_bmc_cb(struct i2c_client *client, enum i2c_slave_event event, u8 *val)
762 {
763 unsigned long flags;
764 struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
765 int ret = 0;
766
767 spin_lock_irqsave(&ssif_bmc->lock, flags);
768
769 switch (event) {
770 case I2C_SLAVE_READ_REQUESTED:
771 on_read_requested_event(ssif_bmc, val);
772 break;
773
774 case I2C_SLAVE_WRITE_REQUESTED:
775 on_write_requested_event(ssif_bmc, val);
776 break;
777
778 case I2C_SLAVE_READ_PROCESSED:
779 on_read_processed_event(ssif_bmc, val);
780 break;
781
782 case I2C_SLAVE_WRITE_RECEIVED:
783 on_write_received_event(ssif_bmc, val);
784 break;
785
786 case I2C_SLAVE_STOP:
787 on_stop_event(ssif_bmc, val);
788 break;
789
790 default:
791 dev_warn(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n");
792 break;
793 }
794
795 if (!ssif_bmc->aborting && ssif_bmc->busy)
796 ret = -EBUSY;
797
798 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
799
800 return ret;
801 }
802
ssif_bmc_probe(struct i2c_client * client)803 static int ssif_bmc_probe(struct i2c_client *client)
804 {
805 struct ssif_bmc_ctx *ssif_bmc;
806 int ret;
807
808 ssif_bmc = devm_kzalloc(&client->dev, sizeof(*ssif_bmc), GFP_KERNEL);
809 if (!ssif_bmc)
810 return -ENOMEM;
811
812 spin_lock_init(&ssif_bmc->lock);
813
814 init_waitqueue_head(&ssif_bmc->wait_queue);
815 ssif_bmc->request_available = false;
816 ssif_bmc->response_in_progress = false;
817 ssif_bmc->busy = false;
818 ssif_bmc->response_timer_inited = false;
819
820 /* Register misc device interface */
821 ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
822 ssif_bmc->miscdev.name = DEVICE_NAME;
823 ssif_bmc->miscdev.fops = &ssif_bmc_fops;
824 ssif_bmc->miscdev.parent = &client->dev;
825 ret = misc_register(&ssif_bmc->miscdev);
826 if (ret)
827 return ret;
828
829 ssif_bmc->client = client;
830 ssif_bmc->client->flags |= I2C_CLIENT_SLAVE;
831
832 /* Register I2C slave */
833 i2c_set_clientdata(client, ssif_bmc);
834 ret = i2c_slave_register(client, ssif_bmc_cb);
835 if (ret)
836 misc_deregister(&ssif_bmc->miscdev);
837
838 return ret;
839 }
840
ssif_bmc_remove(struct i2c_client * client)841 static void ssif_bmc_remove(struct i2c_client *client)
842 {
843 struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
844
845 i2c_slave_unregister(client);
846 misc_deregister(&ssif_bmc->miscdev);
847 }
848
849 static const struct of_device_id ssif_bmc_match[] = {
850 { .compatible = "ssif-bmc" },
851 { },
852 };
853 MODULE_DEVICE_TABLE(of, ssif_bmc_match);
854
855 static const struct i2c_device_id ssif_bmc_id[] = {
856 { DEVICE_NAME, 0 },
857 { },
858 };
859 MODULE_DEVICE_TABLE(i2c, ssif_bmc_id);
860
861 static struct i2c_driver ssif_bmc_driver = {
862 .driver = {
863 .name = DEVICE_NAME,
864 .of_match_table = ssif_bmc_match,
865 },
866 .probe = ssif_bmc_probe,
867 .remove = ssif_bmc_remove,
868 .id_table = ssif_bmc_id,
869 };
870
871 module_i2c_driver(ssif_bmc_driver);
872
873 MODULE_AUTHOR("Quan Nguyen <quan@os.amperecomputing.com>");
874 MODULE_AUTHOR("Chuong Tran <chuong@os.amperecomputing.com>");
875 MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface.");
876 MODULE_LICENSE("GPL");
877