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