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