?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] x86_64: Rename IOMMU option, fix help and mark option embedded.
[linux-2.6/verdex.git] / drivers / char / ipmi / ipmi_si_intf.c
blob02a7dd7a8a55571cbf261e63a9dcdf3cf7fbb969
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 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 *
18 *
19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
20 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
27 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
28 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 675 Mass Ave, Cambridge, MA 02139, USA.
33 */
34
35 /*
36 * This file holds the "policy" for the interface to the SMI state
37 * machine. It does the configuration, handles timers and interrupts,
38 * and drives the real SMI state machine.
39 */
40
41 #include <linux/config.h>
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 #ifdef CONFIG_HIGH_RES_TIMERS
59 #include <linux/hrtime.h>
60 # if defined(schedule_next_int)
61 /* Old high-res timer code, do translations. */
62 # define get_arch_cycles(a) quick_update_jiffies_sub(a)
63 # define arch_cycles_per_jiffy cycles_per_jiffies
64 # endif
65 static inline void add_usec_to_timer(struct timer_list *t, long v)
66 {
67 t->arch_cycle_expires += nsec_to_arch_cycle(v * 1000);
68 while (t->arch_cycle_expires >= arch_cycles_per_jiffy)
69 {
70 t->expires++;
71 t->arch_cycle_expires -= arch_cycles_per_jiffy;
72 }
73 }
74 #endif
75 #include <linux/interrupt.h>
76 #include <linux/rcupdate.h>
77 #include <linux/ipmi_smi.h>
78 #include <asm/io.h>
79 #include "ipmi_si_sm.h"
80 #include <linux/init.h>
81 #include <linux/dmi.h>
82
83 /* Measure times between events in the driver. */
84 #undef DEBUG_TIMING
85
86 /* Call every 10 ms. */
87 #define SI_TIMEOUT_TIME_USEC 10000
88 #define SI_USEC_PER_JIFFY (1000000/HZ)
89 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
90 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
91 short timeout */
92
93 enum si_intf_state {
94 SI_NORMAL,
95 SI_GETTING_FLAGS,
96 SI_GETTING_EVENTS,
97 SI_CLEARING_FLAGS,
98 SI_CLEARING_FLAGS_THEN_SET_IRQ,
99 SI_GETTING_MESSAGES,
100 SI_ENABLE_INTERRUPTS1,
101 SI_ENABLE_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 static int try_smi_init(struct smi_info *smi);
239
240 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
241 static int register_xaction_notifier(struct notifier_block * nb)
242 {
243 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
244 }
245
246 static void si_restart_short_timer(struct smi_info *smi_info);
247
248 static void deliver_recv_msg(struct smi_info *smi_info,
249 struct ipmi_smi_msg *msg)
250 {
251 /* Deliver the message to the upper layer with the lock
252 released. */
253 spin_unlock(&(smi_info->si_lock));
254 ipmi_smi_msg_received(smi_info->intf, msg);
255 spin_lock(&(smi_info->si_lock));
256 }
257
258 static void return_hosed_msg(struct smi_info *smi_info)
259 {
260 struct ipmi_smi_msg *msg = smi_info->curr_msg;
261
262 /* Make it a reponse */
263 msg->rsp[0] = msg->data[0] | 4;
264 msg->rsp[1] = msg->data[1];
265 msg->rsp[2] = 0xFF; /* Unknown error. */
266 msg->rsp_size = 3;
267
268 smi_info->curr_msg = NULL;
269 deliver_recv_msg(smi_info, msg);
270 }
271
272 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
273 {
274 int rv;
275 struct list_head *entry = NULL;
276 #ifdef DEBUG_TIMING
277 struct timeval t;
278 #endif
279
280 /* No need to save flags, we aleady have interrupts off and we
281 already hold the SMI lock. */
282 spin_lock(&(smi_info->msg_lock));
283
284 /* Pick the high priority queue first. */
285 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
286 entry = smi_info->hp_xmit_msgs.next;
287 } else if (!list_empty(&(smi_info->xmit_msgs))) {
288 entry = smi_info->xmit_msgs.next;
289 }
290
291 if (!entry) {
292 smi_info->curr_msg = NULL;
293 rv = SI_SM_IDLE;
294 } else {
295 int err;
296
297 list_del(entry);
298 smi_info->curr_msg = list_entry(entry,
299 struct ipmi_smi_msg,
300 link);
301 #ifdef DEBUG_TIMING
302 do_gettimeofday(&t);
303 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
304 #endif
305 err = atomic_notifier_call_chain(&xaction_notifier_list,
306 0, smi_info);
307 if (err & NOTIFY_STOP_MASK) {
308 rv = SI_SM_CALL_WITHOUT_DELAY;
309 goto out;
310 }
311 err = smi_info->handlers->start_transaction(
312 smi_info->si_sm,
313 smi_info->curr_msg->data,
314 smi_info->curr_msg->data_size);
315 if (err) {
316 return_hosed_msg(smi_info);
317 }
318
319 rv = SI_SM_CALL_WITHOUT_DELAY;
320 }
321 out:
322 spin_unlock(&(smi_info->msg_lock));
323
324 return rv;
325 }
326
327 static void start_enable_irq(struct smi_info *smi_info)
328 {
329 unsigned char msg[2];
330
331 /* If we are enabling interrupts, we have to tell the
332 BMC to use them. */
333 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
334 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
335
336 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
337 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
338 }
339
340 static void start_clear_flags(struct smi_info *smi_info)
341 {
342 unsigned char msg[3];
343
344 /* Make sure the watchdog pre-timeout flag is not set at startup. */
345 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
346 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
347 msg[2] = WDT_PRE_TIMEOUT_INT;
348
349 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
350 smi_info->si_state = SI_CLEARING_FLAGS;
351 }
352
353 /* When we have a situtaion where we run out of memory and cannot
354 allocate messages, we just leave them in the BMC and run the system
355 polled until we can allocate some memory. Once we have some
356 memory, we will re-enable the interrupt. */
357 static inline void disable_si_irq(struct smi_info *smi_info)
358 {
359 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
360 disable_irq_nosync(smi_info->irq);
361 smi_info->interrupt_disabled = 1;
362 }
363 }
364
365 static inline void enable_si_irq(struct smi_info *smi_info)
366 {
367 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
368 enable_irq(smi_info->irq);
369 smi_info->interrupt_disabled = 0;
370 }
371 }
372
373 static void handle_flags(struct smi_info *smi_info)
374 {
375 retry:
376 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
377 /* Watchdog pre-timeout */
378 spin_lock(&smi_info->count_lock);
379 smi_info->watchdog_pretimeouts++;
380 spin_unlock(&smi_info->count_lock);
381
382 start_clear_flags(smi_info);
383 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
384 spin_unlock(&(smi_info->si_lock));
385 ipmi_smi_watchdog_pretimeout(smi_info->intf);
386 spin_lock(&(smi_info->si_lock));
387 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
388 /* Messages available. */
389 smi_info->curr_msg = ipmi_alloc_smi_msg();
390 if (!smi_info->curr_msg) {
391 disable_si_irq(smi_info);
392 smi_info->si_state = SI_NORMAL;
393 return;
394 }
395 enable_si_irq(smi_info);
396
397 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
398 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
399 smi_info->curr_msg->data_size = 2;
400
401 smi_info->handlers->start_transaction(
402 smi_info->si_sm,
403 smi_info->curr_msg->data,
404 smi_info->curr_msg->data_size);
405 smi_info->si_state = SI_GETTING_MESSAGES;
406 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
407 /* Events available. */
408 smi_info->curr_msg = ipmi_alloc_smi_msg();
409 if (!smi_info->curr_msg) {
410 disable_si_irq(smi_info);
411 smi_info->si_state = SI_NORMAL;
412 return;
413 }
414 enable_si_irq(smi_info);
415
416 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
417 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
418 smi_info->curr_msg->data_size = 2;
419
420 smi_info->handlers->start_transaction(
421 smi_info->si_sm,
422 smi_info->curr_msg->data,
423 smi_info->curr_msg->data_size);
424 smi_info->si_state = SI_GETTING_EVENTS;
425 } else if (smi_info->msg_flags & OEM_DATA_AVAIL) {
426 if (smi_info->oem_data_avail_handler)
427 if (smi_info->oem_data_avail_handler(smi_info))
428 goto retry;
429 } else {
430 smi_info->si_state = SI_NORMAL;
431 }
432 }
433
434 static void handle_transaction_done(struct smi_info *smi_info)
435 {
436 struct ipmi_smi_msg *msg;
437 #ifdef DEBUG_TIMING
438 struct timeval t;
439
440 do_gettimeofday(&t);
441 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
442 #endif
443 switch (smi_info->si_state) {
444 case SI_NORMAL:
445 if (!smi_info->curr_msg)
446 break;
447
448 smi_info->curr_msg->rsp_size
449 = smi_info->handlers->get_result(
450 smi_info->si_sm,
451 smi_info->curr_msg->rsp,
452 IPMI_MAX_MSG_LENGTH);
453
454 /* Do this here becase deliver_recv_msg() releases the
455 lock, and a new message can be put in during the
456 time the lock is released. */
457 msg = smi_info->curr_msg;
458 smi_info->curr_msg = NULL;
459 deliver_recv_msg(smi_info, msg);
460 break;
461
462 case SI_GETTING_FLAGS:
463 {
464 unsigned char msg[4];
465 unsigned int len;
466
467 /* We got the flags from the SMI, now handle them. */
468 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
469 if (msg[2] != 0) {
470 /* Error fetching flags, just give up for
471 now. */
472 smi_info->si_state = SI_NORMAL;
473 } else if (len < 4) {
474 /* Hmm, no flags. That's technically illegal, but
475 don't use uninitialized data. */
476 smi_info->si_state = SI_NORMAL;
477 } else {
478 smi_info->msg_flags = msg[3];
479 handle_flags(smi_info);
480 }
481 break;
482 }
483
484 case SI_CLEARING_FLAGS:
485 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
486 {
487 unsigned char msg[3];
488
489 /* We cleared the flags. */
490 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
491 if (msg[2] != 0) {
492 /* Error clearing flags */
493 printk(KERN_WARNING
494 "ipmi_si: Error clearing flags: %2.2x\n",
495 msg[2]);
496 }
497 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
498 start_enable_irq(smi_info);
499 else
500 smi_info->si_state = SI_NORMAL;
501 break;
502 }
503
504 case SI_GETTING_EVENTS:
505 {
506 smi_info->curr_msg->rsp_size
507 = smi_info->handlers->get_result(
508 smi_info->si_sm,
509 smi_info->curr_msg->rsp,
510 IPMI_MAX_MSG_LENGTH);
511
512 /* Do this here becase deliver_recv_msg() releases the
513 lock, and a new message can be put in during the
514 time the lock is released. */
515 msg = smi_info->curr_msg;
516 smi_info->curr_msg = NULL;
517 if (msg->rsp[2] != 0) {
518 /* Error getting event, probably done. */
519 msg->done(msg);
520
521 /* Take off the event flag. */
522 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
523 handle_flags(smi_info);
524 } else {
525 spin_lock(&smi_info->count_lock);
526 smi_info->events++;
527 spin_unlock(&smi_info->count_lock);
528
529 /* Do this before we deliver the message
530 because delivering the message releases the
531 lock and something else can mess with the
532 state. */
533 handle_flags(smi_info);
534
535 deliver_recv_msg(smi_info, msg);
536 }
537 break;
538 }
539
540 case SI_GETTING_MESSAGES:
541 {
542 smi_info->curr_msg->rsp_size
543 = smi_info->handlers->get_result(
544 smi_info->si_sm,
545 smi_info->curr_msg->rsp,
546 IPMI_MAX_MSG_LENGTH);
547
548 /* Do this here becase deliver_recv_msg() releases the
549 lock, and a new message can be put in during the
550 time the lock is released. */
551 msg = smi_info->curr_msg;
552 smi_info->curr_msg = NULL;
553 if (msg->rsp[2] != 0) {
554 /* Error getting event, probably done. */
555 msg->done(msg);
556
557 /* Take off the msg flag. */
558 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
559 handle_flags(smi_info);
560 } else {
561 spin_lock(&smi_info->count_lock);
562 smi_info->incoming_messages++;
563 spin_unlock(&smi_info->count_lock);
564
565 /* Do this before we deliver the message
566 because delivering the message releases the
567 lock and something else can mess with the
568 state. */
569 handle_flags(smi_info);
570
571 deliver_recv_msg(smi_info, msg);
572 }
573 break;
574 }
575
576 case SI_ENABLE_INTERRUPTS1:
577 {
578 unsigned char msg[4];
579
580 /* We got the flags from the SMI, now handle them. */
581 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
582 if (msg[2] != 0) {
583 printk(KERN_WARNING
584 "ipmi_si: Could not enable interrupts"
585 ", failed get, using polled mode.\n");
586 smi_info->si_state = SI_NORMAL;
587 } else {
588 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
589 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
590 msg[2] = msg[3] | 1; /* enable msg queue int */
591 smi_info->handlers->start_transaction(
592 smi_info->si_sm, msg, 3);
593 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
594 }
595 break;
596 }
597
598 case SI_ENABLE_INTERRUPTS2:
599 {
600 unsigned char msg[4];
601
602 /* We got the flags from the SMI, now handle them. */
603 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
604 if (msg[2] != 0) {
605 printk(KERN_WARNING
606 "ipmi_si: Could not enable interrupts"
607 ", failed set, using polled mode.\n");
608 }
609 smi_info->si_state = SI_NORMAL;
610 break;
611 }
612 }
613 }
614
615 /* Called on timeouts and events. Timeouts should pass the elapsed
616 time, interrupts should pass in zero. */
617 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
618 int time)
619 {
620 enum si_sm_result si_sm_result;
621
622 restart:
623 /* There used to be a loop here that waited a little while
624 (around 25us) before giving up. That turned out to be
625 pointless, the minimum delays I was seeing were in the 300us
626 range, which is far too long to wait in an interrupt. So
627 we just run until the state machine tells us something
628 happened or it needs a delay. */
629 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
630 time = 0;
631 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
632 {
633 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
634 }
635
636 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
637 {
638 spin_lock(&smi_info->count_lock);
639 smi_info->complete_transactions++;
640 spin_unlock(&smi_info->count_lock);
641
642 handle_transaction_done(smi_info);
643 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
644 }
645 else if (si_sm_result == SI_SM_HOSED)
646 {
647 spin_lock(&smi_info->count_lock);
648 smi_info->hosed_count++;
649 spin_unlock(&smi_info->count_lock);
650
651 /* Do the before return_hosed_msg, because that
652 releases the lock. */
653 smi_info->si_state = SI_NORMAL;
654 if (smi_info->curr_msg != NULL) {
655 /* If we were handling a user message, format
656 a response to send to the upper layer to
657 tell it about the error. */
658 return_hosed_msg(smi_info);
659 }
660 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
661 }
662
663 /* We prefer handling attn over new messages. */
664 if (si_sm_result == SI_SM_ATTN)
665 {
666 unsigned char msg[2];
667
668 spin_lock(&smi_info->count_lock);
669 smi_info->attentions++;
670 spin_unlock(&smi_info->count_lock);
671
672 /* Got a attn, send down a get message flags to see
673 what's causing it. It would be better to handle
674 this in the upper layer, but due to the way
675 interrupts work with the SMI, that's not really
676 possible. */
677 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
678 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
679
680 smi_info->handlers->start_transaction(
681 smi_info->si_sm, msg, 2);
682 smi_info->si_state = SI_GETTING_FLAGS;
683 goto restart;
684 }
685
686 /* If we are currently idle, try to start the next message. */
687 if (si_sm_result == SI_SM_IDLE) {
688 spin_lock(&smi_info->count_lock);
689 smi_info->idles++;
690 spin_unlock(&smi_info->count_lock);
691
692 si_sm_result = start_next_msg(smi_info);
693 if (si_sm_result != SI_SM_IDLE)
694 goto restart;
695 }
696
697 if ((si_sm_result == SI_SM_IDLE)
698 && (atomic_read(&smi_info->req_events)))
699 {
700 /* We are idle and the upper layer requested that I fetch
701 events, so do so. */
702 unsigned char msg[2];
703
704 spin_lock(&smi_info->count_lock);
705 smi_info->flag_fetches++;
706 spin_unlock(&smi_info->count_lock);
707
708 atomic_set(&smi_info->req_events, 0);
709 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
710 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
711
712 smi_info->handlers->start_transaction(
713 smi_info->si_sm, msg, 2);
714 smi_info->si_state = SI_GETTING_FLAGS;
715 goto restart;
716 }
717
718 return si_sm_result;
719 }
720
721 static void sender(void *send_info,
722 struct ipmi_smi_msg *msg,
723 int priority)
724 {
725 struct smi_info *smi_info = send_info;
726 enum si_sm_result result;
727 unsigned long flags;
728 #ifdef DEBUG_TIMING
729 struct timeval t;
730 #endif
731
732 spin_lock_irqsave(&(smi_info->msg_lock), flags);
733 #ifdef DEBUG_TIMING
734 do_gettimeofday(&t);
735 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
736 #endif
737
738 if (smi_info->run_to_completion) {
739 /* If we are running to completion, then throw it in
740 the list and run transactions until everything is
741 clear. Priority doesn't matter here. */
742 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
743
744 /* We have to release the msg lock and claim the smi
745 lock in this case, because of race conditions. */
746 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
747
748 spin_lock_irqsave(&(smi_info->si_lock), flags);
749 result = smi_event_handler(smi_info, 0);
750 while (result != SI_SM_IDLE) {
751 udelay(SI_SHORT_TIMEOUT_USEC);
752 result = smi_event_handler(smi_info,
753 SI_SHORT_TIMEOUT_USEC);
754 }
755 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
756 return;
757 } else {
758 if (priority > 0) {
759 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
760 } else {
761 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
762 }
763 }
764 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
765
766 spin_lock_irqsave(&(smi_info->si_lock), flags);
767 if ((smi_info->si_state == SI_NORMAL)
768 && (smi_info->curr_msg == NULL))
769 {
770 start_next_msg(smi_info);
771 si_restart_short_timer(smi_info);
772 }
773 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
774 }
775
776 static void set_run_to_completion(void *send_info, int i_run_to_completion)
777 {
778 struct smi_info *smi_info = send_info;
779 enum si_sm_result result;
780 unsigned long flags;
781
782 spin_lock_irqsave(&(smi_info->si_lock), flags);
783
784 smi_info->run_to_completion = i_run_to_completion;
785 if (i_run_to_completion) {
786 result = smi_event_handler(smi_info, 0);
787 while (result != SI_SM_IDLE) {
788 udelay(SI_SHORT_TIMEOUT_USEC);
789 result = smi_event_handler(smi_info,
790 SI_SHORT_TIMEOUT_USEC);
791 }
792 }
793
794 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
795 }
796
797 static int ipmi_thread(void *data)
798 {
799 struct smi_info *smi_info = data;
800 unsigned long flags;
801 enum si_sm_result smi_result;
802
803 set_user_nice(current, 19);
804 while (!kthread_should_stop()) {
805 spin_lock_irqsave(&(smi_info->si_lock), flags);
806 smi_result = smi_event_handler(smi_info, 0);
807 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
808 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
809 /* do nothing */
810 }
811 else if (smi_result == SI_SM_CALL_WITH_DELAY)
812 udelay(1);
813 else
814 schedule_timeout_interruptible(1);
815 }
816 return 0;
817 }
818
819
820 static void poll(void *send_info)
821 {
822 struct smi_info *smi_info = send_info;
823
824 smi_event_handler(smi_info, 0);
825 }
826
827 static void request_events(void *send_info)
828 {
829 struct smi_info *smi_info = send_info;
830
831 atomic_set(&smi_info->req_events, 1);
832 }
833
834 static int initialized = 0;
835
836 /* Must be called with interrupts off and with the si_lock held. */
837 static void si_restart_short_timer(struct smi_info *smi_info)
838 {
839 #if defined(CONFIG_HIGH_RES_TIMERS)
840 unsigned long flags;
841 unsigned long jiffies_now;
842 unsigned long seq;
843
844 if (del_timer(&(smi_info->si_timer))) {
845 /* If we don't delete the timer, then it will go off
846 immediately, anyway. So we only process if we
847 actually delete the timer. */
848
849 do {
850 seq = read_seqbegin_irqsave(&xtime_lock, flags);
851 jiffies_now = jiffies;
852 smi_info->si_timer.expires = jiffies_now;
853 smi_info->si_timer.arch_cycle_expires
854 = get_arch_cycles(jiffies_now);
855 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
856
857 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
858
859 add_timer(&(smi_info->si_timer));
860 spin_lock_irqsave(&smi_info->count_lock, flags);
861 smi_info->timeout_restarts++;
862 spin_unlock_irqrestore(&smi_info->count_lock, flags);
863 }
864 #endif
865 }
866
867 static void smi_timeout(unsigned long data)
868 {
869 struct smi_info *smi_info = (struct smi_info *) data;
870 enum si_sm_result smi_result;
871 unsigned long flags;
872 unsigned long jiffies_now;
873 long time_diff;
874 #ifdef DEBUG_TIMING
875 struct timeval t;
876 #endif
877
878 if (atomic_read(&smi_info->stop_operation))
879 return;
880
881 spin_lock_irqsave(&(smi_info->si_lock), flags);
882 #ifdef DEBUG_TIMING
883 do_gettimeofday(&t);
884 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
885 #endif
886 jiffies_now = jiffies;
887 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
888 * SI_USEC_PER_JIFFY);
889 smi_result = smi_event_handler(smi_info, time_diff);
890
891 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
892
893 smi_info->last_timeout_jiffies = jiffies_now;
894
895 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
896 /* Running with interrupts, only do long timeouts. */
897 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
898 spin_lock_irqsave(&smi_info->count_lock, flags);
899 smi_info->long_timeouts++;
900 spin_unlock_irqrestore(&smi_info->count_lock, flags);
901 goto do_add_timer;
902 }
903
904 /* If the state machine asks for a short delay, then shorten
905 the timer timeout. */
906 if (smi_result == SI_SM_CALL_WITH_DELAY) {
907 #if defined(CONFIG_HIGH_RES_TIMERS)
908 unsigned long seq;
909 #endif
910 spin_lock_irqsave(&smi_info->count_lock, flags);
911 smi_info->short_timeouts++;
912 spin_unlock_irqrestore(&smi_info->count_lock, flags);
913 #if defined(CONFIG_HIGH_RES_TIMERS)
914 do {
915 seq = read_seqbegin_irqsave(&xtime_lock, flags);
916 smi_info->si_timer.expires = jiffies;
917 smi_info->si_timer.arch_cycle_expires
918 = get_arch_cycles(smi_info->si_timer.expires);
919 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
920 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
921 #else
922 smi_info->si_timer.expires = jiffies + 1;
923 #endif
924 } else {
925 spin_lock_irqsave(&smi_info->count_lock, flags);
926 smi_info->long_timeouts++;
927 spin_unlock_irqrestore(&smi_info->count_lock, flags);
928 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
929 #if defined(CONFIG_HIGH_RES_TIMERS)
930 smi_info->si_timer.arch_cycle_expires = 0;
931 #endif
932 }
933
934 do_add_timer:
935 add_timer(&(smi_info->si_timer));
936 }
937
938 static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
939 {
940 struct smi_info *smi_info = data;
941 unsigned long flags;
942 #ifdef DEBUG_TIMING
943 struct timeval t;
944 #endif
945
946 spin_lock_irqsave(&(smi_info->si_lock), flags);
947
948 spin_lock(&smi_info->count_lock);
949 smi_info->interrupts++;
950 spin_unlock(&smi_info->count_lock);
951
952 if (atomic_read(&smi_info->stop_operation))
953 goto out;
954
955 #ifdef DEBUG_TIMING
956 do_gettimeofday(&t);
957 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
958 #endif
959 smi_event_handler(smi_info, 0);
960 out:
961 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
962 return IRQ_HANDLED;
963 }
964
965 static irqreturn_t si_bt_irq_handler(int irq, void *data, struct pt_regs *regs)
966 {
967 struct smi_info *smi_info = data;
968 /* We need to clear the IRQ flag for the BT interface. */
969 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
970 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
971 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
972 return si_irq_handler(irq, data, regs);
973 }
974
975 static int smi_start_processing(void *send_info,
976 ipmi_smi_t intf)
977 {
978 struct smi_info *new_smi = send_info;
979
980 new_smi->intf = intf;
981
982 /* Set up the timer that drives the interface. */
983 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
984 new_smi->last_timeout_jiffies = jiffies;
985 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
986
987 if (new_smi->si_type != SI_BT) {
988 new_smi->thread = kthread_run(ipmi_thread, new_smi,
989 "kipmi%d", new_smi->intf_num);
990 if (IS_ERR(new_smi->thread)) {
991 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
992 " kernel thread due to error %ld, only using"
993 " timers to drive the interface\n",
994 PTR_ERR(new_smi->thread));
995 new_smi->thread = NULL;
996 }
997 }
998
999 return 0;
1000 }
1001
1002 static struct ipmi_smi_handlers handlers =
1003 {
1004 .owner = THIS_MODULE,
1005 .start_processing = smi_start_processing,
1006 .sender = sender,
1007 .request_events = request_events,
1008 .set_run_to_completion = set_run_to_completion,
1009 .poll = poll,
1010 };
1011
1012 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1013 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
1014
1015 #define SI_MAX_PARMS 4
1016 static LIST_HEAD(smi_infos);
1017 static DEFINE_MUTEX(smi_infos_lock);
1018 static int smi_num; /* Used to sequence the SMIs */
1019
1020 #define DEFAULT_REGSPACING 1
1021
1022 static int si_trydefaults = 1;
1023 static char *si_type[SI_MAX_PARMS];
1024 #define MAX_SI_TYPE_STR 30
1025 static char si_type_str[MAX_SI_TYPE_STR];
1026 static unsigned long addrs[SI_MAX_PARMS];
1027 static int num_addrs;
1028 static unsigned int ports[SI_MAX_PARMS];
1029 static int num_ports;
1030 static int irqs[SI_MAX_PARMS];
1031 static int num_irqs;
1032 static int regspacings[SI_MAX_PARMS];
1033 static int num_regspacings = 0;
1034 static int regsizes[SI_MAX_PARMS];
1035 static int num_regsizes = 0;
1036 static int regshifts[SI_MAX_PARMS];
1037 static int num_regshifts = 0;
1038 static int slave_addrs[SI_MAX_PARMS];
1039 static int num_slave_addrs = 0;
1040
1041
1042 module_param_named(trydefaults, si_trydefaults, bool, 0);
1043 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1044 " default scan of the KCS and SMIC interface at the standard"
1045 " address");
1046 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1047 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1048 " interface separated by commas. The types are 'kcs',"
1049 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1050 " the first interface to kcs and the second to bt");
1051 module_param_array(addrs, long, &num_addrs, 0);
1052 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1053 " addresses separated by commas. Only use if an interface"
1054 " is in memory. Otherwise, set it to zero or leave"
1055 " it blank.");
1056 module_param_array(ports, int, &num_ports, 0);
1057 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1058 " addresses separated by commas. Only use if an interface"
1059 " is a port. Otherwise, set it to zero or leave"
1060 " it blank.");
1061 module_param_array(irqs, int, &num_irqs, 0);
1062 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1063 " addresses separated by commas. Only use if an interface"
1064 " has an interrupt. Otherwise, set it to zero or leave"
1065 " it blank.");
1066 module_param_array(regspacings, int, &num_regspacings, 0);
1067 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1068 " and each successive register used by the interface. For"
1069 " instance, if the start address is 0xca2 and the spacing"
1070 " is 2, then the second address is at 0xca4. Defaults"
1071 " to 1.");
1072 module_param_array(regsizes, int, &num_regsizes, 0);
1073 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1074 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1075 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1076 " the 8-bit IPMI register has to be read from a larger"
1077 " register.");
1078 module_param_array(regshifts, int, &num_regshifts, 0);
1079 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1080 " IPMI register, in bits. For instance, if the data"
1081 " is read from a 32-bit word and the IPMI data is in"
1082 " bit 8-15, then the shift would be 8");
1083 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1084 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1085 " the controller. Normally this is 0x20, but can be"
1086 " overridden by this parm. This is an array indexed"
1087 " by interface number.");
1088
1089
1090 #define IPMI_IO_ADDR_SPACE 0
1091 #define IPMI_MEM_ADDR_SPACE 1
1092 static char *addr_space_to_str[] = { "I/O", "memory" };
1093
1094 static void std_irq_cleanup(struct smi_info *info)
1095 {
1096 if (info->si_type == SI_BT)
1097 /* Disable the interrupt in the BT interface. */
1098 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1099 free_irq(info->irq, info);
1100 }
1101
1102 static int std_irq_setup(struct smi_info *info)
1103 {
1104 int rv;
1105
1106 if (!info->irq)
1107 return 0;
1108
1109 if (info->si_type == SI_BT) {
1110 rv = request_irq(info->irq,
1111 si_bt_irq_handler,
1112 SA_INTERRUPT,
1113 DEVICE_NAME,
1114 info);
1115 if (!rv)
1116 /* Enable the interrupt in the BT interface. */
1117 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1118 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1119 } else
1120 rv = request_irq(info->irq,
1121 si_irq_handler,
1122 SA_INTERRUPT,
1123 DEVICE_NAME,
1124 info);
1125 if (rv) {
1126 printk(KERN_WARNING
1127 "ipmi_si: %s unable to claim interrupt %d,"
1128 " running polled\n",
1129 DEVICE_NAME, info->irq);
1130 info->irq = 0;
1131 } else {
1132 info->irq_cleanup = std_irq_cleanup;
1133 printk(" Using irq %d\n", info->irq);
1134 }
1135
1136 return rv;
1137 }
1138
1139 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1140 {
1141 unsigned int addr = io->addr_data;
1142
1143 return inb(addr + (offset * io->regspacing));
1144 }
1145
1146 static void port_outb(struct si_sm_io *io, unsigned int offset,
1147 unsigned char b)
1148 {
1149 unsigned int addr = io->addr_data;
1150
1151 outb(b, addr + (offset * io->regspacing));
1152 }
1153
1154 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1155 {
1156 unsigned int addr = io->addr_data;
1157
1158 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1159 }
1160
1161 static void port_outw(struct si_sm_io *io, unsigned int offset,
1162 unsigned char b)
1163 {
1164 unsigned int addr = io->addr_data;
1165
1166 outw(b << io->regshift, addr + (offset * io->regspacing));
1167 }
1168
1169 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1170 {
1171 unsigned int addr = io->addr_data;
1172
1173 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1174 }
1175
1176 static void port_outl(struct si_sm_io *io, unsigned int offset,
1177 unsigned char b)
1178 {
1179 unsigned int addr = io->addr_data;
1180
1181 outl(b << io->regshift, addr+(offset * io->regspacing));
1182 }
1183
1184 static void port_cleanup(struct smi_info *info)
1185 {
1186 unsigned int addr = info->io.addr_data;
1187 int idx;
1188
1189 if (addr) {
1190 for (idx = 0; idx < info->io_size; idx++) {
1191 release_region(addr + idx * info->io.regspacing,
1192 info->io.regsize);
1193 }
1194 }
1195 }
1196
1197 static int port_setup(struct smi_info *info)
1198 {
1199 unsigned int addr = info->io.addr_data;
1200 int idx;
1201
1202 if (!addr)
1203 return -ENODEV;
1204
1205 info->io_cleanup = port_cleanup;
1206
1207 /* Figure out the actual inb/inw/inl/etc routine to use based
1208 upon the register size. */
1209 switch (info->io.regsize) {
1210 case 1:
1211 info->io.inputb = port_inb;
1212 info->io.outputb = port_outb;
1213 break;
1214 case 2:
1215 info->io.inputb = port_inw;
1216 info->io.outputb = port_outw;
1217 break;
1218 case 4:
1219 info->io.inputb = port_inl;
1220 info->io.outputb = port_outl;
1221 break;
1222 default:
1223 printk("ipmi_si: Invalid register size: %d\n",
1224 info->io.regsize);
1225 return -EINVAL;
1226 }
1227
1228 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1229 * tables. This causes problems when trying to register the
1230 * entire I/O region. Therefore we must register each I/O
1231 * port separately.
1232 */
1233 for (idx = 0; idx < info->io_size; idx++) {
1234 if (request_region(addr + idx * info->io.regspacing,
1235 info->io.regsize, DEVICE_NAME) == NULL) {
1236 /* Undo allocations */
1237 while (idx--) {
1238 release_region(addr + idx * info->io.regspacing,
1239 info->io.regsize);
1240 }
1241 return -EIO;
1242 }
1243 }
1244 return 0;
1245 }
1246
1247 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1248 {
1249 return readb((io->addr)+(offset * io->regspacing));
1250 }
1251
1252 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1253 unsigned char b)
1254 {
1255 writeb(b, (io->addr)+(offset * io->regspacing));
1256 }
1257
1258 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1259 {
1260 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1261 && 0xff;
1262 }
1263
1264 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1265 unsigned char b)
1266 {
1267 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1268 }
1269
1270 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1271 {
1272 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1273 && 0xff;
1274 }
1275
1276 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1277 unsigned char b)
1278 {
1279 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1280 }
1281
1282 #ifdef readq
1283 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1284 {
1285 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1286 && 0xff;
1287 }
1288
1289 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1290 unsigned char b)
1291 {
1292 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1293 }
1294 #endif
1295
1296 static void mem_cleanup(struct smi_info *info)
1297 {
1298 unsigned long addr = info->io.addr_data;
1299 int mapsize;
1300
1301 if (info->io.addr) {
1302 iounmap(info->io.addr);
1303
1304 mapsize = ((info->io_size * info->io.regspacing)
1305 - (info->io.regspacing - info->io.regsize));
1306
1307 release_mem_region(addr, mapsize);
1308 }
1309 }
1310
1311 static int mem_setup(struct smi_info *info)
1312 {
1313 unsigned long addr = info->io.addr_data;
1314 int mapsize;
1315
1316 if (!addr)
1317 return -ENODEV;
1318
1319 info->io_cleanup = mem_cleanup;
1320
1321 /* Figure out the actual readb/readw/readl/etc routine to use based
1322 upon the register size. */
1323 switch (info->io.regsize) {
1324 case 1:
1325 info->io.inputb = intf_mem_inb;
1326 info->io.outputb = intf_mem_outb;
1327 break;
1328 case 2:
1329 info->io.inputb = intf_mem_inw;
1330 info->io.outputb = intf_mem_outw;
1331 break;
1332 case 4:
1333 info->io.inputb = intf_mem_inl;
1334 info->io.outputb = intf_mem_outl;
1335 break;
1336 #ifdef readq
1337 case 8:
1338 info->io.inputb = mem_inq;
1339 info->io.outputb = mem_outq;
1340 break;
1341 #endif
1342 default:
1343 printk("ipmi_si: Invalid register size: %d\n",
1344 info->io.regsize);
1345 return -EINVAL;
1346 }
1347
1348 /* Calculate the total amount of memory to claim. This is an
1349 * unusual looking calculation, but it avoids claiming any
1350 * more memory than it has to. It will claim everything
1351 * between the first address to the end of the last full
1352 * register. */
1353 mapsize = ((info->io_size * info->io.regspacing)
1354 - (info->io.regspacing - info->io.regsize));
1355
1356 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1357 return -EIO;
1358
1359 info->io.addr = ioremap(addr, mapsize);
1360 if (info->io.addr == NULL) {
1361 release_mem_region(addr, mapsize);
1362 return -EIO;
1363 }
1364 return 0;
1365 }
1366
1367
1368 static __devinit void hardcode_find_bmc(void)
1369 {
1370 int i;
1371 struct smi_info *info;
1372
1373 for (i = 0; i < SI_MAX_PARMS; i++) {
1374 if (!ports[i] && !addrs[i])
1375 continue;
1376
1377 info = kzalloc(sizeof(*info), GFP_KERNEL);
1378 if (!info)
1379 return;
1380
1381 info->addr_source = "hardcoded";
1382
1383 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1384 info->si_type = SI_KCS;
1385 } else if (strcmp(si_type[i], "smic") == 0) {
1386 info->si_type = SI_SMIC;
1387 } else if (strcmp(si_type[i], "bt") == 0) {
1388 info->si_type = SI_BT;
1389 } else {
1390 printk(KERN_WARNING
1391 "ipmi_si: Interface type specified "
1392 "for interface %d, was invalid: %s\n",
1393 i, si_type[i]);
1394 kfree(info);
1395 continue;
1396 }
1397
1398 if (ports[i]) {
1399 /* An I/O port */
1400 info->io_setup = port_setup;
1401 info->io.addr_data = ports[i];
1402 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1403 } else if (addrs[i]) {
1404 /* A memory port */
1405 info->io_setup = mem_setup;
1406 info->io.addr_data = addrs[i];
1407 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1408 } else {
1409 printk(KERN_WARNING
1410 "ipmi_si: Interface type specified "
1411 "for interface %d, "
1412 "but port and address were not set or "
1413 "set to zero.\n", i);
1414 kfree(info);
1415 continue;
1416 }
1417
1418 info->io.addr = NULL;
1419 info->io.regspacing = regspacings[i];
1420 if (!info->io.regspacing)
1421 info->io.regspacing = DEFAULT_REGSPACING;
1422 info->io.regsize = regsizes[i];
1423 if (!info->io.regsize)
1424 info->io.regsize = DEFAULT_REGSPACING;
1425 info->io.regshift = regshifts[i];
1426 info->irq = irqs[i];
1427 if (info->irq)
1428 info->irq_setup = std_irq_setup;
1429
1430 try_smi_init(info);
1431 }
1432 }
1433
1434 #ifdef CONFIG_ACPI
1435
1436 #include <linux/acpi.h>
1437
1438 /* Once we get an ACPI failure, we don't try any more, because we go
1439 through the tables sequentially. Once we don't find a table, there
1440 are no more. */
1441 static int acpi_failure = 0;
1442
1443 /* For GPE-type interrupts. */
1444 static u32 ipmi_acpi_gpe(void *context)
1445 {
1446 struct smi_info *smi_info = context;
1447 unsigned long flags;
1448 #ifdef DEBUG_TIMING
1449 struct timeval t;
1450 #endif
1451
1452 spin_lock_irqsave(&(smi_info->si_lock), flags);
1453
1454 spin_lock(&smi_info->count_lock);
1455 smi_info->interrupts++;
1456 spin_unlock(&smi_info->count_lock);
1457
1458 if (atomic_read(&smi_info->stop_operation))
1459 goto out;
1460
1461 #ifdef DEBUG_TIMING
1462 do_gettimeofday(&t);
1463 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1464 #endif
1465 smi_event_handler(smi_info, 0);
1466 out:
1467 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1468
1469 return ACPI_INTERRUPT_HANDLED;
1470 }
1471
1472 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1473 {
1474 if (!info->irq)
1475 return;
1476
1477 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1478 }
1479
1480 static int acpi_gpe_irq_setup(struct smi_info *info)
1481 {
1482 acpi_status status;
1483
1484 if (!info->irq)
1485 return 0;
1486
1487 /* FIXME - is level triggered right? */
1488 status = acpi_install_gpe_handler(NULL,
1489 info->irq,
1490 ACPI_GPE_LEVEL_TRIGGERED,
1491 &ipmi_acpi_gpe,
1492 info);
1493 if (status != AE_OK) {
1494 printk(KERN_WARNING
1495 "ipmi_si: %s unable to claim ACPI GPE %d,"
1496 " running polled\n",
1497 DEVICE_NAME, info->irq);
1498 info->irq = 0;
1499 return -EINVAL;
1500 } else {
1501 info->irq_cleanup = acpi_gpe_irq_cleanup;
1502 printk(" Using ACPI GPE %d\n", info->irq);
1503 return 0;
1504 }
1505 }
1506
1507 /*
1508 * Defined at
1509 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1510 */
1511 struct SPMITable {
1512 s8 Signature[4];
1513 u32 Length;
1514 u8 Revision;
1515 u8 Checksum;
1516 s8 OEMID[6];
1517 s8 OEMTableID[8];
1518 s8 OEMRevision[4];
1519 s8 CreatorID[4];
1520 s8 CreatorRevision[4];
1521 u8 InterfaceType;
1522 u8 IPMIlegacy;
1523 s16 SpecificationRevision;
1524
1525 /*
1526 * Bit 0 - SCI interrupt supported
1527 * Bit 1 - I/O APIC/SAPIC
1528 */
1529 u8 InterruptType;
1530
1531 /* If bit 0 of InterruptType is set, then this is the SCI
1532 interrupt in the GPEx_STS register. */
1533 u8 GPE;
1534
1535 s16 Reserved;
1536
1537 /* If bit 1 of InterruptType is set, then this is the I/O
1538 APIC/SAPIC interrupt. */
1539 u32 GlobalSystemInterrupt;
1540
1541 /* The actual register address. */
1542 struct acpi_generic_address addr;
1543
1544 u8 UID[4];
1545
1546 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1547 };
1548
1549 static __devinit int try_init_acpi(struct SPMITable *spmi)
1550 {
1551 struct smi_info *info;
1552 char *io_type;
1553 u8 addr_space;
1554
1555 if (spmi->IPMIlegacy != 1) {
1556 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1557 return -ENODEV;
1558 }
1559
1560 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1561 addr_space = IPMI_MEM_ADDR_SPACE;
1562 else
1563 addr_space = IPMI_IO_ADDR_SPACE;
1564
1565 info = kzalloc(sizeof(*info), GFP_KERNEL);
1566 if (!info) {
1567 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1568 return -ENOMEM;
1569 }
1570
1571 info->addr_source = "ACPI";
1572
1573 /* Figure out the interface type. */
1574 switch (spmi->InterfaceType)
1575 {
1576 case 1: /* KCS */
1577 info->si_type = SI_KCS;
1578 break;
1579 case 2: /* SMIC */
1580 info->si_type = SI_SMIC;
1581 break;
1582 case 3: /* BT */
1583 info->si_type = SI_BT;
1584 break;
1585 default:
1586 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1587 spmi->InterfaceType);
1588 kfree(info);
1589 return -EIO;
1590 }
1591
1592 if (spmi->InterruptType & 1) {
1593 /* We've got a GPE interrupt. */
1594 info->irq = spmi->GPE;
1595 info->irq_setup = acpi_gpe_irq_setup;
1596 } else if (spmi->InterruptType & 2) {
1597 /* We've got an APIC/SAPIC interrupt. */
1598 info->irq = spmi->GlobalSystemInterrupt;
1599 info->irq_setup = std_irq_setup;
1600 } else {
1601 /* Use the default interrupt setting. */
1602 info->irq = 0;
1603 info->irq_setup = NULL;
1604 }
1605
1606 if (spmi->addr.register_bit_width) {
1607 /* A (hopefully) properly formed register bit width. */
1608 info->io.regspacing = spmi->addr.register_bit_width / 8;
1609 } else {
1610 info->io.regspacing = DEFAULT_REGSPACING;
1611 }
1612 info->io.regsize = info->io.regspacing;
1613 info->io.regshift = spmi->addr.register_bit_offset;
1614
1615 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1616 io_type = "memory";
1617 info->io_setup = mem_setup;
1618 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1619 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1620 io_type = "I/O";
1621 info->io_setup = port_setup;
1622 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1623 } else {
1624 kfree(info);
1625 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1626 return -EIO;
1627 }
1628 info->io.addr_data = spmi->addr.address;
1629
1630 try_smi_init(info);
1631
1632 return 0;
1633 }
1634
1635 static __devinit void acpi_find_bmc(void)
1636 {
1637 acpi_status status;
1638 struct SPMITable *spmi;
1639 int i;
1640
1641 if (acpi_disabled)
1642 return;
1643
1644 if (acpi_failure)
1645 return;
1646
1647 for (i = 0; ; i++) {
1648 status = acpi_get_firmware_table("SPMI", i+1,
1649 ACPI_LOGICAL_ADDRESSING,
1650 (struct acpi_table_header **)
1651 &spmi);
1652 if (status != AE_OK)
1653 return;
1654
1655 try_init_acpi(spmi);
1656 }
1657 }
1658 #endif
1659
1660 #ifdef CONFIG_DMI
1661 struct dmi_ipmi_data
1662 {
1663 u8 type;
1664 u8 addr_space;
1665 unsigned long base_addr;
1666 u8 irq;
1667 u8 offset;
1668 u8 slave_addr;
1669 };
1670
1671 static int __devinit decode_dmi(struct dmi_header *dm,
1672 struct dmi_ipmi_data *dmi)
1673 {
1674 u8 *data = (u8 *)dm;
1675 unsigned long base_addr;
1676 u8 reg_spacing;
1677 u8 len = dm->length;
1678
1679 dmi->type = data[4];
1680
1681 memcpy(&base_addr, data+8, sizeof(unsigned long));
1682 if (len >= 0x11) {
1683 if (base_addr & 1) {
1684 /* I/O */
1685 base_addr &= 0xFFFE;
1686 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1687 }
1688 else {
1689 /* Memory */
1690 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1691 }
1692 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1693 is odd. */
1694 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1695
1696 dmi->irq = data[0x11];
1697
1698 /* The top two bits of byte 0x10 hold the register spacing. */
1699 reg_spacing = (data[0x10] & 0xC0) >> 6;
1700 switch(reg_spacing){
1701 case 0x00: /* Byte boundaries */
1702 dmi->offset = 1;
1703 break;
1704 case 0x01: /* 32-bit boundaries */
1705 dmi->offset = 4;
1706 break;
1707 case 0x02: /* 16-byte boundaries */
1708 dmi->offset = 16;
1709 break;
1710 default:
1711 /* Some other interface, just ignore it. */
1712 return -EIO;
1713 }
1714 } else {
1715 /* Old DMI spec. */
1716 /* Note that technically, the lower bit of the base
1717 * address should be 1 if the address is I/O and 0 if
1718 * the address is in memory. So many systems get that
1719 * wrong (and all that I have seen are I/O) so we just
1720 * ignore that bit and assume I/O. Systems that use
1721 * memory should use the newer spec, anyway. */
1722 dmi->base_addr = base_addr & 0xfffe;
1723 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1724 dmi->offset = 1;
1725 }
1726
1727 dmi->slave_addr = data[6];
1728
1729 return 0;
1730 }
1731
1732 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1733 {
1734 struct smi_info *info;
1735
1736 info = kzalloc(sizeof(*info), GFP_KERNEL);
1737 if (!info) {
1738 printk(KERN_ERR
1739 "ipmi_si: Could not allocate SI data\n");
1740 return;
1741 }
1742
1743 info->addr_source = "SMBIOS";
1744
1745 switch (ipmi_data->type) {
1746 case 0x01: /* KCS */
1747 info->si_type = SI_KCS;
1748 break;
1749 case 0x02: /* SMIC */
1750 info->si_type = SI_SMIC;
1751 break;
1752 case 0x03: /* BT */
1753 info->si_type = SI_BT;
1754 break;
1755 default:
1756 return;
1757 }
1758
1759 switch (ipmi_data->addr_space) {
1760 case IPMI_MEM_ADDR_SPACE:
1761 info->io_setup = mem_setup;
1762 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1763 break;
1764
1765 case IPMI_IO_ADDR_SPACE:
1766 info->io_setup = port_setup;
1767 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1768 break;
1769
1770 default:
1771 kfree(info);
1772 printk(KERN_WARNING
1773 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1774 ipmi_data->addr_space);
1775 return;
1776 }
1777 info->io.addr_data = ipmi_data->base_addr;
1778
1779 info->io.regspacing = ipmi_data->offset;
1780 if (!info->io.regspacing)
1781 info->io.regspacing = DEFAULT_REGSPACING;
1782 info->io.regsize = DEFAULT_REGSPACING;
1783 info->io.regshift = 0;
1784
1785 info->slave_addr = ipmi_data->slave_addr;
1786
1787 info->irq = ipmi_data->irq;
1788 if (info->irq)
1789 info->irq_setup = std_irq_setup;
1790
1791 try_smi_init(info);
1792 }
1793
1794 static void __devinit dmi_find_bmc(void)
1795 {
1796 struct dmi_device *dev = NULL;
1797 struct dmi_ipmi_data data;
1798 int rv;
1799
1800 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1801 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1802 if (!rv)
1803 try_init_dmi(&data);
1804 }
1805 }
1806 #endif /* CONFIG_DMI */
1807
1808 #ifdef CONFIG_PCI
1809
1810 #define PCI_ERMC_CLASSCODE 0x0C0700
1811 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1812 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1813 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1814 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1815 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1816
1817 #define PCI_HP_VENDOR_ID 0x103C
1818 #define PCI_MMC_DEVICE_ID 0x121A
1819 #define PCI_MMC_ADDR_CW 0x10
1820
1821 static void ipmi_pci_cleanup(struct smi_info *info)
1822 {
1823 struct pci_dev *pdev = info->addr_source_data;
1824
1825 pci_disable_device(pdev);
1826 }
1827
1828 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1829 const struct pci_device_id *ent)
1830 {
1831 int rv;
1832 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1833 struct smi_info *info;
1834 int first_reg_offset = 0;
1835
1836 info = kzalloc(sizeof(*info), GFP_KERNEL);
1837 if (!info)
1838 return ENOMEM;
1839
1840 info->addr_source = "PCI";
1841
1842 switch (class_type) {
1843 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1844 info->si_type = SI_SMIC;
1845 break;
1846
1847 case PCI_ERMC_CLASSCODE_TYPE_KCS:
1848 info->si_type = SI_KCS;
1849 break;
1850
1851 case PCI_ERMC_CLASSCODE_TYPE_BT:
1852 info->si_type = SI_BT;
1853 break;
1854
1855 default:
1856 kfree(info);
1857 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1858 pci_name(pdev), class_type);
1859 return ENOMEM;
1860 }
1861
1862 rv = pci_enable_device(pdev);
1863 if (rv) {
1864 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1865 pci_name(pdev));
1866 kfree(info);
1867 return rv;
1868 }
1869
1870 info->addr_source_cleanup = ipmi_pci_cleanup;
1871 info->addr_source_data = pdev;
1872
1873 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1874 first_reg_offset = 1;
1875
1876 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1877 info->io_setup = port_setup;
1878 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1879 } else {
1880 info->io_setup = mem_setup;
1881 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1882 }
1883 info->io.addr_data = pci_resource_start(pdev, 0);
1884
1885 info->io.regspacing = DEFAULT_REGSPACING;
1886 info->io.regsize = DEFAULT_REGSPACING;
1887 info->io.regshift = 0;
1888
1889 info->irq = pdev->irq;
1890 if (info->irq)
1891 info->irq_setup = std_irq_setup;
1892
1893 info->dev = &pdev->dev;
1894
1895 return try_smi_init(info);
1896 }
1897
1898 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1899 {
1900 }
1901
1902 #ifdef CONFIG_PM
1903 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1904 {
1905 return 0;
1906 }
1907
1908 static int ipmi_pci_resume(struct pci_dev *pdev)
1909 {
1910 return 0;
1911 }
1912 #endif
1913
1914 static struct pci_device_id ipmi_pci_devices[] = {
1915 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1916 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE) }
1917 };
1918 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1919
1920 static struct pci_driver ipmi_pci_driver = {
1921 .name = DEVICE_NAME,
1922 .id_table = ipmi_pci_devices,
1923 .probe = ipmi_pci_probe,
1924 .remove = __devexit_p(ipmi_pci_remove),
1925 #ifdef CONFIG_PM
1926 .suspend = ipmi_pci_suspend,
1927 .resume = ipmi_pci_resume,
1928 #endif
1929 };
1930 #endif /* CONFIG_PCI */
1931
1932
1933 static int try_get_dev_id(struct smi_info *smi_info)
1934 {
1935 unsigned char msg[2];
1936 unsigned char *resp;
1937 unsigned long resp_len;
1938 enum si_sm_result smi_result;
1939 int rv = 0;
1940
1941 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1942 if (!resp)
1943 return -ENOMEM;
1944
1945 /* Do a Get Device ID command, since it comes back with some
1946 useful info. */
1947 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1948 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1949 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1950
1951 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1952 for (;;)
1953 {
1954 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1955 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1956 schedule_timeout_uninterruptible(1);
1957 smi_result = smi_info->handlers->event(
1958 smi_info->si_sm, 100);
1959 }
1960 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1961 {
1962 smi_result = smi_info->handlers->event(
1963 smi_info->si_sm, 0);
1964 }
1965 else
1966 break;
1967 }
1968 if (smi_result == SI_SM_HOSED) {
1969 /* We couldn't get the state machine to run, so whatever's at
1970 the port is probably not an IPMI SMI interface. */
1971 rv = -ENODEV;
1972 goto out;
1973 }
1974
1975 /* Otherwise, we got some data. */
1976 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1977 resp, IPMI_MAX_MSG_LENGTH);
1978 if (resp_len < 14) {
1979 /* That's odd, it should be longer. */
1980 rv = -EINVAL;
1981 goto out;
1982 }
1983
1984 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1985 /* That's odd, it shouldn't be able to fail. */
1986 rv = -EINVAL;
1987 goto out;
1988 }
1989
1990 /* Record info from the get device id, in case we need it. */
1991 ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1992
1993 out:
1994 kfree(resp);
1995 return rv;
1996 }
1997
1998 static int type_file_read_proc(char *page, char **start, off_t off,
1999 int count, int *eof, void *data)
2000 {
2001 char *out = (char *) page;
2002 struct smi_info *smi = data;
2003
2004 switch (smi->si_type) {
2005 case SI_KCS:
2006 return sprintf(out, "kcs\n");
2007 case SI_SMIC:
2008 return sprintf(out, "smic\n");
2009 case SI_BT:
2010 return sprintf(out, "bt\n");
2011 default:
2012 return 0;
2013 }
2014 }
2015
2016 static int stat_file_read_proc(char *page, char **start, off_t off,
2017 int count, int *eof, void *data)
2018 {
2019 char *out = (char *) page;
2020 struct smi_info *smi = data;
2021
2022 out += sprintf(out, "interrupts_enabled: %d\n",
2023 smi->irq && !smi->interrupt_disabled);
2024 out += sprintf(out, "short_timeouts: %ld\n",
2025 smi->short_timeouts);
2026 out += sprintf(out, "long_timeouts: %ld\n",
2027 smi->long_timeouts);
2028 out += sprintf(out, "timeout_restarts: %ld\n",
2029 smi->timeout_restarts);
2030 out += sprintf(out, "idles: %ld\n",
2031 smi->idles);
2032 out += sprintf(out, "interrupts: %ld\n",
2033 smi->interrupts);
2034 out += sprintf(out, "attentions: %ld\n",
2035 smi->attentions);
2036 out += sprintf(out, "flag_fetches: %ld\n",
2037 smi->flag_fetches);
2038 out += sprintf(out, "hosed_count: %ld\n",
2039 smi->hosed_count);
2040 out += sprintf(out, "complete_transactions: %ld\n",
2041 smi->complete_transactions);
2042 out += sprintf(out, "events: %ld\n",
2043 smi->events);
2044 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2045 smi->watchdog_pretimeouts);
2046 out += sprintf(out, "incoming_messages: %ld\n",
2047 smi->incoming_messages);
2048
2049 return (out - ((char *) page));
2050 }
2051
2052 /*
2053 * oem_data_avail_to_receive_msg_avail
2054 * @info - smi_info structure with msg_flags set
2055 *
2056 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2057 * Returns 1 indicating need to re-run handle_flags().
2058 */
2059 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2060 {
2061 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2062 RECEIVE_MSG_AVAIL);
2063 return 1;
2064 }
2065
2066 /*
2067 * setup_dell_poweredge_oem_data_handler
2068 * @info - smi_info.device_id must be populated
2069 *
2070 * Systems that match, but have firmware version < 1.40 may assert
2071 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2072 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2073 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2074 * as RECEIVE_MSG_AVAIL instead.
2075 *
2076 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2077 * assert the OEM[012] bits, and if it did, the driver would have to
2078 * change to handle that properly, we don't actually check for the
2079 * firmware version.
2080 * Device ID = 0x20 BMC on PowerEdge 8G servers
2081 * Device Revision = 0x80
2082 * Firmware Revision1 = 0x01 BMC version 1.40
2083 * Firmware Revision2 = 0x40 BCD encoded
2084 * IPMI Version = 0x51 IPMI 1.5
2085 * Manufacturer ID = A2 02 00 Dell IANA
2086 *
2087 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2088 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2089 *
2090 */
2091 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2092 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2093 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2094 #define DELL_IANA_MFR_ID 0x0002a2
2095 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2096 {
2097 struct ipmi_device_id *id = &smi_info->device_id;
2098 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2099 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2100 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2101 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2102 smi_info->oem_data_avail_handler =
2103 oem_data_avail_to_receive_msg_avail;
2104 }
2105 else if (ipmi_version_major(id) < 1 ||
2106 (ipmi_version_major(id) == 1 &&
2107 ipmi_version_minor(id) < 5)) {
2108 smi_info->oem_data_avail_handler =
2109 oem_data_avail_to_receive_msg_avail;
2110 }
2111 }
2112 }
2113
2114 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2115 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2116 {
2117 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2118
2119 /* Make it a reponse */
2120 msg->rsp[0] = msg->data[0] | 4;
2121 msg->rsp[1] = msg->data[1];
2122 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2123 msg->rsp_size = 3;
2124 smi_info->curr_msg = NULL;
2125 deliver_recv_msg(smi_info, msg);
2126 }
2127
2128 /*
2129 * dell_poweredge_bt_xaction_handler
2130 * @info - smi_info.device_id must be populated
2131 *
2132 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2133 * not respond to a Get SDR command if the length of the data
2134 * requested is exactly 0x3A, which leads to command timeouts and no
2135 * data returned. This intercepts such commands, and causes userspace
2136 * callers to try again with a different-sized buffer, which succeeds.
2137 */
2138
2139 #define STORAGE_NETFN 0x0A
2140 #define STORAGE_CMD_GET_SDR 0x23
2141 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2142 unsigned long unused,
2143 void *in)
2144 {
2145 struct smi_info *smi_info = in;
2146 unsigned char *data = smi_info->curr_msg->data;
2147 unsigned int size = smi_info->curr_msg->data_size;
2148 if (size >= 8 &&
2149 (data[0]>>2) == STORAGE_NETFN &&
2150 data[1] == STORAGE_CMD_GET_SDR &&
2151 data[7] == 0x3A) {
2152 return_hosed_msg_badsize(smi_info);
2153 return NOTIFY_STOP;
2154 }
2155 return NOTIFY_DONE;
2156 }
2157
2158 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2159 .notifier_call = dell_poweredge_bt_xaction_handler,
2160 };
2161
2162 /*
2163 * setup_dell_poweredge_bt_xaction_handler
2164 * @info - smi_info.device_id must be filled in already
2165 *
2166 * Fills in smi_info.device_id.start_transaction_pre_hook
2167 * when we know what function to use there.
2168 */
2169 static void
2170 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2171 {
2172 struct ipmi_device_id *id = &smi_info->device_id;
2173 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2174 smi_info->si_type == SI_BT)
2175 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2176 }
2177
2178 /*
2179 * setup_oem_data_handler
2180 * @info - smi_info.device_id must be filled in already
2181 *
2182 * Fills in smi_info.device_id.oem_data_available_handler
2183 * when we know what function to use there.
2184 */
2185
2186 static void setup_oem_data_handler(struct smi_info *smi_info)
2187 {
2188 setup_dell_poweredge_oem_data_handler(smi_info);
2189 }
2190
2191 static void setup_xaction_handlers(struct smi_info *smi_info)
2192 {
2193 setup_dell_poweredge_bt_xaction_handler(smi_info);
2194 }
2195
2196 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2197 {
2198 if (smi_info->intf) {
2199 /* The timer and thread are only running if the
2200 interface has been started up and registered. */
2201 if (smi_info->thread != NULL)
2202 kthread_stop(smi_info->thread);
2203 del_timer_sync(&smi_info->si_timer);
2204 }
2205 }
2206
2207 static __devinitdata struct ipmi_default_vals
2208 {
2209 int type;
2210 int port;
2211 } ipmi_defaults[] =
2212 {
2213 { .type = SI_KCS, .port = 0xca2 },
2214 { .type = SI_SMIC, .port = 0xca9 },
2215 { .type = SI_BT, .port = 0xe4 },
2216 { .port = 0 }
2217 };
2218
2219 static __devinit void default_find_bmc(void)
2220 {
2221 struct smi_info *info;
2222 int i;
2223
2224 for (i = 0; ; i++) {
2225 if (!ipmi_defaults[i].port)
2226 break;
2227
2228 info = kzalloc(sizeof(*info), GFP_KERNEL);
2229 if (!info)
2230 return;
2231
2232 info->addr_source = NULL;
2233
2234 info->si_type = ipmi_defaults[i].type;
2235 info->io_setup = port_setup;
2236 info->io.addr_data = ipmi_defaults[i].port;
2237 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2238
2239 info->io.addr = NULL;
2240 info->io.regspacing = DEFAULT_REGSPACING;
2241 info->io.regsize = DEFAULT_REGSPACING;
2242 info->io.regshift = 0;
2243
2244 if (try_smi_init(info) == 0) {
2245 /* Found one... */
2246 printk(KERN_INFO "ipmi_si: Found default %s state"
2247 " machine at %s address 0x%lx\n",
2248 si_to_str[info->si_type],
2249 addr_space_to_str[info->io.addr_type],
2250 info->io.addr_data);
2251 return;
2252 }
2253 }
2254 }
2255
2256 static int is_new_interface(struct smi_info *info)
2257 {
2258 struct smi_info *e;
2259
2260 list_for_each_entry(e, &smi_infos, link) {
2261 if (e->io.addr_type != info->io.addr_type)
2262 continue;
2263 if (e->io.addr_data == info->io.addr_data)
2264 return 0;
2265 }
2266
2267 return 1;
2268 }
2269
2270 static int try_smi_init(struct smi_info *new_smi)
2271 {
2272 int rv;
2273
2274 if (new_smi->addr_source) {
2275 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2276 " machine at %s address 0x%lx, slave address 0x%x,"
2277 " irq %d\n",
2278 new_smi->addr_source,
2279 si_to_str[new_smi->si_type],
2280 addr_space_to_str[new_smi->io.addr_type],
2281 new_smi->io.addr_data,
2282 new_smi->slave_addr, new_smi->irq);
2283 }
2284
2285 mutex_lock(&smi_infos_lock);
2286 if (!is_new_interface(new_smi)) {
2287 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2288 rv = -EBUSY;
2289 goto out_err;
2290 }
2291
2292 /* So we know not to free it unless we have allocated one. */
2293 new_smi->intf = NULL;
2294 new_smi->si_sm = NULL;
2295 new_smi->handlers = NULL;
2296
2297 switch (new_smi->si_type) {
2298 case SI_KCS:
2299 new_smi->handlers = &kcs_smi_handlers;
2300 break;
2301
2302 case SI_SMIC:
2303 new_smi->handlers = &smic_smi_handlers;
2304 break;
2305
2306 case SI_BT:
2307 new_smi->handlers = &bt_smi_handlers;
2308 break;
2309
2310 default:
2311 /* No support for anything else yet. */
2312 rv = -EIO;
2313 goto out_err;
2314 }
2315
2316 /* Allocate the state machine's data and initialize it. */
2317 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2318 if (!new_smi->si_sm) {
2319 printk(" Could not allocate state machine memory\n");
2320 rv = -ENOMEM;
2321 goto out_err;
2322 }
2323 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2324 &new_smi->io);
2325
2326 /* Now that we know the I/O size, we can set up the I/O. */
2327 rv = new_smi->io_setup(new_smi);
2328 if (rv) {
2329 printk(" Could not set up I/O space\n");
2330 goto out_err;
2331 }
2332
2333 spin_lock_init(&(new_smi->si_lock));
2334 spin_lock_init(&(new_smi->msg_lock));
2335 spin_lock_init(&(new_smi->count_lock));
2336
2337 /* Do low-level detection first. */
2338 if (new_smi->handlers->detect(new_smi->si_sm)) {
2339 if (new_smi->addr_source)
2340 printk(KERN_INFO "ipmi_si: Interface detection"
2341 " failed\n");
2342 rv = -ENODEV;
2343 goto out_err;
2344 }
2345
2346 /* Attempt a get device id command. If it fails, we probably
2347 don't have a BMC here. */
2348 rv = try_get_dev_id(new_smi);
2349 if (rv) {
2350 if (new_smi->addr_source)
2351 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2352 " at this location\n");
2353 goto out_err;
2354 }
2355
2356 setup_oem_data_handler(new_smi);
2357 setup_xaction_handlers(new_smi);
2358
2359 /* Try to claim any interrupts. */
2360 if (new_smi->irq_setup)
2361 new_smi->irq_setup(new_smi);
2362
2363 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2364 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2365 new_smi->curr_msg = NULL;
2366 atomic_set(&new_smi->req_events, 0);
2367 new_smi->run_to_completion = 0;
2368
2369 new_smi->interrupt_disabled = 0;
2370 atomic_set(&new_smi->stop_operation, 0);
2371 new_smi->intf_num = smi_num;
2372 smi_num++;
2373
2374 /* Start clearing the flags before we enable interrupts or the
2375 timer to avoid racing with the timer. */
2376 start_clear_flags(new_smi);
2377 /* IRQ is defined to be set when non-zero. */
2378 if (new_smi->irq)
2379 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2380
2381 if (!new_smi->dev) {
2382 /* If we don't already have a device from something
2383 * else (like PCI), then register a new one. */
2384 new_smi->pdev = platform_device_alloc("ipmi_si",
2385 new_smi->intf_num);
2386 if (rv) {
2387 printk(KERN_ERR
2388 "ipmi_si_intf:"
2389 " Unable to allocate platform device\n");
2390 goto out_err;
2391 }
2392 new_smi->dev = &new_smi->pdev->dev;
2393 new_smi->dev->driver = &ipmi_driver;
2394
2395 rv = platform_device_register(new_smi->pdev);
2396 if (rv) {
2397 printk(KERN_ERR
2398 "ipmi_si_intf:"
2399 " Unable to register system interface device:"
2400 " %d\n",
2401 rv);
2402 goto out_err;
2403 }
2404 new_smi->dev_registered = 1;
2405 }
2406
2407 rv = ipmi_register_smi(&handlers,
2408 new_smi,
2409 &new_smi->device_id,
2410 new_smi->dev,
2411 new_smi->slave_addr);
2412 if (rv) {
2413 printk(KERN_ERR
2414 "ipmi_si: Unable to register device: error %d\n",
2415 rv);
2416 goto out_err_stop_timer;
2417 }
2418
2419 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2420 type_file_read_proc, NULL,
2421 new_smi, THIS_MODULE);
2422 if (rv) {
2423 printk(KERN_ERR
2424 "ipmi_si: Unable to create proc entry: %d\n",
2425 rv);
2426 goto out_err_stop_timer;
2427 }
2428
2429 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2430 stat_file_read_proc, NULL,
2431 new_smi, THIS_MODULE);
2432 if (rv) {
2433 printk(KERN_ERR
2434 "ipmi_si: Unable to create proc entry: %d\n",
2435 rv);
2436 goto out_err_stop_timer;
2437 }
2438
2439 list_add_tail(&new_smi->link, &smi_infos);
2440
2441 mutex_unlock(&smi_infos_lock);
2442
2443 printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2444
2445 return 0;
2446
2447 out_err_stop_timer:
2448 atomic_inc(&new_smi->stop_operation);
2449 wait_for_timer_and_thread(new_smi);
2450
2451 out_err:
2452 if (new_smi->intf)
2453 ipmi_unregister_smi(new_smi->intf);
2454
2455 if (new_smi->irq_cleanup)
2456 new_smi->irq_cleanup(new_smi);
2457
2458 /* Wait until we know that we are out of any interrupt
2459 handlers might have been running before we freed the
2460 interrupt. */
2461 synchronize_sched();
2462
2463 if (new_smi->si_sm) {
2464 if (new_smi->handlers)
2465 new_smi->handlers->cleanup(new_smi->si_sm);
2466 kfree(new_smi->si_sm);
2467 }
2468 if (new_smi->addr_source_cleanup)
2469 new_smi->addr_source_cleanup(new_smi);
2470 if (new_smi->io_cleanup)
2471 new_smi->io_cleanup(new_smi);
2472
2473 if (new_smi->dev_registered)
2474 platform_device_unregister(new_smi->pdev);
2475
2476 kfree(new_smi);
2477
2478 mutex_unlock(&smi_infos_lock);
2479
2480 return rv;
2481 }
2482
2483 static __devinit int init_ipmi_si(void)
2484 {
2485 int i;
2486 char *str;
2487 int rv;
2488
2489 if (initialized)
2490 return 0;
2491 initialized = 1;
2492
2493 /* Register the device drivers. */
2494 rv = driver_register(&ipmi_driver);
2495 if (rv) {
2496 printk(KERN_ERR
2497 "init_ipmi_si: Unable to register driver: %d\n",
2498 rv);
2499 return rv;
2500 }
2501
2502
2503 /* Parse out the si_type string into its components. */
2504 str = si_type_str;
2505 if (*str != '\0') {
2506 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2507 si_type[i] = str;
2508 str = strchr(str, ',');
2509 if (str) {
2510 *str = '\0';
2511 str++;
2512 } else {
2513 break;
2514 }
2515 }
2516 }
2517
2518 printk(KERN_INFO "IPMI System Interface driver.\n");
2519
2520 hardcode_find_bmc();
2521
2522 #ifdef CONFIG_DMI
2523 dmi_find_bmc();
2524 #endif
2525
2526 #ifdef CONFIG_ACPI
2527 if (si_trydefaults)
2528 acpi_find_bmc();
2529 #endif
2530
2531 #ifdef CONFIG_PCI
2532 pci_module_init(&ipmi_pci_driver);
2533 #endif
2534
2535 if (si_trydefaults) {
2536 mutex_lock(&smi_infos_lock);
2537 if (list_empty(&smi_infos)) {
2538 /* No BMC was found, try defaults. */
2539 mutex_unlock(&smi_infos_lock);
2540 default_find_bmc();
2541 } else {
2542 mutex_unlock(&smi_infos_lock);
2543 }
2544 }
2545
2546 mutex_lock(&smi_infos_lock);
2547 if (list_empty(&smi_infos)) {
2548 mutex_unlock(&smi_infos_lock);
2549 #ifdef CONFIG_PCI
2550 pci_unregister_driver(&ipmi_pci_driver);
2551 #endif
2552 printk("ipmi_si: Unable to find any System Interface(s)\n");
2553 return -ENODEV;
2554 } else {
2555 mutex_unlock(&smi_infos_lock);
2556 return 0;
2557 }
2558 }
2559 module_init(init_ipmi_si);
2560
2561 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2562 {
2563 int rv;
2564 unsigned long flags;
2565
2566 if (!to_clean)
2567 return;
2568
2569 list_del(&to_clean->link);
2570
2571 /* Tell the timer and interrupt handlers that we are shutting
2572 down. */
2573 spin_lock_irqsave(&(to_clean->si_lock), flags);
2574 spin_lock(&(to_clean->msg_lock));
2575
2576 atomic_inc(&to_clean->stop_operation);
2577
2578 if (to_clean->irq_cleanup)
2579 to_clean->irq_cleanup(to_clean);
2580
2581 spin_unlock(&(to_clean->msg_lock));
2582 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2583
2584 /* Wait until we know that we are out of any interrupt
2585 handlers might have been running before we freed the
2586 interrupt. */
2587 synchronize_sched();
2588
2589 wait_for_timer_and_thread(to_clean);
2590
2591 /* Interrupts and timeouts are stopped, now make sure the
2592 interface is in a clean state. */
2593 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2594 poll(to_clean);
2595 schedule_timeout_uninterruptible(1);
2596 }
2597
2598 rv = ipmi_unregister_smi(to_clean->intf);
2599 if (rv) {
2600 printk(KERN_ERR
2601 "ipmi_si: Unable to unregister device: errno=%d\n",
2602 rv);
2603 }
2604
2605 to_clean->handlers->cleanup(to_clean->si_sm);
2606
2607 kfree(to_clean->si_sm);
2608
2609 if (to_clean->addr_source_cleanup)
2610 to_clean->addr_source_cleanup(to_clean);
2611 if (to_clean->io_cleanup)
2612 to_clean->io_cleanup(to_clean);
2613
2614 if (to_clean->dev_registered)
2615 platform_device_unregister(to_clean->pdev);
2616
2617 kfree(to_clean);
2618 }
2619
2620 static __exit void cleanup_ipmi_si(void)
2621 {
2622 struct smi_info *e, *tmp_e;
2623
2624 if (!initialized)
2625 return;
2626
2627 #ifdef CONFIG_PCI
2628 pci_unregister_driver(&ipmi_pci_driver);
2629 #endif
2630
2631 mutex_lock(&smi_infos_lock);
2632 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2633 cleanup_one_si(e);
2634 mutex_unlock(&smi_infos_lock);
2635
2636 driver_unregister(&ipmi_driver);
2637 }
2638 module_exit(cleanup_ipmi_si);
2639
2640 MODULE_LICENSE("GPL");
2641 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2642 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");
Verdex Pro support