?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux-2.6.12-rc2
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / char / ipmi / ipmi_msghandler.c
bloba6606a1aced72a125d768a607371ecd8e91fff9a
1 /*
2 * ipmi_msghandler.c
3 *
4 * Incoming and outgoing message routing for an IPMI interface.
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2002 MontaVista Software Inc.
11 *
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.
16 *
17 *
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.
28 *
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.
32 */
33
34 #include <linux/config.h>
35 #include <linux/module.h>
36 #include <linux/errno.h>
37 #include <asm/system.h>
38 #include <linux/sched.h>
39 #include <linux/poll.h>
40 #include <linux/spinlock.h>
41 #include <linux/rwsem.h>
42 #include <linux/slab.h>
43 #include <linux/ipmi.h>
44 #include <linux/ipmi_smi.h>
45 #include <linux/notifier.h>
46 #include <linux/init.h>
47 #include <linux/proc_fs.h>
48
49 #define PFX "IPMI message handler: "
50 #define IPMI_MSGHANDLER_VERSION "v33"
51
52 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
53 static int ipmi_init_msghandler(void);
54
55 static int initialized = 0;
56
57 static struct proc_dir_entry *proc_ipmi_root = NULL;
58
59 #define MAX_EVENTS_IN_QUEUE 25
60
61 /* Don't let a message sit in a queue forever, always time it with at lest
62 the max message timer. This is in milliseconds. */
63 #define MAX_MSG_TIMEOUT 60000
64
65 struct ipmi_user
66 {
67 struct list_head link;
68
69 /* The upper layer that handles receive messages. */
70 struct ipmi_user_hndl *handler;
71 void *handler_data;
72
73 /* The interface this user is bound to. */
74 ipmi_smi_t intf;
75
76 /* Does this interface receive IPMI events? */
77 int gets_events;
78 };
79
80 struct cmd_rcvr
81 {
82 struct list_head link;
83
84 ipmi_user_t user;
85 unsigned char netfn;
86 unsigned char cmd;
87 };
88
89 struct seq_table
90 {
91 unsigned int inuse : 1;
92 unsigned int broadcast : 1;
93
94 unsigned long timeout;
95 unsigned long orig_timeout;
96 unsigned int retries_left;
97
98 /* To verify on an incoming send message response that this is
99 the message that the response is for, we keep a sequence id
100 and increment it every time we send a message. */
101 long seqid;
102
103 /* This is held so we can properly respond to the message on a
104 timeout, and it is used to hold the temporary data for
105 retransmission, too. */
106 struct ipmi_recv_msg *recv_msg;
107 };
108
109 /* Store the information in a msgid (long) to allow us to find a
110 sequence table entry from the msgid. */
111 #define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff))
112
113 #define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \
114 do { \
115 seq = ((msgid >> 26) & 0x3f); \
116 seqid = (msgid & 0x3fffff); \
117 } while(0)
118
119 #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff)
120
121 struct ipmi_channel
122 {
123 unsigned char medium;
124 unsigned char protocol;
125 };
126
127 struct ipmi_proc_entry
128 {
129 char *name;
130 struct ipmi_proc_entry *next;
131 };
132
133 #define IPMI_IPMB_NUM_SEQ 64
134 #define IPMI_MAX_CHANNELS 8
135 struct ipmi_smi
136 {
137 /* What interface number are we? */
138 int intf_num;
139
140 /* The list of upper layers that are using me. We read-lock
141 this when delivering messages to the upper layer to keep
142 the user from going away while we are processing the
143 message. This means that you cannot add or delete a user
144 from the receive callback. */
145 rwlock_t users_lock;
146 struct list_head users;
147
148 /* Used for wake ups at startup. */
149 wait_queue_head_t waitq;
150
151 /* The IPMI version of the BMC on the other end. */
152 unsigned char version_major;
153 unsigned char version_minor;
154
155 /* This is the lower-layer's sender routine. */
156 struct ipmi_smi_handlers *handlers;
157 void *send_info;
158
159 /* A list of proc entries for this interface. This does not
160 need a lock, only one thread creates it and only one thread
161 destroys it. */
162 struct ipmi_proc_entry *proc_entries;
163
164 /* A table of sequence numbers for this interface. We use the
165 sequence numbers for IPMB messages that go out of the
166 interface to match them up with their responses. A routine
167 is called periodically to time the items in this list. */
168 spinlock_t seq_lock;
169 struct seq_table seq_table[IPMI_IPMB_NUM_SEQ];
170 int curr_seq;
171
172 /* Messages that were delayed for some reason (out of memory,
173 for instance), will go in here to be processed later in a
174 periodic timer interrupt. */
175 spinlock_t waiting_msgs_lock;
176 struct list_head waiting_msgs;
177
178 /* The list of command receivers that are registered for commands
179 on this interface. */
180 rwlock_t cmd_rcvr_lock;
181 struct list_head cmd_rcvrs;
182
183 /* Events that were queues because no one was there to receive
184 them. */
185 spinlock_t events_lock; /* For dealing with event stuff. */
186 struct list_head waiting_events;
187 unsigned int waiting_events_count; /* How many events in queue? */
188
189 /* This will be non-null if someone registers to receive all
190 IPMI commands (this is for interface emulation). There
191 may not be any things in the cmd_rcvrs list above when
192 this is registered. */
193 ipmi_user_t all_cmd_rcvr;
194
195 /* My slave address. This is initialized to IPMI_BMC_SLAVE_ADDR,
196 but may be changed by the user. */
197 unsigned char my_address;
198
199 /* My LUN. This should generally stay the SMS LUN, but just in
200 case... */
201 unsigned char my_lun;
202
203 /* The event receiver for my BMC, only really used at panic
204 shutdown as a place to store this. */
205 unsigned char event_receiver;
206 unsigned char event_receiver_lun;
207 unsigned char local_sel_device;
208 unsigned char local_event_generator;
209
210 /* A cheap hack, if this is non-null and a message to an
211 interface comes in with a NULL user, call this routine with
212 it. Note that the message will still be freed by the
213 caller. This only works on the system interface. */
214 void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_smi_msg *msg);
215
216 /* When we are scanning the channels for an SMI, this will
217 tell which channel we are scanning. */
218 int curr_channel;
219
220 /* Channel information */
221 struct ipmi_channel channels[IPMI_MAX_CHANNELS];
222
223 /* Proc FS stuff. */
224 struct proc_dir_entry *proc_dir;
225 char proc_dir_name[10];
226
227 spinlock_t counter_lock; /* For making counters atomic. */
228
229 /* Commands we got that were invalid. */
230 unsigned int sent_invalid_commands;
231
232 /* Commands we sent to the MC. */
233 unsigned int sent_local_commands;
234 /* Responses from the MC that were delivered to a user. */
235 unsigned int handled_local_responses;
236 /* Responses from the MC that were not delivered to a user. */
237 unsigned int unhandled_local_responses;
238
239 /* Commands we sent out to the IPMB bus. */
240 unsigned int sent_ipmb_commands;
241 /* Commands sent on the IPMB that had errors on the SEND CMD */
242 unsigned int sent_ipmb_command_errs;
243 /* Each retransmit increments this count. */
244 unsigned int retransmitted_ipmb_commands;
245 /* When a message times out (runs out of retransmits) this is
246 incremented. */
247 unsigned int timed_out_ipmb_commands;
248
249 /* This is like above, but for broadcasts. Broadcasts are
250 *not* included in the above count (they are expected to
251 time out). */
252 unsigned int timed_out_ipmb_broadcasts;
253
254 /* Responses I have sent to the IPMB bus. */
255 unsigned int sent_ipmb_responses;
256
257 /* The response was delivered to the user. */
258 unsigned int handled_ipmb_responses;
259 /* The response had invalid data in it. */
260 unsigned int invalid_ipmb_responses;
261 /* The response didn't have anyone waiting for it. */
262 unsigned int unhandled_ipmb_responses;
263
264 /* Commands we sent out to the IPMB bus. */
265 unsigned int sent_lan_commands;
266 /* Commands sent on the IPMB that had errors on the SEND CMD */
267 unsigned int sent_lan_command_errs;
268 /* Each retransmit increments this count. */
269 unsigned int retransmitted_lan_commands;
270 /* When a message times out (runs out of retransmits) this is
271 incremented. */
272 unsigned int timed_out_lan_commands;
273
274 /* Responses I have sent to the IPMB bus. */
275 unsigned int sent_lan_responses;
276
277 /* The response was delivered to the user. */
278 unsigned int handled_lan_responses;
279 /* The response had invalid data in it. */
280 unsigned int invalid_lan_responses;
281 /* The response didn't have anyone waiting for it. */
282 unsigned int unhandled_lan_responses;
283
284 /* The command was delivered to the user. */
285 unsigned int handled_commands;
286 /* The command had invalid data in it. */
287 unsigned int invalid_commands;
288 /* The command didn't have anyone waiting for it. */
289 unsigned int unhandled_commands;
290
291 /* Invalid data in an event. */
292 unsigned int invalid_events;
293 /* Events that were received with the proper format. */
294 unsigned int events;
295 };
296
297 #define MAX_IPMI_INTERFACES 4
298 static ipmi_smi_t ipmi_interfaces[MAX_IPMI_INTERFACES];
299
300 /* Used to keep interfaces from going away while operations are
301 operating on interfaces. Grab read if you are not modifying the
302 interfaces, write if you are. */
303 static DECLARE_RWSEM(interfaces_sem);
304
305 /* Directly protects the ipmi_interfaces data structure. This is
306 claimed in the timer interrupt. */
307 static DEFINE_SPINLOCK(interfaces_lock);
308
309 /* List of watchers that want to know when smi's are added and
310 deleted. */
311 static struct list_head smi_watchers = LIST_HEAD_INIT(smi_watchers);
312 static DECLARE_RWSEM(smi_watchers_sem);
313
314 int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
315 {
316 int i;
317
318 down_read(&interfaces_sem);
319 down_write(&smi_watchers_sem);
320 list_add(&(watcher->link), &smi_watchers);
321 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
322 if (ipmi_interfaces[i] != NULL) {
323 watcher->new_smi(i);
324 }
325 }
326 up_write(&smi_watchers_sem);
327 up_read(&interfaces_sem);
328 return 0;
329 }
330
331 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher)
332 {
333 down_write(&smi_watchers_sem);
334 list_del(&(watcher->link));
335 up_write(&smi_watchers_sem);
336 return 0;
337 }
338
339 static void
340 call_smi_watchers(int i)
341 {
342 struct ipmi_smi_watcher *w;
343
344 down_read(&smi_watchers_sem);
345 list_for_each_entry(w, &smi_watchers, link) {
346 if (try_module_get(w->owner)) {
347 w->new_smi(i);
348 module_put(w->owner);
349 }
350 }
351 up_read(&smi_watchers_sem);
352 }
353
354 static int
355 ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
356 {
357 if (addr1->addr_type != addr2->addr_type)
358 return 0;
359
360 if (addr1->channel != addr2->channel)
361 return 0;
362
363 if (addr1->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
364 struct ipmi_system_interface_addr *smi_addr1
365 = (struct ipmi_system_interface_addr *) addr1;
366 struct ipmi_system_interface_addr *smi_addr2
367 = (struct ipmi_system_interface_addr *) addr2;
368 return (smi_addr1->lun == smi_addr2->lun);
369 }
370
371 if ((addr1->addr_type == IPMI_IPMB_ADDR_TYPE)
372 || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
373 {
374 struct ipmi_ipmb_addr *ipmb_addr1
375 = (struct ipmi_ipmb_addr *) addr1;
376 struct ipmi_ipmb_addr *ipmb_addr2
377 = (struct ipmi_ipmb_addr *) addr2;
378
379 return ((ipmb_addr1->slave_addr == ipmb_addr2->slave_addr)
380 && (ipmb_addr1->lun == ipmb_addr2->lun));
381 }
382
383 if (addr1->addr_type == IPMI_LAN_ADDR_TYPE) {
384 struct ipmi_lan_addr *lan_addr1
385 = (struct ipmi_lan_addr *) addr1;
386 struct ipmi_lan_addr *lan_addr2
387 = (struct ipmi_lan_addr *) addr2;
388
389 return ((lan_addr1->remote_SWID == lan_addr2->remote_SWID)
390 && (lan_addr1->local_SWID == lan_addr2->local_SWID)
391 && (lan_addr1->session_handle
392 == lan_addr2->session_handle)
393 && (lan_addr1->lun == lan_addr2->lun));
394 }
395
396 return 1;
397 }
398
399 int ipmi_validate_addr(struct ipmi_addr *addr, int len)
400 {
401 if (len < sizeof(struct ipmi_system_interface_addr)) {
402 return -EINVAL;
403 }
404
405 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
406 if (addr->channel != IPMI_BMC_CHANNEL)
407 return -EINVAL;
408 return 0;
409 }
410
411 if ((addr->channel == IPMI_BMC_CHANNEL)
412 || (addr->channel >= IPMI_NUM_CHANNELS)
413 || (addr->channel < 0))
414 return -EINVAL;
415
416 if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
417 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
418 {
419 if (len < sizeof(struct ipmi_ipmb_addr)) {
420 return -EINVAL;
421 }
422 return 0;
423 }
424
425 if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
426 if (len < sizeof(struct ipmi_lan_addr)) {
427 return -EINVAL;
428 }
429 return 0;
430 }
431
432 return -EINVAL;
433 }
434
435 unsigned int ipmi_addr_length(int addr_type)
436 {
437 if (addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
438 return sizeof(struct ipmi_system_interface_addr);
439
440 if ((addr_type == IPMI_IPMB_ADDR_TYPE)
441 || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
442 {
443 return sizeof(struct ipmi_ipmb_addr);
444 }
445
446 if (addr_type == IPMI_LAN_ADDR_TYPE)
447 return sizeof(struct ipmi_lan_addr);
448
449 return 0;
450 }
451
452 static void deliver_response(struct ipmi_recv_msg *msg)
453 {
454 msg->user->handler->ipmi_recv_hndl(msg, msg->user->handler_data);
455 }
456
457 /* Find the next sequence number not being used and add the given
458 message with the given timeout to the sequence table. This must be
459 called with the interface's seq_lock held. */
460 static int intf_next_seq(ipmi_smi_t intf,
461 struct ipmi_recv_msg *recv_msg,
462 unsigned long timeout,
463 int retries,
464 int broadcast,
465 unsigned char *seq,
466 long *seqid)
467 {
468 int rv = 0;
469 unsigned int i;
470
471 for (i=intf->curr_seq;
472 (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq;
473 i=(i+1)%IPMI_IPMB_NUM_SEQ)
474 {
475 if (! intf->seq_table[i].inuse)
476 break;
477 }
478
479 if (! intf->seq_table[i].inuse) {
480 intf->seq_table[i].recv_msg = recv_msg;
481
482 /* Start with the maximum timeout, when the send response
483 comes in we will start the real timer. */
484 intf->seq_table[i].timeout = MAX_MSG_TIMEOUT;
485 intf->seq_table[i].orig_timeout = timeout;
486 intf->seq_table[i].retries_left = retries;
487 intf->seq_table[i].broadcast = broadcast;
488 intf->seq_table[i].inuse = 1;
489 intf->seq_table[i].seqid = NEXT_SEQID(intf->seq_table[i].seqid);
490 *seq = i;
491 *seqid = intf->seq_table[i].seqid;
492 intf->curr_seq = (i+1)%IPMI_IPMB_NUM_SEQ;
493 } else {
494 rv = -EAGAIN;
495 }
496
497 return rv;
498 }
499
500 /* Return the receive message for the given sequence number and
501 release the sequence number so it can be reused. Some other data
502 is passed in to be sure the message matches up correctly (to help
503 guard against message coming in after their timeout and the
504 sequence number being reused). */
505 static int intf_find_seq(ipmi_smi_t intf,
506 unsigned char seq,
507 short channel,
508 unsigned char cmd,
509 unsigned char netfn,
510 struct ipmi_addr *addr,
511 struct ipmi_recv_msg **recv_msg)
512 {
513 int rv = -ENODEV;
514 unsigned long flags;
515
516 if (seq >= IPMI_IPMB_NUM_SEQ)
517 return -EINVAL;
518
519 spin_lock_irqsave(&(intf->seq_lock), flags);
520 if (intf->seq_table[seq].inuse) {
521 struct ipmi_recv_msg *msg = intf->seq_table[seq].recv_msg;
522
523 if ((msg->addr.channel == channel)
524 && (msg->msg.cmd == cmd)
525 && (msg->msg.netfn == netfn)
526 && (ipmi_addr_equal(addr, &(msg->addr))))
527 {
528 *recv_msg = msg;
529 intf->seq_table[seq].inuse = 0;
530 rv = 0;
531 }
532 }
533 spin_unlock_irqrestore(&(intf->seq_lock), flags);
534
535 return rv;
536 }
537
538
539 /* Start the timer for a specific sequence table entry. */
540 static int intf_start_seq_timer(ipmi_smi_t intf,
541 long msgid)
542 {
543 int rv = -ENODEV;
544 unsigned long flags;
545 unsigned char seq;
546 unsigned long seqid;
547
548
549 GET_SEQ_FROM_MSGID(msgid, seq, seqid);
550
551 spin_lock_irqsave(&(intf->seq_lock), flags);
552 /* We do this verification because the user can be deleted
553 while a message is outstanding. */
554 if ((intf->seq_table[seq].inuse)
555 && (intf->seq_table[seq].seqid == seqid))
556 {
557 struct seq_table *ent = &(intf->seq_table[seq]);
558 ent->timeout = ent->orig_timeout;
559 rv = 0;
560 }
561 spin_unlock_irqrestore(&(intf->seq_lock), flags);
562
563 return rv;
564 }
565
566 /* Got an error for the send message for a specific sequence number. */
567 static int intf_err_seq(ipmi_smi_t intf,
568 long msgid,
569 unsigned int err)
570 {
571 int rv = -ENODEV;
572 unsigned long flags;
573 unsigned char seq;
574 unsigned long seqid;
575 struct ipmi_recv_msg *msg = NULL;
576
577
578 GET_SEQ_FROM_MSGID(msgid, seq, seqid);
579
580 spin_lock_irqsave(&(intf->seq_lock), flags);
581 /* We do this verification because the user can be deleted
582 while a message is outstanding. */
583 if ((intf->seq_table[seq].inuse)
584 && (intf->seq_table[seq].seqid == seqid))
585 {
586 struct seq_table *ent = &(intf->seq_table[seq]);
587
588 ent->inuse = 0;
589 msg = ent->recv_msg;
590 rv = 0;
591 }
592 spin_unlock_irqrestore(&(intf->seq_lock), flags);
593
594 if (msg) {
595 msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
596 msg->msg_data[0] = err;
597 msg->msg.netfn |= 1; /* Convert to a response. */
598 msg->msg.data_len = 1;
599 msg->msg.data = msg->msg_data;
600 deliver_response(msg);
601 }
602
603 return rv;
604 }
605
606
607 int ipmi_create_user(unsigned int if_num,
608 struct ipmi_user_hndl *handler,
609 void *handler_data,
610 ipmi_user_t *user)
611 {
612 unsigned long flags;
613 ipmi_user_t new_user;
614 int rv = 0;
615 ipmi_smi_t intf;
616
617 /* There is no module usecount here, because it's not
618 required. Since this can only be used by and called from
619 other modules, they will implicitly use this module, and
620 thus this can't be removed unless the other modules are
621 removed. */
622
623 if (handler == NULL)
624 return -EINVAL;
625
626 /* Make sure the driver is actually initialized, this handles
627 problems with initialization order. */
628 if (!initialized) {
629 rv = ipmi_init_msghandler();
630 if (rv)
631 return rv;
632
633 /* The init code doesn't return an error if it was turned
634 off, but it won't initialize. Check that. */
635 if (!initialized)
636 return -ENODEV;
637 }
638
639 new_user = kmalloc(sizeof(*new_user), GFP_KERNEL);
640 if (! new_user)
641 return -ENOMEM;
642
643 down_read(&interfaces_sem);
644 if ((if_num > MAX_IPMI_INTERFACES) || ipmi_interfaces[if_num] == NULL)
645 {
646 rv = -EINVAL;
647 goto out_unlock;
648 }
649
650 intf = ipmi_interfaces[if_num];
651
652 new_user->handler = handler;
653 new_user->handler_data = handler_data;
654 new_user->intf = intf;
655 new_user->gets_events = 0;
656
657 if (!try_module_get(intf->handlers->owner)) {
658 rv = -ENODEV;
659 goto out_unlock;
660 }
661
662 if (intf->handlers->inc_usecount) {
663 rv = intf->handlers->inc_usecount(intf->send_info);
664 if (rv) {
665 module_put(intf->handlers->owner);
666 goto out_unlock;
667 }
668 }
669
670 write_lock_irqsave(&intf->users_lock, flags);
671 list_add_tail(&new_user->link, &intf->users);
672 write_unlock_irqrestore(&intf->users_lock, flags);
673
674 out_unlock:
675 if (rv) {
676 kfree(new_user);
677 } else {
678 *user = new_user;
679 }
680
681 up_read(&interfaces_sem);
682 return rv;
683 }
684
685 static int ipmi_destroy_user_nolock(ipmi_user_t user)
686 {
687 int rv = -ENODEV;
688 ipmi_user_t t_user;
689 struct cmd_rcvr *rcvr, *rcvr2;
690 int i;
691 unsigned long flags;
692
693 /* Find the user and delete them from the list. */
694 list_for_each_entry(t_user, &(user->intf->users), link) {
695 if (t_user == user) {
696 list_del(&t_user->link);
697 rv = 0;
698 break;
699 }
700 }
701
702 if (rv) {
703 goto out_unlock;
704 }
705
706 /* Remove the user from the interfaces sequence table. */
707 spin_lock_irqsave(&(user->intf->seq_lock), flags);
708 for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) {
709 if (user->intf->seq_table[i].inuse
710 && (user->intf->seq_table[i].recv_msg->user == user))
711 {
712 user->intf->seq_table[i].inuse = 0;
713 }
714 }
715 spin_unlock_irqrestore(&(user->intf->seq_lock), flags);
716
717 /* Remove the user from the command receiver's table. */
718 write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags);
719 list_for_each_entry_safe(rcvr, rcvr2, &(user->intf->cmd_rcvrs), link) {
720 if (rcvr->user == user) {
721 list_del(&rcvr->link);
722 kfree(rcvr);
723 }
724 }
725 write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags);
726
727 kfree(user);
728
729 out_unlock:
730
731 return rv;
732 }
733
734 int ipmi_destroy_user(ipmi_user_t user)
735 {
736 int rv;
737 ipmi_smi_t intf = user->intf;
738 unsigned long flags;
739
740 down_read(&interfaces_sem);
741 write_lock_irqsave(&intf->users_lock, flags);
742 rv = ipmi_destroy_user_nolock(user);
743 if (!rv) {
744 module_put(intf->handlers->owner);
745 if (intf->handlers->dec_usecount)
746 intf->handlers->dec_usecount(intf->send_info);
747 }
748
749 write_unlock_irqrestore(&intf->users_lock, flags);
750 up_read(&interfaces_sem);
751 return rv;
752 }
753
754 void ipmi_get_version(ipmi_user_t user,
755 unsigned char *major,
756 unsigned char *minor)
757 {
758 *major = user->intf->version_major;
759 *minor = user->intf->version_minor;
760 }
761
762 void ipmi_set_my_address(ipmi_user_t user,
763 unsigned char address)
764 {
765 user->intf->my_address = address;
766 }
767
768 unsigned char ipmi_get_my_address(ipmi_user_t user)
769 {
770 return user->intf->my_address;
771 }
772
773 void ipmi_set_my_LUN(ipmi_user_t user,
774 unsigned char LUN)
775 {
776 user->intf->my_lun = LUN & 0x3;
777 }
778
779 unsigned char ipmi_get_my_LUN(ipmi_user_t user)
780 {
781 return user->intf->my_lun;
782 }
783
784 int ipmi_set_gets_events(ipmi_user_t user, int val)
785 {
786 unsigned long flags;
787 struct ipmi_recv_msg *msg, *msg2;
788
789 read_lock(&(user->intf->users_lock));
790 spin_lock_irqsave(&(user->intf->events_lock), flags);
791 user->gets_events = val;
792
793 if (val) {
794 /* Deliver any queued events. */
795 list_for_each_entry_safe(msg, msg2, &(user->intf->waiting_events), link) {
796 list_del(&msg->link);
797 msg->user = user;
798 deliver_response(msg);
799 }
800 }
801
802 spin_unlock_irqrestore(&(user->intf->events_lock), flags);
803 read_unlock(&(user->intf->users_lock));
804
805 return 0;
806 }
807
808 int ipmi_register_for_cmd(ipmi_user_t user,
809 unsigned char netfn,
810 unsigned char cmd)
811 {
812 struct cmd_rcvr *cmp;
813 unsigned long flags;
814 struct cmd_rcvr *rcvr;
815 int rv = 0;
816
817
818 rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL);
819 if (! rcvr)
820 return -ENOMEM;
821
822 read_lock(&(user->intf->users_lock));
823 write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags);
824 if (user->intf->all_cmd_rcvr != NULL) {
825 rv = -EBUSY;
826 goto out_unlock;
827 }
828
829 /* Make sure the command/netfn is not already registered. */
830 list_for_each_entry(cmp, &(user->intf->cmd_rcvrs), link) {
831 if ((cmp->netfn == netfn) && (cmp->cmd == cmd)) {
832 rv = -EBUSY;
833 break;
834 }
835 }
836
837 if (! rv) {
838 rcvr->cmd = cmd;
839 rcvr->netfn = netfn;
840 rcvr->user = user;
841 list_add_tail(&(rcvr->link), &(user->intf->cmd_rcvrs));
842 }
843 out_unlock:
844 write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags);
845 read_unlock(&(user->intf->users_lock));
846
847 if (rv)
848 kfree(rcvr);
849
850 return rv;
851 }
852
853 int ipmi_unregister_for_cmd(ipmi_user_t user,
854 unsigned char netfn,
855 unsigned char cmd)
856 {
857 unsigned long flags;
858 struct cmd_rcvr *rcvr;
859 int rv = -ENOENT;
860
861 read_lock(&(user->intf->users_lock));
862 write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags);
863 /* Make sure the command/netfn is not already registered. */
864 list_for_each_entry(rcvr, &(user->intf->cmd_rcvrs), link) {
865 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
866 rv = 0;
867 list_del(&rcvr->link);
868 kfree(rcvr);
869 break;
870 }
871 }
872 write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags);
873 read_unlock(&(user->intf->users_lock));
874
875 return rv;
876 }
877
878 void ipmi_user_set_run_to_completion(ipmi_user_t user, int val)
879 {
880 user->intf->handlers->set_run_to_completion(user->intf->send_info,
881 val);
882 }
883
884 static unsigned char
885 ipmb_checksum(unsigned char *data, int size)
886 {
887 unsigned char csum = 0;
888
889 for (; size > 0; size--, data++)
890 csum += *data;
891
892 return -csum;
893 }
894
895 static inline void format_ipmb_msg(struct ipmi_smi_msg *smi_msg,
896 struct kernel_ipmi_msg *msg,
897 struct ipmi_ipmb_addr *ipmb_addr,
898 long msgid,
899 unsigned char ipmb_seq,
900 int broadcast,
901 unsigned char source_address,
902 unsigned char source_lun)
903 {
904 int i = broadcast;
905
906 /* Format the IPMB header data. */
907 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
908 smi_msg->data[1] = IPMI_SEND_MSG_CMD;
909 smi_msg->data[2] = ipmb_addr->channel;
910 if (broadcast)
911 smi_msg->data[3] = 0;
912 smi_msg->data[i+3] = ipmb_addr->slave_addr;
913 smi_msg->data[i+4] = (msg->netfn << 2) | (ipmb_addr->lun & 0x3);
914 smi_msg->data[i+5] = ipmb_checksum(&(smi_msg->data[i+3]), 2);
915 smi_msg->data[i+6] = source_address;
916 smi_msg->data[i+7] = (ipmb_seq << 2) | source_lun;
917 smi_msg->data[i+8] = msg->cmd;
918
919 /* Now tack on the data to the message. */
920 if (msg->data_len > 0)
921 memcpy(&(smi_msg->data[i+9]), msg->data,
922 msg->data_len);
923 smi_msg->data_size = msg->data_len + 9;
924
925 /* Now calculate the checksum and tack it on. */
926 smi_msg->data[i+smi_msg->data_size]
927 = ipmb_checksum(&(smi_msg->data[i+6]),
928 smi_msg->data_size-6);
929
930 /* Add on the checksum size and the offset from the
931 broadcast. */
932 smi_msg->data_size += 1 + i;
933
934 smi_msg->msgid = msgid;
935 }
936
937 static inline void format_lan_msg(struct ipmi_smi_msg *smi_msg,
938 struct kernel_ipmi_msg *msg,
939 struct ipmi_lan_addr *lan_addr,
940 long msgid,
941 unsigned char ipmb_seq,
942 unsigned char source_lun)
943 {
944 /* Format the IPMB header data. */
945 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
946 smi_msg->data[1] = IPMI_SEND_MSG_CMD;
947 smi_msg->data[2] = lan_addr->channel;
948 smi_msg->data[3] = lan_addr->session_handle;
949 smi_msg->data[4] = lan_addr->remote_SWID;
950 smi_msg->data[5] = (msg->netfn << 2) | (lan_addr->lun & 0x3);
951 smi_msg->data[6] = ipmb_checksum(&(smi_msg->data[4]), 2);
952 smi_msg->data[7] = lan_addr->local_SWID;
953 smi_msg->data[8] = (ipmb_seq << 2) | source_lun;
954 smi_msg->data[9] = msg->cmd;
955
956 /* Now tack on the data to the message. */
957 if (msg->data_len > 0)
958 memcpy(&(smi_msg->data[10]), msg->data,
959 msg->data_len);
960 smi_msg->data_size = msg->data_len + 10;
961
962 /* Now calculate the checksum and tack it on. */
963 smi_msg->data[smi_msg->data_size]
964 = ipmb_checksum(&(smi_msg->data[7]),
965 smi_msg->data_size-7);
966
967 /* Add on the checksum size and the offset from the
968 broadcast. */
969 smi_msg->data_size += 1;
970
971 smi_msg->msgid = msgid;
972 }
973
974 /* Separate from ipmi_request so that the user does not have to be
975 supplied in certain circumstances (mainly at panic time). If
976 messages are supplied, they will be freed, even if an error
977 occurs. */
978 static inline int i_ipmi_request(ipmi_user_t user,
979 ipmi_smi_t intf,
980 struct ipmi_addr *addr,
981 long msgid,
982 struct kernel_ipmi_msg *msg,
983 void *user_msg_data,
984 void *supplied_smi,
985 struct ipmi_recv_msg *supplied_recv,
986 int priority,
987 unsigned char source_address,
988 unsigned char source_lun,
989 int retries,
990 unsigned int retry_time_ms)
991 {
992 int rv = 0;
993 struct ipmi_smi_msg *smi_msg;
994 struct ipmi_recv_msg *recv_msg;
995 unsigned long flags;
996
997
998 if (supplied_recv) {
999 recv_msg = supplied_recv;
1000 } else {
1001 recv_msg = ipmi_alloc_recv_msg();
1002 if (recv_msg == NULL) {
1003 return -ENOMEM;
1004 }
1005 }
1006 recv_msg->user_msg_data = user_msg_data;
1007
1008 if (supplied_smi) {
1009 smi_msg = (struct ipmi_smi_msg *) supplied_smi;
1010 } else {
1011 smi_msg = ipmi_alloc_smi_msg();
1012 if (smi_msg == NULL) {
1013 ipmi_free_recv_msg(recv_msg);
1014 return -ENOMEM;
1015 }
1016 }
1017
1018 recv_msg->user = user;
1019 recv_msg->msgid = msgid;
1020 /* Store the message to send in the receive message so timeout
1021 responses can get the proper response data. */
1022 recv_msg->msg = *msg;
1023
1024 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
1025 struct ipmi_system_interface_addr *smi_addr;
1026
1027 if (msg->netfn & 1) {
1028 /* Responses are not allowed to the SMI. */
1029 rv = -EINVAL;
1030 goto out_err;
1031 }
1032
1033 smi_addr = (struct ipmi_system_interface_addr *) addr;
1034 if (smi_addr->lun > 3) {
1035 spin_lock_irqsave(&intf->counter_lock, flags);
1036 intf->sent_invalid_commands++;
1037 spin_unlock_irqrestore(&intf->counter_lock, flags);
1038 rv = -EINVAL;
1039 goto out_err;
1040 }
1041
1042 memcpy(&recv_msg->addr, smi_addr, sizeof(*smi_addr));
1043
1044 if ((msg->netfn == IPMI_NETFN_APP_REQUEST)
1045 && ((msg->cmd == IPMI_SEND_MSG_CMD)
1046 || (msg->cmd == IPMI_GET_MSG_CMD)
1047 || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD)))
1048 {
1049 /* We don't let the user do these, since we manage
1050 the sequence numbers. */
1051 spin_lock_irqsave(&intf->counter_lock, flags);
1052 intf->sent_invalid_commands++;
1053 spin_unlock_irqrestore(&intf->counter_lock, flags);
1054 rv = -EINVAL;
1055 goto out_err;
1056 }
1057
1058 if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) {
1059 spin_lock_irqsave(&intf->counter_lock, flags);
1060 intf->sent_invalid_commands++;
1061 spin_unlock_irqrestore(&intf->counter_lock, flags);
1062 rv = -EMSGSIZE;
1063 goto out_err;
1064 }
1065
1066 smi_msg->data[0] = (msg->netfn << 2) | (smi_addr->lun & 0x3);
1067 smi_msg->data[1] = msg->cmd;
1068 smi_msg->msgid = msgid;
1069 smi_msg->user_data = recv_msg;
1070 if (msg->data_len > 0)
1071 memcpy(&(smi_msg->data[2]), msg->data, msg->data_len);
1072 smi_msg->data_size = msg->data_len + 2;
1073 spin_lock_irqsave(&intf->counter_lock, flags);
1074 intf->sent_local_commands++;
1075 spin_unlock_irqrestore(&intf->counter_lock, flags);
1076 } else if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
1077 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
1078 {
1079 struct ipmi_ipmb_addr *ipmb_addr;
1080 unsigned char ipmb_seq;
1081 long seqid;
1082 int broadcast = 0;
1083
1084 if (addr->channel > IPMI_NUM_CHANNELS) {
1085 spin_lock_irqsave(&intf->counter_lock, flags);
1086 intf->sent_invalid_commands++;
1087 spin_unlock_irqrestore(&intf->counter_lock, flags);
1088 rv = -EINVAL;
1089 goto out_err;
1090 }
1091
1092 if (intf->channels[addr->channel].medium
1093 != IPMI_CHANNEL_MEDIUM_IPMB)
1094 {
1095 spin_lock_irqsave(&intf->counter_lock, flags);
1096 intf->sent_invalid_commands++;
1097 spin_unlock_irqrestore(&intf->counter_lock, flags);
1098 rv = -EINVAL;
1099 goto out_err;
1100 }
1101
1102 if (retries < 0) {
1103 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)
1104 retries = 0; /* Don't retry broadcasts. */
1105 else
1106 retries = 4;
1107 }
1108 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) {
1109 /* Broadcasts add a zero at the beginning of the
1110 message, but otherwise is the same as an IPMB
1111 address. */
1112 addr->addr_type = IPMI_IPMB_ADDR_TYPE;
1113 broadcast = 1;
1114 }
1115
1116
1117 /* Default to 1 second retries. */
1118 if (retry_time_ms == 0)
1119 retry_time_ms = 1000;
1120
1121 /* 9 for the header and 1 for the checksum, plus
1122 possibly one for the broadcast. */
1123 if ((msg->data_len + 10 + broadcast) > IPMI_MAX_MSG_LENGTH) {
1124 spin_lock_irqsave(&intf->counter_lock, flags);
1125 intf->sent_invalid_commands++;
1126 spin_unlock_irqrestore(&intf->counter_lock, flags);
1127 rv = -EMSGSIZE;
1128 goto out_err;
1129 }
1130
1131 ipmb_addr = (struct ipmi_ipmb_addr *) addr;
1132 if (ipmb_addr->lun > 3) {
1133 spin_lock_irqsave(&intf->counter_lock, flags);
1134 intf->sent_invalid_commands++;
1135 spin_unlock_irqrestore(&intf->counter_lock, flags);
1136 rv = -EINVAL;
1137 goto out_err;
1138 }
1139
1140 memcpy(&recv_msg->addr, ipmb_addr, sizeof(*ipmb_addr));
1141
1142 if (recv_msg->msg.netfn & 0x1) {
1143 /* It's a response, so use the user's sequence
1144 from msgid. */
1145 spin_lock_irqsave(&intf->counter_lock, flags);
1146 intf->sent_ipmb_responses++;
1147 spin_unlock_irqrestore(&intf->counter_lock, flags);
1148 format_ipmb_msg(smi_msg, msg, ipmb_addr, msgid,
1149 msgid, broadcast,
1150 source_address, source_lun);
1151
1152 /* Save the receive message so we can use it
1153 to deliver the response. */
1154 smi_msg->user_data = recv_msg;
1155 } else {
1156 /* It's a command, so get a sequence for it. */
1157
1158 spin_lock_irqsave(&(intf->seq_lock), flags);
1159
1160 spin_lock(&intf->counter_lock);
1161 intf->sent_ipmb_commands++;
1162 spin_unlock(&intf->counter_lock);
1163
1164 /* Create a sequence number with a 1 second
1165 timeout and 4 retries. */
1166 rv = intf_next_seq(intf,
1167 recv_msg,
1168 retry_time_ms,
1169 retries,
1170 broadcast,
1171 &ipmb_seq,
1172 &seqid);
1173 if (rv) {
1174 /* We have used up all the sequence numbers,
1175 probably, so abort. */
1176 spin_unlock_irqrestore(&(intf->seq_lock),
1177 flags);
1178 goto out_err;
1179 }
1180
1181 /* Store the sequence number in the message,
1182 so that when the send message response
1183 comes back we can start the timer. */
1184 format_ipmb_msg(smi_msg, msg, ipmb_addr,
1185 STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
1186 ipmb_seq, broadcast,
1187 source_address, source_lun);
1188
1189 /* Copy the message into the recv message data, so we
1190 can retransmit it later if necessary. */
1191 memcpy(recv_msg->msg_data, smi_msg->data,
1192 smi_msg->data_size);
1193 recv_msg->msg.data = recv_msg->msg_data;
1194 recv_msg->msg.data_len = smi_msg->data_size;
1195
1196 /* We don't unlock until here, because we need
1197 to copy the completed message into the
1198 recv_msg before we release the lock.
1199 Otherwise, race conditions may bite us. I
1200 know that's pretty paranoid, but I prefer
1201 to be correct. */
1202 spin_unlock_irqrestore(&(intf->seq_lock), flags);
1203 }
1204 } else if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
1205 struct ipmi_lan_addr *lan_addr;
1206 unsigned char ipmb_seq;
1207 long seqid;
1208
1209 if (addr->channel > IPMI_NUM_CHANNELS) {
1210 spin_lock_irqsave(&intf->counter_lock, flags);
1211 intf->sent_invalid_commands++;
1212 spin_unlock_irqrestore(&intf->counter_lock, flags);
1213 rv = -EINVAL;
1214 goto out_err;
1215 }
1216
1217 if ((intf->channels[addr->channel].medium
1218 != IPMI_CHANNEL_MEDIUM_8023LAN)
1219 && (intf->channels[addr->channel].medium
1220 != IPMI_CHANNEL_MEDIUM_ASYNC))
1221 {
1222 spin_lock_irqsave(&intf->counter_lock, flags);
1223 intf->sent_invalid_commands++;
1224 spin_unlock_irqrestore(&intf->counter_lock, flags);
1225 rv = -EINVAL;
1226 goto out_err;
1227 }
1228
1229 retries = 4;
1230
1231 /* Default to 1 second retries. */
1232 if (retry_time_ms == 0)
1233 retry_time_ms = 1000;
1234
1235 /* 11 for the header and 1 for the checksum. */
1236 if ((msg->data_len + 12) > IPMI_MAX_MSG_LENGTH) {
1237 spin_lock_irqsave(&intf->counter_lock, flags);
1238 intf->sent_invalid_commands++;
1239 spin_unlock_irqrestore(&intf->counter_lock, flags);
1240 rv = -EMSGSIZE;
1241 goto out_err;
1242 }
1243
1244 lan_addr = (struct ipmi_lan_addr *) addr;
1245 if (lan_addr->lun > 3) {
1246 spin_lock_irqsave(&intf->counter_lock, flags);
1247 intf->sent_invalid_commands++;
1248 spin_unlock_irqrestore(&intf->counter_lock, flags);
1249 rv = -EINVAL;
1250 goto out_err;
1251 }
1252
1253 memcpy(&recv_msg->addr, lan_addr, sizeof(*lan_addr));
1254
1255 if (recv_msg->msg.netfn & 0x1) {
1256 /* It's a response, so use the user's sequence
1257 from msgid. */
1258 spin_lock_irqsave(&intf->counter_lock, flags);
1259 intf->sent_lan_responses++;
1260 spin_unlock_irqrestore(&intf->counter_lock, flags);
1261 format_lan_msg(smi_msg, msg, lan_addr, msgid,
1262 msgid, source_lun);
1263
1264 /* Save the receive message so we can use it
1265 to deliver the response. */
1266 smi_msg->user_data = recv_msg;
1267 } else {
1268 /* It's a command, so get a sequence for it. */
1269
1270 spin_lock_irqsave(&(intf->seq_lock), flags);
1271
1272 spin_lock(&intf->counter_lock);
1273 intf->sent_lan_commands++;
1274 spin_unlock(&intf->counter_lock);
1275
1276 /* Create a sequence number with a 1 second
1277 timeout and 4 retries. */
1278 rv = intf_next_seq(intf,
1279 recv_msg,
1280 retry_time_ms,
1281 retries,
1282 0,
1283 &ipmb_seq,
1284 &seqid);
1285 if (rv) {
1286 /* We have used up all the sequence numbers,
1287 probably, so abort. */
1288 spin_unlock_irqrestore(&(intf->seq_lock),
1289 flags);
1290 goto out_err;
1291 }
1292
1293 /* Store the sequence number in the message,
1294 so that when the send message response
1295 comes back we can start the timer. */
1296 format_lan_msg(smi_msg, msg, lan_addr,
1297 STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
1298 ipmb_seq, source_lun);
1299
1300 /* Copy the message into the recv message data, so we
1301 can retransmit it later if necessary. */
1302 memcpy(recv_msg->msg_data, smi_msg->data,
1303 smi_msg->data_size);
1304 recv_msg->msg.data = recv_msg->msg_data;
1305 recv_msg->msg.data_len = smi_msg->data_size;
1306
1307 /* We don't unlock until here, because we need
1308 to copy the completed message into the
1309 recv_msg before we release the lock.
1310 Otherwise, race conditions may bite us. I
1311 know that's pretty paranoid, but I prefer
1312 to be correct. */
1313 spin_unlock_irqrestore(&(intf->seq_lock), flags);
1314 }
1315 } else {
1316 /* Unknown address type. */
1317 spin_lock_irqsave(&intf->counter_lock, flags);
1318 intf->sent_invalid_commands++;
1319 spin_unlock_irqrestore(&intf->counter_lock, flags);
1320 rv = -EINVAL;
1321 goto out_err;
1322 }
1323
1324 #ifdef DEBUG_MSGING
1325 {
1326 int m;
1327 for (m=0; m<smi_msg->data_size; m++)
1328 printk(" %2.2x", smi_msg->data[m]);
1329 printk("\n");
1330 }
1331 #endif
1332 intf->handlers->sender(intf->send_info, smi_msg, priority);
1333
1334 return 0;
1335
1336 out_err:
1337 ipmi_free_smi_msg(smi_msg);
1338 ipmi_free_recv_msg(recv_msg);
1339 return rv;
1340 }
1341
1342 int ipmi_request_settime(ipmi_user_t user,
1343 struct ipmi_addr *addr,
1344 long msgid,
1345 struct kernel_ipmi_msg *msg,
1346 void *user_msg_data,
1347 int priority,
1348 int retries,
1349 unsigned int retry_time_ms)
1350 {
1351 return i_ipmi_request(user,
1352 user->intf,
1353 addr,
1354 msgid,
1355 msg,
1356 user_msg_data,
1357 NULL, NULL,
1358 priority,
1359 user->intf->my_address,
1360 user->intf->my_lun,
1361 retries,
1362 retry_time_ms);
1363 }
1364
1365 int ipmi_request_supply_msgs(ipmi_user_t user,
1366 struct ipmi_addr *addr,
1367 long msgid,
1368 struct kernel_ipmi_msg *msg,
1369 void *user_msg_data,
1370 void *supplied_smi,
1371 struct ipmi_recv_msg *supplied_recv,
1372 int priority)
1373 {
1374 return i_ipmi_request(user,
1375 user->intf,
1376 addr,
1377 msgid,
1378 msg,
1379 user_msg_data,
1380 supplied_smi,
1381 supplied_recv,
1382 priority,
1383 user->intf->my_address,
1384 user->intf->my_lun,
1385 -1, 0);
1386 }
1387
1388 static int ipmb_file_read_proc(char *page, char **start, off_t off,
1389 int count, int *eof, void *data)
1390 {
1391 char *out = (char *) page;
1392 ipmi_smi_t intf = data;
1393
1394 return sprintf(out, "%x\n", intf->my_address);
1395 }
1396
1397 static int version_file_read_proc(char *page, char **start, off_t off,
1398 int count, int *eof, void *data)
1399 {
1400 char *out = (char *) page;
1401 ipmi_smi_t intf = data;
1402
1403 return sprintf(out, "%d.%d\n",
1404 intf->version_major, intf->version_minor);
1405 }
1406
1407 static int stat_file_read_proc(char *page, char **start, off_t off,
1408 int count, int *eof, void *data)
1409 {
1410 char *out = (char *) page;
1411 ipmi_smi_t intf = data;
1412
1413 out += sprintf(out, "sent_invalid_commands: %d\n",
1414 intf->sent_invalid_commands);
1415 out += sprintf(out, "sent_local_commands: %d\n",
1416 intf->sent_local_commands);
1417 out += sprintf(out, "handled_local_responses: %d\n",
1418 intf->handled_local_responses);
1419 out += sprintf(out, "unhandled_local_responses: %d\n",
1420 intf->unhandled_local_responses);
1421 out += sprintf(out, "sent_ipmb_commands: %d\n",
1422 intf->sent_ipmb_commands);
1423 out += sprintf(out, "sent_ipmb_command_errs: %d\n",
1424 intf->sent_ipmb_command_errs);
1425 out += sprintf(out, "retransmitted_ipmb_commands: %d\n",
1426 intf->retransmitted_ipmb_commands);
1427 out += sprintf(out, "timed_out_ipmb_commands: %d\n",
1428 intf->timed_out_ipmb_commands);
1429 out += sprintf(out, "timed_out_ipmb_broadcasts: %d\n",
1430 intf->timed_out_ipmb_broadcasts);
1431 out += sprintf(out, "sent_ipmb_responses: %d\n",
1432 intf->sent_ipmb_responses);
1433 out += sprintf(out, "handled_ipmb_responses: %d\n",
1434 intf->handled_ipmb_responses);
1435 out += sprintf(out, "invalid_ipmb_responses: %d\n",
1436 intf->invalid_ipmb_responses);
1437 out += sprintf(out, "unhandled_ipmb_responses: %d\n",
1438 intf->unhandled_ipmb_responses);
1439 out += sprintf(out, "sent_lan_commands: %d\n",
1440 intf->sent_lan_commands);
1441 out += sprintf(out, "sent_lan_command_errs: %d\n",
1442 intf->sent_lan_command_errs);
1443 out += sprintf(out, "retransmitted_lan_commands: %d\n",
1444 intf->retransmitted_lan_commands);
1445 out += sprintf(out, "timed_out_lan_commands: %d\n",
1446 intf->timed_out_lan_commands);
1447 out += sprintf(out, "sent_lan_responses: %d\n",
1448 intf->sent_lan_responses);
1449 out += sprintf(out, "handled_lan_responses: %d\n",
1450 intf->handled_lan_responses);
1451 out += sprintf(out, "invalid_lan_responses: %d\n",
1452 intf->invalid_lan_responses);
1453 out += sprintf(out, "unhandled_lan_responses: %d\n",
1454 intf->unhandled_lan_responses);
1455 out += sprintf(out, "handled_commands: %d\n",
1456 intf->handled_commands);
1457 out += sprintf(out, "invalid_commands: %d\n",
1458 intf->invalid_commands);
1459 out += sprintf(out, "unhandled_commands: %d\n",
1460 intf->unhandled_commands);
1461 out += sprintf(out, "invalid_events: %d\n",
1462 intf->invalid_events);
1463 out += sprintf(out, "events: %d\n",
1464 intf->events);
1465
1466 return (out - ((char *) page));
1467 }
1468
1469 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
1470 read_proc_t *read_proc, write_proc_t *write_proc,
1471 void *data, struct module *owner)
1472 {
1473 struct proc_dir_entry *file;
1474 int rv = 0;
1475 struct ipmi_proc_entry *entry;
1476
1477 /* Create a list element. */
1478 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1479 if (!entry)
1480 return -ENOMEM;
1481 entry->name = kmalloc(strlen(name)+1, GFP_KERNEL);
1482 if (!entry->name) {
1483 kfree(entry);
1484 return -ENOMEM;
1485 }
1486 strcpy(entry->name, name);
1487
1488 file = create_proc_entry(name, 0, smi->proc_dir);
1489 if (!file) {
1490 kfree(entry->name);
1491 kfree(entry);
1492 rv = -ENOMEM;
1493 } else {
1494 file->nlink = 1;
1495 file->data = data;
1496 file->read_proc = read_proc;
1497 file->write_proc = write_proc;
1498 file->owner = owner;
1499
1500 /* Stick it on the list. */
1501 entry->next = smi->proc_entries;
1502 smi->proc_entries = entry;
1503 }
1504
1505 return rv;
1506 }
1507
1508 static int add_proc_entries(ipmi_smi_t smi, int num)
1509 {
1510 int rv = 0;
1511
1512 sprintf(smi->proc_dir_name, "%d", num);
1513 smi->proc_dir = proc_mkdir(smi->proc_dir_name, proc_ipmi_root);
1514 if (!smi->proc_dir)
1515 rv = -ENOMEM;
1516 else {
1517 smi->proc_dir->owner = THIS_MODULE;
1518 }
1519
1520 if (rv == 0)
1521 rv = ipmi_smi_add_proc_entry(smi, "stats",
1522 stat_file_read_proc, NULL,
1523 smi, THIS_MODULE);
1524
1525 if (rv == 0)
1526 rv = ipmi_smi_add_proc_entry(smi, "ipmb",
1527 ipmb_file_read_proc, NULL,
1528 smi, THIS_MODULE);
1529
1530 if (rv == 0)
1531 rv = ipmi_smi_add_proc_entry(smi, "version",
1532 version_file_read_proc, NULL,
1533 smi, THIS_MODULE);
1534
1535 return rv;
1536 }
1537
1538 static void remove_proc_entries(ipmi_smi_t smi)
1539 {
1540 struct ipmi_proc_entry *entry;
1541
1542 while (smi->proc_entries) {
1543 entry = smi->proc_entries;
1544 smi->proc_entries = entry->next;
1545
1546 remove_proc_entry(entry->name, smi->proc_dir);
1547 kfree(entry->name);
1548 kfree(entry);
1549 }
1550 remove_proc_entry(smi->proc_dir_name, proc_ipmi_root);
1551 }
1552
1553 static int
1554 send_channel_info_cmd(ipmi_smi_t intf, int chan)
1555 {
1556 struct kernel_ipmi_msg msg;
1557 unsigned char data[1];
1558 struct ipmi_system_interface_addr si;
1559
1560 si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
1561 si.channel = IPMI_BMC_CHANNEL;
1562 si.lun = 0;
1563
1564 msg.netfn = IPMI_NETFN_APP_REQUEST;
1565 msg.cmd = IPMI_GET_CHANNEL_INFO_CMD;
1566 msg.data = data;
1567 msg.data_len = 1;
1568 data[0] = chan;
1569 return i_ipmi_request(NULL,
1570 intf,
1571 (struct ipmi_addr *) &si,
1572 0,
1573 &msg,
1574 NULL,
1575 NULL,
1576 NULL,
1577 0,
1578 intf->my_address,
1579 intf->my_lun,
1580 -1, 0);
1581 }
1582
1583 static void
1584 channel_handler(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
1585 {
1586 int rv = 0;
1587 int chan;
1588
1589 if ((msg->rsp[0] == (IPMI_NETFN_APP_RESPONSE << 2))
1590 && (msg->rsp[1] == IPMI_GET_CHANNEL_INFO_CMD))
1591 {
1592 /* It's the one we want */
1593 if (msg->rsp[2] != 0) {
1594 /* Got an error from the channel, just go on. */
1595
1596 if (msg->rsp[2] == IPMI_INVALID_COMMAND_ERR) {
1597 /* If the MC does not support this
1598 command, that is legal. We just
1599 assume it has one IPMB at channel
1600 zero. */
1601 intf->channels[0].medium
1602 = IPMI_CHANNEL_MEDIUM_IPMB;
1603 intf->channels[0].protocol
1604 = IPMI_CHANNEL_PROTOCOL_IPMB;
1605 rv = -ENOSYS;
1606
1607 intf->curr_channel = IPMI_MAX_CHANNELS;
1608 wake_up(&intf->waitq);
1609 goto out;
1610 }
1611 goto next_channel;
1612 }
1613 if (msg->rsp_size < 6) {
1614 /* Message not big enough, just go on. */
1615 goto next_channel;
1616 }
1617 chan = intf->curr_channel;
1618 intf->channels[chan].medium = msg->rsp[4] & 0x7f;
1619 intf->channels[chan].protocol = msg->rsp[5] & 0x1f;
1620
1621 next_channel:
1622 intf->curr_channel++;
1623 if (intf->curr_channel >= IPMI_MAX_CHANNELS)
1624 wake_up(&intf->waitq);
1625 else
1626 rv = send_channel_info_cmd(intf, intf->curr_channel);
1627
1628 if (rv) {
1629 /* Got an error somehow, just give up. */
1630 intf->curr_channel = IPMI_MAX_CHANNELS;
1631 wake_up(&intf->waitq);
1632
1633 printk(KERN_WARNING PFX
1634 "Error sending channel information: %d\n",
1635 rv);
1636 }
1637 }
1638 out:
1639 return;
1640 }
1641
1642 int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
1643 void *send_info,
1644 unsigned char version_major,
1645 unsigned char version_minor,
1646 unsigned char slave_addr,
1647 ipmi_smi_t *intf)
1648 {
1649 int i, j;
1650 int rv;
1651 ipmi_smi_t new_intf;
1652 unsigned long flags;
1653
1654
1655 /* Make sure the driver is actually initialized, this handles
1656 problems with initialization order. */
1657 if (!initialized) {
1658 rv = ipmi_init_msghandler();
1659 if (rv)
1660 return rv;
1661 /* The init code doesn't return an error if it was turned
1662 off, but it won't initialize. Check that. */
1663 if (!initialized)
1664 return -ENODEV;
1665 }
1666
1667 new_intf = kmalloc(sizeof(*new_intf), GFP_KERNEL);
1668 if (!new_intf)
1669 return -ENOMEM;
1670 memset(new_intf, 0, sizeof(*new_intf));
1671
1672 new_intf->proc_dir = NULL;
1673
1674 rv = -ENOMEM;
1675
1676 down_write(&interfaces_sem);
1677 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
1678 if (ipmi_interfaces[i] == NULL) {
1679 new_intf->intf_num = i;
1680 new_intf->version_major = version_major;
1681 new_intf->version_minor = version_minor;
1682 if (slave_addr == 0)
1683 new_intf->my_address = IPMI_BMC_SLAVE_ADDR;
1684 else
1685 new_intf->my_address = slave_addr;
1686 new_intf->my_lun = 2; /* the SMS LUN. */
1687 rwlock_init(&(new_intf->users_lock));
1688 INIT_LIST_HEAD(&(new_intf->users));
1689 new_intf->handlers = handlers;
1690 new_intf->send_info = send_info;
1691 spin_lock_init(&(new_intf->seq_lock));
1692 for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) {
1693 new_intf->seq_table[j].inuse = 0;
1694 new_intf->seq_table[j].seqid = 0;
1695 }
1696 new_intf->curr_seq = 0;
1697 spin_lock_init(&(new_intf->waiting_msgs_lock));
1698 INIT_LIST_HEAD(&(new_intf->waiting_msgs));
1699 spin_lock_init(&(new_intf->events_lock));
1700 INIT_LIST_HEAD(&(new_intf->waiting_events));
1701 new_intf->waiting_events_count = 0;
1702 rwlock_init(&(new_intf->cmd_rcvr_lock));
1703 init_waitqueue_head(&new_intf->waitq);
1704 INIT_LIST_HEAD(&(new_intf->cmd_rcvrs));
1705 new_intf->all_cmd_rcvr = NULL;
1706
1707 spin_lock_init(&(new_intf->counter_lock));
1708
1709 spin_lock_irqsave(&interfaces_lock, flags);
1710 ipmi_interfaces[i] = new_intf;
1711 spin_unlock_irqrestore(&interfaces_lock, flags);
1712
1713 rv = 0;
1714 *intf = new_intf;
1715 break;
1716 }
1717 }
1718
1719 downgrade_write(&interfaces_sem);
1720
1721 if (rv == 0)
1722 rv = add_proc_entries(*intf, i);
1723
1724 if (rv == 0) {
1725 if ((version_major > 1)
1726 || ((version_major == 1) && (version_minor >= 5)))
1727 {
1728 /* Start scanning the channels to see what is
1729 available. */
1730 (*intf)->null_user_handler = channel_handler;
1731 (*intf)->curr_channel = 0;
1732 rv = send_channel_info_cmd(*intf, 0);
1733 if (rv)
1734 goto out;
1735
1736 /* Wait for the channel info to be read. */
1737 up_read(&interfaces_sem);
1738 wait_event((*intf)->waitq,
1739 ((*intf)->curr_channel>=IPMI_MAX_CHANNELS));
1740 down_read(&interfaces_sem);
1741
1742 if (ipmi_interfaces[i] != new_intf)
1743 /* Well, it went away. Just return. */
1744 goto out;
1745 } else {
1746 /* Assume a single IPMB channel at zero. */
1747 (*intf)->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB;
1748 (*intf)->channels[0].protocol
1749 = IPMI_CHANNEL_PROTOCOL_IPMB;
1750 }
1751
1752 /* Call all the watcher interfaces to tell
1753 them that a new interface is available. */
1754 call_smi_watchers(i);
1755 }
1756
1757 out:
1758 up_read(&interfaces_sem);
1759
1760 if (rv) {
1761 if (new_intf->proc_dir)
1762 remove_proc_entries(new_intf);
1763 kfree(new_intf);
1764 }
1765
1766 return rv;
1767 }
1768
1769 static void free_recv_msg_list(struct list_head *q)
1770 {
1771 struct ipmi_recv_msg *msg, *msg2;
1772
1773 list_for_each_entry_safe(msg, msg2, q, link) {
1774 list_del(&msg->link);
1775 ipmi_free_recv_msg(msg);
1776 }
1777 }
1778
1779 static void free_cmd_rcvr_list(struct list_head *q)
1780 {
1781 struct cmd_rcvr *rcvr, *rcvr2;
1782
1783 list_for_each_entry_safe(rcvr, rcvr2, q, link) {
1784 list_del(&rcvr->link);
1785 kfree(rcvr);
1786 }
1787 }
1788
1789 static void clean_up_interface_data(ipmi_smi_t intf)
1790 {
1791 int i;
1792
1793 free_recv_msg_list(&(intf->waiting_msgs));
1794 free_recv_msg_list(&(intf->waiting_events));
1795 free_cmd_rcvr_list(&(intf->cmd_rcvrs));
1796
1797 for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) {
1798 if ((intf->seq_table[i].inuse)
1799 && (intf->seq_table[i].recv_msg))
1800 {
1801 ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
1802 }
1803 }
1804 }
1805
1806 int ipmi_unregister_smi(ipmi_smi_t intf)
1807 {
1808 int rv = -ENODEV;
1809 int i;
1810 struct ipmi_smi_watcher *w;
1811 unsigned long flags;
1812
1813 down_write(&interfaces_sem);
1814 if (list_empty(&(intf->users)))
1815 {
1816 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
1817 if (ipmi_interfaces[i] == intf) {
1818 remove_proc_entries(intf);
1819 spin_lock_irqsave(&interfaces_lock, flags);
1820 ipmi_interfaces[i] = NULL;
1821 clean_up_interface_data(intf);
1822 spin_unlock_irqrestore(&interfaces_lock,flags);
1823 kfree(intf);
1824 rv = 0;
1825 goto out_call_watcher;
1826 }
1827 }
1828 } else {
1829 rv = -EBUSY;
1830 }
1831 up_write(&interfaces_sem);
1832
1833 return rv;
1834
1835 out_call_watcher:
1836 downgrade_write(&interfaces_sem);
1837
1838 /* Call all the watcher interfaces to tell them that
1839 an interface is gone. */
1840 down_read(&smi_watchers_sem);
1841 list_for_each_entry(w, &smi_watchers, link) {
1842 w->smi_gone(i);
1843 }
1844 up_read(&smi_watchers_sem);
1845 up_read(&interfaces_sem);
1846 return 0;
1847 }
1848
1849 static int handle_ipmb_get_msg_rsp(ipmi_smi_t intf,
1850 struct ipmi_smi_msg *msg)
1851 {
1852 struct ipmi_ipmb_addr ipmb_addr;
1853 struct ipmi_recv_msg *recv_msg;
1854 unsigned long flags;
1855
1856
1857 /* This is 11, not 10, because the response must contain a
1858 * completion code. */
1859 if (msg->rsp_size < 11) {
1860 /* Message not big enough, just ignore it. */
1861 spin_lock_irqsave(&intf->counter_lock, flags);
1862 intf->invalid_ipmb_responses++;
1863 spin_unlock_irqrestore(&intf->counter_lock, flags);
1864 return 0;
1865 }
1866
1867 if (msg->rsp[2] != 0) {
1868 /* An error getting the response, just ignore it. */
1869 return 0;
1870 }
1871
1872 ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE;
1873 ipmb_addr.slave_addr = msg->rsp[6];
1874 ipmb_addr.channel = msg->rsp[3] & 0x0f;
1875 ipmb_addr.lun = msg->rsp[7] & 3;
1876
1877 /* It's a response from a remote entity. Look up the sequence
1878 number and handle the response. */
1879 if (intf_find_seq(intf,
1880 msg->rsp[7] >> 2,
1881 msg->rsp[3] & 0x0f,
1882 msg->rsp[8],
1883 (msg->rsp[4] >> 2) & (~1),
1884 (struct ipmi_addr *) &(ipmb_addr),
1885 &recv_msg))
1886 {
1887 /* We were unable to find the sequence number,
1888 so just nuke the message. */
1889 spin_lock_irqsave(&intf->counter_lock, flags);
1890 intf->unhandled_ipmb_responses++;
1891 spin_unlock_irqrestore(&intf->counter_lock, flags);
1892 return 0;
1893 }
1894
1895 memcpy(recv_msg->msg_data,
1896 &(msg->rsp[9]),
1897 msg->rsp_size - 9);
1898 /* THe other fields matched, so no need to set them, except
1899 for netfn, which needs to be the response that was
1900 returned, not the request value. */
1901 recv_msg->msg.netfn = msg->rsp[4] >> 2;
1902 recv_msg->msg.data = recv_msg->msg_data;
1903 recv_msg->msg.data_len = msg->rsp_size - 10;
1904 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
1905 spin_lock_irqsave(&intf->counter_lock, flags);
1906 intf->handled_ipmb_responses++;
1907 spin_unlock_irqrestore(&intf->counter_lock, flags);
1908 deliver_response(recv_msg);
1909
1910 return 0;
1911 }
1912
1913 static int handle_ipmb_get_msg_cmd(ipmi_smi_t intf,
1914 struct ipmi_smi_msg *msg)
1915 {
1916 struct cmd_rcvr *rcvr;
1917 int rv = 0;
1918 unsigned char netfn;
1919 unsigned char cmd;
1920 ipmi_user_t user = NULL;
1921 struct ipmi_ipmb_addr *ipmb_addr;
1922 struct ipmi_recv_msg *recv_msg;
1923 unsigned long flags;
1924
1925 if (msg->rsp_size < 10) {
1926 /* Message not big enough, just ignore it. */
1927 spin_lock_irqsave(&intf->counter_lock, flags);
1928 intf->invalid_commands++;
1929 spin_unlock_irqrestore(&intf->counter_lock, flags);
1930 return 0;
1931 }
1932
1933 if (msg->rsp[2] != 0) {
1934 /* An error getting the response, just ignore it. */
1935 return 0;
1936 }
1937
1938 netfn = msg->rsp[4] >> 2;
1939 cmd = msg->rsp[8];
1940
1941 read_lock(&(intf->cmd_rcvr_lock));
1942
1943 if (intf->all_cmd_rcvr) {
1944 user = intf->all_cmd_rcvr;
1945 } else {
1946 /* Find the command/netfn. */
1947 list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
1948 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
1949 user = rcvr->user;
1950 break;
1951 }
1952 }
1953 }
1954 read_unlock(&(intf->cmd_rcvr_lock));
1955
1956 if (user == NULL) {
1957 /* We didn't find a user, deliver an error response. */
1958 spin_lock_irqsave(&intf->counter_lock, flags);
1959 intf->unhandled_commands++;
1960 spin_unlock_irqrestore(&intf->counter_lock, flags);
1961
1962 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
1963 msg->data[1] = IPMI_SEND_MSG_CMD;
1964 msg->data[2] = msg->rsp[3];
1965 msg->data[3] = msg->rsp[6];
1966 msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3);
1967 msg->data[5] = ipmb_checksum(&(msg->data[3]), 2);
1968 msg->data[6] = intf->my_address;
1969 /* rqseq/lun */
1970 msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3);
1971 msg->data[8] = msg->rsp[8]; /* cmd */
1972 msg->data[9] = IPMI_INVALID_CMD_COMPLETION_CODE;
1973 msg->data[10] = ipmb_checksum(&(msg->data[6]), 4);
1974 msg->data_size = 11;
1975
1976 #ifdef DEBUG_MSGING
1977 {
1978 int m;
1979 printk("Invalid command:");
1980 for (m=0; m<msg->data_size; m++)
1981 printk(" %2.2x", msg->data[m]);
1982 printk("\n");
1983 }
1984 #endif
1985 intf->handlers->sender(intf->send_info, msg, 0);
1986
1987 rv = -1; /* We used the message, so return the value that
1988 causes it to not be freed or queued. */
1989 } else {
1990 /* Deliver the message to the user. */
1991 spin_lock_irqsave(&intf->counter_lock, flags);
1992 intf->handled_commands++;
1993 spin_unlock_irqrestore(&intf->counter_lock, flags);
1994
1995 recv_msg = ipmi_alloc_recv_msg();
1996 if (! recv_msg) {
1997 /* We couldn't allocate memory for the
1998 message, so requeue it for handling
1999 later. */
2000 rv = 1;
2001 } else {
2002 /* Extract the source address from the data. */
2003 ipmb_addr = (struct ipmi_ipmb_addr *) &recv_msg->addr;
2004 ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE;
2005 ipmb_addr->slave_addr = msg->rsp[6];
2006 ipmb_addr->lun = msg->rsp[7] & 3;
2007 ipmb_addr->channel = msg->rsp[3] & 0xf;
2008
2009 /* Extract the rest of the message information
2010 from the IPMB header.*/
2011 recv_msg->user = user;
2012 recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
2013 recv_msg->msgid = msg->rsp[7] >> 2;
2014 recv_msg->msg.netfn = msg->rsp[4] >> 2;
2015 recv_msg->msg.cmd = msg->rsp[8];
2016 recv_msg->msg.data = recv_msg->msg_data;
2017
2018 /* We chop off 10, not 9 bytes because the checksum
2019 at the end also needs to be removed. */
2020 recv_msg->msg.data_len = msg->rsp_size - 10;
2021 memcpy(recv_msg->msg_data,
2022 &(msg->rsp[9]),
2023 msg->rsp_size - 10);
2024 deliver_response(recv_msg);
2025 }
2026 }
2027
2028 return rv;
2029 }
2030
2031 static int handle_lan_get_msg_rsp(ipmi_smi_t intf,
2032 struct ipmi_smi_msg *msg)
2033 {
2034 struct ipmi_lan_addr lan_addr;
2035 struct ipmi_recv_msg *recv_msg;
2036 unsigned long flags;
2037
2038
2039 /* This is 13, not 12, because the response must contain a
2040 * completion code. */
2041 if (msg->rsp_size < 13) {
2042 /* Message not big enough, just ignore it. */
2043 spin_lock_irqsave(&intf->counter_lock, flags);
2044 intf->invalid_lan_responses++;
2045 spin_unlock_irqrestore(&intf->counter_lock, flags);
2046 return 0;
2047 }
2048
2049 if (msg->rsp[2] != 0) {
2050 /* An error getting the response, just ignore it. */
2051 return 0;
2052 }
2053
2054 lan_addr.addr_type = IPMI_LAN_ADDR_TYPE;
2055 lan_addr.session_handle = msg->rsp[4];
2056 lan_addr.remote_SWID = msg->rsp[8];
2057 lan_addr.local_SWID = msg->rsp[5];
2058 lan_addr.channel = msg->rsp[3] & 0x0f;
2059 lan_addr.privilege = msg->rsp[3] >> 4;
2060 lan_addr.lun = msg->rsp[9] & 3;
2061
2062 /* It's a response from a remote entity. Look up the sequence
2063 number and handle the response. */
2064 if (intf_find_seq(intf,
2065 msg->rsp[9] >> 2,
2066 msg->rsp[3] & 0x0f,
2067 msg->rsp[10],
2068 (msg->rsp[6] >> 2) & (~1),
2069 (struct ipmi_addr *) &(lan_addr),
2070 &recv_msg))
2071 {
2072 /* We were unable to find the sequence number,
2073 so just nuke the message. */
2074 spin_lock_irqsave(&intf->counter_lock, flags);
2075 intf->unhandled_lan_responses++;
2076 spin_unlock_irqrestore(&intf->counter_lock, flags);
2077 return 0;
2078 }
2079
2080 memcpy(recv_msg->msg_data,
2081 &(msg->rsp[11]),
2082 msg->rsp_size - 11);
2083 /* The other fields matched, so no need to set them, except
2084 for netfn, which needs to be the response that was
2085 returned, not the request value. */
2086 recv_msg->msg.netfn = msg->rsp[6] >> 2;
2087 recv_msg->msg.data = recv_msg->msg_data;
2088 recv_msg->msg.data_len = msg->rsp_size - 12;
2089 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
2090 spin_lock_irqsave(&intf->counter_lock, flags);
2091 intf->handled_lan_responses++;
2092 spin_unlock_irqrestore(&intf->counter_lock, flags);
2093 deliver_response(recv_msg);
2094
2095 return 0;
2096 }
2097
2098 static int handle_lan_get_msg_cmd(ipmi_smi_t intf,
2099 struct ipmi_smi_msg *msg)
2100 {
2101 struct cmd_rcvr *rcvr;
2102 int rv = 0;
2103 unsigned char netfn;
2104 unsigned char cmd;
2105 ipmi_user_t user = NULL;
2106 struct ipmi_lan_addr *lan_addr;
2107 struct ipmi_recv_msg *recv_msg;
2108 unsigned long flags;
2109
2110 if (msg->rsp_size < 12) {
2111 /* Message not big enough, just ignore it. */
2112 spin_lock_irqsave(&intf->counter_lock, flags);
2113 intf->invalid_commands++;
2114 spin_unlock_irqrestore(&intf->counter_lock, flags);
2115 return 0;
2116 }
2117
2118 if (msg->rsp[2] != 0) {
2119 /* An error getting the response, just ignore it. */
2120 return 0;
2121 }
2122
2123 netfn = msg->rsp[6] >> 2;
2124 cmd = msg->rsp[10];
2125
2126 read_lock(&(intf->cmd_rcvr_lock));
2127
2128 if (intf->all_cmd_rcvr) {
2129 user = intf->all_cmd_rcvr;
2130 } else {
2131 /* Find the command/netfn. */
2132 list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
2133 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
2134 user = rcvr->user;
2135 break;
2136 }
2137 }
2138 }
2139 read_unlock(&(intf->cmd_rcvr_lock));
2140
2141 if (user == NULL) {
2142 /* We didn't find a user, deliver an error response. */
2143 spin_lock_irqsave(&intf->counter_lock, flags);
2144 intf->unhandled_commands++;
2145 spin_unlock_irqrestore(&intf->counter_lock, flags);
2146
2147 rv = 0; /* Don't do anything with these messages, just
2148 allow them to be freed. */
2149 } else {
2150 /* Deliver the message to the user. */
2151 spin_lock_irqsave(&intf->counter_lock, flags);
2152 intf->handled_commands++;
2153 spin_unlock_irqrestore(&intf->counter_lock, flags);
2154
2155 recv_msg = ipmi_alloc_recv_msg();
2156 if (! recv_msg) {
2157 /* We couldn't allocate memory for the
2158 message, so requeue it for handling
2159 later. */
2160 rv = 1;
2161 } else {
2162 /* Extract the source address from the data. */
2163 lan_addr = (struct ipmi_lan_addr *) &recv_msg->addr;
2164 lan_addr->addr_type = IPMI_LAN_ADDR_TYPE;
2165 lan_addr->session_handle = msg->rsp[4];
2166 lan_addr->remote_SWID = msg->rsp[8];
2167 lan_addr->local_SWID = msg->rsp[5];
2168 lan_addr->lun = msg->rsp[9] & 3;
2169 lan_addr->channel = msg->rsp[3] & 0xf;
2170 lan_addr->privilege = msg->rsp[3] >> 4;
2171
2172 /* Extract the rest of the message information
2173 from the IPMB header.*/
2174 recv_msg->user = user;
2175 recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
2176 recv_msg->msgid = msg->rsp[9] >> 2;
2177 recv_msg->msg.netfn = msg->rsp[6] >> 2;
2178 recv_msg->msg.cmd = msg->rsp[10];
2179 recv_msg->msg.data = recv_msg->msg_data;
2180
2181 /* We chop off 12, not 11 bytes because the checksum
2182 at the end also needs to be removed. */
2183 recv_msg->msg.data_len = msg->rsp_size - 12;
2184 memcpy(recv_msg->msg_data,
2185 &(msg->rsp[11]),
2186 msg->rsp_size - 12);
2187 deliver_response(recv_msg);
2188 }
2189 }
2190
2191 return rv;
2192 }
2193
2194 static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg,
2195 struct ipmi_smi_msg *msg)
2196 {
2197 struct ipmi_system_interface_addr *smi_addr;
2198
2199 recv_msg->msgid = 0;
2200 smi_addr = (struct ipmi_system_interface_addr *) &(recv_msg->addr);
2201 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2202 smi_addr->channel = IPMI_BMC_CHANNEL;
2203 smi_addr->lun = msg->rsp[0] & 3;
2204 recv_msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE;
2205 recv_msg->msg.netfn = msg->rsp[0] >> 2;
2206 recv_msg->msg.cmd = msg->rsp[1];
2207 memcpy(recv_msg->msg_data, &(msg->rsp[3]), msg->rsp_size - 3);
2208 recv_msg->msg.data = recv_msg->msg_data;
2209 recv_msg->msg.data_len = msg->rsp_size - 3;
2210 }
2211
2212 /* This will be called with the intf->users_lock read-locked, so no need
2213 to do that here. */
2214 static int handle_read_event_rsp(ipmi_smi_t intf,
2215 struct ipmi_smi_msg *msg)
2216 {
2217 struct ipmi_recv_msg *recv_msg, *recv_msg2;
2218 struct list_head msgs;
2219 ipmi_user_t user;
2220 int rv = 0;
2221 int deliver_count = 0;
2222 unsigned long flags;
2223
2224 if (msg->rsp_size < 19) {
2225 /* Message is too small to be an IPMB event. */
2226 spin_lock_irqsave(&intf->counter_lock, flags);
2227 intf->invalid_events++;
2228 spin_unlock_irqrestore(&intf->counter_lock, flags);
2229 return 0;
2230 }
2231
2232 if (msg->rsp[2] != 0) {
2233 /* An error getting the event, just ignore it. */
2234 return 0;
2235 }
2236
2237 INIT_LIST_HEAD(&msgs);
2238
2239 spin_lock_irqsave(&(intf->events_lock), flags);
2240
2241 spin_lock(&intf->counter_lock);
2242 intf->events++;
2243 spin_unlock(&intf->counter_lock);
2244
2245 /* Allocate and fill in one message for every user that is getting
2246 events. */
2247 list_for_each_entry(user, &(intf->users), link) {
2248 if (! user->gets_events)
2249 continue;
2250
2251 recv_msg = ipmi_alloc_recv_msg();
2252 if (! recv_msg) {
2253 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs, link) {
2254 list_del(&recv_msg->link);
2255 ipmi_free_recv_msg(recv_msg);
2256 }
2257 /* We couldn't allocate memory for the
2258 message, so requeue it for handling
2259 later. */
2260 rv = 1;
2261 goto out;
2262 }
2263
2264 deliver_count++;
2265
2266 copy_event_into_recv_msg(recv_msg, msg);
2267 recv_msg->user = user;
2268 list_add_tail(&(recv_msg->link), &msgs);
2269 }
2270
2271 if (deliver_count) {
2272 /* Now deliver all the messages. */
2273 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs, link) {
2274 list_del(&recv_msg->link);
2275 deliver_response(recv_msg);
2276 }
2277 } else if (intf->waiting_events_count < MAX_EVENTS_IN_QUEUE) {
2278 /* No one to receive the message, put it in queue if there's
2279 not already too many things in the queue. */
2280 recv_msg = ipmi_alloc_recv_msg();
2281 if (! recv_msg) {
2282 /* We couldn't allocate memory for the
2283 message, so requeue it for handling
2284 later. */
2285 rv = 1;
2286 goto out;
2287 }
2288
2289 copy_event_into_recv_msg(recv_msg, msg);
2290 list_add_tail(&(recv_msg->link), &(intf->waiting_events));
2291 } else {
2292 /* There's too many things in the queue, discard this
2293 message. */
2294 printk(KERN_WARNING PFX "Event queue full, discarding an"
2295 " incoming event\n");
2296 }
2297
2298 out:
2299 spin_unlock_irqrestore(&(intf->events_lock), flags);
2300
2301 return rv;
2302 }
2303
2304 static int handle_bmc_rsp(ipmi_smi_t intf,
2305 struct ipmi_smi_msg *msg)
2306 {
2307 struct ipmi_recv_msg *recv_msg;
2308 int found = 0;
2309 struct ipmi_user *user;
2310 unsigned long flags;
2311
2312 recv_msg = (struct ipmi_recv_msg *) msg->user_data;
2313
2314 /* Make sure the user still exists. */
2315 list_for_each_entry(user, &(intf->users), link) {
2316 if (user == recv_msg->user) {
2317 /* Found it, so we can deliver it */
2318 found = 1;
2319 break;
2320 }
2321 }
2322
2323 if (!found) {
2324 /* Special handling for NULL users. */
2325 if (!recv_msg->user && intf->null_user_handler){
2326 intf->null_user_handler(intf, msg);
2327 spin_lock_irqsave(&intf->counter_lock, flags);
2328 intf->handled_local_responses++;
2329 spin_unlock_irqrestore(&intf->counter_lock, flags);
2330 }else{
2331 /* The user for the message went away, so give up. */
2332 spin_lock_irqsave(&intf->counter_lock, flags);
2333 intf->unhandled_local_responses++;
2334 spin_unlock_irqrestore(&intf->counter_lock, flags);
2335 }
2336 ipmi_free_recv_msg(recv_msg);
2337 } else {
2338 struct ipmi_system_interface_addr *smi_addr;
2339
2340 spin_lock_irqsave(&intf->counter_lock, flags);
2341 intf->handled_local_responses++;
2342 spin_unlock_irqrestore(&intf->counter_lock, flags);
2343 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
2344 recv_msg->msgid = msg->msgid;
2345 smi_addr = ((struct ipmi_system_interface_addr *)
2346 &(recv_msg->addr));
2347 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2348 smi_addr->channel = IPMI_BMC_CHANNEL;
2349 smi_addr->lun = msg->rsp[0] & 3;
2350 recv_msg->msg.netfn = msg->rsp[0] >> 2;
2351 recv_msg->msg.cmd = msg->rsp[1];
2352 memcpy(recv_msg->msg_data,
2353 &(msg->rsp[2]),
2354 msg->rsp_size - 2);
2355 recv_msg->msg.data = recv_msg->msg_data;
2356 recv_msg->msg.data_len = msg->rsp_size - 2;
2357 deliver_response(recv_msg);
2358 }
2359
2360 return 0;
2361 }
2362
2363 /* Handle a new message. Return 1 if the message should be requeued,
2364 0 if the message should be freed, or -1 if the message should not
2365 be freed or requeued. */
2366 static int handle_new_recv_msg(ipmi_smi_t intf,
2367 struct ipmi_smi_msg *msg)
2368 {
2369 int requeue;
2370 int chan;
2371
2372 #ifdef DEBUG_MSGING
2373 int m;
2374 printk("Recv:");
2375 for (m=0; m<msg->rsp_size; m++)
2376 printk(" %2.2x", msg->rsp[m]);
2377 printk("\n");
2378 #endif
2379 if (msg->rsp_size < 2) {
2380 /* Message is too small to be correct. */
2381 printk(KERN_WARNING PFX "BMC returned to small a message"
2382 " for netfn %x cmd %x, got %d bytes\n",
2383 (msg->data[0] >> 2) | 1, msg->data[1], msg->rsp_size);
2384
2385 /* Generate an error response for the message. */
2386 msg->rsp[0] = msg->data[0] | (1 << 2);
2387 msg->rsp[1] = msg->data[1];
2388 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
2389 msg->rsp_size = 3;
2390 } else if (((msg->rsp[0] >> 2) != ((msg->data[0] >> 2) | 1))/* Netfn */
2391 || (msg->rsp[1] != msg->data[1])) /* Command */
2392 {
2393 /* The response is not even marginally correct. */
2394 printk(KERN_WARNING PFX "BMC returned incorrect response,"
2395 " expected netfn %x cmd %x, got netfn %x cmd %x\n",
2396 (msg->data[0] >> 2) | 1, msg->data[1],
2397 msg->rsp[0] >> 2, msg->rsp[1]);
2398
2399 /* Generate an error response for the message. */
2400 msg->rsp[0] = msg->data[0] | (1 << 2);
2401 msg->rsp[1] = msg->data[1];
2402 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
2403 msg->rsp_size = 3;
2404 }
2405
2406 if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
2407 && (msg->rsp[1] == IPMI_SEND_MSG_CMD)
2408 && (msg->user_data != NULL))
2409 {
2410 /* It's a response to a response we sent. For this we
2411 deliver a send message response to the user. */
2412 struct ipmi_recv_msg *recv_msg = msg->user_data;
2413
2414 requeue = 0;
2415 if (msg->rsp_size < 2)
2416 /* Message is too small to be correct. */
2417 goto out;
2418
2419 chan = msg->data[2] & 0x0f;
2420 if (chan >= IPMI_MAX_CHANNELS)
2421 /* Invalid channel number */
2422 goto out;
2423
2424 if (recv_msg) {
2425 recv_msg->recv_type = IPMI_RESPONSE_RESPONSE_TYPE;
2426 recv_msg->msg.data = recv_msg->msg_data;
2427 recv_msg->msg.data_len = 1;
2428 recv_msg->msg_data[0] = msg->rsp[2];
2429 deliver_response(recv_msg);
2430 }
2431 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
2432 && (msg->rsp[1] == IPMI_GET_MSG_CMD))
2433 {
2434 /* It's from the receive queue. */
2435 chan = msg->rsp[3] & 0xf;
2436 if (chan >= IPMI_MAX_CHANNELS) {
2437 /* Invalid channel number */
2438 requeue = 0;
2439 goto out;
2440 }
2441
2442 switch (intf->channels[chan].medium) {
2443 case IPMI_CHANNEL_MEDIUM_IPMB:
2444 if (msg->rsp[4] & 0x04) {
2445 /* It's a response, so find the
2446 requesting message and send it up. */
2447 requeue = handle_ipmb_get_msg_rsp(intf, msg);
2448 } else {
2449 /* It's a command to the SMS from some other
2450 entity. Handle that. */
2451 requeue = handle_ipmb_get_msg_cmd(intf, msg);
2452 }
2453 break;
2454
2455 case IPMI_CHANNEL_MEDIUM_8023LAN:
2456 case IPMI_CHANNEL_MEDIUM_ASYNC:
2457 if (msg->rsp[6] & 0x04) {
2458 /* It's a response, so find the
2459 requesting message and send it up. */
2460 requeue = handle_lan_get_msg_rsp(intf, msg);
2461 } else {
2462 /* It's a command to the SMS from some other
2463 entity. Handle that. */
2464 requeue = handle_lan_get_msg_cmd(intf, msg);
2465 }
2466 break;
2467
2468 default:
2469 /* We don't handle the channel type, so just
2470 * free the message. */
2471 requeue = 0;
2472 }
2473
2474 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
2475 && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD))
2476 {
2477 /* It's an asyncronous event. */
2478 requeue = handle_read_event_rsp(intf, msg);
2479 } else {
2480 /* It's a response from the local BMC. */
2481 requeue = handle_bmc_rsp(intf, msg);
2482 }
2483
2484 out:
2485 return requeue;
2486 }
2487
2488 /* Handle a new message from the lower layer. */
2489 void ipmi_smi_msg_received(ipmi_smi_t intf,
2490 struct ipmi_smi_msg *msg)
2491 {
2492 unsigned long flags;
2493 int rv;
2494
2495
2496 /* Lock the user lock so the user can't go away while we are
2497 working on it. */
2498 read_lock(&(intf->users_lock));
2499
2500 if ((msg->data_size >= 2)
2501 && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))
2502 && (msg->data[1] == IPMI_SEND_MSG_CMD)
2503 && (msg->user_data == NULL)) {
2504 /* This is the local response to a command send, start
2505 the timer for these. The user_data will not be
2506 NULL if this is a response send, and we will let
2507 response sends just go through. */
2508
2509 /* Check for errors, if we get certain errors (ones
2510 that mean basically we can try again later), we
2511 ignore them and start the timer. Otherwise we
2512 report the error immediately. */
2513 if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)
2514 && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)
2515 && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR))
2516 {
2517 int chan = msg->rsp[3] & 0xf;
2518
2519 /* Got an error sending the message, handle it. */
2520 spin_lock_irqsave(&intf->counter_lock, flags);
2521 if (chan >= IPMI_MAX_CHANNELS)
2522 ; /* This shouldn't happen */
2523 else if ((intf->channels[chan].medium
2524 == IPMI_CHANNEL_MEDIUM_8023LAN)
2525 || (intf->channels[chan].medium
2526 == IPMI_CHANNEL_MEDIUM_ASYNC))
2527 intf->sent_lan_command_errs++;
2528 else
2529 intf->sent_ipmb_command_errs++;
2530 spin_unlock_irqrestore(&intf->counter_lock, flags);
2531 intf_err_seq(intf, msg->msgid, msg->rsp[2]);
2532 } else {
2533 /* The message was sent, start the timer. */
2534 intf_start_seq_timer(intf, msg->msgid);
2535 }
2536
2537 ipmi_free_smi_msg(msg);
2538 goto out_unlock;
2539 }
2540
2541 /* To preserve message order, if the list is not empty, we
2542 tack this message onto the end of the list. */
2543 spin_lock_irqsave(&(intf->waiting_msgs_lock), flags);
2544 if (!list_empty(&(intf->waiting_msgs))) {
2545 list_add_tail(&(msg->link), &(intf->waiting_msgs));
2546 spin_unlock(&(intf->waiting_msgs_lock));
2547 goto out_unlock;
2548 }
2549 spin_unlock_irqrestore(&(intf->waiting_msgs_lock), flags);
2550
2551 rv = handle_new_recv_msg(intf, msg);
2552 if (rv > 0) {
2553 /* Could not handle the message now, just add it to a
2554 list to handle later. */
2555 spin_lock(&(intf->waiting_msgs_lock));
2556 list_add_tail(&(msg->link), &(intf->waiting_msgs));
2557 spin_unlock(&(intf->waiting_msgs_lock));
2558 } else if (rv == 0) {
2559 ipmi_free_smi_msg(msg);
2560 }
2561
2562 out_unlock:
2563 read_unlock(&(intf->users_lock));
2564 }
2565
2566 void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
2567 {
2568 ipmi_user_t user;
2569
2570 read_lock(&(intf->users_lock));
2571 list_for_each_entry(user, &(intf->users), link) {
2572 if (! user->handler->ipmi_watchdog_pretimeout)
2573 continue;
2574
2575 user->handler->ipmi_watchdog_pretimeout(user->handler_data);
2576 }
2577 read_unlock(&(intf->users_lock));
2578 }
2579
2580 static void
2581 handle_msg_timeout(struct ipmi_recv_msg *msg)
2582 {
2583 msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
2584 msg->msg_data[0] = IPMI_TIMEOUT_COMPLETION_CODE;
2585 msg->msg.netfn |= 1; /* Convert to a response. */
2586 msg->msg.data_len = 1;
2587 msg->msg.data = msg->msg_data;
2588 deliver_response(msg);
2589 }
2590
2591 static void
2592 send_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
2593 struct ipmi_smi_msg *smi_msg,
2594 unsigned char seq, long seqid)
2595 {
2596 if (!smi_msg)
2597 smi_msg = ipmi_alloc_smi_msg();
2598 if (!smi_msg)
2599 /* If we can't allocate the message, then just return, we
2600 get 4 retries, so this should be ok. */
2601 return;
2602
2603 memcpy(smi_msg->data, recv_msg->msg.data, recv_msg->msg.data_len);
2604 smi_msg->data_size = recv_msg->msg.data_len;
2605 smi_msg->msgid = STORE_SEQ_IN_MSGID(seq, seqid);
2606
2607 /* Send the new message. We send with a zero priority. It
2608 timed out, I doubt time is that critical now, and high
2609 priority messages are really only for messages to the local
2610 MC, which don't get resent. */
2611 intf->handlers->sender(intf->send_info, smi_msg, 0);
2612
2613 #ifdef DEBUG_MSGING
2614 {
2615 int m;
2616 printk("Resend: ");
2617 for (m=0; m<smi_msg->data_size; m++)
2618 printk(" %2.2x", smi_msg->data[m]);
2619 printk("\n");
2620 }
2621 #endif
2622 }
2623
2624 static void
2625 ipmi_timeout_handler(long timeout_period)
2626 {
2627 ipmi_smi_t intf;
2628 struct list_head timeouts;
2629 struct ipmi_recv_msg *msg, *msg2;
2630 struct ipmi_smi_msg *smi_msg, *smi_msg2;
2631 unsigned long flags;
2632 int i, j;
2633
2634 INIT_LIST_HEAD(&timeouts);
2635
2636 spin_lock(&interfaces_lock);
2637 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
2638 intf = ipmi_interfaces[i];
2639 if (intf == NULL)
2640 continue;
2641
2642 read_lock(&(intf->users_lock));
2643
2644 /* See if any waiting messages need to be processed. */
2645 spin_lock_irqsave(&(intf->waiting_msgs_lock), flags);
2646 list_for_each_entry_safe(smi_msg, smi_msg2, &(intf->waiting_msgs), link) {
2647 if (! handle_new_recv_msg(intf, smi_msg)) {
2648 list_del(&smi_msg->link);
2649 ipmi_free_smi_msg(smi_msg);
2650 } else {
2651 /* To preserve message order, quit if we
2652 can't handle a message. */
2653 break;
2654 }
2655 }
2656 spin_unlock_irqrestore(&(intf->waiting_msgs_lock), flags);
2657
2658 /* Go through the seq table and find any messages that
2659 have timed out, putting them in the timeouts
2660 list. */
2661 spin_lock_irqsave(&(intf->seq_lock), flags);
2662 for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) {
2663 struct seq_table *ent = &(intf->seq_table[j]);
2664 if (!ent->inuse)
2665 continue;
2666
2667 ent->timeout -= timeout_period;
2668 if (ent->timeout > 0)
2669 continue;
2670
2671 if (ent->retries_left == 0) {
2672 /* The message has used all its retries. */
2673 ent->inuse = 0;
2674 msg = ent->recv_msg;
2675 list_add_tail(&(msg->link), &timeouts);
2676 spin_lock(&intf->counter_lock);
2677 if (ent->broadcast)
2678 intf->timed_out_ipmb_broadcasts++;
2679 else if (ent->recv_msg->addr.addr_type
2680 == IPMI_LAN_ADDR_TYPE)
2681 intf->timed_out_lan_commands++;
2682 else
2683 intf->timed_out_ipmb_commands++;
2684 spin_unlock(&intf->counter_lock);
2685 } else {
2686 /* More retries, send again. */
2687
2688 /* Start with the max timer, set to normal
2689 timer after the message is sent. */
2690 ent->timeout = MAX_MSG_TIMEOUT;
2691 ent->retries_left--;
2692 send_from_recv_msg(intf, ent->recv_msg, NULL,
2693 j, ent->seqid);
2694 spin_lock(&intf->counter_lock);
2695 if (ent->recv_msg->addr.addr_type
2696 == IPMI_LAN_ADDR_TYPE)
2697 intf->retransmitted_lan_commands++;
2698 else
2699 intf->retransmitted_ipmb_commands++;
2700 spin_unlock(&intf->counter_lock);
2701 }
2702 }
2703 spin_unlock_irqrestore(&(intf->seq_lock), flags);
2704
2705 list_for_each_entry_safe(msg, msg2, &timeouts, link) {
2706 handle_msg_timeout(msg);
2707 }
2708
2709 read_unlock(&(intf->users_lock));
2710 }
2711 spin_unlock(&interfaces_lock);
2712 }
2713
2714 static void ipmi_request_event(void)
2715 {
2716 ipmi_smi_t intf;
2717 int i;
2718
2719 spin_lock(&interfaces_lock);
2720 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
2721 intf = ipmi_interfaces[i];
2722 if (intf == NULL)
2723 continue;
2724
2725 intf->handlers->request_events(intf->send_info);
2726 }
2727 spin_unlock(&interfaces_lock);
2728 }
2729
2730 static struct timer_list ipmi_timer;
2731
2732 /* Call every ~100 ms. */
2733 #define IPMI_TIMEOUT_TIME 100
2734
2735 /* How many jiffies does it take to get to the timeout time. */
2736 #define IPMI_TIMEOUT_JIFFIES ((IPMI_TIMEOUT_TIME * HZ) / 1000)
2737
2738 /* Request events from the queue every second (this is the number of
2739 IPMI_TIMEOUT_TIMES between event requests). Hopefully, in the
2740 future, IPMI will add a way to know immediately if an event is in
2741 the queue and this silliness can go away. */
2742 #define IPMI_REQUEST_EV_TIME (1000 / (IPMI_TIMEOUT_TIME))
2743
2744 static volatile int stop_operation = 0;
2745 static volatile int timer_stopped = 0;
2746 static unsigned int ticks_to_req_ev = IPMI_REQUEST_EV_TIME;
2747
2748 static void ipmi_timeout(unsigned long data)
2749 {
2750 if (stop_operation) {
2751 timer_stopped = 1;
2752 return;
2753 }
2754
2755 ticks_to_req_ev--;
2756 if (ticks_to_req_ev == 0) {
2757 ipmi_request_event();
2758 ticks_to_req_ev = IPMI_REQUEST_EV_TIME;
2759 }
2760
2761 ipmi_timeout_handler(IPMI_TIMEOUT_TIME);
2762
2763 ipmi_timer.expires += IPMI_TIMEOUT_JIFFIES;
2764 add_timer(&ipmi_timer);
2765 }
2766
2767
2768 static atomic_t smi_msg_inuse_count = ATOMIC_INIT(0);
2769 static atomic_t recv_msg_inuse_count = ATOMIC_INIT(0);
2770
2771 /* FIXME - convert these to slabs. */
2772 static void free_smi_msg(struct ipmi_smi_msg *msg)
2773 {
2774 atomic_dec(&smi_msg_inuse_count);
2775 kfree(msg);
2776 }
2777
2778 struct ipmi_smi_msg *ipmi_alloc_smi_msg(void)
2779 {
2780 struct ipmi_smi_msg *rv;
2781 rv = kmalloc(sizeof(struct ipmi_smi_msg), GFP_ATOMIC);
2782 if (rv) {
2783 rv->done = free_smi_msg;
2784 rv->user_data = NULL;
2785 atomic_inc(&smi_msg_inuse_count);
2786 }
2787 return rv;
2788 }
2789
2790 static void free_recv_msg(struct ipmi_recv_msg *msg)
2791 {
2792 atomic_dec(&recv_msg_inuse_count);
2793 kfree(msg);
2794 }
2795
2796 struct ipmi_recv_msg *ipmi_alloc_recv_msg(void)
2797 {
2798 struct ipmi_recv_msg *rv;
2799
2800 rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC);
2801 if (rv) {
2802 rv->done = free_recv_msg;
2803 atomic_inc(&recv_msg_inuse_count);
2804 }
2805 return rv;
2806 }
2807
2808 #ifdef CONFIG_IPMI_PANIC_EVENT
2809
2810 static void dummy_smi_done_handler(struct ipmi_smi_msg *msg)
2811 {
2812 }
2813
2814 static void dummy_recv_done_handler(struct ipmi_recv_msg *msg)
2815 {
2816 }
2817
2818 #ifdef CONFIG_IPMI_PANIC_STRING
2819 static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
2820 {
2821 if ((msg->rsp[0] == (IPMI_NETFN_SENSOR_EVENT_RESPONSE << 2))
2822 && (msg->rsp[1] == IPMI_GET_EVENT_RECEIVER_CMD)
2823 && (msg->rsp[2] == IPMI_CC_NO_ERROR))
2824 {
2825 /* A get event receiver command, save it. */
2826 intf->event_receiver = msg->rsp[3];
2827 intf->event_receiver_lun = msg->rsp[4] & 0x3;
2828 }
2829 }
2830
2831 static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
2832 {
2833 if ((msg->rsp[0] == (IPMI_NETFN_APP_RESPONSE << 2))
2834 && (msg->rsp[1] == IPMI_GET_DEVICE_ID_CMD)
2835 && (msg->rsp[2] == IPMI_CC_NO_ERROR))
2836 {
2837 /* A get device id command, save if we are an event
2838 receiver or generator. */
2839 intf->local_sel_device = (msg->rsp[8] >> 2) & 1;
2840 intf->local_event_generator = (msg->rsp[8] >> 5) & 1;
2841 }
2842 }
2843 #endif
2844
2845 static void send_panic_events(char *str)
2846 {
2847 struct kernel_ipmi_msg msg;
2848 ipmi_smi_t intf;
2849 unsigned char data[16];
2850 int i;
2851 struct ipmi_system_interface_addr *si;
2852 struct ipmi_addr addr;
2853 struct ipmi_smi_msg smi_msg;
2854 struct ipmi_recv_msg recv_msg;
2855
2856 si = (struct ipmi_system_interface_addr *) &addr;
2857 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2858 si->channel = IPMI_BMC_CHANNEL;
2859 si->lun = 0;
2860
2861 /* Fill in an event telling that we have failed. */
2862 msg.netfn = 0x04; /* Sensor or Event. */
2863 msg.cmd = 2; /* Platform event command. */
2864 msg.data = data;
2865 msg.data_len = 8;
2866 data[0] = 0x21; /* Kernel generator ID, IPMI table 5-4 */
2867 data[1] = 0x03; /* This is for IPMI 1.0. */
2868 data[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */
2869 data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */
2870 data[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */
2871
2872 /* Put a few breadcrumbs in. Hopefully later we can add more things
2873 to make the panic events more useful. */
2874 if (str) {
2875 data[3] = str[0];
2876 data[6] = str[1];
2877 data[7] = str[2];
2878 }
2879
2880 smi_msg.done = dummy_smi_done_handler;
2881 recv_msg.done = dummy_recv_done_handler;
2882
2883 /* For every registered interface, send the event. */
2884 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
2885 intf = ipmi_interfaces[i];
2886 if (intf == NULL)
2887 continue;
2888
2889 /* Send the event announcing the panic. */
2890 intf->handlers->set_run_to_completion(intf->send_info, 1);
2891 i_ipmi_request(NULL,
2892 intf,
2893 &addr,
2894 0,
2895 &msg,
2896 NULL,
2897 &smi_msg,
2898 &recv_msg,
2899 0,
2900 intf->my_address,
2901 intf->my_lun,
2902 0, 1); /* Don't retry, and don't wait. */
2903 }
2904
2905 #ifdef CONFIG_IPMI_PANIC_STRING
2906 /* On every interface, dump a bunch of OEM event holding the
2907 string. */
2908 if (!str)
2909 return;
2910
2911 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
2912 char *p = str;
2913 struct ipmi_ipmb_addr *ipmb;
2914 int j;
2915
2916 intf = ipmi_interfaces[i];
2917 if (intf == NULL)
2918 continue;
2919
2920 /* First job here is to figure out where to send the
2921 OEM events. There's no way in IPMI to send OEM
2922 events using an event send command, so we have to
2923 find the SEL to put them in and stick them in
2924 there. */
2925
2926 /* Get capabilities from the get device id. */
2927 intf->local_sel_device = 0;
2928 intf->local_event_generator = 0;
2929 intf->event_receiver = 0;
2930
2931 /* Request the device info from the local MC. */
2932 msg.netfn = IPMI_NETFN_APP_REQUEST;
2933 msg.cmd = IPMI_GET_DEVICE_ID_CMD;
2934 msg.data = NULL;
2935 msg.data_len = 0;
2936 intf->null_user_handler = device_id_fetcher;
2937 i_ipmi_request(NULL,
2938 intf,
2939 &addr,
2940 0,
2941 &msg,
2942 NULL,
2943 &smi_msg,
2944 &recv_msg,
2945 0,
2946 intf->my_address,
2947 intf->my_lun,
2948 0, 1); /* Don't retry, and don't wait. */
2949
2950 if (intf->local_event_generator) {
2951 /* Request the event receiver from the local MC. */
2952 msg.netfn = IPMI_NETFN_SENSOR_EVENT_REQUEST;
2953 msg.cmd = IPMI_GET_EVENT_RECEIVER_CMD;
2954 msg.data = NULL;
2955 msg.data_len = 0;
2956 intf->null_user_handler = event_receiver_fetcher;
2957 i_ipmi_request(NULL,
2958 intf,
2959 &addr,
2960 0,
2961 &msg,
2962 NULL,
2963 &smi_msg,
2964 &recv_msg,
2965 0,
2966 intf->my_address,
2967 intf->my_lun,
2968 0, 1); /* no retry, and no wait. */
2969 }
2970 intf->null_user_handler = NULL;
2971
2972 /* Validate the event receiver. The low bit must not
2973 be 1 (it must be a valid IPMB address), it cannot
2974 be zero, and it must not be my address. */
2975 if (((intf->event_receiver & 1) == 0)
2976 && (intf->event_receiver != 0)
2977 && (intf->event_receiver != intf->my_address))
2978 {
2979 /* The event receiver is valid, send an IPMB
2980 message. */
2981 ipmb = (struct ipmi_ipmb_addr *) &addr;
2982 ipmb->addr_type = IPMI_IPMB_ADDR_TYPE;
2983 ipmb->channel = 0; /* FIXME - is this right? */
2984 ipmb->lun = intf->event_receiver_lun;
2985 ipmb->slave_addr = intf->event_receiver;
2986 } else if (intf->local_sel_device) {
2987 /* The event receiver was not valid (or was
2988 me), but I am an SEL device, just dump it
2989 in my SEL. */
2990 si = (struct ipmi_system_interface_addr *) &addr;
2991 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2992 si->channel = IPMI_BMC_CHANNEL;
2993 si->lun = 0;
2994 } else
2995 continue; /* No where to send the event. */
2996
2997
2998 msg.netfn = IPMI_NETFN_STORAGE_REQUEST; /* Storage. */
2999 msg.cmd = IPMI_ADD_SEL_ENTRY_CMD;
3000 msg.data = data;
3001 msg.data_len = 16;
3002
3003 j = 0;
3004 while (*p) {
3005 int size = strlen(p);
3006
3007 if (size > 11)
3008 size = 11;
3009 data[0] = 0;
3010 data[1] = 0;
3011 data[2] = 0xf0; /* OEM event without timestamp. */
3012 data[3] = intf->my_address;
3013 data[4] = j++; /* sequence # */
3014 /* Always give 11 bytes, so strncpy will fill
3015 it with zeroes for me. */
3016 strncpy(data+5, p, 11);
3017 p += size;
3018
3019 i_ipmi_request(NULL,
3020 intf,
3021 &addr,
3022 0,
3023 &msg,
3024 NULL,
3025 &smi_msg,
3026 &recv_msg,
3027 0,
3028 intf->my_address,
3029 intf->my_lun,
3030 0, 1); /* no retry, and no wait. */
3031 }
3032 }
3033 #endif /* CONFIG_IPMI_PANIC_STRING */
3034 }
3035 #endif /* CONFIG_IPMI_PANIC_EVENT */
3036
3037 static int has_paniced = 0;
3038
3039 static int panic_event(struct notifier_block *this,
3040 unsigned long event,
3041 void *ptr)
3042 {
3043 int i;
3044 ipmi_smi_t intf;
3045
3046 if (has_paniced)
3047 return NOTIFY_DONE;
3048 has_paniced = 1;
3049
3050 /* For every registered interface, set it to run to completion. */
3051 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
3052 intf = ipmi_interfaces[i];
3053 if (intf == NULL)
3054 continue;
3055
3056 intf->handlers->set_run_to_completion(intf->send_info, 1);
3057 }
3058
3059 #ifdef CONFIG_IPMI_PANIC_EVENT
3060 send_panic_events(ptr);
3061 #endif
3062
3063 return NOTIFY_DONE;
3064 }
3065
3066 static struct notifier_block panic_block = {
3067 .notifier_call = panic_event,
3068 .next = NULL,
3069 .priority = 200 /* priority: INT_MAX >= x >= 0 */
3070 };
3071
3072 static int ipmi_init_msghandler(void)
3073 {
3074 int i;
3075
3076 if (initialized)
3077 return 0;
3078
3079 printk(KERN_INFO "ipmi message handler version "
3080 IPMI_MSGHANDLER_VERSION "\n");
3081
3082 for (i=0; i<MAX_IPMI_INTERFACES; i++) {
3083 ipmi_interfaces[i] = NULL;
3084 }
3085
3086 proc_ipmi_root = proc_mkdir("ipmi", NULL);
3087 if (!proc_ipmi_root) {
3088 printk(KERN_ERR PFX "Unable to create IPMI proc dir");
3089 return -ENOMEM;
3090 }
3091
3092 proc_ipmi_root->owner = THIS_MODULE;
3093
3094 init_timer(&ipmi_timer);
3095 ipmi_timer.data = 0;
3096 ipmi_timer.function = ipmi_timeout;
3097 ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
3098 add_timer(&ipmi_timer);
3099
3100 notifier_chain_register(&panic_notifier_list, &panic_block);
3101
3102 initialized = 1;
3103
3104 return 0;
3105 }
3106
3107 static __init int ipmi_init_msghandler_mod(void)
3108 {
3109 ipmi_init_msghandler();
3110 return 0;
3111 }
3112
3113 static __exit void cleanup_ipmi(void)
3114 {
3115 int count;
3116
3117 if (!initialized)
3118 return;
3119
3120 notifier_chain_unregister(&panic_notifier_list, &panic_block);
3121
3122 /* This can't be called if any interfaces exist, so no worry about
3123 shutting down the interfaces. */
3124
3125 /* Tell the timer to stop, then wait for it to stop. This avoids
3126 problems with race conditions removing the timer here. */
3127 stop_operation = 1;
3128 while (!timer_stopped) {
3129 set_current_state(TASK_UNINTERRUPTIBLE);
3130 schedule_timeout(1);
3131 }
3132
3133 remove_proc_entry(proc_ipmi_root->name, &proc_root);
3134
3135 initialized = 0;
3136
3137 /* Check for buffer leaks. */
3138 count = atomic_read(&smi_msg_inuse_count);
3139 if (count != 0)
3140 printk(KERN_WARNING PFX "SMI message count %d at exit\n",
3141 count);
3142 count = atomic_read(&recv_msg_inuse_count);
3143 if (count != 0)
3144 printk(KERN_WARNING PFX "recv message count %d at exit\n",
3145 count);
3146 }
3147 module_exit(cleanup_ipmi);
3148
3149 module_init(ipmi_init_msghandler_mod);
3150 MODULE_LICENSE("GPL");
3151
3152 EXPORT_SYMBOL(ipmi_create_user);
3153 EXPORT_SYMBOL(ipmi_destroy_user);
3154 EXPORT_SYMBOL(ipmi_get_version);
3155 EXPORT_SYMBOL(ipmi_request_settime);
3156 EXPORT_SYMBOL(ipmi_request_supply_msgs);
3157 EXPORT_SYMBOL(ipmi_register_smi);
3158 EXPORT_SYMBOL(ipmi_unregister_smi);
3159 EXPORT_SYMBOL(ipmi_register_for_cmd);
3160 EXPORT_SYMBOL(ipmi_unregister_for_cmd);
3161 EXPORT_SYMBOL(ipmi_smi_msg_received);
3162 EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout);
3163 EXPORT_SYMBOL(ipmi_alloc_smi_msg);
3164 EXPORT_SYMBOL(ipmi_addr_length);
3165 EXPORT_SYMBOL(ipmi_validate_addr);
3166 EXPORT_SYMBOL(ipmi_set_gets_events);
3167 EXPORT_SYMBOL(ipmi_smi_watcher_register);
3168 EXPORT_SYMBOL(ipmi_smi_watcher_unregister);
3169 EXPORT_SYMBOL(ipmi_set_my_address);
3170 EXPORT_SYMBOL(ipmi_get_my_address);
3171 EXPORT_SYMBOL(ipmi_set_my_LUN);
3172 EXPORT_SYMBOL(ipmi_get_my_LUN);
3173 EXPORT_SYMBOL(ipmi_smi_add_proc_entry);
3174 EXPORT_SYMBOL(ipmi_user_set_run_to_completion);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree