projects / deliverable / linux.git / blob
? search:


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