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