4 * Incoming and outgoing message routing for an IPMI interface.
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
10 * Copyright 2002 MontaVista Software Inc.
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <linux/module.h>
35 #include <linux/errno.h>
36 #include <linux/poll.h>
37 #include <linux/sched.h>
38 #include <linux/seq_file.h>
39 #include <linux/spinlock.h>
40 #include <linux/mutex.h>
41 #include <linux/slab.h>
42 #include <linux/ipmi.h>
43 #include <linux/ipmi_smi.h>
44 #include <linux/notifier.h>
45 #include <linux/init.h>
46 #include <linux/proc_fs.h>
47 #include <linux/rcupdate.h>
48 #include <linux/interrupt.h>
50 #define PFX "IPMI message handler: "
52 #define IPMI_DRIVER_VERSION "39.2"
54 static struct ipmi_recv_msg
*ipmi_alloc_recv_msg(void);
55 static int ipmi_init_msghandler(void);
56 static void smi_recv_tasklet(unsigned long);
57 static void handle_new_recv_msgs(ipmi_smi_t intf
);
58 static void need_waiter(ipmi_smi_t intf
);
59 static int handle_one_recv_msg(ipmi_smi_t intf
,
60 struct ipmi_smi_msg
*msg
);
62 static int initialized
;
65 static struct proc_dir_entry
*proc_ipmi_root
;
66 #endif /* CONFIG_PROC_FS */
68 /* Remain in auto-maintenance mode for this amount of time (in ms). */
69 #define IPMI_MAINTENANCE_MODE_TIMEOUT 30000
71 #define MAX_EVENTS_IN_QUEUE 25
74 * Don't let a message sit in a queue forever, always time it with at lest
75 * the max message timer. This is in milliseconds.
77 #define MAX_MSG_TIMEOUT 60000
79 /* Call every ~1000 ms. */
80 #define IPMI_TIMEOUT_TIME 1000
82 /* How many jiffies does it take to get to the timeout time. */
83 #define IPMI_TIMEOUT_JIFFIES ((IPMI_TIMEOUT_TIME * HZ) / 1000)
86 * Request events from the queue every second (this is the number of
87 * IPMI_TIMEOUT_TIMES between event requests). Hopefully, in the
88 * future, IPMI will add a way to know immediately if an event is in
89 * the queue and this silliness can go away.
91 #define IPMI_REQUEST_EV_TIME (1000 / (IPMI_TIMEOUT_TIME))
94 * The main "user" data structure.
97 struct list_head link
;
99 /* Set to false when the user is destroyed. */
102 struct kref refcount
;
104 /* The upper layer that handles receive messages. */
105 struct ipmi_user_hndl
*handler
;
108 /* The interface this user is bound to. */
111 /* Does this interface receive IPMI events? */
116 struct list_head link
;
124 * This is used to form a linked lised during mass deletion.
125 * Since this is in an RCU list, we cannot use the link above
126 * or change any data until the RCU period completes. So we
127 * use this next variable during mass deletion so we can have
128 * a list and don't have to wait and restart the search on
129 * every individual deletion of a command.
131 struct cmd_rcvr
*next
;
135 unsigned int inuse
: 1;
136 unsigned int broadcast
: 1;
138 unsigned long timeout
;
139 unsigned long orig_timeout
;
140 unsigned int retries_left
;
143 * To verify on an incoming send message response that this is
144 * the message that the response is for, we keep a sequence id
145 * and increment it every time we send a message.
150 * This is held so we can properly respond to the message on a
151 * timeout, and it is used to hold the temporary data for
152 * retransmission, too.
154 struct ipmi_recv_msg
*recv_msg
;
158 * Store the information in a msgid (long) to allow us to find a
159 * sequence table entry from the msgid.
161 #define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff))
163 #define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \
165 seq = ((msgid >> 26) & 0x3f); \
166 seqid = (msgid & 0x3fffff); \
169 #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff)
171 struct ipmi_channel
{
172 unsigned char medium
;
173 unsigned char protocol
;
176 * My slave address. This is initialized to IPMI_BMC_SLAVE_ADDR,
177 * but may be changed by the user.
179 unsigned char address
;
182 * My LUN. This should generally stay the SMS LUN, but just in
188 #ifdef CONFIG_PROC_FS
189 struct ipmi_proc_entry
{
191 struct ipmi_proc_entry
*next
;
196 struct platform_device pdev
;
197 struct ipmi_device_id id
;
198 unsigned char guid
[16];
201 struct kref usecount
;
203 #define to_bmc_device(x) container_of((x), struct bmc_device, pdev.dev)
206 * Various statistics for IPMI, these index stats[] in the ipmi_smi
209 enum ipmi_stat_indexes
{
210 /* Commands we got from the user that were invalid. */
211 IPMI_STAT_sent_invalid_commands
= 0,
213 /* Commands we sent to the MC. */
214 IPMI_STAT_sent_local_commands
,
216 /* Responses from the MC that were delivered to a user. */
217 IPMI_STAT_handled_local_responses
,
219 /* Responses from the MC that were not delivered to a user. */
220 IPMI_STAT_unhandled_local_responses
,
222 /* Commands we sent out to the IPMB bus. */
223 IPMI_STAT_sent_ipmb_commands
,
225 /* Commands sent on the IPMB that had errors on the SEND CMD */
226 IPMI_STAT_sent_ipmb_command_errs
,
228 /* Each retransmit increments this count. */
229 IPMI_STAT_retransmitted_ipmb_commands
,
232 * When a message times out (runs out of retransmits) this is
235 IPMI_STAT_timed_out_ipmb_commands
,
238 * This is like above, but for broadcasts. Broadcasts are
239 * *not* included in the above count (they are expected to
242 IPMI_STAT_timed_out_ipmb_broadcasts
,
244 /* Responses I have sent to the IPMB bus. */
245 IPMI_STAT_sent_ipmb_responses
,
247 /* The response was delivered to the user. */
248 IPMI_STAT_handled_ipmb_responses
,
250 /* The response had invalid data in it. */
251 IPMI_STAT_invalid_ipmb_responses
,
253 /* The response didn't have anyone waiting for it. */
254 IPMI_STAT_unhandled_ipmb_responses
,
256 /* Commands we sent out to the IPMB bus. */
257 IPMI_STAT_sent_lan_commands
,
259 /* Commands sent on the IPMB that had errors on the SEND CMD */
260 IPMI_STAT_sent_lan_command_errs
,
262 /* Each retransmit increments this count. */
263 IPMI_STAT_retransmitted_lan_commands
,
266 * When a message times out (runs out of retransmits) this is
269 IPMI_STAT_timed_out_lan_commands
,
271 /* Responses I have sent to the IPMB bus. */
272 IPMI_STAT_sent_lan_responses
,
274 /* The response was delivered to the user. */
275 IPMI_STAT_handled_lan_responses
,
277 /* The response had invalid data in it. */
278 IPMI_STAT_invalid_lan_responses
,
280 /* The response didn't have anyone waiting for it. */
281 IPMI_STAT_unhandled_lan_responses
,
283 /* The command was delivered to the user. */
284 IPMI_STAT_handled_commands
,
286 /* The command had invalid data in it. */
287 IPMI_STAT_invalid_commands
,
289 /* The command didn't have anyone waiting for it. */
290 IPMI_STAT_unhandled_commands
,
292 /* Invalid data in an event. */
293 IPMI_STAT_invalid_events
,
295 /* Events that were received with the proper format. */
298 /* Retransmissions on IPMB that failed. */
299 IPMI_STAT_dropped_rexmit_ipmb_commands
,
301 /* Retransmissions on LAN that failed. */
302 IPMI_STAT_dropped_rexmit_lan_commands
,
304 /* This *must* remain last, add new values above this. */
309 #define IPMI_IPMB_NUM_SEQ 64
310 #define IPMI_MAX_CHANNELS 16
312 /* What interface number are we? */
315 struct kref refcount
;
317 /* Set when the interface is being unregistered. */
320 /* Used for a list of interfaces. */
321 struct list_head link
;
324 * The list of upper layers that are using me. seq_lock
327 struct list_head users
;
329 /* Information to supply to users. */
330 unsigned char ipmi_version_major
;
331 unsigned char ipmi_version_minor
;
333 /* Used for wake ups at startup. */
334 wait_queue_head_t waitq
;
336 struct bmc_device
*bmc
;
340 * This is the lower-layer's sender routine. Note that you
341 * must either be holding the ipmi_interfaces_mutex or be in
342 * an umpreemptible region to use this. You must fetch the
343 * value into a local variable and make sure it is not NULL.
345 struct ipmi_smi_handlers
*handlers
;
348 #ifdef CONFIG_PROC_FS
349 /* A list of proc entries for this interface. */
350 struct mutex proc_entry_lock
;
351 struct ipmi_proc_entry
*proc_entries
;
354 /* Driver-model device for the system interface. */
355 struct device
*si_dev
;
358 * A table of sequence numbers for this interface. We use the
359 * sequence numbers for IPMB messages that go out of the
360 * interface to match them up with their responses. A routine
361 * is called periodically to time the items in this list.
364 struct seq_table seq_table
[IPMI_IPMB_NUM_SEQ
];
368 * Messages queued for delivery. If delivery fails (out of memory
369 * for instance), They will stay in here to be processed later in a
370 * periodic timer interrupt. The tasklet is for handling received
371 * messages directly from the handler.
373 spinlock_t waiting_rcv_msgs_lock
;
374 struct list_head waiting_rcv_msgs
;
375 atomic_t watchdog_pretimeouts_to_deliver
;
376 struct tasklet_struct recv_tasklet
;
378 spinlock_t xmit_msgs_lock
;
379 struct list_head xmit_msgs
;
380 struct ipmi_smi_msg
*curr_msg
;
381 struct list_head hp_xmit_msgs
;
384 * The list of command receivers that are registered for commands
387 struct mutex cmd_rcvrs_mutex
;
388 struct list_head cmd_rcvrs
;
391 * Events that were queues because no one was there to receive
394 spinlock_t events_lock
; /* For dealing with event stuff. */
395 struct list_head waiting_events
;
396 unsigned int waiting_events_count
; /* How many events in queue? */
397 char delivering_events
;
398 char event_msg_printed
;
399 atomic_t event_waiters
;
400 unsigned int ticks_to_req_ev
;
401 int last_needs_timer
;
404 * The event receiver for my BMC, only really used at panic
405 * shutdown as a place to store this.
407 unsigned char event_receiver
;
408 unsigned char event_receiver_lun
;
409 unsigned char local_sel_device
;
410 unsigned char local_event_generator
;
412 /* For handling of maintenance mode. */
413 int maintenance_mode
;
414 bool maintenance_mode_enable
;
415 int auto_maintenance_timeout
;
416 spinlock_t maintenance_mode_lock
; /* Used in a timer... */
419 * A cheap hack, if this is non-null and a message to an
420 * interface comes in with a NULL user, call this routine with
421 * it. Note that the message will still be freed by the
422 * caller. This only works on the system interface.
424 void (*null_user_handler
)(ipmi_smi_t intf
, struct ipmi_recv_msg
*msg
);
427 * When we are scanning the channels for an SMI, this will
428 * tell which channel we are scanning.
432 /* Channel information */
433 struct ipmi_channel channels
[IPMI_MAX_CHANNELS
];
436 struct proc_dir_entry
*proc_dir
;
437 char proc_dir_name
[10];
439 atomic_t stats
[IPMI_NUM_STATS
];
442 * run_to_completion duplicate of smb_info, smi_info
443 * and ipmi_serial_info structures. Used to decrease numbers of
444 * parameters passed by "low" level IPMI code.
446 int run_to_completion
;
448 #define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
451 * The driver model view of the IPMI messaging driver.
453 static struct platform_driver ipmidriver
= {
456 .bus
= &platform_bus_type
459 static DEFINE_MUTEX(ipmidriver_mutex
);
461 static LIST_HEAD(ipmi_interfaces
);
462 static DEFINE_MUTEX(ipmi_interfaces_mutex
);
465 * List of watchers that want to know when smi's are added and deleted.
467 static LIST_HEAD(smi_watchers
);
468 static DEFINE_MUTEX(smi_watchers_mutex
);
470 #define ipmi_inc_stat(intf, stat) \
471 atomic_inc(&(intf)->stats[IPMI_STAT_ ## stat])
472 #define ipmi_get_stat(intf, stat) \
473 ((unsigned int) atomic_read(&(intf)->stats[IPMI_STAT_ ## stat]))
475 static char *addr_src_to_str
[] = { "invalid", "hotmod", "hardcoded", "SPMI",
476 "ACPI", "SMBIOS", "PCI",
477 "device-tree", "default" };
479 const char *ipmi_addr_src_to_str(enum ipmi_addr_src src
)
481 if (src
> SI_DEFAULT
)
482 src
= 0; /* Invalid */
483 return addr_src_to_str
[src
];
485 EXPORT_SYMBOL(ipmi_addr_src_to_str
);
487 static int is_lan_addr(struct ipmi_addr
*addr
)
489 return addr
->addr_type
== IPMI_LAN_ADDR_TYPE
;
492 static int is_ipmb_addr(struct ipmi_addr
*addr
)
494 return addr
->addr_type
== IPMI_IPMB_ADDR_TYPE
;
497 static int is_ipmb_bcast_addr(struct ipmi_addr
*addr
)
499 return addr
->addr_type
== IPMI_IPMB_BROADCAST_ADDR_TYPE
;
502 static void free_recv_msg_list(struct list_head
*q
)
504 struct ipmi_recv_msg
*msg
, *msg2
;
506 list_for_each_entry_safe(msg
, msg2
, q
, link
) {
507 list_del(&msg
->link
);
508 ipmi_free_recv_msg(msg
);
512 static void free_smi_msg_list(struct list_head
*q
)
514 struct ipmi_smi_msg
*msg
, *msg2
;
516 list_for_each_entry_safe(msg
, msg2
, q
, link
) {
517 list_del(&msg
->link
);
518 ipmi_free_smi_msg(msg
);
522 static void clean_up_interface_data(ipmi_smi_t intf
)
525 struct cmd_rcvr
*rcvr
, *rcvr2
;
526 struct list_head list
;
528 tasklet_kill(&intf
->recv_tasklet
);
530 free_smi_msg_list(&intf
->waiting_rcv_msgs
);
531 free_recv_msg_list(&intf
->waiting_events
);
534 * Wholesale remove all the entries from the list in the
535 * interface and wait for RCU to know that none are in use.
537 mutex_lock(&intf
->cmd_rcvrs_mutex
);
538 INIT_LIST_HEAD(&list
);
539 list_splice_init_rcu(&intf
->cmd_rcvrs
, &list
, synchronize_rcu
);
540 mutex_unlock(&intf
->cmd_rcvrs_mutex
);
542 list_for_each_entry_safe(rcvr
, rcvr2
, &list
, link
)
545 for (i
= 0; i
< IPMI_IPMB_NUM_SEQ
; i
++) {
546 if ((intf
->seq_table
[i
].inuse
)
547 && (intf
->seq_table
[i
].recv_msg
))
548 ipmi_free_recv_msg(intf
->seq_table
[i
].recv_msg
);
552 static void intf_free(struct kref
*ref
)
554 ipmi_smi_t intf
= container_of(ref
, struct ipmi_smi
, refcount
);
556 clean_up_interface_data(intf
);
560 struct watcher_entry
{
563 struct list_head link
;
566 int ipmi_smi_watcher_register(struct ipmi_smi_watcher
*watcher
)
569 LIST_HEAD(to_deliver
);
570 struct watcher_entry
*e
, *e2
;
572 mutex_lock(&smi_watchers_mutex
);
574 mutex_lock(&ipmi_interfaces_mutex
);
576 /* Build a list of things to deliver. */
577 list_for_each_entry(intf
, &ipmi_interfaces
, link
) {
578 if (intf
->intf_num
== -1)
580 e
= kmalloc(sizeof(*e
), GFP_KERNEL
);
583 kref_get(&intf
->refcount
);
585 e
->intf_num
= intf
->intf_num
;
586 list_add_tail(&e
->link
, &to_deliver
);
589 /* We will succeed, so add it to the list. */
590 list_add(&watcher
->link
, &smi_watchers
);
592 mutex_unlock(&ipmi_interfaces_mutex
);
594 list_for_each_entry_safe(e
, e2
, &to_deliver
, link
) {
596 watcher
->new_smi(e
->intf_num
, e
->intf
->si_dev
);
597 kref_put(&e
->intf
->refcount
, intf_free
);
601 mutex_unlock(&smi_watchers_mutex
);
606 mutex_unlock(&ipmi_interfaces_mutex
);
607 mutex_unlock(&smi_watchers_mutex
);
608 list_for_each_entry_safe(e
, e2
, &to_deliver
, link
) {
610 kref_put(&e
->intf
->refcount
, intf_free
);
615 EXPORT_SYMBOL(ipmi_smi_watcher_register
);
617 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher
*watcher
)
619 mutex_lock(&smi_watchers_mutex
);
620 list_del(&(watcher
->link
));
621 mutex_unlock(&smi_watchers_mutex
);
624 EXPORT_SYMBOL(ipmi_smi_watcher_unregister
);
627 * Must be called with smi_watchers_mutex held.
630 call_smi_watchers(int i
, struct device
*dev
)
632 struct ipmi_smi_watcher
*w
;
634 list_for_each_entry(w
, &smi_watchers
, link
) {
635 if (try_module_get(w
->owner
)) {
637 module_put(w
->owner
);
643 ipmi_addr_equal(struct ipmi_addr
*addr1
, struct ipmi_addr
*addr2
)
645 if (addr1
->addr_type
!= addr2
->addr_type
)
648 if (addr1
->channel
!= addr2
->channel
)
651 if (addr1
->addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
) {
652 struct ipmi_system_interface_addr
*smi_addr1
653 = (struct ipmi_system_interface_addr
*) addr1
;
654 struct ipmi_system_interface_addr
*smi_addr2
655 = (struct ipmi_system_interface_addr
*) addr2
;
656 return (smi_addr1
->lun
== smi_addr2
->lun
);
659 if (is_ipmb_addr(addr1
) || is_ipmb_bcast_addr(addr1
)) {
660 struct ipmi_ipmb_addr
*ipmb_addr1
661 = (struct ipmi_ipmb_addr
*) addr1
;
662 struct ipmi_ipmb_addr
*ipmb_addr2
663 = (struct ipmi_ipmb_addr
*) addr2
;
665 return ((ipmb_addr1
->slave_addr
== ipmb_addr2
->slave_addr
)
666 && (ipmb_addr1
->lun
== ipmb_addr2
->lun
));
669 if (is_lan_addr(addr1
)) {
670 struct ipmi_lan_addr
*lan_addr1
671 = (struct ipmi_lan_addr
*) addr1
;
672 struct ipmi_lan_addr
*lan_addr2
673 = (struct ipmi_lan_addr
*) addr2
;
675 return ((lan_addr1
->remote_SWID
== lan_addr2
->remote_SWID
)
676 && (lan_addr1
->local_SWID
== lan_addr2
->local_SWID
)
677 && (lan_addr1
->session_handle
678 == lan_addr2
->session_handle
)
679 && (lan_addr1
->lun
== lan_addr2
->lun
));
685 int ipmi_validate_addr(struct ipmi_addr
*addr
, int len
)
687 if (len
< sizeof(struct ipmi_system_interface_addr
))
690 if (addr
->addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
) {
691 if (addr
->channel
!= IPMI_BMC_CHANNEL
)
696 if ((addr
->channel
== IPMI_BMC_CHANNEL
)
697 || (addr
->channel
>= IPMI_MAX_CHANNELS
)
698 || (addr
->channel
< 0))
701 if (is_ipmb_addr(addr
) || is_ipmb_bcast_addr(addr
)) {
702 if (len
< sizeof(struct ipmi_ipmb_addr
))
707 if (is_lan_addr(addr
)) {
708 if (len
< sizeof(struct ipmi_lan_addr
))
715 EXPORT_SYMBOL(ipmi_validate_addr
);
717 unsigned int ipmi_addr_length(int addr_type
)
719 if (addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
)
720 return sizeof(struct ipmi_system_interface_addr
);
722 if ((addr_type
== IPMI_IPMB_ADDR_TYPE
)
723 || (addr_type
== IPMI_IPMB_BROADCAST_ADDR_TYPE
))
724 return sizeof(struct ipmi_ipmb_addr
);
726 if (addr_type
== IPMI_LAN_ADDR_TYPE
)
727 return sizeof(struct ipmi_lan_addr
);
731 EXPORT_SYMBOL(ipmi_addr_length
);
733 static void deliver_response(struct ipmi_recv_msg
*msg
)
736 ipmi_smi_t intf
= msg
->user_msg_data
;
738 /* Special handling for NULL users. */
739 if (intf
->null_user_handler
) {
740 intf
->null_user_handler(intf
, msg
);
741 ipmi_inc_stat(intf
, handled_local_responses
);
743 /* No handler, so give up. */
744 ipmi_inc_stat(intf
, unhandled_local_responses
);
746 ipmi_free_recv_msg(msg
);
748 ipmi_user_t user
= msg
->user
;
749 user
->handler
->ipmi_recv_hndl(msg
, user
->handler_data
);
754 deliver_err_response(struct ipmi_recv_msg
*msg
, int err
)
756 msg
->recv_type
= IPMI_RESPONSE_RECV_TYPE
;
757 msg
->msg_data
[0] = err
;
758 msg
->msg
.netfn
|= 1; /* Convert to a response. */
759 msg
->msg
.data_len
= 1;
760 msg
->msg
.data
= msg
->msg_data
;
761 deliver_response(msg
);
765 * Find the next sequence number not being used and add the given
766 * message with the given timeout to the sequence table. This must be
767 * called with the interface's seq_lock held.
769 static int intf_next_seq(ipmi_smi_t intf
,
770 struct ipmi_recv_msg
*recv_msg
,
771 unsigned long timeout
,
780 for (i
= intf
->curr_seq
; (i
+1)%IPMI_IPMB_NUM_SEQ
!= intf
->curr_seq
;
781 i
= (i
+1)%IPMI_IPMB_NUM_SEQ
) {
782 if (!intf
->seq_table
[i
].inuse
)
786 if (!intf
->seq_table
[i
].inuse
) {
787 intf
->seq_table
[i
].recv_msg
= recv_msg
;
790 * Start with the maximum timeout, when the send response
791 * comes in we will start the real timer.
793 intf
->seq_table
[i
].timeout
= MAX_MSG_TIMEOUT
;
794 intf
->seq_table
[i
].orig_timeout
= timeout
;
795 intf
->seq_table
[i
].retries_left
= retries
;
796 intf
->seq_table
[i
].broadcast
= broadcast
;
797 intf
->seq_table
[i
].inuse
= 1;
798 intf
->seq_table
[i
].seqid
= NEXT_SEQID(intf
->seq_table
[i
].seqid
);
800 *seqid
= intf
->seq_table
[i
].seqid
;
801 intf
->curr_seq
= (i
+1)%IPMI_IPMB_NUM_SEQ
;
811 * Return the receive message for the given sequence number and
812 * release the sequence number so it can be reused. Some other data
813 * is passed in to be sure the message matches up correctly (to help
814 * guard against message coming in after their timeout and the
815 * sequence number being reused).
817 static int intf_find_seq(ipmi_smi_t intf
,
822 struct ipmi_addr
*addr
,
823 struct ipmi_recv_msg
**recv_msg
)
828 if (seq
>= IPMI_IPMB_NUM_SEQ
)
831 spin_lock_irqsave(&(intf
->seq_lock
), flags
);
832 if (intf
->seq_table
[seq
].inuse
) {
833 struct ipmi_recv_msg
*msg
= intf
->seq_table
[seq
].recv_msg
;
835 if ((msg
->addr
.channel
== channel
) && (msg
->msg
.cmd
== cmd
)
836 && (msg
->msg
.netfn
== netfn
)
837 && (ipmi_addr_equal(addr
, &(msg
->addr
)))) {
839 intf
->seq_table
[seq
].inuse
= 0;
843 spin_unlock_irqrestore(&(intf
->seq_lock
), flags
);
849 /* Start the timer for a specific sequence table entry. */
850 static int intf_start_seq_timer(ipmi_smi_t intf
,
859 GET_SEQ_FROM_MSGID(msgid
, seq
, seqid
);
861 spin_lock_irqsave(&(intf
->seq_lock
), flags
);
863 * We do this verification because the user can be deleted
864 * while a message is outstanding.
866 if ((intf
->seq_table
[seq
].inuse
)
867 && (intf
->seq_table
[seq
].seqid
== seqid
)) {
868 struct seq_table
*ent
= &(intf
->seq_table
[seq
]);
869 ent
->timeout
= ent
->orig_timeout
;
872 spin_unlock_irqrestore(&(intf
->seq_lock
), flags
);
877 /* Got an error for the send message for a specific sequence number. */
878 static int intf_err_seq(ipmi_smi_t intf
,
886 struct ipmi_recv_msg
*msg
= NULL
;
889 GET_SEQ_FROM_MSGID(msgid
, seq
, seqid
);
891 spin_lock_irqsave(&(intf
->seq_lock
), flags
);
893 * We do this verification because the user can be deleted
894 * while a message is outstanding.
896 if ((intf
->seq_table
[seq
].inuse
)
897 && (intf
->seq_table
[seq
].seqid
== seqid
)) {
898 struct seq_table
*ent
= &(intf
->seq_table
[seq
]);
904 spin_unlock_irqrestore(&(intf
->seq_lock
), flags
);
907 deliver_err_response(msg
, err
);
913 int ipmi_create_user(unsigned int if_num
,
914 struct ipmi_user_hndl
*handler
,
919 ipmi_user_t new_user
;
924 * There is no module usecount here, because it's not
925 * required. Since this can only be used by and called from
926 * other modules, they will implicitly use this module, and
927 * thus this can't be removed unless the other modules are
935 * Make sure the driver is actually initialized, this handles
936 * problems with initialization order.
939 rv
= ipmi_init_msghandler();
944 * The init code doesn't return an error if it was turned
945 * off, but it won't initialize. Check that.
951 new_user
= kmalloc(sizeof(*new_user
), GFP_KERNEL
);
955 mutex_lock(&ipmi_interfaces_mutex
);
956 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
957 if (intf
->intf_num
== if_num
)
960 /* Not found, return an error */
965 /* Note that each existing user holds a refcount to the interface. */
966 kref_get(&intf
->refcount
);
968 kref_init(&new_user
->refcount
);
969 new_user
->handler
= handler
;
970 new_user
->handler_data
= handler_data
;
971 new_user
->intf
= intf
;
972 new_user
->gets_events
= false;
974 if (!try_module_get(intf
->handlers
->owner
)) {
979 if (intf
->handlers
->inc_usecount
) {
980 rv
= intf
->handlers
->inc_usecount(intf
->send_info
);
982 module_put(intf
->handlers
->owner
);
988 * Hold the lock so intf->handlers is guaranteed to be good
991 mutex_unlock(&ipmi_interfaces_mutex
);
993 new_user
->valid
= true;
994 spin_lock_irqsave(&intf
->seq_lock
, flags
);
995 list_add_rcu(&new_user
->link
, &intf
->users
);
996 spin_unlock_irqrestore(&intf
->seq_lock
, flags
);
997 if (handler
->ipmi_watchdog_pretimeout
) {
998 /* User wants pretimeouts, so make sure to watch for them. */
999 if (atomic_inc_return(&intf
->event_waiters
) == 1)
1006 kref_put(&intf
->refcount
, intf_free
);
1008 mutex_unlock(&ipmi_interfaces_mutex
);
1012 EXPORT_SYMBOL(ipmi_create_user
);
1014 int ipmi_get_smi_info(int if_num
, struct ipmi_smi_info
*data
)
1018 struct ipmi_smi_handlers
*handlers
;
1020 mutex_lock(&ipmi_interfaces_mutex
);
1021 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
1022 if (intf
->intf_num
== if_num
)
1025 /* Not found, return an error */
1027 mutex_unlock(&ipmi_interfaces_mutex
);
1031 handlers
= intf
->handlers
;
1033 if (handlers
->get_smi_info
)
1034 rv
= handlers
->get_smi_info(intf
->send_info
, data
);
1035 mutex_unlock(&ipmi_interfaces_mutex
);
1039 EXPORT_SYMBOL(ipmi_get_smi_info
);
1041 static void free_user(struct kref
*ref
)
1043 ipmi_user_t user
= container_of(ref
, struct ipmi_user
, refcount
);
1047 int ipmi_destroy_user(ipmi_user_t user
)
1049 ipmi_smi_t intf
= user
->intf
;
1051 unsigned long flags
;
1052 struct cmd_rcvr
*rcvr
;
1053 struct cmd_rcvr
*rcvrs
= NULL
;
1055 user
->valid
= false;
1057 if (user
->handler
->ipmi_watchdog_pretimeout
)
1058 atomic_dec(&intf
->event_waiters
);
1060 if (user
->gets_events
)
1061 atomic_dec(&intf
->event_waiters
);
1063 /* Remove the user from the interface's sequence table. */
1064 spin_lock_irqsave(&intf
->seq_lock
, flags
);
1065 list_del_rcu(&user
->link
);
1067 for (i
= 0; i
< IPMI_IPMB_NUM_SEQ
; i
++) {
1068 if (intf
->seq_table
[i
].inuse
1069 && (intf
->seq_table
[i
].recv_msg
->user
== user
)) {
1070 intf
->seq_table
[i
].inuse
= 0;
1071 ipmi_free_recv_msg(intf
->seq_table
[i
].recv_msg
);
1074 spin_unlock_irqrestore(&intf
->seq_lock
, flags
);
1077 * Remove the user from the command receiver's table. First
1078 * we build a list of everything (not using the standard link,
1079 * since other things may be using it till we do
1080 * synchronize_rcu()) then free everything in that list.
1082 mutex_lock(&intf
->cmd_rcvrs_mutex
);
1083 list_for_each_entry_rcu(rcvr
, &intf
->cmd_rcvrs
, link
) {
1084 if (rcvr
->user
== user
) {
1085 list_del_rcu(&rcvr
->link
);
1090 mutex_unlock(&intf
->cmd_rcvrs_mutex
);
1098 mutex_lock(&ipmi_interfaces_mutex
);
1099 if (intf
->handlers
) {
1100 module_put(intf
->handlers
->owner
);
1101 if (intf
->handlers
->dec_usecount
)
1102 intf
->handlers
->dec_usecount(intf
->send_info
);
1104 mutex_unlock(&ipmi_interfaces_mutex
);
1106 kref_put(&intf
->refcount
, intf_free
);
1108 kref_put(&user
->refcount
, free_user
);
1112 EXPORT_SYMBOL(ipmi_destroy_user
);
1114 void ipmi_get_version(ipmi_user_t user
,
1115 unsigned char *major
,
1116 unsigned char *minor
)
1118 *major
= user
->intf
->ipmi_version_major
;
1119 *minor
= user
->intf
->ipmi_version_minor
;
1121 EXPORT_SYMBOL(ipmi_get_version
);
1123 int ipmi_set_my_address(ipmi_user_t user
,
1124 unsigned int channel
,
1125 unsigned char address
)
1127 if (channel
>= IPMI_MAX_CHANNELS
)
1129 user
->intf
->channels
[channel
].address
= address
;
1132 EXPORT_SYMBOL(ipmi_set_my_address
);
1134 int ipmi_get_my_address(ipmi_user_t user
,
1135 unsigned int channel
,
1136 unsigned char *address
)
1138 if (channel
>= IPMI_MAX_CHANNELS
)
1140 *address
= user
->intf
->channels
[channel
].address
;
1143 EXPORT_SYMBOL(ipmi_get_my_address
);
1145 int ipmi_set_my_LUN(ipmi_user_t user
,
1146 unsigned int channel
,
1149 if (channel
>= IPMI_MAX_CHANNELS
)
1151 user
->intf
->channels
[channel
].lun
= LUN
& 0x3;
1154 EXPORT_SYMBOL(ipmi_set_my_LUN
);
1156 int ipmi_get_my_LUN(ipmi_user_t user
,
1157 unsigned int channel
,
1158 unsigned char *address
)
1160 if (channel
>= IPMI_MAX_CHANNELS
)
1162 *address
= user
->intf
->channels
[channel
].lun
;
1165 EXPORT_SYMBOL(ipmi_get_my_LUN
);
1167 int ipmi_get_maintenance_mode(ipmi_user_t user
)
1170 unsigned long flags
;
1172 spin_lock_irqsave(&user
->intf
->maintenance_mode_lock
, flags
);
1173 mode
= user
->intf
->maintenance_mode
;
1174 spin_unlock_irqrestore(&user
->intf
->maintenance_mode_lock
, flags
);
1178 EXPORT_SYMBOL(ipmi_get_maintenance_mode
);
1180 static void maintenance_mode_update(ipmi_smi_t intf
)
1182 if (intf
->handlers
->set_maintenance_mode
)
1183 intf
->handlers
->set_maintenance_mode(
1184 intf
->send_info
, intf
->maintenance_mode_enable
);
1187 int ipmi_set_maintenance_mode(ipmi_user_t user
, int mode
)
1190 unsigned long flags
;
1191 ipmi_smi_t intf
= user
->intf
;
1193 spin_lock_irqsave(&intf
->maintenance_mode_lock
, flags
);
1194 if (intf
->maintenance_mode
!= mode
) {
1196 case IPMI_MAINTENANCE_MODE_AUTO
:
1197 intf
->maintenance_mode_enable
1198 = (intf
->auto_maintenance_timeout
> 0);
1201 case IPMI_MAINTENANCE_MODE_OFF
:
1202 intf
->maintenance_mode_enable
= false;
1205 case IPMI_MAINTENANCE_MODE_ON
:
1206 intf
->maintenance_mode_enable
= true;
1213 intf
->maintenance_mode
= mode
;
1215 maintenance_mode_update(intf
);
1218 spin_unlock_irqrestore(&intf
->maintenance_mode_lock
, flags
);
1222 EXPORT_SYMBOL(ipmi_set_maintenance_mode
);
1224 int ipmi_set_gets_events(ipmi_user_t user
, bool val
)
1226 unsigned long flags
;
1227 ipmi_smi_t intf
= user
->intf
;
1228 struct ipmi_recv_msg
*msg
, *msg2
;
1229 struct list_head msgs
;
1231 INIT_LIST_HEAD(&msgs
);
1233 spin_lock_irqsave(&intf
->events_lock
, flags
);
1234 if (user
->gets_events
== val
)
1237 user
->gets_events
= val
;
1240 if (atomic_inc_return(&intf
->event_waiters
) == 1)
1243 atomic_dec(&intf
->event_waiters
);
1246 if (intf
->delivering_events
)
1248 * Another thread is delivering events for this, so
1249 * let it handle any new events.
1253 /* Deliver any queued events. */
1254 while (user
->gets_events
&& !list_empty(&intf
->waiting_events
)) {
1255 list_for_each_entry_safe(msg
, msg2
, &intf
->waiting_events
, link
)
1256 list_move_tail(&msg
->link
, &msgs
);
1257 intf
->waiting_events_count
= 0;
1258 if (intf
->event_msg_printed
) {
1259 printk(KERN_WARNING PFX
"Event queue no longer"
1261 intf
->event_msg_printed
= 0;
1264 intf
->delivering_events
= 1;
1265 spin_unlock_irqrestore(&intf
->events_lock
, flags
);
1267 list_for_each_entry_safe(msg
, msg2
, &msgs
, link
) {
1269 kref_get(&user
->refcount
);
1270 deliver_response(msg
);
1273 spin_lock_irqsave(&intf
->events_lock
, flags
);
1274 intf
->delivering_events
= 0;
1278 spin_unlock_irqrestore(&intf
->events_lock
, flags
);
1282 EXPORT_SYMBOL(ipmi_set_gets_events
);
1284 static struct cmd_rcvr
*find_cmd_rcvr(ipmi_smi_t intf
,
1285 unsigned char netfn
,
1289 struct cmd_rcvr
*rcvr
;
1291 list_for_each_entry_rcu(rcvr
, &intf
->cmd_rcvrs
, link
) {
1292 if ((rcvr
->netfn
== netfn
) && (rcvr
->cmd
== cmd
)
1293 && (rcvr
->chans
& (1 << chan
)))
1299 static int is_cmd_rcvr_exclusive(ipmi_smi_t intf
,
1300 unsigned char netfn
,
1304 struct cmd_rcvr
*rcvr
;
1306 list_for_each_entry_rcu(rcvr
, &intf
->cmd_rcvrs
, link
) {
1307 if ((rcvr
->netfn
== netfn
) && (rcvr
->cmd
== cmd
)
1308 && (rcvr
->chans
& chans
))
1314 int ipmi_register_for_cmd(ipmi_user_t user
,
1315 unsigned char netfn
,
1319 ipmi_smi_t intf
= user
->intf
;
1320 struct cmd_rcvr
*rcvr
;
1324 rcvr
= kmalloc(sizeof(*rcvr
), GFP_KERNEL
);
1328 rcvr
->netfn
= netfn
;
1329 rcvr
->chans
= chans
;
1332 mutex_lock(&intf
->cmd_rcvrs_mutex
);
1333 /* Make sure the command/netfn is not already registered. */
1334 if (!is_cmd_rcvr_exclusive(intf
, netfn
, cmd
, chans
)) {
1339 if (atomic_inc_return(&intf
->event_waiters
) == 1)
1342 list_add_rcu(&rcvr
->link
, &intf
->cmd_rcvrs
);
1345 mutex_unlock(&intf
->cmd_rcvrs_mutex
);
1351 EXPORT_SYMBOL(ipmi_register_for_cmd
);
1353 int ipmi_unregister_for_cmd(ipmi_user_t user
,
1354 unsigned char netfn
,
1358 ipmi_smi_t intf
= user
->intf
;
1359 struct cmd_rcvr
*rcvr
;
1360 struct cmd_rcvr
*rcvrs
= NULL
;
1361 int i
, rv
= -ENOENT
;
1363 mutex_lock(&intf
->cmd_rcvrs_mutex
);
1364 for (i
= 0; i
< IPMI_NUM_CHANNELS
; i
++) {
1365 if (((1 << i
) & chans
) == 0)
1367 rcvr
= find_cmd_rcvr(intf
, netfn
, cmd
, i
);
1370 if (rcvr
->user
== user
) {
1372 rcvr
->chans
&= ~chans
;
1373 if (rcvr
->chans
== 0) {
1374 list_del_rcu(&rcvr
->link
);
1380 mutex_unlock(&intf
->cmd_rcvrs_mutex
);
1383 atomic_dec(&intf
->event_waiters
);
1390 EXPORT_SYMBOL(ipmi_unregister_for_cmd
);
1392 static unsigned char
1393 ipmb_checksum(unsigned char *data
, int size
)
1395 unsigned char csum
= 0;
1397 for (; size
> 0; size
--, data
++)
1403 static inline void format_ipmb_msg(struct ipmi_smi_msg
*smi_msg
,
1404 struct kernel_ipmi_msg
*msg
,
1405 struct ipmi_ipmb_addr
*ipmb_addr
,
1407 unsigned char ipmb_seq
,
1409 unsigned char source_address
,
1410 unsigned char source_lun
)
1414 /* Format the IPMB header data. */
1415 smi_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
1416 smi_msg
->data
[1] = IPMI_SEND_MSG_CMD
;
1417 smi_msg
->data
[2] = ipmb_addr
->channel
;
1419 smi_msg
->data
[3] = 0;
1420 smi_msg
->data
[i
+3] = ipmb_addr
->slave_addr
;
1421 smi_msg
->data
[i
+4] = (msg
->netfn
<< 2) | (ipmb_addr
->lun
& 0x3);
1422 smi_msg
->data
[i
+5] = ipmb_checksum(&(smi_msg
->data
[i
+3]), 2);
1423 smi_msg
->data
[i
+6] = source_address
;
1424 smi_msg
->data
[i
+7] = (ipmb_seq
<< 2) | source_lun
;
1425 smi_msg
->data
[i
+8] = msg
->cmd
;
1427 /* Now tack on the data to the message. */
1428 if (msg
->data_len
> 0)
1429 memcpy(&(smi_msg
->data
[i
+9]), msg
->data
,
1431 smi_msg
->data_size
= msg
->data_len
+ 9;
1433 /* Now calculate the checksum and tack it on. */
1434 smi_msg
->data
[i
+smi_msg
->data_size
]
1435 = ipmb_checksum(&(smi_msg
->data
[i
+6]),
1436 smi_msg
->data_size
-6);
1439 * Add on the checksum size and the offset from the
1442 smi_msg
->data_size
+= 1 + i
;
1444 smi_msg
->msgid
= msgid
;
1447 static inline void format_lan_msg(struct ipmi_smi_msg
*smi_msg
,
1448 struct kernel_ipmi_msg
*msg
,
1449 struct ipmi_lan_addr
*lan_addr
,
1451 unsigned char ipmb_seq
,
1452 unsigned char source_lun
)
1454 /* Format the IPMB header data. */
1455 smi_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
1456 smi_msg
->data
[1] = IPMI_SEND_MSG_CMD
;
1457 smi_msg
->data
[2] = lan_addr
->channel
;
1458 smi_msg
->data
[3] = lan_addr
->session_handle
;
1459 smi_msg
->data
[4] = lan_addr
->remote_SWID
;
1460 smi_msg
->data
[5] = (msg
->netfn
<< 2) | (lan_addr
->lun
& 0x3);
1461 smi_msg
->data
[6] = ipmb_checksum(&(smi_msg
->data
[4]), 2);
1462 smi_msg
->data
[7] = lan_addr
->local_SWID
;
1463 smi_msg
->data
[8] = (ipmb_seq
<< 2) | source_lun
;
1464 smi_msg
->data
[9] = msg
->cmd
;
1466 /* Now tack on the data to the message. */
1467 if (msg
->data_len
> 0)
1468 memcpy(&(smi_msg
->data
[10]), msg
->data
,
1470 smi_msg
->data_size
= msg
->data_len
+ 10;
1472 /* Now calculate the checksum and tack it on. */
1473 smi_msg
->data
[smi_msg
->data_size
]
1474 = ipmb_checksum(&(smi_msg
->data
[7]),
1475 smi_msg
->data_size
-7);
1478 * Add on the checksum size and the offset from the
1481 smi_msg
->data_size
+= 1;
1483 smi_msg
->msgid
= msgid
;
1486 static struct ipmi_smi_msg
*smi_add_send_msg(ipmi_smi_t intf
,
1487 struct ipmi_smi_msg
*smi_msg
,
1490 if (intf
->curr_msg
) {
1492 list_add_tail(&smi_msg
->link
, &intf
->hp_xmit_msgs
);
1494 list_add_tail(&smi_msg
->link
, &intf
->xmit_msgs
);
1497 intf
->curr_msg
= smi_msg
;
1504 static void smi_send(ipmi_smi_t intf
, struct ipmi_smi_handlers
*handlers
,
1505 struct ipmi_smi_msg
*smi_msg
, int priority
)
1507 int run_to_completion
= intf
->run_to_completion
;
1509 if (run_to_completion
) {
1510 smi_msg
= smi_add_send_msg(intf
, smi_msg
, priority
);
1512 unsigned long flags
;
1514 spin_lock_irqsave(&intf
->xmit_msgs_lock
, flags
);
1515 smi_msg
= smi_add_send_msg(intf
, smi_msg
, priority
);
1516 spin_unlock_irqrestore(&intf
->xmit_msgs_lock
, flags
);
1520 handlers
->sender(intf
->send_info
, smi_msg
);
1524 * Separate from ipmi_request so that the user does not have to be
1525 * supplied in certain circumstances (mainly at panic time). If
1526 * messages are supplied, they will be freed, even if an error
1529 static int i_ipmi_request(ipmi_user_t user
,
1531 struct ipmi_addr
*addr
,
1533 struct kernel_ipmi_msg
*msg
,
1534 void *user_msg_data
,
1536 struct ipmi_recv_msg
*supplied_recv
,
1538 unsigned char source_address
,
1539 unsigned char source_lun
,
1541 unsigned int retry_time_ms
)
1544 struct ipmi_smi_msg
*smi_msg
;
1545 struct ipmi_recv_msg
*recv_msg
;
1546 unsigned long flags
;
1550 recv_msg
= supplied_recv
;
1552 recv_msg
= ipmi_alloc_recv_msg();
1553 if (recv_msg
== NULL
)
1556 recv_msg
->user_msg_data
= user_msg_data
;
1559 smi_msg
= (struct ipmi_smi_msg
*) supplied_smi
;
1561 smi_msg
= ipmi_alloc_smi_msg();
1562 if (smi_msg
== NULL
) {
1563 ipmi_free_recv_msg(recv_msg
);
1569 if (intf
->in_shutdown
) {
1574 recv_msg
->user
= user
;
1576 kref_get(&user
->refcount
);
1577 recv_msg
->msgid
= msgid
;
1579 * Store the message to send in the receive message so timeout
1580 * responses can get the proper response data.
1582 recv_msg
->msg
= *msg
;
1584 if (addr
->addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
) {
1585 struct ipmi_system_interface_addr
*smi_addr
;
1587 if (msg
->netfn
& 1) {
1588 /* Responses are not allowed to the SMI. */
1593 smi_addr
= (struct ipmi_system_interface_addr
*) addr
;
1594 if (smi_addr
->lun
> 3) {
1595 ipmi_inc_stat(intf
, sent_invalid_commands
);
1600 memcpy(&recv_msg
->addr
, smi_addr
, sizeof(*smi_addr
));
1602 if ((msg
->netfn
== IPMI_NETFN_APP_REQUEST
)
1603 && ((msg
->cmd
== IPMI_SEND_MSG_CMD
)
1604 || (msg
->cmd
== IPMI_GET_MSG_CMD
)
1605 || (msg
->cmd
== IPMI_READ_EVENT_MSG_BUFFER_CMD
))) {
1607 * We don't let the user do these, since we manage
1608 * the sequence numbers.
1610 ipmi_inc_stat(intf
, sent_invalid_commands
);
1615 if (((msg
->netfn
== IPMI_NETFN_APP_REQUEST
)
1616 && ((msg
->cmd
== IPMI_COLD_RESET_CMD
)
1617 || (msg
->cmd
== IPMI_WARM_RESET_CMD
)))
1618 || (msg
->netfn
== IPMI_NETFN_FIRMWARE_REQUEST
)) {
1619 spin_lock_irqsave(&intf
->maintenance_mode_lock
, flags
);
1620 intf
->auto_maintenance_timeout
1621 = IPMI_MAINTENANCE_MODE_TIMEOUT
;
1622 if (!intf
->maintenance_mode
1623 && !intf
->maintenance_mode_enable
) {
1624 intf
->maintenance_mode_enable
= true;
1625 maintenance_mode_update(intf
);
1627 spin_unlock_irqrestore(&intf
->maintenance_mode_lock
,
1631 if ((msg
->data_len
+ 2) > IPMI_MAX_MSG_LENGTH
) {
1632 ipmi_inc_stat(intf
, sent_invalid_commands
);
1637 smi_msg
->data
[0] = (msg
->netfn
<< 2) | (smi_addr
->lun
& 0x3);
1638 smi_msg
->data
[1] = msg
->cmd
;
1639 smi_msg
->msgid
= msgid
;
1640 smi_msg
->user_data
= recv_msg
;
1641 if (msg
->data_len
> 0)
1642 memcpy(&(smi_msg
->data
[2]), msg
->data
, msg
->data_len
);
1643 smi_msg
->data_size
= msg
->data_len
+ 2;
1644 ipmi_inc_stat(intf
, sent_local_commands
);
1645 } else if (is_ipmb_addr(addr
) || is_ipmb_bcast_addr(addr
)) {
1646 struct ipmi_ipmb_addr
*ipmb_addr
;
1647 unsigned char ipmb_seq
;
1651 if (addr
->channel
>= IPMI_MAX_CHANNELS
) {
1652 ipmi_inc_stat(intf
, sent_invalid_commands
);
1657 if (intf
->channels
[addr
->channel
].medium
1658 != IPMI_CHANNEL_MEDIUM_IPMB
) {
1659 ipmi_inc_stat(intf
, sent_invalid_commands
);
1665 if (addr
->addr_type
== IPMI_IPMB_BROADCAST_ADDR_TYPE
)
1666 retries
= 0; /* Don't retry broadcasts. */
1670 if (addr
->addr_type
== IPMI_IPMB_BROADCAST_ADDR_TYPE
) {
1672 * Broadcasts add a zero at the beginning of the
1673 * message, but otherwise is the same as an IPMB
1676 addr
->addr_type
= IPMI_IPMB_ADDR_TYPE
;
1681 /* Default to 1 second retries. */
1682 if (retry_time_ms
== 0)
1683 retry_time_ms
= 1000;
1686 * 9 for the header and 1 for the checksum, plus
1687 * possibly one for the broadcast.
1689 if ((msg
->data_len
+ 10 + broadcast
) > IPMI_MAX_MSG_LENGTH
) {
1690 ipmi_inc_stat(intf
, sent_invalid_commands
);
1695 ipmb_addr
= (struct ipmi_ipmb_addr
*) addr
;
1696 if (ipmb_addr
->lun
> 3) {
1697 ipmi_inc_stat(intf
, sent_invalid_commands
);
1702 memcpy(&recv_msg
->addr
, ipmb_addr
, sizeof(*ipmb_addr
));
1704 if (recv_msg
->msg
.netfn
& 0x1) {
1706 * It's a response, so use the user's sequence
1709 ipmi_inc_stat(intf
, sent_ipmb_responses
);
1710 format_ipmb_msg(smi_msg
, msg
, ipmb_addr
, msgid
,
1712 source_address
, source_lun
);
1715 * Save the receive message so we can use it
1716 * to deliver the response.
1718 smi_msg
->user_data
= recv_msg
;
1720 /* It's a command, so get a sequence for it. */
1722 spin_lock_irqsave(&(intf
->seq_lock
), flags
);
1725 * Create a sequence number with a 1 second
1726 * timeout and 4 retries.
1728 rv
= intf_next_seq(intf
,
1737 * We have used up all the sequence numbers,
1738 * probably, so abort.
1740 spin_unlock_irqrestore(&(intf
->seq_lock
),
1745 ipmi_inc_stat(intf
, sent_ipmb_commands
);
1748 * Store the sequence number in the message,
1749 * so that when the send message response
1750 * comes back we can start the timer.
1752 format_ipmb_msg(smi_msg
, msg
, ipmb_addr
,
1753 STORE_SEQ_IN_MSGID(ipmb_seq
, seqid
),
1754 ipmb_seq
, broadcast
,
1755 source_address
, source_lun
);
1758 * Copy the message into the recv message data, so we
1759 * can retransmit it later if necessary.
1761 memcpy(recv_msg
->msg_data
, smi_msg
->data
,
1762 smi_msg
->data_size
);
1763 recv_msg
->msg
.data
= recv_msg
->msg_data
;
1764 recv_msg
->msg
.data_len
= smi_msg
->data_size
;
1767 * We don't unlock until here, because we need
1768 * to copy the completed message into the
1769 * recv_msg before we release the lock.
1770 * Otherwise, race conditions may bite us. I
1771 * know that's pretty paranoid, but I prefer
1774 spin_unlock_irqrestore(&(intf
->seq_lock
), flags
);
1776 } else if (is_lan_addr(addr
)) {
1777 struct ipmi_lan_addr
*lan_addr
;
1778 unsigned char ipmb_seq
;
1781 if (addr
->channel
>= IPMI_MAX_CHANNELS
) {
1782 ipmi_inc_stat(intf
, sent_invalid_commands
);
1787 if ((intf
->channels
[addr
->channel
].medium
1788 != IPMI_CHANNEL_MEDIUM_8023LAN
)
1789 && (intf
->channels
[addr
->channel
].medium
1790 != IPMI_CHANNEL_MEDIUM_ASYNC
)) {
1791 ipmi_inc_stat(intf
, sent_invalid_commands
);
1798 /* Default to 1 second retries. */
1799 if (retry_time_ms
== 0)
1800 retry_time_ms
= 1000;
1802 /* 11 for the header and 1 for the checksum. */
1803 if ((msg
->data_len
+ 12) > IPMI_MAX_MSG_LENGTH
) {
1804 ipmi_inc_stat(intf
, sent_invalid_commands
);
1809 lan_addr
= (struct ipmi_lan_addr
*) addr
;
1810 if (lan_addr
->lun
> 3) {
1811 ipmi_inc_stat(intf
, sent_invalid_commands
);
1816 memcpy(&recv_msg
->addr
, lan_addr
, sizeof(*lan_addr
));
1818 if (recv_msg
->msg
.netfn
& 0x1) {
1820 * It's a response, so use the user's sequence
1823 ipmi_inc_stat(intf
, sent_lan_responses
);
1824 format_lan_msg(smi_msg
, msg
, lan_addr
, msgid
,
1828 * Save the receive message so we can use it
1829 * to deliver the response.
1831 smi_msg
->user_data
= recv_msg
;
1833 /* It's a command, so get a sequence for it. */
1835 spin_lock_irqsave(&(intf
->seq_lock
), flags
);
1838 * Create a sequence number with a 1 second
1839 * timeout and 4 retries.
1841 rv
= intf_next_seq(intf
,
1850 * We have used up all the sequence numbers,
1851 * probably, so abort.
1853 spin_unlock_irqrestore(&(intf
->seq_lock
),
1858 ipmi_inc_stat(intf
, sent_lan_commands
);
1861 * Store the sequence number in the message,
1862 * so that when the send message response
1863 * comes back we can start the timer.
1865 format_lan_msg(smi_msg
, msg
, lan_addr
,
1866 STORE_SEQ_IN_MSGID(ipmb_seq
, seqid
),
1867 ipmb_seq
, source_lun
);
1870 * Copy the message into the recv message data, so we
1871 * can retransmit it later if necessary.
1873 memcpy(recv_msg
->msg_data
, smi_msg
->data
,
1874 smi_msg
->data_size
);
1875 recv_msg
->msg
.data
= recv_msg
->msg_data
;
1876 recv_msg
->msg
.data_len
= smi_msg
->data_size
;
1879 * We don't unlock until here, because we need
1880 * to copy the completed message into the
1881 * recv_msg before we release the lock.
1882 * Otherwise, race conditions may bite us. I
1883 * know that's pretty paranoid, but I prefer
1886 spin_unlock_irqrestore(&(intf
->seq_lock
), flags
);
1889 /* Unknown address type. */
1890 ipmi_inc_stat(intf
, sent_invalid_commands
);
1898 for (m
= 0; m
< smi_msg
->data_size
; m
++)
1899 printk(" %2.2x", smi_msg
->data
[m
]);
1904 smi_send(intf
, intf
->handlers
, smi_msg
, priority
);
1911 ipmi_free_smi_msg(smi_msg
);
1912 ipmi_free_recv_msg(recv_msg
);
1916 static int check_addr(ipmi_smi_t intf
,
1917 struct ipmi_addr
*addr
,
1918 unsigned char *saddr
,
1921 if (addr
->channel
>= IPMI_MAX_CHANNELS
)
1923 *lun
= intf
->channels
[addr
->channel
].lun
;
1924 *saddr
= intf
->channels
[addr
->channel
].address
;
1928 int ipmi_request_settime(ipmi_user_t user
,
1929 struct ipmi_addr
*addr
,
1931 struct kernel_ipmi_msg
*msg
,
1932 void *user_msg_data
,
1935 unsigned int retry_time_ms
)
1937 unsigned char saddr
= 0, lun
= 0;
1942 rv
= check_addr(user
->intf
, addr
, &saddr
, &lun
);
1945 return i_ipmi_request(user
,
1958 EXPORT_SYMBOL(ipmi_request_settime
);
1960 int ipmi_request_supply_msgs(ipmi_user_t user
,
1961 struct ipmi_addr
*addr
,
1963 struct kernel_ipmi_msg
*msg
,
1964 void *user_msg_data
,
1966 struct ipmi_recv_msg
*supplied_recv
,
1969 unsigned char saddr
= 0, lun
= 0;
1974 rv
= check_addr(user
->intf
, addr
, &saddr
, &lun
);
1977 return i_ipmi_request(user
,
1990 EXPORT_SYMBOL(ipmi_request_supply_msgs
);
1992 #ifdef CONFIG_PROC_FS
1993 static int smi_ipmb_proc_show(struct seq_file
*m
, void *v
)
1995 ipmi_smi_t intf
= m
->private;
1998 seq_printf(m
, "%x", intf
->channels
[0].address
);
1999 for (i
= 1; i
< IPMI_MAX_CHANNELS
; i
++)
2000 seq_printf(m
, " %x", intf
->channels
[i
].address
);
2003 return seq_has_overflowed(m
);
2006 static int smi_ipmb_proc_open(struct inode
*inode
, struct file
*file
)
2008 return single_open(file
, smi_ipmb_proc_show
, PDE_DATA(inode
));
2011 static const struct file_operations smi_ipmb_proc_ops
= {
2012 .open
= smi_ipmb_proc_open
,
2014 .llseek
= seq_lseek
,
2015 .release
= single_release
,
2018 static int smi_version_proc_show(struct seq_file
*m
, void *v
)
2020 ipmi_smi_t intf
= m
->private;
2022 seq_printf(m
, "%u.%u\n",
2023 ipmi_version_major(&intf
->bmc
->id
),
2024 ipmi_version_minor(&intf
->bmc
->id
));
2026 return seq_has_overflowed(m
);
2029 static int smi_version_proc_open(struct inode
*inode
, struct file
*file
)
2031 return single_open(file
, smi_version_proc_show
, PDE_DATA(inode
));
2034 static const struct file_operations smi_version_proc_ops
= {
2035 .open
= smi_version_proc_open
,
2037 .llseek
= seq_lseek
,
2038 .release
= single_release
,
2041 static int smi_stats_proc_show(struct seq_file
*m
, void *v
)
2043 ipmi_smi_t intf
= m
->private;
2045 seq_printf(m
, "sent_invalid_commands: %u\n",
2046 ipmi_get_stat(intf
, sent_invalid_commands
));
2047 seq_printf(m
, "sent_local_commands: %u\n",
2048 ipmi_get_stat(intf
, sent_local_commands
));
2049 seq_printf(m
, "handled_local_responses: %u\n",
2050 ipmi_get_stat(intf
, handled_local_responses
));
2051 seq_printf(m
, "unhandled_local_responses: %u\n",
2052 ipmi_get_stat(intf
, unhandled_local_responses
));
2053 seq_printf(m
, "sent_ipmb_commands: %u\n",
2054 ipmi_get_stat(intf
, sent_ipmb_commands
));
2055 seq_printf(m
, "sent_ipmb_command_errs: %u\n",
2056 ipmi_get_stat(intf
, sent_ipmb_command_errs
));
2057 seq_printf(m
, "retransmitted_ipmb_commands: %u\n",
2058 ipmi_get_stat(intf
, retransmitted_ipmb_commands
));
2059 seq_printf(m
, "timed_out_ipmb_commands: %u\n",
2060 ipmi_get_stat(intf
, timed_out_ipmb_commands
));
2061 seq_printf(m
, "timed_out_ipmb_broadcasts: %u\n",
2062 ipmi_get_stat(intf
, timed_out_ipmb_broadcasts
));
2063 seq_printf(m
, "sent_ipmb_responses: %u\n",
2064 ipmi_get_stat(intf
, sent_ipmb_responses
));
2065 seq_printf(m
, "handled_ipmb_responses: %u\n",
2066 ipmi_get_stat(intf
, handled_ipmb_responses
));
2067 seq_printf(m
, "invalid_ipmb_responses: %u\n",
2068 ipmi_get_stat(intf
, invalid_ipmb_responses
));
2069 seq_printf(m
, "unhandled_ipmb_responses: %u\n",
2070 ipmi_get_stat(intf
, unhandled_ipmb_responses
));
2071 seq_printf(m
, "sent_lan_commands: %u\n",
2072 ipmi_get_stat(intf
, sent_lan_commands
));
2073 seq_printf(m
, "sent_lan_command_errs: %u\n",
2074 ipmi_get_stat(intf
, sent_lan_command_errs
));
2075 seq_printf(m
, "retransmitted_lan_commands: %u\n",
2076 ipmi_get_stat(intf
, retransmitted_lan_commands
));
2077 seq_printf(m
, "timed_out_lan_commands: %u\n",
2078 ipmi_get_stat(intf
, timed_out_lan_commands
));
2079 seq_printf(m
, "sent_lan_responses: %u\n",
2080 ipmi_get_stat(intf
, sent_lan_responses
));
2081 seq_printf(m
, "handled_lan_responses: %u\n",
2082 ipmi_get_stat(intf
, handled_lan_responses
));
2083 seq_printf(m
, "invalid_lan_responses: %u\n",
2084 ipmi_get_stat(intf
, invalid_lan_responses
));
2085 seq_printf(m
, "unhandled_lan_responses: %u\n",
2086 ipmi_get_stat(intf
, unhandled_lan_responses
));
2087 seq_printf(m
, "handled_commands: %u\n",
2088 ipmi_get_stat(intf
, handled_commands
));
2089 seq_printf(m
, "invalid_commands: %u\n",
2090 ipmi_get_stat(intf
, invalid_commands
));
2091 seq_printf(m
, "unhandled_commands: %u\n",
2092 ipmi_get_stat(intf
, unhandled_commands
));
2093 seq_printf(m
, "invalid_events: %u\n",
2094 ipmi_get_stat(intf
, invalid_events
));
2095 seq_printf(m
, "events: %u\n",
2096 ipmi_get_stat(intf
, events
));
2097 seq_printf(m
, "failed rexmit LAN msgs: %u\n",
2098 ipmi_get_stat(intf
, dropped_rexmit_lan_commands
));
2099 seq_printf(m
, "failed rexmit IPMB msgs: %u\n",
2100 ipmi_get_stat(intf
, dropped_rexmit_ipmb_commands
));
2104 static int smi_stats_proc_open(struct inode
*inode
, struct file
*file
)
2106 return single_open(file
, smi_stats_proc_show
, PDE_DATA(inode
));
2109 static const struct file_operations smi_stats_proc_ops
= {
2110 .open
= smi_stats_proc_open
,
2112 .llseek
= seq_lseek
,
2113 .release
= single_release
,
2115 #endif /* CONFIG_PROC_FS */
2117 int ipmi_smi_add_proc_entry(ipmi_smi_t smi
, char *name
,
2118 const struct file_operations
*proc_ops
,
2122 #ifdef CONFIG_PROC_FS
2123 struct proc_dir_entry
*file
;
2124 struct ipmi_proc_entry
*entry
;
2126 /* Create a list element. */
2127 entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
);
2130 entry
->name
= kstrdup(name
, GFP_KERNEL
);
2136 file
= proc_create_data(name
, 0, smi
->proc_dir
, proc_ops
, data
);
2142 mutex_lock(&smi
->proc_entry_lock
);
2143 /* Stick it on the list. */
2144 entry
->next
= smi
->proc_entries
;
2145 smi
->proc_entries
= entry
;
2146 mutex_unlock(&smi
->proc_entry_lock
);
2148 #endif /* CONFIG_PROC_FS */
2152 EXPORT_SYMBOL(ipmi_smi_add_proc_entry
);
2154 static int add_proc_entries(ipmi_smi_t smi
, int num
)
2158 #ifdef CONFIG_PROC_FS
2159 sprintf(smi
->proc_dir_name
, "%d", num
);
2160 smi
->proc_dir
= proc_mkdir(smi
->proc_dir_name
, proc_ipmi_root
);
2165 rv
= ipmi_smi_add_proc_entry(smi
, "stats",
2166 &smi_stats_proc_ops
,
2170 rv
= ipmi_smi_add_proc_entry(smi
, "ipmb",
2175 rv
= ipmi_smi_add_proc_entry(smi
, "version",
2176 &smi_version_proc_ops
,
2178 #endif /* CONFIG_PROC_FS */
2183 static void remove_proc_entries(ipmi_smi_t smi
)
2185 #ifdef CONFIG_PROC_FS
2186 struct ipmi_proc_entry
*entry
;
2188 mutex_lock(&smi
->proc_entry_lock
);
2189 while (smi
->proc_entries
) {
2190 entry
= smi
->proc_entries
;
2191 smi
->proc_entries
= entry
->next
;
2193 remove_proc_entry(entry
->name
, smi
->proc_dir
);
2197 mutex_unlock(&smi
->proc_entry_lock
);
2198 remove_proc_entry(smi
->proc_dir_name
, proc_ipmi_root
);
2199 #endif /* CONFIG_PROC_FS */
2202 static int __find_bmc_guid(struct device
*dev
, void *data
)
2204 unsigned char *id
= data
;
2205 struct bmc_device
*bmc
= to_bmc_device(dev
);
2206 return memcmp(bmc
->guid
, id
, 16) == 0;
2209 static struct bmc_device
*ipmi_find_bmc_guid(struct device_driver
*drv
,
2210 unsigned char *guid
)
2214 dev
= driver_find_device(drv
, NULL
, guid
, __find_bmc_guid
);
2216 return to_bmc_device(dev
);
2221 struct prod_dev_id
{
2222 unsigned int product_id
;
2223 unsigned char device_id
;
2226 static int __find_bmc_prod_dev_id(struct device
*dev
, void *data
)
2228 struct prod_dev_id
*id
= data
;
2229 struct bmc_device
*bmc
= to_bmc_device(dev
);
2231 return (bmc
->id
.product_id
== id
->product_id
2232 && bmc
->id
.device_id
== id
->device_id
);
2235 static struct bmc_device
*ipmi_find_bmc_prod_dev_id(
2236 struct device_driver
*drv
,
2237 unsigned int product_id
, unsigned char device_id
)
2239 struct prod_dev_id id
= {
2240 .product_id
= product_id
,
2241 .device_id
= device_id
,
2245 dev
= driver_find_device(drv
, NULL
, &id
, __find_bmc_prod_dev_id
);
2247 return to_bmc_device(dev
);
2252 static ssize_t
device_id_show(struct device
*dev
,
2253 struct device_attribute
*attr
,
2256 struct bmc_device
*bmc
= to_bmc_device(dev
);
2258 return snprintf(buf
, 10, "%u\n", bmc
->id
.device_id
);
2260 static DEVICE_ATTR(device_id
, S_IRUGO
, device_id_show
, NULL
);
2262 static ssize_t
provides_device_sdrs_show(struct device
*dev
,
2263 struct device_attribute
*attr
,
2266 struct bmc_device
*bmc
= to_bmc_device(dev
);
2268 return snprintf(buf
, 10, "%u\n",
2269 (bmc
->id
.device_revision
& 0x80) >> 7);
2271 static DEVICE_ATTR(provides_device_sdrs
, S_IRUGO
, provides_device_sdrs_show
,
2274 static ssize_t
revision_show(struct device
*dev
, struct device_attribute
*attr
,
2277 struct bmc_device
*bmc
= to_bmc_device(dev
);
2279 return snprintf(buf
, 20, "%u\n",
2280 bmc
->id
.device_revision
& 0x0F);
2282 static DEVICE_ATTR(revision
, S_IRUGO
, revision_show
, NULL
);
2284 static ssize_t
firmware_revision_show(struct device
*dev
,
2285 struct device_attribute
*attr
,
2288 struct bmc_device
*bmc
= to_bmc_device(dev
);
2290 return snprintf(buf
, 20, "%u.%x\n", bmc
->id
.firmware_revision_1
,
2291 bmc
->id
.firmware_revision_2
);
2293 static DEVICE_ATTR(firmware_revision
, S_IRUGO
, firmware_revision_show
, NULL
);
2295 static ssize_t
ipmi_version_show(struct device
*dev
,
2296 struct device_attribute
*attr
,
2299 struct bmc_device
*bmc
= to_bmc_device(dev
);
2301 return snprintf(buf
, 20, "%u.%u\n",
2302 ipmi_version_major(&bmc
->id
),
2303 ipmi_version_minor(&bmc
->id
));
2305 static DEVICE_ATTR(ipmi_version
, S_IRUGO
, ipmi_version_show
, NULL
);
2307 static ssize_t
add_dev_support_show(struct device
*dev
,
2308 struct device_attribute
*attr
,
2311 struct bmc_device
*bmc
= to_bmc_device(dev
);
2313 return snprintf(buf
, 10, "0x%02x\n",
2314 bmc
->id
.additional_device_support
);
2316 static DEVICE_ATTR(additional_device_support
, S_IRUGO
, add_dev_support_show
,
2319 static ssize_t
manufacturer_id_show(struct device
*dev
,
2320 struct device_attribute
*attr
,
2323 struct bmc_device
*bmc
= to_bmc_device(dev
);
2325 return snprintf(buf
, 20, "0x%6.6x\n", bmc
->id
.manufacturer_id
);
2327 static DEVICE_ATTR(manufacturer_id
, S_IRUGO
, manufacturer_id_show
, NULL
);
2329 static ssize_t
product_id_show(struct device
*dev
,
2330 struct device_attribute
*attr
,
2333 struct bmc_device
*bmc
= to_bmc_device(dev
);
2335 return snprintf(buf
, 10, "0x%4.4x\n", bmc
->id
.product_id
);
2337 static DEVICE_ATTR(product_id
, S_IRUGO
, product_id_show
, NULL
);
2339 static ssize_t
aux_firmware_rev_show(struct device
*dev
,
2340 struct device_attribute
*attr
,
2343 struct bmc_device
*bmc
= to_bmc_device(dev
);
2345 return snprintf(buf
, 21, "0x%02x 0x%02x 0x%02x 0x%02x\n",
2346 bmc
->id
.aux_firmware_revision
[3],
2347 bmc
->id
.aux_firmware_revision
[2],
2348 bmc
->id
.aux_firmware_revision
[1],
2349 bmc
->id
.aux_firmware_revision
[0]);
2351 static DEVICE_ATTR(aux_firmware_revision
, S_IRUGO
, aux_firmware_rev_show
, NULL
);
2353 static ssize_t
guid_show(struct device
*dev
, struct device_attribute
*attr
,
2356 struct bmc_device
*bmc
= to_bmc_device(dev
);
2358 return snprintf(buf
, 100, "%Lx%Lx\n",
2359 (long long) bmc
->guid
[0],
2360 (long long) bmc
->guid
[8]);
2362 static DEVICE_ATTR(guid
, S_IRUGO
, guid_show
, NULL
);
2364 static struct attribute
*bmc_dev_attrs
[] = {
2365 &dev_attr_device_id
.attr
,
2366 &dev_attr_provides_device_sdrs
.attr
,
2367 &dev_attr_revision
.attr
,
2368 &dev_attr_firmware_revision
.attr
,
2369 &dev_attr_ipmi_version
.attr
,
2370 &dev_attr_additional_device_support
.attr
,
2371 &dev_attr_manufacturer_id
.attr
,
2372 &dev_attr_product_id
.attr
,
2373 &dev_attr_aux_firmware_revision
.attr
,
2374 &dev_attr_guid
.attr
,
2378 static umode_t
bmc_dev_attr_is_visible(struct kobject
*kobj
,
2379 struct attribute
*attr
, int idx
)
2381 struct device
*dev
= kobj_to_dev(kobj
);
2382 struct bmc_device
*bmc
= to_bmc_device(dev
);
2383 umode_t mode
= attr
->mode
;
2385 if (attr
== &dev_attr_aux_firmware_revision
.attr
)
2386 return bmc
->id
.aux_firmware_revision_set
? mode
: 0;
2387 if (attr
== &dev_attr_guid
.attr
)
2388 return bmc
->guid_set
? mode
: 0;
2392 static struct attribute_group bmc_dev_attr_group
= {
2393 .attrs
= bmc_dev_attrs
,
2394 .is_visible
= bmc_dev_attr_is_visible
,
2397 static const struct attribute_group
*bmc_dev_attr_groups
[] = {
2398 &bmc_dev_attr_group
,
2402 static struct device_type bmc_device_type
= {
2403 .groups
= bmc_dev_attr_groups
,
2407 release_bmc_device(struct device
*dev
)
2409 kfree(to_bmc_device(dev
));
2413 cleanup_bmc_device(struct kref
*ref
)
2415 struct bmc_device
*bmc
= container_of(ref
, struct bmc_device
, usecount
);
2417 platform_device_unregister(&bmc
->pdev
);
2420 static void ipmi_bmc_unregister(ipmi_smi_t intf
)
2422 struct bmc_device
*bmc
= intf
->bmc
;
2424 sysfs_remove_link(&intf
->si_dev
->kobj
, "bmc");
2425 if (intf
->my_dev_name
) {
2426 sysfs_remove_link(&bmc
->pdev
.dev
.kobj
, intf
->my_dev_name
);
2427 kfree(intf
->my_dev_name
);
2428 intf
->my_dev_name
= NULL
;
2431 mutex_lock(&ipmidriver_mutex
);
2432 kref_put(&bmc
->usecount
, cleanup_bmc_device
);
2434 mutex_unlock(&ipmidriver_mutex
);
2437 static int ipmi_bmc_register(ipmi_smi_t intf
, int ifnum
)
2440 struct bmc_device
*bmc
= intf
->bmc
;
2441 struct bmc_device
*old_bmc
;
2443 mutex_lock(&ipmidriver_mutex
);
2446 * Try to find if there is an bmc_device struct
2447 * representing the interfaced BMC already
2450 old_bmc
= ipmi_find_bmc_guid(&ipmidriver
.driver
, bmc
->guid
);
2452 old_bmc
= ipmi_find_bmc_prod_dev_id(&ipmidriver
.driver
,
2457 * If there is already an bmc_device, free the new one,
2458 * otherwise register the new BMC device
2462 intf
->bmc
= old_bmc
;
2465 kref_get(&bmc
->usecount
);
2466 mutex_unlock(&ipmidriver_mutex
);
2469 "ipmi: interfacing existing BMC (man_id: 0x%6.6x,"
2470 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
2471 bmc
->id
.manufacturer_id
,
2475 unsigned char orig_dev_id
= bmc
->id
.device_id
;
2476 int warn_printed
= 0;
2478 snprintf(bmc
->name
, sizeof(bmc
->name
),
2479 "ipmi_bmc.%4.4x", bmc
->id
.product_id
);
2480 bmc
->pdev
.name
= bmc
->name
;
2482 while (ipmi_find_bmc_prod_dev_id(&ipmidriver
.driver
,
2484 bmc
->id
.device_id
)) {
2485 if (!warn_printed
) {
2486 printk(KERN_WARNING PFX
2487 "This machine has two different BMCs"
2488 " with the same product id and device"
2489 " id. This is an error in the"
2490 " firmware, but incrementing the"
2491 " device id to work around the problem."
2492 " Prod ID = 0x%x, Dev ID = 0x%x\n",
2493 bmc
->id
.product_id
, bmc
->id
.device_id
);
2496 bmc
->id
.device_id
++; /* Wraps at 255 */
2497 if (bmc
->id
.device_id
== orig_dev_id
) {
2499 "Out of device ids!\n");
2504 bmc
->pdev
.dev
.driver
= &ipmidriver
.driver
;
2505 bmc
->pdev
.id
= bmc
->id
.device_id
;
2506 bmc
->pdev
.dev
.release
= release_bmc_device
;
2507 bmc
->pdev
.dev
.type
= &bmc_device_type
;
2508 kref_init(&bmc
->usecount
);
2510 rv
= platform_device_register(&bmc
->pdev
);
2511 mutex_unlock(&ipmidriver_mutex
);
2513 put_device(&bmc
->pdev
.dev
);
2516 " Unable to register bmc device: %d\n",
2519 * Don't go to out_err, you can only do that if
2520 * the device is registered already.
2525 dev_info(intf
->si_dev
, "Found new BMC (man_id: 0x%6.6x, "
2526 "prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
2527 bmc
->id
.manufacturer_id
,
2533 * create symlink from system interface device to bmc device
2536 rv
= sysfs_create_link(&intf
->si_dev
->kobj
, &bmc
->pdev
.dev
.kobj
, "bmc");
2539 "ipmi_msghandler: Unable to create bmc symlink: %d\n",
2544 intf
->my_dev_name
= kasprintf(GFP_KERNEL
, "ipmi%d", ifnum
);
2545 if (!intf
->my_dev_name
) {
2548 "ipmi_msghandler: allocate link from BMC: %d\n",
2553 rv
= sysfs_create_link(&bmc
->pdev
.dev
.kobj
, &intf
->si_dev
->kobj
,
2556 kfree(intf
->my_dev_name
);
2557 intf
->my_dev_name
= NULL
;
2560 " Unable to create symlink to bmc: %d\n",
2568 ipmi_bmc_unregister(intf
);
2573 send_guid_cmd(ipmi_smi_t intf
, int chan
)
2575 struct kernel_ipmi_msg msg
;
2576 struct ipmi_system_interface_addr si
;
2578 si
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
2579 si
.channel
= IPMI_BMC_CHANNEL
;
2582 msg
.netfn
= IPMI_NETFN_APP_REQUEST
;
2583 msg
.cmd
= IPMI_GET_DEVICE_GUID_CMD
;
2586 return i_ipmi_request(NULL
,
2588 (struct ipmi_addr
*) &si
,
2595 intf
->channels
[0].address
,
2596 intf
->channels
[0].lun
,
2601 guid_handler(ipmi_smi_t intf
, struct ipmi_recv_msg
*msg
)
2603 if ((msg
->addr
.addr_type
!= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
)
2604 || (msg
->msg
.netfn
!= IPMI_NETFN_APP_RESPONSE
)
2605 || (msg
->msg
.cmd
!= IPMI_GET_DEVICE_GUID_CMD
))
2609 if (msg
->msg
.data
[0] != 0) {
2610 /* Error from getting the GUID, the BMC doesn't have one. */
2611 intf
->bmc
->guid_set
= 0;
2615 if (msg
->msg
.data_len
< 17) {
2616 intf
->bmc
->guid_set
= 0;
2617 printk(KERN_WARNING PFX
2618 "guid_handler: The GUID response from the BMC was too"
2619 " short, it was %d but should have been 17. Assuming"
2620 " GUID is not available.\n",
2625 memcpy(intf
->bmc
->guid
, msg
->msg
.data
, 16);
2626 intf
->bmc
->guid_set
= 1;
2628 wake_up(&intf
->waitq
);
2632 get_guid(ipmi_smi_t intf
)
2636 intf
->bmc
->guid_set
= 0x2;
2637 intf
->null_user_handler
= guid_handler
;
2638 rv
= send_guid_cmd(intf
, 0);
2640 /* Send failed, no GUID available. */
2641 intf
->bmc
->guid_set
= 0;
2642 wait_event(intf
->waitq
, intf
->bmc
->guid_set
!= 2);
2643 intf
->null_user_handler
= NULL
;
2647 send_channel_info_cmd(ipmi_smi_t intf
, int chan
)
2649 struct kernel_ipmi_msg msg
;
2650 unsigned char data
[1];
2651 struct ipmi_system_interface_addr si
;
2653 si
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
2654 si
.channel
= IPMI_BMC_CHANNEL
;
2657 msg
.netfn
= IPMI_NETFN_APP_REQUEST
;
2658 msg
.cmd
= IPMI_GET_CHANNEL_INFO_CMD
;
2662 return i_ipmi_request(NULL
,
2664 (struct ipmi_addr
*) &si
,
2671 intf
->channels
[0].address
,
2672 intf
->channels
[0].lun
,
2677 channel_handler(ipmi_smi_t intf
, struct ipmi_recv_msg
*msg
)
2682 if ((msg
->addr
.addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
)
2683 && (msg
->msg
.netfn
== IPMI_NETFN_APP_RESPONSE
)
2684 && (msg
->msg
.cmd
== IPMI_GET_CHANNEL_INFO_CMD
)) {
2685 /* It's the one we want */
2686 if (msg
->msg
.data
[0] != 0) {
2687 /* Got an error from the channel, just go on. */
2689 if (msg
->msg
.data
[0] == IPMI_INVALID_COMMAND_ERR
) {
2691 * If the MC does not support this
2692 * command, that is legal. We just
2693 * assume it has one IPMB at channel
2696 intf
->channels
[0].medium
2697 = IPMI_CHANNEL_MEDIUM_IPMB
;
2698 intf
->channels
[0].protocol
2699 = IPMI_CHANNEL_PROTOCOL_IPMB
;
2701 intf
->curr_channel
= IPMI_MAX_CHANNELS
;
2702 wake_up(&intf
->waitq
);
2707 if (msg
->msg
.data_len
< 4) {
2708 /* Message not big enough, just go on. */
2711 chan
= intf
->curr_channel
;
2712 intf
->channels
[chan
].medium
= msg
->msg
.data
[2] & 0x7f;
2713 intf
->channels
[chan
].protocol
= msg
->msg
.data
[3] & 0x1f;
2716 intf
->curr_channel
++;
2717 if (intf
->curr_channel
>= IPMI_MAX_CHANNELS
)
2718 wake_up(&intf
->waitq
);
2720 rv
= send_channel_info_cmd(intf
, intf
->curr_channel
);
2723 /* Got an error somehow, just give up. */
2724 printk(KERN_WARNING PFX
2725 "Error sending channel information for channel"
2726 " %d: %d\n", intf
->curr_channel
, rv
);
2728 intf
->curr_channel
= IPMI_MAX_CHANNELS
;
2729 wake_up(&intf
->waitq
);
2736 static void ipmi_poll(ipmi_smi_t intf
)
2738 if (intf
->handlers
->poll
)
2739 intf
->handlers
->poll(intf
->send_info
);
2740 /* In case something came in */
2741 handle_new_recv_msgs(intf
);
2744 void ipmi_poll_interface(ipmi_user_t user
)
2746 ipmi_poll(user
->intf
);
2748 EXPORT_SYMBOL(ipmi_poll_interface
);
2750 int ipmi_register_smi(struct ipmi_smi_handlers
*handlers
,
2752 struct ipmi_device_id
*device_id
,
2753 struct device
*si_dev
,
2754 unsigned char slave_addr
)
2760 struct list_head
*link
;
2763 * Make sure the driver is actually initialized, this handles
2764 * problems with initialization order.
2767 rv
= ipmi_init_msghandler();
2771 * The init code doesn't return an error if it was turned
2772 * off, but it won't initialize. Check that.
2778 intf
= kzalloc(sizeof(*intf
), GFP_KERNEL
);
2782 intf
->ipmi_version_major
= ipmi_version_major(device_id
);
2783 intf
->ipmi_version_minor
= ipmi_version_minor(device_id
);
2785 intf
->bmc
= kzalloc(sizeof(*intf
->bmc
), GFP_KERNEL
);
2790 intf
->intf_num
= -1; /* Mark it invalid for now. */
2791 kref_init(&intf
->refcount
);
2792 intf
->bmc
->id
= *device_id
;
2793 intf
->si_dev
= si_dev
;
2794 for (j
= 0; j
< IPMI_MAX_CHANNELS
; j
++) {
2795 intf
->channels
[j
].address
= IPMI_BMC_SLAVE_ADDR
;
2796 intf
->channels
[j
].lun
= 2;
2798 if (slave_addr
!= 0)
2799 intf
->channels
[0].address
= slave_addr
;
2800 INIT_LIST_HEAD(&intf
->users
);
2801 intf
->handlers
= handlers
;
2802 intf
->send_info
= send_info
;
2803 spin_lock_init(&intf
->seq_lock
);
2804 for (j
= 0; j
< IPMI_IPMB_NUM_SEQ
; j
++) {
2805 intf
->seq_table
[j
].inuse
= 0;
2806 intf
->seq_table
[j
].seqid
= 0;
2809 #ifdef CONFIG_PROC_FS
2810 mutex_init(&intf
->proc_entry_lock
);
2812 spin_lock_init(&intf
->waiting_rcv_msgs_lock
);
2813 INIT_LIST_HEAD(&intf
->waiting_rcv_msgs
);
2814 tasklet_init(&intf
->recv_tasklet
,
2816 (unsigned long) intf
);
2817 atomic_set(&intf
->watchdog_pretimeouts_to_deliver
, 0);
2818 spin_lock_init(&intf
->xmit_msgs_lock
);
2819 INIT_LIST_HEAD(&intf
->xmit_msgs
);
2820 INIT_LIST_HEAD(&intf
->hp_xmit_msgs
);
2821 spin_lock_init(&intf
->events_lock
);
2822 atomic_set(&intf
->event_waiters
, 0);
2823 intf
->ticks_to_req_ev
= IPMI_REQUEST_EV_TIME
;
2824 INIT_LIST_HEAD(&intf
->waiting_events
);
2825 intf
->waiting_events_count
= 0;
2826 mutex_init(&intf
->cmd_rcvrs_mutex
);
2827 spin_lock_init(&intf
->maintenance_mode_lock
);
2828 INIT_LIST_HEAD(&intf
->cmd_rcvrs
);
2829 init_waitqueue_head(&intf
->waitq
);
2830 for (i
= 0; i
< IPMI_NUM_STATS
; i
++)
2831 atomic_set(&intf
->stats
[i
], 0);
2833 intf
->proc_dir
= NULL
;
2835 mutex_lock(&smi_watchers_mutex
);
2836 mutex_lock(&ipmi_interfaces_mutex
);
2837 /* Look for a hole in the numbers. */
2839 link
= &ipmi_interfaces
;
2840 list_for_each_entry_rcu(tintf
, &ipmi_interfaces
, link
) {
2841 if (tintf
->intf_num
!= i
) {
2842 link
= &tintf
->link
;
2847 /* Add the new interface in numeric order. */
2849 list_add_rcu(&intf
->link
, &ipmi_interfaces
);
2851 list_add_tail_rcu(&intf
->link
, link
);
2853 rv
= handlers
->start_processing(send_info
, intf
);
2859 if ((intf
->ipmi_version_major
> 1)
2860 || ((intf
->ipmi_version_major
== 1)
2861 && (intf
->ipmi_version_minor
>= 5))) {
2863 * Start scanning the channels to see what is
2866 intf
->null_user_handler
= channel_handler
;
2867 intf
->curr_channel
= 0;
2868 rv
= send_channel_info_cmd(intf
, 0);
2870 printk(KERN_WARNING PFX
2871 "Error sending channel information for channel"
2876 /* Wait for the channel info to be read. */
2877 wait_event(intf
->waitq
,
2878 intf
->curr_channel
>= IPMI_MAX_CHANNELS
);
2879 intf
->null_user_handler
= NULL
;
2881 /* Assume a single IPMB channel at zero. */
2882 intf
->channels
[0].medium
= IPMI_CHANNEL_MEDIUM_IPMB
;
2883 intf
->channels
[0].protocol
= IPMI_CHANNEL_PROTOCOL_IPMB
;
2884 intf
->curr_channel
= IPMI_MAX_CHANNELS
;
2888 rv
= add_proc_entries(intf
, i
);
2890 rv
= ipmi_bmc_register(intf
, i
);
2895 remove_proc_entries(intf
);
2896 intf
->handlers
= NULL
;
2897 list_del_rcu(&intf
->link
);
2898 mutex_unlock(&ipmi_interfaces_mutex
);
2899 mutex_unlock(&smi_watchers_mutex
);
2901 kref_put(&intf
->refcount
, intf_free
);
2904 * Keep memory order straight for RCU readers. Make
2905 * sure everything else is committed to memory before
2906 * setting intf_num to mark the interface valid.
2910 mutex_unlock(&ipmi_interfaces_mutex
);
2911 /* After this point the interface is legal to use. */
2912 call_smi_watchers(i
, intf
->si_dev
);
2913 mutex_unlock(&smi_watchers_mutex
);
2918 EXPORT_SYMBOL(ipmi_register_smi
);
2920 static void deliver_smi_err_response(ipmi_smi_t intf
,
2921 struct ipmi_smi_msg
*msg
,
2924 msg
->rsp
[0] = msg
->data
[0] | 4;
2925 msg
->rsp
[1] = msg
->data
[1];
2928 /* It's an error, so it will never requeue, no need to check return. */
2929 handle_one_recv_msg(intf
, msg
);
2932 static void cleanup_smi_msgs(ipmi_smi_t intf
)
2935 struct seq_table
*ent
;
2936 struct ipmi_smi_msg
*msg
;
2937 struct list_head
*entry
;
2938 struct list_head tmplist
;
2940 /* Clear out our transmit queues and hold the messages. */
2941 INIT_LIST_HEAD(&tmplist
);
2942 list_splice_tail(&intf
->hp_xmit_msgs
, &tmplist
);
2943 list_splice_tail(&intf
->xmit_msgs
, &tmplist
);
2945 /* Current message first, to preserve order */
2946 while (intf
->curr_msg
&& !list_empty(&intf
->waiting_rcv_msgs
)) {
2947 /* Wait for the message to clear out. */
2948 schedule_timeout(1);
2951 /* No need for locks, the interface is down. */
2954 * Return errors for all pending messages in queue and in the
2955 * tables waiting for remote responses.
2957 while (!list_empty(&tmplist
)) {
2958 entry
= tmplist
.next
;
2960 msg
= list_entry(entry
, struct ipmi_smi_msg
, link
);
2961 deliver_smi_err_response(intf
, msg
, IPMI_ERR_UNSPECIFIED
);
2964 for (i
= 0; i
< IPMI_IPMB_NUM_SEQ
; i
++) {
2965 ent
= &(intf
->seq_table
[i
]);
2968 deliver_err_response(ent
->recv_msg
, IPMI_ERR_UNSPECIFIED
);
2972 int ipmi_unregister_smi(ipmi_smi_t intf
)
2974 struct ipmi_smi_watcher
*w
;
2975 int intf_num
= intf
->intf_num
;
2978 ipmi_bmc_unregister(intf
);
2980 mutex_lock(&smi_watchers_mutex
);
2981 mutex_lock(&ipmi_interfaces_mutex
);
2982 intf
->intf_num
= -1;
2983 intf
->in_shutdown
= true;
2984 list_del_rcu(&intf
->link
);
2985 mutex_unlock(&ipmi_interfaces_mutex
);
2988 cleanup_smi_msgs(intf
);
2990 /* Clean up the effects of users on the lower-level software. */
2991 mutex_lock(&ipmi_interfaces_mutex
);
2993 list_for_each_entry_rcu(user
, &intf
->users
, link
) {
2994 module_put(intf
->handlers
->owner
);
2995 if (intf
->handlers
->dec_usecount
)
2996 intf
->handlers
->dec_usecount(intf
->send_info
);
2999 intf
->handlers
= NULL
;
3000 mutex_unlock(&ipmi_interfaces_mutex
);
3002 remove_proc_entries(intf
);
3005 * Call all the watcher interfaces to tell them that
3006 * an interface is gone.
3008 list_for_each_entry(w
, &smi_watchers
, link
)
3009 w
->smi_gone(intf_num
);
3010 mutex_unlock(&smi_watchers_mutex
);
3012 kref_put(&intf
->refcount
, intf_free
);
3015 EXPORT_SYMBOL(ipmi_unregister_smi
);
3017 static int handle_ipmb_get_msg_rsp(ipmi_smi_t intf
,
3018 struct ipmi_smi_msg
*msg
)
3020 struct ipmi_ipmb_addr ipmb_addr
;
3021 struct ipmi_recv_msg
*recv_msg
;
3024 * This is 11, not 10, because the response must contain a
3027 if (msg
->rsp_size
< 11) {
3028 /* Message not big enough, just ignore it. */
3029 ipmi_inc_stat(intf
, invalid_ipmb_responses
);
3033 if (msg
->rsp
[2] != 0) {
3034 /* An error getting the response, just ignore it. */
3038 ipmb_addr
.addr_type
= IPMI_IPMB_ADDR_TYPE
;
3039 ipmb_addr
.slave_addr
= msg
->rsp
[6];
3040 ipmb_addr
.channel
= msg
->rsp
[3] & 0x0f;
3041 ipmb_addr
.lun
= msg
->rsp
[7] & 3;
3044 * It's a response from a remote entity. Look up the sequence
3045 * number and handle the response.
3047 if (intf_find_seq(intf
,
3051 (msg
->rsp
[4] >> 2) & (~1),
3052 (struct ipmi_addr
*) &(ipmb_addr
),
3055 * We were unable to find the sequence number,
3056 * so just nuke the message.
3058 ipmi_inc_stat(intf
, unhandled_ipmb_responses
);
3062 memcpy(recv_msg
->msg_data
,
3066 * The other fields matched, so no need to set them, except
3067 * for netfn, which needs to be the response that was
3068 * returned, not the request value.
3070 recv_msg
->msg
.netfn
= msg
->rsp
[4] >> 2;
3071 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3072 recv_msg
->msg
.data_len
= msg
->rsp_size
- 10;
3073 recv_msg
->recv_type
= IPMI_RESPONSE_RECV_TYPE
;
3074 ipmi_inc_stat(intf
, handled_ipmb_responses
);
3075 deliver_response(recv_msg
);
3080 static int handle_ipmb_get_msg_cmd(ipmi_smi_t intf
,
3081 struct ipmi_smi_msg
*msg
)
3083 struct cmd_rcvr
*rcvr
;
3085 unsigned char netfn
;
3088 ipmi_user_t user
= NULL
;
3089 struct ipmi_ipmb_addr
*ipmb_addr
;
3090 struct ipmi_recv_msg
*recv_msg
;
3092 if (msg
->rsp_size
< 10) {
3093 /* Message not big enough, just ignore it. */
3094 ipmi_inc_stat(intf
, invalid_commands
);
3098 if (msg
->rsp
[2] != 0) {
3099 /* An error getting the response, just ignore it. */
3103 netfn
= msg
->rsp
[4] >> 2;
3105 chan
= msg
->rsp
[3] & 0xf;
3108 rcvr
= find_cmd_rcvr(intf
, netfn
, cmd
, chan
);
3111 kref_get(&user
->refcount
);
3117 /* We didn't find a user, deliver an error response. */
3118 ipmi_inc_stat(intf
, unhandled_commands
);
3120 msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
3121 msg
->data
[1] = IPMI_SEND_MSG_CMD
;
3122 msg
->data
[2] = msg
->rsp
[3];
3123 msg
->data
[3] = msg
->rsp
[6];
3124 msg
->data
[4] = ((netfn
+ 1) << 2) | (msg
->rsp
[7] & 0x3);
3125 msg
->data
[5] = ipmb_checksum(&(msg
->data
[3]), 2);
3126 msg
->data
[6] = intf
->channels
[msg
->rsp
[3] & 0xf].address
;
3128 msg
->data
[7] = (msg
->rsp
[7] & 0xfc) | (msg
->rsp
[4] & 0x3);
3129 msg
->data
[8] = msg
->rsp
[8]; /* cmd */
3130 msg
->data
[9] = IPMI_INVALID_CMD_COMPLETION_CODE
;
3131 msg
->data
[10] = ipmb_checksum(&(msg
->data
[6]), 4);
3132 msg
->data_size
= 11;
3137 printk("Invalid command:");
3138 for (m
= 0; m
< msg
->data_size
; m
++)
3139 printk(" %2.2x", msg
->data
[m
]);
3144 if (!intf
->in_shutdown
) {
3145 smi_send(intf
, intf
->handlers
, msg
, 0);
3147 * We used the message, so return the value
3148 * that causes it to not be freed or
3155 /* Deliver the message to the user. */
3156 ipmi_inc_stat(intf
, handled_commands
);
3158 recv_msg
= ipmi_alloc_recv_msg();
3161 * We couldn't allocate memory for the
3162 * message, so requeue it for handling
3166 kref_put(&user
->refcount
, free_user
);
3168 /* Extract the source address from the data. */
3169 ipmb_addr
= (struct ipmi_ipmb_addr
*) &recv_msg
->addr
;
3170 ipmb_addr
->addr_type
= IPMI_IPMB_ADDR_TYPE
;
3171 ipmb_addr
->slave_addr
= msg
->rsp
[6];
3172 ipmb_addr
->lun
= msg
->rsp
[7] & 3;
3173 ipmb_addr
->channel
= msg
->rsp
[3] & 0xf;
3176 * Extract the rest of the message information
3177 * from the IPMB header.
3179 recv_msg
->user
= user
;
3180 recv_msg
->recv_type
= IPMI_CMD_RECV_TYPE
;
3181 recv_msg
->msgid
= msg
->rsp
[7] >> 2;
3182 recv_msg
->msg
.netfn
= msg
->rsp
[4] >> 2;
3183 recv_msg
->msg
.cmd
= msg
->rsp
[8];
3184 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3187 * We chop off 10, not 9 bytes because the checksum
3188 * at the end also needs to be removed.
3190 recv_msg
->msg
.data_len
= msg
->rsp_size
- 10;
3191 memcpy(recv_msg
->msg_data
,
3193 msg
->rsp_size
- 10);
3194 deliver_response(recv_msg
);
3201 static int handle_lan_get_msg_rsp(ipmi_smi_t intf
,
3202 struct ipmi_smi_msg
*msg
)
3204 struct ipmi_lan_addr lan_addr
;
3205 struct ipmi_recv_msg
*recv_msg
;
3209 * This is 13, not 12, because the response must contain a
3212 if (msg
->rsp_size
< 13) {
3213 /* Message not big enough, just ignore it. */
3214 ipmi_inc_stat(intf
, invalid_lan_responses
);
3218 if (msg
->rsp
[2] != 0) {
3219 /* An error getting the response, just ignore it. */
3223 lan_addr
.addr_type
= IPMI_LAN_ADDR_TYPE
;
3224 lan_addr
.session_handle
= msg
->rsp
[4];
3225 lan_addr
.remote_SWID
= msg
->rsp
[8];
3226 lan_addr
.local_SWID
= msg
->rsp
[5];
3227 lan_addr
.channel
= msg
->rsp
[3] & 0x0f;
3228 lan_addr
.privilege
= msg
->rsp
[3] >> 4;
3229 lan_addr
.lun
= msg
->rsp
[9] & 3;
3232 * It's a response from a remote entity. Look up the sequence
3233 * number and handle the response.
3235 if (intf_find_seq(intf
,
3239 (msg
->rsp
[6] >> 2) & (~1),
3240 (struct ipmi_addr
*) &(lan_addr
),
3243 * We were unable to find the sequence number,
3244 * so just nuke the message.
3246 ipmi_inc_stat(intf
, unhandled_lan_responses
);
3250 memcpy(recv_msg
->msg_data
,
3252 msg
->rsp_size
- 11);
3254 * The other fields matched, so no need to set them, except
3255 * for netfn, which needs to be the response that was
3256 * returned, not the request value.
3258 recv_msg
->msg
.netfn
= msg
->rsp
[6] >> 2;
3259 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3260 recv_msg
->msg
.data_len
= msg
->rsp_size
- 12;
3261 recv_msg
->recv_type
= IPMI_RESPONSE_RECV_TYPE
;
3262 ipmi_inc_stat(intf
, handled_lan_responses
);
3263 deliver_response(recv_msg
);
3268 static int handle_lan_get_msg_cmd(ipmi_smi_t intf
,
3269 struct ipmi_smi_msg
*msg
)
3271 struct cmd_rcvr
*rcvr
;
3273 unsigned char netfn
;
3276 ipmi_user_t user
= NULL
;
3277 struct ipmi_lan_addr
*lan_addr
;
3278 struct ipmi_recv_msg
*recv_msg
;
3280 if (msg
->rsp_size
< 12) {
3281 /* Message not big enough, just ignore it. */
3282 ipmi_inc_stat(intf
, invalid_commands
);
3286 if (msg
->rsp
[2] != 0) {
3287 /* An error getting the response, just ignore it. */
3291 netfn
= msg
->rsp
[6] >> 2;
3293 chan
= msg
->rsp
[3] & 0xf;
3296 rcvr
= find_cmd_rcvr(intf
, netfn
, cmd
, chan
);
3299 kref_get(&user
->refcount
);
3305 /* We didn't find a user, just give up. */
3306 ipmi_inc_stat(intf
, unhandled_commands
);
3309 * Don't do anything with these messages, just allow
3314 /* Deliver the message to the user. */
3315 ipmi_inc_stat(intf
, handled_commands
);
3317 recv_msg
= ipmi_alloc_recv_msg();
3320 * We couldn't allocate memory for the
3321 * message, so requeue it for handling later.
3324 kref_put(&user
->refcount
, free_user
);
3326 /* Extract the source address from the data. */
3327 lan_addr
= (struct ipmi_lan_addr
*) &recv_msg
->addr
;
3328 lan_addr
->addr_type
= IPMI_LAN_ADDR_TYPE
;
3329 lan_addr
->session_handle
= msg
->rsp
[4];
3330 lan_addr
->remote_SWID
= msg
->rsp
[8];
3331 lan_addr
->local_SWID
= msg
->rsp
[5];
3332 lan_addr
->lun
= msg
->rsp
[9] & 3;
3333 lan_addr
->channel
= msg
->rsp
[3] & 0xf;
3334 lan_addr
->privilege
= msg
->rsp
[3] >> 4;
3337 * Extract the rest of the message information
3338 * from the IPMB header.
3340 recv_msg
->user
= user
;
3341 recv_msg
->recv_type
= IPMI_CMD_RECV_TYPE
;
3342 recv_msg
->msgid
= msg
->rsp
[9] >> 2;
3343 recv_msg
->msg
.netfn
= msg
->rsp
[6] >> 2;
3344 recv_msg
->msg
.cmd
= msg
->rsp
[10];
3345 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3348 * We chop off 12, not 11 bytes because the checksum
3349 * at the end also needs to be removed.
3351 recv_msg
->msg
.data_len
= msg
->rsp_size
- 12;
3352 memcpy(recv_msg
->msg_data
,
3354 msg
->rsp_size
- 12);
3355 deliver_response(recv_msg
);
3363 * This routine will handle "Get Message" command responses with
3364 * channels that use an OEM Medium. The message format belongs to
3365 * the OEM. See IPMI 2.0 specification, Chapter 6 and
3366 * Chapter 22, sections 22.6 and 22.24 for more details.
3368 static int handle_oem_get_msg_cmd(ipmi_smi_t intf
,
3369 struct ipmi_smi_msg
*msg
)
3371 struct cmd_rcvr
*rcvr
;
3373 unsigned char netfn
;
3376 ipmi_user_t user
= NULL
;
3377 struct ipmi_system_interface_addr
*smi_addr
;
3378 struct ipmi_recv_msg
*recv_msg
;
3381 * We expect the OEM SW to perform error checking
3382 * so we just do some basic sanity checks
3384 if (msg
->rsp_size
< 4) {
3385 /* Message not big enough, just ignore it. */
3386 ipmi_inc_stat(intf
, invalid_commands
);
3390 if (msg
->rsp
[2] != 0) {
3391 /* An error getting the response, just ignore it. */
3396 * This is an OEM Message so the OEM needs to know how
3397 * handle the message. We do no interpretation.
3399 netfn
= msg
->rsp
[0] >> 2;
3401 chan
= msg
->rsp
[3] & 0xf;
3404 rcvr
= find_cmd_rcvr(intf
, netfn
, cmd
, chan
);
3407 kref_get(&user
->refcount
);
3413 /* We didn't find a user, just give up. */
3414 ipmi_inc_stat(intf
, unhandled_commands
);
3417 * Don't do anything with these messages, just allow
3423 /* Deliver the message to the user. */
3424 ipmi_inc_stat(intf
, handled_commands
);
3426 recv_msg
= ipmi_alloc_recv_msg();
3429 * We couldn't allocate memory for the
3430 * message, so requeue it for handling
3434 kref_put(&user
->refcount
, free_user
);
3437 * OEM Messages are expected to be delivered via
3438 * the system interface to SMS software. We might
3439 * need to visit this again depending on OEM
3442 smi_addr
= ((struct ipmi_system_interface_addr
*)
3444 smi_addr
->addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
3445 smi_addr
->channel
= IPMI_BMC_CHANNEL
;
3446 smi_addr
->lun
= msg
->rsp
[0] & 3;
3448 recv_msg
->user
= user
;
3449 recv_msg
->user_msg_data
= NULL
;
3450 recv_msg
->recv_type
= IPMI_OEM_RECV_TYPE
;
3451 recv_msg
->msg
.netfn
= msg
->rsp
[0] >> 2;
3452 recv_msg
->msg
.cmd
= msg
->rsp
[1];
3453 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3456 * The message starts at byte 4 which follows the
3457 * the Channel Byte in the "GET MESSAGE" command
3459 recv_msg
->msg
.data_len
= msg
->rsp_size
- 4;
3460 memcpy(recv_msg
->msg_data
,
3463 deliver_response(recv_msg
);
3470 static void copy_event_into_recv_msg(struct ipmi_recv_msg
*recv_msg
,
3471 struct ipmi_smi_msg
*msg
)
3473 struct ipmi_system_interface_addr
*smi_addr
;
3475 recv_msg
->msgid
= 0;
3476 smi_addr
= (struct ipmi_system_interface_addr
*) &(recv_msg
->addr
);
3477 smi_addr
->addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
3478 smi_addr
->channel
= IPMI_BMC_CHANNEL
;
3479 smi_addr
->lun
= msg
->rsp
[0] & 3;
3480 recv_msg
->recv_type
= IPMI_ASYNC_EVENT_RECV_TYPE
;
3481 recv_msg
->msg
.netfn
= msg
->rsp
[0] >> 2;
3482 recv_msg
->msg
.cmd
= msg
->rsp
[1];
3483 memcpy(recv_msg
->msg_data
, &(msg
->rsp
[3]), msg
->rsp_size
- 3);
3484 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3485 recv_msg
->msg
.data_len
= msg
->rsp_size
- 3;
3488 static int handle_read_event_rsp(ipmi_smi_t intf
,
3489 struct ipmi_smi_msg
*msg
)
3491 struct ipmi_recv_msg
*recv_msg
, *recv_msg2
;
3492 struct list_head msgs
;
3495 int deliver_count
= 0;
3496 unsigned long flags
;
3498 if (msg
->rsp_size
< 19) {
3499 /* Message is too small to be an IPMB event. */
3500 ipmi_inc_stat(intf
, invalid_events
);
3504 if (msg
->rsp
[2] != 0) {
3505 /* An error getting the event, just ignore it. */
3509 INIT_LIST_HEAD(&msgs
);
3511 spin_lock_irqsave(&intf
->events_lock
, flags
);
3513 ipmi_inc_stat(intf
, events
);
3516 * Allocate and fill in one message for every user that is
3520 list_for_each_entry_rcu(user
, &intf
->users
, link
) {
3521 if (!user
->gets_events
)
3524 recv_msg
= ipmi_alloc_recv_msg();
3527 list_for_each_entry_safe(recv_msg
, recv_msg2
, &msgs
,
3529 list_del(&recv_msg
->link
);
3530 ipmi_free_recv_msg(recv_msg
);
3533 * We couldn't allocate memory for the
3534 * message, so requeue it for handling
3543 copy_event_into_recv_msg(recv_msg
, msg
);
3544 recv_msg
->user
= user
;
3545 kref_get(&user
->refcount
);
3546 list_add_tail(&(recv_msg
->link
), &msgs
);
3550 if (deliver_count
) {
3551 /* Now deliver all the messages. */
3552 list_for_each_entry_safe(recv_msg
, recv_msg2
, &msgs
, link
) {
3553 list_del(&recv_msg
->link
);
3554 deliver_response(recv_msg
);
3556 } else if (intf
->waiting_events_count
< MAX_EVENTS_IN_QUEUE
) {
3558 * No one to receive the message, put it in queue if there's
3559 * not already too many things in the queue.
3561 recv_msg
= ipmi_alloc_recv_msg();
3564 * We couldn't allocate memory for the
3565 * message, so requeue it for handling
3572 copy_event_into_recv_msg(recv_msg
, msg
);
3573 list_add_tail(&(recv_msg
->link
), &(intf
->waiting_events
));
3574 intf
->waiting_events_count
++;
3575 } else if (!intf
->event_msg_printed
) {
3577 * There's too many things in the queue, discard this
3580 printk(KERN_WARNING PFX
"Event queue full, discarding"
3581 " incoming events\n");
3582 intf
->event_msg_printed
= 1;
3586 spin_unlock_irqrestore(&(intf
->events_lock
), flags
);
3591 static int handle_bmc_rsp(ipmi_smi_t intf
,
3592 struct ipmi_smi_msg
*msg
)
3594 struct ipmi_recv_msg
*recv_msg
;
3595 struct ipmi_user
*user
;
3597 recv_msg
= (struct ipmi_recv_msg
*) msg
->user_data
;
3598 if (recv_msg
== NULL
) {
3600 "IPMI message received with no owner. This\n"
3601 "could be because of a malformed message, or\n"
3602 "because of a hardware error. Contact your\n"
3603 "hardware vender for assistance\n");
3607 user
= recv_msg
->user
;
3608 /* Make sure the user still exists. */
3609 if (user
&& !user
->valid
) {
3610 /* The user for the message went away, so give up. */
3611 ipmi_inc_stat(intf
, unhandled_local_responses
);
3612 ipmi_free_recv_msg(recv_msg
);
3614 struct ipmi_system_interface_addr
*smi_addr
;
3616 ipmi_inc_stat(intf
, handled_local_responses
);
3617 recv_msg
->recv_type
= IPMI_RESPONSE_RECV_TYPE
;
3618 recv_msg
->msgid
= msg
->msgid
;
3619 smi_addr
= ((struct ipmi_system_interface_addr
*)
3621 smi_addr
->addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
3622 smi_addr
->channel
= IPMI_BMC_CHANNEL
;
3623 smi_addr
->lun
= msg
->rsp
[0] & 3;
3624 recv_msg
->msg
.netfn
= msg
->rsp
[0] >> 2;
3625 recv_msg
->msg
.cmd
= msg
->rsp
[1];
3626 memcpy(recv_msg
->msg_data
,
3629 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3630 recv_msg
->msg
.data_len
= msg
->rsp_size
- 2;
3631 deliver_response(recv_msg
);
3638 * Handle a received message. Return 1 if the message should be requeued,
3639 * 0 if the message should be freed, or -1 if the message should not
3640 * be freed or requeued.
3642 static int handle_one_recv_msg(ipmi_smi_t intf
,
3643 struct ipmi_smi_msg
*msg
)
3651 for (m
= 0; m
< msg
->rsp_size
; m
++)
3652 printk(" %2.2x", msg
->rsp
[m
]);
3655 if (msg
->rsp_size
< 2) {
3656 /* Message is too small to be correct. */
3657 printk(KERN_WARNING PFX
"BMC returned to small a message"
3658 " for netfn %x cmd %x, got %d bytes\n",
3659 (msg
->data
[0] >> 2) | 1, msg
->data
[1], msg
->rsp_size
);
3661 /* Generate an error response for the message. */
3662 msg
->rsp
[0] = msg
->data
[0] | (1 << 2);
3663 msg
->rsp
[1] = msg
->data
[1];
3664 msg
->rsp
[2] = IPMI_ERR_UNSPECIFIED
;
3666 } else if (((msg
->rsp
[0] >> 2) != ((msg
->data
[0] >> 2) | 1))
3667 || (msg
->rsp
[1] != msg
->data
[1])) {
3669 * The NetFN and Command in the response is not even
3670 * marginally correct.
3672 printk(KERN_WARNING PFX
"BMC returned incorrect response,"
3673 " expected netfn %x cmd %x, got netfn %x cmd %x\n",
3674 (msg
->data
[0] >> 2) | 1, msg
->data
[1],
3675 msg
->rsp
[0] >> 2, msg
->rsp
[1]);
3677 /* Generate an error response for the message. */
3678 msg
->rsp
[0] = msg
->data
[0] | (1 << 2);
3679 msg
->rsp
[1] = msg
->data
[1];
3680 msg
->rsp
[2] = IPMI_ERR_UNSPECIFIED
;
3684 if ((msg
->rsp
[0] == ((IPMI_NETFN_APP_REQUEST
|1) << 2))
3685 && (msg
->rsp
[1] == IPMI_SEND_MSG_CMD
)
3686 && (msg
->user_data
!= NULL
)) {
3688 * It's a response to a response we sent. For this we
3689 * deliver a send message response to the user.
3691 struct ipmi_recv_msg
*recv_msg
= msg
->user_data
;
3694 if (msg
->rsp_size
< 2)
3695 /* Message is too small to be correct. */
3698 chan
= msg
->data
[2] & 0x0f;
3699 if (chan
>= IPMI_MAX_CHANNELS
)
3700 /* Invalid channel number */
3706 /* Make sure the user still exists. */
3707 if (!recv_msg
->user
|| !recv_msg
->user
->valid
)
3710 recv_msg
->recv_type
= IPMI_RESPONSE_RESPONSE_TYPE
;
3711 recv_msg
->msg
.data
= recv_msg
->msg_data
;
3712 recv_msg
->msg
.data_len
= 1;
3713 recv_msg
->msg_data
[0] = msg
->rsp
[2];
3714 deliver_response(recv_msg
);
3715 } else if ((msg
->rsp
[0] == ((IPMI_NETFN_APP_REQUEST
|1) << 2))
3716 && (msg
->rsp
[1] == IPMI_GET_MSG_CMD
)) {
3717 /* It's from the receive queue. */
3718 chan
= msg
->rsp
[3] & 0xf;
3719 if (chan
>= IPMI_MAX_CHANNELS
) {
3720 /* Invalid channel number */
3726 * We need to make sure the channels have been initialized.
3727 * The channel_handler routine will set the "curr_channel"
3728 * equal to or greater than IPMI_MAX_CHANNELS when all the
3729 * channels for this interface have been initialized.
3731 if (intf
->curr_channel
< IPMI_MAX_CHANNELS
) {
3732 requeue
= 0; /* Throw the message away */
3736 switch (intf
->channels
[chan
].medium
) {
3737 case IPMI_CHANNEL_MEDIUM_IPMB
:
3738 if (msg
->rsp
[4] & 0x04) {
3740 * It's a response, so find the
3741 * requesting message and send it up.
3743 requeue
= handle_ipmb_get_msg_rsp(intf
, msg
);
3746 * It's a command to the SMS from some other
3747 * entity. Handle that.
3749 requeue
= handle_ipmb_get_msg_cmd(intf
, msg
);
3753 case IPMI_CHANNEL_MEDIUM_8023LAN
:
3754 case IPMI_CHANNEL_MEDIUM_ASYNC
:
3755 if (msg
->rsp
[6] & 0x04) {
3757 * It's a response, so find the
3758 * requesting message and send it up.
3760 requeue
= handle_lan_get_msg_rsp(intf
, msg
);
3763 * It's a command to the SMS from some other
3764 * entity. Handle that.
3766 requeue
= handle_lan_get_msg_cmd(intf
, msg
);
3771 /* Check for OEM Channels. Clients had better
3772 register for these commands. */
3773 if ((intf
->channels
[chan
].medium
3774 >= IPMI_CHANNEL_MEDIUM_OEM_MIN
)
3775 && (intf
->channels
[chan
].medium
3776 <= IPMI_CHANNEL_MEDIUM_OEM_MAX
)) {
3777 requeue
= handle_oem_get_msg_cmd(intf
, msg
);
3780 * We don't handle the channel type, so just
3787 } else if ((msg
->rsp
[0] == ((IPMI_NETFN_APP_REQUEST
|1) << 2))
3788 && (msg
->rsp
[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD
)) {
3789 /* It's an asynchronous event. */
3790 requeue
= handle_read_event_rsp(intf
, msg
);
3792 /* It's a response from the local BMC. */
3793 requeue
= handle_bmc_rsp(intf
, msg
);
3801 * If there are messages in the queue or pretimeouts, handle them.
3803 static void handle_new_recv_msgs(ipmi_smi_t intf
)
3805 struct ipmi_smi_msg
*smi_msg
;
3806 unsigned long flags
= 0;
3808 int run_to_completion
= intf
->run_to_completion
;
3810 /* See if any waiting messages need to be processed. */
3811 if (!run_to_completion
)
3812 spin_lock_irqsave(&intf
->waiting_rcv_msgs_lock
, flags
);
3813 while (!list_empty(&intf
->waiting_rcv_msgs
)) {
3814 smi_msg
= list_entry(intf
->waiting_rcv_msgs
.next
,
3815 struct ipmi_smi_msg
, link
);
3816 if (!run_to_completion
)
3817 spin_unlock_irqrestore(&intf
->waiting_rcv_msgs_lock
,
3819 rv
= handle_one_recv_msg(intf
, smi_msg
);
3820 if (!run_to_completion
)
3821 spin_lock_irqsave(&intf
->waiting_rcv_msgs_lock
, flags
);
3824 * To preserve message order, quit if we
3825 * can't handle a message.
3829 list_del(&smi_msg
->link
);
3831 /* Message handled */
3832 ipmi_free_smi_msg(smi_msg
);
3833 /* If rv < 0, fatal error, del but don't free. */
3836 if (!run_to_completion
)
3837 spin_unlock_irqrestore(&intf
->waiting_rcv_msgs_lock
, flags
);
3840 * If the pretimout count is non-zero, decrement one from it and
3841 * deliver pretimeouts to all the users.
3843 if (atomic_add_unless(&intf
->watchdog_pretimeouts_to_deliver
, -1, 0)) {
3847 list_for_each_entry_rcu(user
, &intf
->users
, link
) {
3848 if (user
->handler
->ipmi_watchdog_pretimeout
)
3849 user
->handler
->ipmi_watchdog_pretimeout(
3850 user
->handler_data
);
3856 static void smi_recv_tasklet(unsigned long val
)
3858 unsigned long flags
= 0; /* keep us warning-free. */
3859 ipmi_smi_t intf
= (ipmi_smi_t
) val
;
3860 int run_to_completion
= intf
->run_to_completion
;
3861 struct ipmi_smi_msg
*newmsg
= NULL
;
3864 * Start the next message if available.
3866 * Do this here, not in the actual receiver, because we may deadlock
3867 * because the lower layer is allowed to hold locks while calling
3870 if (!run_to_completion
)
3871 spin_lock_irqsave(&intf
->xmit_msgs_lock
, flags
);
3872 if (intf
->curr_msg
== NULL
&& !intf
->in_shutdown
) {
3873 struct list_head
*entry
= NULL
;
3875 /* Pick the high priority queue first. */
3876 if (!list_empty(&intf
->hp_xmit_msgs
))
3877 entry
= intf
->hp_xmit_msgs
.next
;
3878 else if (!list_empty(&intf
->xmit_msgs
))
3879 entry
= intf
->xmit_msgs
.next
;
3883 newmsg
= list_entry(entry
, struct ipmi_smi_msg
, link
);
3884 intf
->curr_msg
= newmsg
;
3887 if (!run_to_completion
)
3888 spin_unlock_irqrestore(&intf
->xmit_msgs_lock
, flags
);
3890 intf
->handlers
->sender(intf
->send_info
, newmsg
);
3892 handle_new_recv_msgs(intf
);
3895 /* Handle a new message from the lower layer. */
3896 void ipmi_smi_msg_received(ipmi_smi_t intf
,
3897 struct ipmi_smi_msg
*msg
)
3899 unsigned long flags
= 0; /* keep us warning-free. */
3900 int run_to_completion
= intf
->run_to_completion
;
3902 if ((msg
->data_size
>= 2)
3903 && (msg
->data
[0] == (IPMI_NETFN_APP_REQUEST
<< 2))
3904 && (msg
->data
[1] == IPMI_SEND_MSG_CMD
)
3905 && (msg
->user_data
== NULL
)) {
3907 if (intf
->in_shutdown
)
3911 * This is the local response to a command send, start
3912 * the timer for these. The user_data will not be
3913 * NULL if this is a response send, and we will let
3914 * response sends just go through.
3918 * Check for errors, if we get certain errors (ones
3919 * that mean basically we can try again later), we
3920 * ignore them and start the timer. Otherwise we
3921 * report the error immediately.
3923 if ((msg
->rsp_size
>= 3) && (msg
->rsp
[2] != 0)
3924 && (msg
->rsp
[2] != IPMI_NODE_BUSY_ERR
)
3925 && (msg
->rsp
[2] != IPMI_LOST_ARBITRATION_ERR
)
3926 && (msg
->rsp
[2] != IPMI_BUS_ERR
)
3927 && (msg
->rsp
[2] != IPMI_NAK_ON_WRITE_ERR
)) {
3928 int chan
= msg
->rsp
[3] & 0xf;
3930 /* Got an error sending the message, handle it. */
3931 if (chan
>= IPMI_MAX_CHANNELS
)
3932 ; /* This shouldn't happen */
3933 else if ((intf
->channels
[chan
].medium
3934 == IPMI_CHANNEL_MEDIUM_8023LAN
)
3935 || (intf
->channels
[chan
].medium
3936 == IPMI_CHANNEL_MEDIUM_ASYNC
))
3937 ipmi_inc_stat(intf
, sent_lan_command_errs
);
3939 ipmi_inc_stat(intf
, sent_ipmb_command_errs
);
3940 intf_err_seq(intf
, msg
->msgid
, msg
->rsp
[2]);
3942 /* The message was sent, start the timer. */
3943 intf_start_seq_timer(intf
, msg
->msgid
);
3946 ipmi_free_smi_msg(msg
);
3949 * To preserve message order, we keep a queue and deliver from
3952 if (!run_to_completion
)
3953 spin_lock_irqsave(&intf
->waiting_rcv_msgs_lock
, flags
);
3954 list_add_tail(&msg
->link
, &intf
->waiting_rcv_msgs
);
3955 if (!run_to_completion
)
3956 spin_unlock_irqrestore(&intf
->waiting_rcv_msgs_lock
,
3960 if (!run_to_completion
)
3961 spin_lock_irqsave(&intf
->xmit_msgs_lock
, flags
);
3962 if (msg
== intf
->curr_msg
)
3963 intf
->curr_msg
= NULL
;
3964 if (!run_to_completion
)
3965 spin_unlock_irqrestore(&intf
->xmit_msgs_lock
, flags
);
3967 if (run_to_completion
)
3968 smi_recv_tasklet((unsigned long) intf
);
3970 tasklet_schedule(&intf
->recv_tasklet
);
3972 EXPORT_SYMBOL(ipmi_smi_msg_received
);
3974 void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf
)
3976 if (intf
->in_shutdown
)
3979 atomic_set(&intf
->watchdog_pretimeouts_to_deliver
, 1);
3980 tasklet_schedule(&intf
->recv_tasklet
);
3982 EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout
);
3984 static struct ipmi_smi_msg
*
3985 smi_from_recv_msg(ipmi_smi_t intf
, struct ipmi_recv_msg
*recv_msg
,
3986 unsigned char seq
, long seqid
)
3988 struct ipmi_smi_msg
*smi_msg
= ipmi_alloc_smi_msg();
3991 * If we can't allocate the message, then just return, we
3992 * get 4 retries, so this should be ok.
3996 memcpy(smi_msg
->data
, recv_msg
->msg
.data
, recv_msg
->msg
.data_len
);
3997 smi_msg
->data_size
= recv_msg
->msg
.data_len
;
3998 smi_msg
->msgid
= STORE_SEQ_IN_MSGID(seq
, seqid
);
4004 for (m
= 0; m
< smi_msg
->data_size
; m
++)
4005 printk(" %2.2x", smi_msg
->data
[m
]);
4012 static void check_msg_timeout(ipmi_smi_t intf
, struct seq_table
*ent
,
4013 struct list_head
*timeouts
, long timeout_period
,
4014 int slot
, unsigned long *flags
,
4015 unsigned int *waiting_msgs
)
4017 struct ipmi_recv_msg
*msg
;
4018 struct ipmi_smi_handlers
*handlers
;
4020 if (intf
->in_shutdown
)
4026 ent
->timeout
-= timeout_period
;
4027 if (ent
->timeout
> 0) {
4032 if (ent
->retries_left
== 0) {
4033 /* The message has used all its retries. */
4035 msg
= ent
->recv_msg
;
4036 list_add_tail(&msg
->link
, timeouts
);
4038 ipmi_inc_stat(intf
, timed_out_ipmb_broadcasts
);
4039 else if (is_lan_addr(&ent
->recv_msg
->addr
))
4040 ipmi_inc_stat(intf
, timed_out_lan_commands
);
4042 ipmi_inc_stat(intf
, timed_out_ipmb_commands
);
4044 struct ipmi_smi_msg
*smi_msg
;
4045 /* More retries, send again. */
4050 * Start with the max timer, set to normal timer after
4051 * the message is sent.
4053 ent
->timeout
= MAX_MSG_TIMEOUT
;
4054 ent
->retries_left
--;
4055 smi_msg
= smi_from_recv_msg(intf
, ent
->recv_msg
, slot
,
4058 if (is_lan_addr(&ent
->recv_msg
->addr
))
4060 dropped_rexmit_lan_commands
);
4063 dropped_rexmit_ipmb_commands
);
4067 spin_unlock_irqrestore(&intf
->seq_lock
, *flags
);
4070 * Send the new message. We send with a zero
4071 * priority. It timed out, I doubt time is that
4072 * critical now, and high priority messages are really
4073 * only for messages to the local MC, which don't get
4076 handlers
= intf
->handlers
;
4078 if (is_lan_addr(&ent
->recv_msg
->addr
))
4080 retransmitted_lan_commands
);
4083 retransmitted_ipmb_commands
);
4085 smi_send(intf
, intf
->handlers
, smi_msg
, 0);
4087 ipmi_free_smi_msg(smi_msg
);
4089 spin_lock_irqsave(&intf
->seq_lock
, *flags
);
4093 static unsigned int ipmi_timeout_handler(ipmi_smi_t intf
, long timeout_period
)
4095 struct list_head timeouts
;
4096 struct ipmi_recv_msg
*msg
, *msg2
;
4097 unsigned long flags
;
4099 unsigned int waiting_msgs
= 0;
4102 * Go through the seq table and find any messages that
4103 * have timed out, putting them in the timeouts
4106 INIT_LIST_HEAD(&timeouts
);
4107 spin_lock_irqsave(&intf
->seq_lock
, flags
);
4108 for (i
= 0; i
< IPMI_IPMB_NUM_SEQ
; i
++)
4109 check_msg_timeout(intf
, &(intf
->seq_table
[i
]),
4110 &timeouts
, timeout_period
, i
,
4111 &flags
, &waiting_msgs
);
4112 spin_unlock_irqrestore(&intf
->seq_lock
, flags
);
4114 list_for_each_entry_safe(msg
, msg2
, &timeouts
, link
)
4115 deliver_err_response(msg
, IPMI_TIMEOUT_COMPLETION_CODE
);
4118 * Maintenance mode handling. Check the timeout
4119 * optimistically before we claim the lock. It may
4120 * mean a timeout gets missed occasionally, but that
4121 * only means the timeout gets extended by one period
4122 * in that case. No big deal, and it avoids the lock
4125 if (intf
->auto_maintenance_timeout
> 0) {
4126 spin_lock_irqsave(&intf
->maintenance_mode_lock
, flags
);
4127 if (intf
->auto_maintenance_timeout
> 0) {
4128 intf
->auto_maintenance_timeout
4130 if (!intf
->maintenance_mode
4131 && (intf
->auto_maintenance_timeout
<= 0)) {
4132 intf
->maintenance_mode_enable
= false;
4133 maintenance_mode_update(intf
);
4136 spin_unlock_irqrestore(&intf
->maintenance_mode_lock
,
4140 tasklet_schedule(&intf
->recv_tasklet
);
4142 return waiting_msgs
;
4145 static void ipmi_request_event(ipmi_smi_t intf
)
4147 /* No event requests when in maintenance mode. */
4148 if (intf
->maintenance_mode_enable
)
4151 if (!intf
->in_shutdown
)
4152 intf
->handlers
->request_events(intf
->send_info
);
4155 static struct timer_list ipmi_timer
;
4157 static atomic_t stop_operation
;
4159 static void ipmi_timeout(unsigned long data
)
4164 if (atomic_read(&stop_operation
))
4168 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
4171 if (atomic_read(&intf
->event_waiters
)) {
4172 intf
->ticks_to_req_ev
--;
4173 if (intf
->ticks_to_req_ev
== 0) {
4174 ipmi_request_event(intf
);
4175 intf
->ticks_to_req_ev
= IPMI_REQUEST_EV_TIME
;
4180 lnt
+= ipmi_timeout_handler(intf
, IPMI_TIMEOUT_TIME
);
4183 if (lnt
!= intf
->last_needs_timer
&&
4184 intf
->handlers
->set_need_watch
)
4185 intf
->handlers
->set_need_watch(intf
->send_info
, lnt
);
4186 intf
->last_needs_timer
= lnt
;
4193 mod_timer(&ipmi_timer
, jiffies
+ IPMI_TIMEOUT_JIFFIES
);
4196 static void need_waiter(ipmi_smi_t intf
)
4198 /* Racy, but worst case we start the timer twice. */
4199 if (!timer_pending(&ipmi_timer
))
4200 mod_timer(&ipmi_timer
, jiffies
+ IPMI_TIMEOUT_JIFFIES
);
4203 static atomic_t smi_msg_inuse_count
= ATOMIC_INIT(0);
4204 static atomic_t recv_msg_inuse_count
= ATOMIC_INIT(0);
4206 static void free_smi_msg(struct ipmi_smi_msg
*msg
)
4208 atomic_dec(&smi_msg_inuse_count
);
4212 struct ipmi_smi_msg
*ipmi_alloc_smi_msg(void)
4214 struct ipmi_smi_msg
*rv
;
4215 rv
= kmalloc(sizeof(struct ipmi_smi_msg
), GFP_ATOMIC
);
4217 rv
->done
= free_smi_msg
;
4218 rv
->user_data
= NULL
;
4219 atomic_inc(&smi_msg_inuse_count
);
4223 EXPORT_SYMBOL(ipmi_alloc_smi_msg
);
4225 static void free_recv_msg(struct ipmi_recv_msg
*msg
)
4227 atomic_dec(&recv_msg_inuse_count
);
4231 static struct ipmi_recv_msg
*ipmi_alloc_recv_msg(void)
4233 struct ipmi_recv_msg
*rv
;
4235 rv
= kmalloc(sizeof(struct ipmi_recv_msg
), GFP_ATOMIC
);
4238 rv
->done
= free_recv_msg
;
4239 atomic_inc(&recv_msg_inuse_count
);
4244 void ipmi_free_recv_msg(struct ipmi_recv_msg
*msg
)
4247 kref_put(&msg
->user
->refcount
, free_user
);
4250 EXPORT_SYMBOL(ipmi_free_recv_msg
);
4252 #ifdef CONFIG_IPMI_PANIC_EVENT
4254 static atomic_t panic_done_count
= ATOMIC_INIT(0);
4256 static void dummy_smi_done_handler(struct ipmi_smi_msg
*msg
)
4258 atomic_dec(&panic_done_count
);
4261 static void dummy_recv_done_handler(struct ipmi_recv_msg
*msg
)
4263 atomic_dec(&panic_done_count
);
4267 * Inside a panic, send a message and wait for a response.
4269 static void ipmi_panic_request_and_wait(ipmi_smi_t intf
,
4270 struct ipmi_addr
*addr
,
4271 struct kernel_ipmi_msg
*msg
)
4273 struct ipmi_smi_msg smi_msg
;
4274 struct ipmi_recv_msg recv_msg
;
4277 smi_msg
.done
= dummy_smi_done_handler
;
4278 recv_msg
.done
= dummy_recv_done_handler
;
4279 atomic_add(2, &panic_done_count
);
4280 rv
= i_ipmi_request(NULL
,
4289 intf
->channels
[0].address
,
4290 intf
->channels
[0].lun
,
4291 0, 1); /* Don't retry, and don't wait. */
4293 atomic_sub(2, &panic_done_count
);
4294 while (atomic_read(&panic_done_count
) != 0)
4298 #ifdef CONFIG_IPMI_PANIC_STRING
4299 static void event_receiver_fetcher(ipmi_smi_t intf
, struct ipmi_recv_msg
*msg
)
4301 if ((msg
->addr
.addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
)
4302 && (msg
->msg
.netfn
== IPMI_NETFN_SENSOR_EVENT_RESPONSE
)
4303 && (msg
->msg
.cmd
== IPMI_GET_EVENT_RECEIVER_CMD
)
4304 && (msg
->msg
.data
[0] == IPMI_CC_NO_ERROR
)) {
4305 /* A get event receiver command, save it. */
4306 intf
->event_receiver
= msg
->msg
.data
[1];
4307 intf
->event_receiver_lun
= msg
->msg
.data
[2] & 0x3;
4311 static void device_id_fetcher(ipmi_smi_t intf
, struct ipmi_recv_msg
*msg
)
4313 if ((msg
->addr
.addr_type
== IPMI_SYSTEM_INTERFACE_ADDR_TYPE
)
4314 && (msg
->msg
.netfn
== IPMI_NETFN_APP_RESPONSE
)
4315 && (msg
->msg
.cmd
== IPMI_GET_DEVICE_ID_CMD
)
4316 && (msg
->msg
.data
[0] == IPMI_CC_NO_ERROR
)) {
4318 * A get device id command, save if we are an event
4319 * receiver or generator.
4321 intf
->local_sel_device
= (msg
->msg
.data
[6] >> 2) & 1;
4322 intf
->local_event_generator
= (msg
->msg
.data
[6] >> 5) & 1;
4327 static void send_panic_events(char *str
)
4329 struct kernel_ipmi_msg msg
;
4331 unsigned char data
[16];
4332 struct ipmi_system_interface_addr
*si
;
4333 struct ipmi_addr addr
;
4335 si
= (struct ipmi_system_interface_addr
*) &addr
;
4336 si
->addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
4337 si
->channel
= IPMI_BMC_CHANNEL
;
4340 /* Fill in an event telling that we have failed. */
4341 msg
.netfn
= 0x04; /* Sensor or Event. */
4342 msg
.cmd
= 2; /* Platform event command. */
4345 data
[0] = 0x41; /* Kernel generator ID, IPMI table 5-4 */
4346 data
[1] = 0x03; /* This is for IPMI 1.0. */
4347 data
[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */
4348 data
[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */
4349 data
[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */
4352 * Put a few breadcrumbs in. Hopefully later we can add more things
4353 * to make the panic events more useful.
4361 /* For every registered interface, send the event. */
4362 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
4363 if (!intf
->handlers
)
4364 /* Interface is not ready. */
4367 intf
->run_to_completion
= 1;
4368 /* Send the event announcing the panic. */
4369 intf
->handlers
->set_run_to_completion(intf
->send_info
, 1);
4370 ipmi_panic_request_and_wait(intf
, &addr
, &msg
);
4373 #ifdef CONFIG_IPMI_PANIC_STRING
4375 * On every interface, dump a bunch of OEM event holding the
4381 /* For every registered interface, send the event. */
4382 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
4384 struct ipmi_ipmb_addr
*ipmb
;
4387 if (intf
->intf_num
== -1)
4388 /* Interface was not ready yet. */
4392 * intf_num is used as an marker to tell if the
4393 * interface is valid. Thus we need a read barrier to
4394 * make sure data fetched before checking intf_num
4400 * First job here is to figure out where to send the
4401 * OEM events. There's no way in IPMI to send OEM
4402 * events using an event send command, so we have to
4403 * find the SEL to put them in and stick them in
4407 /* Get capabilities from the get device id. */
4408 intf
->local_sel_device
= 0;
4409 intf
->local_event_generator
= 0;
4410 intf
->event_receiver
= 0;
4412 /* Request the device info from the local MC. */
4413 msg
.netfn
= IPMI_NETFN_APP_REQUEST
;
4414 msg
.cmd
= IPMI_GET_DEVICE_ID_CMD
;
4417 intf
->null_user_handler
= device_id_fetcher
;
4418 ipmi_panic_request_and_wait(intf
, &addr
, &msg
);
4420 if (intf
->local_event_generator
) {
4421 /* Request the event receiver from the local MC. */
4422 msg
.netfn
= IPMI_NETFN_SENSOR_EVENT_REQUEST
;
4423 msg
.cmd
= IPMI_GET_EVENT_RECEIVER_CMD
;
4426 intf
->null_user_handler
= event_receiver_fetcher
;
4427 ipmi_panic_request_and_wait(intf
, &addr
, &msg
);
4429 intf
->null_user_handler
= NULL
;
4432 * Validate the event receiver. The low bit must not
4433 * be 1 (it must be a valid IPMB address), it cannot
4434 * be zero, and it must not be my address.
4436 if (((intf
->event_receiver
& 1) == 0)
4437 && (intf
->event_receiver
!= 0)
4438 && (intf
->event_receiver
!= intf
->channels
[0].address
)) {
4440 * The event receiver is valid, send an IPMB
4443 ipmb
= (struct ipmi_ipmb_addr
*) &addr
;
4444 ipmb
->addr_type
= IPMI_IPMB_ADDR_TYPE
;
4445 ipmb
->channel
= 0; /* FIXME - is this right? */
4446 ipmb
->lun
= intf
->event_receiver_lun
;
4447 ipmb
->slave_addr
= intf
->event_receiver
;
4448 } else if (intf
->local_sel_device
) {
4450 * The event receiver was not valid (or was
4451 * me), but I am an SEL device, just dump it
4454 si
= (struct ipmi_system_interface_addr
*) &addr
;
4455 si
->addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
4456 si
->channel
= IPMI_BMC_CHANNEL
;
4459 continue; /* No where to send the event. */
4461 msg
.netfn
= IPMI_NETFN_STORAGE_REQUEST
; /* Storage. */
4462 msg
.cmd
= IPMI_ADD_SEL_ENTRY_CMD
;
4468 int size
= strlen(p
);
4474 data
[2] = 0xf0; /* OEM event without timestamp. */
4475 data
[3] = intf
->channels
[0].address
;
4476 data
[4] = j
++; /* sequence # */
4478 * Always give 11 bytes, so strncpy will fill
4479 * it with zeroes for me.
4481 strncpy(data
+5, p
, 11);
4484 ipmi_panic_request_and_wait(intf
, &addr
, &msg
);
4487 #endif /* CONFIG_IPMI_PANIC_STRING */
4489 #endif /* CONFIG_IPMI_PANIC_EVENT */
4491 static int has_panicked
;
4493 static int panic_event(struct notifier_block
*this,
4494 unsigned long event
,
4503 /* For every registered interface, set it to run to completion. */
4504 list_for_each_entry_rcu(intf
, &ipmi_interfaces
, link
) {
4505 if (!intf
->handlers
)
4506 /* Interface is not ready. */
4509 intf
->run_to_completion
= 1;
4510 intf
->handlers
->set_run_to_completion(intf
->send_info
, 1);
4513 #ifdef CONFIG_IPMI_PANIC_EVENT
4514 send_panic_events(ptr
);
4520 static struct notifier_block panic_block
= {
4521 .notifier_call
= panic_event
,
4523 .priority
= 200 /* priority: INT_MAX >= x >= 0 */
4526 static int ipmi_init_msghandler(void)
4533 rv
= driver_register(&ipmidriver
.driver
);
4535 printk(KERN_ERR PFX
"Could not register IPMI driver\n");
4539 printk(KERN_INFO
"ipmi message handler version "
4540 IPMI_DRIVER_VERSION
"\n");
4542 #ifdef CONFIG_PROC_FS
4543 proc_ipmi_root
= proc_mkdir("ipmi", NULL
);
4544 if (!proc_ipmi_root
) {
4545 printk(KERN_ERR PFX
"Unable to create IPMI proc dir");
4546 driver_unregister(&ipmidriver
.driver
);
4550 #endif /* CONFIG_PROC_FS */
4552 setup_timer(&ipmi_timer
, ipmi_timeout
, 0);
4553 mod_timer(&ipmi_timer
, jiffies
+ IPMI_TIMEOUT_JIFFIES
);
4555 atomic_notifier_chain_register(&panic_notifier_list
, &panic_block
);
4562 static int __init
ipmi_init_msghandler_mod(void)
4564 ipmi_init_msghandler();
4568 static void __exit
cleanup_ipmi(void)
4575 atomic_notifier_chain_unregister(&panic_notifier_list
, &panic_block
);
4578 * This can't be called if any interfaces exist, so no worry
4579 * about shutting down the interfaces.
4583 * Tell the timer to stop, then wait for it to stop. This
4584 * avoids problems with race conditions removing the timer
4587 atomic_inc(&stop_operation
);
4588 del_timer_sync(&ipmi_timer
);
4590 #ifdef CONFIG_PROC_FS
4591 proc_remove(proc_ipmi_root
);
4592 #endif /* CONFIG_PROC_FS */
4594 driver_unregister(&ipmidriver
.driver
);
4598 /* Check for buffer leaks. */
4599 count
= atomic_read(&smi_msg_inuse_count
);
4601 printk(KERN_WARNING PFX
"SMI message count %d at exit\n",
4603 count
= atomic_read(&recv_msg_inuse_count
);
4605 printk(KERN_WARNING PFX
"recv message count %d at exit\n",
4608 module_exit(cleanup_ipmi
);
4610 module_init(ipmi_init_msghandler_mod
);
4611 MODULE_LICENSE("GPL");
4612 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
4613 MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI"
4615 MODULE_VERSION(IPMI_DRIVER_VERSION
);