1 /* 2 * ipmi_si.c 3 * 4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC, 5 * BT). 6 * 7 * Author: MontaVista Software, Inc. 8 * Corey Minyard <minyard@mvista.com> 9 * source@mvista.com 10 * 11 * Copyright 2002 MontaVista Software Inc. 12 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com> 13 * 14 * This program is free software; you can redistribute it and/or modify it 15 * under the terms of the GNU General Public License as published by the 16 * Free Software Foundation; either version 2 of the License, or (at your 17 * option) any later version. 18 * 19 * 20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 21 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 22 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 25 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 26 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 27 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 28 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 29 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 * 31 * You should have received a copy of the GNU General Public License along 32 * with this program; if not, write to the Free Software Foundation, Inc., 33 * 675 Mass Ave, Cambridge, MA 02139, USA. 34 */ 35 36 /* 37 * This file holds the "policy" for the interface to the SMI state 38 * machine. It does the configuration, handles timers and interrupts, 39 * and drives the real SMI state machine. 40 */ 41 42 #include <linux/module.h> 43 #include <linux/moduleparam.h> 44 #include <linux/sched.h> 45 #include <linux/seq_file.h> 46 #include <linux/timer.h> 47 #include <linux/errno.h> 48 #include <linux/spinlock.h> 49 #include <linux/slab.h> 50 #include <linux/delay.h> 51 #include <linux/list.h> 52 #include <linux/pci.h> 53 #include <linux/ioport.h> 54 #include <linux/notifier.h> 55 #include <linux/mutex.h> 56 #include <linux/kthread.h> 57 #include <asm/irq.h> 58 #include <linux/interrupt.h> 59 #include <linux/rcupdate.h> 60 #include <linux/ipmi.h> 61 #include <linux/ipmi_smi.h> 62 #include <asm/io.h> 63 #include "ipmi_si_sm.h" 64 #include "ipmi_dmi.h" 65 #include <linux/dmi.h> 66 #include <linux/string.h> 67 #include <linux/ctype.h> 68 #include <linux/of_device.h> 69 #include <linux/of_platform.h> 70 #include <linux/of_address.h> 71 #include <linux/of_irq.h> 72 #include <linux/acpi.h> 73 74 #ifdef CONFIG_PARISC 75 #include <asm/hardware.h> /* for register_parisc_driver() stuff */ 76 #include <asm/parisc-device.h> 77 #endif 78 79 #define PFX "ipmi_si: " 80 81 /* Measure times between events in the driver. */ 82 #undef DEBUG_TIMING 83 84 /* Call every 10 ms. */ 85 #define SI_TIMEOUT_TIME_USEC 10000 86 #define SI_USEC_PER_JIFFY (1000000/HZ) 87 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY) 88 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a 89 short timeout */ 90 91 enum si_intf_state { 92 SI_NORMAL, 93 SI_GETTING_FLAGS, 94 SI_GETTING_EVENTS, 95 SI_CLEARING_FLAGS, 96 SI_GETTING_MESSAGES, 97 SI_CHECKING_ENABLES, 98 SI_SETTING_ENABLES 99 /* FIXME - add watchdog stuff. */ 100 }; 101 102 /* Some BT-specific defines we need here. */ 103 #define IPMI_BT_INTMASK_REG 2 104 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2 105 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1 106 107 enum si_type { 108 SI_KCS, SI_SMIC, SI_BT 109 }; 110 111 static const char * const si_to_str[] = { "kcs", "smic", "bt" }; 112 113 #define DEVICE_NAME "ipmi_si" 114 115 static struct platform_driver ipmi_driver; 116 117 /* 118 * Indexes into stats[] in smi_info below. 119 */ 120 enum si_stat_indexes { 121 /* 122 * Number of times the driver requested a timer while an operation 123 * was in progress. 124 */ 125 SI_STAT_short_timeouts = 0, 126 127 /* 128 * Number of times the driver requested a timer while nothing was in 129 * progress. 130 */ 131 SI_STAT_long_timeouts, 132 133 /* Number of times the interface was idle while being polled. */ 134 SI_STAT_idles, 135 136 /* Number of interrupts the driver handled. */ 137 SI_STAT_interrupts, 138 139 /* Number of time the driver got an ATTN from the hardware. */ 140 SI_STAT_attentions, 141 142 /* Number of times the driver requested flags from the hardware. */ 143 SI_STAT_flag_fetches, 144 145 /* Number of times the hardware didn't follow the state machine. */ 146 SI_STAT_hosed_count, 147 148 /* Number of completed messages. */ 149 SI_STAT_complete_transactions, 150 151 /* Number of IPMI events received from the hardware. */ 152 SI_STAT_events, 153 154 /* Number of watchdog pretimeouts. */ 155 SI_STAT_watchdog_pretimeouts, 156 157 /* Number of asynchronous messages received. */ 158 SI_STAT_incoming_messages, 159 160 161 /* This *must* remain last, add new values above this. */ 162 SI_NUM_STATS 163 }; 164 165 struct smi_info { 166 int intf_num; 167 ipmi_smi_t intf; 168 struct si_sm_data *si_sm; 169 const struct si_sm_handlers *handlers; 170 enum si_type si_type; 171 spinlock_t si_lock; 172 struct ipmi_smi_msg *waiting_msg; 173 struct ipmi_smi_msg *curr_msg; 174 enum si_intf_state si_state; 175 176 /* 177 * Used to handle the various types of I/O that can occur with 178 * IPMI 179 */ 180 struct si_sm_io io; 181 int (*io_setup)(struct smi_info *info); 182 void (*io_cleanup)(struct smi_info *info); 183 int (*irq_setup)(struct smi_info *info); 184 void (*irq_cleanup)(struct smi_info *info); 185 unsigned int io_size; 186 enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */ 187 void (*addr_source_cleanup)(struct smi_info *info); 188 void *addr_source_data; 189 190 /* 191 * Per-OEM handler, called from handle_flags(). Returns 1 192 * when handle_flags() needs to be re-run or 0 indicating it 193 * set si_state itself. 194 */ 195 int (*oem_data_avail_handler)(struct smi_info *smi_info); 196 197 /* 198 * Flags from the last GET_MSG_FLAGS command, used when an ATTN 199 * is set to hold the flags until we are done handling everything 200 * from the flags. 201 */ 202 #define RECEIVE_MSG_AVAIL 0x01 203 #define EVENT_MSG_BUFFER_FULL 0x02 204 #define WDT_PRE_TIMEOUT_INT 0x08 205 #define OEM0_DATA_AVAIL 0x20 206 #define OEM1_DATA_AVAIL 0x40 207 #define OEM2_DATA_AVAIL 0x80 208 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \ 209 OEM1_DATA_AVAIL | \ 210 OEM2_DATA_AVAIL) 211 unsigned char msg_flags; 212 213 /* Does the BMC have an event buffer? */ 214 bool has_event_buffer; 215 216 /* 217 * If set to true, this will request events the next time the 218 * state machine is idle. 219 */ 220 atomic_t req_events; 221 222 /* 223 * If true, run the state machine to completion on every send 224 * call. Generally used after a panic to make sure stuff goes 225 * out. 226 */ 227 bool run_to_completion; 228 229 /* The I/O port of an SI interface. */ 230 int port; 231 232 /* 233 * The space between start addresses of the two ports. For 234 * instance, if the first port is 0xca2 and the spacing is 4, then 235 * the second port is 0xca6. 236 */ 237 unsigned int spacing; 238 239 /* zero if no irq; */ 240 int irq; 241 242 /* The timer for this si. */ 243 struct timer_list si_timer; 244 245 /* This flag is set, if the timer is running (timer_pending() isn't enough) */ 246 bool timer_running; 247 248 /* The time (in jiffies) the last timeout occurred at. */ 249 unsigned long last_timeout_jiffies; 250 251 /* Are we waiting for the events, pretimeouts, received msgs? */ 252 atomic_t need_watch; 253 254 /* 255 * The driver will disable interrupts when it gets into a 256 * situation where it cannot handle messages due to lack of 257 * memory. Once that situation clears up, it will re-enable 258 * interrupts. 259 */ 260 bool interrupt_disabled; 261 262 /* 263 * Does the BMC support events? 264 */ 265 bool supports_event_msg_buff; 266 267 /* 268 * Can we disable interrupts the global enables receive irq 269 * bit? There are currently two forms of brokenness, some 270 * systems cannot disable the bit (which is technically within 271 * the spec but a bad idea) and some systems have the bit 272 * forced to zero even though interrupts work (which is 273 * clearly outside the spec). The next bool tells which form 274 * of brokenness is present. 275 */ 276 bool cannot_disable_irq; 277 278 /* 279 * Some systems are broken and cannot set the irq enable 280 * bit, even if they support interrupts. 281 */ 282 bool irq_enable_broken; 283 284 /* 285 * Did we get an attention that we did not handle? 286 */ 287 bool got_attn; 288 289 /* From the get device id response... */ 290 struct ipmi_device_id device_id; 291 292 /* Driver model stuff. */ 293 struct device *dev; 294 struct platform_device *pdev; 295 296 /* 297 * True if we allocated the device, false if it came from 298 * someplace else (like PCI). 299 */ 300 bool dev_registered; 301 302 /* Slave address, could be reported from DMI. */ 303 unsigned char slave_addr; 304 305 /* Counters and things for the proc filesystem. */ 306 atomic_t stats[SI_NUM_STATS]; 307 308 struct task_struct *thread; 309 310 struct list_head link; 311 union ipmi_smi_info_union addr_info; 312 }; 313 314 #define smi_inc_stat(smi, stat) \ 315 atomic_inc(&(smi)->stats[SI_STAT_ ## stat]) 316 #define smi_get_stat(smi, stat) \ 317 ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat])) 318 319 #define SI_MAX_PARMS 4 320 321 static int force_kipmid[SI_MAX_PARMS]; 322 static int num_force_kipmid; 323 #ifdef CONFIG_PCI 324 static bool pci_registered; 325 #endif 326 #ifdef CONFIG_PARISC 327 static bool parisc_registered; 328 #endif 329 330 static unsigned int kipmid_max_busy_us[SI_MAX_PARMS]; 331 static int num_max_busy_us; 332 333 static bool unload_when_empty = true; 334 335 static int add_smi(struct smi_info *smi); 336 static int try_smi_init(struct smi_info *smi); 337 static void cleanup_one_si(struct smi_info *to_clean); 338 static void cleanup_ipmi_si(void); 339 340 #ifdef DEBUG_TIMING 341 void debug_timestamp(char *msg) 342 { 343 struct timespec64 t; 344 345 getnstimeofday64(&t); 346 pr_debug("**%s: %lld.%9.9ld\n", msg, (long long) t.tv_sec, t.tv_nsec); 347 } 348 #else 349 #define debug_timestamp(x) 350 #endif 351 352 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list); 353 static int register_xaction_notifier(struct notifier_block *nb) 354 { 355 return atomic_notifier_chain_register(&xaction_notifier_list, nb); 356 } 357 358 static void deliver_recv_msg(struct smi_info *smi_info, 359 struct ipmi_smi_msg *msg) 360 { 361 /* Deliver the message to the upper layer. */ 362 if (smi_info->intf) 363 ipmi_smi_msg_received(smi_info->intf, msg); 364 else 365 ipmi_free_smi_msg(msg); 366 } 367 368 static void return_hosed_msg(struct smi_info *smi_info, int cCode) 369 { 370 struct ipmi_smi_msg *msg = smi_info->curr_msg; 371 372 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED) 373 cCode = IPMI_ERR_UNSPECIFIED; 374 /* else use it as is */ 375 376 /* Make it a response */ 377 msg->rsp[0] = msg->data[0] | 4; 378 msg->rsp[1] = msg->data[1]; 379 msg->rsp[2] = cCode; 380 msg->rsp_size = 3; 381 382 smi_info->curr_msg = NULL; 383 deliver_recv_msg(smi_info, msg); 384 } 385 386 static enum si_sm_result start_next_msg(struct smi_info *smi_info) 387 { 388 int rv; 389 390 if (!smi_info->waiting_msg) { 391 smi_info->curr_msg = NULL; 392 rv = SI_SM_IDLE; 393 } else { 394 int err; 395 396 smi_info->curr_msg = smi_info->waiting_msg; 397 smi_info->waiting_msg = NULL; 398 debug_timestamp("Start2"); 399 err = atomic_notifier_call_chain(&xaction_notifier_list, 400 0, smi_info); 401 if (err & NOTIFY_STOP_MASK) { 402 rv = SI_SM_CALL_WITHOUT_DELAY; 403 goto out; 404 } 405 err = smi_info->handlers->start_transaction( 406 smi_info->si_sm, 407 smi_info->curr_msg->data, 408 smi_info->curr_msg->data_size); 409 if (err) 410 return_hosed_msg(smi_info, err); 411 412 rv = SI_SM_CALL_WITHOUT_DELAY; 413 } 414 out: 415 return rv; 416 } 417 418 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val) 419 { 420 smi_info->last_timeout_jiffies = jiffies; 421 mod_timer(&smi_info->si_timer, new_val); 422 smi_info->timer_running = true; 423 } 424 425 /* 426 * Start a new message and (re)start the timer and thread. 427 */ 428 static void start_new_msg(struct smi_info *smi_info, unsigned char *msg, 429 unsigned int size) 430 { 431 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 432 433 if (smi_info->thread) 434 wake_up_process(smi_info->thread); 435 436 smi_info->handlers->start_transaction(smi_info->si_sm, msg, size); 437 } 438 439 static void start_check_enables(struct smi_info *smi_info, bool start_timer) 440 { 441 unsigned char msg[2]; 442 443 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 444 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 445 446 if (start_timer) 447 start_new_msg(smi_info, msg, 2); 448 else 449 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 450 smi_info->si_state = SI_CHECKING_ENABLES; 451 } 452 453 static void start_clear_flags(struct smi_info *smi_info, bool start_timer) 454 { 455 unsigned char msg[3]; 456 457 /* Make sure the watchdog pre-timeout flag is not set at startup. */ 458 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 459 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD; 460 msg[2] = WDT_PRE_TIMEOUT_INT; 461 462 if (start_timer) 463 start_new_msg(smi_info, msg, 3); 464 else 465 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3); 466 smi_info->si_state = SI_CLEARING_FLAGS; 467 } 468 469 static void start_getting_msg_queue(struct smi_info *smi_info) 470 { 471 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 472 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD; 473 smi_info->curr_msg->data_size = 2; 474 475 start_new_msg(smi_info, smi_info->curr_msg->data, 476 smi_info->curr_msg->data_size); 477 smi_info->si_state = SI_GETTING_MESSAGES; 478 } 479 480 static void start_getting_events(struct smi_info *smi_info) 481 { 482 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 483 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD; 484 smi_info->curr_msg->data_size = 2; 485 486 start_new_msg(smi_info, smi_info->curr_msg->data, 487 smi_info->curr_msg->data_size); 488 smi_info->si_state = SI_GETTING_EVENTS; 489 } 490 491 /* 492 * When we have a situtaion where we run out of memory and cannot 493 * allocate messages, we just leave them in the BMC and run the system 494 * polled until we can allocate some memory. Once we have some 495 * memory, we will re-enable the interrupt. 496 * 497 * Note that we cannot just use disable_irq(), since the interrupt may 498 * be shared. 499 */ 500 static inline bool disable_si_irq(struct smi_info *smi_info, bool start_timer) 501 { 502 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) { 503 smi_info->interrupt_disabled = true; 504 start_check_enables(smi_info, start_timer); 505 return true; 506 } 507 return false; 508 } 509 510 static inline bool enable_si_irq(struct smi_info *smi_info) 511 { 512 if ((smi_info->irq) && (smi_info->interrupt_disabled)) { 513 smi_info->interrupt_disabled = false; 514 start_check_enables(smi_info, true); 515 return true; 516 } 517 return false; 518 } 519 520 /* 521 * Allocate a message. If unable to allocate, start the interrupt 522 * disable process and return NULL. If able to allocate but 523 * interrupts are disabled, free the message and return NULL after 524 * starting the interrupt enable process. 525 */ 526 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info) 527 { 528 struct ipmi_smi_msg *msg; 529 530 msg = ipmi_alloc_smi_msg(); 531 if (!msg) { 532 if (!disable_si_irq(smi_info, true)) 533 smi_info->si_state = SI_NORMAL; 534 } else if (enable_si_irq(smi_info)) { 535 ipmi_free_smi_msg(msg); 536 msg = NULL; 537 } 538 return msg; 539 } 540 541 static void handle_flags(struct smi_info *smi_info) 542 { 543 retry: 544 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) { 545 /* Watchdog pre-timeout */ 546 smi_inc_stat(smi_info, watchdog_pretimeouts); 547 548 start_clear_flags(smi_info, true); 549 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT; 550 if (smi_info->intf) 551 ipmi_smi_watchdog_pretimeout(smi_info->intf); 552 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) { 553 /* Messages available. */ 554 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 555 if (!smi_info->curr_msg) 556 return; 557 558 start_getting_msg_queue(smi_info); 559 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) { 560 /* Events available. */ 561 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 562 if (!smi_info->curr_msg) 563 return; 564 565 start_getting_events(smi_info); 566 } else if (smi_info->msg_flags & OEM_DATA_AVAIL && 567 smi_info->oem_data_avail_handler) { 568 if (smi_info->oem_data_avail_handler(smi_info)) 569 goto retry; 570 } else 571 smi_info->si_state = SI_NORMAL; 572 } 573 574 /* 575 * Global enables we care about. 576 */ 577 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \ 578 IPMI_BMC_EVT_MSG_INTR) 579 580 static u8 current_global_enables(struct smi_info *smi_info, u8 base, 581 bool *irq_on) 582 { 583 u8 enables = 0; 584 585 if (smi_info->supports_event_msg_buff) 586 enables |= IPMI_BMC_EVT_MSG_BUFF; 587 588 if (((smi_info->irq && !smi_info->interrupt_disabled) || 589 smi_info->cannot_disable_irq) && 590 !smi_info->irq_enable_broken) 591 enables |= IPMI_BMC_RCV_MSG_INTR; 592 593 if (smi_info->supports_event_msg_buff && 594 smi_info->irq && !smi_info->interrupt_disabled && 595 !smi_info->irq_enable_broken) 596 enables |= IPMI_BMC_EVT_MSG_INTR; 597 598 *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR); 599 600 return enables; 601 } 602 603 static void check_bt_irq(struct smi_info *smi_info, bool irq_on) 604 { 605 u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG); 606 607 irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT; 608 609 if ((bool)irqstate == irq_on) 610 return; 611 612 if (irq_on) 613 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 614 IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 615 else 616 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0); 617 } 618 619 static void handle_transaction_done(struct smi_info *smi_info) 620 { 621 struct ipmi_smi_msg *msg; 622 623 debug_timestamp("Done"); 624 switch (smi_info->si_state) { 625 case SI_NORMAL: 626 if (!smi_info->curr_msg) 627 break; 628 629 smi_info->curr_msg->rsp_size 630 = smi_info->handlers->get_result( 631 smi_info->si_sm, 632 smi_info->curr_msg->rsp, 633 IPMI_MAX_MSG_LENGTH); 634 635 /* 636 * Do this here becase deliver_recv_msg() releases the 637 * lock, and a new message can be put in during the 638 * time the lock is released. 639 */ 640 msg = smi_info->curr_msg; 641 smi_info->curr_msg = NULL; 642 deliver_recv_msg(smi_info, msg); 643 break; 644 645 case SI_GETTING_FLAGS: 646 { 647 unsigned char msg[4]; 648 unsigned int len; 649 650 /* We got the flags from the SMI, now handle them. */ 651 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 652 if (msg[2] != 0) { 653 /* Error fetching flags, just give up for now. */ 654 smi_info->si_state = SI_NORMAL; 655 } else if (len < 4) { 656 /* 657 * Hmm, no flags. That's technically illegal, but 658 * don't use uninitialized data. 659 */ 660 smi_info->si_state = SI_NORMAL; 661 } else { 662 smi_info->msg_flags = msg[3]; 663 handle_flags(smi_info); 664 } 665 break; 666 } 667 668 case SI_CLEARING_FLAGS: 669 { 670 unsigned char msg[3]; 671 672 /* We cleared the flags. */ 673 smi_info->handlers->get_result(smi_info->si_sm, msg, 3); 674 if (msg[2] != 0) { 675 /* Error clearing flags */ 676 dev_warn(smi_info->dev, 677 "Error clearing flags: %2.2x\n", msg[2]); 678 } 679 smi_info->si_state = SI_NORMAL; 680 break; 681 } 682 683 case SI_GETTING_EVENTS: 684 { 685 smi_info->curr_msg->rsp_size 686 = smi_info->handlers->get_result( 687 smi_info->si_sm, 688 smi_info->curr_msg->rsp, 689 IPMI_MAX_MSG_LENGTH); 690 691 /* 692 * Do this here becase deliver_recv_msg() releases the 693 * lock, and a new message can be put in during the 694 * time the lock is released. 695 */ 696 msg = smi_info->curr_msg; 697 smi_info->curr_msg = NULL; 698 if (msg->rsp[2] != 0) { 699 /* Error getting event, probably done. */ 700 msg->done(msg); 701 702 /* Take off the event flag. */ 703 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL; 704 handle_flags(smi_info); 705 } else { 706 smi_inc_stat(smi_info, events); 707 708 /* 709 * Do this before we deliver the message 710 * because delivering the message releases the 711 * lock and something else can mess with the 712 * state. 713 */ 714 handle_flags(smi_info); 715 716 deliver_recv_msg(smi_info, msg); 717 } 718 break; 719 } 720 721 case SI_GETTING_MESSAGES: 722 { 723 smi_info->curr_msg->rsp_size 724 = smi_info->handlers->get_result( 725 smi_info->si_sm, 726 smi_info->curr_msg->rsp, 727 IPMI_MAX_MSG_LENGTH); 728 729 /* 730 * Do this here becase deliver_recv_msg() releases the 731 * lock, and a new message can be put in during the 732 * time the lock is released. 733 */ 734 msg = smi_info->curr_msg; 735 smi_info->curr_msg = NULL; 736 if (msg->rsp[2] != 0) { 737 /* Error getting event, probably done. */ 738 msg->done(msg); 739 740 /* Take off the msg flag. */ 741 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL; 742 handle_flags(smi_info); 743 } else { 744 smi_inc_stat(smi_info, incoming_messages); 745 746 /* 747 * Do this before we deliver the message 748 * because delivering the message releases the 749 * lock and something else can mess with the 750 * state. 751 */ 752 handle_flags(smi_info); 753 754 deliver_recv_msg(smi_info, msg); 755 } 756 break; 757 } 758 759 case SI_CHECKING_ENABLES: 760 { 761 unsigned char msg[4]; 762 u8 enables; 763 bool irq_on; 764 765 /* We got the flags from the SMI, now handle them. */ 766 smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 767 if (msg[2] != 0) { 768 dev_warn(smi_info->dev, 769 "Couldn't get irq info: %x.\n", msg[2]); 770 dev_warn(smi_info->dev, 771 "Maybe ok, but ipmi might run very slowly.\n"); 772 smi_info->si_state = SI_NORMAL; 773 break; 774 } 775 enables = current_global_enables(smi_info, 0, &irq_on); 776 if (smi_info->si_type == SI_BT) 777 /* BT has its own interrupt enable bit. */ 778 check_bt_irq(smi_info, irq_on); 779 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) { 780 /* Enables are not correct, fix them. */ 781 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 782 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 783 msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK); 784 smi_info->handlers->start_transaction( 785 smi_info->si_sm, msg, 3); 786 smi_info->si_state = SI_SETTING_ENABLES; 787 } else if (smi_info->supports_event_msg_buff) { 788 smi_info->curr_msg = ipmi_alloc_smi_msg(); 789 if (!smi_info->curr_msg) { 790 smi_info->si_state = SI_NORMAL; 791 break; 792 } 793 start_getting_events(smi_info); 794 } else { 795 smi_info->si_state = SI_NORMAL; 796 } 797 break; 798 } 799 800 case SI_SETTING_ENABLES: 801 { 802 unsigned char msg[4]; 803 804 smi_info->handlers->get_result(smi_info->si_sm, msg, 4); 805 if (msg[2] != 0) 806 dev_warn(smi_info->dev, 807 "Could not set the global enables: 0x%x.\n", 808 msg[2]); 809 810 if (smi_info->supports_event_msg_buff) { 811 smi_info->curr_msg = ipmi_alloc_smi_msg(); 812 if (!smi_info->curr_msg) { 813 smi_info->si_state = SI_NORMAL; 814 break; 815 } 816 start_getting_events(smi_info); 817 } else { 818 smi_info->si_state = SI_NORMAL; 819 } 820 break; 821 } 822 } 823 } 824 825 /* 826 * Called on timeouts and events. Timeouts should pass the elapsed 827 * time, interrupts should pass in zero. Must be called with 828 * si_lock held and interrupts disabled. 829 */ 830 static enum si_sm_result smi_event_handler(struct smi_info *smi_info, 831 int time) 832 { 833 enum si_sm_result si_sm_result; 834 835 restart: 836 /* 837 * There used to be a loop here that waited a little while 838 * (around 25us) before giving up. That turned out to be 839 * pointless, the minimum delays I was seeing were in the 300us 840 * range, which is far too long to wait in an interrupt. So 841 * we just run until the state machine tells us something 842 * happened or it needs a delay. 843 */ 844 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time); 845 time = 0; 846 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY) 847 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0); 848 849 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) { 850 smi_inc_stat(smi_info, complete_transactions); 851 852 handle_transaction_done(smi_info); 853 goto restart; 854 } else if (si_sm_result == SI_SM_HOSED) { 855 smi_inc_stat(smi_info, hosed_count); 856 857 /* 858 * Do the before return_hosed_msg, because that 859 * releases the lock. 860 */ 861 smi_info->si_state = SI_NORMAL; 862 if (smi_info->curr_msg != NULL) { 863 /* 864 * If we were handling a user message, format 865 * a response to send to the upper layer to 866 * tell it about the error. 867 */ 868 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED); 869 } 870 goto restart; 871 } 872 873 /* 874 * We prefer handling attn over new messages. But don't do 875 * this if there is not yet an upper layer to handle anything. 876 */ 877 if (likely(smi_info->intf) && 878 (si_sm_result == SI_SM_ATTN || smi_info->got_attn)) { 879 unsigned char msg[2]; 880 881 if (smi_info->si_state != SI_NORMAL) { 882 /* 883 * We got an ATTN, but we are doing something else. 884 * Handle the ATTN later. 885 */ 886 smi_info->got_attn = true; 887 } else { 888 smi_info->got_attn = false; 889 smi_inc_stat(smi_info, attentions); 890 891 /* 892 * Got a attn, send down a get message flags to see 893 * what's causing it. It would be better to handle 894 * this in the upper layer, but due to the way 895 * interrupts work with the SMI, that's not really 896 * possible. 897 */ 898 msg[0] = (IPMI_NETFN_APP_REQUEST << 2); 899 msg[1] = IPMI_GET_MSG_FLAGS_CMD; 900 901 start_new_msg(smi_info, msg, 2); 902 smi_info->si_state = SI_GETTING_FLAGS; 903 goto restart; 904 } 905 } 906 907 /* If we are currently idle, try to start the next message. */ 908 if (si_sm_result == SI_SM_IDLE) { 909 smi_inc_stat(smi_info, idles); 910 911 si_sm_result = start_next_msg(smi_info); 912 if (si_sm_result != SI_SM_IDLE) 913 goto restart; 914 } 915 916 if ((si_sm_result == SI_SM_IDLE) 917 && (atomic_read(&smi_info->req_events))) { 918 /* 919 * We are idle and the upper layer requested that I fetch 920 * events, so do so. 921 */ 922 atomic_set(&smi_info->req_events, 0); 923 924 /* 925 * Take this opportunity to check the interrupt and 926 * message enable state for the BMC. The BMC can be 927 * asynchronously reset, and may thus get interrupts 928 * disable and messages disabled. 929 */ 930 if (smi_info->supports_event_msg_buff || smi_info->irq) { 931 start_check_enables(smi_info, true); 932 } else { 933 smi_info->curr_msg = alloc_msg_handle_irq(smi_info); 934 if (!smi_info->curr_msg) 935 goto out; 936 937 start_getting_events(smi_info); 938 } 939 goto restart; 940 } 941 942 if (si_sm_result == SI_SM_IDLE && smi_info->timer_running) { 943 /* Ok it if fails, the timer will just go off. */ 944 if (del_timer(&smi_info->si_timer)) 945 smi_info->timer_running = false; 946 } 947 948 out: 949 return si_sm_result; 950 } 951 952 static void check_start_timer_thread(struct smi_info *smi_info) 953 { 954 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) { 955 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 956 957 if (smi_info->thread) 958 wake_up_process(smi_info->thread); 959 960 start_next_msg(smi_info); 961 smi_event_handler(smi_info, 0); 962 } 963 } 964 965 static void flush_messages(void *send_info) 966 { 967 struct smi_info *smi_info = send_info; 968 enum si_sm_result result; 969 970 /* 971 * Currently, this function is called only in run-to-completion 972 * mode. This means we are single-threaded, no need for locks. 973 */ 974 result = smi_event_handler(smi_info, 0); 975 while (result != SI_SM_IDLE) { 976 udelay(SI_SHORT_TIMEOUT_USEC); 977 result = smi_event_handler(smi_info, SI_SHORT_TIMEOUT_USEC); 978 } 979 } 980 981 static void sender(void *send_info, 982 struct ipmi_smi_msg *msg) 983 { 984 struct smi_info *smi_info = send_info; 985 unsigned long flags; 986 987 debug_timestamp("Enqueue"); 988 989 if (smi_info->run_to_completion) { 990 /* 991 * If we are running to completion, start it. Upper 992 * layer will call flush_messages to clear it out. 993 */ 994 smi_info->waiting_msg = msg; 995 return; 996 } 997 998 spin_lock_irqsave(&smi_info->si_lock, flags); 999 /* 1000 * The following two lines don't need to be under the lock for 1001 * the lock's sake, but they do need SMP memory barriers to 1002 * avoid getting things out of order. We are already claiming 1003 * the lock, anyway, so just do it under the lock to avoid the 1004 * ordering problem. 1005 */ 1006 BUG_ON(smi_info->waiting_msg); 1007 smi_info->waiting_msg = msg; 1008 check_start_timer_thread(smi_info); 1009 spin_unlock_irqrestore(&smi_info->si_lock, flags); 1010 } 1011 1012 static void set_run_to_completion(void *send_info, bool i_run_to_completion) 1013 { 1014 struct smi_info *smi_info = send_info; 1015 1016 smi_info->run_to_completion = i_run_to_completion; 1017 if (i_run_to_completion) 1018 flush_messages(smi_info); 1019 } 1020 1021 /* 1022 * Use -1 in the nsec value of the busy waiting timespec to tell that 1023 * we are spinning in kipmid looking for something and not delaying 1024 * between checks 1025 */ 1026 static inline void ipmi_si_set_not_busy(struct timespec64 *ts) 1027 { 1028 ts->tv_nsec = -1; 1029 } 1030 static inline int ipmi_si_is_busy(struct timespec64 *ts) 1031 { 1032 return ts->tv_nsec != -1; 1033 } 1034 1035 static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result, 1036 const struct smi_info *smi_info, 1037 struct timespec64 *busy_until) 1038 { 1039 unsigned int max_busy_us = 0; 1040 1041 if (smi_info->intf_num < num_max_busy_us) 1042 max_busy_us = kipmid_max_busy_us[smi_info->intf_num]; 1043 if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY) 1044 ipmi_si_set_not_busy(busy_until); 1045 else if (!ipmi_si_is_busy(busy_until)) { 1046 getnstimeofday64(busy_until); 1047 timespec64_add_ns(busy_until, max_busy_us*NSEC_PER_USEC); 1048 } else { 1049 struct timespec64 now; 1050 1051 getnstimeofday64(&now); 1052 if (unlikely(timespec64_compare(&now, busy_until) > 0)) { 1053 ipmi_si_set_not_busy(busy_until); 1054 return 0; 1055 } 1056 } 1057 return 1; 1058 } 1059 1060 1061 /* 1062 * A busy-waiting loop for speeding up IPMI operation. 1063 * 1064 * Lousy hardware makes this hard. This is only enabled for systems 1065 * that are not BT and do not have interrupts. It starts spinning 1066 * when an operation is complete or until max_busy tells it to stop 1067 * (if that is enabled). See the paragraph on kimid_max_busy_us in 1068 * Documentation/IPMI.txt for details. 1069 */ 1070 static int ipmi_thread(void *data) 1071 { 1072 struct smi_info *smi_info = data; 1073 unsigned long flags; 1074 enum si_sm_result smi_result; 1075 struct timespec64 busy_until; 1076 1077 ipmi_si_set_not_busy(&busy_until); 1078 set_user_nice(current, MAX_NICE); 1079 while (!kthread_should_stop()) { 1080 int busy_wait; 1081 1082 spin_lock_irqsave(&(smi_info->si_lock), flags); 1083 smi_result = smi_event_handler(smi_info, 0); 1084 1085 /* 1086 * If the driver is doing something, there is a possible 1087 * race with the timer. If the timer handler see idle, 1088 * and the thread here sees something else, the timer 1089 * handler won't restart the timer even though it is 1090 * required. So start it here if necessary. 1091 */ 1092 if (smi_result != SI_SM_IDLE && !smi_info->timer_running) 1093 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES); 1094 1095 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1096 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info, 1097 &busy_until); 1098 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) 1099 ; /* do nothing */ 1100 else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait) 1101 schedule(); 1102 else if (smi_result == SI_SM_IDLE) { 1103 if (atomic_read(&smi_info->need_watch)) { 1104 schedule_timeout_interruptible(100); 1105 } else { 1106 /* Wait to be woken up when we are needed. */ 1107 __set_current_state(TASK_INTERRUPTIBLE); 1108 schedule(); 1109 } 1110 } else 1111 schedule_timeout_interruptible(1); 1112 } 1113 return 0; 1114 } 1115 1116 1117 static void poll(void *send_info) 1118 { 1119 struct smi_info *smi_info = send_info; 1120 unsigned long flags = 0; 1121 bool run_to_completion = smi_info->run_to_completion; 1122 1123 /* 1124 * Make sure there is some delay in the poll loop so we can 1125 * drive time forward and timeout things. 1126 */ 1127 udelay(10); 1128 if (!run_to_completion) 1129 spin_lock_irqsave(&smi_info->si_lock, flags); 1130 smi_event_handler(smi_info, 10); 1131 if (!run_to_completion) 1132 spin_unlock_irqrestore(&smi_info->si_lock, flags); 1133 } 1134 1135 static void request_events(void *send_info) 1136 { 1137 struct smi_info *smi_info = send_info; 1138 1139 if (!smi_info->has_event_buffer) 1140 return; 1141 1142 atomic_set(&smi_info->req_events, 1); 1143 } 1144 1145 static void set_need_watch(void *send_info, bool enable) 1146 { 1147 struct smi_info *smi_info = send_info; 1148 unsigned long flags; 1149 1150 atomic_set(&smi_info->need_watch, enable); 1151 spin_lock_irqsave(&smi_info->si_lock, flags); 1152 check_start_timer_thread(smi_info); 1153 spin_unlock_irqrestore(&smi_info->si_lock, flags); 1154 } 1155 1156 static int initialized; 1157 1158 static void smi_timeout(unsigned long data) 1159 { 1160 struct smi_info *smi_info = (struct smi_info *) data; 1161 enum si_sm_result smi_result; 1162 unsigned long flags; 1163 unsigned long jiffies_now; 1164 long time_diff; 1165 long timeout; 1166 1167 spin_lock_irqsave(&(smi_info->si_lock), flags); 1168 debug_timestamp("Timer"); 1169 1170 jiffies_now = jiffies; 1171 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies) 1172 * SI_USEC_PER_JIFFY); 1173 smi_result = smi_event_handler(smi_info, time_diff); 1174 1175 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) { 1176 /* Running with interrupts, only do long timeouts. */ 1177 timeout = jiffies + SI_TIMEOUT_JIFFIES; 1178 smi_inc_stat(smi_info, long_timeouts); 1179 goto do_mod_timer; 1180 } 1181 1182 /* 1183 * If the state machine asks for a short delay, then shorten 1184 * the timer timeout. 1185 */ 1186 if (smi_result == SI_SM_CALL_WITH_DELAY) { 1187 smi_inc_stat(smi_info, short_timeouts); 1188 timeout = jiffies + 1; 1189 } else { 1190 smi_inc_stat(smi_info, long_timeouts); 1191 timeout = jiffies + SI_TIMEOUT_JIFFIES; 1192 } 1193 1194 do_mod_timer: 1195 if (smi_result != SI_SM_IDLE) 1196 smi_mod_timer(smi_info, timeout); 1197 else 1198 smi_info->timer_running = false; 1199 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1200 } 1201 1202 static irqreturn_t si_irq_handler(int irq, void *data) 1203 { 1204 struct smi_info *smi_info = data; 1205 unsigned long flags; 1206 1207 spin_lock_irqsave(&(smi_info->si_lock), flags); 1208 1209 smi_inc_stat(smi_info, interrupts); 1210 1211 debug_timestamp("Interrupt"); 1212 1213 smi_event_handler(smi_info, 0); 1214 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 1215 return IRQ_HANDLED; 1216 } 1217 1218 static irqreturn_t si_bt_irq_handler(int irq, void *data) 1219 { 1220 struct smi_info *smi_info = data; 1221 /* We need to clear the IRQ flag for the BT interface. */ 1222 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 1223 IPMI_BT_INTMASK_CLEAR_IRQ_BIT 1224 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 1225 return si_irq_handler(irq, data); 1226 } 1227 1228 static int smi_start_processing(void *send_info, 1229 ipmi_smi_t intf) 1230 { 1231 struct smi_info *new_smi = send_info; 1232 int enable = 0; 1233 1234 new_smi->intf = intf; 1235 1236 /* Set up the timer that drives the interface. */ 1237 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi); 1238 smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES); 1239 1240 /* Try to claim any interrupts. */ 1241 if (new_smi->irq_setup) 1242 new_smi->irq_setup(new_smi); 1243 1244 /* 1245 * Check if the user forcefully enabled the daemon. 1246 */ 1247 if (new_smi->intf_num < num_force_kipmid) 1248 enable = force_kipmid[new_smi->intf_num]; 1249 /* 1250 * The BT interface is efficient enough to not need a thread, 1251 * and there is no need for a thread if we have interrupts. 1252 */ 1253 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq)) 1254 enable = 1; 1255 1256 if (enable) { 1257 new_smi->thread = kthread_run(ipmi_thread, new_smi, 1258 "kipmi%d", new_smi->intf_num); 1259 if (IS_ERR(new_smi->thread)) { 1260 dev_notice(new_smi->dev, "Could not start" 1261 " kernel thread due to error %ld, only using" 1262 " timers to drive the interface\n", 1263 PTR_ERR(new_smi->thread)); 1264 new_smi->thread = NULL; 1265 } 1266 } 1267 1268 return 0; 1269 } 1270 1271 static int get_smi_info(void *send_info, struct ipmi_smi_info *data) 1272 { 1273 struct smi_info *smi = send_info; 1274 1275 data->addr_src = smi->addr_source; 1276 data->dev = smi->dev; 1277 data->addr_info = smi->addr_info; 1278 get_device(smi->dev); 1279 1280 return 0; 1281 } 1282 1283 static void set_maintenance_mode(void *send_info, bool enable) 1284 { 1285 struct smi_info *smi_info = send_info; 1286 1287 if (!enable) 1288 atomic_set(&smi_info->req_events, 0); 1289 } 1290 1291 static const struct ipmi_smi_handlers handlers = { 1292 .owner = THIS_MODULE, 1293 .start_processing = smi_start_processing, 1294 .get_smi_info = get_smi_info, 1295 .sender = sender, 1296 .request_events = request_events, 1297 .set_need_watch = set_need_watch, 1298 .set_maintenance_mode = set_maintenance_mode, 1299 .set_run_to_completion = set_run_to_completion, 1300 .flush_messages = flush_messages, 1301 .poll = poll, 1302 }; 1303 1304 /* 1305 * There can be 4 IO ports passed in (with or without IRQs), 4 addresses, 1306 * a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS. 1307 */ 1308 1309 static LIST_HEAD(smi_infos); 1310 static DEFINE_MUTEX(smi_infos_lock); 1311 static int smi_num; /* Used to sequence the SMIs */ 1312 1313 #define DEFAULT_REGSPACING 1 1314 #define DEFAULT_REGSIZE 1 1315 1316 #ifdef CONFIG_ACPI 1317 static bool si_tryacpi = true; 1318 #endif 1319 #ifdef CONFIG_DMI 1320 static bool si_trydmi = true; 1321 #endif 1322 static bool si_tryplatform = true; 1323 #ifdef CONFIG_PCI 1324 static bool si_trypci = true; 1325 #endif 1326 static char *si_type[SI_MAX_PARMS]; 1327 #define MAX_SI_TYPE_STR 30 1328 static char si_type_str[MAX_SI_TYPE_STR]; 1329 static unsigned long addrs[SI_MAX_PARMS]; 1330 static unsigned int num_addrs; 1331 static unsigned int ports[SI_MAX_PARMS]; 1332 static unsigned int num_ports; 1333 static int irqs[SI_MAX_PARMS]; 1334 static unsigned int num_irqs; 1335 static int regspacings[SI_MAX_PARMS]; 1336 static unsigned int num_regspacings; 1337 static int regsizes[SI_MAX_PARMS]; 1338 static unsigned int num_regsizes; 1339 static int regshifts[SI_MAX_PARMS]; 1340 static unsigned int num_regshifts; 1341 static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */ 1342 static unsigned int num_slave_addrs; 1343 1344 #define IPMI_IO_ADDR_SPACE 0 1345 #define IPMI_MEM_ADDR_SPACE 1 1346 static const char * const addr_space_to_str[] = { "i/o", "mem" }; 1347 1348 static int hotmod_handler(const char *val, struct kernel_param *kp); 1349 1350 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200); 1351 MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See" 1352 " Documentation/IPMI.txt in the kernel sources for the" 1353 " gory details."); 1354 1355 #ifdef CONFIG_ACPI 1356 module_param_named(tryacpi, si_tryacpi, bool, 0); 1357 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the" 1358 " default scan of the interfaces identified via ACPI"); 1359 #endif 1360 #ifdef CONFIG_DMI 1361 module_param_named(trydmi, si_trydmi, bool, 0); 1362 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the" 1363 " default scan of the interfaces identified via DMI"); 1364 #endif 1365 module_param_named(tryplatform, si_tryplatform, bool, 0); 1366 MODULE_PARM_DESC(tryplatform, "Setting this to zero will disable the" 1367 " default scan of the interfaces identified via platform" 1368 " interfaces like openfirmware"); 1369 #ifdef CONFIG_PCI 1370 module_param_named(trypci, si_trypci, bool, 0); 1371 MODULE_PARM_DESC(trypci, "Setting this to zero will disable the" 1372 " default scan of the interfaces identified via pci"); 1373 #endif 1374 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0); 1375 MODULE_PARM_DESC(type, "Defines the type of each interface, each" 1376 " interface separated by commas. The types are 'kcs'," 1377 " 'smic', and 'bt'. For example si_type=kcs,bt will set" 1378 " the first interface to kcs and the second to bt"); 1379 module_param_hw_array(addrs, ulong, iomem, &num_addrs, 0); 1380 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the" 1381 " addresses separated by commas. Only use if an interface" 1382 " is in memory. Otherwise, set it to zero or leave" 1383 " it blank."); 1384 module_param_hw_array(ports, uint, ioport, &num_ports, 0); 1385 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the" 1386 " addresses separated by commas. Only use if an interface" 1387 " is a port. Otherwise, set it to zero or leave" 1388 " it blank."); 1389 module_param_hw_array(irqs, int, irq, &num_irqs, 0); 1390 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the" 1391 " addresses separated by commas. Only use if an interface" 1392 " has an interrupt. Otherwise, set it to zero or leave" 1393 " it blank."); 1394 module_param_hw_array(regspacings, int, other, &num_regspacings, 0); 1395 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address" 1396 " and each successive register used by the interface. For" 1397 " instance, if the start address is 0xca2 and the spacing" 1398 " is 2, then the second address is at 0xca4. Defaults" 1399 " to 1."); 1400 module_param_hw_array(regsizes, int, other, &num_regsizes, 0); 1401 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes." 1402 " This should generally be 1, 2, 4, or 8 for an 8-bit," 1403 " 16-bit, 32-bit, or 64-bit register. Use this if you" 1404 " the 8-bit IPMI register has to be read from a larger" 1405 " register."); 1406 module_param_hw_array(regshifts, int, other, &num_regshifts, 0); 1407 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the." 1408 " IPMI register, in bits. For instance, if the data" 1409 " is read from a 32-bit word and the IPMI data is in" 1410 " bit 8-15, then the shift would be 8"); 1411 module_param_hw_array(slave_addrs, int, other, &num_slave_addrs, 0); 1412 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for" 1413 " the controller. Normally this is 0x20, but can be" 1414 " overridden by this parm. This is an array indexed" 1415 " by interface number."); 1416 module_param_array(force_kipmid, int, &num_force_kipmid, 0); 1417 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or" 1418 " disabled(0). Normally the IPMI driver auto-detects" 1419 " this, but the value may be overridden by this parm."); 1420 module_param(unload_when_empty, bool, 0); 1421 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are" 1422 " specified or found, default is 1. Setting to 0" 1423 " is useful for hot add of devices using hotmod."); 1424 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644); 1425 MODULE_PARM_DESC(kipmid_max_busy_us, 1426 "Max time (in microseconds) to busy-wait for IPMI data before" 1427 " sleeping. 0 (default) means to wait forever. Set to 100-500" 1428 " if kipmid is using up a lot of CPU time."); 1429 1430 1431 static void std_irq_cleanup(struct smi_info *info) 1432 { 1433 if (info->si_type == SI_BT) 1434 /* Disable the interrupt in the BT interface. */ 1435 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0); 1436 free_irq(info->irq, info); 1437 } 1438 1439 static int std_irq_setup(struct smi_info *info) 1440 { 1441 int rv; 1442 1443 if (!info->irq) 1444 return 0; 1445 1446 if (info->si_type == SI_BT) { 1447 rv = request_irq(info->irq, 1448 si_bt_irq_handler, 1449 IRQF_SHARED, 1450 DEVICE_NAME, 1451 info); 1452 if (!rv) 1453 /* Enable the interrupt in the BT interface. */ 1454 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 1455 IPMI_BT_INTMASK_ENABLE_IRQ_BIT); 1456 } else 1457 rv = request_irq(info->irq, 1458 si_irq_handler, 1459 IRQF_SHARED, 1460 DEVICE_NAME, 1461 info); 1462 if (rv) { 1463 dev_warn(info->dev, "%s unable to claim interrupt %d," 1464 " running polled\n", 1465 DEVICE_NAME, info->irq); 1466 info->irq = 0; 1467 } else { 1468 info->irq_cleanup = std_irq_cleanup; 1469 dev_info(info->dev, "Using irq %d\n", info->irq); 1470 } 1471 1472 return rv; 1473 } 1474 1475 static unsigned char port_inb(const struct si_sm_io *io, unsigned int offset) 1476 { 1477 unsigned int addr = io->addr_data; 1478 1479 return inb(addr + (offset * io->regspacing)); 1480 } 1481 1482 static void port_outb(const struct si_sm_io *io, unsigned int offset, 1483 unsigned char b) 1484 { 1485 unsigned int addr = io->addr_data; 1486 1487 outb(b, addr + (offset * io->regspacing)); 1488 } 1489 1490 static unsigned char port_inw(const struct si_sm_io *io, unsigned int offset) 1491 { 1492 unsigned int addr = io->addr_data; 1493 1494 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff; 1495 } 1496 1497 static void port_outw(const struct si_sm_io *io, unsigned int offset, 1498 unsigned char b) 1499 { 1500 unsigned int addr = io->addr_data; 1501 1502 outw(b << io->regshift, addr + (offset * io->regspacing)); 1503 } 1504 1505 static unsigned char port_inl(const struct si_sm_io *io, unsigned int offset) 1506 { 1507 unsigned int addr = io->addr_data; 1508 1509 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff; 1510 } 1511 1512 static void port_outl(const struct si_sm_io *io, unsigned int offset, 1513 unsigned char b) 1514 { 1515 unsigned int addr = io->addr_data; 1516 1517 outl(b << io->regshift, addr+(offset * io->regspacing)); 1518 } 1519 1520 static void port_cleanup(struct smi_info *info) 1521 { 1522 unsigned int addr = info->io.addr_data; 1523 int idx; 1524 1525 if (addr) { 1526 for (idx = 0; idx < info->io_size; idx++) 1527 release_region(addr + idx * info->io.regspacing, 1528 info->io.regsize); 1529 } 1530 } 1531 1532 static int port_setup(struct smi_info *info) 1533 { 1534 unsigned int addr = info->io.addr_data; 1535 int idx; 1536 1537 if (!addr) 1538 return -ENODEV; 1539 1540 info->io_cleanup = port_cleanup; 1541 1542 /* 1543 * Figure out the actual inb/inw/inl/etc routine to use based 1544 * upon the register size. 1545 */ 1546 switch (info->io.regsize) { 1547 case 1: 1548 info->io.inputb = port_inb; 1549 info->io.outputb = port_outb; 1550 break; 1551 case 2: 1552 info->io.inputb = port_inw; 1553 info->io.outputb = port_outw; 1554 break; 1555 case 4: 1556 info->io.inputb = port_inl; 1557 info->io.outputb = port_outl; 1558 break; 1559 default: 1560 dev_warn(info->dev, "Invalid register size: %d\n", 1561 info->io.regsize); 1562 return -EINVAL; 1563 } 1564 1565 /* 1566 * Some BIOSes reserve disjoint I/O regions in their ACPI 1567 * tables. This causes problems when trying to register the 1568 * entire I/O region. Therefore we must register each I/O 1569 * port separately. 1570 */ 1571 for (idx = 0; idx < info->io_size; idx++) { 1572 if (request_region(addr + idx * info->io.regspacing, 1573 info->io.regsize, DEVICE_NAME) == NULL) { 1574 /* Undo allocations */ 1575 while (idx--) 1576 release_region(addr + idx * info->io.regspacing, 1577 info->io.regsize); 1578 return -EIO; 1579 } 1580 } 1581 return 0; 1582 } 1583 1584 static unsigned char intf_mem_inb(const struct si_sm_io *io, 1585 unsigned int offset) 1586 { 1587 return readb((io->addr)+(offset * io->regspacing)); 1588 } 1589 1590 static void intf_mem_outb(const struct si_sm_io *io, unsigned int offset, 1591 unsigned char b) 1592 { 1593 writeb(b, (io->addr)+(offset * io->regspacing)); 1594 } 1595 1596 static unsigned char intf_mem_inw(const struct si_sm_io *io, 1597 unsigned int offset) 1598 { 1599 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift) 1600 & 0xff; 1601 } 1602 1603 static void intf_mem_outw(const struct si_sm_io *io, unsigned int offset, 1604 unsigned char b) 1605 { 1606 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing)); 1607 } 1608 1609 static unsigned char intf_mem_inl(const struct si_sm_io *io, 1610 unsigned int offset) 1611 { 1612 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift) 1613 & 0xff; 1614 } 1615 1616 static void intf_mem_outl(const struct si_sm_io *io, unsigned int offset, 1617 unsigned char b) 1618 { 1619 writel(b << io->regshift, (io->addr)+(offset * io->regspacing)); 1620 } 1621 1622 #ifdef readq 1623 static unsigned char mem_inq(const struct si_sm_io *io, unsigned int offset) 1624 { 1625 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift) 1626 & 0xff; 1627 } 1628 1629 static void mem_outq(const struct si_sm_io *io, unsigned int offset, 1630 unsigned char b) 1631 { 1632 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing)); 1633 } 1634 #endif 1635 1636 static void mem_region_cleanup(struct smi_info *info, int num) 1637 { 1638 unsigned long addr = info->io.addr_data; 1639 int idx; 1640 1641 for (idx = 0; idx < num; idx++) 1642 release_mem_region(addr + idx * info->io.regspacing, 1643 info->io.regsize); 1644 } 1645 1646 static void mem_cleanup(struct smi_info *info) 1647 { 1648 if (info->io.addr) { 1649 iounmap(info->io.addr); 1650 mem_region_cleanup(info, info->io_size); 1651 } 1652 } 1653 1654 static int mem_setup(struct smi_info *info) 1655 { 1656 unsigned long addr = info->io.addr_data; 1657 int mapsize, idx; 1658 1659 if (!addr) 1660 return -ENODEV; 1661 1662 info->io_cleanup = mem_cleanup; 1663 1664 /* 1665 * Figure out the actual readb/readw/readl/etc routine to use based 1666 * upon the register size. 1667 */ 1668 switch (info->io.regsize) { 1669 case 1: 1670 info->io.inputb = intf_mem_inb; 1671 info->io.outputb = intf_mem_outb; 1672 break; 1673 case 2: 1674 info->io.inputb = intf_mem_inw; 1675 info->io.outputb = intf_mem_outw; 1676 break; 1677 case 4: 1678 info->io.inputb = intf_mem_inl; 1679 info->io.outputb = intf_mem_outl; 1680 break; 1681 #ifdef readq 1682 case 8: 1683 info->io.inputb = mem_inq; 1684 info->io.outputb = mem_outq; 1685 break; 1686 #endif 1687 default: 1688 dev_warn(info->dev, "Invalid register size: %d\n", 1689 info->io.regsize); 1690 return -EINVAL; 1691 } 1692 1693 /* 1694 * Some BIOSes reserve disjoint memory regions in their ACPI 1695 * tables. This causes problems when trying to request the 1696 * entire region. Therefore we must request each register 1697 * separately. 1698 */ 1699 for (idx = 0; idx < info->io_size; idx++) { 1700 if (request_mem_region(addr + idx * info->io.regspacing, 1701 info->io.regsize, DEVICE_NAME) == NULL) { 1702 /* Undo allocations */ 1703 mem_region_cleanup(info, idx); 1704 return -EIO; 1705 } 1706 } 1707 1708 /* 1709 * Calculate the total amount of memory to claim. This is an 1710 * unusual looking calculation, but it avoids claiming any 1711 * more memory than it has to. It will claim everything 1712 * between the first address to the end of the last full 1713 * register. 1714 */ 1715 mapsize = ((info->io_size * info->io.regspacing) 1716 - (info->io.regspacing - info->io.regsize)); 1717 info->io.addr = ioremap(addr, mapsize); 1718 if (info->io.addr == NULL) { 1719 mem_region_cleanup(info, info->io_size); 1720 return -EIO; 1721 } 1722 return 0; 1723 } 1724 1725 /* 1726 * Parms come in as <op1>[:op2[:op3...]]. ops are: 1727 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]] 1728 * Options are: 1729 * rsp=<regspacing> 1730 * rsi=<regsize> 1731 * rsh=<regshift> 1732 * irq=<irq> 1733 * ipmb=<ipmb addr> 1734 */ 1735 enum hotmod_op { HM_ADD, HM_REMOVE }; 1736 struct hotmod_vals { 1737 const char *name; 1738 const int val; 1739 }; 1740 1741 static const struct hotmod_vals hotmod_ops[] = { 1742 { "add", HM_ADD }, 1743 { "remove", HM_REMOVE }, 1744 { NULL } 1745 }; 1746 1747 static const struct hotmod_vals hotmod_si[] = { 1748 { "kcs", SI_KCS }, 1749 { "smic", SI_SMIC }, 1750 { "bt", SI_BT }, 1751 { NULL } 1752 }; 1753 1754 static const struct hotmod_vals hotmod_as[] = { 1755 { "mem", IPMI_MEM_ADDR_SPACE }, 1756 { "i/o", IPMI_IO_ADDR_SPACE }, 1757 { NULL } 1758 }; 1759 1760 static int parse_str(const struct hotmod_vals *v, int *val, char *name, 1761 char **curr) 1762 { 1763 char *s; 1764 int i; 1765 1766 s = strchr(*curr, ','); 1767 if (!s) { 1768 pr_warn(PFX "No hotmod %s given.\n", name); 1769 return -EINVAL; 1770 } 1771 *s = '\0'; 1772 s++; 1773 for (i = 0; v[i].name; i++) { 1774 if (strcmp(*curr, v[i].name) == 0) { 1775 *val = v[i].val; 1776 *curr = s; 1777 return 0; 1778 } 1779 } 1780 1781 pr_warn(PFX "Invalid hotmod %s '%s'\n", name, *curr); 1782 return -EINVAL; 1783 } 1784 1785 static int check_hotmod_int_op(const char *curr, const char *option, 1786 const char *name, int *val) 1787 { 1788 char *n; 1789 1790 if (strcmp(curr, name) == 0) { 1791 if (!option) { 1792 pr_warn(PFX "No option given for '%s'\n", curr); 1793 return -EINVAL; 1794 } 1795 *val = simple_strtoul(option, &n, 0); 1796 if ((*n != '\0') || (*option == '\0')) { 1797 pr_warn(PFX "Bad option given for '%s'\n", curr); 1798 return -EINVAL; 1799 } 1800 return 1; 1801 } 1802 return 0; 1803 } 1804 1805 static struct smi_info *smi_info_alloc(void) 1806 { 1807 struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL); 1808 1809 if (info) 1810 spin_lock_init(&info->si_lock); 1811 return info; 1812 } 1813 1814 static int hotmod_handler(const char *val, struct kernel_param *kp) 1815 { 1816 char *str = kstrdup(val, GFP_KERNEL); 1817 int rv; 1818 char *next, *curr, *s, *n, *o; 1819 enum hotmod_op op; 1820 enum si_type si_type; 1821 int addr_space; 1822 unsigned long addr; 1823 int regspacing; 1824 int regsize; 1825 int regshift; 1826 int irq; 1827 int ipmb; 1828 int ival; 1829 int len; 1830 struct smi_info *info; 1831 1832 if (!str) 1833 return -ENOMEM; 1834 1835 /* Kill any trailing spaces, as we can get a "\n" from echo. */ 1836 len = strlen(str); 1837 ival = len - 1; 1838 while ((ival >= 0) && isspace(str[ival])) { 1839 str[ival] = '\0'; 1840 ival--; 1841 } 1842 1843 for (curr = str; curr; curr = next) { 1844 regspacing = 1; 1845 regsize = 1; 1846 regshift = 0; 1847 irq = 0; 1848 ipmb = 0; /* Choose the default if not specified */ 1849 1850 next = strchr(curr, ':'); 1851 if (next) { 1852 *next = '\0'; 1853 next++; 1854 } 1855 1856 rv = parse_str(hotmod_ops, &ival, "operation", &curr); 1857 if (rv) 1858 break; 1859 op = ival; 1860 1861 rv = parse_str(hotmod_si, &ival, "interface type", &curr); 1862 if (rv) 1863 break; 1864 si_type = ival; 1865 1866 rv = parse_str(hotmod_as, &addr_space, "address space", &curr); 1867 if (rv) 1868 break; 1869 1870 s = strchr(curr, ','); 1871 if (s) { 1872 *s = '\0'; 1873 s++; 1874 } 1875 addr = simple_strtoul(curr, &n, 0); 1876 if ((*n != '\0') || (*curr == '\0')) { 1877 pr_warn(PFX "Invalid hotmod address '%s'\n", curr); 1878 break; 1879 } 1880 1881 while (s) { 1882 curr = s; 1883 s = strchr(curr, ','); 1884 if (s) { 1885 *s = '\0'; 1886 s++; 1887 } 1888 o = strchr(curr, '='); 1889 if (o) { 1890 *o = '\0'; 1891 o++; 1892 } 1893 rv = check_hotmod_int_op(curr, o, "rsp", ®spacing); 1894 if (rv < 0) 1895 goto out; 1896 else if (rv) 1897 continue; 1898 rv = check_hotmod_int_op(curr, o, "rsi", ®size); 1899 if (rv < 0) 1900 goto out; 1901 else if (rv) 1902 continue; 1903 rv = check_hotmod_int_op(curr, o, "rsh", ®shift); 1904 if (rv < 0) 1905 goto out; 1906 else if (rv) 1907 continue; 1908 rv = check_hotmod_int_op(curr, o, "irq", &irq); 1909 if (rv < 0) 1910 goto out; 1911 else if (rv) 1912 continue; 1913 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb); 1914 if (rv < 0) 1915 goto out; 1916 else if (rv) 1917 continue; 1918 1919 rv = -EINVAL; 1920 pr_warn(PFX "Invalid hotmod option '%s'\n", curr); 1921 goto out; 1922 } 1923 1924 if (op == HM_ADD) { 1925 info = smi_info_alloc(); 1926 if (!info) { 1927 rv = -ENOMEM; 1928 goto out; 1929 } 1930 1931 info->addr_source = SI_HOTMOD; 1932 info->si_type = si_type; 1933 info->io.addr_data = addr; 1934 info->io.addr_type = addr_space; 1935 if (addr_space == IPMI_MEM_ADDR_SPACE) 1936 info->io_setup = mem_setup; 1937 else 1938 info->io_setup = port_setup; 1939 1940 info->io.addr = NULL; 1941 info->io.regspacing = regspacing; 1942 if (!info->io.regspacing) 1943 info->io.regspacing = DEFAULT_REGSPACING; 1944 info->io.regsize = regsize; 1945 if (!info->io.regsize) 1946 info->io.regsize = DEFAULT_REGSIZE; 1947 info->io.regshift = regshift; 1948 info->irq = irq; 1949 if (info->irq) 1950 info->irq_setup = std_irq_setup; 1951 info->slave_addr = ipmb; 1952 1953 rv = add_smi(info); 1954 if (rv) { 1955 kfree(info); 1956 goto out; 1957 } 1958 mutex_lock(&smi_infos_lock); 1959 rv = try_smi_init(info); 1960 mutex_unlock(&smi_infos_lock); 1961 if (rv) { 1962 cleanup_one_si(info); 1963 goto out; 1964 } 1965 } else { 1966 /* remove */ 1967 struct smi_info *e, *tmp_e; 1968 1969 mutex_lock(&smi_infos_lock); 1970 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) { 1971 if (e->io.addr_type != addr_space) 1972 continue; 1973 if (e->si_type != si_type) 1974 continue; 1975 if (e->io.addr_data == addr) 1976 cleanup_one_si(e); 1977 } 1978 mutex_unlock(&smi_infos_lock); 1979 } 1980 } 1981 rv = len; 1982 out: 1983 kfree(str); 1984 return rv; 1985 } 1986 1987 static int hardcode_find_bmc(void) 1988 { 1989 int ret = -ENODEV; 1990 int i; 1991 struct smi_info *info; 1992 1993 for (i = 0; i < SI_MAX_PARMS; i++) { 1994 if (!ports[i] && !addrs[i]) 1995 continue; 1996 1997 info = smi_info_alloc(); 1998 if (!info) 1999 return -ENOMEM; 2000 2001 info->addr_source = SI_HARDCODED; 2002 pr_info(PFX "probing via hardcoded address\n"); 2003 2004 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) { 2005 info->si_type = SI_KCS; 2006 } else if (strcmp(si_type[i], "smic") == 0) { 2007 info->si_type = SI_SMIC; 2008 } else if (strcmp(si_type[i], "bt") == 0) { 2009 info->si_type = SI_BT; 2010 } else { 2011 pr_warn(PFX "Interface type specified for interface %d, was invalid: %s\n", 2012 i, si_type[i]); 2013 kfree(info); 2014 continue; 2015 } 2016 2017 if (ports[i]) { 2018 /* An I/O port */ 2019 info->io_setup = port_setup; 2020 info->io.addr_data = ports[i]; 2021 info->io.addr_type = IPMI_IO_ADDR_SPACE; 2022 } else if (addrs[i]) { 2023 /* A memory port */ 2024 info->io_setup = mem_setup; 2025 info->io.addr_data = addrs[i]; 2026 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2027 } else { 2028 pr_warn(PFX "Interface type specified for interface %d, but port and address were not set or set to zero.\n", 2029 i); 2030 kfree(info); 2031 continue; 2032 } 2033 2034 info->io.addr = NULL; 2035 info->io.regspacing = regspacings[i]; 2036 if (!info->io.regspacing) 2037 info->io.regspacing = DEFAULT_REGSPACING; 2038 info->io.regsize = regsizes[i]; 2039 if (!info->io.regsize) 2040 info->io.regsize = DEFAULT_REGSIZE; 2041 info->io.regshift = regshifts[i]; 2042 info->irq = irqs[i]; 2043 if (info->irq) 2044 info->irq_setup = std_irq_setup; 2045 info->slave_addr = slave_addrs[i]; 2046 2047 if (!add_smi(info)) { 2048 mutex_lock(&smi_infos_lock); 2049 if (try_smi_init(info)) 2050 cleanup_one_si(info); 2051 mutex_unlock(&smi_infos_lock); 2052 ret = 0; 2053 } else { 2054 kfree(info); 2055 } 2056 } 2057 return ret; 2058 } 2059 2060 #ifdef CONFIG_ACPI 2061 2062 /* 2063 * Once we get an ACPI failure, we don't try any more, because we go 2064 * through the tables sequentially. Once we don't find a table, there 2065 * are no more. 2066 */ 2067 static int acpi_failure; 2068 2069 /* For GPE-type interrupts. */ 2070 static u32 ipmi_acpi_gpe(acpi_handle gpe_device, 2071 u32 gpe_number, void *context) 2072 { 2073 struct smi_info *smi_info = context; 2074 unsigned long flags; 2075 2076 spin_lock_irqsave(&(smi_info->si_lock), flags); 2077 2078 smi_inc_stat(smi_info, interrupts); 2079 2080 debug_timestamp("ACPI_GPE"); 2081 2082 smi_event_handler(smi_info, 0); 2083 spin_unlock_irqrestore(&(smi_info->si_lock), flags); 2084 2085 return ACPI_INTERRUPT_HANDLED; 2086 } 2087 2088 static void acpi_gpe_irq_cleanup(struct smi_info *info) 2089 { 2090 if (!info->irq) 2091 return; 2092 2093 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe); 2094 } 2095 2096 static int acpi_gpe_irq_setup(struct smi_info *info) 2097 { 2098 acpi_status status; 2099 2100 if (!info->irq) 2101 return 0; 2102 2103 status = acpi_install_gpe_handler(NULL, 2104 info->irq, 2105 ACPI_GPE_LEVEL_TRIGGERED, 2106 &ipmi_acpi_gpe, 2107 info); 2108 if (status != AE_OK) { 2109 dev_warn(info->dev, "%s unable to claim ACPI GPE %d," 2110 " running polled\n", DEVICE_NAME, info->irq); 2111 info->irq = 0; 2112 return -EINVAL; 2113 } else { 2114 info->irq_cleanup = acpi_gpe_irq_cleanup; 2115 dev_info(info->dev, "Using ACPI GPE %d\n", info->irq); 2116 return 0; 2117 } 2118 } 2119 2120 /* 2121 * Defined at 2122 * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf 2123 */ 2124 struct SPMITable { 2125 s8 Signature[4]; 2126 u32 Length; 2127 u8 Revision; 2128 u8 Checksum; 2129 s8 OEMID[6]; 2130 s8 OEMTableID[8]; 2131 s8 OEMRevision[4]; 2132 s8 CreatorID[4]; 2133 s8 CreatorRevision[4]; 2134 u8 InterfaceType; 2135 u8 IPMIlegacy; 2136 s16 SpecificationRevision; 2137 2138 /* 2139 * Bit 0 - SCI interrupt supported 2140 * Bit 1 - I/O APIC/SAPIC 2141 */ 2142 u8 InterruptType; 2143 2144 /* 2145 * If bit 0 of InterruptType is set, then this is the SCI 2146 * interrupt in the GPEx_STS register. 2147 */ 2148 u8 GPE; 2149 2150 s16 Reserved; 2151 2152 /* 2153 * If bit 1 of InterruptType is set, then this is the I/O 2154 * APIC/SAPIC interrupt. 2155 */ 2156 u32 GlobalSystemInterrupt; 2157 2158 /* The actual register address. */ 2159 struct acpi_generic_address addr; 2160 2161 u8 UID[4]; 2162 2163 s8 spmi_id[1]; /* A '\0' terminated array starts here. */ 2164 }; 2165 2166 static int try_init_spmi(struct SPMITable *spmi) 2167 { 2168 struct smi_info *info; 2169 int rv; 2170 2171 if (spmi->IPMIlegacy != 1) { 2172 pr_info(PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy); 2173 return -ENODEV; 2174 } 2175 2176 info = smi_info_alloc(); 2177 if (!info) { 2178 pr_err(PFX "Could not allocate SI data (3)\n"); 2179 return -ENOMEM; 2180 } 2181 2182 info->addr_source = SI_SPMI; 2183 pr_info(PFX "probing via SPMI\n"); 2184 2185 /* Figure out the interface type. */ 2186 switch (spmi->InterfaceType) { 2187 case 1: /* KCS */ 2188 info->si_type = SI_KCS; 2189 break; 2190 case 2: /* SMIC */ 2191 info->si_type = SI_SMIC; 2192 break; 2193 case 3: /* BT */ 2194 info->si_type = SI_BT; 2195 break; 2196 case 4: /* SSIF, just ignore */ 2197 kfree(info); 2198 return -EIO; 2199 default: 2200 pr_info(PFX "Unknown ACPI/SPMI SI type %d\n", 2201 spmi->InterfaceType); 2202 kfree(info); 2203 return -EIO; 2204 } 2205 2206 if (spmi->InterruptType & 1) { 2207 /* We've got a GPE interrupt. */ 2208 info->irq = spmi->GPE; 2209 info->irq_setup = acpi_gpe_irq_setup; 2210 } else if (spmi->InterruptType & 2) { 2211 /* We've got an APIC/SAPIC interrupt. */ 2212 info->irq = spmi->GlobalSystemInterrupt; 2213 info->irq_setup = std_irq_setup; 2214 } else { 2215 /* Use the default interrupt setting. */ 2216 info->irq = 0; 2217 info->irq_setup = NULL; 2218 } 2219 2220 if (spmi->addr.bit_width) { 2221 /* A (hopefully) properly formed register bit width. */ 2222 info->io.regspacing = spmi->addr.bit_width / 8; 2223 } else { 2224 info->io.regspacing = DEFAULT_REGSPACING; 2225 } 2226 info->io.regsize = info->io.regspacing; 2227 info->io.regshift = spmi->addr.bit_offset; 2228 2229 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) { 2230 info->io_setup = mem_setup; 2231 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2232 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 2233 info->io_setup = port_setup; 2234 info->io.addr_type = IPMI_IO_ADDR_SPACE; 2235 } else { 2236 kfree(info); 2237 pr_warn(PFX "Unknown ACPI I/O Address type\n"); 2238 return -EIO; 2239 } 2240 info->io.addr_data = spmi->addr.address; 2241 2242 pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n", 2243 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem", 2244 info->io.addr_data, info->io.regsize, info->io.regspacing, 2245 info->irq); 2246 2247 rv = add_smi(info); 2248 if (rv) 2249 kfree(info); 2250 2251 return rv; 2252 } 2253 2254 static void spmi_find_bmc(void) 2255 { 2256 acpi_status status; 2257 struct SPMITable *spmi; 2258 int i; 2259 2260 if (acpi_disabled) 2261 return; 2262 2263 if (acpi_failure) 2264 return; 2265 2266 for (i = 0; ; i++) { 2267 status = acpi_get_table(ACPI_SIG_SPMI, i+1, 2268 (struct acpi_table_header **)&spmi); 2269 if (status != AE_OK) 2270 return; 2271 2272 try_init_spmi(spmi); 2273 } 2274 } 2275 #endif 2276 2277 #if defined(CONFIG_DMI) || defined(CONFIG_ACPI) 2278 struct resource *ipmi_get_info_from_resources(struct platform_device *pdev, 2279 struct smi_info *info) 2280 { 2281 struct resource *res, *res_second; 2282 2283 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 2284 if (res) { 2285 info->io_setup = port_setup; 2286 info->io.addr_type = IPMI_IO_ADDR_SPACE; 2287 } else { 2288 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 2289 if (res) { 2290 info->io_setup = mem_setup; 2291 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2292 } 2293 } 2294 if (!res) { 2295 dev_err(&pdev->dev, "no I/O or memory address\n"); 2296 return NULL; 2297 } 2298 info->io.addr_data = res->start; 2299 2300 info->io.regspacing = DEFAULT_REGSPACING; 2301 res_second = platform_get_resource(pdev, 2302 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? 2303 IORESOURCE_IO : IORESOURCE_MEM, 2304 1); 2305 if (res_second) { 2306 if (res_second->start > info->io.addr_data) 2307 info->io.regspacing = 2308 res_second->start - info->io.addr_data; 2309 } 2310 info->io.regsize = DEFAULT_REGSIZE; 2311 info->io.regshift = 0; 2312 2313 return res; 2314 } 2315 2316 #endif 2317 2318 #ifdef CONFIG_DMI 2319 static int dmi_ipmi_probe(struct platform_device *pdev) 2320 { 2321 struct smi_info *info; 2322 u8 type, slave_addr; 2323 int rv; 2324 2325 if (!si_trydmi) 2326 return -ENODEV; 2327 2328 rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type); 2329 if (rv) 2330 return -ENODEV; 2331 2332 info = smi_info_alloc(); 2333 if (!info) { 2334 pr_err(PFX "Could not allocate SI data\n"); 2335 return -ENOMEM; 2336 } 2337 2338 info->addr_source = SI_SMBIOS; 2339 pr_info(PFX "probing via SMBIOS\n"); 2340 2341 switch (type) { 2342 case IPMI_DMI_TYPE_KCS: 2343 info->si_type = SI_KCS; 2344 break; 2345 case IPMI_DMI_TYPE_SMIC: 2346 info->si_type = SI_SMIC; 2347 break; 2348 case IPMI_DMI_TYPE_BT: 2349 info->si_type = SI_BT; 2350 break; 2351 default: 2352 kfree(info); 2353 return -EINVAL; 2354 } 2355 2356 if (!ipmi_get_info_from_resources(pdev, info)) { 2357 rv = -EINVAL; 2358 goto err_free; 2359 } 2360 2361 rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr); 2362 if (rv) { 2363 dev_warn(&pdev->dev, "device has no slave-addr property"); 2364 info->slave_addr = 0x20; 2365 } else { 2366 info->slave_addr = slave_addr; 2367 } 2368 2369 info->irq = platform_get_irq(pdev, 0); 2370 if (info->irq > 0) 2371 info->irq_setup = std_irq_setup; 2372 else 2373 info->irq = 0; 2374 2375 info->dev = &pdev->dev; 2376 2377 pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n", 2378 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem", 2379 info->io.addr_data, info->io.regsize, info->io.regspacing, 2380 info->irq); 2381 2382 if (add_smi(info)) 2383 kfree(info); 2384 2385 return 0; 2386 2387 err_free: 2388 kfree(info); 2389 return rv; 2390 } 2391 #else 2392 static int dmi_ipmi_probe(struct platform_device *pdev) 2393 { 2394 return -ENODEV; 2395 } 2396 #endif /* CONFIG_DMI */ 2397 2398 #ifdef CONFIG_PCI 2399 2400 #define PCI_ERMC_CLASSCODE 0x0C0700 2401 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00 2402 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff 2403 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00 2404 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01 2405 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02 2406 2407 #define PCI_HP_VENDOR_ID 0x103C 2408 #define PCI_MMC_DEVICE_ID 0x121A 2409 #define PCI_MMC_ADDR_CW 0x10 2410 2411 static void ipmi_pci_cleanup(struct smi_info *info) 2412 { 2413 struct pci_dev *pdev = info->addr_source_data; 2414 2415 pci_disable_device(pdev); 2416 } 2417 2418 static int ipmi_pci_probe_regspacing(struct smi_info *info) 2419 { 2420 if (info->si_type == SI_KCS) { 2421 unsigned char status; 2422 int regspacing; 2423 2424 info->io.regsize = DEFAULT_REGSIZE; 2425 info->io.regshift = 0; 2426 info->io_size = 2; 2427 info->handlers = &kcs_smi_handlers; 2428 2429 /* detect 1, 4, 16byte spacing */ 2430 for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) { 2431 info->io.regspacing = regspacing; 2432 if (info->io_setup(info)) { 2433 dev_err(info->dev, 2434 "Could not setup I/O space\n"); 2435 return DEFAULT_REGSPACING; 2436 } 2437 /* write invalid cmd */ 2438 info->io.outputb(&info->io, 1, 0x10); 2439 /* read status back */ 2440 status = info->io.inputb(&info->io, 1); 2441 info->io_cleanup(info); 2442 if (status) 2443 return regspacing; 2444 regspacing *= 4; 2445 } 2446 } 2447 return DEFAULT_REGSPACING; 2448 } 2449 2450 static int ipmi_pci_probe(struct pci_dev *pdev, 2451 const struct pci_device_id *ent) 2452 { 2453 int rv; 2454 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK; 2455 struct smi_info *info; 2456 2457 info = smi_info_alloc(); 2458 if (!info) 2459 return -ENOMEM; 2460 2461 info->addr_source = SI_PCI; 2462 dev_info(&pdev->dev, "probing via PCI"); 2463 2464 switch (class_type) { 2465 case PCI_ERMC_CLASSCODE_TYPE_SMIC: 2466 info->si_type = SI_SMIC; 2467 break; 2468 2469 case PCI_ERMC_CLASSCODE_TYPE_KCS: 2470 info->si_type = SI_KCS; 2471 break; 2472 2473 case PCI_ERMC_CLASSCODE_TYPE_BT: 2474 info->si_type = SI_BT; 2475 break; 2476 2477 default: 2478 kfree(info); 2479 dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type); 2480 return -ENOMEM; 2481 } 2482 2483 rv = pci_enable_device(pdev); 2484 if (rv) { 2485 dev_err(&pdev->dev, "couldn't enable PCI device\n"); 2486 kfree(info); 2487 return rv; 2488 } 2489 2490 info->addr_source_cleanup = ipmi_pci_cleanup; 2491 info->addr_source_data = pdev; 2492 2493 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) { 2494 info->io_setup = port_setup; 2495 info->io.addr_type = IPMI_IO_ADDR_SPACE; 2496 } else { 2497 info->io_setup = mem_setup; 2498 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2499 } 2500 info->io.addr_data = pci_resource_start(pdev, 0); 2501 2502 info->io.regspacing = ipmi_pci_probe_regspacing(info); 2503 info->io.regsize = DEFAULT_REGSIZE; 2504 info->io.regshift = 0; 2505 2506 info->irq = pdev->irq; 2507 if (info->irq) 2508 info->irq_setup = std_irq_setup; 2509 2510 info->dev = &pdev->dev; 2511 pci_set_drvdata(pdev, info); 2512 2513 dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n", 2514 &pdev->resource[0], info->io.regsize, info->io.regspacing, 2515 info->irq); 2516 2517 rv = add_smi(info); 2518 if (rv) { 2519 kfree(info); 2520 pci_disable_device(pdev); 2521 } 2522 2523 return rv; 2524 } 2525 2526 static void ipmi_pci_remove(struct pci_dev *pdev) 2527 { 2528 struct smi_info *info = pci_get_drvdata(pdev); 2529 cleanup_one_si(info); 2530 } 2531 2532 static const struct pci_device_id ipmi_pci_devices[] = { 2533 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) }, 2534 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }, 2535 { 0, } 2536 }; 2537 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices); 2538 2539 static struct pci_driver ipmi_pci_driver = { 2540 .name = DEVICE_NAME, 2541 .id_table = ipmi_pci_devices, 2542 .probe = ipmi_pci_probe, 2543 .remove = ipmi_pci_remove, 2544 }; 2545 #endif /* CONFIG_PCI */ 2546 2547 #ifdef CONFIG_OF 2548 static const struct of_device_id of_ipmi_match[] = { 2549 { .type = "ipmi", .compatible = "ipmi-kcs", 2550 .data = (void *)(unsigned long) SI_KCS }, 2551 { .type = "ipmi", .compatible = "ipmi-smic", 2552 .data = (void *)(unsigned long) SI_SMIC }, 2553 { .type = "ipmi", .compatible = "ipmi-bt", 2554 .data = (void *)(unsigned long) SI_BT }, 2555 {}, 2556 }; 2557 MODULE_DEVICE_TABLE(of, of_ipmi_match); 2558 2559 static int of_ipmi_probe(struct platform_device *dev) 2560 { 2561 const struct of_device_id *match; 2562 struct smi_info *info; 2563 struct resource resource; 2564 const __be32 *regsize, *regspacing, *regshift; 2565 struct device_node *np = dev->dev.of_node; 2566 int ret; 2567 int proplen; 2568 2569 dev_info(&dev->dev, "probing via device tree\n"); 2570 2571 match = of_match_device(of_ipmi_match, &dev->dev); 2572 if (!match) 2573 return -ENODEV; 2574 2575 if (!of_device_is_available(np)) 2576 return -EINVAL; 2577 2578 ret = of_address_to_resource(np, 0, &resource); 2579 if (ret) { 2580 dev_warn(&dev->dev, PFX "invalid address from OF\n"); 2581 return ret; 2582 } 2583 2584 regsize = of_get_property(np, "reg-size", &proplen); 2585 if (regsize && proplen != 4) { 2586 dev_warn(&dev->dev, PFX "invalid regsize from OF\n"); 2587 return -EINVAL; 2588 } 2589 2590 regspacing = of_get_property(np, "reg-spacing", &proplen); 2591 if (regspacing && proplen != 4) { 2592 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n"); 2593 return -EINVAL; 2594 } 2595 2596 regshift = of_get_property(np, "reg-shift", &proplen); 2597 if (regshift && proplen != 4) { 2598 dev_warn(&dev->dev, PFX "invalid regshift from OF\n"); 2599 return -EINVAL; 2600 } 2601 2602 info = smi_info_alloc(); 2603 2604 if (!info) { 2605 dev_err(&dev->dev, 2606 "could not allocate memory for OF probe\n"); 2607 return -ENOMEM; 2608 } 2609 2610 info->si_type = (enum si_type) match->data; 2611 info->addr_source = SI_DEVICETREE; 2612 info->irq_setup = std_irq_setup; 2613 2614 if (resource.flags & IORESOURCE_IO) { 2615 info->io_setup = port_setup; 2616 info->io.addr_type = IPMI_IO_ADDR_SPACE; 2617 } else { 2618 info->io_setup = mem_setup; 2619 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2620 } 2621 2622 info->io.addr_data = resource.start; 2623 2624 info->io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE; 2625 info->io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING; 2626 info->io.regshift = regshift ? be32_to_cpup(regshift) : 0; 2627 2628 info->irq = irq_of_parse_and_map(dev->dev.of_node, 0); 2629 info->dev = &dev->dev; 2630 2631 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n", 2632 info->io.addr_data, info->io.regsize, info->io.regspacing, 2633 info->irq); 2634 2635 dev_set_drvdata(&dev->dev, info); 2636 2637 ret = add_smi(info); 2638 if (ret) { 2639 kfree(info); 2640 return ret; 2641 } 2642 return 0; 2643 } 2644 #else 2645 #define of_ipmi_match NULL 2646 static int of_ipmi_probe(struct platform_device *dev) 2647 { 2648 return -ENODEV; 2649 } 2650 #endif 2651 2652 #ifdef CONFIG_ACPI 2653 static int find_slave_address(struct smi_info *info, int slave_addr) 2654 { 2655 #ifdef CONFIG_IPMI_DMI_DECODE 2656 if (!slave_addr) { 2657 int type = -1; 2658 u32 flags = IORESOURCE_IO; 2659 2660 switch (info->si_type) { 2661 case SI_KCS: 2662 type = IPMI_DMI_TYPE_KCS; 2663 break; 2664 case SI_BT: 2665 type = IPMI_DMI_TYPE_BT; 2666 break; 2667 case SI_SMIC: 2668 type = IPMI_DMI_TYPE_SMIC; 2669 break; 2670 } 2671 2672 if (info->io.addr_type == IPMI_MEM_ADDR_SPACE) 2673 flags = IORESOURCE_MEM; 2674 2675 slave_addr = ipmi_dmi_get_slave_addr(type, flags, 2676 info->io.addr_data); 2677 } 2678 #endif 2679 2680 return slave_addr; 2681 } 2682 2683 static int acpi_ipmi_probe(struct platform_device *dev) 2684 { 2685 struct smi_info *info; 2686 acpi_handle handle; 2687 acpi_status status; 2688 unsigned long long tmp; 2689 struct resource *res; 2690 int rv = -EINVAL; 2691 2692 if (!si_tryacpi) 2693 return -ENODEV; 2694 2695 handle = ACPI_HANDLE(&dev->dev); 2696 if (!handle) 2697 return -ENODEV; 2698 2699 info = smi_info_alloc(); 2700 if (!info) 2701 return -ENOMEM; 2702 2703 info->addr_source = SI_ACPI; 2704 dev_info(&dev->dev, PFX "probing via ACPI\n"); 2705 2706 info->addr_info.acpi_info.acpi_handle = handle; 2707 2708 /* _IFT tells us the interface type: KCS, BT, etc */ 2709 status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp); 2710 if (ACPI_FAILURE(status)) { 2711 dev_err(&dev->dev, "Could not find ACPI IPMI interface type\n"); 2712 goto err_free; 2713 } 2714 2715 switch (tmp) { 2716 case 1: 2717 info->si_type = SI_KCS; 2718 break; 2719 case 2: 2720 info->si_type = SI_SMIC; 2721 break; 2722 case 3: 2723 info->si_type = SI_BT; 2724 break; 2725 case 4: /* SSIF, just ignore */ 2726 rv = -ENODEV; 2727 goto err_free; 2728 default: 2729 dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp); 2730 goto err_free; 2731 } 2732 2733 res = ipmi_get_info_from_resources(dev, info); 2734 if (!res) { 2735 rv = -EINVAL; 2736 goto err_free; 2737 } 2738 2739 /* If _GPE exists, use it; otherwise use standard interrupts */ 2740 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp); 2741 if (ACPI_SUCCESS(status)) { 2742 info->irq = tmp; 2743 info->irq_setup = acpi_gpe_irq_setup; 2744 } else { 2745 int irq = platform_get_irq(dev, 0); 2746 2747 if (irq > 0) { 2748 info->irq = irq; 2749 info->irq_setup = std_irq_setup; 2750 } 2751 } 2752 2753 info->slave_addr = find_slave_address(info, info->slave_addr); 2754 2755 info->dev = &dev->dev; 2756 platform_set_drvdata(dev, info); 2757 2758 dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n", 2759 res, info->io.regsize, info->io.regspacing, 2760 info->irq); 2761 2762 rv = add_smi(info); 2763 if (rv) 2764 kfree(info); 2765 2766 return rv; 2767 2768 err_free: 2769 kfree(info); 2770 return rv; 2771 } 2772 2773 static const struct acpi_device_id acpi_ipmi_match[] = { 2774 { "IPI0001", 0 }, 2775 { }, 2776 }; 2777 MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match); 2778 #else 2779 static int acpi_ipmi_probe(struct platform_device *dev) 2780 { 2781 return -ENODEV; 2782 } 2783 #endif 2784 2785 static int ipmi_probe(struct platform_device *dev) 2786 { 2787 if (of_ipmi_probe(dev) == 0) 2788 return 0; 2789 2790 if (acpi_ipmi_probe(dev) == 0) 2791 return 0; 2792 2793 return dmi_ipmi_probe(dev); 2794 } 2795 2796 static int ipmi_remove(struct platform_device *dev) 2797 { 2798 struct smi_info *info = dev_get_drvdata(&dev->dev); 2799 2800 cleanup_one_si(info); 2801 return 0; 2802 } 2803 2804 static struct platform_driver ipmi_driver = { 2805 .driver = { 2806 .name = DEVICE_NAME, 2807 .of_match_table = of_ipmi_match, 2808 .acpi_match_table = ACPI_PTR(acpi_ipmi_match), 2809 }, 2810 .probe = ipmi_probe, 2811 .remove = ipmi_remove, 2812 }; 2813 2814 #ifdef CONFIG_PARISC 2815 static int ipmi_parisc_probe(struct parisc_device *dev) 2816 { 2817 struct smi_info *info; 2818 int rv; 2819 2820 info = smi_info_alloc(); 2821 2822 if (!info) { 2823 dev_err(&dev->dev, 2824 "could not allocate memory for PARISC probe\n"); 2825 return -ENOMEM; 2826 } 2827 2828 info->si_type = SI_KCS; 2829 info->addr_source = SI_DEVICETREE; 2830 info->io_setup = mem_setup; 2831 info->io.addr_type = IPMI_MEM_ADDR_SPACE; 2832 info->io.addr_data = dev->hpa.start; 2833 info->io.regsize = 1; 2834 info->io.regspacing = 1; 2835 info->io.regshift = 0; 2836 info->irq = 0; /* no interrupt */ 2837 info->irq_setup = NULL; 2838 info->dev = &dev->dev; 2839 2840 dev_dbg(&dev->dev, "addr 0x%lx\n", info->io.addr_data); 2841 2842 dev_set_drvdata(&dev->dev, info); 2843 2844 rv = add_smi(info); 2845 if (rv) { 2846 kfree(info); 2847 return rv; 2848 } 2849 2850 return 0; 2851 } 2852 2853 static int ipmi_parisc_remove(struct parisc_device *dev) 2854 { 2855 cleanup_one_si(dev_get_drvdata(&dev->dev)); 2856 return 0; 2857 } 2858 2859 static const struct parisc_device_id ipmi_parisc_tbl[] = { 2860 { HPHW_MC, HVERSION_REV_ANY_ID, 0x004, 0xC0 }, 2861 { 0, } 2862 }; 2863 2864 static struct parisc_driver ipmi_parisc_driver = { 2865 .name = "ipmi", 2866 .id_table = ipmi_parisc_tbl, 2867 .probe = ipmi_parisc_probe, 2868 .remove = ipmi_parisc_remove, 2869 }; 2870 #endif /* CONFIG_PARISC */ 2871 2872 static int wait_for_msg_done(struct smi_info *smi_info) 2873 { 2874 enum si_sm_result smi_result; 2875 2876 smi_result = smi_info->handlers->event(smi_info->si_sm, 0); 2877 for (;;) { 2878 if (smi_result == SI_SM_CALL_WITH_DELAY || 2879 smi_result == SI_SM_CALL_WITH_TICK_DELAY) { 2880 schedule_timeout_uninterruptible(1); 2881 smi_result = smi_info->handlers->event( 2882 smi_info->si_sm, jiffies_to_usecs(1)); 2883 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) { 2884 smi_result = smi_info->handlers->event( 2885 smi_info->si_sm, 0); 2886 } else 2887 break; 2888 } 2889 if (smi_result == SI_SM_HOSED) 2890 /* 2891 * We couldn't get the state machine to run, so whatever's at 2892 * the port is probably not an IPMI SMI interface. 2893 */ 2894 return -ENODEV; 2895 2896 return 0; 2897 } 2898 2899 static int try_get_dev_id(struct smi_info *smi_info) 2900 { 2901 unsigned char msg[2]; 2902 unsigned char *resp; 2903 unsigned long resp_len; 2904 int rv = 0; 2905 2906 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 2907 if (!resp) 2908 return -ENOMEM; 2909 2910 /* 2911 * Do a Get Device ID command, since it comes back with some 2912 * useful info. 2913 */ 2914 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 2915 msg[1] = IPMI_GET_DEVICE_ID_CMD; 2916 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 2917 2918 rv = wait_for_msg_done(smi_info); 2919 if (rv) 2920 goto out; 2921 2922 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 2923 resp, IPMI_MAX_MSG_LENGTH); 2924 2925 /* Check and record info from the get device id, in case we need it. */ 2926 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id); 2927 2928 out: 2929 kfree(resp); 2930 return rv; 2931 } 2932 2933 static int get_global_enables(struct smi_info *smi_info, u8 *enables) 2934 { 2935 unsigned char msg[3]; 2936 unsigned char *resp; 2937 unsigned long resp_len; 2938 int rv; 2939 2940 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 2941 if (!resp) 2942 return -ENOMEM; 2943 2944 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 2945 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 2946 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 2947 2948 rv = wait_for_msg_done(smi_info); 2949 if (rv) { 2950 dev_warn(smi_info->dev, 2951 "Error getting response from get global enables command: %d\n", 2952 rv); 2953 goto out; 2954 } 2955 2956 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 2957 resp, IPMI_MAX_MSG_LENGTH); 2958 2959 if (resp_len < 4 || 2960 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 2961 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD || 2962 resp[2] != 0) { 2963 dev_warn(smi_info->dev, 2964 "Invalid return from get global enables command: %ld %x %x %x\n", 2965 resp_len, resp[0], resp[1], resp[2]); 2966 rv = -EINVAL; 2967 goto out; 2968 } else { 2969 *enables = resp[3]; 2970 } 2971 2972 out: 2973 kfree(resp); 2974 return rv; 2975 } 2976 2977 /* 2978 * Returns 1 if it gets an error from the command. 2979 */ 2980 static int set_global_enables(struct smi_info *smi_info, u8 enables) 2981 { 2982 unsigned char msg[3]; 2983 unsigned char *resp; 2984 unsigned long resp_len; 2985 int rv; 2986 2987 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 2988 if (!resp) 2989 return -ENOMEM; 2990 2991 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 2992 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 2993 msg[2] = enables; 2994 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3); 2995 2996 rv = wait_for_msg_done(smi_info); 2997 if (rv) { 2998 dev_warn(smi_info->dev, 2999 "Error getting response from set global enables command: %d\n", 3000 rv); 3001 goto out; 3002 } 3003 3004 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 3005 resp, IPMI_MAX_MSG_LENGTH); 3006 3007 if (resp_len < 3 || 3008 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 3009 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) { 3010 dev_warn(smi_info->dev, 3011 "Invalid return from set global enables command: %ld %x %x\n", 3012 resp_len, resp[0], resp[1]); 3013 rv = -EINVAL; 3014 goto out; 3015 } 3016 3017 if (resp[2] != 0) 3018 rv = 1; 3019 3020 out: 3021 kfree(resp); 3022 return rv; 3023 } 3024 3025 /* 3026 * Some BMCs do not support clearing the receive irq bit in the global 3027 * enables (even if they don't support interrupts on the BMC). Check 3028 * for this and handle it properly. 3029 */ 3030 static void check_clr_rcv_irq(struct smi_info *smi_info) 3031 { 3032 u8 enables = 0; 3033 int rv; 3034 3035 rv = get_global_enables(smi_info, &enables); 3036 if (!rv) { 3037 if ((enables & IPMI_BMC_RCV_MSG_INTR) == 0) 3038 /* Already clear, should work ok. */ 3039 return; 3040 3041 enables &= ~IPMI_BMC_RCV_MSG_INTR; 3042 rv = set_global_enables(smi_info, enables); 3043 } 3044 3045 if (rv < 0) { 3046 dev_err(smi_info->dev, 3047 "Cannot check clearing the rcv irq: %d\n", rv); 3048 return; 3049 } 3050 3051 if (rv) { 3052 /* 3053 * An error when setting the event buffer bit means 3054 * clearing the bit is not supported. 3055 */ 3056 dev_warn(smi_info->dev, 3057 "The BMC does not support clearing the recv irq bit, compensating, but the BMC needs to be fixed.\n"); 3058 smi_info->cannot_disable_irq = true; 3059 } 3060 } 3061 3062 /* 3063 * Some BMCs do not support setting the interrupt bits in the global 3064 * enables even if they support interrupts. Clearly bad, but we can 3065 * compensate. 3066 */ 3067 static void check_set_rcv_irq(struct smi_info *smi_info) 3068 { 3069 u8 enables = 0; 3070 int rv; 3071 3072 if (!smi_info->irq) 3073 return; 3074 3075 rv = get_global_enables(smi_info, &enables); 3076 if (!rv) { 3077 enables |= IPMI_BMC_RCV_MSG_INTR; 3078 rv = set_global_enables(smi_info, enables); 3079 } 3080 3081 if (rv < 0) { 3082 dev_err(smi_info->dev, 3083 "Cannot check setting the rcv irq: %d\n", rv); 3084 return; 3085 } 3086 3087 if (rv) { 3088 /* 3089 * An error when setting the event buffer bit means 3090 * setting the bit is not supported. 3091 */ 3092 dev_warn(smi_info->dev, 3093 "The BMC does not support setting the recv irq bit, compensating, but the BMC needs to be fixed.\n"); 3094 smi_info->cannot_disable_irq = true; 3095 smi_info->irq_enable_broken = true; 3096 } 3097 } 3098 3099 static int try_enable_event_buffer(struct smi_info *smi_info) 3100 { 3101 unsigned char msg[3]; 3102 unsigned char *resp; 3103 unsigned long resp_len; 3104 int rv = 0; 3105 3106 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL); 3107 if (!resp) 3108 return -ENOMEM; 3109 3110 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 3111 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; 3112 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); 3113 3114 rv = wait_for_msg_done(smi_info); 3115 if (rv) { 3116 pr_warn(PFX "Error getting response from get global enables command, the event buffer is not enabled.\n"); 3117 goto out; 3118 } 3119 3120 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 3121 resp, IPMI_MAX_MSG_LENGTH); 3122 3123 if (resp_len < 4 || 3124 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 3125 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD || 3126 resp[2] != 0) { 3127 pr_warn(PFX "Invalid return from get global enables command, cannot enable the event buffer.\n"); 3128 rv = -EINVAL; 3129 goto out; 3130 } 3131 3132 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) { 3133 /* buffer is already enabled, nothing to do. */ 3134 smi_info->supports_event_msg_buff = true; 3135 goto out; 3136 } 3137 3138 msg[0] = IPMI_NETFN_APP_REQUEST << 2; 3139 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD; 3140 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF; 3141 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3); 3142 3143 rv = wait_for_msg_done(smi_info); 3144 if (rv) { 3145 pr_warn(PFX "Error getting response from set global, enables command, the event buffer is not enabled.\n"); 3146 goto out; 3147 } 3148 3149 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 3150 resp, IPMI_MAX_MSG_LENGTH); 3151 3152 if (resp_len < 3 || 3153 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 || 3154 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) { 3155 pr_warn(PFX "Invalid return from get global, enables command, not enable the event buffer.\n"); 3156 rv = -EINVAL; 3157 goto out; 3158 } 3159 3160 if (resp[2] != 0) 3161 /* 3162 * An error when setting the event buffer bit means 3163 * that the event buffer is not supported. 3164 */ 3165 rv = -ENOENT; 3166 else 3167 smi_info->supports_event_msg_buff = true; 3168 3169 out: 3170 kfree(resp); 3171 return rv; 3172 } 3173 3174 static int smi_type_proc_show(struct seq_file *m, void *v) 3175 { 3176 struct smi_info *smi = m->private; 3177 3178 seq_printf(m, "%s\n", si_to_str[smi->si_type]); 3179 3180 return 0; 3181 } 3182 3183 static int smi_type_proc_open(struct inode *inode, struct file *file) 3184 { 3185 return single_open(file, smi_type_proc_show, PDE_DATA(inode)); 3186 } 3187 3188 static const struct file_operations smi_type_proc_ops = { 3189 .open = smi_type_proc_open, 3190 .read = seq_read, 3191 .llseek = seq_lseek, 3192 .release = single_release, 3193 }; 3194 3195 static int smi_si_stats_proc_show(struct seq_file *m, void *v) 3196 { 3197 struct smi_info *smi = m->private; 3198 3199 seq_printf(m, "interrupts_enabled: %d\n", 3200 smi->irq && !smi->interrupt_disabled); 3201 seq_printf(m, "short_timeouts: %u\n", 3202 smi_get_stat(smi, short_timeouts)); 3203 seq_printf(m, "long_timeouts: %u\n", 3204 smi_get_stat(smi, long_timeouts)); 3205 seq_printf(m, "idles: %u\n", 3206 smi_get_stat(smi, idles)); 3207 seq_printf(m, "interrupts: %u\n", 3208 smi_get_stat(smi, interrupts)); 3209 seq_printf(m, "attentions: %u\n", 3210 smi_get_stat(smi, attentions)); 3211 seq_printf(m, "flag_fetches: %u\n", 3212 smi_get_stat(smi, flag_fetches)); 3213 seq_printf(m, "hosed_count: %u\n", 3214 smi_get_stat(smi, hosed_count)); 3215 seq_printf(m, "complete_transactions: %u\n", 3216 smi_get_stat(smi, complete_transactions)); 3217 seq_printf(m, "events: %u\n", 3218 smi_get_stat(smi, events)); 3219 seq_printf(m, "watchdog_pretimeouts: %u\n", 3220 smi_get_stat(smi, watchdog_pretimeouts)); 3221 seq_printf(m, "incoming_messages: %u\n", 3222 smi_get_stat(smi, incoming_messages)); 3223 return 0; 3224 } 3225 3226 static int smi_si_stats_proc_open(struct inode *inode, struct file *file) 3227 { 3228 return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode)); 3229 } 3230 3231 static const struct file_operations smi_si_stats_proc_ops = { 3232 .open = smi_si_stats_proc_open, 3233 .read = seq_read, 3234 .llseek = seq_lseek, 3235 .release = single_release, 3236 }; 3237 3238 static int smi_params_proc_show(struct seq_file *m, void *v) 3239 { 3240 struct smi_info *smi = m->private; 3241 3242 seq_printf(m, 3243 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n", 3244 si_to_str[smi->si_type], 3245 addr_space_to_str[smi->io.addr_type], 3246 smi->io.addr_data, 3247 smi->io.regspacing, 3248 smi->io.regsize, 3249 smi->io.regshift, 3250 smi->irq, 3251 smi->slave_addr); 3252 3253 return 0; 3254 } 3255 3256 static int smi_params_proc_open(struct inode *inode, struct file *file) 3257 { 3258 return single_open(file, smi_params_proc_show, PDE_DATA(inode)); 3259 } 3260 3261 static const struct file_operations smi_params_proc_ops = { 3262 .open = smi_params_proc_open, 3263 .read = seq_read, 3264 .llseek = seq_lseek, 3265 .release = single_release, 3266 }; 3267 3268 /* 3269 * oem_data_avail_to_receive_msg_avail 3270 * @info - smi_info structure with msg_flags set 3271 * 3272 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL 3273 * Returns 1 indicating need to re-run handle_flags(). 3274 */ 3275 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info) 3276 { 3277 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) | 3278 RECEIVE_MSG_AVAIL); 3279 return 1; 3280 } 3281 3282 /* 3283 * setup_dell_poweredge_oem_data_handler 3284 * @info - smi_info.device_id must be populated 3285 * 3286 * Systems that match, but have firmware version < 1.40 may assert 3287 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that 3288 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL 3289 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags 3290 * as RECEIVE_MSG_AVAIL instead. 3291 * 3292 * As Dell has no plans to release IPMI 1.5 firmware that *ever* 3293 * assert the OEM[012] bits, and if it did, the driver would have to 3294 * change to handle that properly, we don't actually check for the 3295 * firmware version. 3296 * Device ID = 0x20 BMC on PowerEdge 8G servers 3297 * Device Revision = 0x80 3298 * Firmware Revision1 = 0x01 BMC version 1.40 3299 * Firmware Revision2 = 0x40 BCD encoded 3300 * IPMI Version = 0x51 IPMI 1.5 3301 * Manufacturer ID = A2 02 00 Dell IANA 3302 * 3303 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert 3304 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL. 3305 * 3306 */ 3307 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20 3308 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80 3309 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51 3310 #define DELL_IANA_MFR_ID 0x0002a2 3311 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info) 3312 { 3313 struct ipmi_device_id *id = &smi_info->device_id; 3314 if (id->manufacturer_id == DELL_IANA_MFR_ID) { 3315 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID && 3316 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV && 3317 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) { 3318 smi_info->oem_data_avail_handler = 3319 oem_data_avail_to_receive_msg_avail; 3320 } else if (ipmi_version_major(id) < 1 || 3321 (ipmi_version_major(id) == 1 && 3322 ipmi_version_minor(id) < 5)) { 3323 smi_info->oem_data_avail_handler = 3324 oem_data_avail_to_receive_msg_avail; 3325 } 3326 } 3327 } 3328 3329 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA 3330 static void return_hosed_msg_badsize(struct smi_info *smi_info) 3331 { 3332 struct ipmi_smi_msg *msg = smi_info->curr_msg; 3333 3334 /* Make it a response */ 3335 msg->rsp[0] = msg->data[0] | 4; 3336 msg->rsp[1] = msg->data[1]; 3337 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH; 3338 msg->rsp_size = 3; 3339 smi_info->curr_msg = NULL; 3340 deliver_recv_msg(smi_info, msg); 3341 } 3342 3343 /* 3344 * dell_poweredge_bt_xaction_handler 3345 * @info - smi_info.device_id must be populated 3346 * 3347 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will 3348 * not respond to a Get SDR command if the length of the data 3349 * requested is exactly 0x3A, which leads to command timeouts and no 3350 * data returned. This intercepts such commands, and causes userspace 3351 * callers to try again with a different-sized buffer, which succeeds. 3352 */ 3353 3354 #define STORAGE_NETFN 0x0A 3355 #define STORAGE_CMD_GET_SDR 0x23 3356 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self, 3357 unsigned long unused, 3358 void *in) 3359 { 3360 struct smi_info *smi_info = in; 3361 unsigned char *data = smi_info->curr_msg->data; 3362 unsigned int size = smi_info->curr_msg->data_size; 3363 if (size >= 8 && 3364 (data[0]>>2) == STORAGE_NETFN && 3365 data[1] == STORAGE_CMD_GET_SDR && 3366 data[7] == 0x3A) { 3367 return_hosed_msg_badsize(smi_info); 3368 return NOTIFY_STOP; 3369 } 3370 return NOTIFY_DONE; 3371 } 3372 3373 static struct notifier_block dell_poweredge_bt_xaction_notifier = { 3374 .notifier_call = dell_poweredge_bt_xaction_handler, 3375 }; 3376 3377 /* 3378 * setup_dell_poweredge_bt_xaction_handler 3379 * @info - smi_info.device_id must be filled in already 3380 * 3381 * Fills in smi_info.device_id.start_transaction_pre_hook 3382 * when we know what function to use there. 3383 */ 3384 static void 3385 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info) 3386 { 3387 struct ipmi_device_id *id = &smi_info->device_id; 3388 if (id->manufacturer_id == DELL_IANA_MFR_ID && 3389 smi_info->si_type == SI_BT) 3390 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier); 3391 } 3392 3393 /* 3394 * setup_oem_data_handler 3395 * @info - smi_info.device_id must be filled in already 3396 * 3397 * Fills in smi_info.device_id.oem_data_available_handler 3398 * when we know what function to use there. 3399 */ 3400 3401 static void setup_oem_data_handler(struct smi_info *smi_info) 3402 { 3403 setup_dell_poweredge_oem_data_handler(smi_info); 3404 } 3405 3406 static void setup_xaction_handlers(struct smi_info *smi_info) 3407 { 3408 setup_dell_poweredge_bt_xaction_handler(smi_info); 3409 } 3410 3411 static void check_for_broken_irqs(struct smi_info *smi_info) 3412 { 3413 check_clr_rcv_irq(smi_info); 3414 check_set_rcv_irq(smi_info); 3415 } 3416 3417 static inline void wait_for_timer_and_thread(struct smi_info *smi_info) 3418 { 3419 if (smi_info->thread != NULL) 3420 kthread_stop(smi_info->thread); 3421 if (smi_info->timer_running) 3422 del_timer_sync(&smi_info->si_timer); 3423 } 3424 3425 static int is_new_interface(struct smi_info *info) 3426 { 3427 struct smi_info *e; 3428 3429 list_for_each_entry(e, &smi_infos, link) { 3430 if (e->io.addr_type != info->io.addr_type) 3431 continue; 3432 if (e->io.addr_data == info->io.addr_data) { 3433 /* 3434 * This is a cheap hack, ACPI doesn't have a defined 3435 * slave address but SMBIOS does. Pick it up from 3436 * any source that has it available. 3437 */ 3438 if (info->slave_addr && !e->slave_addr) 3439 e->slave_addr = info->slave_addr; 3440 return 0; 3441 } 3442 } 3443 3444 return 1; 3445 } 3446 3447 static int add_smi(struct smi_info *new_smi) 3448 { 3449 int rv = 0; 3450 3451 mutex_lock(&smi_infos_lock); 3452 if (!is_new_interface(new_smi)) { 3453 pr_info(PFX "%s-specified %s state machine: duplicate\n", 3454 ipmi_addr_src_to_str(new_smi->addr_source), 3455 si_to_str[new_smi->si_type]); 3456 rv = -EBUSY; 3457 goto out_err; 3458 } 3459 3460 pr_info(PFX "Adding %s-specified %s state machine\n", 3461 ipmi_addr_src_to_str(new_smi->addr_source), 3462 si_to_str[new_smi->si_type]); 3463 3464 /* So we know not to free it unless we have allocated one. */ 3465 new_smi->intf = NULL; 3466 new_smi->si_sm = NULL; 3467 new_smi->handlers = NULL; 3468 3469 list_add_tail(&new_smi->link, &smi_infos); 3470 3471 out_err: 3472 mutex_unlock(&smi_infos_lock); 3473 return rv; 3474 } 3475 3476 /* 3477 * Try to start up an interface. Must be called with smi_infos_lock 3478 * held, primarily to keep smi_num consistent, we only one to do these 3479 * one at a time. 3480 */ 3481 static int try_smi_init(struct smi_info *new_smi) 3482 { 3483 int rv = 0; 3484 int i; 3485 char *init_name = NULL; 3486 3487 pr_info(PFX "Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n", 3488 ipmi_addr_src_to_str(new_smi->addr_source), 3489 si_to_str[new_smi->si_type], 3490 addr_space_to_str[new_smi->io.addr_type], 3491 new_smi->io.addr_data, 3492 new_smi->slave_addr, new_smi->irq); 3493 3494 switch (new_smi->si_type) { 3495 case SI_KCS: 3496 new_smi->handlers = &kcs_smi_handlers; 3497 break; 3498 3499 case SI_SMIC: 3500 new_smi->handlers = &smic_smi_handlers; 3501 break; 3502 3503 case SI_BT: 3504 new_smi->handlers = &bt_smi_handlers; 3505 break; 3506 3507 default: 3508 /* No support for anything else yet. */ 3509 rv = -EIO; 3510 goto out_err; 3511 } 3512 3513 new_smi->intf_num = smi_num; 3514 3515 /* Do this early so it's available for logs. */ 3516 if (!new_smi->dev) { 3517 init_name = kasprintf(GFP_KERNEL, "ipmi_si.%d", 3518 new_smi->intf_num); 3519 3520 /* 3521 * If we don't already have a device from something 3522 * else (like PCI), then register a new one. 3523 */ 3524 new_smi->pdev = platform_device_alloc("ipmi_si", 3525 new_smi->intf_num); 3526 if (!new_smi->pdev) { 3527 pr_err(PFX "Unable to allocate platform device\n"); 3528 goto out_err; 3529 } 3530 new_smi->dev = &new_smi->pdev->dev; 3531 new_smi->dev->driver = &ipmi_driver.driver; 3532 /* Nulled by device_add() */ 3533 new_smi->dev->init_name = init_name; 3534 } 3535 3536 /* Allocate the state machine's data and initialize it. */ 3537 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL); 3538 if (!new_smi->si_sm) { 3539 pr_err(PFX "Could not allocate state machine memory\n"); 3540 rv = -ENOMEM; 3541 goto out_err; 3542 } 3543 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm, 3544 &new_smi->io); 3545 3546 /* Now that we know the I/O size, we can set up the I/O. */ 3547 rv = new_smi->io_setup(new_smi); 3548 if (rv) { 3549 dev_err(new_smi->dev, "Could not set up I/O space\n"); 3550 goto out_err; 3551 } 3552 3553 /* Do low-level detection first. */ 3554 if (new_smi->handlers->detect(new_smi->si_sm)) { 3555 if (new_smi->addr_source) 3556 dev_err(new_smi->dev, "Interface detection failed\n"); 3557 rv = -ENODEV; 3558 goto out_err; 3559 } 3560 3561 /* 3562 * Attempt a get device id command. If it fails, we probably 3563 * don't have a BMC here. 3564 */ 3565 rv = try_get_dev_id(new_smi); 3566 if (rv) { 3567 if (new_smi->addr_source) 3568 dev_err(new_smi->dev, "There appears to be no BMC at this location\n"); 3569 goto out_err; 3570 } 3571 3572 setup_oem_data_handler(new_smi); 3573 setup_xaction_handlers(new_smi); 3574 check_for_broken_irqs(new_smi); 3575 3576 new_smi->waiting_msg = NULL; 3577 new_smi->curr_msg = NULL; 3578 atomic_set(&new_smi->req_events, 0); 3579 new_smi->run_to_completion = false; 3580 for (i = 0; i < SI_NUM_STATS; i++) 3581 atomic_set(&new_smi->stats[i], 0); 3582 3583 new_smi->interrupt_disabled = true; 3584 atomic_set(&new_smi->need_watch, 0); 3585 3586 rv = try_enable_event_buffer(new_smi); 3587 if (rv == 0) 3588 new_smi->has_event_buffer = true; 3589 3590 /* 3591 * Start clearing the flags before we enable interrupts or the 3592 * timer to avoid racing with the timer. 3593 */ 3594 start_clear_flags(new_smi, false); 3595 3596 /* 3597 * IRQ is defined to be set when non-zero. req_events will 3598 * cause a global flags check that will enable interrupts. 3599 */ 3600 if (new_smi->irq) { 3601 new_smi->interrupt_disabled = false; 3602 atomic_set(&new_smi->req_events, 1); 3603 } 3604 3605 if (new_smi->pdev) { 3606 rv = platform_device_add(new_smi->pdev); 3607 if (rv) { 3608 dev_err(new_smi->dev, 3609 "Unable to register system interface device: %d\n", 3610 rv); 3611 goto out_err; 3612 } 3613 new_smi->dev_registered = true; 3614 } 3615 3616 rv = ipmi_register_smi(&handlers, 3617 new_smi, 3618 &new_smi->device_id, 3619 new_smi->dev, 3620 new_smi->slave_addr); 3621 if (rv) { 3622 dev_err(new_smi->dev, "Unable to register device: error %d\n", 3623 rv); 3624 goto out_err_stop_timer; 3625 } 3626 3627 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type", 3628 &smi_type_proc_ops, 3629 new_smi); 3630 if (rv) { 3631 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv); 3632 goto out_err_stop_timer; 3633 } 3634 3635 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats", 3636 &smi_si_stats_proc_ops, 3637 new_smi); 3638 if (rv) { 3639 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv); 3640 goto out_err_stop_timer; 3641 } 3642 3643 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params", 3644 &smi_params_proc_ops, 3645 new_smi); 3646 if (rv) { 3647 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv); 3648 goto out_err_stop_timer; 3649 } 3650 3651 /* Don't increment till we know we have succeeded. */ 3652 smi_num++; 3653 3654 dev_info(new_smi->dev, "IPMI %s interface initialized\n", 3655 si_to_str[new_smi->si_type]); 3656 3657 WARN_ON(new_smi->dev->init_name != NULL); 3658 kfree(init_name); 3659 3660 return 0; 3661 3662 out_err_stop_timer: 3663 wait_for_timer_and_thread(new_smi); 3664 3665 out_err: 3666 new_smi->interrupt_disabled = true; 3667 3668 if (new_smi->intf) { 3669 ipmi_smi_t intf = new_smi->intf; 3670 new_smi->intf = NULL; 3671 ipmi_unregister_smi(intf); 3672 } 3673 3674 if (new_smi->irq_cleanup) { 3675 new_smi->irq_cleanup(new_smi); 3676 new_smi->irq_cleanup = NULL; 3677 } 3678 3679 /* 3680 * Wait until we know that we are out of any interrupt 3681 * handlers might have been running before we freed the 3682 * interrupt. 3683 */ 3684 synchronize_sched(); 3685 3686 if (new_smi->si_sm) { 3687 if (new_smi->handlers) 3688 new_smi->handlers->cleanup(new_smi->si_sm); 3689 kfree(new_smi->si_sm); 3690 new_smi->si_sm = NULL; 3691 } 3692 if (new_smi->addr_source_cleanup) { 3693 new_smi->addr_source_cleanup(new_smi); 3694 new_smi->addr_source_cleanup = NULL; 3695 } 3696 if (new_smi->io_cleanup) { 3697 new_smi->io_cleanup(new_smi); 3698 new_smi->io_cleanup = NULL; 3699 } 3700 3701 if (new_smi->dev_registered) { 3702 platform_device_unregister(new_smi->pdev); 3703 new_smi->dev_registered = false; 3704 new_smi->pdev = NULL; 3705 } else if (new_smi->pdev) { 3706 platform_device_put(new_smi->pdev); 3707 new_smi->pdev = NULL; 3708 } 3709 3710 kfree(init_name); 3711 3712 return rv; 3713 } 3714 3715 static int init_ipmi_si(void) 3716 { 3717 int i; 3718 char *str; 3719 int rv; 3720 struct smi_info *e; 3721 enum ipmi_addr_src type = SI_INVALID; 3722 3723 if (initialized) 3724 return 0; 3725 initialized = 1; 3726 3727 if (si_tryplatform) { 3728 rv = platform_driver_register(&ipmi_driver); 3729 if (rv) { 3730 pr_err(PFX "Unable to register driver: %d\n", rv); 3731 return rv; 3732 } 3733 } 3734 3735 /* Parse out the si_type string into its components. */ 3736 str = si_type_str; 3737 if (*str != '\0') { 3738 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) { 3739 si_type[i] = str; 3740 str = strchr(str, ','); 3741 if (str) { 3742 *str = '\0'; 3743 str++; 3744 } else { 3745 break; 3746 } 3747 } 3748 } 3749 3750 pr_info("IPMI System Interface driver.\n"); 3751 3752 /* If the user gave us a device, they presumably want us to use it */ 3753 if (!hardcode_find_bmc()) 3754 return 0; 3755 3756 #ifdef CONFIG_PCI 3757 if (si_trypci) { 3758 rv = pci_register_driver(&ipmi_pci_driver); 3759 if (rv) 3760 pr_err(PFX "Unable to register PCI driver: %d\n", rv); 3761 else 3762 pci_registered = true; 3763 } 3764 #endif 3765 3766 #ifdef CONFIG_ACPI 3767 if (si_tryacpi) 3768 spmi_find_bmc(); 3769 #endif 3770 3771 #ifdef CONFIG_PARISC 3772 register_parisc_driver(&ipmi_parisc_driver); 3773 parisc_registered = true; 3774 #endif 3775 3776 /* We prefer devices with interrupts, but in the case of a machine 3777 with multiple BMCs we assume that there will be several instances 3778 of a given type so if we succeed in registering a type then also 3779 try to register everything else of the same type */ 3780 3781 mutex_lock(&smi_infos_lock); 3782 list_for_each_entry(e, &smi_infos, link) { 3783 /* Try to register a device if it has an IRQ and we either 3784 haven't successfully registered a device yet or this 3785 device has the same type as one we successfully registered */ 3786 if (e->irq && (!type || e->addr_source == type)) { 3787 if (!try_smi_init(e)) { 3788 type = e->addr_source; 3789 } 3790 } 3791 } 3792 3793 /* type will only have been set if we successfully registered an si */ 3794 if (type) { 3795 mutex_unlock(&smi_infos_lock); 3796 return 0; 3797 } 3798 3799 /* Fall back to the preferred device */ 3800 3801 list_for_each_entry(e, &smi_infos, link) { 3802 if (!e->irq && (!type || e->addr_source == type)) { 3803 if (!try_smi_init(e)) { 3804 type = e->addr_source; 3805 } 3806 } 3807 } 3808 mutex_unlock(&smi_infos_lock); 3809 3810 if (type) 3811 return 0; 3812 3813 mutex_lock(&smi_infos_lock); 3814 if (unload_when_empty && list_empty(&smi_infos)) { 3815 mutex_unlock(&smi_infos_lock); 3816 cleanup_ipmi_si(); 3817 pr_warn(PFX "Unable to find any System Interface(s)\n"); 3818 return -ENODEV; 3819 } else { 3820 mutex_unlock(&smi_infos_lock); 3821 return 0; 3822 } 3823 } 3824 module_init(init_ipmi_si); 3825 3826 static void cleanup_one_si(struct smi_info *to_clean) 3827 { 3828 int rv = 0; 3829 3830 if (!to_clean) 3831 return; 3832 3833 if (to_clean->intf) { 3834 ipmi_smi_t intf = to_clean->intf; 3835 3836 to_clean->intf = NULL; 3837 rv = ipmi_unregister_smi(intf); 3838 if (rv) { 3839 pr_err(PFX "Unable to unregister device: errno=%d\n", 3840 rv); 3841 } 3842 } 3843 3844 if (to_clean->dev) 3845 dev_set_drvdata(to_clean->dev, NULL); 3846 3847 list_del(&to_clean->link); 3848 3849 /* 3850 * Make sure that interrupts, the timer and the thread are 3851 * stopped and will not run again. 3852 */ 3853 if (to_clean->irq_cleanup) 3854 to_clean->irq_cleanup(to_clean); 3855 wait_for_timer_and_thread(to_clean); 3856 3857 /* 3858 * Timeouts are stopped, now make sure the interrupts are off 3859 * in the BMC. Note that timers and CPU interrupts are off, 3860 * so no need for locks. 3861 */ 3862 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) { 3863 poll(to_clean); 3864 schedule_timeout_uninterruptible(1); 3865 } 3866 disable_si_irq(to_clean, false); 3867 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) { 3868 poll(to_clean); 3869 schedule_timeout_uninterruptible(1); 3870 } 3871 3872 if (to_clean->handlers) 3873 to_clean->handlers->cleanup(to_clean->si_sm); 3874 3875 kfree(to_clean->si_sm); 3876 3877 if (to_clean->addr_source_cleanup) 3878 to_clean->addr_source_cleanup(to_clean); 3879 if (to_clean->io_cleanup) 3880 to_clean->io_cleanup(to_clean); 3881 3882 if (to_clean->dev_registered) 3883 platform_device_unregister(to_clean->pdev); 3884 3885 kfree(to_clean); 3886 } 3887 3888 static void cleanup_ipmi_si(void) 3889 { 3890 struct smi_info *e, *tmp_e; 3891 3892 if (!initialized) 3893 return; 3894 3895 #ifdef CONFIG_PCI 3896 if (pci_registered) 3897 pci_unregister_driver(&ipmi_pci_driver); 3898 #endif 3899 #ifdef CONFIG_PARISC 3900 if (parisc_registered) 3901 unregister_parisc_driver(&ipmi_parisc_driver); 3902 #endif 3903 3904 platform_driver_unregister(&ipmi_driver); 3905 3906 mutex_lock(&smi_infos_lock); 3907 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) 3908 cleanup_one_si(e); 3909 mutex_unlock(&smi_infos_lock); 3910 } 3911 module_exit(cleanup_ipmi_si); 3912 3913 MODULE_ALIAS("platform:dmi-ipmi-si"); 3914 MODULE_LICENSE("GPL"); 3915 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 3916 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT" 3917 " system interfaces."); 3918