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 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 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 */ 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 */ 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 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 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 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. */ 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 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. */ 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 }, 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