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 #if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
22 #include <kunit/test.h>
23 #endif
24
25 #define DEVICE_NAME "ipmi-ssif-host"
26
27 #define GET_8BIT_ADDR(addr_7bit) (((addr_7bit) << 1) & 0xff)
28
29 /* A standard SMBus Transaction is limited to 32 data bytes */
30 #define MAX_PAYLOAD_PER_TRANSACTION 32
31 /* Transaction includes the address, the command, the length and the PEC byte */
32 #define MAX_TRANSACTION (MAX_PAYLOAD_PER_TRANSACTION + 4)
33
34 #define MAX_IPMI_DATA_PER_START_TRANSACTION 30
35 #define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION 31
36
37 #define SSIF_IPMI_SINGLEPART_WRITE 0x2
38 #define SSIF_IPMI_SINGLEPART_READ 0x3
39 #define SSIF_IPMI_MULTIPART_WRITE_START 0x6
40 #define SSIF_IPMI_MULTIPART_WRITE_MIDDLE 0x7
41 #define SSIF_IPMI_MULTIPART_WRITE_END 0x8
42 #define SSIF_IPMI_MULTIPART_READ_START 0x3
43 #define SSIF_IPMI_MULTIPART_READ_MIDDLE 0x9
44
45 /*
46 * IPMI 2.0 Spec, section 12.7 SSIF Timing,
47 * Request-to-Response Time is T6max(250ms) - T1max(20ms) - 3ms = 227ms
48 * Recover ssif_bmc from busy state if it takes up to 500ms
49 */
50 #define RESPONSE_TIMEOUT 500 /* ms */
51
52 struct ssif_part_buffer {
53 u8 address;
54 u8 smbus_cmd;
55 u8 length;
56 u8 payload[MAX_PAYLOAD_PER_TRANSACTION];
57 u8 pec;
58 u8 index;
59 };
60
61 /*
62 * SSIF internal states:
63 * SSIF_READY 0x00 : Ready state
64 * SSIF_START 0x01 : Start smbus transaction
65 * SSIF_SMBUS_CMD 0x02 : Received SMBus command
66 * SSIF_REQ_RECVING 0x03 : Receiving request
67 * SSIF_RES_SENDING 0x04 : Sending response
68 * SSIF_ABORTING 0x05 : Aborting state
69 */
70 enum ssif_state {
71 SSIF_READY,
72 SSIF_START,
73 SSIF_SMBUS_CMD,
74 SSIF_REQ_RECVING,
75 SSIF_RES_SENDING,
76 SSIF_ABORTING,
77 SSIF_STATE_MAX
78 };
79
80 struct ssif_bmc_ctx {
81 struct i2c_client *client;
82 struct miscdevice miscdev;
83 int msg_idx;
84 bool pec_support;
85 /* ssif bmc spinlock */
86 spinlock_t lock;
87 wait_queue_head_t wait_queue;
88 u8 running;
89 enum ssif_state state;
90 /* Timeout waiting for response */
91 struct timer_list response_timer;
92 bool response_timer_inited;
93 /* Flag to identify a Multi-part Read Transaction */
94 bool is_singlepart_read;
95 u8 nbytes_processed;
96 u8 remain_len;
97 u8 recv_len;
98 /* Block Number of a Multi-part Read Transaction */
99 u8 block_num;
100 bool request_available;
101 bool response_in_progress;
102 bool busy;
103 bool aborting;
104 /* Buffer for SSIF Transaction part*/
105 struct ssif_part_buffer part_buf;
106 struct ipmi_ssif_msg response;
107 struct ipmi_ssif_msg request;
108 };
109
to_ssif_bmc(struct file * file)110 static inline struct ssif_bmc_ctx *to_ssif_bmc(struct file *file)
111 {
112 return container_of(file->private_data, struct ssif_bmc_ctx, miscdev);
113 }
114
state_to_string(enum ssif_state state)115 static const char *state_to_string(enum ssif_state state)
116 {
117 switch (state) {
118 case SSIF_READY:
119 return "SSIF_READY";
120 case SSIF_START:
121 return "SSIF_START";
122 case SSIF_SMBUS_CMD:
123 return "SSIF_SMBUS_CMD";
124 case SSIF_REQ_RECVING:
125 return "SSIF_REQ_RECVING";
126 case SSIF_RES_SENDING:
127 return "SSIF_RES_SENDING";
128 case SSIF_ABORTING:
129 return "SSIF_ABORTING";
130 default:
131 return "SSIF_STATE_UNKNOWN";
132 }
133 }
134
135 /* Handle SSIF message that will be sent to user */
ssif_bmc_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)136 static ssize_t ssif_bmc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
137 {
138 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
139 struct ipmi_ssif_msg msg;
140 unsigned long flags;
141 ssize_t ret;
142
143 spin_lock_irqsave(&ssif_bmc->lock, flags);
144 while (!ssif_bmc->request_available) {
145 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
146 if (file->f_flags & O_NONBLOCK)
147 return -EAGAIN;
148 ret = wait_event_interruptible(ssif_bmc->wait_queue,
149 ssif_bmc->request_available);
150 if (ret)
151 return ret;
152 spin_lock_irqsave(&ssif_bmc->lock, flags);
153 }
154
155 if (count < min_t(ssize_t,
156 sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
157 sizeof(struct ipmi_ssif_msg))) {
158 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
159 ret = -EINVAL;
160 } else {
161 count = min_t(ssize_t,
162 sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
163 sizeof(struct ipmi_ssif_msg));
164 memcpy(&msg, &ssif_bmc->request, count);
165 ssif_bmc->request_available = false;
166 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
167
168 ret = copy_to_user(buf, &msg, count);
169 if (ret > 0)
170 ret = -EFAULT;
171 }
172
173 return (ret < 0) ? ret : count;
174 }
175
176 /* Handle SSIF message that is written by user */
ssif_bmc_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)177 static ssize_t ssif_bmc_write(struct file *file, const char __user *buf, size_t count,
178 loff_t *ppos)
179 {
180 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
181 struct ipmi_ssif_msg msg;
182 unsigned long flags;
183 ssize_t ret;
184
185 if (count < sizeof(msg.len) ||
186 count > sizeof(struct ipmi_ssif_msg))
187 return -EINVAL;
188
189 if (copy_from_user(&msg, buf, count))
190 return -EFAULT;
191
192 if (!msg.len || msg.len > IPMI_SSIF_PAYLOAD_MAX ||
193 count < sizeof_field(struct ipmi_ssif_msg, len) + msg.len)
194 return -EINVAL;
195
196 spin_lock_irqsave(&ssif_bmc->lock, flags);
197 while (ssif_bmc->response_in_progress) {
198 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
199 if (file->f_flags & O_NONBLOCK)
200 return -EAGAIN;
201 ret = wait_event_interruptible(ssif_bmc->wait_queue,
202 !ssif_bmc->response_in_progress);
203 if (ret)
204 return ret;
205 spin_lock_irqsave(&ssif_bmc->lock, flags);
206 }
207
208 /*
209 * The write must complete before the response timeout fired, otherwise
210 * the response is aborted and wait for next request
211 * Return -EINVAL if the response is aborted
212 */
213 ret = (ssif_bmc->response_timer_inited) ? 0 : -EINVAL;
214 if (ret)
215 goto exit;
216
217 timer_delete(&ssif_bmc->response_timer);
218 ssif_bmc->response_timer_inited = false;
219
220 memcpy(&ssif_bmc->response, &msg, count);
221 ssif_bmc->is_singlepart_read = (msg.len <= MAX_PAYLOAD_PER_TRANSACTION);
222
223 ssif_bmc->response_in_progress = true;
224
225 /* ssif_bmc not busy */
226 ssif_bmc->busy = false;
227
228 /* Clean old request buffer */
229 memset(&ssif_bmc->request, 0, sizeof(struct ipmi_ssif_msg));
230 exit:
231 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
232
233 return (ret < 0) ? ret : count;
234 }
235
ssif_bmc_open(struct inode * inode,struct file * file)236 static int ssif_bmc_open(struct inode *inode, struct file *file)
237 {
238 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
239 int ret = 0;
240
241 spin_lock_irq(&ssif_bmc->lock);
242 if (!ssif_bmc->running)
243 ssif_bmc->running = 1;
244 else
245 ret = -EBUSY;
246 spin_unlock_irq(&ssif_bmc->lock);
247
248 return ret;
249 }
250
ssif_bmc_poll(struct file * file,poll_table * wait)251 static __poll_t ssif_bmc_poll(struct file *file, poll_table *wait)
252 {
253 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
254 __poll_t mask = 0;
255
256 poll_wait(file, &ssif_bmc->wait_queue, wait);
257
258 spin_lock_irq(&ssif_bmc->lock);
259 /* The request is available, userspace application can get the request */
260 if (ssif_bmc->request_available)
261 mask |= EPOLLIN;
262
263 spin_unlock_irq(&ssif_bmc->lock);
264
265 return mask;
266 }
267
ssif_bmc_release(struct inode * inode,struct file * file)268 static int ssif_bmc_release(struct inode *inode, struct file *file)
269 {
270 struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
271
272 spin_lock_irq(&ssif_bmc->lock);
273 ssif_bmc->running = 0;
274 spin_unlock_irq(&ssif_bmc->lock);
275
276 return 0;
277 }
278
279 /*
280 * System calls to device interface for user apps
281 */
282 static const struct file_operations ssif_bmc_fops = {
283 .owner = THIS_MODULE,
284 .open = ssif_bmc_open,
285 .read = ssif_bmc_read,
286 .write = ssif_bmc_write,
287 .release = ssif_bmc_release,
288 .poll = ssif_bmc_poll,
289 };
290
291 /* Called with ssif_bmc->lock held. */
complete_response(struct ssif_bmc_ctx * ssif_bmc)292 static void complete_response(struct ssif_bmc_ctx *ssif_bmc)
293 {
294 /* Invalidate response in buffer to denote it having been sent. */
295 ssif_bmc->response.len = 0;
296 ssif_bmc->response_in_progress = false;
297 ssif_bmc->nbytes_processed = 0;
298 ssif_bmc->remain_len = 0;
299 ssif_bmc->busy = false;
300 wake_up_all(&ssif_bmc->wait_queue);
301 }
302
response_timeout(struct timer_list * t)303 static void response_timeout(struct timer_list *t)
304 {
305 struct ssif_bmc_ctx *ssif_bmc = timer_container_of(ssif_bmc, t,
306 response_timer);
307 unsigned long flags;
308
309 spin_lock_irqsave(&ssif_bmc->lock, flags);
310
311 /* Do nothing if the response is in progress */
312 if (!ssif_bmc->response_in_progress) {
313 /* Recover ssif_bmc from busy */
314 ssif_bmc->busy = false;
315 ssif_bmc->response_timer_inited = false;
316 /* Set aborting flag */
317 ssif_bmc->aborting = true;
318 }
319
320 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
321 }
322
323 /* Called with ssif_bmc->lock held. */
handle_request(struct ssif_bmc_ctx * ssif_bmc)324 static void handle_request(struct ssif_bmc_ctx *ssif_bmc)
325 {
326 /* set ssif_bmc to busy waiting for response */
327 ssif_bmc->busy = true;
328 /* Request message is available to process */
329 ssif_bmc->request_available = true;
330 /* Clean old response buffer */
331 memset(&ssif_bmc->response, 0, sizeof(struct ipmi_ssif_msg));
332 /* This is the new READ request.*/
333 wake_up_all(&ssif_bmc->wait_queue);
334
335 /* Armed timer to recover slave from busy state in case of no response */
336 if (!ssif_bmc->response_timer_inited) {
337 timer_setup(&ssif_bmc->response_timer, response_timeout, 0);
338 ssif_bmc->response_timer_inited = true;
339 }
340 mod_timer(&ssif_bmc->response_timer, jiffies + msecs_to_jiffies(RESPONSE_TIMEOUT));
341 }
342
calculate_response_part_pec(struct ssif_part_buffer * part)343 static void calculate_response_part_pec(struct ssif_part_buffer *part)
344 {
345 u8 addr = part->address;
346
347 /* PEC - Start Read Address */
348 part->pec = i2c_smbus_pec(0, &addr, 1);
349 /* PEC - SSIF Command */
350 part->pec = i2c_smbus_pec(part->pec, &part->smbus_cmd, 1);
351 /* PEC - Restart Write Address */
352 addr = addr | 0x01;
353 part->pec = i2c_smbus_pec(part->pec, &addr, 1);
354 part->pec = i2c_smbus_pec(part->pec, &part->length, 1);
355 if (part->length)
356 part->pec = i2c_smbus_pec(part->pec, part->payload, part->length);
357 }
358
set_singlepart_response_buffer(struct ssif_bmc_ctx * ssif_bmc)359 static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
360 {
361 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
362
363 part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
364 part->length = (u8)ssif_bmc->response.len;
365
366 /* Clear the rest to 0 */
367 memset(part->payload + part->length, 0, MAX_PAYLOAD_PER_TRANSACTION - part->length);
368 memcpy(&part->payload[0], &ssif_bmc->response.payload[0], part->length);
369 }
370
set_multipart_response_buffer(struct ssif_bmc_ctx * ssif_bmc)371 static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
372 {
373 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
374 u8 part_len = 0;
375
376 part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
377 switch (part->smbus_cmd) {
378 case SSIF_IPMI_MULTIPART_READ_START:
379 /*
380 * Read Start length is 32 bytes.
381 * Read Start transfer first 30 bytes of IPMI response
382 * and 2 special code 0x00, 0x01.
383 */
384 ssif_bmc->nbytes_processed = 0;
385 ssif_bmc->block_num = 0;
386 part->length = MAX_PAYLOAD_PER_TRANSACTION;
387 part_len = MAX_IPMI_DATA_PER_START_TRANSACTION;
388 ssif_bmc->remain_len = ssif_bmc->response.len - part_len;
389
390 part->payload[0] = 0x00; /* Start Flag */
391 part->payload[1] = 0x01; /* Start Flag */
392
393 memcpy(&part->payload[2], &ssif_bmc->response.payload[0], part_len);
394 break;
395
396 case SSIF_IPMI_MULTIPART_READ_MIDDLE:
397 /*
398 * IPMI READ Middle or READ End messages can carry up to 31 bytes
399 * IPMI data plus block number byte.
400 */
401 if (ssif_bmc->remain_len <= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) {
402 /*
403 * This is READ End message
404 * Return length is the remaining response data length
405 * plus block number
406 * Block number 0xFF is to indicate this is last message
407 *
408 */
409 /* Clean the buffer */
410 memset(&part->payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
411 part->length = ssif_bmc->remain_len + 1;
412 part_len = ssif_bmc->remain_len;
413 ssif_bmc->block_num = 0xFF;
414 part->payload[0] = ssif_bmc->block_num;
415 } else {
416 /*
417 * This is READ Middle message
418 * Response length is the maximum SMBUS transfer length
419 * Block number byte is incremented
420 * Return length is maximum SMBUS transfer length
421 */
422 part->length = MAX_PAYLOAD_PER_TRANSACTION;
423 part_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION;
424 part->payload[0] = ssif_bmc->block_num;
425 ssif_bmc->block_num++;
426 }
427
428 ssif_bmc->remain_len -= part_len;
429 memcpy(&part->payload[1], ssif_bmc->response.payload + ssif_bmc->nbytes_processed,
430 part_len);
431 break;
432
433 default:
434 /* Do not expect to go to this case */
435 dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
436 __func__, part->smbus_cmd);
437 break;
438 }
439
440 ssif_bmc->nbytes_processed += part_len;
441 }
442
supported_read_cmd(u8 cmd)443 static bool supported_read_cmd(u8 cmd)
444 {
445 if (cmd == SSIF_IPMI_SINGLEPART_READ ||
446 cmd == SSIF_IPMI_MULTIPART_READ_START ||
447 cmd == SSIF_IPMI_MULTIPART_READ_MIDDLE)
448 return true;
449
450 return false;
451 }
452
supported_write_cmd(u8 cmd)453 static bool supported_write_cmd(u8 cmd)
454 {
455 if (cmd == SSIF_IPMI_SINGLEPART_WRITE ||
456 cmd == SSIF_IPMI_MULTIPART_WRITE_START ||
457 cmd == SSIF_IPMI_MULTIPART_WRITE_MIDDLE ||
458 cmd == SSIF_IPMI_MULTIPART_WRITE_END)
459 return true;
460
461 return false;
462 }
463
supported_write_start_cmd(u8 cmd)464 static bool supported_write_start_cmd(u8 cmd)
465 {
466 if (cmd == SSIF_IPMI_SINGLEPART_WRITE ||
467 cmd == SSIF_IPMI_MULTIPART_WRITE_START)
468 return true;
469
470 return false;
471 }
472
473 /* Process the IPMI response that will be read by master */
handle_read_processed(struct ssif_bmc_ctx * ssif_bmc,u8 * val)474 static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
475 {
476 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
477
478 /* msg_idx start from 0 */
479 if (part->index < part->length)
480 *val = part->payload[part->index];
481 else if (part->index == part->length && ssif_bmc->pec_support)
482 *val = part->pec;
483 else
484 *val = 0;
485
486 part->index++;
487 }
488
handle_write_received(struct ssif_bmc_ctx * ssif_bmc,u8 * val)489 static void handle_write_received(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
490 {
491 /*
492 * The msg_idx must be 1 when first enter SSIF_REQ_RECVING state
493 * And it would never exceeded 36 bytes included the 32 bytes max payload +
494 * the address + the command + the len and the PEC.
495 */
496 if (ssif_bmc->msg_idx < 1 || ssif_bmc->msg_idx > MAX_TRANSACTION)
497 return;
498
499 if (ssif_bmc->msg_idx == 1) {
500 ssif_bmc->part_buf.length = *val;
501 ssif_bmc->part_buf.index = 0;
502 } else {
503 ssif_bmc->part_buf.payload[ssif_bmc->part_buf.index++] = *val;
504 }
505
506 ssif_bmc->msg_idx++;
507 }
508
validate_request_part(struct ssif_bmc_ctx * ssif_bmc)509 static bool validate_request_part(struct ssif_bmc_ctx *ssif_bmc)
510 {
511 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
512 bool ret = true;
513 u8 cpec;
514 u8 addr;
515
516 if (part->index == part->length) {
517 /* PEC is not included */
518 ssif_bmc->pec_support = false;
519 ret = true;
520 goto exit;
521 }
522
523 if (part->index != part->length + 1) {
524 ret = false;
525 goto exit;
526 }
527
528 /* PEC is included */
529 ssif_bmc->pec_support = true;
530 part->pec = part->payload[part->length];
531 addr = GET_8BIT_ADDR(ssif_bmc->client->addr);
532 cpec = i2c_smbus_pec(0, &addr, 1);
533 cpec = i2c_smbus_pec(cpec, &part->smbus_cmd, 1);
534 cpec = i2c_smbus_pec(cpec, &part->length, 1);
535 /*
536 * As SMBus specification does not allow the length
537 * (byte count) in the Write-Block protocol to be zero.
538 * Therefore, it is illegal to have the last Middle
539 * transaction in the sequence carry 32-byte and have
540 * a length of ‘0’ in the End transaction.
541 * But some users may try to use this way and we should
542 * prevent ssif_bmc driver broken in this case.
543 */
544 if (part->length)
545 cpec = i2c_smbus_pec(cpec, part->payload, part->length);
546
547 if (cpec != part->pec)
548 ret = false;
549
550 exit:
551 return ret;
552 }
553
process_request_part(struct ssif_bmc_ctx * ssif_bmc)554 static void process_request_part(struct ssif_bmc_ctx *ssif_bmc)
555 {
556 struct ssif_part_buffer *part = &ssif_bmc->part_buf;
557 unsigned int len;
558
559 switch (part->smbus_cmd) {
560 case SSIF_IPMI_SINGLEPART_WRITE:
561 /* save the whole part to request*/
562 ssif_bmc->request.len = part->length;
563 memcpy(ssif_bmc->request.payload, part->payload, part->length);
564
565 break;
566 case SSIF_IPMI_MULTIPART_WRITE_START:
567 ssif_bmc->request.len = 0;
568
569 fallthrough;
570 case SSIF_IPMI_MULTIPART_WRITE_MIDDLE:
571 case SSIF_IPMI_MULTIPART_WRITE_END:
572 len = ssif_bmc->request.len + part->length;
573 /* Do the bound check here, not allow the request len exceed 254 bytes */
574 if (len > IPMI_SSIF_PAYLOAD_MAX) {
575 dev_dbg(&ssif_bmc->client->dev,
576 "Warn: Request exceeded 254 bytes, aborting");
577 /* Request too long, aborting */
578 ssif_bmc->aborting = true;
579 } else {
580 memcpy(ssif_bmc->request.payload + ssif_bmc->request.len,
581 part->payload, part->length);
582 ssif_bmc->request.len += part->length;
583 }
584 break;
585 default:
586 /* Do not expect to go to this case */
587 dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
588 __func__, part->smbus_cmd);
589 break;
590 }
591 }
592
process_smbus_cmd(struct ssif_bmc_ctx * ssif_bmc,u8 * val)593 static void process_smbus_cmd(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
594 {
595 /* SMBUS command can vary (single or multi-part) */
596 ssif_bmc->part_buf.smbus_cmd = *val;
597 ssif_bmc->msg_idx = 1;
598 memset(&ssif_bmc->part_buf.payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
599
600 if (*val == SSIF_IPMI_SINGLEPART_WRITE || *val == SSIF_IPMI_MULTIPART_WRITE_START) {
601 /*
602 * The response maybe not come in-time, causing host SSIF driver
603 * to timeout and resend a new request. In such case check for
604 * pending response and clear it
605 */
606 if (ssif_bmc->response_in_progress)
607 complete_response(ssif_bmc);
608
609 /* This is new request, flip aborting flag if set */
610 if (ssif_bmc->aborting)
611 ssif_bmc->aborting = false;
612 }
613 }
614
on_read_requested_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)615 static void on_read_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
616 {
617 if (ssif_bmc->state == SSIF_READY ||
618 ssif_bmc->state == SSIF_START ||
619 ssif_bmc->state == SSIF_REQ_RECVING ||
620 ssif_bmc->state == SSIF_RES_SENDING) {
621 dev_dbg(&ssif_bmc->client->dev,
622 "Warn: %s unexpected READ REQUESTED in state=%s\n",
623 __func__, state_to_string(ssif_bmc->state));
624 ssif_bmc->state = SSIF_ABORTING;
625 *val = 0;
626 return;
627
628 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
629 if (!supported_read_cmd(ssif_bmc->part_buf.smbus_cmd)) {
630 dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x",
631 ssif_bmc->part_buf.smbus_cmd);
632 ssif_bmc->aborting = true;
633 }
634
635 if (ssif_bmc->aborting)
636 ssif_bmc->state = SSIF_ABORTING;
637 else
638 ssif_bmc->state = SSIF_RES_SENDING;
639 }
640
641 ssif_bmc->msg_idx = 0;
642
643 /* Send 0 if there is nothing to send */
644 if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
645 *val = 0;
646 return;
647 }
648
649 if (ssif_bmc->is_singlepart_read)
650 set_singlepart_response_buffer(ssif_bmc);
651 else
652 set_multipart_response_buffer(ssif_bmc);
653
654 calculate_response_part_pec(&ssif_bmc->part_buf);
655 ssif_bmc->part_buf.index = 0;
656 *val = ssif_bmc->part_buf.length;
657 }
658
on_read_processed_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)659 static void on_read_processed_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
660 {
661 if (ssif_bmc->state == SSIF_READY ||
662 ssif_bmc->state == SSIF_START ||
663 ssif_bmc->state == SSIF_REQ_RECVING ||
664 ssif_bmc->state == SSIF_SMBUS_CMD) {
665 dev_dbg(&ssif_bmc->client->dev,
666 "Warn: %s unexpected READ PROCESSED in state=%s\n",
667 __func__, state_to_string(ssif_bmc->state));
668 ssif_bmc->state = SSIF_ABORTING;
669 *val = 0;
670 return;
671 }
672
673 /* Send 0 if there is nothing to send */
674 if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
675 *val = 0;
676 return;
677 }
678
679 handle_read_processed(ssif_bmc, val);
680 }
681
on_write_requested_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)682 static void on_write_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
683 {
684 if (ssif_bmc->state == SSIF_READY || ssif_bmc->state == SSIF_SMBUS_CMD) {
685 ssif_bmc->state = SSIF_START;
686
687 } else if (ssif_bmc->state == SSIF_START ||
688 ssif_bmc->state == SSIF_REQ_RECVING ||
689 ssif_bmc->state == SSIF_RES_SENDING) {
690 dev_dbg(&ssif_bmc->client->dev,
691 "Warn: %s unexpected WRITE REQUEST in state=%s\n",
692 __func__, state_to_string(ssif_bmc->state));
693 ssif_bmc->state = SSIF_ABORTING;
694 return;
695 }
696
697 ssif_bmc->msg_idx = 0;
698 ssif_bmc->part_buf.address = *val;
699 }
700
on_write_received_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)701 static void on_write_received_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
702 {
703 if (ssif_bmc->state == SSIF_READY ||
704 ssif_bmc->state == SSIF_RES_SENDING) {
705 dev_dbg(&ssif_bmc->client->dev,
706 "Warn: %s unexpected WRITE RECEIVED in state=%s\n",
707 __func__, state_to_string(ssif_bmc->state));
708 ssif_bmc->state = SSIF_ABORTING;
709
710 } else if (ssif_bmc->state == SSIF_START) {
711 ssif_bmc->state = SSIF_SMBUS_CMD;
712
713 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
714 if (!supported_write_cmd(ssif_bmc->part_buf.smbus_cmd)) {
715 dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x",
716 ssif_bmc->part_buf.smbus_cmd);
717 ssif_bmc->aborting = true;
718 }
719
720 if (ssif_bmc->aborting)
721 ssif_bmc->state = SSIF_ABORTING;
722 else
723 ssif_bmc->state = SSIF_REQ_RECVING;
724 } else if (ssif_bmc->state == SSIF_ABORTING) {
725 if (supported_write_start_cmd(*val)) {
726 ssif_bmc->state = SSIF_SMBUS_CMD;
727 ssif_bmc->aborting = false;
728 }
729 }
730
731 /* This is response sending state */
732 if (ssif_bmc->state == SSIF_REQ_RECVING)
733 handle_write_received(ssif_bmc, val);
734 else if (ssif_bmc->state == SSIF_SMBUS_CMD)
735 process_smbus_cmd(ssif_bmc, val);
736 }
737
on_stop_event(struct ssif_bmc_ctx * ssif_bmc,u8 * val)738 static void on_stop_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
739 {
740 if (ssif_bmc->state == SSIF_READY ||
741 ssif_bmc->state == SSIF_START ||
742 ssif_bmc->state == SSIF_SMBUS_CMD ||
743 ssif_bmc->state == SSIF_ABORTING) {
744 dev_dbg(&ssif_bmc->client->dev,
745 "Warn: %s unexpected SLAVE STOP in state=%s\n",
746 __func__, state_to_string(ssif_bmc->state));
747 ssif_bmc->state = SSIF_READY;
748
749 } else if (ssif_bmc->state == SSIF_REQ_RECVING) {
750 if (validate_request_part(ssif_bmc)) {
751 process_request_part(ssif_bmc);
752 if (ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_SINGLEPART_WRITE ||
753 ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_MULTIPART_WRITE_END)
754 handle_request(ssif_bmc);
755 ssif_bmc->state = SSIF_READY;
756 } else {
757 /*
758 * A BMC that receives an invalid request drop the data for the write
759 * transaction and any further transactions (read or write) until
760 * the next valid read or write Start transaction is received
761 */
762 dev_err(&ssif_bmc->client->dev, "Error: invalid pec\n");
763 ssif_bmc->aborting = true;
764 }
765 } else if (ssif_bmc->state == SSIF_RES_SENDING) {
766 if (ssif_bmc->is_singlepart_read || ssif_bmc->block_num == 0xFF) {
767 memset(&ssif_bmc->part_buf, 0, sizeof(struct ssif_part_buffer));
768 /* Invalidate response buffer to denote it is sent */
769 complete_response(ssif_bmc);
770 }
771 ssif_bmc->state = SSIF_READY;
772 }
773
774 /* Reset message index */
775 ssif_bmc->msg_idx = 0;
776 }
777
778 /*
779 * Callback function to handle I2C slave events
780 */
ssif_bmc_cb(struct i2c_client * client,enum i2c_slave_event event,u8 * val)781 static int ssif_bmc_cb(struct i2c_client *client, enum i2c_slave_event event, u8 *val)
782 {
783 unsigned long flags;
784 struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
785 int ret = 0;
786
787 spin_lock_irqsave(&ssif_bmc->lock, flags);
788
789 switch (event) {
790 case I2C_SLAVE_READ_REQUESTED:
791 on_read_requested_event(ssif_bmc, val);
792 break;
793
794 case I2C_SLAVE_WRITE_REQUESTED:
795 on_write_requested_event(ssif_bmc, val);
796 break;
797
798 case I2C_SLAVE_READ_PROCESSED:
799 on_read_processed_event(ssif_bmc, val);
800 break;
801
802 case I2C_SLAVE_WRITE_RECEIVED:
803 on_write_received_event(ssif_bmc, val);
804 break;
805
806 case I2C_SLAVE_STOP:
807 on_stop_event(ssif_bmc, val);
808 break;
809
810 default:
811 dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n");
812 break;
813 }
814
815 if (!ssif_bmc->aborting && ssif_bmc->busy)
816 ret = -EBUSY;
817
818 spin_unlock_irqrestore(&ssif_bmc->lock, flags);
819
820 return ret;
821 }
822
ssif_bmc_probe(struct i2c_client * client)823 static int ssif_bmc_probe(struct i2c_client *client)
824 {
825 struct ssif_bmc_ctx *ssif_bmc;
826 int ret;
827
828 ssif_bmc = devm_kzalloc(&client->dev, sizeof(*ssif_bmc), GFP_KERNEL);
829 if (!ssif_bmc)
830 return -ENOMEM;
831
832 spin_lock_init(&ssif_bmc->lock);
833
834 init_waitqueue_head(&ssif_bmc->wait_queue);
835 ssif_bmc->request_available = false;
836 ssif_bmc->response_in_progress = false;
837 ssif_bmc->busy = false;
838 ssif_bmc->response_timer_inited = false;
839
840 /* Register misc device interface */
841 ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
842 ssif_bmc->miscdev.name = DEVICE_NAME;
843 ssif_bmc->miscdev.fops = &ssif_bmc_fops;
844 ssif_bmc->miscdev.parent = &client->dev;
845 ret = misc_register(&ssif_bmc->miscdev);
846 if (ret)
847 return ret;
848
849 ssif_bmc->client = client;
850 ssif_bmc->client->flags |= I2C_CLIENT_SLAVE;
851
852 /* Register I2C slave */
853 i2c_set_clientdata(client, ssif_bmc);
854 ret = i2c_slave_register(client, ssif_bmc_cb);
855 if (ret)
856 misc_deregister(&ssif_bmc->miscdev);
857
858 return ret;
859 }
860
ssif_bmc_remove(struct i2c_client * client)861 static void ssif_bmc_remove(struct i2c_client *client)
862 {
863 struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
864
865 timer_delete_sync(&ssif_bmc->response_timer);
866 i2c_slave_unregister(client);
867 misc_deregister(&ssif_bmc->miscdev);
868 }
869
870 static const struct of_device_id ssif_bmc_match[] = {
871 { .compatible = "ssif-bmc" },
872 { },
873 };
874 MODULE_DEVICE_TABLE(of, ssif_bmc_match);
875
876 static const struct i2c_device_id ssif_bmc_id[] = {
877 { .name = DEVICE_NAME },
878 { }
879 };
880 MODULE_DEVICE_TABLE(i2c, ssif_bmc_id);
881
882 static struct i2c_driver ssif_bmc_driver = {
883 .driver = {
884 .name = DEVICE_NAME,
885 .of_match_table = ssif_bmc_match,
886 },
887 .probe = ssif_bmc_probe,
888 .remove = ssif_bmc_remove,
889 .id_table = ssif_bmc_id,
890 };
891
892 #if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
893 struct ssif_bmc_test_ctx {
894 struct ssif_bmc_ctx ssif_bmc;
895 struct i2c_client client;
896 struct i2c_adapter adapter;
897 struct i2c_algorithm algo;
898 };
899
ssif_bmc_test_init(struct kunit * test)900 static int ssif_bmc_test_init(struct kunit *test)
901 {
902 struct ssif_bmc_test_ctx *test_ctx;
903
904 test_ctx = kunit_kzalloc(test, sizeof(*test_ctx), GFP_KERNEL);
905 if (!test_ctx)
906 return -ENOMEM;
907
908 test_ctx->adapter.algo = &test_ctx->algo;
909 test_ctx->client.addr = 0x20;
910 test_ctx->client.adapter = &test_ctx->adapter;
911
912 spin_lock_init(&test_ctx->ssif_bmc.lock);
913 init_waitqueue_head(&test_ctx->ssif_bmc.wait_queue);
914 test_ctx->ssif_bmc.client = &test_ctx->client;
915 i2c_set_clientdata(&test_ctx->client, &test_ctx->ssif_bmc);
916
917 test->priv = test_ctx;
918
919 return 0;
920 }
921
ssif_bmc_test_exit(struct kunit * test)922 static void ssif_bmc_test_exit(struct kunit *test)
923 {
924 struct ssif_bmc_test_ctx *test_ctx = test->priv;
925
926 if (test_ctx->ssif_bmc.response_timer_inited)
927 timer_delete_sync(&test_ctx->ssif_bmc.response_timer);
928 }
929
ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx * test_ctx,enum i2c_slave_event event,u8 * value)930 static int ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx *test_ctx,
931 enum i2c_slave_event event,
932 u8 *value)
933 {
934 return ssif_bmc_cb(&test_ctx->client, event, value);
935 }
936
ssif_bmc_test_run_event(struct ssif_bmc_test_ctx * test_ctx,enum i2c_slave_event event,u8 value)937 static int ssif_bmc_test_run_event(struct ssif_bmc_test_ctx *test_ctx,
938 enum i2c_slave_event event, u8 value)
939 {
940 return ssif_bmc_test_run_event_val(test_ctx, event, &value);
941 }
942
ssif_bmc_test_singlepart_req(struct kunit * test)943 static void ssif_bmc_test_singlepart_req(struct kunit *test)
944 {
945 struct ssif_bmc_test_ctx *test_ctx = test->priv;
946 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
947
948 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
949 GET_8BIT_ADDR(test_ctx->client.addr));
950 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
951 SSIF_IPMI_SINGLEPART_WRITE);
952 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2);
953
954 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xaa);
955
956 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x55);
957 KUNIT_EXPECT_EQ(test,
958 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
959
960 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
961 KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
962 KUNIT_EXPECT_TRUE(test, ssif_bmc->busy);
963 KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
964 KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 2);
965 KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xaa);
966 KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[1], 0x55);
967 KUNIT_EXPECT_TRUE(test, ssif_bmc->response_timer_inited);
968 }
969
ssif_bmc_test_restart_write_without_stop(struct kunit * test)970 static void ssif_bmc_test_restart_write_without_stop(struct kunit *test)
971 {
972 struct ssif_bmc_test_ctx *test_ctx = test->priv;
973 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
974
975 KUNIT_ASSERT_EQ(test,
976 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
977 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
978 KUNIT_ASSERT_EQ(test,
979 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
980 SSIF_IPMI_SINGLEPART_WRITE), 0);
981 KUNIT_ASSERT_EQ(test,
982 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
983 KUNIT_ASSERT_EQ(test,
984 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xde), 0);
985
986 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);
987
988 /* Write transaction, without stop, and new request coming */
989 ssif_bmc_test_singlepart_req(test);
990 }
991
992
ssif_bmc_test_restart_after_invalid_command(struct kunit * test)993 static void ssif_bmc_test_restart_after_invalid_command(struct kunit *test)
994 {
995 struct ssif_bmc_test_ctx *test_ctx = test->priv;
996 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
997
998 KUNIT_ASSERT_EQ(test,
999 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1000 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1001 KUNIT_ASSERT_EQ(test,
1002 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xff), 0);
1003 KUNIT_ASSERT_EQ(test,
1004 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1005
1006 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);
1007 KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);
1008
1009 /* After An Invalid Command, expect could handle new request */
1010 ssif_bmc_test_singlepart_req(test);
1011 }
1012
ssif_bmc_test_singlepart_read_response_completion(struct kunit * test)1013 static void ssif_bmc_test_singlepart_read_response_completion(struct kunit *test)
1014 {
1015 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1016 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1017 u8 value;
1018
1019 ssif_bmc->state = SSIF_SMBUS_CMD;
1020 ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1021 ssif_bmc->response.len = 2;
1022 ssif_bmc->response.payload[0] = 0x11;
1023 ssif_bmc->response.payload[1] = 0x22;
1024 ssif_bmc->response_in_progress = true;
1025 ssif_bmc->is_singlepart_read = true;
1026 ssif_bmc->pec_support = true;
1027
1028 value = 0;
1029 KUNIT_ASSERT_EQ(test,
1030 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1031 &value), 0);
1032 KUNIT_EXPECT_EQ(test, value, 2);
1033 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1034
1035 value = 0;
1036 KUNIT_EXPECT_EQ(test,
1037 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1038 &value), 0);
1039 KUNIT_EXPECT_EQ(test, value, 0x11);
1040
1041 value = 0;
1042 KUNIT_EXPECT_EQ(test,
1043 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1044 &value), 0);
1045 KUNIT_EXPECT_EQ(test, value, 0x22);
1046
1047 value = 0;
1048 KUNIT_EXPECT_EQ(test,
1049 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1050 &value), 0);
1051 KUNIT_EXPECT_EQ(test, value, ssif_bmc->part_buf.pec);
1052
1053 KUNIT_EXPECT_EQ(test,
1054 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1055 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1056 KUNIT_EXPECT_FALSE(test, ssif_bmc->response_in_progress);
1057 KUNIT_EXPECT_EQ(test, ssif_bmc->response.len, 0);
1058 }
1059
ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit * test)1060 static void ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit *test)
1061 {
1062 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1063 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1064
1065 KUNIT_ASSERT_EQ(test,
1066 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1067 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1068 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_START);
1069
1070 KUNIT_EXPECT_EQ(test,
1071 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1072 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1073 KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
1074 KUNIT_EXPECT_EQ(test, ssif_bmc->msg_idx, 0);
1075
1076 KUNIT_EXPECT_EQ(test,
1077 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1078 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1079 KUNIT_EXPECT_EQ(test,
1080 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1081 SSIF_IPMI_SINGLEPART_WRITE), 0);
1082 KUNIT_EXPECT_EQ(test,
1083 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1084 KUNIT_EXPECT_EQ(test,
1085 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x77), 0);
1086 KUNIT_EXPECT_EQ(test,
1087 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1088
1089 KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1090 KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1091 KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x77);
1092 }
1093
ssif_bmc_test_read_interrupts_partial_write(struct kunit * test)1094 static void ssif_bmc_test_read_interrupts_partial_write(struct kunit *test)
1095 {
1096 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1097 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1098 u8 value = 0xff;
1099
1100 KUNIT_ASSERT_EQ(test,
1101 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1102 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1103 KUNIT_ASSERT_EQ(test,
1104 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1105 SSIF_IPMI_SINGLEPART_WRITE), 0);
1106 KUNIT_ASSERT_EQ(test,
1107 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
1108 KUNIT_ASSERT_EQ(test,
1109 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xab), 0);
1110
1111 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);
1112 KUNIT_EXPECT_EQ(test,
1113 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1114 &value), 0);
1115 KUNIT_EXPECT_EQ(test, value, 0);
1116 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);
1117
1118 KUNIT_EXPECT_EQ(test,
1119 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1120 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1121 KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
1122 KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 0);
1123
1124 KUNIT_EXPECT_EQ(test,
1125 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1126 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1127 KUNIT_EXPECT_EQ(test,
1128 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1129 SSIF_IPMI_SINGLEPART_WRITE), 0);
1130 KUNIT_EXPECT_EQ(test,
1131 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1132 KUNIT_EXPECT_EQ(test,
1133 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xcd), 0);
1134 KUNIT_EXPECT_EQ(test,
1135 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1136
1137 KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1138 KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1139 KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xcd);
1140 }
1141
ssif_bmc_test_write_interrupts_response_send(struct kunit * test)1142 static void ssif_bmc_test_write_interrupts_response_send(struct kunit *test)
1143 {
1144 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1145 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1146 u8 value = 0;
1147
1148 ssif_bmc->state = SSIF_SMBUS_CMD;
1149 ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1150 ssif_bmc->response.len = 1;
1151 ssif_bmc->response.payload[0] = 0x66;
1152 ssif_bmc->response_in_progress = true;
1153 ssif_bmc->is_singlepart_read = true;
1154
1155 KUNIT_ASSERT_EQ(test,
1156 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1157 &value), 0);
1158 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1159
1160 /* READ_REQUESTED transaction */
1161 ssif_bmc_test_singlepart_req(test);
1162 }
1163
ssif_bmc_test_write_interrupts_response_sending(struct kunit * test)1164 static void ssif_bmc_test_write_interrupts_response_sending(struct kunit *test)
1165 {
1166 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1167 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1168 u8 value = 0;
1169
1170 ssif_bmc->state = SSIF_SMBUS_CMD;
1171 ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1172 ssif_bmc->response.len = 1;
1173 ssif_bmc->response.payload[0] = 0x66;
1174 ssif_bmc->response_in_progress = true;
1175 ssif_bmc->is_singlepart_read = true;
1176
1177 KUNIT_ASSERT_EQ(test,
1178 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1179 &value), 0);
1180 KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1181
1182 KUNIT_ASSERT_EQ(test,
1183 ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1184 &value), 0);
1185 KUNIT_EXPECT_EQ(test, value, 0x66);
1186
1187 /* READ_REQUESTED transaction */
1188 ssif_bmc_test_singlepart_req(test);
1189 }
1190
ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit * test)1191 static void ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit *test)
1192 {
1193 struct ssif_bmc_test_ctx *test_ctx = test->priv;
1194 struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1195
1196 KUNIT_ASSERT_EQ(test,
1197 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1198 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1199 KUNIT_ASSERT_EQ(test,
1200 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1201 SSIF_IPMI_SINGLEPART_WRITE), 0);
1202 KUNIT_ASSERT_EQ(test,
1203 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1204 KUNIT_ASSERT_EQ(test,
1205 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x21), 0);
1206 KUNIT_ASSERT_EQ(test,
1207 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1208
1209 KUNIT_ASSERT_TRUE(test, timer_pending(&ssif_bmc->response_timer));
1210 timer_delete_sync(&ssif_bmc->response_timer);
1211 response_timeout(&ssif_bmc->response_timer);
1212
1213 KUNIT_EXPECT_FALSE(test, ssif_bmc->busy);
1214 KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);
1215 KUNIT_EXPECT_FALSE(test, ssif_bmc->response_timer_inited);
1216
1217 KUNIT_EXPECT_EQ(test,
1218 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1219 GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1220 KUNIT_EXPECT_EQ(test,
1221 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1222 SSIF_IPMI_SINGLEPART_WRITE), 0);
1223 KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
1224 KUNIT_EXPECT_EQ(test,
1225 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1226 KUNIT_EXPECT_EQ(test,
1227 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x22), 0);
1228 KUNIT_EXPECT_EQ(test,
1229 ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1230
1231 KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1232 KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1233 KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x22);
1234 }
1235
1236 static struct kunit_case ssif_bmc_test_cases[] = {
1237 KUNIT_CASE(ssif_bmc_test_singlepart_req),
1238 KUNIT_CASE(ssif_bmc_test_restart_write_without_stop),
1239 KUNIT_CASE(ssif_bmc_test_restart_after_invalid_command),
1240 KUNIT_CASE(ssif_bmc_test_singlepart_read_response_completion),
1241 KUNIT_CASE(ssif_bmc_test_stop_during_start_discards_partial_request),
1242 KUNIT_CASE(ssif_bmc_test_read_interrupts_partial_write),
1243 KUNIT_CASE(ssif_bmc_test_write_interrupts_response_send),
1244 KUNIT_CASE(ssif_bmc_test_write_interrupts_response_sending),
1245 KUNIT_CASE(ssif_bmc_test_timeout_interrupt_allows_retry),
1246 {}
1247 };
1248
1249 static struct kunit_suite ssif_bmc_test_suite = {
1250 .name = "ssif_bmc_test",
1251 .init = ssif_bmc_test_init,
1252 .exit = ssif_bmc_test_exit,
1253 .test_cases = ssif_bmc_test_cases,
1254 };
1255
1256 kunit_test_suite(ssif_bmc_test_suite);
1257 #endif
1258
1259 module_i2c_driver(ssif_bmc_driver);
1260
1261 MODULE_AUTHOR("Quan Nguyen <quan@os.amperecomputing.com>");
1262 MODULE_AUTHOR("Chuong Tran <chuong@os.amperecomputing.com>");
1263 MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface.");
1264 MODULE_LICENSE("GPL");
1265