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