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