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 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 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 */ 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 */ 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 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 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 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. */ 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 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. */ 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 { 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 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 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 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 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 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 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 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 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 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 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 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 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 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