Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

Linux/drivers/char/ipmi/ipmi_si_intf.c

  1 /*
  2  * ipmi_si.c
  3  *
  4  * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
  5  * BT).
  6  *
  7  * Author: MontaVista Software, Inc.
  8  *         Corey Minyard <minyard@mvista.com>
  9  *         source@mvista.com
 10  *
 11  * Copyright 2002 MontaVista Software Inc.
 12  * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
 13  *
 14  *  This program is free software; you can redistribute it and/or modify it
 15  *  under the terms of the GNU General Public License as published by the
 16  *  Free Software Foundation; either version 2 of the License, or (at your
 17  *  option) any later version.
 18  *
 19  *
 20  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 21  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 22  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 23  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 24  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 25  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 26  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 27  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 28  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 29  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30  *
 31  *  You should have received a copy of the GNU General Public License along
 32  *  with this program; if not, write to the Free Software Foundation, Inc.,
 33  *  675 Mass Ave, Cambridge, MA 02139, USA.
 34  */
 35 
 36 /*
 37  * This file holds the "policy" for the interface to the SMI state
 38  * machine.  It does the configuration, handles timers and interrupts,
 39  * and drives the real SMI state machine.
 40  */
 41 
 42 #include <linux/module.h>
 43 #include <linux/moduleparam.h>
 44 #include <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>       /* for register_parisc_driver() stuff */
 75 #include <asm/parisc-device.h>
 76 #endif
 77 
 78 #define PFX "ipmi_si: "
 79 
 80 /* Measure times between events in the driver. */
 81 #undef DEBUG_TIMING
 82 
 83 /* Call every 10 ms. */
 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 /* .25ms when the SM request a
 88                                       short timeout */
 89 
 90 enum 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         /* FIXME - add watchdog stuff. */
 99 };
100 
101 /* Some BT-specific defines we need here. */
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 
106 enum si_type {
107     SI_KCS, SI_SMIC, SI_BT
108 };
109 static char *si_to_str[] = { "kcs", "smic", "bt" };
110 
111 #define DEVICE_NAME "ipmi_si"
112 
113 static struct platform_driver ipmi_driver;
114 
115 /*
116  * Indexes into stats[] in smi_info below.
117  */
118 enum si_stat_indexes {
119         /*
120          * Number of times the driver requested a timer while an operation
121          * was in progress.
122          */
123         SI_STAT_short_timeouts = 0,
124 
125         /*
126          * Number of times the driver requested a timer while nothing was in
127          * progress.
128          */
129         SI_STAT_long_timeouts,
130 
131         /* Number of times the interface was idle while being polled. */
132         SI_STAT_idles,
133 
134         /* Number of interrupts the driver handled. */
135         SI_STAT_interrupts,
136 
137         /* Number of time the driver got an ATTN from the hardware. */
138         SI_STAT_attentions,
139 
140         /* Number of times the driver requested flags from the hardware. */
141         SI_STAT_flag_fetches,
142 
143         /* Number of times the hardware didn't follow the state machine. */
144         SI_STAT_hosed_count,
145 
146         /* Number of completed messages. */
147         SI_STAT_complete_transactions,
148 
149         /* Number of IPMI events received from the hardware. */
150         SI_STAT_events,
151 
152         /* Number of watchdog pretimeouts. */
153         SI_STAT_watchdog_pretimeouts,
154 
155         /* Number of asynchronous messages received. */
156         SI_STAT_incoming_messages,
157 
158 
159         /* This *must* remain last, add new values above this. */
160         SI_NUM_STATS
161 };
162 
163 struct 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          * Used to handle the various types of I/O that can occur with
176          * IPMI
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; /* ACPI, PCI, SMBIOS, hardcode, etc. */
185         void (*addr_source_cleanup)(struct smi_info *info);
186         void *addr_source_data;
187 
188         /*
189          * Per-OEM handler, called from handle_flags().  Returns 1
190          * when handle_flags() needs to be re-run or 0 indicating it
191          * set si_state itself.
192          */
193         int (*oem_data_avail_handler)(struct smi_info *smi_info);
194 
195         /*
196          * Flags from the last GET_MSG_FLAGS command, used when an ATTN
197          * is set to hold the flags until we are done handling everything
198          * from the flags.
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         /* Does the BMC have an event buffer? */
212         bool                has_event_buffer;
213 
214         /*
215          * If set to true, this will request events the next time the
216          * state machine is idle.
217          */
218         atomic_t            req_events;
219 
220         /*
221          * If true, run the state machine to completion on every send
222          * call.  Generally used after a panic to make sure stuff goes
223          * out.
224          */
225         bool                run_to_completion;
226 
227         /* The I/O port of an SI interface. */
228         int                 port;
229 
230         /*
231          * The space between start addresses of the two ports.  For
232          * instance, if the first port is 0xca2 and the spacing is 4, then
233          * the second port is 0xca6.
234          */
235         unsigned int        spacing;
236 
237         /* zero if no irq; */
238         int                 irq;
239 
240         /* The timer for this si. */
241         struct timer_list   si_timer;
242 
243         /* This flag is set, if the timer is running (timer_pending() isn't enough) */
244         bool                timer_running;
245 
246         /* The time (in jiffies) the last timeout occurred at. */
247         unsigned long       last_timeout_jiffies;
248 
249         /* Are we waiting for the events, pretimeouts, received msgs? */
250         atomic_t            need_watch;
251 
252         /*
253          * The driver will disable interrupts when it gets into a
254          * situation where it cannot handle messages due to lack of
255          * memory.  Once that situation clears up, it will re-enable
256          * interrupts.
257          */
258         bool interrupt_disabled;
259 
260         /*
261          * Does the BMC support events?
262          */
263         bool supports_event_msg_buff;
264 
265         /*
266          * Can we clear the global enables receive irq bit?
267          */
268         bool cannot_clear_recv_irq_bit;
269 
270         /*
271          * Did we get an attention that we did not handle?
272          */
273         bool got_attn;
274 
275         /* From the get device id response... */
276         struct ipmi_device_id device_id;
277 
278         /* Driver model stuff. */
279         struct device *dev;
280         struct platform_device *pdev;
281 
282         /*
283          * True if we allocated the device, false if it came from
284          * someplace else (like PCI).
285          */
286         bool dev_registered;
287 
288         /* Slave address, could be reported from DMI. */
289         unsigned char slave_addr;
290 
291         /* Counters and things for the proc filesystem. */
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 
307 static int force_kipmid[SI_MAX_PARMS];
308 static int num_force_kipmid;
309 #ifdef CONFIG_PCI
310 static bool pci_registered;
311 #endif
312 #ifdef CONFIG_ACPI
313 static bool pnp_registered;
314 #endif
315 #ifdef CONFIG_PARISC
316 static bool parisc_registered;
317 #endif
318 
319 static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
320 static int num_max_busy_us;
321 
322 static bool unload_when_empty = true;
323 
324 static int add_smi(struct smi_info *smi);
325 static int try_smi_init(struct smi_info *smi);
326 static void cleanup_one_si(struct smi_info *to_clean);
327 static void cleanup_ipmi_si(void);
328 
329 #ifdef DEBUG_TIMING
330 void 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 
341 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
342 static int register_xaction_notifier(struct notifier_block *nb)
343 {
344         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
345 }
346 
347 static void deliver_recv_msg(struct smi_info *smi_info,
348                              struct ipmi_smi_msg *msg)
349 {
350         /* Deliver the message to the upper layer. */
351         if (smi_info->intf)
352                 ipmi_smi_msg_received(smi_info->intf, msg);
353         else
354                 ipmi_free_smi_msg(msg);
355 }
356 
357 static 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         /* else use it as is */
364 
365         /* Make it a response */
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 
375 static 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 
407 static 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 
418 static void start_clear_flags(struct smi_info *smi_info)
419 {
420         unsigned char msg[3];
421 
422         /* Make sure the watchdog pre-timeout flag is not set at startup. */
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 
431 static 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 
444 static 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 
457 static 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  * When we have a situtaion where we run out of memory and cannot
466  * allocate messages, we just leave them in the BMC and run the system
467  * polled until we can allocate some memory.  Once we have some
468  * memory, we will re-enable the interrupt.
469  *
470  * Note that we cannot just use disable_irq(), since the interrupt may
471  * be shared.
472  */
473 static 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 
483 static 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  * Allocate a message.  If unable to allocate, start the interrupt
495  * disable process and return NULL.  If able to allocate but
496  * interrupts are disabled, free the message and return NULL after
497  * starting the interrupt enable process.
498  */
499 static 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 
514 static void handle_flags(struct smi_info *smi_info)
515 {
516  retry:
517         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
518                 /* Watchdog pre-timeout */
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                 /* Messages available. */
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                 /* Events available. */
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  * Global enables we care about.
549  */
550 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
551                              IPMI_BMC_EVT_MSG_INTR)
552 
553 static 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 
575 static 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 
591 static 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                  * Do this here becase deliver_recv_msg() releases the
609                  * lock, and a new message can be put in during the
610                  * time the lock is released.
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                 /* We got the flags from the SMI, now handle them. */
623                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
624                 if (msg[2] != 0) {
625                         /* Error fetching flags, just give up for now. */
626                         smi_info->si_state = SI_NORMAL;
627                 } else if (len < 4) {
628                         /*
629                          * Hmm, no flags.  That's technically illegal, but
630                          * don't use uninitialized data.
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                 /* We cleared the flags. */
645                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
646                 if (msg[2] != 0) {
647                         /* Error clearing flags */
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                  * Do this here becase deliver_recv_msg() releases the
665                  * lock, and a new message can be put in during the
666                  * time the lock is released.
667                  */
668                 msg = smi_info->curr_msg;
669                 smi_info->curr_msg = NULL;
670                 if (msg->rsp[2] != 0) {
671                         /* Error getting event, probably done. */
672                         msg->done(msg);
673 
674                         /* Take off the event flag. */
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                          * Do this before we deliver the message
682                          * because delivering the message releases the
683                          * lock and something else can mess with the
684                          * state.
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                  * Do this here becase deliver_recv_msg() releases the
703                  * lock, and a new message can be put in during the
704                  * time the lock is released.
705                  */
706                 msg = smi_info->curr_msg;
707                 smi_info->curr_msg = NULL;
708                 if (msg->rsp[2] != 0) {
709                         /* Error getting event, probably done. */
710                         msg->done(msg);
711 
712                         /* Take off the msg flag. */
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                          * Do this before we deliver the message
720                          * because delivering the message releases the
721                          * lock and something else can mess with the
722                          * state.
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                 /* We got the flags from the SMI, now handle them. */
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                         /* BT has its own interrupt enable bit. */
750                         check_bt_irq(smi_info, irq_on);
751                 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
752                         /* Enables are not correct, fix them. */
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  * Called on timeouts and events.  Timeouts should pass the elapsed
799  * time, interrupts should pass in zero.  Must be called with
800  * si_lock held and interrupts disabled.
801  */
802 static 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          * There used to be a loop here that waited a little while
810          * (around 25us) before giving up.  That turned out to be
811          * pointless, the minimum delays I was seeing were in the 300us
812          * range, which is far too long to wait in an interrupt.  So
813          * we just run until the state machine tells us something
814          * happened or it needs a delay.
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                  * Do the before return_hosed_msg, because that
831                  * releases the lock.
832                  */
833                 smi_info->si_state = SI_NORMAL;
834                 if (smi_info->curr_msg != NULL) {
835                         /*
836                          * If we were handling a user message, format
837                          * a response to send to the upper layer to
838                          * tell it about the error.
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          * We prefer handling attn over new messages.  But don't do
847          * this if there is not yet an upper layer to handle anything.
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                          * We got an ATTN, but we are doing something else.
856                          * Handle the ATTN later.
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                          * Got a attn, send down a get message flags to see
865                          * what's causing it.  It would be better to handle
866                          * this in the upper layer, but due to the way
867                          * interrupts work with the SMI, that's not really
868                          * possible.
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         /* If we are currently idle, try to start the next message. */
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                  * We are idle and the upper layer requested that I fetch
893                  * events, so do so.
894                  */
895                 atomic_set(&smi_info->req_events, 0);
896 
897                 /*
898                  * Take this opportunity to check the interrupt and
899                  * message enable state for the BMC.  The BMC can be
900                  * asynchronously reset, and may thus get interrupts
901                  * disable and messages disabled.
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 
918 static 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 
931 static 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                  * If we are running to completion, start it and run
943                  * transactions until everything is clear.
944                  */
945                 smi_info->curr_msg = msg;
946                 smi_info->waiting_msg = NULL;
947 
948                 /*
949                  * Run to completion means we are single-threaded, no
950                  * need for locks.
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          * The following two lines don't need to be under the lock for
965          * the lock's sake, but they do need SMP memory barriers to
966          * avoid getting things out of order.  We are already claiming
967          * the lock, anyway, so just do it under the lock to avoid the
968          * ordering problem.
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 
976 static 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  * Use -1 in the nsec value of the busy waiting timespec to tell that
994  * we are spinning in kipmid looking for something and not delaying
995  * between checks
996  */
997 static inline void ipmi_si_set_not_busy(struct timespec64 *ts)
998 {
999         ts->tv_nsec = -1;
1000 }
1001 static inline int ipmi_si_is_busy(struct timespec64 *ts)
1002 {
1003         return ts->tv_nsec != -1;
1004 }
1005 
1006 static 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  * A busy-waiting loop for speeding up IPMI operation.
1034  *
1035  * Lousy hardware makes this hard.  This is only enabled for systems
1036  * that are not BT and do not have interrupts.  It starts spinning
1037  * when an operation is complete or until max_busy tells it to stop
1038  * (if that is enabled).  See the paragraph on kimid_max_busy_us in
1039  * Documentation/IPMI.txt for details.
1040  */
1041 static 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                  * If the driver is doing something, there is a possible
1058                  * race with the timer.  If the timer handler see idle,
1059                  * and the thread here sees something else, the timer
1060                  * handler won't restart the timer even though it is
1061                  * required.  So start it here if necessary.
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                         ; /* do nothing */
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                                 /* Wait to be woken up when we are needed. */
1078                                 __set_current_state(TASK_INTERRUPTIBLE);
1079                                 schedule();
1080                         }
1081                 } else
1082                         schedule_timeout_interruptible(1);
1083         }
1084         return 0;
1085 }
1086 
1087 
1088 static 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          * Make sure there is some delay in the poll loop so we can
1096          * drive time forward and timeout things.
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 
1106 static 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 
1116 static 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 
1127 static int initialized;
1128 
1129 static 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                 /* Running with interrupts, only do long timeouts. */
1148                 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1149                 smi_inc_stat(smi_info, long_timeouts);
1150                 goto do_mod_timer;
1151         }
1152 
1153         /*
1154          * If the state machine asks for a short delay, then shorten
1155          * the timer timeout.
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 
1173 static 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 
1189 static irqreturn_t si_bt_irq_handler(int irq, void *data)
1190 {
1191         struct smi_info *smi_info = data;
1192         /* We need to clear the IRQ flag for the BT interface. */
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 
1199 static 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         /* Try to claim any interrupts. */
1208         if (new_smi->irq_setup)
1209                 new_smi->irq_setup(new_smi);
1210 
1211         /* Set up the timer that drives the interface. */
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          * Check if the user forcefully enabled the daemon.
1217          */
1218         if (new_smi->intf_num < num_force_kipmid)
1219                 enable = force_kipmid[new_smi->intf_num];
1220         /*
1221          * The BT interface is efficient enough to not need a thread,
1222          * and there is no need for a thread if we have interrupts.
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 
1242 static 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 
1254 static 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 
1262 static 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  * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1276  * a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS.
1277  */
1278 
1279 static LIST_HEAD(smi_infos);
1280 static DEFINE_MUTEX(smi_infos_lock);
1281 static int smi_num; /* Used to sequence the SMIs */
1282 
1283 #define DEFAULT_REGSPACING      1
1284 #define DEFAULT_REGSIZE         1
1285 
1286 #ifdef CONFIG_ACPI
1287 static bool          si_tryacpi = 1;
1288 #endif
1289 #ifdef CONFIG_DMI
1290 static bool          si_trydmi = 1;
1291 #endif
1292 static bool          si_tryplatform = 1;
1293 #ifdef CONFIG_PCI
1294 static bool          si_trypci = 1;
1295 #endif
1296 static bool          si_trydefaults = IS_ENABLED(CONFIG_IPMI_SI_PROBE_DEFAULTS);
1297 static char          *si_type[SI_MAX_PARMS];
1298 #define MAX_SI_TYPE_STR 30
1299 static char          si_type_str[MAX_SI_TYPE_STR];
1300 static unsigned long addrs[SI_MAX_PARMS];
1301 static unsigned int num_addrs;
1302 static unsigned int  ports[SI_MAX_PARMS];
1303 static unsigned int num_ports;
1304 static int           irqs[SI_MAX_PARMS];
1305 static unsigned int num_irqs;
1306 static int           regspacings[SI_MAX_PARMS];
1307 static unsigned int num_regspacings;
1308 static int           regsizes[SI_MAX_PARMS];
1309 static unsigned int num_regsizes;
1310 static int           regshifts[SI_MAX_PARMS];
1311 static unsigned int num_regshifts;
1312 static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
1313 static unsigned int num_slave_addrs;
1314 
1315 #define IPMI_IO_ADDR_SPACE  0
1316 #define IPMI_MEM_ADDR_SPACE 1
1317 static char *addr_space_to_str[] = { "i/o", "mem" };
1318 
1319 static int hotmod_handler(const char *val, struct kernel_param *kp);
1320 
1321 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1322 MODULE_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
1327 module_param_named(tryacpi, si_tryacpi, bool, 0);
1328 MODULE_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
1332 module_param_named(trydmi, si_trydmi, bool, 0);
1333 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
1334                  " default scan of the interfaces identified via DMI");
1335 #endif
1336 module_param_named(tryplatform, si_tryplatform, bool, 0);
1337 MODULE_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
1341 module_param_named(trypci, si_trypci, bool, 0);
1342 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1343                  " default scan of the interfaces identified via pci");
1344 #endif
1345 module_param_named(trydefaults, si_trydefaults, bool, 0);
1346 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1347                  " default scan of the KCS and SMIC interface at the standard"
1348                  " address");
1349 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1350 MODULE_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");
1354 module_param_array(addrs, ulong, &num_addrs, 0);
1355 MODULE_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.");
1359 module_param_array(ports, uint, &num_ports, 0);
1360 MODULE_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.");
1364 module_param_array(irqs, int, &num_irqs, 0);
1365 MODULE_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.");
1369 module_param_array(regspacings, int, &num_regspacings, 0);
1370 MODULE_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.");
1375 module_param_array(regsizes, int, &num_regsizes, 0);
1376 MODULE_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.");
1381 module_param_array(regshifts, int, &num_regshifts, 0);
1382 MODULE_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");
1386 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1387 MODULE_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.");
1391 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1392 MODULE_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.");
1395 module_param(unload_when_empty, bool, 0);
1396 MODULE_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.");
1399 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1400 MODULE_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 
1406 static void std_irq_cleanup(struct smi_info *info)
1407 {
1408         if (info->si_type == SI_BT)
1409                 /* Disable the interrupt in the BT interface. */
1410                 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1411         free_irq(info->irq, info);
1412 }
1413 
1414 static 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                         /* Enable the interrupt in the BT interface. */
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 
1450 static 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 
1457 static 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 
1465 static 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 
1472 static 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 
1480 static 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 
1487 static 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 
1495 static 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 
1507 static 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          * Figure out the actual inb/inw/inl/etc routine to use based
1519          * upon the register size.
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          * Some BIOSes reserve disjoint I/O regions in their ACPI
1542          * tables.  This causes problems when trying to register the
1543          * entire I/O region.  Therefore we must register each I/O
1544          * port separately.
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                         /* Undo allocations */
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 
1560 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1561 {
1562         return readb((io->addr)+(offset * io->regspacing));
1563 }
1564 
1565 static 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 
1571 static 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 
1577 static 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 
1583 static 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 
1589 static 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
1596 static 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 
1602 static 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 
1609 static 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 
1624 static 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          * Figure out the actual readb/readw/readl/etc routine to use based
1636          * upon the register size.
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          * Calculate the total amount of memory to claim.  This is an
1665          * unusual looking calculation, but it avoids claiming any
1666          * more memory than it has to.  It will claim everything
1667          * between the first address to the end of the last full
1668          * register.
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  * Parms come in as <op1>[:op2[:op3...]].  ops are:
1686  *   add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1687  * Options are:
1688  *   rsp=<regspacing>
1689  *   rsi=<regsize>
1690  *   rsh=<regshift>
1691  *   irq=<irq>
1692  *   ipmb=<ipmb addr>
1693  */
1694 enum hotmod_op { HM_ADD, HM_REMOVE };
1695 struct hotmod_vals {
1696         char *name;
1697         int  val;
1698 };
1699 static struct hotmod_vals hotmod_ops[] = {
1700         { "add",        HM_ADD },
1701         { "remove",     HM_REMOVE },
1702         { NULL }
1703 };
1704 static struct hotmod_vals hotmod_si[] = {
1705         { "kcs",        SI_KCS },
1706         { "smic",       SI_SMIC },
1707         { "bt",         SI_BT },
1708         { NULL }
1709 };
1710 static struct hotmod_vals hotmod_as[] = {
1711         { "mem",        IPMI_MEM_ADDR_SPACE },
1712         { "i/o",        IPMI_IO_ADDR_SPACE },
1713         { NULL }
1714 };
1715 
1716 static 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 
1740 static 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 
1764 static 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 
1773 static 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         /* Kill any trailing spaces, as we can get a "\n" from echo. */
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; /* Choose the default if not specified */
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", &regspacing);
1854                         if (rv < 0)
1855                                 goto out;
1856                         else if (rv)
1857                                 continue;
1858                         rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
1859                         if (rv < 0)
1860                                 goto out;
1861                         else if (rv)
1862                                 continue;
1863                         rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
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                         /* remove */
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 
1947 static 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                         /* An I/O port */
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                         /* A memory port */
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  * Once we get an ACPI failure, we don't try any more, because we go
2026  * through the tables sequentially.  Once we don't find a table, there
2027  * are no more.
2028  */
2029 static int acpi_failure;
2030 
2031 /* For GPE-type interrupts. */
2032 static 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 
2050 static 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 
2058 static 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  * Defined at
2084  * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
2085  */
2086 struct 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          * Bit 0 - SCI interrupt supported
2102          * Bit 1 - I/O APIC/SAPIC
2103          */
2104         u8      InterruptType;
2105 
2106         /*
2107          * If bit 0 of InterruptType is set, then this is the SCI
2108          * interrupt in the GPEx_STS register.
2109          */
2110         u8      GPE;
2111 
2112         s16     Reserved;
2113 
2114         /*
2115          * If bit 1 of InterruptType is set, then this is the I/O
2116          * APIC/SAPIC interrupt.
2117          */
2118         u32     GlobalSystemInterrupt;
2119 
2120         /* The actual register address. */
2121         struct acpi_generic_address addr;
2122 
2123         u8      UID[4];
2124 
2125         s8      spmi_id[1]; /* A '\0' terminated array starts here. */
2126 };
2127 
2128 static 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         /* Figure out the interface type. */
2148         switch (spmi->InterfaceType) {
2149         case 1: /* KCS */
2150                 info->si_type = SI_KCS;
2151                 break;
2152         case 2: /* SMIC */
2153                 info->si_type = SI_SMIC;
2154                 break;
2155         case 3: /* BT */
2156                 info->si_type = SI_BT;
2157                 break;
2158         case 4: /* SSIF, just ignore */
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                 /* We've got a GPE interrupt. */
2170                 info->irq = spmi->GPE;
2171                 info->irq_setup = acpi_gpe_irq_setup;
2172         } else if (spmi->InterruptType & 2) {
2173                 /* We've got an APIC/SAPIC interrupt. */
2174                 info->irq = spmi->GlobalSystemInterrupt;
2175                 info->irq_setup = std_irq_setup;
2176         } else {
2177                 /* Use the default interrupt setting. */
2178                 info->irq = 0;
2179                 info->irq_setup = NULL;
2180         }
2181 
2182         if (spmi->addr.bit_width) {
2183                 /* A (hopefully) properly formed register bit width. */
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 
2216 static 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 
2238 static 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         /* _IFT tells us the interface type: KCS, BT, etc */
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: /* SSIF, just ignore */
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         /* If _GPE exists, use it; otherwise use standard interrupts */
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 
2337 err_free:
2338         kfree(info);
2339         return -EINVAL;
2340 }
2341 
2342 static 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 
2349 static const struct pnp_device_id pnp_dev_table[] = {
2350         {"IPI0001", 0},
2351         {"", 0},
2352 };
2353 
2354 static 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 
2361 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
2362 #endif
2363 
2364 #ifdef CONFIG_DMI
2365 struct 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 
2374 static 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                         /* I/O */
2388                         base_addr &= 0xFFFE;
2389                         dmi->addr_space = IPMI_IO_ADDR_SPACE;
2390                 } else
2391                         /* Memory */
2392                         dmi->addr_space = IPMI_MEM_ADDR_SPACE;
2393 
2394                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
2395                    is odd. */
2396                 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
2397 
2398                 dmi->irq = data[0x11];
2399 
2400                 /* The top two bits of byte 0x10 hold the register spacing. */
2401                 reg_spacing = (data[0x10] & 0xC0) >> 6;
2402                 switch (reg_spacing) {
2403                 case 0x00: /* Byte boundaries */
2404                     dmi->offset = 1;
2405                     break;
2406                 case 0x01: /* 32-bit boundaries */
2407                     dmi->offset = 4;
2408                     break;
2409                 case 0x02: /* 16-byte boundaries */
2410                     dmi->offset = 16;
2411                     break;
2412                 default:
2413                     /* Some other interface, just ignore it. */
2414                     return -EIO;
2415                 }
2416         } else {
2417                 /* Old DMI spec. */
2418                 /*
2419                  * Note that technically, the lower bit of the base
2420                  * address should be 1 if the address is I/O and 0 if
2421                  * the address is in memory.  So many systems get that
2422                  * wrong (and all that I have seen are I/O) so we just
2423                  * ignore that bit and assume I/O.  Systems that use
2424                  * memory should use the newer spec, anyway.
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 
2436 static 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: /* KCS */
2451                 info->si_type = SI_KCS;
2452                 break;
2453         case 0x02: /* SMIC */
2454                 info->si_type = SI_SMIC;
2455                 break;
2456         case 0x03: /* BT */
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 
2504 static 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 /* CONFIG_DMI */
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 
2533 static 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 
2540 static 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                 /* detect 1, 4, 16byte spacing */
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                         /* write invalid cmd */
2560                         info->io.outputb(&info->io, 1, 0x10);
2561                         /* read status back */
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 
2572 static 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 
2648 static 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 
2655 static 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 };
2660 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2661 
2662 static 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 /* CONFIG_PCI */
2669 
2670 static struct of_device_id ipmi_match[];
2671 static 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 
2759 static 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 
2767 static 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 
2778 static 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
2788 static 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; /* no interrupt */
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 
2826 static int ipmi_parisc_remove(struct parisc_device *dev)
2827 {
2828         cleanup_one_si(dev_get_drvdata(&dev->dev));
2829         return 0;
2830 }
2831 
2832 static struct parisc_device_id ipmi_parisc_tbl[] = {
2833         { HPHW_MC, HVERSION_REV_ANY_ID, 0x004, 0xC0 },
2834         { 0, }
2835 };
2836 
2837 static 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 /* CONFIG_PARISC */
2844 
2845 static 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                  * We couldn't get the state machine to run, so whatever's at
2865                  * the port is probably not an IPMI SMI interface.
2866                  */
2867                 return -ENODEV;
2868 
2869         return 0;
2870 }
2871 
2872 static 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          * Do a Get Device ID command, since it comes back with some
2885          * useful info.
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         /* Check and record info from the get device id, in case we need it. */
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  * Some BMCs do not support clearing the receive irq bit in the global
2908  * enables (even if they don't support interrupts on the BMC).  Check
2909  * for this and handle it properly.
2910  */
2911 static 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                 /* Already clear, should work ok. */
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                  * An error when setting the event buffer bit means
2985                  * clearing the bit is not supported.
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 
2996 static 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                 /* buffer is already enabled, nothing to do. */
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                  * An error when setting the event buffer bit means
3066                  * that the event buffer is not supported.
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 
3077 static 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 
3086 static 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 
3091 static 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 
3098 static 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 
3129 static 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 
3134 static 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 
3141 static 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 
3159 static 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 
3164 static 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  * oem_data_avail_to_receive_msg_avail
3173  * @info - smi_info structure with msg_flags set
3174  *
3175  * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
3176  * Returns 1 indicating need to re-run handle_flags().
3177  */
3178 static 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  * setup_dell_poweredge_oem_data_handler
3187  * @info - smi_info.device_id must be populated
3188  *
3189  * Systems that match, but have firmware version < 1.40 may assert
3190  * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
3191  * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
3192  * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
3193  * as RECEIVE_MSG_AVAIL instead.
3194  *
3195  * As Dell has no plans to release IPMI 1.5 firmware that *ever*
3196  * assert the OEM[012] bits, and if it did, the driver would have to
3197  * change to handle that properly, we don't actually check for the
3198  * firmware version.
3199  * Device ID = 0x20                BMC on PowerEdge 8G servers
3200  * Device Revision = 0x80
3201  * Firmware Revision1 = 0x01       BMC version 1.40
3202  * Firmware Revision2 = 0x40       BCD encoded
3203  * IPMI Version = 0x51             IPMI 1.5
3204  * Manufacturer ID = A2 02 00      Dell IANA
3205  *
3206  * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
3207  * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
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
3214 static 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
3233 static void return_hosed_msg_badsize(struct smi_info *smi_info)
3234 {
3235         struct ipmi_smi_msg *msg = smi_info->curr_msg;
3236 
3237         /* Make it a response */
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  * dell_poweredge_bt_xaction_handler
3248  * @info - smi_info.device_id must be populated
3249  *
3250  * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
3251  * not respond to a Get SDR command if the length of the data
3252  * requested is exactly 0x3A, which leads to command timeouts and no
3253  * data returned.  This intercepts such commands, and causes userspace
3254  * callers to try again with a different-sized buffer, which succeeds.
3255  */
3256 
3257 #define STORAGE_NETFN 0x0A
3258 #define STORAGE_CMD_GET_SDR 0x23
3259 static 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 
3276 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
3277         .notifier_call  = dell_poweredge_bt_xaction_handler,
3278 };
3279 
3280 /*
3281  * setup_dell_poweredge_bt_xaction_handler
3282  * @info - smi_info.device_id must be filled in already
3283  *
3284  * Fills in smi_info.device_id.start_transaction_pre_hook
3285  * when we know what function to use there.
3286  */
3287 static void
3288 setup_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  * setup_oem_data_handler
3298  * @info - smi_info.device_id must be filled in already
3299  *
3300  * Fills in smi_info.device_id.oem_data_available_handler
3301  * when we know what function to use there.
3302  */
3303 
3304 static void setup_oem_data_handler(struct smi_info *smi_info)
3305 {
3306         setup_dell_poweredge_oem_data_handler(smi_info);
3307 }
3308 
3309 static void setup_xaction_handlers(struct smi_info *smi_info)
3310 {
3311         setup_dell_poweredge_bt_xaction_handler(smi_info);
3312 }
3313 
3314 static 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 
3322 static 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 
3334 static 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                                 /* Found one... */
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 
3378 static 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 
3392 static 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         /* So we know not to free it unless we have allocated one. */
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 
3415 out_err:
3416         mutex_unlock(&smi_infos_lock);
3417         return rv;
3418 }
3419 
3420 static 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                 /* No support for anything else yet. */
3449                 rv = -EIO;
3450                 goto out_err;
3451         }
3452 
3453         /* Allocate the state machine's data and initialize it. */
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         /* Now that we know the I/O size, we can set up the I/O. */
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         /* Do low-level detection first. */
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          * Attempt a get device id command.  If it fails, we probably
3481          * don't have a BMC here.
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          * Start clearing the flags before we enable interrupts or the
3514          * timer to avoid racing with the timer.
3515          */
3516         start_clear_flags(new_smi);
3517 
3518         /*
3519          * IRQ is defined to be set when non-zero.  req_events will
3520          * cause a global flags check that will enable interrupts.
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                  * If we don't already have a device from something
3530                  * else (like PCI), then register a new one.
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          * Wait until we know that we are out of any interrupt
3612          * handlers might have been running before we freed the
3613          * interrupt.
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 
3640 static 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         /* Parse out the si_type string into its components. */
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         /* If the user gave us a device, they presumably want us to use it */
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         /* poking PC IO addresses will crash machine, don't do it */
3714         si_trydefaults = 0;
3715 #endif
3716 
3717         /* We prefer devices with interrupts, but in the case of a machine
3718            with multiple BMCs we assume that there will be several instances
3719            of a given type so if we succeed in registering a type then also
3720            try to register everything else of the same type */
3721 
3722         mutex_lock(&smi_infos_lock);
3723         list_for_each_entry(e, &smi_infos, link) {
3724                 /* Try to register a device if it has an IRQ and we either
3725                    haven't successfully registered a device yet or this
3726                    device has the same type as one we successfully registered */
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         /* type will only have been set if we successfully registered an si */
3735         if (type) {
3736                 mutex_unlock(&smi_infos_lock);
3737                 return 0;
3738         }
3739 
3740         /* Fall back to the preferred device */
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                         /* No BMC was found, try defaults. */
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 }
3776 module_init(init_ipmi_si);
3777 
3778 static 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          * Make sure that interrupts, the timer and the thread are
3803          * stopped and will not run again.
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          * Timeouts are stopped, now make sure the interrupts are off
3811          * in the BMC.  Note that timers and CPU interrupts are off,
3812          * so no need for locks.
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 
3840 static 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 }
3867 module_exit(cleanup_ipmi_si);
3868 
3869 MODULE_LICENSE("GPL");
3870 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3871 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
3872                    " system interfaces.");
3873 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us