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