1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * ipmi_si.c 4 * 5 * The interface to the IPMI driver for the system interfaces (KCS, SMIC, 6 * BT). 7 * 8 * Author: MontaVista Software, Inc. 9 * Corey Minyard <minyard@mvista.com> 10 * source@mvista.com 11 * 12 * Copyright 2002 MontaVista Software Inc. 13 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com> 14 */ 15 16/* 17 * This file holds the "policy" for the interface to the SMI state 18 * machine. It does the configuration, handles timers and interrupts, 19 * and drives the real SMI state machine. 20 */ 21 22#define pr_fmt(fmt) "ipmi_si: " fmt 23 24#include <linux/module.h> 25#include <linux/moduleparam.h> 26#include <linux/sched.h> 27#include <linux/seq_file.h> 28#include <linux/timer.h> 29#include <linux/errno.h> 30#include <linux/spinlock.h> 31#include <linux/slab.h> 32#include <linux/delay.h> 33#include <linux/list.h> 34#include <linux/notifier.h> 35#include <linux/mutex.h> 36#include <linux/kthread.h> 37#include <asm/irq.h> 38#include <linux/interrupt.h> 39#include <linux/rcupdate.h> 40#include <linux/ipmi.h> 41#include <linux/ipmi_smi.h> 42#include "ipmi_si.h" 43#include "ipmi_si_sm.h" 44#include <linux/string.h> 45#include <linux/ctype.h> 46 47/* Measure times between events in the driver. */ 48#undef DEBUG_TIMING 49 50/* Call every 10 ms. */ 51#define SI_TIMEOUT_TIME_USEC 10000 52#define SI_USEC_PER_JIFFY (1000000/HZ) 53#define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY) 54#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a 55 short timeout */ 56 57enum si_intf_state { 58 SI_NORMAL, 59 SI_GETTING_FLAGS, 60 SI_GETTING_EVENTS, 61 SI_CLEARING_FLAGS, 62 SI_GETTING_MESSAGES, 63 SI_CHECKING_ENABLES, 64 SI_SETTING_ENABLES 65 /* FIXME - add watchdog stuff. */ 66}; 67 68/* Some BT-specific defines we need here. */ 69#define IPMI_BT_INTMASK_REG 2 70#define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2 71#define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1 72 73/* 'invalid' to allow a firmware-specified interface to be disabled */ 74const char *const si_to_str[] = { "invalid", "kcs", "smic", "bt", NULL }; 75 76static bool initialized; 77 78/* 79 * Indexes into stats[] in smi_info below. 80 */ 81enum si_stat_indexes { 82 /* 83 * Number of times the driver requested a timer while an operation 84 * was in progress. 85 */ 86 SI_STAT_short_timeouts = 0, 87 88 /* 89 * Number of times the driver requested a timer while nothing was in 90 * progress. 91 */ 92 SI_STAT_long_timeouts, 93 94 /* Number of times the interface was idle while being polled. */ 95 SI_STAT_idles, 96 97 /* Number of interrupts the driver handled. */ 98 SI_STAT_interrupts, 99 100 /* Number of time the driver got an ATTN from the hardware. */ 101 SI_STAT_attentions, 102 103 /* Number of times the driver requested flags from the hardware. */ 104 SI_STAT_flag_fetches, 105 106 /* Number of times the hardware didn't follow the state machine. */ 107 SI_STAT_hosed_count, 108 109 /* Number of completed messages. */ 110 SI_STAT_complete_transactions, 111 112 /* Number of IPMI events received from the hardware. */ 113 SI_STAT_events, 114 115 /* Number of watchdog pretimeouts. */ 116 SI_STAT_watchdog_pretimeouts, 117 118 /* Number of asynchronous messages received. */ 119 SI_STAT_incoming_messages, 120 121 122 /* This *must* remain last, add new values above this. */ 123 SI_NUM_STATS 124}; 125 126struct smi_info { 127 int si_num; 128 struct ipmi_smi *intf; 129 struct si_sm_data *si_sm; 130 const struct si_sm_handlers *handlers; 131 spinlock_t si_lock; 132 struct ipmi_smi_msg *waiting_msg; 133 struct ipmi_smi_msg *curr_msg; 134 enum si_intf_state si_state; 135 136 /* 137 * Used to handle the various types of I/O that can occur with 138 * IPMI 139 */ 140 struct si_sm_io io; 141 142 /* 143 * Per-OEM handler, called from handle_flags(). Returns 1 144 * when handle_flags() needs to be re-run or 0 indicating it 145 * set si_state itself. 146 */ 147 int (*oem_data_avail_handler)(struct smi_info *smi_info); 148 149 /* 150 * Flags from the last GET_MSG_FLAGS command, used when an ATTN 151 * is set to hold the flags until we are done handling everything 152 * from the flags. 153 */ 154#define RECEIVE_MSG_AVAIL 0x01 155#define EVENT_MSG_BUFFER_FULL 0x02 156#define WDT_PRE_TIMEOUT_INT 0x08 157#define OEM0_DATA_AVAIL 0x20 158#define OEM1_DATA_AVAIL 0x40 159#define OEM2_DATA_AVAIL 0x80 160#define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \ 161 OEM1_DATA_AVAIL | \ 162 OEM2_DATA_AVAIL) 163 unsigned char msg_flags; 164 165 /* Does the BMC have an event buffer? */ 166 bool has_event_buffer; 167 168 /* 169 * If set to true, this will request events the next time the 170 * state machine is idle. 171 */ 172 atomic_t req_events; 173 174 /* 175 * If true, run the state machine to completion on every send 176 * call. Generally used after a panic to make sure stuff goes 177 * out. 178 */ 179 bool run_to_completion; 180 181 /* The timer for this si. */ 182 struct timer_list si_timer; 183 184 /* This flag is set, if the timer can be set */ 185 bool timer_can_start; 186 187 /* This flag is set, if the timer is running (timer_pending() isn't enough) */ 188 bool timer_running; 189 190 /* The time (in jiffies) the last timeout occurred at. */ 191 unsigned long last_timeout_jiffies; 192 193 /* Are we waiting for the events, pretimeouts, received msgs? */ 194 atomic_t need_watch; 195 196 /* 197 * The driver will disable interrupts when it gets into a 198 * situation where it cannot handle messages due to lack of 199 * memory. Once that situation clears up, it will re-enable 200 * interrupts. 201 */ 202 bool interrupt_disabled; 203 204 /* 205 * Does the BMC support events? 206 */ 207 bool supports_event_msg_buff; 208 209 /* 210 * Can we disable interrupts the global enables receive irq 211 * bit? There are currently two forms of brokenness, some 212 * systems cannot disable the bit (which is technically within 213 * the spec but a bad idea) and some systems have the bit 214 * forced to zero even though interrupts work (which is 215 * clearly outside the spec). The next bool tells which form 216 * of brokenness is present. 217 */ 218 bool cannot_disable_irq; 219 220 /* 221 * Some systems are broken and cannot set the irq enable 222 * bit, even if they support interrupts. 223 */ 224 bool irq_enable_broken; 225 226 /* Is the driver in maintenance mode? */ 227 bool in_maintenance_mode; 228 229 /* 230 * Did we get an attention that we did not handle? 231 */ 232 bool got_attn; 233 234 /* From the get device id response... */ 235 struct ipmi_device_id device_id; 236 237 /* Have we added the device group to the device? */ 238 bool dev_group_added; 239 240 /* Counters and things for the proc filesystem. */ 241 atomic_t stats[SI_NUM_STATS]; 242 243 struct task_struct *thread; 244 245 struct list_head link; 246}; 247 248#define smi_inc_stat(smi, stat) \ 249 atomic_inc(&(smi)->stats[SI_STAT_ ## stat]) 250#define smi_get_stat(smi, stat) \ 251 ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat])) 252 253#define IPMI_MAX_INTFS 4 254static int force_kipmid[IPMI_MAX_INTFS]; 255static int num_force_kipmid; 256 257static unsigned int kipmid_max_busy_us[IPMI_MAX_INTFS]; 258static int num_max_busy_us; 259 260static bool unload_when_empty = true; 261 262static int try_smi_init(struct smi_info *smi); 263static void cleanup_one_si(struct smi_info *smi_info); 264static void cleanup_ipmi_si(void); 265 266#ifdef DEBUG_TIMING 267void debug_timestamp(struct smi_info *smi_info, char *msg) 268{ 269 struct timespec64 t; 270 271 ktime_get_ts64(&t); 272 dev_dbg(smi_info->io.dev, "**%s: %lld.%9.9ld\n", 273 msg, t.tv_sec, t.tv_nsec); 274} 275#else 276#define debug_timestamp(smi_info, x) 277#endif 278 279static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list); 280static int register_xaction_notifier(struct notifier_block *nb) 281{ 282 return atomic_notifier_chain_register(&xaction_notifier_list, nb); 283} 284 285static void deliver_recv_msg(struct smi_info *smi_info, 286 struct ipmi_smi_msg *msg) 287{ 288 /* Deliver the message to the upper layer. */ 289 ipmi_smi_msg_received(smi_info->intf, msg); 290} 291 292static void return_hosed_msg(struct smi_info *smi_info, int cCode) 293{ 294 struct ipmi_smi_msg *msg = smi_info->curr_msg; 295 296 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED) 297 cCode = IPMI_ERR_UNSPECIFIED; 298 /* else use it as is */ 299 300 /* Make it a response */ 301 msg->rsp[0] = msg->data[0] | 4; 302 msg->rsp[1] = msg->data[1]; 303 msg->rsp[2] = cCode; 304 msg->rsp_size = 3; 305 306 smi_info->curr_msg = NULL; 307 deliver_recv_msg(smi_info, msg); 308} 309 310static enum si_sm_result start_next_msg(struct smi_info *smi_info) 311{ 312 int rv; 313 314 if (!smi_info->waiting_msg) { 315 smi_info->curr_msg = NULL; 316 rv = SI_SM_IDLE; 317 } else { 318 int err; 319 320 smi_info->curr_msg = smi_info->waiting_msg; 321 smi_info->waiting_msg = NULL; 322 debug_timestamp(smi_info, "Start2"); 323 err = atomic_notifier_call_chain(&xaction_notifier_list, 324 0, smi_info); 325 if (err & NOTIFY_STOP_MASK) { 326 rv = SI_SM_CALL_WITHOUT_DELAY; 327 goto out; 328 } 329 err = smi_info->handlers->start_transaction( 330 smi_info->si_sm, 331 smi_info->curr_msg->data, 332 smi_info->curr_msg->data_size); 333 if (err) 334 return_hosed_msg(smi_info, err); 335 336 rv = SI_SM_CALL_WITHOUT_DELAY; 337 } 338out: 339 return rv; 340} 341 342static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val) 343{ 344 if (!smi_info->timer_can_start) 345 return; 346 smi_info->last_timeout_jiffies = jiffies; 347 mod_timer(&smi_info->si_timer, new_val); 348 smi_info->timer_running = true; 349} 350 351/* 352 * Start a new message and (re)start the timer and thread. 353 */ 354static void start_new_msg(struct smi_info *smi_info, unsigned char *msg, 355 unsigned int size) 356{ 357 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 358 359 if (smi_info->thread) 360 wake_up_process(smi_info->thread); 361 362 smi_info->handlers->start_transaction(smi_info->si_sm, msg, size); 363} 364 365static void start_check_enables(struct smi_info *smi_info) 366{ 367 unsigned char msg[2]; 368 369 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 370 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 371 372 start_new_msg(smi_info, msg, 2); 373 smi_info->si_state = SI_CHECKING_ENABLES; 374} 375 376static void start_clear_flags(struct smi_info *smi_info) 377{ 378 unsigned char msg[3]; 379 380 /* Make sure the watchdog pre-timeout flag is not set at startup. */ 381 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 382 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD; 383 msg[2] = WDT_PRE_TIMEOUT_INT; 384 385 start_new_msg(smi_info, msg, 3); 386 smi_info->si_state = SI_CLEARING_FLAGS; 387} 388 389static void start_getting_msg_queue(struct smi_info *smi_info) 390{ 391 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 392 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD; 393 smi_info->curr_msg->data_size = 2; 394 395 start_new_msg(smi_info, smi_info->curr_msg->data, 396 smi_info->curr_msg->data_size); 397 smi_info->si_state = SI_GETTING_MESSAGES; 398} 399 400static void start_getting_events(struct smi_info *smi_info) 401{ 402 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 403 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD; 404 smi_info->curr_msg->data_size = 2; 405 406 start_new_msg(smi_info, smi_info->curr_msg->data, 407 smi_info->curr_msg->data_size); 408 smi_info->si_state = SI_GETTING_EVENTS; 409} 410 411/* 412 * When we have a situtaion where we run out of memory and cannot 413 * allocate messages, we just leave them in the BMC and run the system 414 * polled until we can allocate some memory. Once we have some 415 * memory, we will re-enable the interrupt. 416 * 417 * Note that we cannot just use disable_irq(), since the interrupt may 418 * be shared. 419 */ 420static inline bool disable_si_irq(struct smi_info *smi_info) 421{ 422 if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) { 423 smi_info->interrupt_disabled = true; 424 start_check_enables(smi_info); 425 return true; 426 } 427 return false; 428} 429 430static inline bool enable_si_irq(struct smi_info *smi_info) 431{ 432 if ((smi_info->io.irq) && (smi_info->interrupt_disabled)) { 433 smi_info->interrupt_disabled = false; 434 start_check_enables(smi_info); 435 return true; 436 } 437 return false; 438} 439 440/* 441 * Allocate a message. If unable to allocate, start the interrupt 442 * disable process and return NULL. If able to allocate but 443 * interrupts are disabled, free the message and return NULL after 444 * starting the interrupt enable process. 445 */ 446static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info) 447{ 448 struct ipmi_smi_msg *msg; 449 450 msg = ipmi_alloc_smi_msg(); 451 if (!msg) { 452 if (!disable_si_irq(smi_info)) 453 smi_info->si_state = SI_NORMAL; 454 } else if (enable_si_irq(smi_info)) { 455 ipmi_free_smi_msg(msg); 456 msg = NULL; 457 } 458 return msg; 459} 460 461static void handle_flags(struct smi_info *smi_info) 462{ 463retry: 464 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) { 465 /* Watchdog pre-timeout */ 466 smi_inc_stat(smi_info, watchdog_pretimeouts); 467 468 start_clear_flags(smi_info); 469 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT; 470 ipmi_smi_watchdog_pretimeout(smi_info->intf); 471 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) { 472 /* Messages available. */ 473 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 474 if (!smi_info->curr_msg) 475 return; 476 477 start_getting_msg_queue(smi_info); 478 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) { 479 /* Events available. */ 480 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 481 if (!smi_info->curr_msg) 482 return; 483 484 start_getting_events(smi_info); 485 } else if (smi_info->msg_flags & OEM_DATA_AVAIL && 486 smi_info->oem_data_avail_handler) { 487 if (smi_info->oem_data_avail_handler(smi_info)) 488 goto retry; 489 } else 490 smi_info->si_state = SI_NORMAL; 491} 492 493/* 494 * Global enables we care about. 495 */ 496#define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \ 497 IPMI_BMC_EVT_MSG_INTR) 498 499static u8 current_global_enables(struct smi_info *smi_info, u8 base, 500 bool *irq_on) 501{ 502 u8 enables = 0; 503 504 if (smi_info->supports_event_msg_buff) 505 enables |= IPMI_BMC_EVT_MSG_BUFF; 506 507 if (((smi_info->io.irq && !smi_info->interrupt_disabled) || 508 smi_info->cannot_disable_irq) && 509 !smi_info->irq_enable_broken) 510 enables |= IPMI_BMC_RCV_MSG_INTR; 511 512 if (smi_info->supports_event_msg_buff && 513 smi_info->io.irq && !smi_info->interrupt_disabled && 514 !smi_info->irq_enable_broken) 515 enables |= IPMI_BMC_EVT_MSG_INTR; 516 517 *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR); 518 519 return enables; 520} 521 522static void check_bt_irq(struct smi_info *smi_info, bool irq_on) 523{ 524 u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG); 525 526 irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT; 527 528 if ((bool)irqstate == irq_on) 529 return; 530 531 if (irq_on) 532 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 533 IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 534 else 535 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0); 536} 537 538static void handle_transaction_done(struct smi_info *smi_info) 539{ 540 struct ipmi_smi_msg *msg; 541 542 debug_timestamp(smi_info, "Done"); 543 switch (smi_info->si_state) { 544 case SI_NORMAL: 545 if (!smi_info->curr_msg) 546 break; 547 548 smi_info->curr_msg->rsp_size 549 = smi_info->handlers->get_result( 550 smi_info->si_sm, 551 smi_info->curr_msg->rsp, 552 IPMI_MAX_MSG_LENGTH); 553 554 /* 555 * Do this here becase deliver_recv_msg() releases the 556 * lock, and a new message can be put in during the 557 * time the lock is released. 558 */ 559 msg = smi_info->curr_msg; 560 smi_info->curr_msg = NULL; 561 deliver_recv_msg(smi_info, msg); 562 break; 563 564 case SI_GETTING_FLAGS: 565 { 566 unsigned char msg[4]; 567 unsigned int len; 568 569 /* We got the flags from the SMI, now handle them. */ 570 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 571 if (msg[2] != 0) { 572 /* Error fetching flags, just give up for now. */ 573 smi_info->si_state = SI_NORMAL; 574 } else if (len < 4) { 575 /* 576 * Hmm, no flags. That's technically illegal, but 577 * don't use uninitialized data. 578 */ 579 smi_info->si_state = SI_NORMAL; 580 } else { 581 smi_info->msg_flags = msg[3]; 582 handle_flags(smi_info); 583 } 584 break; 585 } 586 587 case SI_CLEARING_FLAGS: 588 { 589 unsigned char msg[3]; 590 591 /* We cleared the flags. */ 592 smi_info->handlers->get_result(smi_info->si_sm, msg, 3); 593 if (msg[2] != 0) { 594 /* Error clearing flags */ 595 dev_warn_ratelimited(smi_info->io.dev, 596 "Error clearing flags: %2.2x\n", msg[2]); 597 } 598 smi_info->si_state = SI_NORMAL; 599 break; 600 } 601 602 case SI_GETTING_EVENTS: 603 { 604 smi_info->curr_msg->rsp_size 605 = smi_info->handlers->get_result( 606 smi_info->si_sm, 607 smi_info->curr_msg->rsp, 608 IPMI_MAX_MSG_LENGTH); 609 610 /* 611 * Do this here becase deliver_recv_msg() releases the 612 * lock, and a new message can be put in during the 613 * time the lock is released. 614 */ 615 msg = smi_info->curr_msg; 616 smi_info->curr_msg = NULL; 617 if (msg->rsp[2] != 0) { 618 /* Error getting event, probably done. */ 619 msg->done(msg); 620 621 /* Take off the event flag. */ 622 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 623 handle_flags(smi_info); 624 } else { 625 smi_inc_stat(smi_info, events); 626 627 /* 628 * Do this before we deliver the message 629 * because delivering the message releases the 630 * lock and something else can mess with the 631 * state. 632 */ 633 handle_flags(smi_info); 634 635 deliver_recv_msg(smi_info, msg); 636 } 637 break; 638 } 639 640 case SI_GETTING_MESSAGES: 641 { 642 smi_info->curr_msg->rsp_size 643 = smi_info->handlers->get_result( 644 smi_info->si_sm, 645 smi_info->curr_msg->rsp, 646 IPMI_MAX_MSG_LENGTH); 647 648 /* 649 * Do this here becase deliver_recv_msg() releases the 650 * lock, and a new message can be put in during the 651 * time the lock is released. 652 */ 653 msg = smi_info->curr_msg; 654 smi_info->curr_msg = NULL; 655 if (msg->rsp[2] != 0) { 656 /* Error getting event, probably done. */ 657 msg->done(msg); 658 659 /* Take off the msg flag. */ 660 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 661 handle_flags(smi_info); 662 } else { 663 smi_inc_stat(smi_info, incoming_messages); 664 665 /* 666 * Do this before we deliver the message 667 * because delivering the message releases the 668 * lock and something else can mess with the 669 * state. 670 */ 671 handle_flags(smi_info); 672 673 deliver_recv_msg(smi_info, msg); 674 } 675 break; 676 } 677 678 case SI_CHECKING_ENABLES: 679 { 680 unsigned char msg[4]; 681 u8 enables; 682 bool irq_on; 683 684 /* We got the flags from the SMI, now handle them. */ 685 smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 686 if (msg[2] != 0) { 687 dev_warn_ratelimited(smi_info->io.dev, 688 "Couldn't get irq info: %x,\n" 689 "Maybe ok, but ipmi might run very slowly.\n", 690 msg[2]); 691 smi_info->si_state = SI_NORMAL; 692 break; 693 } 694 enables = current_global_enables(smi_info, 0, &irq_on); 695 if (smi_info->io.si_type == SI_BT) 696 /* BT has its own interrupt enable bit. */ 697 check_bt_irq(smi_info, irq_on); 698 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) { 699 /* Enables are not correct, fix them. */ 700 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 701 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 702 msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK); 703 smi_info->handlers->start_transaction( 704 smi_info->si_sm, msg, 3); 705 smi_info->si_state = SI_SETTING_ENABLES; 706 } else if (smi_info->supports_event_msg_buff) { 707 smi_info->curr_msg = ipmi_alloc_smi_msg(); 708 if (!smi_info->curr_msg) { 709 smi_info->si_state = SI_NORMAL; 710 break; 711 } 712 start_getting_events(smi_info); 713 } else { 714 smi_info->si_state = SI_NORMAL; 715 } 716 break; 717 } 718 719 case SI_SETTING_ENABLES: 720 { 721 unsigned char msg[4]; 722 723 smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 724 if (msg[2] != 0) 725 dev_warn_ratelimited(smi_info->io.dev, 726 "Could not set the global enables: 0x%x.\n", 727 msg[2]); 728 729 if (smi_info->supports_event_msg_buff) { 730 smi_info->curr_msg = ipmi_alloc_smi_msg(); 731 if (!smi_info->curr_msg) { 732 smi_info->si_state = SI_NORMAL; 733 break; 734 } 735 start_getting_events(smi_info); 736 } else { 737 smi_info->si_state = SI_NORMAL; 738 } 739 break; 740 } 741 } 742} 743 744/* 745 * Called on timeouts and events. Timeouts should pass the elapsed 746 * time, interrupts should pass in zero. Must be called with 747 * si_lock held and interrupts disabled. 748 */ 749static enum si_sm_result smi_event_handler(struct smi_info *smi_info, 750 int time) 751{ 752 enum si_sm_result si_sm_result; 753 754restart: 755 /* 756 * There used to be a loop here that waited a little while 757 * (around 25us) before giving up. That turned out to be 758 * pointless, the minimum delays I was seeing were in the 300us 759 * range, which is far too long to wait in an interrupt. So 760 * we just run until the state machine tells us something 761 * happened or it needs a delay. 762 */ 763 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time); 764 time = 0; 765 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY) 766 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0); 767 768 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) { 769 smi_inc_stat(smi_info, complete_transactions); 770 771 handle_transaction_done(smi_info); 772 goto restart; 773 } else if (si_sm_result == SI_SM_HOSED) { 774 smi_inc_stat(smi_info, hosed_count); 775 776 /* 777 * Do the before return_hosed_msg, because that 778 * releases the lock. 779 */ 780 smi_info->si_state = SI_NORMAL; 781 if (smi_info->curr_msg != NULL) { 782 /* 783 * If we were handling a user message, format 784 * a response to send to the upper layer to 785 * tell it about the error. 786 */ 787 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED); 788 } 789 goto restart; 790 } 791 792 /* 793 * We prefer handling attn over new messages. But don't do 794 * this if there is not yet an upper layer to handle anything. 795 */ 796 if (si_sm_result == SI_SM_ATTN || smi_info->got_attn) { 797 unsigned char msg[2]; 798 799 if (smi_info->si_state != SI_NORMAL) { 800 /* 801 * We got an ATTN, but we are doing something else. 802 * Handle the ATTN later. 803 */ 804 smi_info->got_attn = true; 805 } else { 806 smi_info->got_attn = false; 807 smi_inc_stat(smi_info, attentions); 808 809 /* 810 * Got a attn, send down a get message flags to see 811 * what's causing it. It would be better to handle 812 * this in the upper layer, but due to the way 813 * interrupts work with the SMI, that's not really 814 * possible. 815 */ 816 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 817 msg[1] = IPMI_GET_MSG_FLAGS_CMD; 818 819 start_new_msg(smi_info, msg, 2); 820 smi_info->si_state = SI_GETTING_FLAGS; 821 goto restart; 822 } 823 } 824 825 /* If we are currently idle, try to start the next message. */ 826 if (si_sm_result == SI_SM_IDLE) { 827 smi_inc_stat(smi_info, idles); 828 829 si_sm_result = start_next_msg(smi_info); 830 if (si_sm_result != SI_SM_IDLE) 831 goto restart; 832 } 833 834 if ((si_sm_result == SI_SM_IDLE) 835 && (atomic_read(&smi_info->req_events))) { 836 /* 837 * We are idle and the upper layer requested that I fetch 838 * events, so do so. 839 */ 840 atomic_set(&smi_info->req_events, 0); 841 842 /* 843 * Take this opportunity to check the interrupt and 844 * message enable state for the BMC. The BMC can be 845 * asynchronously reset, and may thus get interrupts 846 * disable and messages disabled. 847 */ 848 if (smi_info->supports_event_msg_buff || smi_info->io.irq) { 849 start_check_enables(smi_info); 850 } else { 851 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 852 if (!smi_info->curr_msg) 853 goto out; 854 855 start_getting_events(smi_info); 856 } 857 goto restart; 858 } 859 860 if (si_sm_result == SI_SM_IDLE && smi_info->timer_running) { 861 /* Ok it if fails, the timer will just go off. */ 862 if (del_timer(&smi_info->si_timer)) 863 smi_info->timer_running = false; 864 } 865 866out: 867 return si_sm_result; 868} 869 870static void check_start_timer_thread(struct smi_info *smi_info) 871{ 872 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) { 873 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 874 875 if (smi_info->thread) 876 wake_up_process(smi_info->thread); 877 878 start_next_msg(smi_info); 879 smi_event_handler(smi_info, 0); 880 } 881} 882 883static void flush_messages(void *send_info) 884{ 885 struct smi_info *smi_info = send_info; 886 enum si_sm_result result; 887 888 /* 889 * Currently, this function is called only in run-to-completion 890 * mode. This means we are single-threaded, no need for locks. 891 */ 892 result = smi_event_handler(smi_info, 0); 893 while (result != SI_SM_IDLE) { 894 udelay(SI_SHORT_TIMEOUT_USEC); 895 result = smi_event_handler(smi_info, SI_SHORT_TIMEOUT_USEC); 896 } 897} 898 899static void sender(void *send_info, 900 struct ipmi_smi_msg *msg) 901{ 902 struct smi_info *smi_info = send_info; 903 unsigned long flags; 904 905 debug_timestamp(smi_info, "Enqueue"); 906 907 if (smi_info->run_to_completion) { 908 /* 909 * If we are running to completion, start it. Upper 910 * layer will call flush_messages to clear it out. 911 */ 912 smi_info->waiting_msg = msg; 913 return; 914 } 915 916 spin_lock_irqsave(&smi_info->si_lock, flags); 917 /* 918 * The following two lines don't need to be under the lock for 919 * the lock's sake, but they do need SMP memory barriers to 920 * avoid getting things out of order. We are already claiming 921 * the lock, anyway, so just do it under the lock to avoid the 922 * ordering problem. 923 */ 924 BUG_ON(smi_info->waiting_msg); 925 smi_info->waiting_msg = msg; 926 check_start_timer_thread(smi_info); 927 spin_unlock_irqrestore(&smi_info->si_lock, flags); 928} 929 930static void set_run_to_completion(void *send_info, bool i_run_to_completion) 931{ 932 struct smi_info *smi_info = send_info; 933 934 smi_info->run_to_completion = i_run_to_completion; 935 if (i_run_to_completion) 936 flush_messages(smi_info); 937} 938 939/* 940 * Use -1 as a special constant to tell that we are spinning in kipmid 941 * looking for something and not delaying between checks 942 */ 943#define IPMI_TIME_NOT_BUSY ns_to_ktime(-1ull) 944static inline bool ipmi_thread_busy_wait(enum si_sm_result smi_result, 945 const struct smi_info *smi_info, 946 ktime_t *busy_until) 947{ 948 unsigned int max_busy_us = 0; 949 950 if (smi_info->si_num < num_max_busy_us) 951 max_busy_us = kipmid_max_busy_us[smi_info->si_num]; 952 if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY) 953 *busy_until = IPMI_TIME_NOT_BUSY; 954 else if (*busy_until == IPMI_TIME_NOT_BUSY) { 955 *busy_until = ktime_get() + max_busy_us * NSEC_PER_USEC; 956 } else { 957 if (unlikely(ktime_get() > *busy_until)) { 958 *busy_until = IPMI_TIME_NOT_BUSY; 959 return false; 960 } 961 } 962 return true; 963} 964 965 966/* 967 * A busy-waiting loop for speeding up IPMI operation. 968 * 969 * Lousy hardware makes this hard. This is only enabled for systems 970 * that are not BT and do not have interrupts. It starts spinning 971 * when an operation is complete or until max_busy tells it to stop 972 * (if that is enabled). See the paragraph on kimid_max_busy_us in 973 * Documentation/driver-api/ipmi.rst for details. 974 */ 975static int ipmi_thread(void *data) 976{ 977 struct smi_info *smi_info = data; 978 unsigned long flags; 979 enum si_sm_result smi_result; 980 ktime_t busy_until = IPMI_TIME_NOT_BUSY; 981 982 set_user_nice(current, MAX_NICE); 983 while (!kthread_should_stop()) { 984 int busy_wait; 985 986 spin_lock_irqsave(&(smi_info->si_lock), flags); 987 smi_result = smi_event_handler(smi_info, 0); 988 989 /* 990 * If the driver is doing something, there is a possible 991 * race with the timer. If the timer handler see idle, 992 * and the thread here sees something else, the timer 993 * handler won't restart the timer even though it is 994 * required. So start it here if necessary. 995 */ 996 if (smi_result != SI_SM_IDLE && !smi_info->timer_running) 997 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 998 999 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1000 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info, 1001 &busy_until); 1002 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) { 1003 ; /* do nothing */ 1004 } else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait) { 1005 /* 1006 * In maintenance mode we run as fast as 1007 * possible to allow firmware updates to 1008 * complete as fast as possible, but normally 1009 * don't bang on the scheduler. 1010 */ 1011 if (smi_info->in_maintenance_mode) 1012 schedule(); 1013 else 1014 usleep_range(100, 200); 1015 } else if (smi_result == SI_SM_IDLE) { 1016 if (atomic_read(&smi_info->need_watch)) { 1017 schedule_timeout_interruptible(100); 1018 } else { 1019 /* Wait to be woken up when we are needed. */ 1020 __set_current_state(TASK_INTERRUPTIBLE); 1021 schedule(); 1022 } 1023 } else { 1024 schedule_timeout_interruptible(1); 1025 } 1026 } 1027 return 0; 1028} 1029 1030 1031static void poll(void *send_info) 1032{ 1033 struct smi_info *smi_info = send_info; 1034 unsigned long flags = 0; 1035 bool run_to_completion = smi_info->run_to_completion; 1036 1037 /* 1038 * Make sure there is some delay in the poll loop so we can 1039 * drive time forward and timeout things. 1040 */ 1041 udelay(10); 1042 if (!run_to_completion) 1043 spin_lock_irqsave(&smi_info->si_lock, flags); 1044 smi_event_handler(smi_info, 10); 1045 if (!run_to_completion) 1046 spin_unlock_irqrestore(&smi_info->si_lock, flags); 1047} 1048 1049static void request_events(void *send_info) 1050{ 1051 struct smi_info *smi_info = send_info; 1052 1053 if (!smi_info->has_event_buffer) 1054 return; 1055 1056 atomic_set(&smi_info->req_events, 1); 1057} 1058 1059static void set_need_watch(void *send_info, unsigned int watch_mask) 1060{ 1061 struct smi_info *smi_info = send_info; 1062 unsigned long flags; 1063 int enable; 1064 1065 enable = !!watch_mask; 1066 1067 atomic_set(&smi_info->need_watch, enable); 1068 spin_lock_irqsave(&smi_info->si_lock, flags); 1069 check_start_timer_thread(smi_info); 1070 spin_unlock_irqrestore(&smi_info->si_lock, flags); 1071} 1072 1073static void smi_timeout(struct timer_list *t) 1074{ 1075 struct smi_info *smi_info = from_timer(smi_info, t, si_timer); 1076 enum si_sm_result smi_result; 1077 unsigned long flags; 1078 unsigned long jiffies_now; 1079 long time_diff; 1080 long timeout; 1081 1082 spin_lock_irqsave(&(smi_info->si_lock), flags); 1083 debug_timestamp(smi_info, "Timer"); 1084 1085 jiffies_now = jiffies; 1086 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies) 1087 * SI_USEC_PER_JIFFY); 1088 smi_result = smi_event_handler(smi_info, time_diff); 1089 1090 if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) { 1091 /* Running with interrupts, only do long timeouts. */ 1092 timeout = jiffies + SI_TIMEOUT_JIFFIES; 1093 smi_inc_stat(smi_info, long_timeouts); 1094 goto do_mod_timer; 1095 } 1096 1097 /* 1098 * If the state machine asks for a short delay, then shorten 1099 * the timer timeout. 1100 */ 1101 if (smi_result == SI_SM_CALL_WITH_DELAY) { 1102 smi_inc_stat(smi_info, short_timeouts); 1103 timeout = jiffies + 1; 1104 } else { 1105 smi_inc_stat(smi_info, long_timeouts); 1106 timeout = jiffies + SI_TIMEOUT_JIFFIES; 1107 } 1108 1109do_mod_timer: 1110 if (smi_result != SI_SM_IDLE) 1111 smi_mod_timer(smi_info, timeout); 1112 else 1113 smi_info->timer_running = false; 1114 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1115} 1116 1117irqreturn_t ipmi_si_irq_handler(int irq, void *data) 1118{ 1119 struct smi_info *smi_info = data; 1120 unsigned long flags; 1121 1122 if (smi_info->io.si_type == SI_BT) 1123 /* We need to clear the IRQ flag for the BT interface. */ 1124 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 1125 IPMI_BT_INTMASK_CLEAR_IRQ_BIT 1126 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 1127 1128 spin_lock_irqsave(&(smi_info->si_lock), flags); 1129 1130 smi_inc_stat(smi_info, interrupts); 1131 1132 debug_timestamp(smi_info, "Interrupt"); 1133 1134 smi_event_handler(smi_info, 0); 1135 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1136 return IRQ_HANDLED; 1137} 1138 1139static int smi_start_processing(void *send_info, 1140 struct ipmi_smi *intf) 1141{ 1142 struct smi_info *new_smi = send_info; 1143 int enable = 0; 1144 1145 new_smi->intf = intf; 1146 1147 /* Set up the timer that drives the interface. */ 1148 timer_setup(&new_smi->si_timer, smi_timeout, 0); 1149 new_smi->timer_can_start = true; 1150 smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES); 1151 1152 /* Try to claim any interrupts. */ 1153 if (new_smi->io.irq_setup) { 1154 new_smi->io.irq_handler_data = new_smi; 1155 new_smi->io.irq_setup(&new_smi->io); 1156 } 1157 1158 /* 1159 * Check if the user forcefully enabled the daemon. 1160 */ 1161 if (new_smi->si_num < num_force_kipmid) 1162 enable = force_kipmid[new_smi->si_num]; 1163 /* 1164 * The BT interface is efficient enough to not need a thread, 1165 * and there is no need for a thread if we have interrupts. 1166 */ 1167 else if ((new_smi->io.si_type != SI_BT) && (!new_smi->io.irq)) 1168 enable = 1; 1169 1170 if (enable) { 1171 new_smi->thread = kthread_run(ipmi_thread, new_smi, 1172 "kipmi%d", new_smi->si_num); 1173 if (IS_ERR(new_smi->thread)) { 1174 dev_notice(new_smi->io.dev, 1175 "Could not start kernel thread due to error %ld, only using timers to drive the interface\n", 1176 PTR_ERR(new_smi->thread)); 1177 new_smi->thread = NULL; 1178 } 1179 } 1180 1181 return 0; 1182} 1183 1184static int get_smi_info(void *send_info, struct ipmi_smi_info *data) 1185{ 1186 struct smi_info *smi = send_info; 1187 1188 data->addr_src = smi->io.addr_source; 1189 data->dev = smi->io.dev; 1190 data->addr_info = smi->io.addr_info; 1191 get_device(smi->io.dev); 1192 1193 return 0; 1194} 1195 1196static void set_maintenance_mode(void *send_info, bool enable) 1197{ 1198 struct smi_info *smi_info = send_info; 1199 1200 if (!enable) 1201 atomic_set(&smi_info->req_events, 0); 1202 smi_info->in_maintenance_mode = enable; 1203} 1204 1205static void shutdown_smi(void *send_info); 1206static const struct ipmi_smi_handlers handlers = { 1207 .owner = THIS_MODULE, 1208 .start_processing = smi_start_processing, 1209 .shutdown = shutdown_smi, 1210 .get_smi_info = get_smi_info, 1211 .sender = sender, 1212 .request_events = request_events, 1213 .set_need_watch = set_need_watch, 1214 .set_maintenance_mode = set_maintenance_mode, 1215 .set_run_to_completion = set_run_to_completion, 1216 .flush_messages = flush_messages, 1217 .poll = poll, 1218}; 1219 1220static LIST_HEAD(smi_infos); 1221static DEFINE_MUTEX(smi_infos_lock); 1222static int smi_num; /* Used to sequence the SMIs */ 1223 1224static const char * const addr_space_to_str[] = { "i/o", "mem" }; 1225 1226module_param_array(force_kipmid, int, &num_force_kipmid, 0); 1227MODULE_PARM_DESC(force_kipmid, 1228 "Force the kipmi daemon to be enabled (1) or disabled(0). Normally the IPMI driver auto-detects this, but the value may be overridden by this parm."); 1229module_param(unload_when_empty, bool, 0); 1230MODULE_PARM_DESC(unload_when_empty, 1231 "Unload the module if no interfaces are specified or found, default is 1. Setting to 0 is useful for hot add of devices using hotmod."); 1232module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644); 1233MODULE_PARM_DESC(kipmid_max_busy_us, 1234 "Max time (in microseconds) to busy-wait for IPMI data before sleeping. 0 (default) means to wait forever. Set to 100-500 if kipmid is using up a lot of CPU time."); 1235 1236void ipmi_irq_finish_setup(struct si_sm_io *io) 1237{ 1238 if (io->si_type == SI_BT) 1239 /* Enable the interrupt in the BT interface. */ 1240 io->outputb(io, IPMI_BT_INTMASK_REG, 1241 IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 1242} 1243 1244void ipmi_irq_start_cleanup(struct si_sm_io *io) 1245{ 1246 if (io->si_type == SI_BT) 1247 /* Disable the interrupt in the BT interface. */ 1248 io->outputb(io, IPMI_BT_INTMASK_REG, 0); 1249} 1250 1251static void std_irq_cleanup(struct si_sm_io *io) 1252{ 1253 ipmi_irq_start_cleanup(io); 1254 free_irq(io->irq, io->irq_handler_data); 1255} 1256 1257int ipmi_std_irq_setup(struct si_sm_io *io) 1258{ 1259 int rv; 1260 1261 if (!io->irq) 1262 return 0; 1263 1264 rv = request_irq(io->irq, 1265 ipmi_si_irq_handler, 1266 IRQF_SHARED, 1267 SI_DEVICE_NAME, 1268 io->irq_handler_data); 1269 if (rv) { 1270 dev_warn(io->dev, "%s unable to claim interrupt %d, running polled\n", 1271 SI_DEVICE_NAME, io->irq); 1272 io->irq = 0; 1273 } else { 1274 io->irq_cleanup = std_irq_cleanup; 1275 ipmi_irq_finish_setup(io); 1276 dev_info(io->dev, "Using irq %d\n", io->irq); 1277 } 1278 1279 return rv; 1280} 1281 1282static int wait_for_msg_done(struct smi_info *smi_info) 1283{ 1284 enum si_sm_result smi_result; 1285 1286 smi_result = smi_info->handlers->event(smi_info->si_sm, 0); 1287 for (;;) { 1288 if (smi_result == SI_SM_CALL_WITH_DELAY || 1289 smi_result == SI_SM_CALL_WITH_TICK_DELAY) { 1290 schedule_timeout_uninterruptible(1); 1291 smi_result = smi_info->handlers->event( 1292 smi_info->si_sm, jiffies_to_usecs(1)); 1293 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) { 1294 smi_result = smi_info->handlers->event( 1295 smi_info->si_sm, 0); 1296 } else 1297 break; 1298 } 1299 if (smi_result == SI_SM_HOSED) 1300 /* 1301 * We couldn't get the state machine to run, so whatever's at 1302 * the port is probably not an IPMI SMI interface. 1303 */ 1304 return -ENODEV; 1305 1306 return 0; 1307} 1308 1309static int try_get_dev_id(struct smi_info *smi_info) 1310{ 1311 unsigned char msg[2]; 1312 unsigned char *resp; 1313 unsigned long resp_len; 1314 int rv = 0; 1315 unsigned int retry_count = 0; 1316 1317 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1318 if (!resp) 1319 return -ENOMEM; 1320 1321 /* 1322 * Do a Get Device ID command, since it comes back with some 1323 * useful info. 1324 */ 1325 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1326 msg[1] = IPMI_GET_DEVICE_ID_CMD; 1327 1328retry: 1329 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 1330 1331 rv = wait_for_msg_done(smi_info); 1332 if (rv) 1333 goto out; 1334 1335 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 1336 resp, IPMI_MAX_MSG_LENGTH); 1337 1338 /* Check and record info from the get device id, in case we need it. */ 1339 rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1], 1340 resp + 2, resp_len - 2, &smi_info->device_id); 1341 if (rv) { 1342 /* record completion code */ 1343 unsigned char cc = *(resp + 2); 1344 1345 if (cc != IPMI_CC_NO_ERROR && 1346 ++retry_count <= GET_DEVICE_ID_MAX_RETRY) { 1347 dev_warn_ratelimited(smi_info->io.dev, 1348 "BMC returned 0x%2.2x, retry get bmc device id\n", 1349 cc); 1350 goto retry; 1351 } 1352 } 1353 1354out: 1355 kfree(resp); 1356 return rv; 1357} 1358 1359static int get_global_enables(struct smi_info *smi_info, u8 *enables) 1360{ 1361 unsigned char msg[3]; 1362 unsigned char *resp; 1363 unsigned long resp_len; 1364 int rv; 1365 1366 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1367 if (!resp) 1368 return -ENOMEM; 1369 1370 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1371 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 1372 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 1373 1374 rv = wait_for_msg_done(smi_info); 1375 if (rv) { 1376 dev_warn(smi_info->io.dev, 1377 "Error getting response from get global enables command: %d\n", 1378 rv); 1379 goto out; 1380 } 1381 1382 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 1383 resp, IPMI_MAX_MSG_LENGTH); 1384 1385 if (resp_len < 4 || 1386 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 1387 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD || 1388 resp[2] != 0) { 1389 dev_warn(smi_info->io.dev, 1390 "Invalid return from get global enables command: %ld %x %x %x\n", 1391 resp_len, resp[0], resp[1], resp[2]); 1392 rv = -EINVAL; 1393 goto out; 1394 } else { 1395 *enables = resp[3]; 1396 } 1397 1398out: 1399 kfree(resp); 1400 return rv; 1401} 1402 1403/* 1404 * Returns 1 if it gets an error from the command. 1405 */ 1406static int set_global_enables(struct smi_info *smi_info, u8 enables) 1407{ 1408 unsigned char msg[3]; 1409 unsigned char *resp; 1410 unsigned long resp_len; 1411 int rv; 1412 1413 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1414 if (!resp) 1415 return -ENOMEM; 1416 1417 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1418 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1419 msg[2] = enables; 1420 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3); 1421 1422 rv = wait_for_msg_done(smi_info); 1423 if (rv) { 1424 dev_warn(smi_info->io.dev, 1425 "Error getting response from set global enables command: %d\n", 1426 rv); 1427 goto out; 1428 } 1429 1430 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 1431 resp, IPMI_MAX_MSG_LENGTH); 1432 1433 if (resp_len < 3 || 1434 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 1435 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) { 1436 dev_warn(smi_info->io.dev, 1437 "Invalid return from set global enables command: %ld %x %x\n", 1438 resp_len, resp[0], resp[1]); 1439 rv = -EINVAL; 1440 goto out; 1441 } 1442 1443 if (resp[2] != 0) 1444 rv = 1; 1445 1446out: 1447 kfree(resp); 1448 return rv; 1449} 1450 1451/* 1452 * Some BMCs do not support clearing the receive irq bit in the global 1453 * enables (even if they don't support interrupts on the BMC). Check 1454 * for this and handle it properly. 1455 */ 1456static void check_clr_rcv_irq(struct smi_info *smi_info) 1457{ 1458 u8 enables = 0; 1459 int rv; 1460 1461 rv = get_global_enables(smi_info, &enables); 1462 if (!rv) { 1463 if ((enables & IPMI_BMC_RCV_MSG_INTR) == 0) 1464 /* Already clear, should work ok. */ 1465 return; 1466 1467 enables &= ~IPMI_BMC_RCV_MSG_INTR; 1468 rv = set_global_enables(smi_info, enables); 1469 } 1470 1471 if (rv < 0) { 1472 dev_err(smi_info->io.dev, 1473 "Cannot check clearing the rcv irq: %d\n", rv); 1474 return; 1475 } 1476 1477 if (rv) { 1478 /* 1479 * An error when setting the event buffer bit means 1480 * clearing the bit is not supported. 1481 */ 1482 dev_warn(smi_info->io.dev, 1483 "The BMC does not support clearing the recv irq bit, compensating, but the BMC needs to be fixed.\n"); 1484 smi_info->cannot_disable_irq = true; 1485 } 1486} 1487 1488/* 1489 * Some BMCs do not support setting the interrupt bits in the global 1490 * enables even if they support interrupts. Clearly bad, but we can 1491 * compensate. 1492 */ 1493static void check_set_rcv_irq(struct smi_info *smi_info) 1494{ 1495 u8 enables = 0; 1496 int rv; 1497 1498 if (!smi_info->io.irq) 1499 return; 1500 1501 rv = get_global_enables(smi_info, &enables); 1502 if (!rv) { 1503 enables |= IPMI_BMC_RCV_MSG_INTR; 1504 rv = set_global_enables(smi_info, enables); 1505 } 1506 1507 if (rv < 0) { 1508 dev_err(smi_info->io.dev, 1509 "Cannot check setting the rcv irq: %d\n", rv); 1510 return; 1511 } 1512 1513 if (rv) { 1514 /* 1515 * An error when setting the event buffer bit means 1516 * setting the bit is not supported. 1517 */ 1518 dev_warn(smi_info->io.dev, 1519 "The BMC does not support setting the recv irq bit, compensating, but the BMC needs to be fixed.\n"); 1520 smi_info->cannot_disable_irq = true; 1521 smi_info->irq_enable_broken = true; 1522 } 1523} 1524 1525static int try_enable_event_buffer(struct smi_info *smi_info) 1526{ 1527 unsigned char msg[3]; 1528 unsigned char *resp; 1529 unsigned long resp_len; 1530 int rv = 0; 1531 1532 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 1533 if (!resp) 1534 return -ENOMEM; 1535 1536 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1537 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 1538 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 1539 1540 rv = wait_for_msg_done(smi_info); 1541 if (rv) { 1542 pr_warn("Error getting response from get global enables command, the event buffer is not enabled\n"); 1543 goto out; 1544 } 1545 1546 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 1547 resp, IPMI_MAX_MSG_LENGTH); 1548 1549 if (resp_len < 4 || 1550 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 1551 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD || 1552 resp[2] != 0) { 1553 pr_warn("Invalid return from get global enables command, cannot enable the event buffer\n"); 1554 rv = -EINVAL; 1555 goto out; 1556 } 1557 1558 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) { 1559 /* buffer is already enabled, nothing to do. */ 1560 smi_info->supports_event_msg_buff = true; 1561 goto out; 1562 } 1563 1564 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 1565 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 1566 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF; 1567 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3); 1568 1569 rv = wait_for_msg_done(smi_info); 1570 if (rv) { 1571 pr_warn("Error getting response from set global, enables command, the event buffer is not enabled\n"); 1572 goto out; 1573 } 1574 1575 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 1576 resp, IPMI_MAX_MSG_LENGTH); 1577 1578 if (resp_len < 3 || 1579 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 1580 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) { 1581 pr_warn("Invalid return from get global, enables command, not enable the event buffer\n"); 1582 rv = -EINVAL; 1583 goto out; 1584 } 1585 1586 if (resp[2] != 0) 1587 /* 1588 * An error when setting the event buffer bit means 1589 * that the event buffer is not supported. 1590 */ 1591 rv = -ENOENT; 1592 else 1593 smi_info->supports_event_msg_buff = true; 1594 1595out: 1596 kfree(resp); 1597 return rv; 1598} 1599 1600#define IPMI_SI_ATTR(name) \ 1601static ssize_t name##_show(struct device *dev, \ 1602 struct device_attribute *attr, \ 1603 char *buf) \ 1604{ \ 1605 struct smi_info *smi_info = dev_get_drvdata(dev); \ 1606 \ 1607 return sysfs_emit(buf, "%u\n", smi_get_stat(smi_info, name)); \ 1608} \ 1609static DEVICE_ATTR_RO(name) 1610 1611static ssize_t type_show(struct device *dev, 1612 struct device_attribute *attr, 1613 char *buf) 1614{ 1615 struct smi_info *smi_info = dev_get_drvdata(dev); 1616 1617 return sysfs_emit(buf, "%s\n", si_to_str[smi_info->io.si_type]); 1618} 1619static DEVICE_ATTR_RO(type); 1620 1621static ssize_t interrupts_enabled_show(struct device *dev, 1622 struct device_attribute *attr, 1623 char *buf) 1624{ 1625 struct smi_info *smi_info = dev_get_drvdata(dev); 1626 int enabled = smi_info->io.irq && !smi_info->interrupt_disabled; 1627 1628 return sysfs_emit(buf, "%d\n", enabled); 1629} 1630static DEVICE_ATTR_RO(interrupts_enabled); 1631 1632IPMI_SI_ATTR(short_timeouts); 1633IPMI_SI_ATTR(long_timeouts); 1634IPMI_SI_ATTR(idles); 1635IPMI_SI_ATTR(interrupts); 1636IPMI_SI_ATTR(attentions); 1637IPMI_SI_ATTR(flag_fetches); 1638IPMI_SI_ATTR(hosed_count); 1639IPMI_SI_ATTR(complete_transactions); 1640IPMI_SI_ATTR(events); 1641IPMI_SI_ATTR(watchdog_pretimeouts); 1642IPMI_SI_ATTR(incoming_messages); 1643 1644static ssize_t params_show(struct device *dev, 1645 struct device_attribute *attr, 1646 char *buf) 1647{ 1648 struct smi_info *smi_info = dev_get_drvdata(dev); 1649 1650 return sysfs_emit(buf, 1651 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n", 1652 si_to_str[smi_info->io.si_type], 1653 addr_space_to_str[smi_info->io.addr_space], 1654 smi_info->io.addr_data, 1655 smi_info->io.regspacing, 1656 smi_info->io.regsize, 1657 smi_info->io.regshift, 1658 smi_info->io.irq, 1659 smi_info->io.slave_addr); 1660} 1661static DEVICE_ATTR_RO(params); 1662 1663static struct attribute *ipmi_si_dev_attrs[] = { 1664 &dev_attr_type.attr, 1665 &dev_attr_interrupts_enabled.attr, 1666 &dev_attr_short_timeouts.attr, 1667 &dev_attr_long_timeouts.attr, 1668 &dev_attr_idles.attr, 1669 &dev_attr_interrupts.attr, 1670 &dev_attr_attentions.attr, 1671 &dev_attr_flag_fetches.attr, 1672 &dev_attr_hosed_count.attr, 1673 &dev_attr_complete_transactions.attr, 1674 &dev_attr_events.attr, 1675 &dev_attr_watchdog_pretimeouts.attr, 1676 &dev_attr_incoming_messages.attr, 1677 &dev_attr_params.attr, 1678 NULL 1679}; 1680 1681static const struct attribute_group ipmi_si_dev_attr_group = { 1682 .attrs = ipmi_si_dev_attrs, 1683}; 1684 1685/* 1686 * oem_data_avail_to_receive_msg_avail 1687 * @info - smi_info structure with msg_flags set 1688 * 1689 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL 1690 * Returns 1 indicating need to re-run handle_flags(). 1691 */ 1692static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info) 1693{ 1694 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) | 1695 RECEIVE_MSG_AVAIL); 1696 return 1; 1697} 1698 1699/* 1700 * setup_dell_poweredge_oem_data_handler 1701 * @info - smi_info.device_id must be populated 1702 * 1703 * Systems that match, but have firmware version < 1.40 may assert 1704 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that 1705 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL 1706 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags 1707 * as RECEIVE_MSG_AVAIL instead. 1708 * 1709 * As Dell has no plans to release IPMI 1.5 firmware that *ever* 1710 * assert the OEM[012] bits, and if it did, the driver would have to 1711 * change to handle that properly, we don't actually check for the 1712 * firmware version. 1713 * Device ID = 0x20 BMC on PowerEdge 8G servers 1714 * Device Revision = 0x80 1715 * Firmware Revision1 = 0x01 BMC version 1.40 1716 * Firmware Revision2 = 0x40 BCD encoded 1717 * IPMI Version = 0x51 IPMI 1.5 1718 * Manufacturer ID = A2 02 00 Dell IANA 1719 * 1720 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert 1721 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL. 1722 * 1723 */ 1724#define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20 1725#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80 1726#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51 1727#define DELL_IANA_MFR_ID 0x0002a2 1728static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info) 1729{ 1730 struct ipmi_device_id *id = &smi_info->device_id; 1731 if (id->manufacturer_id == DELL_IANA_MFR_ID) { 1732 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID && 1733 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV && 1734 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) { 1735 smi_info->oem_data_avail_handler = 1736 oem_data_avail_to_receive_msg_avail; 1737 } else if (ipmi_version_major(id) < 1 || 1738 (ipmi_version_major(id) == 1 && 1739 ipmi_version_minor(id) < 5)) { 1740 smi_info->oem_data_avail_handler = 1741 oem_data_avail_to_receive_msg_avail; 1742 } 1743 } 1744} 1745 1746#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA 1747static void return_hosed_msg_badsize(struct smi_info *smi_info) 1748{ 1749 struct ipmi_smi_msg *msg = smi_info->curr_msg; 1750 1751 /* Make it a response */ 1752 msg->rsp[0] = msg->data[0] | 4; 1753 msg->rsp[1] = msg->data[1]; 1754 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH; 1755 msg->rsp_size = 3; 1756 smi_info->curr_msg = NULL; 1757 deliver_recv_msg(smi_info, msg); 1758} 1759 1760/* 1761 * dell_poweredge_bt_xaction_handler 1762 * @info - smi_info.device_id must be populated 1763 * 1764 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will 1765 * not respond to a Get SDR command if the length of the data 1766 * requested is exactly 0x3A, which leads to command timeouts and no 1767 * data returned. This intercepts such commands, and causes userspace 1768 * callers to try again with a different-sized buffer, which succeeds. 1769 */ 1770 1771#define STORAGE_NETFN 0x0A 1772#define STORAGE_CMD_GET_SDR 0x23 1773static int dell_poweredge_bt_xaction_handler(struct notifier_block *self, 1774 unsigned long unused, 1775 void *in) 1776{ 1777 struct smi_info *smi_info = in; 1778 unsigned char *data = smi_info->curr_msg->data; 1779 unsigned int size = smi_info->curr_msg->data_size; 1780 if (size >= 8 && 1781 (data[0]>>2) == STORAGE_NETFN && 1782 data[1] == STORAGE_CMD_GET_SDR && 1783 data[7] == 0x3A) { 1784 return_hosed_msg_badsize(smi_info); 1785 return NOTIFY_STOP; 1786 } 1787 return NOTIFY_DONE; 1788} 1789 1790static struct notifier_block dell_poweredge_bt_xaction_notifier = { 1791 .notifier_call = dell_poweredge_bt_xaction_handler, 1792}; 1793 1794/* 1795 * setup_dell_poweredge_bt_xaction_handler 1796 * @info - smi_info.device_id must be filled in already 1797 * 1798 * Fills in smi_info.device_id.start_transaction_pre_hook 1799 * when we know what function to use there. 1800 */ 1801static void 1802setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info) 1803{ 1804 struct ipmi_device_id *id = &smi_info->device_id; 1805 if (id->manufacturer_id == DELL_IANA_MFR_ID && 1806 smi_info->io.si_type == SI_BT) 1807 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier); 1808} 1809 1810/* 1811 * setup_oem_data_handler 1812 * @info - smi_info.device_id must be filled in already 1813 * 1814 * Fills in smi_info.device_id.oem_data_available_handler 1815 * when we know what function to use there. 1816 */ 1817 1818static void setup_oem_data_handler(struct smi_info *smi_info) 1819{ 1820 setup_dell_poweredge_oem_data_handler(smi_info); 1821} 1822 1823static void setup_xaction_handlers(struct smi_info *smi_info) 1824{ 1825 setup_dell_poweredge_bt_xaction_handler(smi_info); 1826} 1827 1828static void check_for_broken_irqs(struct smi_info *smi_info) 1829{ 1830 check_clr_rcv_irq(smi_info); 1831 check_set_rcv_irq(smi_info); 1832} 1833 1834static inline void stop_timer_and_thread(struct smi_info *smi_info) 1835{ 1836 if (smi_info->thread != NULL) { 1837 kthread_stop(smi_info->thread); 1838 smi_info->thread = NULL; 1839 } 1840 1841 smi_info->timer_can_start = false; 1842 del_timer_sync(&smi_info->si_timer); 1843} 1844 1845static struct smi_info *find_dup_si(struct smi_info *info) 1846{ 1847 struct smi_info *e; 1848 1849 list_for_each_entry(e, &smi_infos, link) { 1850 if (e->io.addr_space != info->io.addr_space) 1851 continue; 1852 if (e->io.addr_data == info->io.addr_data) { 1853 /* 1854 * This is a cheap hack, ACPI doesn't have a defined 1855 * slave address but SMBIOS does. Pick it up from 1856 * any source that has it available. 1857 */ 1858 if (info->io.slave_addr && !e->io.slave_addr) 1859 e->io.slave_addr = info->io.slave_addr; 1860 return e; 1861 } 1862 } 1863 1864 return NULL; 1865} 1866 1867int ipmi_si_add_smi(struct si_sm_io *io) 1868{ 1869 int rv = 0; 1870 struct smi_info *new_smi, *dup; 1871 1872 /* 1873 * If the user gave us a hard-coded device at the same 1874 * address, they presumably want us to use it and not what is 1875 * in the firmware. 1876 */ 1877 if (io->addr_source != SI_HARDCODED && io->addr_source != SI_HOTMOD && 1878 ipmi_si_hardcode_match(io->addr_space, io->addr_data)) { 1879 dev_info(io->dev, 1880 "Hard-coded device at this address already exists"); 1881 return -ENODEV; 1882 } 1883 1884 if (!io->io_setup) { 1885 if (io->addr_space == IPMI_IO_ADDR_SPACE) { 1886 io->io_setup = ipmi_si_port_setup; 1887 } else if (io->addr_space == IPMI_MEM_ADDR_SPACE) { 1888 io->io_setup = ipmi_si_mem_setup; 1889 } else { 1890 return -EINVAL; 1891 } 1892 } 1893 1894 new_smi = kzalloc(sizeof(*new_smi), GFP_KERNEL); 1895 if (!new_smi) 1896 return -ENOMEM; 1897 spin_lock_init(&new_smi->si_lock); 1898 1899 new_smi->io = *io; 1900 1901 mutex_lock(&smi_infos_lock); 1902 dup = find_dup_si(new_smi); 1903 if (dup) { 1904 if (new_smi->io.addr_source == SI_ACPI && 1905 dup->io.addr_source == SI_SMBIOS) { 1906 /* We prefer ACPI over SMBIOS. */ 1907 dev_info(dup->io.dev, 1908 "Removing SMBIOS-specified %s state machine in favor of ACPI\n", 1909 si_to_str[new_smi->io.si_type]); 1910 cleanup_one_si(dup); 1911 } else { 1912 dev_info(new_smi->io.dev, 1913 "%s-specified %s state machine: duplicate\n", 1914 ipmi_addr_src_to_str(new_smi->io.addr_source), 1915 si_to_str[new_smi->io.si_type]); 1916 rv = -EBUSY; 1917 kfree(new_smi); 1918 goto out_err; 1919 } 1920 } 1921 1922 pr_info("Adding %s-specified %s state machine\n", 1923 ipmi_addr_src_to_str(new_smi->io.addr_source), 1924 si_to_str[new_smi->io.si_type]); 1925 1926 list_add_tail(&new_smi->link, &smi_infos); 1927 1928 if (initialized) 1929 rv = try_smi_init(new_smi); 1930out_err: 1931 mutex_unlock(&smi_infos_lock); 1932 return rv; 1933} 1934 1935/* 1936 * Try to start up an interface. Must be called with smi_infos_lock 1937 * held, primarily to keep smi_num consistent, we only one to do these 1938 * one at a time. 1939 */ 1940static int try_smi_init(struct smi_info *new_smi) 1941{ 1942 int rv = 0; 1943 int i; 1944 1945 pr_info("Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n", 1946 ipmi_addr_src_to_str(new_smi->io.addr_source), 1947 si_to_str[new_smi->io.si_type], 1948 addr_space_to_str[new_smi->io.addr_space], 1949 new_smi->io.addr_data, 1950 new_smi->io.slave_addr, new_smi->io.irq); 1951 1952 switch (new_smi->io.si_type) { 1953 case SI_KCS: 1954 new_smi->handlers = &kcs_smi_handlers; 1955 break; 1956 1957 case SI_SMIC: 1958 new_smi->handlers = &smic_smi_handlers; 1959 break; 1960 1961 case SI_BT: 1962 new_smi->handlers = &bt_smi_handlers; 1963 break; 1964 1965 default: 1966 /* No support for anything else yet. */ 1967 rv = -EIO; 1968 goto out_err; 1969 } 1970 1971 new_smi->si_num = smi_num; 1972 1973 /* Do this early so it's available for logs. */ 1974 if (!new_smi->io.dev) { 1975 pr_err("IPMI interface added with no device\n"); 1976 rv = -EIO; 1977 goto out_err; 1978 } 1979 1980 /* Allocate the state machine's data and initialize it. */ 1981 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL); 1982 if (!new_smi->si_sm) { 1983 rv = -ENOMEM; 1984 goto out_err; 1985 } 1986 new_smi->io.io_size = new_smi->handlers->init_data(new_smi->si_sm, 1987 &new_smi->io); 1988 1989 /* Now that we know the I/O size, we can set up the I/O. */ 1990 rv = new_smi->io.io_setup(&new_smi->io); 1991 if (rv) { 1992 dev_err(new_smi->io.dev, "Could not set up I/O space\n"); 1993 goto out_err; 1994 } 1995 1996 /* Do low-level detection first. */ 1997 if (new_smi->handlers->detect(new_smi->si_sm)) { 1998 if (new_smi->io.addr_source) 1999 dev_err(new_smi->io.dev, 2000 "Interface detection failed\n"); 2001 rv = -ENODEV; 2002 goto out_err; 2003 } 2004 2005 /* 2006 * Attempt a get device id command. If it fails, we probably 2007 * don't have a BMC here. 2008 */ 2009 rv = try_get_dev_id(new_smi); 2010 if (rv) { 2011 if (new_smi->io.addr_source) 2012 dev_err(new_smi->io.dev, 2013 "There appears to be no BMC at this location\n"); 2014 goto out_err; 2015 } 2016 2017 setup_oem_data_handler(new_smi); 2018 setup_xaction_handlers(new_smi); 2019 check_for_broken_irqs(new_smi); 2020 2021 new_smi->waiting_msg = NULL; 2022 new_smi->curr_msg = NULL; 2023 atomic_set(&new_smi->req_events, 0); 2024 new_smi->run_to_completion = false; 2025 for (i = 0; i < SI_NUM_STATS; i++) 2026 atomic_set(&new_smi->stats[i], 0); 2027 2028 new_smi->interrupt_disabled = true; 2029 atomic_set(&new_smi->need_watch, 0); 2030 2031 rv = try_enable_event_buffer(new_smi); 2032 if (rv == 0) 2033 new_smi->has_event_buffer = true; 2034 2035 /* 2036 * Start clearing the flags before we enable interrupts or the 2037 * timer to avoid racing with the timer. 2038 */ 2039 start_clear_flags(new_smi); 2040 2041 /* 2042 * IRQ is defined to be set when non-zero. req_events will 2043 * cause a global flags check that will enable interrupts. 2044 */ 2045 if (new_smi->io.irq) { 2046 new_smi->interrupt_disabled = false; 2047 atomic_set(&new_smi->req_events, 1); 2048 } 2049 2050 dev_set_drvdata(new_smi->io.dev, new_smi); 2051 rv = device_add_group(new_smi->io.dev, &ipmi_si_dev_attr_group); 2052 if (rv) { 2053 dev_err(new_smi->io.dev, 2054 "Unable to add device attributes: error %d\n", 2055 rv); 2056 goto out_err; 2057 } 2058 new_smi->dev_group_added = true; 2059 2060 rv = ipmi_register_smi(&handlers, 2061 new_smi, 2062 new_smi->io.dev, 2063 new_smi->io.slave_addr); 2064 if (rv) { 2065 dev_err(new_smi->io.dev, 2066 "Unable to register device: error %d\n", 2067 rv); 2068 goto out_err; 2069 } 2070 2071 /* Don't increment till we know we have succeeded. */ 2072 smi_num++; 2073 2074 dev_info(new_smi->io.dev, "IPMI %s interface initialized\n", 2075 si_to_str[new_smi->io.si_type]); 2076 2077 WARN_ON(new_smi->io.dev->init_name != NULL); 2078 2079 out_err: 2080 if (rv && new_smi->io.io_cleanup) { 2081 new_smi->io.io_cleanup(&new_smi->io); 2082 new_smi->io.io_cleanup = NULL; 2083 } 2084 2085 if (rv && new_smi->si_sm) { 2086 kfree(new_smi->si_sm); 2087 new_smi->si_sm = NULL; 2088 } 2089 2090 return rv; 2091} 2092 2093static int __init init_ipmi_si(void) 2094{ 2095 struct smi_info *e; 2096 enum ipmi_addr_src type = SI_INVALID; 2097 2098 if (initialized) 2099 return 0; 2100 2101 ipmi_hardcode_init(); 2102 2103 pr_info("IPMI System Interface driver\n"); 2104 2105 ipmi_si_platform_init(); 2106 2107 ipmi_si_pci_init(); 2108 2109 ipmi_si_parisc_init(); 2110 2111 /* We prefer devices with interrupts, but in the case of a machine 2112 with multiple BMCs we assume that there will be several instances 2113 of a given type so if we succeed in registering a type then also 2114 try to register everything else of the same type */ 2115 mutex_lock(&smi_infos_lock); 2116 list_for_each_entry(e, &smi_infos, link) { 2117 /* Try to register a device if it has an IRQ and we either 2118 haven't successfully registered a device yet or this 2119 device has the same type as one we successfully registered */ 2120 if (e->io.irq && (!type || e->io.addr_source == type)) { 2121 if (!try_smi_init(e)) { 2122 type = e->io.addr_source; 2123 } 2124 } 2125 } 2126 2127 /* type will only have been set if we successfully registered an si */ 2128 if (type) 2129 goto skip_fallback_noirq; 2130 2131 /* Fall back to the preferred device */ 2132 2133 list_for_each_entry(e, &smi_infos, link) { 2134 if (!e->io.irq && (!type || e->io.addr_source == type)) { 2135 if (!try_smi_init(e)) { 2136 type = e->io.addr_source; 2137 } 2138 } 2139 } 2140 2141skip_fallback_noirq: 2142 initialized = true; 2143 mutex_unlock(&smi_infos_lock); 2144 2145 if (type) 2146 return 0; 2147 2148 mutex_lock(&smi_infos_lock); 2149 if (unload_when_empty && list_empty(&smi_infos)) { 2150 mutex_unlock(&smi_infos_lock); 2151 cleanup_ipmi_si(); 2152 pr_warn("Unable to find any System Interface(s)\n"); 2153 return -ENODEV; 2154 } else { 2155 mutex_unlock(&smi_infos_lock); 2156 return 0; 2157 } 2158} 2159module_init(init_ipmi_si); 2160 2161static void wait_msg_processed(struct smi_info *smi_info) 2162{ 2163 unsigned long jiffies_now; 2164 long time_diff; 2165 2166 while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) { 2167 jiffies_now = jiffies; 2168 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies) 2169 * SI_USEC_PER_JIFFY); 2170 smi_event_handler(smi_info, time_diff); 2171 schedule_timeout_uninterruptible(1); 2172 } 2173} 2174 2175static void shutdown_smi(void *send_info) 2176{ 2177 struct smi_info *smi_info = send_info; 2178 2179 if (smi_info->dev_group_added) { 2180 device_remove_group(smi_info->io.dev, &ipmi_si_dev_attr_group); 2181 smi_info->dev_group_added = false; 2182 } 2183 if (smi_info->io.dev) 2184 dev_set_drvdata(smi_info->io.dev, NULL); 2185 2186 /* 2187 * Make sure that interrupts, the timer and the thread are 2188 * stopped and will not run again. 2189 */ 2190 smi_info->interrupt_disabled = true; 2191 if (smi_info->io.irq_cleanup) { 2192 smi_info->io.irq_cleanup(&smi_info->io); 2193 smi_info->io.irq_cleanup = NULL; 2194 } 2195 stop_timer_and_thread(smi_info); 2196 2197 /* 2198 * Wait until we know that we are out of any interrupt 2199 * handlers might have been running before we freed the 2200 * interrupt. 2201 */ 2202 synchronize_rcu(); 2203 2204 /* 2205 * Timeouts are stopped, now make sure the interrupts are off 2206 * in the BMC. Note that timers and CPU interrupts are off, 2207 * so no need for locks. 2208 */ 2209 wait_msg_processed(smi_info); 2210 2211 if (smi_info->handlers) 2212 disable_si_irq(smi_info); 2213 2214 wait_msg_processed(smi_info); 2215 2216 if (smi_info->handlers) 2217 smi_info->handlers->cleanup(smi_info->si_sm); 2218 2219 if (smi_info->io.io_cleanup) { 2220 smi_info->io.io_cleanup(&smi_info->io); 2221 smi_info->io.io_cleanup = NULL; 2222 } 2223 2224 kfree(smi_info->si_sm); 2225 smi_info->si_sm = NULL; 2226 2227 smi_info->intf = NULL; 2228} 2229 2230/* 2231 * Must be called with smi_infos_lock held, to serialize the 2232 * smi_info->intf check. 2233 */ 2234static void cleanup_one_si(struct smi_info *smi_info) 2235{ 2236 if (!smi_info) 2237 return; 2238 2239 list_del(&smi_info->link); 2240 ipmi_unregister_smi(smi_info->intf); 2241 kfree(smi_info); 2242} 2243 2244void ipmi_si_remove_by_dev(struct device *dev) 2245{ 2246 struct smi_info *e; 2247 2248 mutex_lock(&smi_infos_lock); 2249 list_for_each_entry(e, &smi_infos, link) { 2250 if (e->io.dev == dev) { 2251 cleanup_one_si(e); 2252 break; 2253 } 2254 } 2255 mutex_unlock(&smi_infos_lock); 2256} 2257 2258struct device *ipmi_si_remove_by_data(int addr_space, enum si_type si_type, 2259 unsigned long addr) 2260{ 2261 /* remove */ 2262 struct smi_info *e, *tmp_e; 2263 struct device *dev = NULL; 2264 2265 mutex_lock(&smi_infos_lock); 2266 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) { 2267 if (e->io.addr_space != addr_space) 2268 continue; 2269 if (e->io.si_type != si_type) 2270 continue; 2271 if (e->io.addr_data == addr) { 2272 dev = get_device(e->io.dev); 2273 cleanup_one_si(e); 2274 } 2275 } 2276 mutex_unlock(&smi_infos_lock); 2277 2278 return dev; 2279} 2280 2281static void cleanup_ipmi_si(void) 2282{ 2283 struct smi_info *e, *tmp_e; 2284 2285 if (!initialized) 2286 return; 2287 2288 ipmi_si_pci_shutdown(); 2289 2290 ipmi_si_parisc_shutdown(); 2291 2292 ipmi_si_platform_shutdown(); 2293 2294 mutex_lock(&smi_infos_lock); 2295 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) 2296 cleanup_one_si(e); 2297 mutex_unlock(&smi_infos_lock); 2298 2299 ipmi_si_hardcode_exit(); 2300 ipmi_si_hotmod_exit(); 2301} 2302module_exit(cleanup_ipmi_si); 2303 2304MODULE_ALIAS("platform:dmi-ipmi-si"); 2305MODULE_LICENSE("GPL"); 2306MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 2307MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces."); 2308