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 97enum 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 */ 112enum 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 180struct 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 196struct ssif_info; 197 198typedef void (*ssif_i2c_done)(struct ssif_info *ssif_info, int result, 199 unsigned char *data, unsigned int len); 200 201struct 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 297static bool initialized; 298static bool platform_registered; 299 300static void return_hosed_msg(struct ssif_info *ssif_info, 301 struct ipmi_smi_msg *msg); 302static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags); 303static int start_send(struct ssif_info *ssif_info, 304 unsigned char *data, 305 unsigned int len); 306 307static 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 315static 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 322static 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 335static 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 */ 355static 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 374static 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 388static 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 402static 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 426static 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 */ 455static 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 474static 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 (ssif_info->stopping) 485 break; 486 if (result == -ERESTARTSYS) 487 continue; 488 init_completion(&ssif_info->wake_thread); 489 490 if (ssif_info->i2c_read_write == I2C_SMBUS_WRITE) { 491 result = i2c_smbus_write_block_data( 492 ssif_info->client, ssif_info->i2c_command, 493 ssif_info->i2c_data[0], 494 ssif_info->i2c_data + 1); 495 ssif_info->done_handler(ssif_info, result, NULL, 0); 496 } else { 497 result = i2c_smbus_read_block_data( 498 ssif_info->client, ssif_info->i2c_command, 499 ssif_info->i2c_data); 500 if (result < 0) 501 ssif_info->done_handler(ssif_info, result, 502 NULL, 0); 503 else 504 ssif_info->done_handler(ssif_info, 0, 505 ssif_info->i2c_data, 506 result); 507 } 508 } 509 510 return 0; 511} 512 513static void ssif_i2c_send(struct ssif_info *ssif_info, 514 ssif_i2c_done handler, 515 int read_write, int command, 516 unsigned char *data, unsigned int size) 517{ 518 ssif_info->done_handler = handler; 519 520 ssif_info->i2c_read_write = read_write; 521 ssif_info->i2c_command = command; 522 ssif_info->i2c_data = data; 523 ssif_info->i2c_size = size; 524 complete(&ssif_info->wake_thread); 525} 526 527 528static void msg_done_handler(struct ssif_info *ssif_info, int result, 529 unsigned char *data, unsigned int len); 530 531static void start_get(struct ssif_info *ssif_info) 532{ 533 ssif_info->multi_pos = 0; 534 535 ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ, 536 SSIF_IPMI_RESPONSE, 537 ssif_info->recv, I2C_SMBUS_BLOCK_DATA); 538} 539 540static void start_resend(struct ssif_info *ssif_info); 541 542static void retry_timeout(struct timer_list *t) 543{ 544 struct ssif_info *ssif_info = from_timer(ssif_info, t, retry_timer); 545 unsigned long oflags, *flags; 546 bool waiting, resend; 547 548 if (ssif_info->stopping) 549 return; 550 551 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 552 resend = ssif_info->do_resend; 553 ssif_info->do_resend = false; 554 waiting = ssif_info->waiting_alert; 555 ssif_info->waiting_alert = false; 556 ipmi_ssif_unlock_cond(ssif_info, flags); 557 558 if (waiting) 559 start_get(ssif_info); 560 if (resend) { 561 start_resend(ssif_info); 562 ssif_inc_stat(ssif_info, send_retries); 563 } 564} 565 566static void watch_timeout(struct timer_list *t) 567{ 568 struct ssif_info *ssif_info = from_timer(ssif_info, t, watch_timer); 569 unsigned long oflags, *flags; 570 571 if (ssif_info->stopping) 572 return; 573 574 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 575 if (ssif_info->watch_timeout) { 576 mod_timer(&ssif_info->watch_timer, 577 jiffies + ssif_info->watch_timeout); 578 if (IS_SSIF_IDLE(ssif_info)) { 579 start_flag_fetch(ssif_info, flags); /* Releases lock */ 580 return; 581 } 582 ssif_info->req_flags = true; 583 } 584 ipmi_ssif_unlock_cond(ssif_info, flags); 585} 586 587static void ssif_alert(struct i2c_client *client, enum i2c_alert_protocol type, 588 unsigned int data) 589{ 590 struct ssif_info *ssif_info = i2c_get_clientdata(client); 591 unsigned long oflags, *flags; 592 bool do_get = false; 593 594 if (type != I2C_PROTOCOL_SMBUS_ALERT) 595 return; 596 597 ssif_inc_stat(ssif_info, alerts); 598 599 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 600 if (ssif_info->waiting_alert) { 601 ssif_info->waiting_alert = false; 602 del_timer(&ssif_info->retry_timer); 603 do_get = true; 604 } else if (ssif_info->curr_msg) { 605 ssif_info->got_alert = true; 606 } 607 ipmi_ssif_unlock_cond(ssif_info, flags); 608 if (do_get) 609 start_get(ssif_info); 610} 611 612static void msg_done_handler(struct ssif_info *ssif_info, int result, 613 unsigned char *data, unsigned int len) 614{ 615 struct ipmi_smi_msg *msg; 616 unsigned long oflags, *flags; 617 618 /* 619 * We are single-threaded here, so no need for a lock until we 620 * start messing with driver states or the queues. 621 */ 622 623 if (result < 0) { 624 ssif_info->retries_left--; 625 if (ssif_info->retries_left > 0) { 626 ssif_inc_stat(ssif_info, receive_retries); 627 628 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 629 ssif_info->waiting_alert = true; 630 if (!ssif_info->stopping) 631 mod_timer(&ssif_info->retry_timer, 632 jiffies + SSIF_MSG_JIFFIES); 633 ipmi_ssif_unlock_cond(ssif_info, flags); 634 return; 635 } 636 637 ssif_inc_stat(ssif_info, receive_errors); 638 639 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 640 dev_dbg(&ssif_info->client->dev, 641 "%s: Error %d\n", __func__, result); 642 len = 0; 643 goto continue_op; 644 } 645 646 if ((len > 1) && (ssif_info->multi_pos == 0) 647 && (data[0] == 0x00) && (data[1] == 0x01)) { 648 /* Start of multi-part read. Start the next transaction. */ 649 int i; 650 651 ssif_inc_stat(ssif_info, received_message_parts); 652 653 /* Remove the multi-part read marker. */ 654 len -= 2; 655 data += 2; 656 for (i = 0; i < len; i++) 657 ssif_info->data[i] = data[i]; 658 ssif_info->multi_len = len; 659 ssif_info->multi_pos = 1; 660 661 ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ, 662 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE, 663 ssif_info->recv, I2C_SMBUS_BLOCK_DATA); 664 return; 665 } else if (ssif_info->multi_pos) { 666 /* Middle of multi-part read. Start the next transaction. */ 667 int i; 668 unsigned char blocknum; 669 670 if (len == 0) { 671 result = -EIO; 672 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 673 dev_dbg(&ssif_info->client->dev, 674 "Middle message with no data\n"); 675 676 goto continue_op; 677 } 678 679 blocknum = data[0]; 680 len--; 681 data++; 682 683 if (blocknum != 0xff && len != 31) { 684 /* All blocks but the last must have 31 data bytes. */ 685 result = -EIO; 686 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 687 dev_dbg(&ssif_info->client->dev, 688 "Received middle message <31\n"); 689 690 goto continue_op; 691 } 692 693 if (ssif_info->multi_len + len > IPMI_MAX_MSG_LENGTH) { 694 /* Received message too big, abort the operation. */ 695 result = -E2BIG; 696 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 697 dev_dbg(&ssif_info->client->dev, 698 "Received message too big\n"); 699 700 goto continue_op; 701 } 702 703 for (i = 0; i < len; i++) 704 ssif_info->data[i + ssif_info->multi_len] = data[i]; 705 ssif_info->multi_len += len; 706 if (blocknum == 0xff) { 707 /* End of read */ 708 len = ssif_info->multi_len; 709 data = ssif_info->data; 710 } else if (blocknum + 1 != ssif_info->multi_pos) { 711 /* 712 * Out of sequence block, just abort. Block 713 * numbers start at zero for the second block, 714 * but multi_pos starts at one, so the +1. 715 */ 716 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 717 dev_dbg(&ssif_info->client->dev, 718 "Received message out of sequence, expected %u, got %u\n", 719 ssif_info->multi_pos - 1, blocknum); 720 result = -EIO; 721 } else { 722 ssif_inc_stat(ssif_info, received_message_parts); 723 724 ssif_info->multi_pos++; 725 726 ssif_i2c_send(ssif_info, msg_done_handler, 727 I2C_SMBUS_READ, 728 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE, 729 ssif_info->recv, 730 I2C_SMBUS_BLOCK_DATA); 731 return; 732 } 733 } 734 735 continue_op: 736 if (result < 0) { 737 ssif_inc_stat(ssif_info, receive_errors); 738 } else { 739 ssif_inc_stat(ssif_info, received_messages); 740 ssif_inc_stat(ssif_info, received_message_parts); 741 } 742 743 if (ssif_info->ssif_debug & SSIF_DEBUG_STATE) 744 dev_dbg(&ssif_info->client->dev, 745 "DONE 1: state = %d, result=%d\n", 746 ssif_info->ssif_state, result); 747 748 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 749 msg = ssif_info->curr_msg; 750 if (msg) { 751 if (data) { 752 if (len > IPMI_MAX_MSG_LENGTH) 753 len = IPMI_MAX_MSG_LENGTH; 754 memcpy(msg->rsp, data, len); 755 } else { 756 len = 0; 757 } 758 msg->rsp_size = len; 759 ssif_info->curr_msg = NULL; 760 } 761 762 switch (ssif_info->ssif_state) { 763 case SSIF_IDLE: 764 ipmi_ssif_unlock_cond(ssif_info, flags); 765 if (!msg) 766 break; 767 768 if (result < 0) 769 return_hosed_msg(ssif_info, msg); 770 else 771 deliver_recv_msg(ssif_info, msg); 772 break; 773 774 case SSIF_GETTING_FLAGS: 775 /* We got the flags from the SSIF, now handle them. */ 776 if ((result < 0) || (len < 4) || (data[2] != 0)) { 777 /* 778 * Error fetching flags, or invalid length, 779 * just give up for now. 780 */ 781 ssif_info->ssif_state = SSIF_IDLE; 782 ipmi_ssif_unlock_cond(ssif_info, flags); 783 dev_warn(&ssif_info->client->dev, 784 "Error getting flags: %d %d, %x\n", 785 result, len, (len >= 3) ? data[2] : 0); 786 } else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 787 || data[1] != IPMI_GET_MSG_FLAGS_CMD) { 788 /* 789 * Recv error response, give up. 790 */ 791 ssif_info->ssif_state = SSIF_IDLE; 792 ipmi_ssif_unlock_cond(ssif_info, flags); 793 dev_warn(&ssif_info->client->dev, 794 "Invalid response getting flags: %x %x\n", 795 data[0], data[1]); 796 } else { 797 ssif_inc_stat(ssif_info, flag_fetches); 798 ssif_info->msg_flags = data[3]; 799 handle_flags(ssif_info, flags); 800 } 801 break; 802 803 case SSIF_CLEARING_FLAGS: 804 /* We cleared the flags. */ 805 if ((result < 0) || (len < 3) || (data[2] != 0)) { 806 /* Error clearing flags */ 807 dev_warn(&ssif_info->client->dev, 808 "Error clearing flags: %d %d, %x\n", 809 result, len, (len >= 3) ? data[2] : 0); 810 } else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 811 || data[1] != IPMI_CLEAR_MSG_FLAGS_CMD) { 812 dev_warn(&ssif_info->client->dev, 813 "Invalid response clearing flags: %x %x\n", 814 data[0], data[1]); 815 } 816 ssif_info->ssif_state = SSIF_IDLE; 817 ipmi_ssif_unlock_cond(ssif_info, flags); 818 break; 819 820 case SSIF_GETTING_EVENTS: 821 if (!msg) { 822 /* Should never happen, but just in case. */ 823 dev_warn(&ssif_info->client->dev, 824 "No message set while getting events\n"); 825 ipmi_ssif_unlock_cond(ssif_info, flags); 826 break; 827 } 828 829 if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) { 830 /* Error getting event, probably done. */ 831 msg->done(msg); 832 833 /* Take off the event flag. */ 834 ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 835 handle_flags(ssif_info, flags); 836 } else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 837 || msg->rsp[1] != IPMI_READ_EVENT_MSG_BUFFER_CMD) { 838 dev_warn(&ssif_info->client->dev, 839 "Invalid response getting events: %x %x\n", 840 msg->rsp[0], msg->rsp[1]); 841 msg->done(msg); 842 /* Take off the event flag. */ 843 ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 844 handle_flags(ssif_info, flags); 845 } else { 846 handle_flags(ssif_info, flags); 847 ssif_inc_stat(ssif_info, events); 848 deliver_recv_msg(ssif_info, msg); 849 } 850 break; 851 852 case SSIF_GETTING_MESSAGES: 853 if (!msg) { 854 /* Should never happen, but just in case. */ 855 dev_warn(&ssif_info->client->dev, 856 "No message set while getting messages\n"); 857 ipmi_ssif_unlock_cond(ssif_info, flags); 858 break; 859 } 860 861 if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) { 862 /* Error getting event, probably done. */ 863 msg->done(msg); 864 865 /* Take off the msg flag. */ 866 ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 867 handle_flags(ssif_info, flags); 868 } else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 869 || msg->rsp[1] != IPMI_GET_MSG_CMD) { 870 dev_warn(&ssif_info->client->dev, 871 "Invalid response clearing flags: %x %x\n", 872 msg->rsp[0], msg->rsp[1]); 873 msg->done(msg); 874 875 /* Take off the msg flag. */ 876 ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 877 handle_flags(ssif_info, flags); 878 } else { 879 ssif_inc_stat(ssif_info, incoming_messages); 880 handle_flags(ssif_info, flags); 881 deliver_recv_msg(ssif_info, msg); 882 } 883 break; 884 885 default: 886 /* Should never happen, but just in case. */ 887 dev_warn(&ssif_info->client->dev, 888 "Invalid state in message done handling: %d\n", 889 ssif_info->ssif_state); 890 ipmi_ssif_unlock_cond(ssif_info, flags); 891 } 892 893 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 894 if (IS_SSIF_IDLE(ssif_info) && !ssif_info->stopping) { 895 if (ssif_info->req_events) 896 start_event_fetch(ssif_info, flags); 897 else if (ssif_info->req_flags) 898 start_flag_fetch(ssif_info, flags); 899 else 900 start_next_msg(ssif_info, flags); 901 } else 902 ipmi_ssif_unlock_cond(ssif_info, flags); 903 904 if (ssif_info->ssif_debug & SSIF_DEBUG_STATE) 905 dev_dbg(&ssif_info->client->dev, 906 "DONE 2: state = %d.\n", ssif_info->ssif_state); 907} 908 909static void msg_written_handler(struct ssif_info *ssif_info, int result, 910 unsigned char *data, unsigned int len) 911{ 912 /* We are single-threaded here, so no need for a lock. */ 913 if (result < 0) { 914 ssif_info->retries_left--; 915 if (ssif_info->retries_left > 0) { 916 /* 917 * Wait the retry timeout time per the spec, 918 * then redo the send. 919 */ 920 ssif_info->do_resend = true; 921 mod_timer(&ssif_info->retry_timer, 922 jiffies + SSIF_REQ_RETRY_JIFFIES); 923 return; 924 } 925 926 ssif_inc_stat(ssif_info, send_errors); 927 928 if (ssif_info->ssif_debug & SSIF_DEBUG_MSG) 929 dev_dbg(&ssif_info->client->dev, 930 "%s: Out of retries\n", __func__); 931 932 msg_done_handler(ssif_info, -EIO, NULL, 0); 933 return; 934 } 935 936 if (ssif_info->multi_data) { 937 /* 938 * In the middle of a multi-data write. See the comment 939 * in the SSIF_MULTI_n_PART case in the probe function 940 * for details on the intricacies of this. 941 */ 942 int left, to_write; 943 unsigned char *data_to_send; 944 unsigned char cmd; 945 946 ssif_inc_stat(ssif_info, sent_messages_parts); 947 948 left = ssif_info->multi_len - ssif_info->multi_pos; 949 to_write = left; 950 if (to_write > 32) 951 to_write = 32; 952 /* Length byte. */ 953 ssif_info->multi_data[ssif_info->multi_pos] = to_write; 954 data_to_send = ssif_info->multi_data + ssif_info->multi_pos; 955 ssif_info->multi_pos += to_write; 956 cmd = SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE; 957 if (ssif_info->cmd8_works) { 958 if (left == to_write) { 959 cmd = SSIF_IPMI_MULTI_PART_REQUEST_END; 960 ssif_info->multi_data = NULL; 961 } 962 } else if (to_write < 32) { 963 ssif_info->multi_data = NULL; 964 } 965 966 ssif_i2c_send(ssif_info, msg_written_handler, 967 I2C_SMBUS_WRITE, cmd, 968 data_to_send, I2C_SMBUS_BLOCK_DATA); 969 } else { 970 /* Ready to request the result. */ 971 unsigned long oflags, *flags; 972 973 ssif_inc_stat(ssif_info, sent_messages); 974 ssif_inc_stat(ssif_info, sent_messages_parts); 975 976 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 977 if (ssif_info->got_alert) { 978 /* The result is already ready, just start it. */ 979 ssif_info->got_alert = false; 980 ipmi_ssif_unlock_cond(ssif_info, flags); 981 start_get(ssif_info); 982 } else { 983 /* Wait a jiffie then request the next message */ 984 ssif_info->waiting_alert = true; 985 ssif_info->retries_left = SSIF_RECV_RETRIES; 986 if (!ssif_info->stopping) 987 mod_timer(&ssif_info->retry_timer, 988 jiffies + SSIF_MSG_PART_JIFFIES); 989 ipmi_ssif_unlock_cond(ssif_info, flags); 990 } 991 } 992} 993 994static void start_resend(struct ssif_info *ssif_info) 995{ 996 int command; 997 998 ssif_info->got_alert = false; 999 1000 if (ssif_info->data_len > 32) { 1001 command = SSIF_IPMI_MULTI_PART_REQUEST_START; 1002 ssif_info->multi_data = ssif_info->data; 1003 ssif_info->multi_len = ssif_info->data_len; 1004 /* 1005 * Subtle thing, this is 32, not 33, because we will 1006 * overwrite the thing at position 32 (which was just 1007 * transmitted) with the new length. 1008 */ 1009 ssif_info->multi_pos = 32; 1010 ssif_info->data[0] = 32; 1011 } else { 1012 ssif_info->multi_data = NULL; 1013 command = SSIF_IPMI_REQUEST; 1014 ssif_info->data[0] = ssif_info->data_len; 1015 } 1016 1017 ssif_i2c_send(ssif_info, msg_written_handler, I2C_SMBUS_WRITE, 1018 command, ssif_info->data, I2C_SMBUS_BLOCK_DATA); 1019} 1020 1021static int start_send(struct ssif_info *ssif_info, 1022 unsigned char *data, 1023 unsigned int len) 1024{ 1025 if (len > IPMI_MAX_MSG_LENGTH) 1026 return -E2BIG; 1027 if (len > ssif_info->max_xmit_msg_size) 1028 return -E2BIG; 1029 1030 ssif_info->retries_left = SSIF_SEND_RETRIES; 1031 memcpy(ssif_info->data + 1, data, len); 1032 ssif_info->data_len = len; 1033 start_resend(ssif_info); 1034 return 0; 1035} 1036 1037/* Must be called with the message lock held. */ 1038static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags) 1039{ 1040 struct ipmi_smi_msg *msg; 1041 unsigned long oflags; 1042 1043 restart: 1044 if (!IS_SSIF_IDLE(ssif_info)) { 1045 ipmi_ssif_unlock_cond(ssif_info, flags); 1046 return; 1047 } 1048 1049 if (!ssif_info->waiting_msg) { 1050 ssif_info->curr_msg = NULL; 1051 ipmi_ssif_unlock_cond(ssif_info, flags); 1052 } else { 1053 int rv; 1054 1055 ssif_info->curr_msg = ssif_info->waiting_msg; 1056 ssif_info->waiting_msg = NULL; 1057 ipmi_ssif_unlock_cond(ssif_info, flags); 1058 rv = start_send(ssif_info, 1059 ssif_info->curr_msg->data, 1060 ssif_info->curr_msg->data_size); 1061 if (rv) { 1062 msg = ssif_info->curr_msg; 1063 ssif_info->curr_msg = NULL; 1064 return_hosed_msg(ssif_info, msg); 1065 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1066 goto restart; 1067 } 1068 } 1069} 1070 1071static void sender(void *send_info, 1072 struct ipmi_smi_msg *msg) 1073{ 1074 struct ssif_info *ssif_info = send_info; 1075 unsigned long oflags, *flags; 1076 1077 BUG_ON(ssif_info->waiting_msg); 1078 ssif_info->waiting_msg = msg; 1079 1080 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1081 start_next_msg(ssif_info, flags); 1082 1083 if (ssif_info->ssif_debug & SSIF_DEBUG_TIMING) { 1084 struct timespec64 t; 1085 1086 ktime_get_real_ts64(&t); 1087 dev_dbg(&ssif_info->client->dev, 1088 "**Enqueue %02x %02x: %lld.%6.6ld\n", 1089 msg->data[0], msg->data[1], 1090 (long long)t.tv_sec, (long)t.tv_nsec / NSEC_PER_USEC); 1091 } 1092} 1093 1094static int get_smi_info(void *send_info, struct ipmi_smi_info *data) 1095{ 1096 struct ssif_info *ssif_info = send_info; 1097 1098 data->addr_src = ssif_info->addr_source; 1099 data->dev = &ssif_info->client->dev; 1100 data->addr_info = ssif_info->addr_info; 1101 get_device(data->dev); 1102 1103 return 0; 1104} 1105 1106/* 1107 * Upper layer wants us to request events. 1108 */ 1109static void request_events(void *send_info) 1110{ 1111 struct ssif_info *ssif_info = send_info; 1112 unsigned long oflags, *flags; 1113 1114 if (!ssif_info->has_event_buffer) 1115 return; 1116 1117 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1118 ssif_info->req_events = true; 1119 ipmi_ssif_unlock_cond(ssif_info, flags); 1120} 1121 1122/* 1123 * Upper layer is changing the flag saying whether we need to request 1124 * flags periodically or not. 1125 */ 1126static void ssif_set_need_watch(void *send_info, unsigned int watch_mask) 1127{ 1128 struct ssif_info *ssif_info = send_info; 1129 unsigned long oflags, *flags; 1130 long timeout = 0; 1131 1132 if (watch_mask & IPMI_WATCH_MASK_CHECK_MESSAGES) 1133 timeout = SSIF_WATCH_MSG_TIMEOUT; 1134 else if (watch_mask) 1135 timeout = SSIF_WATCH_WATCHDOG_TIMEOUT; 1136 1137 flags = ipmi_ssif_lock_cond(ssif_info, &oflags); 1138 if (timeout != ssif_info->watch_timeout) { 1139 ssif_info->watch_timeout = timeout; 1140 if (ssif_info->watch_timeout) 1141 mod_timer(&ssif_info->watch_timer, 1142 jiffies + ssif_info->watch_timeout); 1143 } 1144 ipmi_ssif_unlock_cond(ssif_info, flags); 1145} 1146 1147static int ssif_start_processing(void *send_info, 1148 struct ipmi_smi *intf) 1149{ 1150 struct ssif_info *ssif_info = send_info; 1151 1152 ssif_info->intf = intf; 1153 1154 return 0; 1155} 1156 1157#define MAX_SSIF_BMCS 4 1158 1159static unsigned short addr[MAX_SSIF_BMCS]; 1160static int num_addrs; 1161module_param_array(addr, ushort, &num_addrs, 0); 1162MODULE_PARM_DESC(addr, "The addresses to scan for IPMI BMCs on the SSIFs."); 1163 1164static char *adapter_name[MAX_SSIF_BMCS]; 1165static int num_adapter_names; 1166module_param_array(adapter_name, charp, &num_adapter_names, 0); 1167MODULE_PARM_DESC(adapter_name, "The string name of the I2C device that has the BMC. By default all devices are scanned."); 1168 1169static int slave_addrs[MAX_SSIF_BMCS]; 1170static int num_slave_addrs; 1171module_param_array(slave_addrs, int, &num_slave_addrs, 0); 1172MODULE_PARM_DESC(slave_addrs, 1173 "The default IPMB slave address for the controller."); 1174 1175static bool alerts_broken; 1176module_param(alerts_broken, bool, 0); 1177MODULE_PARM_DESC(alerts_broken, "Don't enable alerts for the controller."); 1178 1179/* 1180 * Bit 0 enables message debugging, bit 1 enables state debugging, and 1181 * bit 2 enables timing debugging. This is an array indexed by 1182 * interface number" 1183 */ 1184static int dbg[MAX_SSIF_BMCS]; 1185static int num_dbg; 1186module_param_array(dbg, int, &num_dbg, 0); 1187MODULE_PARM_DESC(dbg, "Turn on debugging."); 1188 1189static bool ssif_dbg_probe; 1190module_param_named(dbg_probe, ssif_dbg_probe, bool, 0); 1191MODULE_PARM_DESC(dbg_probe, "Enable debugging of probing of adapters."); 1192 1193static bool ssif_tryacpi = true; 1194module_param_named(tryacpi, ssif_tryacpi, bool, 0); 1195MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the default scan of the interfaces identified via ACPI"); 1196 1197static bool ssif_trydmi = true; 1198module_param_named(trydmi, ssif_trydmi, bool, 0); 1199MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the default scan of the interfaces identified via DMI (SMBIOS)"); 1200 1201static DEFINE_MUTEX(ssif_infos_mutex); 1202static LIST_HEAD(ssif_infos); 1203 1204#define IPMI_SSIF_ATTR(name) \ 1205static ssize_t ipmi_##name##_show(struct device *dev, \ 1206 struct device_attribute *attr, \ 1207 char *buf) \ 1208{ \ 1209 struct ssif_info *ssif_info = dev_get_drvdata(dev); \ 1210 \ 1211 return sysfs_emit(buf, "%u\n", ssif_get_stat(ssif_info, name));\ 1212} \ 1213static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL) 1214 1215static ssize_t ipmi_type_show(struct device *dev, 1216 struct device_attribute *attr, 1217 char *buf) 1218{ 1219 return sysfs_emit(buf, "ssif\n"); 1220} 1221static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL); 1222 1223IPMI_SSIF_ATTR(sent_messages); 1224IPMI_SSIF_ATTR(sent_messages_parts); 1225IPMI_SSIF_ATTR(send_retries); 1226IPMI_SSIF_ATTR(send_errors); 1227IPMI_SSIF_ATTR(received_messages); 1228IPMI_SSIF_ATTR(received_message_parts); 1229IPMI_SSIF_ATTR(receive_retries); 1230IPMI_SSIF_ATTR(receive_errors); 1231IPMI_SSIF_ATTR(flag_fetches); 1232IPMI_SSIF_ATTR(hosed); 1233IPMI_SSIF_ATTR(events); 1234IPMI_SSIF_ATTR(watchdog_pretimeouts); 1235IPMI_SSIF_ATTR(alerts); 1236 1237static struct attribute *ipmi_ssif_dev_attrs[] = { 1238 &dev_attr_type.attr, 1239 &dev_attr_sent_messages.attr, 1240 &dev_attr_sent_messages_parts.attr, 1241 &dev_attr_send_retries.attr, 1242 &dev_attr_send_errors.attr, 1243 &dev_attr_received_messages.attr, 1244 &dev_attr_received_message_parts.attr, 1245 &dev_attr_receive_retries.attr, 1246 &dev_attr_receive_errors.attr, 1247 &dev_attr_flag_fetches.attr, 1248 &dev_attr_hosed.attr, 1249 &dev_attr_events.attr, 1250 &dev_attr_watchdog_pretimeouts.attr, 1251 &dev_attr_alerts.attr, 1252 NULL 1253}; 1254 1255static const struct attribute_group ipmi_ssif_dev_attr_group = { 1256 .attrs = ipmi_ssif_dev_attrs, 1257}; 1258 1259static void shutdown_ssif(void *send_info) 1260{ 1261 struct ssif_info *ssif_info = send_info; 1262 1263 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group); 1264 dev_set_drvdata(&ssif_info->client->dev, NULL); 1265 1266 /* make sure the driver is not looking for flags any more. */ 1267 while (ssif_info->ssif_state != SSIF_IDLE) 1268 schedule_timeout(1); 1269 1270 ssif_info->stopping = true; 1271 del_timer_sync(&ssif_info->watch_timer); 1272 del_timer_sync(&ssif_info->retry_timer); 1273 if (ssif_info->thread) { 1274 complete(&ssif_info->wake_thread); 1275 kthread_stop(ssif_info->thread); 1276 } 1277} 1278 1279static void ssif_remove(struct i2c_client *client) 1280{ 1281 struct ssif_info *ssif_info = i2c_get_clientdata(client); 1282 struct ssif_addr_info *addr_info; 1283 1284 /* 1285 * After this point, we won't deliver anything asynchronously 1286 * to the message handler. We can unregister ourself. 1287 */ 1288 ipmi_unregister_smi(ssif_info->intf); 1289 1290 list_for_each_entry(addr_info, &ssif_infos, link) { 1291 if (addr_info->client == client) { 1292 addr_info->client = NULL; 1293 break; 1294 } 1295 } 1296 1297 kfree(ssif_info); 1298} 1299 1300static int read_response(struct i2c_client *client, unsigned char *resp) 1301{ 1302 int ret = -ENODEV, retry_cnt = SSIF_RECV_RETRIES; 1303 1304 while (retry_cnt > 0) { 1305 ret = i2c_smbus_read_block_data(client, SSIF_IPMI_RESPONSE, 1306 resp); 1307 if (ret > 0) 1308 break; 1309 msleep(SSIF_MSG_MSEC); 1310 retry_cnt--; 1311 if (retry_cnt <= 0) 1312 break; 1313 } 1314 1315 return ret; 1316} 1317 1318static int do_cmd(struct i2c_client *client, int len, unsigned char *msg, 1319 int *resp_len, unsigned char *resp) 1320{ 1321 int retry_cnt; 1322 int ret; 1323 1324 retry_cnt = SSIF_SEND_RETRIES; 1325 retry1: 1326 ret = i2c_smbus_write_block_data(client, SSIF_IPMI_REQUEST, len, msg); 1327 if (ret) { 1328 retry_cnt--; 1329 if (retry_cnt > 0) { 1330 msleep(SSIF_REQ_RETRY_MSEC); 1331 goto retry1; 1332 } 1333 return -ENODEV; 1334 } 1335 1336 ret = read_response(client, resp); 1337 if (ret > 0) { 1338 /* Validate that the response is correct. */ 1339 if (ret < 3 || 1340 (resp[0] != (msg[0] | (1 << 2))) || 1341 (resp[1] != msg[1])) 1342 ret = -EINVAL; 1343 else if (ret > IPMI_MAX_MSG_LENGTH) { 1344 ret = -E2BIG; 1345 } else { 1346 *resp_len = ret; 1347 ret = 0; 1348 } 1349 } 1350 1351 return ret; 1352} 1353 1354static int ssif_detect(struct i2c_client *client, struct i2c_board_info *info) 1355{ 1356 unsigned char *resp; 1357 unsigned char msg[3]; 1358 int rv; 1359 int len; 1360 1361 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1362 if (!resp) 1363 return -ENOMEM; 1364 1365 /* Do a Get Device ID command, since it is required. */ 1366 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1367 msg[1] = IPMI_GET_DEVICE_ID_CMD; 1368 rv = do_cmd(client, 2, msg, &len, resp); 1369 if (rv) 1370 rv = -ENODEV; 1371 else 1372 strscpy(info->type, DEVICE_NAME, I2C_NAME_SIZE); 1373 kfree(resp); 1374 return rv; 1375} 1376 1377static int strcmp_nospace(char *s1, char *s2) 1378{ 1379 while (*s1 && *s2) { 1380 while (isspace(*s1)) 1381 s1++; 1382 while (isspace(*s2)) 1383 s2++; 1384 if (*s1 > *s2) 1385 return 1; 1386 if (*s1 < *s2) 1387 return -1; 1388 s1++; 1389 s2++; 1390 } 1391 return 0; 1392} 1393 1394static struct ssif_addr_info *ssif_info_find(unsigned short addr, 1395 char *adapter_name, 1396 bool match_null_name) 1397{ 1398 struct ssif_addr_info *info, *found = NULL; 1399 1400restart: 1401 list_for_each_entry(info, &ssif_infos, link) { 1402 if (info->binfo.addr == addr) { 1403 if (info->addr_src == SI_SMBIOS && !info->adapter_name) 1404 info->adapter_name = kstrdup(adapter_name, 1405 GFP_KERNEL); 1406 1407 if (info->adapter_name || adapter_name) { 1408 if (!info->adapter_name != !adapter_name) { 1409 /* One is NULL and one is not */ 1410 continue; 1411 } 1412 if (adapter_name && 1413 strcmp_nospace(info->adapter_name, 1414 adapter_name)) 1415 /* Names do not match */ 1416 continue; 1417 } 1418 found = info; 1419 break; 1420 } 1421 } 1422 1423 if (!found && match_null_name) { 1424 /* Try to get an exact match first, then try with a NULL name */ 1425 adapter_name = NULL; 1426 match_null_name = false; 1427 goto restart; 1428 } 1429 1430 return found; 1431} 1432 1433static bool check_acpi(struct ssif_info *ssif_info, struct device *dev) 1434{ 1435#ifdef CONFIG_ACPI 1436 acpi_handle acpi_handle; 1437 1438 acpi_handle = ACPI_HANDLE(dev); 1439 if (acpi_handle) { 1440 ssif_info->addr_source = SI_ACPI; 1441 ssif_info->addr_info.acpi_info.acpi_handle = acpi_handle; 1442 request_module_nowait("acpi_ipmi"); 1443 return true; 1444 } 1445#endif 1446 return false; 1447} 1448 1449static int find_slave_address(struct i2c_client *client, int slave_addr) 1450{ 1451#ifdef CONFIG_IPMI_DMI_DECODE 1452 if (!slave_addr) 1453 slave_addr = ipmi_dmi_get_slave_addr( 1454 SI_TYPE_INVALID, 1455 i2c_adapter_id(client->adapter), 1456 client->addr); 1457#endif 1458 1459 return slave_addr; 1460} 1461 1462static int start_multipart_test(struct i2c_client *client, 1463 unsigned char *msg, bool do_middle) 1464{ 1465 int retry_cnt = SSIF_SEND_RETRIES, ret; 1466 1467retry_write: 1468 ret = i2c_smbus_write_block_data(client, 1469 SSIF_IPMI_MULTI_PART_REQUEST_START, 1470 32, msg); 1471 if (ret) { 1472 retry_cnt--; 1473 if (retry_cnt > 0) { 1474 msleep(SSIF_REQ_RETRY_MSEC); 1475 goto retry_write; 1476 } 1477 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"); 1478 return ret; 1479 } 1480 1481 if (!do_middle) 1482 return 0; 1483 1484 ret = i2c_smbus_write_block_data(client, 1485 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE, 1486 32, msg + 32); 1487 if (ret) { 1488 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"); 1489 return ret; 1490 } 1491 1492 return 0; 1493} 1494 1495static void test_multipart_messages(struct i2c_client *client, 1496 struct ssif_info *ssif_info, 1497 unsigned char *resp) 1498{ 1499 unsigned char msg[65]; 1500 int ret; 1501 bool do_middle; 1502 1503 if (ssif_info->max_xmit_msg_size <= 32) 1504 return; 1505 1506 do_middle = ssif_info->max_xmit_msg_size > 63; 1507 1508 memset(msg, 0, sizeof(msg)); 1509 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1510 msg[1] = IPMI_GET_DEVICE_ID_CMD; 1511 1512 /* 1513 * The specification is all messed up dealing with sending 1514 * multi-part messages. Per what the specification says, it 1515 * is impossible to send a message that is a multiple of 32 1516 * bytes, except for 32 itself. It talks about a "start" 1517 * transaction (cmd=6) that must be 32 bytes, "middle" 1518 * transaction (cmd=7) that must be 32 bytes, and an "end" 1519 * transaction. The "end" transaction is shown as cmd=7 in 1520 * the text, but if that's the case there is no way to 1521 * differentiate between a middle and end part except the 1522 * length being less than 32. But there is a table at the far 1523 * end of the section (that I had never noticed until someone 1524 * pointed it out to me) that mentions it as cmd=8. 1525 * 1526 * After some thought, I think the example is wrong and the 1527 * end transaction should be cmd=8. But some systems don't 1528 * implement cmd=8, they use a zero-length end transaction, 1529 * even though that violates the SMBus specification. 1530 * 1531 * So, to work around this, this code tests if cmd=8 works. 1532 * If it does, then we use that. If not, it tests zero- 1533 * byte end transactions. If that works, good. If not, 1534 * we only allow 63-byte transactions max. 1535 */ 1536 1537 ret = start_multipart_test(client, msg, do_middle); 1538 if (ret) 1539 goto out_no_multi_part; 1540 1541 ret = i2c_smbus_write_block_data(client, 1542 SSIF_IPMI_MULTI_PART_REQUEST_END, 1543 1, msg + 64); 1544 1545 if (!ret) 1546 ret = read_response(client, resp); 1547 1548 if (ret > 0) { 1549 /* End transactions work, we are good. */ 1550 ssif_info->cmd8_works = true; 1551 return; 1552 } 1553 1554 ret = start_multipart_test(client, msg, do_middle); 1555 if (ret) { 1556 dev_err(&client->dev, "Second multipart test failed.\n"); 1557 goto out_no_multi_part; 1558 } 1559 1560 ret = i2c_smbus_write_block_data(client, 1561 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE, 1562 0, msg + 64); 1563 if (!ret) 1564 ret = read_response(client, resp); 1565 if (ret > 0) 1566 /* Zero-size end parts work, use those. */ 1567 return; 1568 1569 /* Limit to 63 bytes and use a short middle command to mark the end. */ 1570 if (ssif_info->max_xmit_msg_size > 63) 1571 ssif_info->max_xmit_msg_size = 63; 1572 return; 1573 1574out_no_multi_part: 1575 ssif_info->max_xmit_msg_size = 32; 1576 return; 1577} 1578 1579/* 1580 * Global enables we care about. 1581 */ 1582#define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \ 1583 IPMI_BMC_EVT_MSG_INTR) 1584 1585static void ssif_remove_dup(struct i2c_client *client) 1586{ 1587 struct ssif_info *ssif_info = i2c_get_clientdata(client); 1588 1589 ipmi_unregister_smi(ssif_info->intf); 1590 kfree(ssif_info); 1591} 1592 1593static int ssif_add_infos(struct i2c_client *client) 1594{ 1595 struct ssif_addr_info *info; 1596 1597 info = kzalloc(sizeof(*info), GFP_KERNEL); 1598 if (!info) 1599 return -ENOMEM; 1600 info->addr_src = SI_ACPI; 1601 info->client = client; 1602 info->adapter_name = kstrdup(client->adapter->name, GFP_KERNEL); 1603 if (!info->adapter_name) { 1604 kfree(info); 1605 return -ENOMEM; 1606 } 1607 1608 info->binfo.addr = client->addr; 1609 list_add_tail(&info->link, &ssif_infos); 1610 return 0; 1611} 1612 1613/* 1614 * Prefer ACPI over SMBIOS, if both are available. 1615 * So if we get an ACPI interface and have already registered a SMBIOS 1616 * interface at the same address, remove the SMBIOS and add the ACPI one. 1617 */ 1618static int ssif_check_and_remove(struct i2c_client *client, 1619 struct ssif_info *ssif_info) 1620{ 1621 struct ssif_addr_info *info; 1622 1623 list_for_each_entry(info, &ssif_infos, link) { 1624 if (!info->client) 1625 return 0; 1626 if (!strcmp(info->adapter_name, client->adapter->name) && 1627 info->binfo.addr == client->addr) { 1628 if (info->addr_src == SI_ACPI) 1629 return -EEXIST; 1630 1631 if (ssif_info->addr_source == SI_ACPI && 1632 info->addr_src == SI_SMBIOS) { 1633 dev_info(&client->dev, 1634 "Removing %s-specified SSIF interface in favor of ACPI\n", 1635 ipmi_addr_src_to_str(info->addr_src)); 1636 ssif_remove_dup(info->client); 1637 return 0; 1638 } 1639 } 1640 } 1641 return 0; 1642} 1643 1644static int ssif_probe(struct i2c_client *client) 1645{ 1646 unsigned char msg[3]; 1647 unsigned char *resp; 1648 struct ssif_info *ssif_info; 1649 int rv = 0; 1650 int len = 0; 1651 int i; 1652 u8 slave_addr = 0; 1653 struct ssif_addr_info *addr_info = NULL; 1654 1655 mutex_lock(&ssif_infos_mutex); 1656 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1657 if (!resp) { 1658 mutex_unlock(&ssif_infos_mutex); 1659 return -ENOMEM; 1660 } 1661 1662 ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL); 1663 if (!ssif_info) { 1664 kfree(resp); 1665 mutex_unlock(&ssif_infos_mutex); 1666 return -ENOMEM; 1667 } 1668 1669 if (!check_acpi(ssif_info, &client->dev)) { 1670 addr_info = ssif_info_find(client->addr, client->adapter->name, 1671 true); 1672 if (!addr_info) { 1673 /* Must have come in through sysfs. */ 1674 ssif_info->addr_source = SI_HOTMOD; 1675 } else { 1676 ssif_info->addr_source = addr_info->addr_src; 1677 ssif_info->ssif_debug = addr_info->debug; 1678 ssif_info->addr_info = addr_info->addr_info; 1679 addr_info->client = client; 1680 slave_addr = addr_info->slave_addr; 1681 } 1682 } 1683 1684 ssif_info->client = client; 1685 i2c_set_clientdata(client, ssif_info); 1686 1687 rv = ssif_check_and_remove(client, ssif_info); 1688 /* If rv is 0 and addr source is not SI_ACPI, continue probing */ 1689 if (!rv && ssif_info->addr_source == SI_ACPI) { 1690 rv = ssif_add_infos(client); 1691 if (rv) { 1692 dev_err(&client->dev, "Out of memory!, exiting ..\n"); 1693 goto out; 1694 } 1695 } else if (rv) { 1696 dev_err(&client->dev, "Not probing, Interface already present\n"); 1697 goto out; 1698 } 1699 1700 slave_addr = find_slave_address(client, slave_addr); 1701 1702 dev_info(&client->dev, 1703 "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n", 1704 ipmi_addr_src_to_str(ssif_info->addr_source), 1705 client->addr, client->adapter->name, slave_addr); 1706 1707 /* Now check for system interface capabilities */ 1708 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1709 msg[1] = IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD; 1710 msg[2] = 0; /* SSIF */ 1711 rv = do_cmd(client, 3, msg, &len, resp); 1712 if (!rv && (len >= 3) && (resp[2] == 0)) { 1713 if (len < 7) { 1714 if (ssif_dbg_probe) 1715 dev_dbg(&ssif_info->client->dev, 1716 "SSIF info too short: %d\n", len); 1717 goto no_support; 1718 } 1719 1720 /* Got a good SSIF response, handle it. */ 1721 ssif_info->max_xmit_msg_size = resp[5]; 1722 ssif_info->max_recv_msg_size = resp[6]; 1723 ssif_info->multi_support = (resp[4] >> 6) & 0x3; 1724 ssif_info->supports_pec = (resp[4] >> 3) & 0x1; 1725 1726 /* Sanitize the data */ 1727 switch (ssif_info->multi_support) { 1728 case SSIF_NO_MULTI: 1729 if (ssif_info->max_xmit_msg_size > 32) 1730 ssif_info->max_xmit_msg_size = 32; 1731 if (ssif_info->max_recv_msg_size > 32) 1732 ssif_info->max_recv_msg_size = 32; 1733 break; 1734 1735 case SSIF_MULTI_2_PART: 1736 if (ssif_info->max_xmit_msg_size > 63) 1737 ssif_info->max_xmit_msg_size = 63; 1738 if (ssif_info->max_recv_msg_size > 62) 1739 ssif_info->max_recv_msg_size = 62; 1740 break; 1741 1742 case SSIF_MULTI_n_PART: 1743 /* We take whatever size given, but do some testing. */ 1744 break; 1745 1746 default: 1747 /* Data is not sane, just give up. */ 1748 goto no_support; 1749 } 1750 } else { 1751 no_support: 1752 /* Assume no multi-part or PEC support */ 1753 dev_info(&ssif_info->client->dev, 1754 "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n", 1755 rv, len, resp[2]); 1756 1757 ssif_info->max_xmit_msg_size = 32; 1758 ssif_info->max_recv_msg_size = 32; 1759 ssif_info->multi_support = SSIF_NO_MULTI; 1760 ssif_info->supports_pec = 0; 1761 } 1762 1763 test_multipart_messages(client, ssif_info, resp); 1764 1765 /* Make sure the NMI timeout is cleared. */ 1766 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1767 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD; 1768 msg[2] = WDT_PRE_TIMEOUT_INT; 1769 rv = do_cmd(client, 3, msg, &len, resp); 1770 if (rv || (len < 3) || (resp[2] != 0)) 1771 dev_warn(&ssif_info->client->dev, 1772 "Unable to clear message flags: %d %d %2.2x\n", 1773 rv, len, resp[2]); 1774 1775 /* Attempt to enable the event buffer. */ 1776 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1777 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 1778 rv = do_cmd(client, 2, msg, &len, resp); 1779 if (rv || (len < 4) || (resp[2] != 0)) { 1780 dev_warn(&ssif_info->client->dev, 1781 "Error getting global enables: %d %d %2.2x\n", 1782 rv, len, resp[2]); 1783 rv = 0; /* Not fatal */ 1784 goto found; 1785 } 1786 1787 ssif_info->global_enables = resp[3]; 1788 1789 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) { 1790 ssif_info->has_event_buffer = true; 1791 /* buffer is already enabled, nothing to do. */ 1792 goto found; 1793 } 1794 1795 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1796 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1797 msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF; 1798 rv = do_cmd(client, 3, msg, &len, resp); 1799 if (rv || (len < 2)) { 1800 dev_warn(&ssif_info->client->dev, 1801 "Error setting global enables: %d %d %2.2x\n", 1802 rv, len, resp[2]); 1803 rv = 0; /* Not fatal */ 1804 goto found; 1805 } 1806 1807 if (resp[2] == 0) { 1808 /* A successful return means the event buffer is supported. */ 1809 ssif_info->has_event_buffer = true; 1810 ssif_info->global_enables |= IPMI_BMC_EVT_MSG_BUFF; 1811 } 1812 1813 /* Some systems don't behave well if you enable alerts. */ 1814 if (alerts_broken) 1815 goto found; 1816 1817 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1818 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1819 msg[2] = ssif_info->global_enables | IPMI_BMC_RCV_MSG_INTR; 1820 rv = do_cmd(client, 3, msg, &len, resp); 1821 if (rv || (len < 2)) { 1822 dev_warn(&ssif_info->client->dev, 1823 "Error setting global enables: %d %d %2.2x\n", 1824 rv, len, resp[2]); 1825 rv = 0; /* Not fatal */ 1826 goto found; 1827 } 1828 1829 if (resp[2] == 0) { 1830 /* A successful return means the alert is supported. */ 1831 ssif_info->supports_alert = true; 1832 ssif_info->global_enables |= IPMI_BMC_RCV_MSG_INTR; 1833 } 1834 1835 found: 1836 if (ssif_dbg_probe) { 1837 dev_dbg(&ssif_info->client->dev, 1838 "%s: i2c_probe found device at i2c address %x\n", 1839 __func__, client->addr); 1840 } 1841 1842 spin_lock_init(&ssif_info->lock); 1843 ssif_info->ssif_state = SSIF_IDLE; 1844 timer_setup(&ssif_info->retry_timer, retry_timeout, 0); 1845 timer_setup(&ssif_info->watch_timer, watch_timeout, 0); 1846 1847 for (i = 0; i < SSIF_NUM_STATS; i++) 1848 atomic_set(&ssif_info->stats[i], 0); 1849 1850 if (ssif_info->supports_pec) 1851 ssif_info->client->flags |= I2C_CLIENT_PEC; 1852 1853 ssif_info->handlers.owner = THIS_MODULE; 1854 ssif_info->handlers.start_processing = ssif_start_processing; 1855 ssif_info->handlers.shutdown = shutdown_ssif; 1856 ssif_info->handlers.get_smi_info = get_smi_info; 1857 ssif_info->handlers.sender = sender; 1858 ssif_info->handlers.request_events = request_events; 1859 ssif_info->handlers.set_need_watch = ssif_set_need_watch; 1860 1861 { 1862 unsigned int thread_num; 1863 1864 thread_num = ((i2c_adapter_id(ssif_info->client->adapter) 1865 << 8) | 1866 ssif_info->client->addr); 1867 init_completion(&ssif_info->wake_thread); 1868 ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info, 1869 "kssif%4.4x", thread_num); 1870 if (IS_ERR(ssif_info->thread)) { 1871 rv = PTR_ERR(ssif_info->thread); 1872 dev_notice(&ssif_info->client->dev, 1873 "Could not start kernel thread: error %d\n", 1874 rv); 1875 goto out; 1876 } 1877 } 1878 1879 dev_set_drvdata(&ssif_info->client->dev, ssif_info); 1880 rv = device_add_group(&ssif_info->client->dev, 1881 &ipmi_ssif_dev_attr_group); 1882 if (rv) { 1883 dev_err(&ssif_info->client->dev, 1884 "Unable to add device attributes: error %d\n", 1885 rv); 1886 goto out; 1887 } 1888 1889 rv = ipmi_register_smi(&ssif_info->handlers, 1890 ssif_info, 1891 &ssif_info->client->dev, 1892 slave_addr); 1893 if (rv) { 1894 dev_err(&ssif_info->client->dev, 1895 "Unable to register device: error %d\n", rv); 1896 goto out_remove_attr; 1897 } 1898 1899 out: 1900 if (rv) { 1901 if (addr_info) 1902 addr_info->client = NULL; 1903 1904 dev_err(&ssif_info->client->dev, 1905 "Unable to start IPMI SSIF: %d\n", rv); 1906 i2c_set_clientdata(client, NULL); 1907 kfree(ssif_info); 1908 } 1909 kfree(resp); 1910 mutex_unlock(&ssif_infos_mutex); 1911 return rv; 1912 1913out_remove_attr: 1914 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group); 1915 dev_set_drvdata(&ssif_info->client->dev, NULL); 1916 goto out; 1917} 1918 1919static int new_ssif_client(int addr, char *adapter_name, 1920 int debug, int slave_addr, 1921 enum ipmi_addr_src addr_src, 1922 struct device *dev) 1923{ 1924 struct ssif_addr_info *addr_info; 1925 int rv = 0; 1926 1927 mutex_lock(&ssif_infos_mutex); 1928 if (ssif_info_find(addr, adapter_name, false)) { 1929 rv = -EEXIST; 1930 goto out_unlock; 1931 } 1932 1933 addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL); 1934 if (!addr_info) { 1935 rv = -ENOMEM; 1936 goto out_unlock; 1937 } 1938 1939 if (adapter_name) { 1940 addr_info->adapter_name = kstrdup(adapter_name, GFP_KERNEL); 1941 if (!addr_info->adapter_name) { 1942 kfree(addr_info); 1943 rv = -ENOMEM; 1944 goto out_unlock; 1945 } 1946 } 1947 1948 strscpy(addr_info->binfo.type, DEVICE_NAME, 1949 sizeof(addr_info->binfo.type)); 1950 addr_info->binfo.addr = addr; 1951 addr_info->binfo.platform_data = addr_info; 1952 addr_info->debug = debug; 1953 addr_info->slave_addr = slave_addr; 1954 addr_info->addr_src = addr_src; 1955 addr_info->dev = dev; 1956 1957 if (dev) 1958 dev_set_drvdata(dev, addr_info); 1959 1960 list_add_tail(&addr_info->link, &ssif_infos); 1961 1962 /* Address list will get it */ 1963 1964out_unlock: 1965 mutex_unlock(&ssif_infos_mutex); 1966 return rv; 1967} 1968 1969static void free_ssif_clients(void) 1970{ 1971 struct ssif_addr_info *info, *tmp; 1972 1973 mutex_lock(&ssif_infos_mutex); 1974 list_for_each_entry_safe(info, tmp, &ssif_infos, link) { 1975 list_del(&info->link); 1976 kfree(info->adapter_name); 1977 kfree(info); 1978 } 1979 mutex_unlock(&ssif_infos_mutex); 1980} 1981 1982static unsigned short *ssif_address_list(void) 1983{ 1984 struct ssif_addr_info *info; 1985 unsigned int count = 0, i = 0; 1986 unsigned short *address_list; 1987 1988 list_for_each_entry(info, &ssif_infos, link) 1989 count++; 1990 1991 address_list = kcalloc(count + 1, sizeof(*address_list), 1992 GFP_KERNEL); 1993 if (!address_list) 1994 return NULL; 1995 1996 list_for_each_entry(info, &ssif_infos, link) { 1997 unsigned short addr = info->binfo.addr; 1998 int j; 1999 2000 for (j = 0; j < i; j++) { 2001 if (address_list[j] == addr) 2002 /* Found a dup. */ 2003 break; 2004 } 2005 if (j == i) /* Didn't find it in the list. */ 2006 address_list[i++] = addr; 2007 } 2008 address_list[i] = I2C_CLIENT_END; 2009 2010 return address_list; 2011} 2012 2013#ifdef CONFIG_ACPI 2014static const struct acpi_device_id ssif_acpi_match[] = { 2015 { "IPI0001", 0 }, 2016 { }, 2017}; 2018MODULE_DEVICE_TABLE(acpi, ssif_acpi_match); 2019#endif 2020 2021#ifdef CONFIG_DMI 2022static int dmi_ipmi_probe(struct platform_device *pdev) 2023{ 2024 u8 slave_addr = 0; 2025 u16 i2c_addr; 2026 int rv; 2027 2028 if (!ssif_trydmi) 2029 return -ENODEV; 2030 2031 rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr); 2032 if (rv) { 2033 dev_warn(&pdev->dev, "No i2c-addr property\n"); 2034 return -ENODEV; 2035 } 2036 2037 rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr); 2038 if (rv) 2039 slave_addr = 0x20; 2040 2041 return new_ssif_client(i2c_addr, NULL, 0, 2042 slave_addr, SI_SMBIOS, &pdev->dev); 2043} 2044#else 2045static int dmi_ipmi_probe(struct platform_device *pdev) 2046{ 2047 return -ENODEV; 2048} 2049#endif 2050 2051static const struct i2c_device_id ssif_id[] = { 2052 { DEVICE_NAME, 0 }, 2053 { } 2054}; 2055MODULE_DEVICE_TABLE(i2c, ssif_id); 2056 2057static struct i2c_driver ssif_i2c_driver = { 2058 .class = I2C_CLASS_HWMON, 2059 .driver = { 2060 .name = DEVICE_NAME 2061 }, 2062 .probe = ssif_probe, 2063 .remove = ssif_remove, 2064 .alert = ssif_alert, 2065 .id_table = ssif_id, 2066 .detect = ssif_detect 2067}; 2068 2069static int ssif_platform_probe(struct platform_device *dev) 2070{ 2071 return dmi_ipmi_probe(dev); 2072} 2073 2074static int ssif_platform_remove(struct platform_device *dev) 2075{ 2076 struct ssif_addr_info *addr_info = dev_get_drvdata(&dev->dev); 2077 2078 mutex_lock(&ssif_infos_mutex); 2079 list_del(&addr_info->link); 2080 kfree(addr_info); 2081 mutex_unlock(&ssif_infos_mutex); 2082 return 0; 2083} 2084 2085static const struct platform_device_id ssif_plat_ids[] = { 2086 { "dmi-ipmi-ssif", 0 }, 2087 { } 2088}; 2089 2090static struct platform_driver ipmi_driver = { 2091 .driver = { 2092 .name = DEVICE_NAME, 2093 }, 2094 .probe = ssif_platform_probe, 2095 .remove = ssif_platform_remove, 2096 .id_table = ssif_plat_ids 2097}; 2098 2099static int __init init_ipmi_ssif(void) 2100{ 2101 int i; 2102 int rv; 2103 2104 if (initialized) 2105 return 0; 2106 2107 pr_info("IPMI SSIF Interface driver\n"); 2108 2109 /* build list for i2c from addr list */ 2110 for (i = 0; i < num_addrs; i++) { 2111 rv = new_ssif_client(addr[i], adapter_name[i], 2112 dbg[i], slave_addrs[i], 2113 SI_HARDCODED, NULL); 2114 if (rv) 2115 pr_err("Couldn't add hardcoded device at addr 0x%x\n", 2116 addr[i]); 2117 } 2118 2119 if (ssif_tryacpi) 2120 ssif_i2c_driver.driver.acpi_match_table = 2121 ACPI_PTR(ssif_acpi_match); 2122 2123 if (ssif_trydmi) { 2124 rv = platform_driver_register(&ipmi_driver); 2125 if (rv) 2126 pr_err("Unable to register driver: %d\n", rv); 2127 else 2128 platform_registered = true; 2129 } 2130 2131 ssif_i2c_driver.address_list = ssif_address_list(); 2132 2133 rv = i2c_add_driver(&ssif_i2c_driver); 2134 if (!rv) 2135 initialized = true; 2136 2137 return rv; 2138} 2139module_init(init_ipmi_ssif); 2140 2141static void __exit cleanup_ipmi_ssif(void) 2142{ 2143 if (!initialized) 2144 return; 2145 2146 initialized = false; 2147 2148 i2c_del_driver(&ssif_i2c_driver); 2149 2150 kfree(ssif_i2c_driver.address_list); 2151 2152 if (ssif_trydmi && platform_registered) 2153 platform_driver_unregister(&ipmi_driver); 2154 2155 free_ssif_clients(); 2156} 2157module_exit(cleanup_ipmi_ssif); 2158 2159MODULE_ALIAS("platform:dmi-ipmi-ssif"); 2160MODULE_AUTHOR("Todd C Davis <todd.c.davis@intel.com>, Corey Minyard <minyard@acm.org>"); 2161MODULE_DESCRIPTION("IPMI driver for management controllers on a SMBus"); 2162MODULE_LICENSE("GPL"); 2163