1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * ipmi_ssif.c 4 * 5 * The interface to the IPMI driver for SMBus access to a SMBus 6 * compliant device. Called SSIF by the IPMI spec. 7 * 8 * Author: Intel Corporation 9 * Todd Davis <todd.c.davis@intel.com> 10 * 11 * Rewritten by Corey Minyard <minyard@acm.org> to support the 12 * non-blocking I2C interface, add support for multi-part 13 * transactions, add PEC support, and general clenaup. 14 * 15 * Copyright 2003 Intel Corporation 16 * Copyright 2005 MontaVista Software 17 */ 18 19 /* 20 * This file holds the "policy" for the interface to the SSIF state 21 * machine. It does the configuration, handles timers and interrupts, 22 * and drives the real SSIF state machine. 23 */ 24 25 #define pr_fmt(fmt) "ipmi_ssif: " fmt 26 #define dev_fmt(fmt) "ipmi_ssif: " fmt 27 28 #if defined(MODVERSIONS) 29 #include <linux/modversions.h> 30 #endif 31 32 #include <linux/module.h> 33 #include <linux/moduleparam.h> 34 #include <linux/sched.h> 35 #include <linux/seq_file.h> 36 #include <linux/timer.h> 37 #include <linux/delay.h> 38 #include <linux/errno.h> 39 #include <linux/spinlock.h> 40 #include <linux/slab.h> 41 #include <linux/list.h> 42 #include <linux/i2c.h> 43 #include <linux/ipmi_smi.h> 44 #include <linux/init.h> 45 #include <linux/dmi.h> 46 #include <linux/kthread.h> 47 #include <linux/acpi.h> 48 #include <linux/ctype.h> 49 #include <linux/time64.h> 50 #include "ipmi_dmi.h" 51 52 #define DEVICE_NAME "ipmi_ssif" 53 54 #define IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD 0x57 55 56 #define SSIF_IPMI_REQUEST 2 57 #define SSIF_IPMI_MULTI_PART_REQUEST_START 6 58 #define SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE 7 59 #define SSIF_IPMI_MULTI_PART_REQUEST_END 8 60 #define SSIF_IPMI_RESPONSE 3 61 #define SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE 9 62 63 /* ssif_debug is a bit-field 64 * SSIF_DEBUG_MSG - commands and their responses 65 * SSIF_DEBUG_STATES - message states 66 * SSIF_DEBUG_TIMING - Measure times between events in the driver 67 */ 68 #define SSIF_DEBUG_TIMING 4 69 #define SSIF_DEBUG_STATE 2 70 #define SSIF_DEBUG_MSG 1 71 #define SSIF_NODEBUG 0 72 #define SSIF_DEFAULT_DEBUG (SSIF_NODEBUG) 73 74 /* 75 * Timer values 76 */ 77 #define SSIF_MSG_USEC 60000 /* 60ms between message tries (T3). */ 78 #define SSIF_REQ_RETRY_USEC 60000 /* 60ms between send retries (T6). */ 79 #define SSIF_MSG_PART_USEC 5000 /* 5ms for a message part */ 80 81 /* How many times to we retry sending/receiving the message. */ 82 #define SSIF_SEND_RETRIES 5 83 #define SSIF_RECV_RETRIES 250 84 85 #define SSIF_MSG_MSEC (SSIF_MSG_USEC / 1000) 86 #define SSIF_REQ_RETRY_MSEC (SSIF_REQ_RETRY_USEC / 1000) 87 #define SSIF_MSG_JIFFIES ((SSIF_MSG_USEC * 1000) / TICK_NSEC) 88 #define SSIF_REQ_RETRY_JIFFIES ((SSIF_REQ_RETRY_USEC * 1000) / TICK_NSEC) 89 #define SSIF_MSG_PART_JIFFIES ((SSIF_MSG_PART_USEC * 1000) / TICK_NSEC) 90 91 /* 92 * Timeout for the watch, only used for get flag timer. 93 */ 94 #define SSIF_WATCH_MSG_TIMEOUT msecs_to_jiffies(10) 95 #define SSIF_WATCH_WATCHDOG_TIMEOUT msecs_to_jiffies(250) 96 97 enum ssif_intf_state { 98 SSIF_IDLE, 99 SSIF_GETTING_FLAGS, 100 SSIF_GETTING_EVENTS, 101 SSIF_CLEARING_FLAGS, 102 SSIF_GETTING_MESSAGES, 103 /* FIXME - add watchdog stuff. */ 104 }; 105 106 #define IS_SSIF_IDLE(ssif) ((ssif)->ssif_state == SSIF_IDLE \ 107 && (ssif)->curr_msg == NULL) 108 109 /* 110 * Indexes into stats[] in ssif_info below. 111 */ 112 enum ssif_stat_indexes { 113 /* Number of total messages sent. */ 114 SSIF_STAT_sent_messages = 0, 115 116 /* 117 * Number of message parts sent. Messages may be broken into 118 * parts if they are long. 119 */ 120 SSIF_STAT_sent_messages_parts, 121 122 /* 123 * Number of time a message was retried. 124 */ 125 SSIF_STAT_send_retries, 126 127 /* 128 * Number of times the send of a message failed. 129 */ 130 SSIF_STAT_send_errors, 131 132 /* 133 * Number of message responses received. 134 */ 135 SSIF_STAT_received_messages, 136 137 /* 138 * Number of message fragments received. 139 */ 140 SSIF_STAT_received_message_parts, 141 142 /* 143 * Number of times the receive of a message was retried. 144 */ 145 SSIF_STAT_receive_retries, 146 147 /* 148 * Number of errors receiving messages. 149 */ 150 SSIF_STAT_receive_errors, 151 152 /* 153 * Number of times a flag fetch was requested. 154 */ 155 SSIF_STAT_flag_fetches, 156 157 /* 158 * Number of times the hardware didn't follow the state machine. 159 */ 160 SSIF_STAT_hosed, 161 162 /* 163 * Number of received events. 164 */ 165 SSIF_STAT_events, 166 167 /* Number of asyncronous messages received. */ 168 SSIF_STAT_incoming_messages, 169 170 /* Number of watchdog pretimeouts. */ 171 SSIF_STAT_watchdog_pretimeouts, 172 173 /* Number of alers received. */ 174 SSIF_STAT_alerts, 175 176 /* Always add statistics before this value, it must be last. */ 177 SSIF_NUM_STATS 178 }; 179 180 struct ssif_addr_info { 181 struct i2c_board_info binfo; 182 char *adapter_name; 183 int debug; 184 int slave_addr; 185 enum ipmi_addr_src addr_src; 186 union ipmi_smi_info_union addr_info; 187 struct device *dev; 188 struct i2c_client *client; 189 190 struct mutex clients_mutex; 191 struct list_head clients; 192 193 struct list_head link; 194 }; 195 196 struct ssif_info; 197 198 typedef void (*ssif_i2c_done)(struct ssif_info *ssif_info, int result, 199 unsigned char *data, unsigned int len); 200 201 struct ssif_info { 202 struct ipmi_smi *intf; 203 spinlock_t lock; 204 struct ipmi_smi_msg *waiting_msg; 205 struct ipmi_smi_msg *curr_msg; 206 enum ssif_intf_state ssif_state; 207 unsigned long ssif_debug; 208 209 struct ipmi_smi_handlers handlers; 210 211 enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */ 212 union ipmi_smi_info_union addr_info; 213 214 /* 215 * Flags from the last GET_MSG_FLAGS command, used when an ATTN 216 * is set to hold the flags until we are done handling everything 217 * from the flags. 218 */ 219 #define RECEIVE_MSG_AVAIL 0x01 220 #define EVENT_MSG_BUFFER_FULL 0x02 221 #define WDT_PRE_TIMEOUT_INT 0x08 222 unsigned char msg_flags; 223 224 u8 global_enables; 225 bool has_event_buffer; 226 bool supports_alert; 227 228 /* 229 * Used to tell what we should do with alerts. If we are 230 * waiting on a response, read the data immediately. 231 */ 232 bool got_alert; 233 bool waiting_alert; 234 235 /* Used to inform the timeout that it should do a resend. */ 236 bool do_resend; 237 238 /* 239 * If set to true, this will request events the next time the 240 * state machine is idle. 241 */ 242 bool req_events; 243 244 /* 245 * If set to true, this will request flags the next time the 246 * state machine is idle. 247 */ 248 bool req_flags; 249 250 /* Used for sending/receiving data. +1 for the length. */ 251 unsigned char data[IPMI_MAX_MSG_LENGTH + 1]; 252 unsigned int data_len; 253 254 /* Temp receive buffer, gets copied into data. */ 255 unsigned char recv[I2C_SMBUS_BLOCK_MAX]; 256 257 struct i2c_client *client; 258 ssif_i2c_done done_handler; 259 260 /* Thread interface handling */ 261 struct task_struct *thread; 262 struct completion wake_thread; 263 bool stopping; 264 int i2c_read_write; 265 int i2c_command; 266 unsigned char *i2c_data; 267 unsigned int i2c_size; 268 269 struct timer_list retry_timer; 270 int retries_left; 271 272 long watch_timeout; /* Timeout for flags check, 0 if off. */ 273 struct timer_list watch_timer; /* Flag fetch timer. */ 274 275 /* Info from SSIF cmd */ 276 unsigned char max_xmit_msg_size; 277 unsigned char max_recv_msg_size; 278 bool cmd8_works; /* See test_multipart_messages() for details. */ 279 unsigned int multi_support; 280 int supports_pec; 281 282 #define SSIF_NO_MULTI 0 283 #define SSIF_MULTI_2_PART 1 284 #define SSIF_MULTI_n_PART 2 285 unsigned char *multi_data; 286 unsigned int multi_len; 287 unsigned int multi_pos; 288 289 atomic_t stats[SSIF_NUM_STATS]; 290 }; 291 292 #define ssif_inc_stat(ssif, stat) \ 293 atomic_inc(&(ssif)->stats[SSIF_STAT_ ## stat]) 294 #define ssif_get_stat(ssif, stat) \ 295 ((unsigned int) atomic_read(&(ssif)->stats[SSIF_STAT_ ## stat])) 296 297 static bool initialized; 298 static bool platform_registered; 299 300 static void return_hosed_msg(struct ssif_info *ssif_info, 301 struct ipmi_smi_msg *msg); 302 static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags); 303 static int start_send(struct ssif_info *ssif_info, 304 unsigned char *data, 305 unsigned int len); 306 307 static unsigned long *ipmi_ssif_lock_cond(struct ssif_info *ssif_info, 308 unsigned long *flags) 309 __acquires(&ssif_info->lock) 310 { 311 spin_lock_irqsave(&ssif_info->lock, *flags); 312 return flags; 313 } 314 315 static void ipmi_ssif_unlock_cond(struct ssif_info *ssif_info, 316 unsigned long *flags) 317 __releases(&ssif_info->lock) 318 { 319 spin_unlock_irqrestore(&ssif_info->lock, *flags); 320 } 321 322 static void deliver_recv_msg(struct ssif_info *ssif_info, 323 struct ipmi_smi_msg *msg) 324 { 325 if (msg->rsp_size < 0) { 326 return_hosed_msg(ssif_info, msg); 327 dev_err(&ssif_info->client->dev, 328 "%s: Malformed message: rsp_size = %d\n", 329 __func__, msg->rsp_size); 330 } else { 331 ipmi_smi_msg_received(ssif_info->intf, msg); 332 } 333 } 334 335 static void return_hosed_msg(struct ssif_info *ssif_info, 336 struct ipmi_smi_msg *msg) 337 { 338 ssif_inc_stat(ssif_info, hosed); 339 340 /* Make it a response */ 341 msg->rsp[0] = msg->data[0] | 4; 342 msg->rsp[1] = msg->data[1]; 343 msg->rsp[2] = 0xFF; /* Unknown error. */ 344 msg->rsp_size = 3; 345 346 deliver_recv_msg(ssif_info, msg); 347 } 348 349 /* 350 * Must be called with the message lock held. This will release the 351 * message lock. Note that the caller will check IS_SSIF_IDLE and 352 * start a new operation, so there is no need to check for new 353 * messages to start in here. 354 */ 355 static void start_clear_flags(struct ssif_info *ssif_info, unsigned long *flags) 356 { 357 unsigned char msg[3]; 358 359 ssif_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT; 360 ssif_info->ssif_state = SSIF_CLEARING_FLAGS; 361 ipmi_ssif_unlock_cond(ssif_info, flags); 362 363 /* Make sure the watchdog pre-timeout flag is not set at startup. */ 364 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 365 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD; 366 msg[2] = WDT_PRE_TIMEOUT_INT; 367 368 if (start_send(ssif_info, msg, 3) != 0) { 369 /* Error, just go to normal state. */ 370 ssif_info->ssif_state = SSIF_IDLE; 371 } 372 } 373 374 static void start_flag_fetch(struct ssif_info *ssif_info, unsigned long *flags) 375 { 376 unsigned char mb[2]; 377 378 ssif_info->req_flags = false; 379 ssif_info->ssif_state = SSIF_GETTING_FLAGS; 380 ipmi_ssif_unlock_cond(ssif_info, flags); 381 382 mb[0] = (IPMI_NETFN_APP_REQUEST << 2); 383 mb[1] = IPMI_GET_MSG_FLAGS_CMD; 384 if (start_send(ssif_info, mb, 2) != 0) 385 ssif_info->ssif_state = SSIF_IDLE; 386 } 387 388 static void check_start_send(struct ssif_info *ssif_info, unsigned long *flags, 389 struct ipmi_smi_msg *msg) 390 { 391 if (start_send(ssif_info, msg->data, msg->data_size) != 0) { 392 unsigned long oflags; 393 394 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 395 ssif_info->curr_msg = NULL; 396 ssif_info->ssif_state = SSIF_IDLE; 397 ipmi_ssif_unlock_cond(ssif_info, flags); 398 ipmi_free_smi_msg(msg); 399 } 400 } 401 402 static void start_event_fetch(struct ssif_info *ssif_info, unsigned long *flags) 403 { 404 struct ipmi_smi_msg *msg; 405 406 ssif_info->req_events = false; 407 408 msg = ipmi_alloc_smi_msg(); 409 if (!msg) { 410 ssif_info->ssif_state = SSIF_IDLE; 411 ipmi_ssif_unlock_cond(ssif_info, flags); 412 return; 413 } 414 415 ssif_info->curr_msg = msg; 416 ssif_info->ssif_state = SSIF_GETTING_EVENTS; 417 ipmi_ssif_unlock_cond(ssif_info, flags); 418 419 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 420 msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD; 421 msg->data_size = 2; 422 423 check_start_send(ssif_info, flags, msg); 424 } 425 426 static void start_recv_msg_fetch(struct ssif_info *ssif_info, 427 unsigned long *flags) 428 { 429 struct ipmi_smi_msg *msg; 430 431 msg = ipmi_alloc_smi_msg(); 432 if (!msg) { 433 ssif_info->ssif_state = SSIF_IDLE; 434 ipmi_ssif_unlock_cond(ssif_info, flags); 435 return; 436 } 437 438 ssif_info->curr_msg = msg; 439 ssif_info->ssif_state = SSIF_GETTING_MESSAGES; 440 ipmi_ssif_unlock_cond(ssif_info, flags); 441 442 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 443 msg->data[1] = IPMI_GET_MSG_CMD; 444 msg->data_size = 2; 445 446 check_start_send(ssif_info, flags, msg); 447 } 448 449 /* 450 * Must be called with the message lock held. This will release the 451 * message lock. Note that the caller will check IS_SSIF_IDLE and 452 * start a new operation, so there is no need to check for new 453 * messages to start in here. 454 */ 455 static void handle_flags(struct ssif_info *ssif_info, unsigned long *flags) 456 { 457 if (ssif_info->msg_flags & WDT_PRE_TIMEOUT_INT) { 458 /* Watchdog pre-timeout */ 459 ssif_inc_stat(ssif_info, watchdog_pretimeouts); 460 start_clear_flags(ssif_info, flags); 461 ipmi_smi_watchdog_pretimeout(ssif_info->intf); 462 } else if (ssif_info->msg_flags & RECEIVE_MSG_AVAIL) 463 /* Messages available. */ 464 start_recv_msg_fetch(ssif_info, flags); 465 else if (ssif_info->msg_flags & EVENT_MSG_BUFFER_FULL) 466 /* Events available. */ 467 start_event_fetch(ssif_info, flags); 468 else { 469 ssif_info->ssif_state = SSIF_IDLE; 470 ipmi_ssif_unlock_cond(ssif_info, flags); 471 } 472 } 473 474 static int ipmi_ssif_thread(void *data) 475 { 476 struct ssif_info *ssif_info = data; 477 478 while (!kthread_should_stop()) { 479 int result; 480 481 /* Wait for something to do */ 482 result = wait_for_completion_interruptible( 483 &ssif_info->wake_thread); 484 if (result == -ERESTARTSYS) 485 continue; 486 init_completion(&ssif_info->wake_thread); 487 488 if (ssif_info->i2c_read_write == I2C_SMBUS_WRITE) { 489 result = i2c_smbus_write_block_data( 490 ssif_info->client, ssif_info->i2c_command, 491 ssif_info->i2c_data[0], 492 ssif_info->i2c_data + 1); 493 ssif_info->done_handler(ssif_info, result, NULL, 0); 494 } else { 495 result = i2c_smbus_read_block_data( 496 ssif_info->client, ssif_info->i2c_command, 497 ssif_info->i2c_data); 498 if (result < 0) 499 ssif_info->done_handler(ssif_info, result, 500 NULL, 0); 501 else 502 ssif_info->done_handler(ssif_info, 0, 503 ssif_info->i2c_data, 504 result); 505 } 506 } 507 508 return 0; 509 } 510 511 static void ssif_i2c_send(struct ssif_info *ssif_info, 512 ssif_i2c_done handler, 513 int read_write, int command, 514 unsigned char *data, unsigned int size) 515 { 516 ssif_info->done_handler = handler; 517 518 ssif_info->i2c_read_write = read_write; 519 ssif_info->i2c_command = command; 520 ssif_info->i2c_data = data; 521 ssif_info->i2c_size = size; 522 complete(&ssif_info->wake_thread); 523 } 524 525 526 static void msg_done_handler(struct ssif_info *ssif_info, int result, 527 unsigned char *data, unsigned int len); 528 529 static void start_get(struct ssif_info *ssif_info) 530 { 531 ssif_info->multi_pos = 0; 532 533 ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ, 534 SSIF_IPMI_RESPONSE, 535 ssif_info->recv, I2C_SMBUS_BLOCK_DATA); 536 } 537 538 static void start_resend(struct ssif_info *ssif_info); 539 540 static void retry_timeout(struct timer_list *t) 541 { 542 struct ssif_info *ssif_info = from_timer(ssif_info, t, retry_timer); 543 unsigned long oflags, *flags; 544 bool waiting, resend; 545 546 if (ssif_info->stopping) 547 return; 548 549 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 550 resend = ssif_info->do_resend; 551 ssif_info->do_resend = false; 552 waiting = ssif_info->waiting_alert; 553 ssif_info->waiting_alert = false; 554 ipmi_ssif_unlock_cond(ssif_info, flags); 555 556 if (waiting) 557 start_get(ssif_info); 558 if (resend) { 559 start_resend(ssif_info); 560 ssif_inc_stat(ssif_info, send_retries); 561 } 562 } 563 564 static void watch_timeout(struct timer_list *t) 565 { 566 struct ssif_info *ssif_info = from_timer(ssif_info, t, watch_timer); 567 unsigned long oflags, *flags; 568 569 if (ssif_info->stopping) 570 return; 571 572 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 573 if (ssif_info->watch_timeout) { 574 mod_timer(&ssif_info->watch_timer, 575 jiffies + ssif_info->watch_timeout); 576 if (IS_SSIF_IDLE(ssif_info)) { 577 start_flag_fetch(ssif_info, flags); /* Releases lock */ 578 return; 579 } 580 ssif_info->req_flags = true; 581 } 582 ipmi_ssif_unlock_cond(ssif_info, flags); 583 } 584 585 static void ssif_alert(struct i2c_client *client, enum i2c_alert_protocol type, 586 unsigned int data) 587 { 588 struct ssif_info *ssif_info = i2c_get_clientdata(client); 589 unsigned long oflags, *flags; 590 bool do_get = false; 591 592 if (type != I2C_PROTOCOL_SMBUS_ALERT) 593 return; 594 595 ssif_inc_stat(ssif_info, alerts); 596 597 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 598 if (ssif_info->waiting_alert) { 599 ssif_info->waiting_alert = false; 600 timer_delete(&ssif_info->retry_timer); 601 do_get = true; 602 } else if (ssif_info->curr_msg) { 603 ssif_info->got_alert = true; 604 } 605 ipmi_ssif_unlock_cond(ssif_info, flags); 606 if (do_get) 607 start_get(ssif_info); 608 } 609 610 static void msg_done_handler(struct ssif_info *ssif_info, int result, 611 unsigned char *data, unsigned int len) 612 { 613 struct ipmi_smi_msg *msg; 614 unsigned long oflags, *flags; 615 616 /* 617 * We are single-threaded here, so no need for a lock until we 618 * start messing with driver states or the queues. 619 */ 620 621 if (result < 0) { 622 ssif_info->retries_left--; 623 if (ssif_info->retries_left > 0) { 624 ssif_inc_stat(ssif_info, receive_retries); 625 626 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 627 ssif_info->waiting_alert = true; 628 if (!ssif_info->stopping) 629 mod_timer(&ssif_info->retry_timer, 630 jiffies + SSIF_MSG_JIFFIES); 631 ipmi_ssif_unlock_cond(ssif_info, flags); 632 return; 633 } 634 635 ssif_inc_stat(ssif_info, receive_errors); 636 637 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 638 dev_dbg(&ssif_info->client->dev, 639 "%s: Error %d\n", __func__, result); 640 len = 0; 641 goto continue_op; 642 } 643 644 if ((len > 1) && (ssif_info->multi_pos == 0) 645 && (data[0] == 0x00) && (data[1] == 0x01)) { 646 /* Start of multi-part read. Start the next transaction. */ 647 int i; 648 649 ssif_inc_stat(ssif_info, received_message_parts); 650 651 /* Remove the multi-part read marker. */ 652 len -= 2; 653 data += 2; 654 for (i = 0; i < len; i++) 655 ssif_info->data[i] = data[i]; 656 ssif_info->multi_len = len; 657 ssif_info->multi_pos = 1; 658 659 ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ, 660 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE, 661 ssif_info->recv, I2C_SMBUS_BLOCK_DATA); 662 return; 663 } else if (ssif_info->multi_pos) { 664 /* Middle of multi-part read. Start the next transaction. */ 665 int i; 666 unsigned char blocknum; 667 668 if (len == 0) { 669 result = -EIO; 670 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 671 dev_dbg(&ssif_info->client->dev, 672 "Middle message with no data\n"); 673 674 goto continue_op; 675 } 676 677 blocknum = data[0]; 678 len--; 679 data++; 680 681 if (blocknum != 0xff && len != 31) { 682 /* All blocks but the last must have 31 data bytes. */ 683 result = -EIO; 684 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 685 dev_dbg(&ssif_info->client->dev, 686 "Received middle message <31\n"); 687 688 goto continue_op; 689 } 690 691 if (ssif_info->multi_len + len > IPMI_MAX_MSG_LENGTH) { 692 /* Received message too big, abort the operation. */ 693 result = -E2BIG; 694 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 695 dev_dbg(&ssif_info->client->dev, 696 "Received message too big\n"); 697 698 goto continue_op; 699 } 700 701 for (i = 0; i < len; i++) 702 ssif_info->data[i + ssif_info->multi_len] = data[i]; 703 ssif_info->multi_len += len; 704 if (blocknum == 0xff) { 705 /* End of read */ 706 len = ssif_info->multi_len; 707 data = ssif_info->data; 708 } else if (blocknum + 1 != ssif_info->multi_pos) { 709 /* 710 * Out of sequence block, just abort. Block 711 * numbers start at zero for the second block, 712 * but multi_pos starts at one, so the +1. 713 */ 714 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 715 dev_dbg(&ssif_info->client->dev, 716 "Received message out of sequence, expected %u, got %u\n", 717 ssif_info->multi_pos - 1, blocknum); 718 result = -EIO; 719 } else { 720 ssif_inc_stat(ssif_info, received_message_parts); 721 722 ssif_info->multi_pos++; 723 724 ssif_i2c_send(ssif_info, msg_done_handler, 725 I2C_SMBUS_READ, 726 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE, 727 ssif_info->recv, 728 I2C_SMBUS_BLOCK_DATA); 729 return; 730 } 731 } 732 733 continue_op: 734 if (result < 0) { 735 ssif_inc_stat(ssif_info, receive_errors); 736 } else { 737 ssif_inc_stat(ssif_info, received_messages); 738 ssif_inc_stat(ssif_info, received_message_parts); 739 } 740 741 if (ssif_info->ssif_debug & SSIF_DEBUG_STATE) 742 dev_dbg(&ssif_info->client->dev, 743 "DONE 1: state = %d, result=%d\n", 744 ssif_info->ssif_state, result); 745 746 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 747 msg = ssif_info->curr_msg; 748 if (msg) { 749 if (data) { 750 if (len > IPMI_MAX_MSG_LENGTH) 751 len = IPMI_MAX_MSG_LENGTH; 752 memcpy(msg->rsp, data, len); 753 } else { 754 len = 0; 755 } 756 msg->rsp_size = len; 757 ssif_info->curr_msg = NULL; 758 } 759 760 switch (ssif_info->ssif_state) { 761 case SSIF_IDLE: 762 ipmi_ssif_unlock_cond(ssif_info, flags); 763 if (!msg) 764 break; 765 766 if (result < 0) 767 return_hosed_msg(ssif_info, msg); 768 else 769 deliver_recv_msg(ssif_info, msg); 770 break; 771 772 case SSIF_GETTING_FLAGS: 773 /* We got the flags from the SSIF, now handle them. */ 774 if ((result < 0) || (len < 4) || (data[2] != 0)) { 775 /* 776 * Error fetching flags, or invalid length, 777 * just give up for now. 778 */ 779 ssif_info->ssif_state = SSIF_IDLE; 780 ipmi_ssif_unlock_cond(ssif_info, flags); 781 dev_warn(&ssif_info->client->dev, 782 "Error getting flags: %d %d, %x\n", 783 result, len, (len >= 3) ? data[2] : 0); 784 } else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 785 || data[1] != IPMI_GET_MSG_FLAGS_CMD) { 786 /* 787 * Recv error response, give up. 788 */ 789 ssif_info->ssif_state = SSIF_IDLE; 790 ipmi_ssif_unlock_cond(ssif_info, flags); 791 dev_warn(&ssif_info->client->dev, 792 "Invalid response getting flags: %x %x\n", 793 data[0], data[1]); 794 } else { 795 ssif_inc_stat(ssif_info, flag_fetches); 796 ssif_info->msg_flags = data[3]; 797 handle_flags(ssif_info, flags); 798 } 799 break; 800 801 case SSIF_CLEARING_FLAGS: 802 /* We cleared the flags. */ 803 if ((result < 0) || (len < 3) || (data[2] != 0)) { 804 /* Error clearing flags */ 805 dev_warn(&ssif_info->client->dev, 806 "Error clearing flags: %d %d, %x\n", 807 result, len, (len >= 3) ? data[2] : 0); 808 } else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 809 || data[1] != IPMI_CLEAR_MSG_FLAGS_CMD) { 810 dev_warn(&ssif_info->client->dev, 811 "Invalid response clearing flags: %x %x\n", 812 data[0], data[1]); 813 } 814 ssif_info->ssif_state = SSIF_IDLE; 815 ipmi_ssif_unlock_cond(ssif_info, flags); 816 break; 817 818 case SSIF_GETTING_EVENTS: 819 if (!msg) { 820 /* Should never happen, but just in case. */ 821 dev_warn(&ssif_info->client->dev, 822 "No message set while getting events\n"); 823 ipmi_ssif_unlock_cond(ssif_info, flags); 824 break; 825 } 826 827 if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) { 828 /* Error getting event, probably done. */ 829 msg->done(msg); 830 831 /* Take off the event flag. */ 832 ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 833 handle_flags(ssif_info, flags); 834 } else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 835 || msg->rsp[1] != IPMI_READ_EVENT_MSG_BUFFER_CMD) { 836 dev_warn(&ssif_info->client->dev, 837 "Invalid response getting events: %x %x\n", 838 msg->rsp[0], msg->rsp[1]); 839 msg->done(msg); 840 /* Take off the event flag. */ 841 ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 842 handle_flags(ssif_info, flags); 843 } else { 844 handle_flags(ssif_info, flags); 845 ssif_inc_stat(ssif_info, events); 846 deliver_recv_msg(ssif_info, msg); 847 } 848 break; 849 850 case SSIF_GETTING_MESSAGES: 851 if (!msg) { 852 /* Should never happen, but just in case. */ 853 dev_warn(&ssif_info->client->dev, 854 "No message set while getting messages\n"); 855 ipmi_ssif_unlock_cond(ssif_info, flags); 856 break; 857 } 858 859 if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) { 860 /* Error getting event, probably done. */ 861 msg->done(msg); 862 863 /* Take off the msg flag. */ 864 ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 865 handle_flags(ssif_info, flags); 866 } else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 867 || msg->rsp[1] != IPMI_GET_MSG_CMD) { 868 dev_warn(&ssif_info->client->dev, 869 "Invalid response clearing flags: %x %x\n", 870 msg->rsp[0], msg->rsp[1]); 871 msg->done(msg); 872 873 /* Take off the msg flag. */ 874 ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 875 handle_flags(ssif_info, flags); 876 } else { 877 ssif_inc_stat(ssif_info, incoming_messages); 878 handle_flags(ssif_info, flags); 879 deliver_recv_msg(ssif_info, msg); 880 } 881 break; 882 883 default: 884 /* Should never happen, but just in case. */ 885 dev_warn(&ssif_info->client->dev, 886 "Invalid state in message done handling: %d\n", 887 ssif_info->ssif_state); 888 ipmi_ssif_unlock_cond(ssif_info, flags); 889 } 890 891 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 892 if (IS_SSIF_IDLE(ssif_info) && !ssif_info->stopping) { 893 if (ssif_info->req_events) 894 start_event_fetch(ssif_info, flags); 895 else if (ssif_info->req_flags) 896 start_flag_fetch(ssif_info, flags); 897 else 898 start_next_msg(ssif_info, flags); 899 } else 900 ipmi_ssif_unlock_cond(ssif_info, flags); 901 902 if (ssif_info->ssif_debug & SSIF_DEBUG_STATE) 903 dev_dbg(&ssif_info->client->dev, 904 "DONE 2: state = %d.\n", ssif_info->ssif_state); 905 } 906 907 static void msg_written_handler(struct ssif_info *ssif_info, int result, 908 unsigned char *data, unsigned int len) 909 { 910 /* We are single-threaded here, so no need for a lock. */ 911 if (result < 0) { 912 ssif_info->retries_left--; 913 if (ssif_info->retries_left > 0) { 914 /* 915 * Wait the retry timeout time per the spec, 916 * then redo the send. 917 */ 918 ssif_info->do_resend = true; 919 mod_timer(&ssif_info->retry_timer, 920 jiffies + SSIF_REQ_RETRY_JIFFIES); 921 return; 922 } 923 924 ssif_inc_stat(ssif_info, send_errors); 925 926 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 927 dev_dbg(&ssif_info->client->dev, 928 "%s: Out of retries\n", __func__); 929 930 msg_done_handler(ssif_info, -EIO, NULL, 0); 931 return; 932 } 933 934 if (ssif_info->multi_data) { 935 /* 936 * In the middle of a multi-data write. See the comment 937 * in the SSIF_MULTI_n_PART case in the probe function 938 * for details on the intricacies of this. 939 */ 940 int left, to_write; 941 unsigned char *data_to_send; 942 unsigned char cmd; 943 944 ssif_inc_stat(ssif_info, sent_messages_parts); 945 946 left = ssif_info->multi_len - ssif_info->multi_pos; 947 to_write = left; 948 if (to_write > 32) 949 to_write = 32; 950 /* Length byte. */ 951 ssif_info->multi_data[ssif_info->multi_pos] = to_write; 952 data_to_send = ssif_info->multi_data + ssif_info->multi_pos; 953 ssif_info->multi_pos += to_write; 954 cmd = SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE; 955 if (ssif_info->cmd8_works) { 956 if (left == to_write) { 957 cmd = SSIF_IPMI_MULTI_PART_REQUEST_END; 958 ssif_info->multi_data = NULL; 959 } 960 } else if (to_write < 32) { 961 ssif_info->multi_data = NULL; 962 } 963 964 ssif_i2c_send(ssif_info, msg_written_handler, 965 I2C_SMBUS_WRITE, cmd, 966 data_to_send, I2C_SMBUS_BLOCK_DATA); 967 } else { 968 /* Ready to request the result. */ 969 unsigned long oflags, *flags; 970 971 ssif_inc_stat(ssif_info, sent_messages); 972 ssif_inc_stat(ssif_info, sent_messages_parts); 973 974 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 975 if (ssif_info->got_alert) { 976 /* The result is already ready, just start it. */ 977 ssif_info->got_alert = false; 978 ipmi_ssif_unlock_cond(ssif_info, flags); 979 start_get(ssif_info); 980 } else { 981 /* Wait a jiffy then request the next message */ 982 ssif_info->waiting_alert = true; 983 ssif_info->retries_left = SSIF_RECV_RETRIES; 984 if (!ssif_info->stopping) 985 mod_timer(&ssif_info->retry_timer, 986 jiffies + SSIF_MSG_PART_JIFFIES); 987 ipmi_ssif_unlock_cond(ssif_info, flags); 988 } 989 } 990 } 991 992 static void start_resend(struct ssif_info *ssif_info) 993 { 994 int command; 995 996 ssif_info->got_alert = false; 997 998 if (ssif_info->data_len > 32) { 999 command = SSIF_IPMI_MULTI_PART_REQUEST_START; 1000 ssif_info->multi_data = ssif_info->data; 1001 ssif_info->multi_len = ssif_info->data_len; 1002 /* 1003 * Subtle thing, this is 32, not 33, because we will 1004 * overwrite the thing at position 32 (which was just 1005 * transmitted) with the new length. 1006 */ 1007 ssif_info->multi_pos = 32; 1008 ssif_info->data[0] = 32; 1009 } else { 1010 ssif_info->multi_data = NULL; 1011 command = SSIF_IPMI_REQUEST; 1012 ssif_info->data[0] = ssif_info->data_len; 1013 } 1014 1015 ssif_i2c_send(ssif_info, msg_written_handler, I2C_SMBUS_WRITE, 1016 command, ssif_info->data, I2C_SMBUS_BLOCK_DATA); 1017 } 1018 1019 static int start_send(struct ssif_info *ssif_info, 1020 unsigned char *data, 1021 unsigned int len) 1022 { 1023 if (len > IPMI_MAX_MSG_LENGTH) 1024 return -E2BIG; 1025 if (len > ssif_info->max_xmit_msg_size) 1026 return -E2BIG; 1027 1028 ssif_info->retries_left = SSIF_SEND_RETRIES; 1029 memcpy(ssif_info->data + 1, data, len); 1030 ssif_info->data_len = len; 1031 start_resend(ssif_info); 1032 return 0; 1033 } 1034 1035 /* Must be called with the message lock held. */ 1036 static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags) 1037 { 1038 struct ipmi_smi_msg *msg; 1039 unsigned long oflags; 1040 1041 restart: 1042 if (!IS_SSIF_IDLE(ssif_info)) { 1043 ipmi_ssif_unlock_cond(ssif_info, flags); 1044 return; 1045 } 1046 1047 if (!ssif_info->waiting_msg) { 1048 ssif_info->curr_msg = NULL; 1049 ipmi_ssif_unlock_cond(ssif_info, flags); 1050 } else { 1051 int rv; 1052 1053 ssif_info->curr_msg = ssif_info->waiting_msg; 1054 ssif_info->waiting_msg = NULL; 1055 ipmi_ssif_unlock_cond(ssif_info, flags); 1056 rv = start_send(ssif_info, 1057 ssif_info->curr_msg->data, 1058 ssif_info->curr_msg->data_size); 1059 if (rv) { 1060 msg = ssif_info->curr_msg; 1061 ssif_info->curr_msg = NULL; 1062 return_hosed_msg(ssif_info, msg); 1063 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1064 goto restart; 1065 } 1066 } 1067 } 1068 1069 static void sender(void *send_info, 1070 struct ipmi_smi_msg *msg) 1071 { 1072 struct ssif_info *ssif_info = send_info; 1073 unsigned long oflags, *flags; 1074 1075 BUG_ON(ssif_info->waiting_msg); 1076 ssif_info->waiting_msg = msg; 1077 1078 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1079 start_next_msg(ssif_info, flags); 1080 1081 if (ssif_info->ssif_debug & SSIF_DEBUG_TIMING) { 1082 struct timespec64 t; 1083 1084 ktime_get_real_ts64(&t); 1085 dev_dbg(&ssif_info->client->dev, 1086 "**Enqueue %02x %02x: %lld.%6.6ld\n", 1087 msg->data[0], msg->data[1], 1088 (long long)t.tv_sec, (long)t.tv_nsec / NSEC_PER_USEC); 1089 } 1090 } 1091 1092 static int get_smi_info(void *send_info, struct ipmi_smi_info *data) 1093 { 1094 struct ssif_info *ssif_info = send_info; 1095 1096 data->addr_src = ssif_info->addr_source; 1097 data->dev = &ssif_info->client->dev; 1098 data->addr_info = ssif_info->addr_info; 1099 get_device(data->dev); 1100 1101 return 0; 1102 } 1103 1104 /* 1105 * Upper layer wants us to request events. 1106 */ 1107 static void request_events(void *send_info) 1108 { 1109 struct ssif_info *ssif_info = send_info; 1110 unsigned long oflags, *flags; 1111 1112 if (!ssif_info->has_event_buffer) 1113 return; 1114 1115 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1116 ssif_info->req_events = true; 1117 ipmi_ssif_unlock_cond(ssif_info, flags); 1118 } 1119 1120 /* 1121 * Upper layer is changing the flag saying whether we need to request 1122 * flags periodically or not. 1123 */ 1124 static void ssif_set_need_watch(void *send_info, unsigned int watch_mask) 1125 { 1126 struct ssif_info *ssif_info = send_info; 1127 unsigned long oflags, *flags; 1128 long timeout = 0; 1129 1130 if (watch_mask & IPMI_WATCH_MASK_CHECK_MESSAGES) 1131 timeout = SSIF_WATCH_MSG_TIMEOUT; 1132 else if (watch_mask) 1133 timeout = SSIF_WATCH_WATCHDOG_TIMEOUT; 1134 1135 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1136 if (timeout != ssif_info->watch_timeout) { 1137 ssif_info->watch_timeout = timeout; 1138 if (ssif_info->watch_timeout) 1139 mod_timer(&ssif_info->watch_timer, 1140 jiffies + ssif_info->watch_timeout); 1141 } 1142 ipmi_ssif_unlock_cond(ssif_info, flags); 1143 } 1144 1145 static int ssif_start_processing(void *send_info, 1146 struct ipmi_smi *intf) 1147 { 1148 struct ssif_info *ssif_info = send_info; 1149 1150 ssif_info->intf = intf; 1151 1152 return 0; 1153 } 1154 1155 #define MAX_SSIF_BMCS 4 1156 1157 static unsigned short addr[MAX_SSIF_BMCS]; 1158 static int num_addrs; 1159 module_param_array(addr, ushort, &num_addrs, 0); 1160 MODULE_PARM_DESC(addr, "The addresses to scan for IPMI BMCs on the SSIFs."); 1161 1162 static char *adapter_name[MAX_SSIF_BMCS]; 1163 static int num_adapter_names; 1164 module_param_array(adapter_name, charp, &num_adapter_names, 0); 1165 MODULE_PARM_DESC(adapter_name, "The string name of the I2C device that has the BMC. By default all devices are scanned."); 1166 1167 static int slave_addrs[MAX_SSIF_BMCS]; 1168 static int num_slave_addrs; 1169 module_param_array(slave_addrs, int, &num_slave_addrs, 0); 1170 MODULE_PARM_DESC(slave_addrs, 1171 "The default IPMB slave address for the controller."); 1172 1173 static bool alerts_broken; 1174 module_param(alerts_broken, bool, 0); 1175 MODULE_PARM_DESC(alerts_broken, "Don't enable alerts for the controller."); 1176 1177 /* 1178 * Bit 0 enables message debugging, bit 1 enables state debugging, and 1179 * bit 2 enables timing debugging. This is an array indexed by 1180 * interface number" 1181 */ 1182 static int dbg[MAX_SSIF_BMCS]; 1183 static int num_dbg; 1184 module_param_array(dbg, int, &num_dbg, 0); 1185 MODULE_PARM_DESC(dbg, "Turn on debugging."); 1186 1187 static bool ssif_dbg_probe; 1188 module_param_named(dbg_probe, ssif_dbg_probe, bool, 0); 1189 MODULE_PARM_DESC(dbg_probe, "Enable debugging of probing of adapters."); 1190 1191 static bool ssif_tryacpi = true; 1192 module_param_named(tryacpi, ssif_tryacpi, bool, 0); 1193 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the default scan of the interfaces identified via ACPI"); 1194 1195 static bool ssif_trydmi = true; 1196 module_param_named(trydmi, ssif_trydmi, bool, 0); 1197 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the default scan of the interfaces identified via DMI (SMBIOS)"); 1198 1199 static DEFINE_MUTEX(ssif_infos_mutex); 1200 static LIST_HEAD(ssif_infos); 1201 1202 #define IPMI_SSIF_ATTR(name) \ 1203 static ssize_t ipmi_##name##_show(struct device *dev, \ 1204 struct device_attribute *attr, \ 1205 char *buf) \ 1206 { \ 1207 struct ssif_info *ssif_info = dev_get_drvdata(dev); \ 1208 \ 1209 return sysfs_emit(buf, "%u\n", ssif_get_stat(ssif_info, name));\ 1210 } \ 1211 static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL) 1212 1213 static ssize_t ipmi_type_show(struct device *dev, 1214 struct device_attribute *attr, 1215 char *buf) 1216 { 1217 return sysfs_emit(buf, "ssif\n"); 1218 } 1219 static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL); 1220 1221 IPMI_SSIF_ATTR(sent_messages); 1222 IPMI_SSIF_ATTR(sent_messages_parts); 1223 IPMI_SSIF_ATTR(send_retries); 1224 IPMI_SSIF_ATTR(send_errors); 1225 IPMI_SSIF_ATTR(received_messages); 1226 IPMI_SSIF_ATTR(received_message_parts); 1227 IPMI_SSIF_ATTR(receive_retries); 1228 IPMI_SSIF_ATTR(receive_errors); 1229 IPMI_SSIF_ATTR(flag_fetches); 1230 IPMI_SSIF_ATTR(hosed); 1231 IPMI_SSIF_ATTR(events); 1232 IPMI_SSIF_ATTR(watchdog_pretimeouts); 1233 IPMI_SSIF_ATTR(alerts); 1234 1235 static struct attribute *ipmi_ssif_dev_attrs[] = { 1236 &dev_attr_type.attr, 1237 &dev_attr_sent_messages.attr, 1238 &dev_attr_sent_messages_parts.attr, 1239 &dev_attr_send_retries.attr, 1240 &dev_attr_send_errors.attr, 1241 &dev_attr_received_messages.attr, 1242 &dev_attr_received_message_parts.attr, 1243 &dev_attr_receive_retries.attr, 1244 &dev_attr_receive_errors.attr, 1245 &dev_attr_flag_fetches.attr, 1246 &dev_attr_hosed.attr, 1247 &dev_attr_events.attr, 1248 &dev_attr_watchdog_pretimeouts.attr, 1249 &dev_attr_alerts.attr, 1250 NULL 1251 }; 1252 1253 static const struct attribute_group ipmi_ssif_dev_attr_group = { 1254 .attrs = ipmi_ssif_dev_attrs, 1255 }; 1256 1257 static void shutdown_ssif(void *send_info) 1258 { 1259 struct ssif_info *ssif_info = send_info; 1260 1261 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group); 1262 dev_set_drvdata(&ssif_info->client->dev, NULL); 1263 1264 /* make sure the driver is not looking for flags any more. */ 1265 while (ssif_info->ssif_state != SSIF_IDLE) 1266 schedule_timeout(1); 1267 1268 ssif_info->stopping = true; 1269 timer_delete_sync(&ssif_info->watch_timer); 1270 timer_delete_sync(&ssif_info->retry_timer); 1271 if (ssif_info->thread) 1272 kthread_stop(ssif_info->thread); 1273 } 1274 1275 static void ssif_remove(struct i2c_client *client) 1276 { 1277 struct ssif_info *ssif_info = i2c_get_clientdata(client); 1278 struct ssif_addr_info *addr_info; 1279 1280 /* 1281 * After this point, we won't deliver anything asynchronously 1282 * to the message handler. We can unregister ourself. 1283 */ 1284 ipmi_unregister_smi(ssif_info->intf); 1285 1286 list_for_each_entry(addr_info, &ssif_infos, link) { 1287 if (addr_info->client == client) { 1288 addr_info->client = NULL; 1289 break; 1290 } 1291 } 1292 1293 kfree(ssif_info); 1294 } 1295 1296 static int read_response(struct i2c_client *client, unsigned char *resp) 1297 { 1298 int ret = -ENODEV, retry_cnt = SSIF_RECV_RETRIES; 1299 1300 while (retry_cnt > 0) { 1301 ret = i2c_smbus_read_block_data(client, SSIF_IPMI_RESPONSE, 1302 resp); 1303 if (ret > 0) 1304 break; 1305 msleep(SSIF_MSG_MSEC); 1306 retry_cnt--; 1307 if (retry_cnt <= 0) 1308 break; 1309 } 1310 1311 return ret; 1312 } 1313 1314 static int do_cmd(struct i2c_client *client, int len, unsigned char *msg, 1315 int *resp_len, unsigned char *resp) 1316 { 1317 int retry_cnt; 1318 int ret; 1319 1320 retry_cnt = SSIF_SEND_RETRIES; 1321 retry1: 1322 ret = i2c_smbus_write_block_data(client, SSIF_IPMI_REQUEST, len, msg); 1323 if (ret) { 1324 retry_cnt--; 1325 if (retry_cnt > 0) { 1326 msleep(SSIF_REQ_RETRY_MSEC); 1327 goto retry1; 1328 } 1329 return -ENODEV; 1330 } 1331 1332 ret = read_response(client, resp); 1333 if (ret > 0) { 1334 /* Validate that the response is correct. */ 1335 if (ret < 3 || 1336 (resp[0] != (msg[0] | (1 << 2))) || 1337 (resp[1] != msg[1])) 1338 ret = -EINVAL; 1339 else if (ret > IPMI_MAX_MSG_LENGTH) { 1340 ret = -E2BIG; 1341 } else { 1342 *resp_len = ret; 1343 ret = 0; 1344 } 1345 } 1346 1347 return ret; 1348 } 1349 1350 static int ssif_detect(struct i2c_client *client, struct i2c_board_info *info) 1351 { 1352 unsigned char *resp; 1353 unsigned char msg[3]; 1354 int rv; 1355 int len; 1356 1357 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1358 if (!resp) 1359 return -ENOMEM; 1360 1361 /* Do a Get Device ID command, since it is required. */ 1362 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1363 msg[1] = IPMI_GET_DEVICE_ID_CMD; 1364 rv = do_cmd(client, 2, msg, &len, resp); 1365 if (rv) 1366 rv = -ENODEV; 1367 else { 1368 if (len < 3) { 1369 rv = -ENODEV; 1370 } else { 1371 struct ipmi_device_id id; 1372 1373 rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1], 1374 resp + 2, len - 2, &id); 1375 if (rv) 1376 rv = -ENODEV; /* Error means a BMC probably isn't there. */ 1377 } 1378 if (!rv && info) 1379 strscpy(info->type, DEVICE_NAME, I2C_NAME_SIZE); 1380 } 1381 kfree(resp); 1382 return rv; 1383 } 1384 1385 static int strcmp_nospace(char *s1, char *s2) 1386 { 1387 while (*s1 && *s2) { 1388 while (isspace(*s1)) 1389 s1++; 1390 while (isspace(*s2)) 1391 s2++; 1392 if (*s1 > *s2) 1393 return 1; 1394 if (*s1 < *s2) 1395 return -1; 1396 s1++; 1397 s2++; 1398 } 1399 return 0; 1400 } 1401 1402 static struct ssif_addr_info *ssif_info_find(unsigned short addr, 1403 char *adapter_name, 1404 bool match_null_name) 1405 { 1406 struct ssif_addr_info *info, *found = NULL; 1407 1408 restart: 1409 list_for_each_entry(info, &ssif_infos, link) { 1410 if (info->binfo.addr == addr) { 1411 if (info->addr_src == SI_SMBIOS && !info->adapter_name) 1412 info->adapter_name = kstrdup(adapter_name, 1413 GFP_KERNEL); 1414 1415 if (info->adapter_name || adapter_name) { 1416 if (!info->adapter_name != !adapter_name) { 1417 /* One is NULL and one is not */ 1418 continue; 1419 } 1420 if (adapter_name && 1421 strcmp_nospace(info->adapter_name, 1422 adapter_name)) 1423 /* Names do not match */ 1424 continue; 1425 } 1426 found = info; 1427 break; 1428 } 1429 } 1430 1431 if (!found && match_null_name) { 1432 /* Try to get an exact match first, then try with a NULL name */ 1433 adapter_name = NULL; 1434 match_null_name = false; 1435 goto restart; 1436 } 1437 1438 return found; 1439 } 1440 1441 static bool check_acpi(struct ssif_info *ssif_info, struct device *dev) 1442 { 1443 #ifdef CONFIG_ACPI 1444 acpi_handle acpi_handle; 1445 1446 acpi_handle = ACPI_HANDLE(dev); 1447 if (acpi_handle) { 1448 ssif_info->addr_source = SI_ACPI; 1449 ssif_info->addr_info.acpi_info.acpi_handle = acpi_handle; 1450 request_module_nowait("acpi_ipmi"); 1451 return true; 1452 } 1453 #endif 1454 return false; 1455 } 1456 1457 static int find_slave_address(struct i2c_client *client, int slave_addr) 1458 { 1459 #ifdef CONFIG_IPMI_DMI_DECODE 1460 if (!slave_addr) 1461 slave_addr = ipmi_dmi_get_slave_addr( 1462 SI_TYPE_INVALID, 1463 i2c_adapter_id(client->adapter), 1464 client->addr); 1465 #endif 1466 1467 return slave_addr; 1468 } 1469 1470 static int start_multipart_test(struct i2c_client *client, 1471 unsigned char *msg, bool do_middle) 1472 { 1473 int retry_cnt = SSIF_SEND_RETRIES, ret; 1474 1475 retry_write: 1476 ret = i2c_smbus_write_block_data(client, 1477 SSIF_IPMI_MULTI_PART_REQUEST_START, 1478 32, msg); 1479 if (ret) { 1480 retry_cnt--; 1481 if (retry_cnt > 0) { 1482 msleep(SSIF_REQ_RETRY_MSEC); 1483 goto retry_write; 1484 } 1485 dev_err(&client->dev, "Could not write multi-part start, though the BMC said it could handle it. Just limit sends to one part.\n"); 1486 return ret; 1487 } 1488 1489 if (!do_middle) 1490 return 0; 1491 1492 ret = i2c_smbus_write_block_data(client, 1493 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE, 1494 32, msg + 32); 1495 if (ret) { 1496 dev_err(&client->dev, "Could not write multi-part middle, though the BMC said it could handle it. Just limit sends to one part.\n"); 1497 return ret; 1498 } 1499 1500 return 0; 1501 } 1502 1503 static void test_multipart_messages(struct i2c_client *client, 1504 struct ssif_info *ssif_info, 1505 unsigned char *resp) 1506 { 1507 unsigned char msg[65]; 1508 int ret; 1509 bool do_middle; 1510 1511 if (ssif_info->max_xmit_msg_size <= 32) 1512 return; 1513 1514 do_middle = ssif_info->max_xmit_msg_size > 63; 1515 1516 memset(msg, 0, sizeof(msg)); 1517 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1518 msg[1] = IPMI_GET_DEVICE_ID_CMD; 1519 1520 /* 1521 * The specification is all messed up dealing with sending 1522 * multi-part messages. Per what the specification says, it 1523 * is impossible to send a message that is a multiple of 32 1524 * bytes, except for 32 itself. It talks about a "start" 1525 * transaction (cmd=6) that must be 32 bytes, "middle" 1526 * transaction (cmd=7) that must be 32 bytes, and an "end" 1527 * transaction. The "end" transaction is shown as cmd=7 in 1528 * the text, but if that's the case there is no way to 1529 * differentiate between a middle and end part except the 1530 * length being less than 32. But there is a table at the far 1531 * end of the section (that I had never noticed until someone 1532 * pointed it out to me) that mentions it as cmd=8. 1533 * 1534 * After some thought, I think the example is wrong and the 1535 * end transaction should be cmd=8. But some systems don't 1536 * implement cmd=8, they use a zero-length end transaction, 1537 * even though that violates the SMBus specification. 1538 * 1539 * So, to work around this, this code tests if cmd=8 works. 1540 * If it does, then we use that. If not, it tests zero- 1541 * byte end transactions. If that works, good. If not, 1542 * we only allow 63-byte transactions max. 1543 */ 1544 1545 ret = start_multipart_test(client, msg, do_middle); 1546 if (ret) 1547 goto out_no_multi_part; 1548 1549 ret = i2c_smbus_write_block_data(client, 1550 SSIF_IPMI_MULTI_PART_REQUEST_END, 1551 1, msg + 64); 1552 1553 if (!ret) 1554 ret = read_response(client, resp); 1555 1556 if (ret > 0) { 1557 /* End transactions work, we are good. */ 1558 ssif_info->cmd8_works = true; 1559 return; 1560 } 1561 1562 ret = start_multipart_test(client, msg, do_middle); 1563 if (ret) { 1564 dev_err(&client->dev, "Second multipart test failed.\n"); 1565 goto out_no_multi_part; 1566 } 1567 1568 ret = i2c_smbus_write_block_data(client, 1569 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE, 1570 0, msg + 64); 1571 if (!ret) 1572 ret = read_response(client, resp); 1573 if (ret > 0) 1574 /* Zero-size end parts work, use those. */ 1575 return; 1576 1577 /* Limit to 63 bytes and use a short middle command to mark the end. */ 1578 if (ssif_info->max_xmit_msg_size > 63) 1579 ssif_info->max_xmit_msg_size = 63; 1580 return; 1581 1582 out_no_multi_part: 1583 ssif_info->max_xmit_msg_size = 32; 1584 return; 1585 } 1586 1587 /* 1588 * Global enables we care about. 1589 */ 1590 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \ 1591 IPMI_BMC_EVT_MSG_INTR) 1592 1593 static void ssif_remove_dup(struct i2c_client *client) 1594 { 1595 struct ssif_info *ssif_info = i2c_get_clientdata(client); 1596 1597 ipmi_unregister_smi(ssif_info->intf); 1598 kfree(ssif_info); 1599 } 1600 1601 static int ssif_add_infos(struct i2c_client *client) 1602 { 1603 struct ssif_addr_info *info; 1604 1605 info = kzalloc(sizeof(*info), GFP_KERNEL); 1606 if (!info) 1607 return -ENOMEM; 1608 info->addr_src = SI_ACPI; 1609 info->client = client; 1610 info->adapter_name = kstrdup(client->adapter->name, GFP_KERNEL); 1611 if (!info->adapter_name) { 1612 kfree(info); 1613 return -ENOMEM; 1614 } 1615 1616 info->binfo.addr = client->addr; 1617 list_add_tail(&info->link, &ssif_infos); 1618 return 0; 1619 } 1620 1621 /* 1622 * Prefer ACPI over SMBIOS, if both are available. 1623 * So if we get an ACPI interface and have already registered a SMBIOS 1624 * interface at the same address, remove the SMBIOS and add the ACPI one. 1625 */ 1626 static int ssif_check_and_remove(struct i2c_client *client, 1627 struct ssif_info *ssif_info) 1628 { 1629 struct ssif_addr_info *info; 1630 1631 list_for_each_entry(info, &ssif_infos, link) { 1632 if (!info->client) 1633 return 0; 1634 if (!strcmp(info->adapter_name, client->adapter->name) && 1635 info->binfo.addr == client->addr) { 1636 if (info->addr_src == SI_ACPI) 1637 return -EEXIST; 1638 1639 if (ssif_info->addr_source == SI_ACPI && 1640 info->addr_src == SI_SMBIOS) { 1641 dev_info(&client->dev, 1642 "Removing %s-specified SSIF interface in favor of ACPI\n", 1643 ipmi_addr_src_to_str(info->addr_src)); 1644 ssif_remove_dup(info->client); 1645 return 0; 1646 } 1647 } 1648 } 1649 return 0; 1650 } 1651 1652 static int ssif_probe(struct i2c_client *client) 1653 { 1654 unsigned char msg[3]; 1655 unsigned char *resp; 1656 struct ssif_info *ssif_info; 1657 int rv = 0; 1658 int len = 0; 1659 int i; 1660 u8 slave_addr = 0; 1661 struct ssif_addr_info *addr_info = NULL; 1662 1663 mutex_lock(&ssif_infos_mutex); 1664 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1665 if (!resp) { 1666 mutex_unlock(&ssif_infos_mutex); 1667 return -ENOMEM; 1668 } 1669 1670 ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL); 1671 if (!ssif_info) { 1672 kfree(resp); 1673 mutex_unlock(&ssif_infos_mutex); 1674 return -ENOMEM; 1675 } 1676 1677 if (!check_acpi(ssif_info, &client->dev)) { 1678 addr_info = ssif_info_find(client->addr, client->adapter->name, 1679 true); 1680 if (!addr_info) { 1681 /* Must have come in through sysfs. */ 1682 ssif_info->addr_source = SI_HOTMOD; 1683 } else { 1684 ssif_info->addr_source = addr_info->addr_src; 1685 ssif_info->ssif_debug = addr_info->debug; 1686 ssif_info->addr_info = addr_info->addr_info; 1687 addr_info->client = client; 1688 slave_addr = addr_info->slave_addr; 1689 } 1690 } 1691 1692 ssif_info->client = client; 1693 i2c_set_clientdata(client, ssif_info); 1694 1695 rv = ssif_check_and_remove(client, ssif_info); 1696 /* If rv is 0 and addr source is not SI_ACPI, continue probing */ 1697 if (!rv && ssif_info->addr_source == SI_ACPI) { 1698 rv = ssif_add_infos(client); 1699 if (rv) { 1700 dev_err(&client->dev, "Out of memory!, exiting ..\n"); 1701 goto out; 1702 } 1703 } else if (rv) { 1704 dev_err(&client->dev, "Not probing, Interface already present\n"); 1705 goto out; 1706 } 1707 1708 slave_addr = find_slave_address(client, slave_addr); 1709 1710 dev_info(&client->dev, 1711 "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n", 1712 ipmi_addr_src_to_str(ssif_info->addr_source), 1713 client->addr, client->adapter->name, slave_addr); 1714 1715 /* 1716 * Send a get device id command and validate its response to 1717 * make sure a valid BMC is there. 1718 */ 1719 rv = ssif_detect(client, NULL); 1720 if (rv) { 1721 dev_err(&client->dev, "Not present\n"); 1722 goto out; 1723 } 1724 1725 /* Now check for system interface capabilities */ 1726 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1727 msg[1] = IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD; 1728 msg[2] = 0; /* SSIF */ 1729 rv = do_cmd(client, 3, msg, &len, resp); 1730 if (!rv && (len >= 3) && (resp[2] == 0)) { 1731 if (len < 7) { 1732 if (ssif_dbg_probe) 1733 dev_dbg(&ssif_info->client->dev, 1734 "SSIF info too short: %d\n", len); 1735 goto no_support; 1736 } 1737 1738 /* Got a good SSIF response, handle it. */ 1739 ssif_info->max_xmit_msg_size = resp[5]; 1740 ssif_info->max_recv_msg_size = resp[6]; 1741 ssif_info->multi_support = (resp[4] >> 6) & 0x3; 1742 ssif_info->supports_pec = (resp[4] >> 3) & 0x1; 1743 1744 /* Sanitize the data */ 1745 switch (ssif_info->multi_support) { 1746 case SSIF_NO_MULTI: 1747 if (ssif_info->max_xmit_msg_size > 32) 1748 ssif_info->max_xmit_msg_size = 32; 1749 if (ssif_info->max_recv_msg_size > 32) 1750 ssif_info->max_recv_msg_size = 32; 1751 break; 1752 1753 case SSIF_MULTI_2_PART: 1754 if (ssif_info->max_xmit_msg_size > 63) 1755 ssif_info->max_xmit_msg_size = 63; 1756 if (ssif_info->max_recv_msg_size > 62) 1757 ssif_info->max_recv_msg_size = 62; 1758 break; 1759 1760 case SSIF_MULTI_n_PART: 1761 /* We take whatever size given, but do some testing. */ 1762 break; 1763 1764 default: 1765 /* Data is not sane, just give up. */ 1766 goto no_support; 1767 } 1768 } else { 1769 no_support: 1770 /* Assume no multi-part or PEC support */ 1771 dev_info(&ssif_info->client->dev, 1772 "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n", 1773 rv, len, resp[2]); 1774 1775 ssif_info->max_xmit_msg_size = 32; 1776 ssif_info->max_recv_msg_size = 32; 1777 ssif_info->multi_support = SSIF_NO_MULTI; 1778 ssif_info->supports_pec = 0; 1779 } 1780 1781 test_multipart_messages(client, ssif_info, resp); 1782 1783 /* Make sure the NMI timeout is cleared. */ 1784 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1785 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD; 1786 msg[2] = WDT_PRE_TIMEOUT_INT; 1787 rv = do_cmd(client, 3, msg, &len, resp); 1788 if (rv || (len < 3) || (resp[2] != 0)) 1789 dev_warn(&ssif_info->client->dev, 1790 "Unable to clear message flags: %d %d %2.2x\n", 1791 rv, len, resp[2]); 1792 1793 /* Attempt to enable the event buffer. */ 1794 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1795 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 1796 rv = do_cmd(client, 2, msg, &len, resp); 1797 if (rv || (len < 4) || (resp[2] != 0)) { 1798 dev_warn(&ssif_info->client->dev, 1799 "Error getting global enables: %d %d %2.2x\n", 1800 rv, len, resp[2]); 1801 rv = 0; /* Not fatal */ 1802 goto found; 1803 } 1804 1805 ssif_info->global_enables = resp[3]; 1806 1807 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) { 1808 ssif_info->has_event_buffer = true; 1809 /* buffer is already enabled, nothing to do. */ 1810 goto found; 1811 } 1812 1813 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1814 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1815 msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF; 1816 rv = do_cmd(client, 3, msg, &len, resp); 1817 if (rv || (len < 2)) { 1818 dev_warn(&ssif_info->client->dev, 1819 "Error setting global enables: %d %d %2.2x\n", 1820 rv, len, resp[2]); 1821 rv = 0; /* Not fatal */ 1822 goto found; 1823 } 1824 1825 if (resp[2] == 0) { 1826 /* A successful return means the event buffer is supported. */ 1827 ssif_info->has_event_buffer = true; 1828 ssif_info->global_enables |= IPMI_BMC_EVT_MSG_BUFF; 1829 } 1830 1831 /* Some systems don't behave well if you enable alerts. */ 1832 if (alerts_broken) 1833 goto found; 1834 1835 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1836 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1837 msg[2] = ssif_info->global_enables | IPMI_BMC_RCV_MSG_INTR; 1838 rv = do_cmd(client, 3, msg, &len, resp); 1839 if (rv || (len < 2)) { 1840 dev_warn(&ssif_info->client->dev, 1841 "Error setting global enables: %d %d %2.2x\n", 1842 rv, len, resp[2]); 1843 rv = 0; /* Not fatal */ 1844 goto found; 1845 } 1846 1847 if (resp[2] == 0) { 1848 /* A successful return means the alert is supported. */ 1849 ssif_info->supports_alert = true; 1850 ssif_info->global_enables |= IPMI_BMC_RCV_MSG_INTR; 1851 } 1852 1853 found: 1854 if (ssif_dbg_probe) { 1855 dev_dbg(&ssif_info->client->dev, 1856 "%s: i2c_probe found device at i2c address %x\n", 1857 __func__, client->addr); 1858 } 1859 1860 spin_lock_init(&ssif_info->lock); 1861 ssif_info->ssif_state = SSIF_IDLE; 1862 timer_setup(&ssif_info->retry_timer, retry_timeout, 0); 1863 timer_setup(&ssif_info->watch_timer, watch_timeout, 0); 1864 1865 for (i = 0; i < SSIF_NUM_STATS; i++) 1866 atomic_set(&ssif_info->stats[i], 0); 1867 1868 if (ssif_info->supports_pec) 1869 ssif_info->client->flags |= I2C_CLIENT_PEC; 1870 1871 ssif_info->handlers.owner = THIS_MODULE; 1872 ssif_info->handlers.start_processing = ssif_start_processing; 1873 ssif_info->handlers.shutdown = shutdown_ssif; 1874 ssif_info->handlers.get_smi_info = get_smi_info; 1875 ssif_info->handlers.sender = sender; 1876 ssif_info->handlers.request_events = request_events; 1877 ssif_info->handlers.set_need_watch = ssif_set_need_watch; 1878 1879 { 1880 unsigned int thread_num; 1881 1882 thread_num = ((i2c_adapter_id(ssif_info->client->adapter) 1883 << 8) | 1884 ssif_info->client->addr); 1885 init_completion(&ssif_info->wake_thread); 1886 ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info, 1887 "kssif%4.4x", thread_num); 1888 if (IS_ERR(ssif_info->thread)) { 1889 rv = PTR_ERR(ssif_info->thread); 1890 dev_notice(&ssif_info->client->dev, 1891 "Could not start kernel thread: error %d\n", 1892 rv); 1893 goto out; 1894 } 1895 } 1896 1897 dev_set_drvdata(&ssif_info->client->dev, ssif_info); 1898 rv = device_add_group(&ssif_info->client->dev, 1899 &ipmi_ssif_dev_attr_group); 1900 if (rv) { 1901 dev_err(&ssif_info->client->dev, 1902 "Unable to add device attributes: error %d\n", 1903 rv); 1904 goto out; 1905 } 1906 1907 rv = ipmi_register_smi(&ssif_info->handlers, 1908 ssif_info, 1909 &ssif_info->client->dev, 1910 slave_addr); 1911 if (rv) { 1912 dev_err(&ssif_info->client->dev, 1913 "Unable to register device: error %d\n", rv); 1914 goto out_remove_attr; 1915 } 1916 1917 out: 1918 if (rv) { 1919 if (addr_info) 1920 addr_info->client = NULL; 1921 1922 dev_err(&ssif_info->client->dev, 1923 "Unable to start IPMI SSIF: %d\n", rv); 1924 i2c_set_clientdata(client, NULL); 1925 kfree(ssif_info); 1926 } 1927 kfree(resp); 1928 mutex_unlock(&ssif_infos_mutex); 1929 return rv; 1930 1931 out_remove_attr: 1932 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group); 1933 dev_set_drvdata(&ssif_info->client->dev, NULL); 1934 goto out; 1935 } 1936 1937 static int new_ssif_client(int addr, char *adapter_name, 1938 int debug, int slave_addr, 1939 enum ipmi_addr_src addr_src, 1940 struct device *dev) 1941 { 1942 struct ssif_addr_info *addr_info; 1943 int rv = 0; 1944 1945 mutex_lock(&ssif_infos_mutex); 1946 if (ssif_info_find(addr, adapter_name, false)) { 1947 rv = -EEXIST; 1948 goto out_unlock; 1949 } 1950 1951 addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL); 1952 if (!addr_info) { 1953 rv = -ENOMEM; 1954 goto out_unlock; 1955 } 1956 1957 if (adapter_name) { 1958 addr_info->adapter_name = kstrdup(adapter_name, GFP_KERNEL); 1959 if (!addr_info->adapter_name) { 1960 kfree(addr_info); 1961 rv = -ENOMEM; 1962 goto out_unlock; 1963 } 1964 } 1965 1966 strscpy(addr_info->binfo.type, DEVICE_NAME, 1967 sizeof(addr_info->binfo.type)); 1968 addr_info->binfo.addr = addr; 1969 addr_info->binfo.platform_data = addr_info; 1970 addr_info->debug = debug; 1971 addr_info->slave_addr = slave_addr; 1972 addr_info->addr_src = addr_src; 1973 addr_info->dev = dev; 1974 1975 if (dev) 1976 dev_set_drvdata(dev, addr_info); 1977 1978 list_add_tail(&addr_info->link, &ssif_infos); 1979 1980 /* Address list will get it */ 1981 1982 out_unlock: 1983 mutex_unlock(&ssif_infos_mutex); 1984 return rv; 1985 } 1986 1987 static void free_ssif_clients(void) 1988 { 1989 struct ssif_addr_info *info, *tmp; 1990 1991 mutex_lock(&ssif_infos_mutex); 1992 list_for_each_entry_safe(info, tmp, &ssif_infos, link) { 1993 list_del(&info->link); 1994 kfree(info->adapter_name); 1995 kfree(info); 1996 } 1997 mutex_unlock(&ssif_infos_mutex); 1998 } 1999 2000 static unsigned short *ssif_address_list(void) 2001 { 2002 struct ssif_addr_info *info; 2003 unsigned int count = 0, i = 0; 2004 unsigned short *address_list; 2005 2006 list_for_each_entry(info, &ssif_infos, link) 2007 count++; 2008 2009 address_list = kcalloc(count + 1, sizeof(*address_list), 2010 GFP_KERNEL); 2011 if (!address_list) 2012 return NULL; 2013 2014 list_for_each_entry(info, &ssif_infos, link) { 2015 unsigned short addr = info->binfo.addr; 2016 int j; 2017 2018 for (j = 0; j < i; j++) { 2019 if (address_list[j] == addr) 2020 /* Found a dup. */ 2021 break; 2022 } 2023 if (j == i) /* Didn't find it in the list. */ 2024 address_list[i++] = addr; 2025 } 2026 address_list[i] = I2C_CLIENT_END; 2027 2028 return address_list; 2029 } 2030 2031 #ifdef CONFIG_ACPI 2032 static const struct acpi_device_id ssif_acpi_match[] = { 2033 { "IPI0001", 0 }, 2034 { }, 2035 }; 2036 MODULE_DEVICE_TABLE(acpi, ssif_acpi_match); 2037 #endif 2038 2039 #ifdef CONFIG_DMI 2040 static int dmi_ipmi_probe(struct platform_device *pdev) 2041 { 2042 u8 slave_addr = 0; 2043 u16 i2c_addr; 2044 int rv; 2045 2046 if (!ssif_trydmi) 2047 return -ENODEV; 2048 2049 rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr); 2050 if (rv) { 2051 dev_warn(&pdev->dev, "No i2c-addr property\n"); 2052 return -ENODEV; 2053 } 2054 2055 rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr); 2056 if (rv) 2057 slave_addr = 0x20; 2058 2059 return new_ssif_client(i2c_addr, NULL, 0, 2060 slave_addr, SI_SMBIOS, &pdev->dev); 2061 } 2062 #else 2063 static int dmi_ipmi_probe(struct platform_device *pdev) 2064 { 2065 return -ENODEV; 2066 } 2067 #endif 2068 2069 static const struct i2c_device_id ssif_id[] = { 2070 { DEVICE_NAME }, 2071 { } 2072 }; 2073 MODULE_DEVICE_TABLE(i2c, ssif_id); 2074 2075 static struct i2c_driver ssif_i2c_driver = { 2076 .class = I2C_CLASS_HWMON, 2077 .driver = { 2078 .name = DEVICE_NAME 2079 }, 2080 .probe = ssif_probe, 2081 .remove = ssif_remove, 2082 .alert = ssif_alert, 2083 .id_table = ssif_id, 2084 .detect = ssif_detect 2085 }; 2086 2087 static int ssif_platform_probe(struct platform_device *dev) 2088 { 2089 return dmi_ipmi_probe(dev); 2090 } 2091 2092 static void ssif_platform_remove(struct platform_device *dev) 2093 { 2094 struct ssif_addr_info *addr_info = dev_get_drvdata(&dev->dev); 2095 2096 mutex_lock(&ssif_infos_mutex); 2097 list_del(&addr_info->link); 2098 kfree(addr_info); 2099 mutex_unlock(&ssif_infos_mutex); 2100 } 2101 2102 static const struct platform_device_id ssif_plat_ids[] = { 2103 { "dmi-ipmi-ssif", 0 }, 2104 { } 2105 }; 2106 MODULE_DEVICE_TABLE(platform, ssif_plat_ids); 2107 2108 static struct platform_driver ipmi_driver = { 2109 .driver = { 2110 .name = DEVICE_NAME, 2111 }, 2112 .probe = ssif_platform_probe, 2113 .remove = ssif_platform_remove, 2114 .id_table = ssif_plat_ids 2115 }; 2116 2117 static int __init init_ipmi_ssif(void) 2118 { 2119 int i; 2120 int rv; 2121 2122 if (initialized) 2123 return 0; 2124 2125 pr_info("IPMI SSIF Interface driver\n"); 2126 2127 /* build list for i2c from addr list */ 2128 for (i = 0; i < num_addrs; i++) { 2129 rv = new_ssif_client(addr[i], adapter_name[i], 2130 dbg[i], slave_addrs[i], 2131 SI_HARDCODED, NULL); 2132 if (rv) 2133 pr_err("Couldn't add hardcoded device at addr 0x%x\n", 2134 addr[i]); 2135 } 2136 2137 if (ssif_tryacpi) 2138 ssif_i2c_driver.driver.acpi_match_table = 2139 ACPI_PTR(ssif_acpi_match); 2140 2141 if (ssif_trydmi) { 2142 rv = platform_driver_register(&ipmi_driver); 2143 if (rv) 2144 pr_err("Unable to register driver: %d\n", rv); 2145 else 2146 platform_registered = true; 2147 } 2148 2149 ssif_i2c_driver.address_list = ssif_address_list(); 2150 2151 rv = i2c_add_driver(&ssif_i2c_driver); 2152 if (!rv) 2153 initialized = true; 2154 2155 return rv; 2156 } 2157 module_init(init_ipmi_ssif); 2158 2159 static void __exit cleanup_ipmi_ssif(void) 2160 { 2161 if (!initialized) 2162 return; 2163 2164 initialized = false; 2165 2166 i2c_del_driver(&ssif_i2c_driver); 2167 2168 kfree(ssif_i2c_driver.address_list); 2169 2170 if (ssif_trydmi && platform_registered) 2171 platform_driver_unregister(&ipmi_driver); 2172 2173 free_ssif_clients(); 2174 } 2175 module_exit(cleanup_ipmi_ssif); 2176 2177 MODULE_ALIAS("platform:dmi-ipmi-ssif"); 2178 MODULE_AUTHOR("Todd C Davis <todd.c.davis@intel.com>, Corey Minyard <minyard@acm.org>"); 2179 MODULE_DESCRIPTION("IPMI driver for management controllers on a SMBus"); 2180 MODULE_LICENSE("GPL"); 2181