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