projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] IPMI: Fix device model name
[deliverable/linux.git] / drivers / char / ipmi / ipmi_msghandler.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 34#include <linux/module.h>
35#include <linux/errno.h>
36#include <asm/system.h>
37#include <linux/sched.h>
38#include <linux/poll.h>
39#include <linux/spinlock.h>
d6dfd131 40#include <linux/mutex.h>
1da177e4
LT		 41#include <linux/slab.h>
42#include <linux/ipmi.h>
43#include <linux/ipmi_smi.h>
44#include <linux/notifier.h>
45#include <linux/init.h>
46#include <linux/proc_fs.h>
393d2cc3 47#include <linux/rcupdate.h>
1da177e4
LT		 48
49#define PFX "IPMI message handler: "
1fdd75bd 50
a23f9a3c 51#define IPMI_DRIVER_VERSION "39.0"
1da177e4
LT		 52
53static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
54static int ipmi_init_msghandler(void);
55
56static int initialized = 0;
57
3b625943 58#ifdef CONFIG_PROC_FS
456229a9 59static struct proc_dir_entry *proc_ipmi_root = NULL;
3b625943 60#endif /* CONFIG_PROC_FS */
1da177e4
LT		 61
62#define MAX_EVENTS_IN_QUEUE 25
63
64/* Don't let a message sit in a queue forever, always time it with at lest
65 the max message timer. This is in milliseconds. */
66#define MAX_MSG_TIMEOUT 60000
67
393d2cc3
CM		 68
69/*
70 * The main "user" data structure.
71 */
1da177e4
LT		 72struct ipmi_user
73{
74 struct list_head link;
75
393d2cc3
CM		 76 /* Set to "0" when the user is destroyed. */
77 int valid;
78
79 struct kref refcount;
80
1da177e4
LT		 81 /* The upper layer that handles receive messages. */
82 struct ipmi_user_hndl *handler;
83 void *handler_data;
84
85 /* The interface this user is bound to. */
86 ipmi_smi_t intf;
87
88 /* Does this interface receive IPMI events? */
89 int gets_events;
90};
91
92struct cmd_rcvr
93{
94 struct list_head link;
95
96 ipmi_user_t user;
97 unsigned char netfn;
98 unsigned char cmd;
c69c3127 99 unsigned int chans;
393d2cc3
CM		 100
101 /*
102 * This is used to form a linked lised during mass deletion.
103 * Since this is in an RCU list, we cannot use the link above
104 * or change any data until the RCU period completes. So we
105 * use this next variable during mass deletion so we can have
106 * a list and don't have to wait and restart the search on
107 * every individual deletion of a command. */
108 struct cmd_rcvr *next;
1da177e4
LT		 109};
110
111struct seq_table
112{
113 unsigned int inuse : 1;
114 unsigned int broadcast : 1;
115
116 unsigned long timeout;
117 unsigned long orig_timeout;
118 unsigned int retries_left;
119
120 /* To verify on an incoming send message response that this is
121 the message that the response is for, we keep a sequence id
122 and increment it every time we send a message. */
123 long seqid;
124
125 /* This is held so we can properly respond to the message on a
126 timeout, and it is used to hold the temporary data for
127 retransmission, too. */
128 struct ipmi_recv_msg *recv_msg;
129};
130
131/* Store the information in a msgid (long) to allow us to find a
132 sequence table entry from the msgid. */
133#define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff))
134
135#define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \
136 do { \
137 seq = ((msgid >> 26) & 0x3f); \
138 seqid = (msgid & 0x3fffff); \
e8b33617 139 } while (0)
1da177e4
LT		 140
141#define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff)
142
143struct ipmi_channel
144{
145 unsigned char medium;
146 unsigned char protocol;
c14979b9
CM		 147
148 /* My slave address. This is initialized to IPMI_BMC_SLAVE_ADDR,
149 but may be changed by the user. */
150 unsigned char address;
151
152 /* My LUN. This should generally stay the SMS LUN, but just in
153 case... */
154 unsigned char lun;
1da177e4
LT		 155};
156
3b625943 157#ifdef CONFIG_PROC_FS
1da177e4
LT		 158struct ipmi_proc_entry
159{
160 char *name;
161 struct ipmi_proc_entry *next;
162};
3b625943 163#endif
1da177e4 164
50c812b2
CM		 165struct bmc_device
166{
167 struct platform_device *dev;
168 struct ipmi_device_id id;
169 unsigned char guid[16];
170 int guid_set;
171
172 struct kref refcount;
173
174 /* bmc device attributes */
175 struct device_attribute device_id_attr;
176 struct device_attribute provides_dev_sdrs_attr;
177 struct device_attribute revision_attr;
178 struct device_attribute firmware_rev_attr;
179 struct device_attribute version_attr;
180 struct device_attribute add_dev_support_attr;
181 struct device_attribute manufacturer_id_attr;
182 struct device_attribute product_id_attr;
183 struct device_attribute guid_attr;
184 struct device_attribute aux_firmware_rev_attr;
185};
186
1da177e4 187#define IPMI_IPMB_NUM_SEQ 64
c14979b9 188#define IPMI_MAX_CHANNELS 16
1da177e4
LT		 189struct ipmi_smi
190{
191 /* What interface number are we? */
192 int intf_num;
193
393d2cc3
CM		 194 struct kref refcount;
195
196 /* The list of upper layers that are using me. seq_lock
197 * protects this. */
198 struct list_head users;
1da177e4
LT		 199
200 /* Used for wake ups at startup. */
201 wait_queue_head_t waitq;
202
50c812b2
CM		 203 struct bmc_device *bmc;
204 char *my_dev_name;
1da177e4
LT		 205
206 /* This is the lower-layer's sender routine. */
207 struct ipmi_smi_handlers *handlers;
208 void *send_info;
209
3b625943 210#ifdef CONFIG_PROC_FS
1da177e4
LT		 211 /* A list of proc entries for this interface. This does not
212 need a lock, only one thread creates it and only one thread
213 destroys it. */
3b625943 214 spinlock_t proc_entry_lock;
1da177e4 215 struct ipmi_proc_entry *proc_entries;
3b625943 216#endif
1da177e4 217
50c812b2
CM		 218 /* Driver-model device for the system interface. */
219 struct device *si_dev;
220
1da177e4
LT		 221 /* A table of sequence numbers for this interface. We use the
222 sequence numbers for IPMB messages that go out of the
223 interface to match them up with their responses. A routine
224 is called periodically to time the items in this list. */
225 spinlock_t seq_lock;
226 struct seq_table seq_table[IPMI_IPMB_NUM_SEQ];
227 int curr_seq;
228
229 /* Messages that were delayed for some reason (out of memory,
230 for instance), will go in here to be processed later in a
231 periodic timer interrupt. */
232 spinlock_t waiting_msgs_lock;
233 struct list_head waiting_msgs;
234
235 /* The list of command receivers that are registered for commands
236 on this interface. */
d6dfd131 237 struct mutex cmd_rcvrs_mutex;
1da177e4
LT		 238 struct list_head cmd_rcvrs;
239
240 /* Events that were queues because no one was there to receive
241 them. */
242 spinlock_t events_lock; /* For dealing with event stuff. */
243 struct list_head waiting_events;
244 unsigned int waiting_events_count; /* How many events in queue? */
245
1da177e4
LT		 246 /* The event receiver for my BMC, only really used at panic
247 shutdown as a place to store this. */
248 unsigned char event_receiver;
249 unsigned char event_receiver_lun;
250 unsigned char local_sel_device;
251 unsigned char local_event_generator;
252
253 /* A cheap hack, if this is non-null and a message to an
254 interface comes in with a NULL user, call this routine with
255 it. Note that the message will still be freed by the
256 caller. This only works on the system interface. */
56a55ec6 257 void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg);
1da177e4
LT		 258
259 /* When we are scanning the channels for an SMI, this will
260 tell which channel we are scanning. */
261 int curr_channel;
262
263 /* Channel information */
264 struct ipmi_channel channels[IPMI_MAX_CHANNELS];
265
266 /* Proc FS stuff. */
267 struct proc_dir_entry *proc_dir;
268 char proc_dir_name[10];
269
270 spinlock_t counter_lock; /* For making counters atomic. */
271
272 /* Commands we got that were invalid. */
273 unsigned int sent_invalid_commands;
274
275 /* Commands we sent to the MC. */
276 unsigned int sent_local_commands;
277 /* Responses from the MC that were delivered to a user. */
278 unsigned int handled_local_responses;
279 /* Responses from the MC that were not delivered to a user. */
280 unsigned int unhandled_local_responses;
281
282 /* Commands we sent out to the IPMB bus. */
283 unsigned int sent_ipmb_commands;
284 /* Commands sent on the IPMB that had errors on the SEND CMD */
285 unsigned int sent_ipmb_command_errs;
286 /* Each retransmit increments this count. */
287 unsigned int retransmitted_ipmb_commands;
288 /* When a message times out (runs out of retransmits) this is
289 incremented. */
290 unsigned int timed_out_ipmb_commands;
291
292 /* This is like above, but for broadcasts. Broadcasts are
293 *not* included in the above count (they are expected to
294 time out). */
295 unsigned int timed_out_ipmb_broadcasts;
296
297 /* Responses I have sent to the IPMB bus. */
298 unsigned int sent_ipmb_responses;
299
300 /* The response was delivered to the user. */
301 unsigned int handled_ipmb_responses;
302 /* The response had invalid data in it. */
303 unsigned int invalid_ipmb_responses;
304 /* The response didn't have anyone waiting for it. */
305 unsigned int unhandled_ipmb_responses;
306
307 /* Commands we sent out to the IPMB bus. */
308 unsigned int sent_lan_commands;
309 /* Commands sent on the IPMB that had errors on the SEND CMD */
310 unsigned int sent_lan_command_errs;
311 /* Each retransmit increments this count. */
312 unsigned int retransmitted_lan_commands;
313 /* When a message times out (runs out of retransmits) this is
314 incremented. */
315 unsigned int timed_out_lan_commands;
316
317 /* Responses I have sent to the IPMB bus. */
318 unsigned int sent_lan_responses;
319
320 /* The response was delivered to the user. */
321 unsigned int handled_lan_responses;
322 /* The response had invalid data in it. */
323 unsigned int invalid_lan_responses;
324 /* The response didn't have anyone waiting for it. */
325 unsigned int unhandled_lan_responses;
326
327 /* The command was delivered to the user. */
328 unsigned int handled_commands;
329 /* The command had invalid data in it. */
330 unsigned int invalid_commands;
331 /* The command didn't have anyone waiting for it. */
332 unsigned int unhandled_commands;
333
334 /* Invalid data in an event. */
335 unsigned int invalid_events;
336 /* Events that were received with the proper format. */
337 unsigned int events;
338};
50c812b2 339#define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
1da177e4 340
393d2cc3
CM		 341/* Used to mark an interface entry that cannot be used but is not a
342 * free entry, either, primarily used at creation and deletion time so
343 * a slot doesn't get reused too quickly. */
344#define IPMI_INVALID_INTERFACE_ENTRY ((ipmi_smi_t) ((long) 1))
345#define IPMI_INVALID_INTERFACE(i) (((i) == NULL) \
346 || (i == IPMI_INVALID_INTERFACE_ENTRY))
347
50c812b2
CM		 348/**
349 * The driver model view of the IPMI messaging driver.
350 */
351static struct device_driver ipmidriver = {
352 .name = "ipmi",
353 .bus = &platform_bus_type
354};
355static DEFINE_MUTEX(ipmidriver_mutex);
356
1da177e4
LT		 357#define MAX_IPMI_INTERFACES 4
358static ipmi_smi_t ipmi_interfaces[MAX_IPMI_INTERFACES];
359
393d2cc3 360/* Directly protects the ipmi_interfaces data structure. */
1da177e4
LT		 361static DEFINE_SPINLOCK(interfaces_lock);
362
363/* List of watchers that want to know when smi's are added and
364 deleted. */
365static struct list_head smi_watchers = LIST_HEAD_INIT(smi_watchers);
366static DECLARE_RWSEM(smi_watchers_sem);
367
393d2cc3
CM		 368
369static void free_recv_msg_list(struct list_head *q)
370{
371 struct ipmi_recv_msg *msg, *msg2;
372
373 list_for_each_entry_safe(msg, msg2, q, link) {
374 list_del(&msg->link);
375 ipmi_free_recv_msg(msg);
376 }
377}
378
f3ce6a0e
CM		 379static void free_smi_msg_list(struct list_head *q)
380{
381 struct ipmi_smi_msg *msg, *msg2;
382
383 list_for_each_entry_safe(msg, msg2, q, link) {
384 list_del(&msg->link);
385 ipmi_free_smi_msg(msg);
386 }
387}
388
393d2cc3
CM		 389static void clean_up_interface_data(ipmi_smi_t intf)
390{
391 int i;
392 struct cmd_rcvr *rcvr, *rcvr2;
393d2cc3
CM		 393 struct list_head list;
394
f3ce6a0e 395 free_smi_msg_list(&intf->waiting_msgs);
393d2cc3
CM		 396 free_recv_msg_list(&intf->waiting_events);
397
398 /* Wholesale remove all the entries from the list in the
399 * interface and wait for RCU to know that none are in use. */
d6dfd131 400 mutex_lock(&intf->cmd_rcvrs_mutex);
393d2cc3
CM		 401 list_add_rcu(&list, &intf->cmd_rcvrs);
402 list_del_rcu(&intf->cmd_rcvrs);
d6dfd131 403 mutex_unlock(&intf->cmd_rcvrs_mutex);
393d2cc3
CM		 404 synchronize_rcu();
405
406 list_for_each_entry_safe(rcvr, rcvr2, &list, link)
407 kfree(rcvr);
408
409 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
410 if ((intf->seq_table[i].inuse)
411 && (intf->seq_table[i].recv_msg))
412 {
413 ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
414 }
415 }
416}
417
418static void intf_free(struct kref *ref)
419{
420 ipmi_smi_t intf = container_of(ref, struct ipmi_smi, refcount);
421
422 clean_up_interface_data(intf);
423 kfree(intf);
424}
425
1da177e4
LT		 426int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
427{
393d2cc3
CM		 428 int i;
429 unsigned long flags;
1da177e4 430
1da177e4
LT		 431 down_write(&smi_watchers_sem);
432 list_add(&(watcher->link), &smi_watchers);
393d2cc3
CM		 433 up_write(&smi_watchers_sem);
434 spin_lock_irqsave(&interfaces_lock, flags);
e8b33617 435 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
393d2cc3
CM		 436 ipmi_smi_t intf = ipmi_interfaces[i];
437 if (IPMI_INVALID_INTERFACE(intf))
438 continue;
439 spin_unlock_irqrestore(&interfaces_lock, flags);
50c812b2 440 watcher->new_smi(i, intf->si_dev);
393d2cc3 441 spin_lock_irqsave(&interfaces_lock, flags);
1da177e4 442 }
393d2cc3 443 spin_unlock_irqrestore(&interfaces_lock, flags);
1da177e4
LT		 444 return 0;
445}
446
447int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher)
448{
449 down_write(&smi_watchers_sem);
450 list_del(&(watcher->link));
451 up_write(&smi_watchers_sem);
452 return 0;
453}
454
455static void
50c812b2 456call_smi_watchers(int i, struct device *dev)
1da177e4
LT		 457{
458 struct ipmi_smi_watcher *w;
459
460 down_read(&smi_watchers_sem);
461 list_for_each_entry(w, &smi_watchers, link) {
462 if (try_module_get(w->owner)) {
50c812b2 463 w->new_smi(i, dev);
1da177e4
LT		 464 module_put(w->owner);
465 }
466 }
467 up_read(&smi_watchers_sem);
468}
469
470static int
471ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
472{
473 if (addr1->addr_type != addr2->addr_type)
474 return 0;
475
476 if (addr1->channel != addr2->channel)
477 return 0;
478
479 if (addr1->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
480 struct ipmi_system_interface_addr *smi_addr1
481 = (struct ipmi_system_interface_addr *) addr1;
482 struct ipmi_system_interface_addr *smi_addr2
483 = (struct ipmi_system_interface_addr *) addr2;
484 return (smi_addr1->lun == smi_addr2->lun);
485 }
486
487 if ((addr1->addr_type == IPMI_IPMB_ADDR_TYPE)
488 || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
489 {
490 struct ipmi_ipmb_addr *ipmb_addr1
491 = (struct ipmi_ipmb_addr *) addr1;
492 struct ipmi_ipmb_addr *ipmb_addr2
493 = (struct ipmi_ipmb_addr *) addr2;
494
495 return ((ipmb_addr1->slave_addr == ipmb_addr2->slave_addr)
496 && (ipmb_addr1->lun == ipmb_addr2->lun));
497 }
498
499 if (addr1->addr_type == IPMI_LAN_ADDR_TYPE) {
500 struct ipmi_lan_addr *lan_addr1
501 = (struct ipmi_lan_addr *) addr1;
502 struct ipmi_lan_addr *lan_addr2
503 = (struct ipmi_lan_addr *) addr2;
504
505 return ((lan_addr1->remote_SWID == lan_addr2->remote_SWID)
506 && (lan_addr1->local_SWID == lan_addr2->local_SWID)
507 && (lan_addr1->session_handle
508 == lan_addr2->session_handle)
509 && (lan_addr1->lun == lan_addr2->lun));
510 }
511
512 return 1;
513}
514
515int ipmi_validate_addr(struct ipmi_addr *addr, int len)
516{
517 if (len < sizeof(struct ipmi_system_interface_addr)) {
518 return -EINVAL;
519 }
520
521 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
522 if (addr->channel != IPMI_BMC_CHANNEL)
523 return -EINVAL;
524 return 0;
525 }
526
527 if ((addr->channel == IPMI_BMC_CHANNEL)
12fc1d7b 528 || (addr->channel >= IPMI_MAX_CHANNELS)
1da177e4
LT		 529 || (addr->channel < 0))
530 return -EINVAL;
531
532 if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
533 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
534 {
535 if (len < sizeof(struct ipmi_ipmb_addr)) {
536 return -EINVAL;
537 }
538 return 0;
539 }
540
541 if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
542 if (len < sizeof(struct ipmi_lan_addr)) {
543 return -EINVAL;
544 }
545 return 0;
546 }
547
548 return -EINVAL;
549}
550
551unsigned int ipmi_addr_length(int addr_type)
552{
553 if (addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
554 return sizeof(struct ipmi_system_interface_addr);
555
556 if ((addr_type == IPMI_IPMB_ADDR_TYPE)
557 || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
558 {
559 return sizeof(struct ipmi_ipmb_addr);
560 }
561
562 if (addr_type == IPMI_LAN_ADDR_TYPE)
563 return sizeof(struct ipmi_lan_addr);
564
565 return 0;
566}
567
568static void deliver_response(struct ipmi_recv_msg *msg)
569{
8a3628d5 570 if (!msg->user) {
56a55ec6
CM		 571 ipmi_smi_t intf = msg->user_msg_data;
572 unsigned long flags;
573
574 /* Special handling for NULL users. */
575 if (intf->null_user_handler) {
576 intf->null_user_handler(intf, msg);
577 spin_lock_irqsave(&intf->counter_lock, flags);
578 intf->handled_local_responses++;
579 spin_unlock_irqrestore(&intf->counter_lock, flags);
580 } else {
581 /* No handler, so give up. */
582 spin_lock_irqsave(&intf->counter_lock, flags);
583 intf->unhandled_local_responses++;
584 spin_unlock_irqrestore(&intf->counter_lock, flags);
585 }
586 ipmi_free_recv_msg(msg);
587 } else {
393d2cc3
CM		 588 ipmi_user_t user = msg->user;
589 user->handler->ipmi_recv_hndl(msg, user->handler_data);
56a55ec6 590 }
1da177e4
LT		 591}
592
593/* Find the next sequence number not being used and add the given
594 message with the given timeout to the sequence table. This must be
595 called with the interface's seq_lock held. */
596static int intf_next_seq(ipmi_smi_t intf,
597 struct ipmi_recv_msg *recv_msg,
598 unsigned long timeout,
599 int retries,
600 int broadcast,
601 unsigned char *seq,
602 long *seqid)
603{
604 int rv = 0;
605 unsigned int i;
606
e8b33617 607 for (i = intf->curr_seq;
1da177e4 608 (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq;
e8b33617 609 i = (i+1)%IPMI_IPMB_NUM_SEQ)
1da177e4 610 {
8a3628d5 611 if (!intf->seq_table[i].inuse)
1da177e4
LT		 612 break;
613 }
614
8a3628d5 615 if (!intf->seq_table[i].inuse) {
1da177e4
LT		 616 intf->seq_table[i].recv_msg = recv_msg;
617
618 /* Start with the maximum timeout, when the send response
619 comes in we will start the real timer. */
620 intf->seq_table[i].timeout = MAX_MSG_TIMEOUT;
621 intf->seq_table[i].orig_timeout = timeout;
622 intf->seq_table[i].retries_left = retries;
623 intf->seq_table[i].broadcast = broadcast;
624 intf->seq_table[i].inuse = 1;
625 intf->seq_table[i].seqid = NEXT_SEQID(intf->seq_table[i].seqid);
626 *seq = i;
627 *seqid = intf->seq_table[i].seqid;
628 intf->curr_seq = (i+1)%IPMI_IPMB_NUM_SEQ;
629 } else {
630 rv = -EAGAIN;
631 }
632
633 return rv;
634}
635
636/* Return the receive message for the given sequence number and
637 release the sequence number so it can be reused. Some other data
638 is passed in to be sure the message matches up correctly (to help
639 guard against message coming in after their timeout and the
640 sequence number being reused). */
641static int intf_find_seq(ipmi_smi_t intf,
642 unsigned char seq,
643 short channel,
644 unsigned char cmd,
645 unsigned char netfn,
646 struct ipmi_addr *addr,
647 struct ipmi_recv_msg **recv_msg)
648{
649 int rv = -ENODEV;
650 unsigned long flags;
651
652 if (seq >= IPMI_IPMB_NUM_SEQ)
653 return -EINVAL;
654
655 spin_lock_irqsave(&(intf->seq_lock), flags);
656 if (intf->seq_table[seq].inuse) {
657 struct ipmi_recv_msg *msg = intf->seq_table[seq].recv_msg;
658
659 if ((msg->addr.channel == channel)
660 && (msg->msg.cmd == cmd)
661 && (msg->msg.netfn == netfn)
662 && (ipmi_addr_equal(addr, &(msg->addr))))
663 {
664 *recv_msg = msg;
665 intf->seq_table[seq].inuse = 0;
666 rv = 0;
667 }
668 }
669 spin_unlock_irqrestore(&(intf->seq_lock), flags);
670
671 return rv;
672}
673
674
675/* Start the timer for a specific sequence table entry. */
676static int intf_start_seq_timer(ipmi_smi_t intf,
677 long msgid)
678{
679 int rv = -ENODEV;
680 unsigned long flags;
681 unsigned char seq;
682 unsigned long seqid;
683
684
685 GET_SEQ_FROM_MSGID(msgid, seq, seqid);
686
687 spin_lock_irqsave(&(intf->seq_lock), flags);
688 /* We do this verification because the user can be deleted
689 while a message is outstanding. */
690 if ((intf->seq_table[seq].inuse)
691 && (intf->seq_table[seq].seqid == seqid))
692 {
693 struct seq_table *ent = &(intf->seq_table[seq]);
694 ent->timeout = ent->orig_timeout;
695 rv = 0;
696 }
697 spin_unlock_irqrestore(&(intf->seq_lock), flags);
698
699 return rv;
700}
701
702/* Got an error for the send message for a specific sequence number. */
703static int intf_err_seq(ipmi_smi_t intf,
704 long msgid,
705 unsigned int err)
706{
707 int rv = -ENODEV;
708 unsigned long flags;
709 unsigned char seq;
710 unsigned long seqid;
711 struct ipmi_recv_msg *msg = NULL;
712
713
714 GET_SEQ_FROM_MSGID(msgid, seq, seqid);
715
716 spin_lock_irqsave(&(intf->seq_lock), flags);
717 /* We do this verification because the user can be deleted
718 while a message is outstanding. */
719 if ((intf->seq_table[seq].inuse)
720 && (intf->seq_table[seq].seqid == seqid))
721 {
722 struct seq_table *ent = &(intf->seq_table[seq]);
723
724 ent->inuse = 0;
725 msg = ent->recv_msg;
726 rv = 0;
727 }
728 spin_unlock_irqrestore(&(intf->seq_lock), flags);
729
730 if (msg) {
731 msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
732 msg->msg_data[0] = err;
733 msg->msg.netfn |= 1; /* Convert to a response. */
734 msg->msg.data_len = 1;
735 msg->msg.data = msg->msg_data;
736 deliver_response(msg);
737 }
738
739 return rv;
740}
741
742
743int ipmi_create_user(unsigned int if_num,
744 struct ipmi_user_hndl *handler,
745 void *handler_data,
746 ipmi_user_t *user)
747{
748 unsigned long flags;
749 ipmi_user_t new_user;
750 int rv = 0;
751 ipmi_smi_t intf;
752
753 /* There is no module usecount here, because it's not
754 required. Since this can only be used by and called from
755 other modules, they will implicitly use this module, and
756 thus this can't be removed unless the other modules are
757 removed. */
758
759 if (handler == NULL)
760 return -EINVAL;
761
762 /* Make sure the driver is actually initialized, this handles
763 problems with initialization order. */
764 if (!initialized) {
765 rv = ipmi_init_msghandler();
766 if (rv)
767 return rv;
768
769 /* The init code doesn't return an error if it was turned
770 off, but it won't initialize. Check that. */
771 if (!initialized)
772 return -ENODEV;
773 }
774
775 new_user = kmalloc(sizeof(*new_user), GFP_KERNEL);
8a3628d5 776 if (!new_user)
1da177e4
LT		 777 return -ENOMEM;
778
393d2cc3
CM		 779 spin_lock_irqsave(&interfaces_lock, flags);
780 intf = ipmi_interfaces[if_num];
781 if ((if_num >= MAX_IPMI_INTERFACES) || IPMI_INVALID_INTERFACE(intf)) {
782 spin_unlock_irqrestore(&interfaces_lock, flags);
5c98d29a
AB		 783 rv = -EINVAL;
784 goto out_kfree;
1da177e4
LT		 785 }
786
393d2cc3
CM		 787 /* Note that each existing user holds a refcount to the interface. */
788 kref_get(&intf->refcount);
789 spin_unlock_irqrestore(&interfaces_lock, flags);
1da177e4 790
393d2cc3 791 kref_init(&new_user->refcount);
1da177e4
LT		 792 new_user->handler = handler;
793 new_user->handler_data = handler_data;
794 new_user->intf = intf;
795 new_user->gets_events = 0;
796
797 if (!try_module_get(intf->handlers->owner)) {
798 rv = -ENODEV;
5c98d29a 799 goto out_kref;
1da177e4
LT		 800 }
801
802 if (intf->handlers->inc_usecount) {
803 rv = intf->handlers->inc_usecount(intf->send_info);
804 if (rv) {
805 module_put(intf->handlers->owner);
5c98d29a 806 goto out_kref;
1da177e4
LT		 807 }
808 }
809
393d2cc3
CM		 810 new_user->valid = 1;
811 spin_lock_irqsave(&intf->seq_lock, flags);
812 list_add_rcu(&new_user->link, &intf->users);
813 spin_unlock_irqrestore(&intf->seq_lock, flags);
814 *user = new_user;
815 return 0;
1da177e4 816
5c98d29a 817out_kref:
393d2cc3 818 kref_put(&intf->refcount, intf_free);
5c98d29a
AB		 819out_kfree:
820 kfree(new_user);
1da177e4
LT		 821 return rv;
822}
823
393d2cc3
CM		 824static void free_user(struct kref *ref)
825{
826 ipmi_user_t user = container_of(ref, struct ipmi_user, refcount);
827 kfree(user);
828}
829
830int ipmi_destroy_user(ipmi_user_t user)
1da177e4 831{
393d2cc3 832 ipmi_smi_t intf = user->intf;
1da177e4
LT		 833 int i;
834 unsigned long flags;
393d2cc3 835 struct cmd_rcvr *rcvr;
393d2cc3 836 struct cmd_rcvr *rcvrs = NULL;
1da177e4 837
8a3628d5 838 user->valid = 0;
1da177e4 839
393d2cc3
CM		 840 /* Remove the user from the interface's sequence table. */
841 spin_lock_irqsave(&intf->seq_lock, flags);
842 list_del_rcu(&user->link);
1da177e4 843
e8b33617 844 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
393d2cc3
CM		 845 if (intf->seq_table[i].inuse
846 && (intf->seq_table[i].recv_msg->user == user))
1da177e4 847 {
393d2cc3 848 intf->seq_table[i].inuse = 0;
1da177e4
LT		 849 }
850 }
393d2cc3
CM		 851 spin_unlock_irqrestore(&intf->seq_lock, flags);
852
853 /*
854 * Remove the user from the command receiver's table. First
855 * we build a list of everything (not using the standard link,
856 * since other things may be using it till we do
857 * synchronize_rcu()) then free everything in that list.
858 */
d6dfd131 859 mutex_lock(&intf->cmd_rcvrs_mutex);
066bb8d0 860 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
1da177e4 861 if (rcvr->user == user) {
393d2cc3
CM		 862 list_del_rcu(&rcvr->link);
863 rcvr->next = rcvrs;
864 rcvrs = rcvr;
1da177e4
LT		 865 }
866 }
d6dfd131 867 mutex_unlock(&intf->cmd_rcvrs_mutex);
393d2cc3
CM		 868 synchronize_rcu();
869 while (rcvrs) {
870 rcvr = rcvrs;
871 rcvrs = rcvr->next;
872 kfree(rcvr);
873 }
1da177e4 874
393d2cc3
CM		 875 module_put(intf->handlers->owner);
876 if (intf->handlers->dec_usecount)
877 intf->handlers->dec_usecount(intf->send_info);
1da177e4 878
393d2cc3 879 kref_put(&intf->refcount, intf_free);
1da177e4 880
393d2cc3 881 kref_put(&user->refcount, free_user);
1da177e4 882
8a3628d5 883 return 0;
1da177e4
LT		 884}
885
886void ipmi_get_version(ipmi_user_t user,
887 unsigned char *major,
888 unsigned char *minor)
889{
50c812b2
CM		 890 *major = ipmi_version_major(&user->intf->bmc->id);
891 *minor = ipmi_version_minor(&user->intf->bmc->id);
1da177e4
LT		 892}
893
c14979b9
CM		 894int ipmi_set_my_address(ipmi_user_t user,
895 unsigned int channel,
896 unsigned char address)
1da177e4 897{
c14979b9
CM		 898 if (channel >= IPMI_MAX_CHANNELS)
899 return -EINVAL;
900 user->intf->channels[channel].address = address;
901 return 0;
1da177e4
LT		 902}
903
c14979b9
CM		 904int ipmi_get_my_address(ipmi_user_t user,
905 unsigned int channel,
906 unsigned char *address)
1da177e4 907{
c14979b9
CM		 908 if (channel >= IPMI_MAX_CHANNELS)
909 return -EINVAL;
910 *address = user->intf->channels[channel].address;
911 return 0;
1da177e4
LT		 912}
913
c14979b9
CM		 914int ipmi_set_my_LUN(ipmi_user_t user,
915 unsigned int channel,
916 unsigned char LUN)
1da177e4 917{
c14979b9
CM		 918 if (channel >= IPMI_MAX_CHANNELS)
919 return -EINVAL;
920 user->intf->channels[channel].lun = LUN & 0x3;
921 return 0;
1da177e4
LT		 922}
923
c14979b9
CM		 924int ipmi_get_my_LUN(ipmi_user_t user,
925 unsigned int channel,
926 unsigned char *address)
1da177e4 927{
c14979b9
CM		 928 if (channel >= IPMI_MAX_CHANNELS)
929 return -EINVAL;
930 *address = user->intf->channels[channel].lun;
931 return 0;
1da177e4
LT		 932}
933
934int ipmi_set_gets_events(ipmi_user_t user, int val)
935{
393d2cc3
CM		 936 unsigned long flags;
937 ipmi_smi_t intf = user->intf;
938 struct ipmi_recv_msg *msg, *msg2;
939 struct list_head msgs;
1da177e4 940
393d2cc3
CM		 941 INIT_LIST_HEAD(&msgs);
942
943 spin_lock_irqsave(&intf->events_lock, flags);
1da177e4
LT		 944 user->gets_events = val;
945
946 if (val) {
947 /* Deliver any queued events. */
179e0917
AM		 948 list_for_each_entry_safe(msg, msg2, &intf->waiting_events, link)
949 list_move_tail(&msg->link, &msgs);
4791c03d 950 intf->waiting_events_count = 0;
1da177e4 951 }
393d2cc3
CM		 952
953 /* Hold the events lock while doing this to preserve order. */
954 list_for_each_entry_safe(msg, msg2, &msgs, link) {
955 msg->user = user;
956 kref_get(&user->refcount);
957 deliver_response(msg);
958 }
959
960 spin_unlock_irqrestore(&intf->events_lock, flags);
1da177e4
LT		 961
962 return 0;
963}
964
393d2cc3
CM		 965static struct cmd_rcvr *find_cmd_rcvr(ipmi_smi_t intf,
966 unsigned char netfn,
c69c3127
CM		 967 unsigned char cmd,
968 unsigned char chan)
393d2cc3
CM		 969{
970 struct cmd_rcvr *rcvr;
971
972 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
c69c3127
CM		 973 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
974 && (rcvr->chans & (1 << chan)))
393d2cc3
CM		 975 return rcvr;
976 }
977 return NULL;
978}
979
c69c3127
CM		 980static int is_cmd_rcvr_exclusive(ipmi_smi_t intf,
981 unsigned char netfn,
982 unsigned char cmd,
983 unsigned int chans)
984{
985 struct cmd_rcvr *rcvr;
986
987 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
988 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
989 && (rcvr->chans & chans))
990 return 0;
991 }
992 return 1;
993}
994
1da177e4
LT		 995int ipmi_register_for_cmd(ipmi_user_t user,
996 unsigned char netfn,
c69c3127
CM		 997 unsigned char cmd,
998 unsigned int chans)
1da177e4 999{
393d2cc3
CM		 1000 ipmi_smi_t intf = user->intf;
1001 struct cmd_rcvr *rcvr;
393d2cc3 1002 int rv = 0;
1da177e4
LT		 1003
1004
1005 rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL);
8a3628d5 1006 if (!rcvr)
1da177e4 1007 return -ENOMEM;
393d2cc3
CM		 1008 rcvr->cmd = cmd;
1009 rcvr->netfn = netfn;
c69c3127 1010 rcvr->chans = chans;
393d2cc3 1011 rcvr->user = user;
1da177e4 1012
d6dfd131 1013 mutex_lock(&intf->cmd_rcvrs_mutex);
1da177e4 1014 /* Make sure the command/netfn is not already registered. */
c69c3127 1015 if (!is_cmd_rcvr_exclusive(intf, netfn, cmd, chans)) {
393d2cc3
CM		 1016 rv = -EBUSY;
1017 goto out_unlock;
1da177e4 1018 }
877197ef 1019
393d2cc3 1020 list_add_rcu(&rcvr->link, &intf->cmd_rcvrs);
1da177e4 1021
393d2cc3 1022 out_unlock:
d6dfd131 1023 mutex_unlock(&intf->cmd_rcvrs_mutex);
1da177e4
LT		 1024 if (rv)
1025 kfree(rcvr);
1026
1027 return rv;
1028}
1029
1030int ipmi_unregister_for_cmd(ipmi_user_t user,
1031 unsigned char netfn,
c69c3127
CM		 1032 unsigned char cmd,
1033 unsigned int chans)
1da177e4 1034{
393d2cc3
CM		 1035 ipmi_smi_t intf = user->intf;
1036 struct cmd_rcvr *rcvr;
c69c3127
CM		 1037 struct cmd_rcvr *rcvrs = NULL;
1038 int i, rv = -ENOENT;
1da177e4 1039
d6dfd131 1040 mutex_lock(&intf->cmd_rcvrs_mutex);
c69c3127
CM		 1041 for (i = 0; i < IPMI_NUM_CHANNELS; i++) {
1042 if (((1 << i) & chans) == 0)
1043 continue;
1044 rcvr = find_cmd_rcvr(intf, netfn, cmd, i);
1045 if (rcvr == NULL)
1046 continue;
1047 if (rcvr->user == user) {
1048 rv = 0;
1049 rcvr->chans &= ~chans;
1050 if (rcvr->chans == 0) {
1051 list_del_rcu(&rcvr->link);
1052 rcvr->next = rcvrs;
1053 rcvrs = rcvr;
1054 }
1055 }
1056 }
1057 mutex_unlock(&intf->cmd_rcvrs_mutex);
1058 synchronize_rcu();
1059 while (rcvrs) {
1060 rcvr = rcvrs;
1061 rcvrs = rcvr->next;
393d2cc3 1062 kfree(rcvr);
1da177e4 1063 }
c69c3127 1064 return rv;
1da177e4
LT		 1065}
1066
1067void ipmi_user_set_run_to_completion(ipmi_user_t user, int val)
1068{
393d2cc3
CM		 1069 ipmi_smi_t intf = user->intf;
1070 intf->handlers->set_run_to_completion(intf->send_info, val);
1da177e4
LT		 1071}
1072
1073static unsigned char
1074ipmb_checksum(unsigned char *data, int size)
1075{
1076 unsigned char csum = 0;
1077
1078 for (; size > 0; size--, data++)
1079 csum += *data;
1080
1081 return -csum;
1082}
1083
1084static inline void format_ipmb_msg(struct ipmi_smi_msg *smi_msg,
1085 struct kernel_ipmi_msg *msg,
1086 struct ipmi_ipmb_addr *ipmb_addr,
1087 long msgid,
1088 unsigned char ipmb_seq,
1089 int broadcast,
1090 unsigned char source_address,
1091 unsigned char source_lun)
1092{
1093 int i = broadcast;
1094
1095 /* Format the IPMB header data. */
1096 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
1097 smi_msg->data[1] = IPMI_SEND_MSG_CMD;
1098 smi_msg->data[2] = ipmb_addr->channel;
1099 if (broadcast)
1100 smi_msg->data[3] = 0;
1101 smi_msg->data[i+3] = ipmb_addr->slave_addr;
1102 smi_msg->data[i+4] = (msg->netfn << 2) | (ipmb_addr->lun & 0x3);
1103 smi_msg->data[i+5] = ipmb_checksum(&(smi_msg->data[i+3]), 2);
1104 smi_msg->data[i+6] = source_address;
1105 smi_msg->data[i+7] = (ipmb_seq << 2) | source_lun;
1106 smi_msg->data[i+8] = msg->cmd;
1107
1108 /* Now tack on the data to the message. */
1109 if (msg->data_len > 0)
1110 memcpy(&(smi_msg->data[i+9]), msg->data,
1111 msg->data_len);
1112 smi_msg->data_size = msg->data_len + 9;
1113
1114 /* Now calculate the checksum and tack it on. */
1115 smi_msg->data[i+smi_msg->data_size]
1116 = ipmb_checksum(&(smi_msg->data[i+6]),
1117 smi_msg->data_size-6);
1118
1119 /* Add on the checksum size and the offset from the
1120 broadcast. */
1121 smi_msg->data_size += 1 + i;
1122
1123 smi_msg->msgid = msgid;
1124}
1125
1126static inline void format_lan_msg(struct ipmi_smi_msg *smi_msg,
1127 struct kernel_ipmi_msg *msg,
1128 struct ipmi_lan_addr *lan_addr,
1129 long msgid,
1130 unsigned char ipmb_seq,
1131 unsigned char source_lun)
1132{
1133 /* Format the IPMB header data. */
1134 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
1135 smi_msg->data[1] = IPMI_SEND_MSG_CMD;
1136 smi_msg->data[2] = lan_addr->channel;
1137 smi_msg->data[3] = lan_addr->session_handle;
1138 smi_msg->data[4] = lan_addr->remote_SWID;
1139 smi_msg->data[5] = (msg->netfn << 2) | (lan_addr->lun & 0x3);
1140 smi_msg->data[6] = ipmb_checksum(&(smi_msg->data[4]), 2);
1141 smi_msg->data[7] = lan_addr->local_SWID;
1142 smi_msg->data[8] = (ipmb_seq << 2) | source_lun;
1143 smi_msg->data[9] = msg->cmd;
1144
1145 /* Now tack on the data to the message. */
1146 if (msg->data_len > 0)
1147 memcpy(&(smi_msg->data[10]), msg->data,
1148 msg->data_len);
1149 smi_msg->data_size = msg->data_len + 10;
1150
1151 /* Now calculate the checksum and tack it on. */
1152 smi_msg->data[smi_msg->data_size]
1153 = ipmb_checksum(&(smi_msg->data[7]),
1154 smi_msg->data_size-7);
1155
1156 /* Add on the checksum size and the offset from the
1157 broadcast. */
1158 smi_msg->data_size += 1;
1159
1160 smi_msg->msgid = msgid;
1161}
1162
1163/* Separate from ipmi_request so that the user does not have to be
1164 supplied in certain circumstances (mainly at panic time). If
1165 messages are supplied, they will be freed, even if an error
1166 occurs. */
393d2cc3
CM		 1167static int i_ipmi_request(ipmi_user_t user,
1168 ipmi_smi_t intf,
1169 struct ipmi_addr *addr,
1170 long msgid,
1171 struct kernel_ipmi_msg *msg,
1172 void *user_msg_data,
1173 void *supplied_smi,
1174 struct ipmi_recv_msg *supplied_recv,
1175 int priority,
1176 unsigned char source_address,
1177 unsigned char source_lun,
1178 int retries,
1179 unsigned int retry_time_ms)
1da177e4
LT		 1180{
1181 int rv = 0;
1182 struct ipmi_smi_msg *smi_msg;
1183 struct ipmi_recv_msg *recv_msg;
1184 unsigned long flags;
1185
1186
1187 if (supplied_recv) {
1188 recv_msg = supplied_recv;
1189 } else {
1190 recv_msg = ipmi_alloc_recv_msg();
1191 if (recv_msg == NULL) {
1192 return -ENOMEM;
1193 }
1194 }
1195 recv_msg->user_msg_data = user_msg_data;
1196
1197 if (supplied_smi) {
1198 smi_msg = (struct ipmi_smi_msg *) supplied_smi;
1199 } else {
1200 smi_msg = ipmi_alloc_smi_msg();
1201 if (smi_msg == NULL) {
1202 ipmi_free_recv_msg(recv_msg);
1203 return -ENOMEM;
1204 }
1205 }
1206
1207 recv_msg->user = user;
393d2cc3
CM		 1208 if (user)
1209 kref_get(&user->refcount);
1da177e4
LT		 1210 recv_msg->msgid = msgid;
1211 /* Store the message to send in the receive message so timeout
1212 responses can get the proper response data. */
1213 recv_msg->msg = *msg;
1214
1215 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
1216 struct ipmi_system_interface_addr *smi_addr;
1217
1218 if (msg->netfn & 1) {
1219 /* Responses are not allowed to the SMI. */
1220 rv = -EINVAL;
1221 goto out_err;
1222 }
1223
1224 smi_addr = (struct ipmi_system_interface_addr *) addr;
1225 if (smi_addr->lun > 3) {
1226 spin_lock_irqsave(&intf->counter_lock, flags);
1227 intf->sent_invalid_commands++;
1228 spin_unlock_irqrestore(&intf->counter_lock, flags);
1229 rv = -EINVAL;
1230 goto out_err;
1231 }
1232
1233 memcpy(&recv_msg->addr, smi_addr, sizeof(*smi_addr));
1234
1235 if ((msg->netfn == IPMI_NETFN_APP_REQUEST)
1236 && ((msg->cmd == IPMI_SEND_MSG_CMD)
1237 || (msg->cmd == IPMI_GET_MSG_CMD)
1238 || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD)))
1239 {
1240 /* We don't let the user do these, since we manage
1241 the sequence numbers. */
1242 spin_lock_irqsave(&intf->counter_lock, flags);
1243 intf->sent_invalid_commands++;
1244 spin_unlock_irqrestore(&intf->counter_lock, flags);
1245 rv = -EINVAL;
1246 goto out_err;
1247 }
1248
1249 if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) {
1250 spin_lock_irqsave(&intf->counter_lock, flags);
1251 intf->sent_invalid_commands++;
1252 spin_unlock_irqrestore(&intf->counter_lock, flags);
1253 rv = -EMSGSIZE;
1254 goto out_err;
1255 }
1256
1257 smi_msg->data[0] = (msg->netfn << 2) | (smi_addr->lun & 0x3);
1258 smi_msg->data[1] = msg->cmd;
1259 smi_msg->msgid = msgid;
1260 smi_msg->user_data = recv_msg;
1261 if (msg->data_len > 0)
1262 memcpy(&(smi_msg->data[2]), msg->data, msg->data_len);
1263 smi_msg->data_size = msg->data_len + 2;
1264 spin_lock_irqsave(&intf->counter_lock, flags);
1265 intf->sent_local_commands++;
1266 spin_unlock_irqrestore(&intf->counter_lock, flags);
1267 } else if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
1268 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
1269 {
1270 struct ipmi_ipmb_addr *ipmb_addr;
1271 unsigned char ipmb_seq;
1272 long seqid;
1273 int broadcast = 0;
1274
9c101fd4
KZ		 1275 if (addr->channel >= IPMI_MAX_CHANNELS) {
1276 spin_lock_irqsave(&intf->counter_lock, flags);
1da177e4
LT		 1277 intf->sent_invalid_commands++;
1278 spin_unlock_irqrestore(&intf->counter_lock, flags);
1279 rv = -EINVAL;
1280 goto out_err;
1281 }
1282
1283 if (intf->channels[addr->channel].medium
1284 != IPMI_CHANNEL_MEDIUM_IPMB)
1285 {
1286 spin_lock_irqsave(&intf->counter_lock, flags);
1287 intf->sent_invalid_commands++;
1288 spin_unlock_irqrestore(&intf->counter_lock, flags);
1289 rv = -EINVAL;
1290 goto out_err;
1291 }
1292
1293 if (retries < 0) {
1294 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)
1295 retries = 0; /* Don't retry broadcasts. */
1296 else
1297 retries = 4;
1298 }
1299 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) {
1300 /* Broadcasts add a zero at the beginning of the
1301 message, but otherwise is the same as an IPMB
1302 address. */
1303 addr->addr_type = IPMI_IPMB_ADDR_TYPE;
1304 broadcast = 1;
1305 }
1306
1307
1308 /* Default to 1 second retries. */
1309 if (retry_time_ms == 0)
1310 retry_time_ms = 1000;
1311
1312 /* 9 for the header and 1 for the checksum, plus
1313 possibly one for the broadcast. */
1314 if ((msg->data_len + 10 + broadcast) > IPMI_MAX_MSG_LENGTH) {
1315 spin_lock_irqsave(&intf->counter_lock, flags);
1316 intf->sent_invalid_commands++;
1317 spin_unlock_irqrestore(&intf->counter_lock, flags);
1318 rv = -EMSGSIZE;
1319 goto out_err;
1320 }
1321
1322 ipmb_addr = (struct ipmi_ipmb_addr *) addr;
1323 if (ipmb_addr->lun > 3) {
1324 spin_lock_irqsave(&intf->counter_lock, flags);
1325 intf->sent_invalid_commands++;
1326 spin_unlock_irqrestore(&intf->counter_lock, flags);
1327 rv = -EINVAL;
1328 goto out_err;
1329 }
1330
1331 memcpy(&recv_msg->addr, ipmb_addr, sizeof(*ipmb_addr));
1332
1333 if (recv_msg->msg.netfn & 0x1) {
1334 /* It's a response, so use the user's sequence
1335 from msgid. */
1336 spin_lock_irqsave(&intf->counter_lock, flags);
1337 intf->sent_ipmb_responses++;
1338 spin_unlock_irqrestore(&intf->counter_lock, flags);
1339 format_ipmb_msg(smi_msg, msg, ipmb_addr, msgid,
1340 msgid, broadcast,
1341 source_address, source_lun);
1342
1343 /* Save the receive message so we can use it
1344 to deliver the response. */
1345 smi_msg->user_data = recv_msg;
1346 } else {
1347 /* It's a command, so get a sequence for it. */
1348
1349 spin_lock_irqsave(&(intf->seq_lock), flags);
1350
1351 spin_lock(&intf->counter_lock);
1352 intf->sent_ipmb_commands++;
1353 spin_unlock(&intf->counter_lock);
1354
1355 /* Create a sequence number with a 1 second
1356 timeout and 4 retries. */
1357 rv = intf_next_seq(intf,
1358 recv_msg,
1359 retry_time_ms,
1360 retries,
1361 broadcast,
1362 &ipmb_seq,
1363 &seqid);
1364 if (rv) {
1365 /* We have used up all the sequence numbers,
1366 probably, so abort. */
1367 spin_unlock_irqrestore(&(intf->seq_lock),
1368 flags);
1369 goto out_err;
1370 }
1371
1372 /* Store the sequence number in the message,
1373 so that when the send message response
1374 comes back we can start the timer. */
1375 format_ipmb_msg(smi_msg, msg, ipmb_addr,
1376 STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
1377 ipmb_seq, broadcast,
1378 source_address, source_lun);
1379
1380 /* Copy the message into the recv message data, so we
1381 can retransmit it later if necessary. */
1382 memcpy(recv_msg->msg_data, smi_msg->data,
1383 smi_msg->data_size);
1384 recv_msg->msg.data = recv_msg->msg_data;
1385 recv_msg->msg.data_len = smi_msg->data_size;
1386
1387 /* We don't unlock until here, because we need
1388 to copy the completed message into the
1389 recv_msg before we release the lock.
1390 Otherwise, race conditions may bite us. I
1391 know that's pretty paranoid, but I prefer
1392 to be correct. */
1393 spin_unlock_irqrestore(&(intf->seq_lock), flags);
1394 }
1395 } else if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
1396 struct ipmi_lan_addr *lan_addr;
1397 unsigned char ipmb_seq;
1398 long seqid;
1399
12fc1d7b 1400 if (addr->channel >= IPMI_MAX_CHANNELS) {
1da177e4
LT		 1401 spin_lock_irqsave(&intf->counter_lock, flags);
1402 intf->sent_invalid_commands++;
1403 spin_unlock_irqrestore(&intf->counter_lock, flags);
1404 rv = -EINVAL;
1405 goto out_err;
1406 }
1407
1408 if ((intf->channels[addr->channel].medium
1409 != IPMI_CHANNEL_MEDIUM_8023LAN)
1410 && (intf->channels[addr->channel].medium
1411 != IPMI_CHANNEL_MEDIUM_ASYNC))
1412 {
1413 spin_lock_irqsave(&intf->counter_lock, flags);
1414 intf->sent_invalid_commands++;
1415 spin_unlock_irqrestore(&intf->counter_lock, flags);
1416 rv = -EINVAL;
1417 goto out_err;
1418 }
1419
1420 retries = 4;
1421
1422 /* Default to 1 second retries. */
1423 if (retry_time_ms == 0)
1424 retry_time_ms = 1000;
1425
1426 /* 11 for the header and 1 for the checksum. */
1427 if ((msg->data_len + 12) > IPMI_MAX_MSG_LENGTH) {
1428 spin_lock_irqsave(&intf->counter_lock, flags);
1429 intf->sent_invalid_commands++;
1430 spin_unlock_irqrestore(&intf->counter_lock, flags);
1431 rv = -EMSGSIZE;
1432 goto out_err;
1433 }
1434
1435 lan_addr = (struct ipmi_lan_addr *) addr;
1436 if (lan_addr->lun > 3) {
1437 spin_lock_irqsave(&intf->counter_lock, flags);
1438 intf->sent_invalid_commands++;
1439 spin_unlock_irqrestore(&intf->counter_lock, flags);
1440 rv = -EINVAL;
1441 goto out_err;
1442 }
1443
1444 memcpy(&recv_msg->addr, lan_addr, sizeof(*lan_addr));
1445
1446 if (recv_msg->msg.netfn & 0x1) {
1447 /* It's a response, so use the user's sequence
1448 from msgid. */
1449 spin_lock_irqsave(&intf->counter_lock, flags);
1450 intf->sent_lan_responses++;
1451 spin_unlock_irqrestore(&intf->counter_lock, flags);
1452 format_lan_msg(smi_msg, msg, lan_addr, msgid,
1453 msgid, source_lun);
1454
1455 /* Save the receive message so we can use it
1456 to deliver the response. */
1457 smi_msg->user_data = recv_msg;
1458 } else {
1459 /* It's a command, so get a sequence for it. */
1460
1461 spin_lock_irqsave(&(intf->seq_lock), flags);
1462
1463 spin_lock(&intf->counter_lock);
1464 intf->sent_lan_commands++;
1465 spin_unlock(&intf->counter_lock);
1466
1467 /* Create a sequence number with a 1 second
1468 timeout and 4 retries. */
1469 rv = intf_next_seq(intf,
1470 recv_msg,
1471 retry_time_ms,
1472 retries,
1473 0,
1474 &ipmb_seq,
1475 &seqid);
1476 if (rv) {
1477 /* We have used up all the sequence numbers,
1478 probably, so abort. */
1479 spin_unlock_irqrestore(&(intf->seq_lock),
1480 flags);
1481 goto out_err;
1482 }
1483
1484 /* Store the sequence number in the message,
1485 so that when the send message response
1486 comes back we can start the timer. */
1487 format_lan_msg(smi_msg, msg, lan_addr,
1488 STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
1489 ipmb_seq, source_lun);
1490
1491 /* Copy the message into the recv message data, so we
1492 can retransmit it later if necessary. */
1493 memcpy(recv_msg->msg_data, smi_msg->data,
1494 smi_msg->data_size);
1495 recv_msg->msg.data = recv_msg->msg_data;
1496 recv_msg->msg.data_len = smi_msg->data_size;
1497
1498 /* We don't unlock until here, because we need
1499 to copy the completed message into the
1500 recv_msg before we release the lock.
1501 Otherwise, race conditions may bite us. I
1502 know that's pretty paranoid, but I prefer
1503 to be correct. */
1504 spin_unlock_irqrestore(&(intf->seq_lock), flags);
1505 }
1506 } else {
1507 /* Unknown address type. */
1508 spin_lock_irqsave(&intf->counter_lock, flags);
1509 intf->sent_invalid_commands++;
1510 spin_unlock_irqrestore(&intf->counter_lock, flags);
1511 rv = -EINVAL;
1512 goto out_err;
1513 }
1514
1515#ifdef DEBUG_MSGING
1516 {
1517 int m;
e8b33617 1518 for (m = 0; m < smi_msg->data_size; m++)
1da177e4
LT		 1519 printk(" %2.2x", smi_msg->data[m]);
1520 printk("\n");
1521 }
1522#endif
1523 intf->handlers->sender(intf->send_info, smi_msg, priority);
1524
1525 return 0;
1526
1527 out_err:
1528 ipmi_free_smi_msg(smi_msg);
1529 ipmi_free_recv_msg(recv_msg);
1530 return rv;
1531}
1532
c14979b9
CM		 1533static int check_addr(ipmi_smi_t intf,
1534 struct ipmi_addr *addr,
1535 unsigned char *saddr,
1536 unsigned char *lun)
1537{
1538 if (addr->channel >= IPMI_MAX_CHANNELS)
1539 return -EINVAL;
1540 *lun = intf->channels[addr->channel].lun;
1541 *saddr = intf->channels[addr->channel].address;
1542 return 0;
1543}
1544
1da177e4
LT		 1545int ipmi_request_settime(ipmi_user_t user,
1546 struct ipmi_addr *addr,
1547 long msgid,
1548 struct kernel_ipmi_msg *msg,
1549 void *user_msg_data,
1550 int priority,
1551 int retries,
1552 unsigned int retry_time_ms)
1553{
c14979b9
CM		 1554 unsigned char saddr, lun;
1555 int rv;
1556
8a3628d5 1557 if (!user)
56a55ec6 1558 return -EINVAL;
c14979b9
CM		 1559 rv = check_addr(user->intf, addr, &saddr, &lun);
1560 if (rv)
1561 return rv;
1da177e4
LT		 1562 return i_ipmi_request(user,
1563 user->intf,
1564 addr,
1565 msgid,
1566 msg,
1567 user_msg_data,
1568 NULL, NULL,
1569 priority,
c14979b9
CM		 1570 saddr,
1571 lun,
1da177e4
LT		 1572 retries,
1573 retry_time_ms);
1574}
1575
1576int ipmi_request_supply_msgs(ipmi_user_t user,
1577 struct ipmi_addr *addr,
1578 long msgid,
1579 struct kernel_ipmi_msg *msg,
1580 void *user_msg_data,
1581 void *supplied_smi,
1582 struct ipmi_recv_msg *supplied_recv,
1583 int priority)
1584{
c14979b9
CM		 1585 unsigned char saddr, lun;
1586 int rv;
1587
8a3628d5 1588 if (!user)
56a55ec6 1589 return -EINVAL;
c14979b9
CM		 1590 rv = check_addr(user->intf, addr, &saddr, &lun);
1591 if (rv)
1592 return rv;
1da177e4
LT		 1593 return i_ipmi_request(user,
1594 user->intf,
1595 addr,
1596 msgid,
1597 msg,
1598 user_msg_data,
1599 supplied_smi,
1600 supplied_recv,
1601 priority,
c14979b9
CM		 1602 saddr,
1603 lun,
1da177e4
LT		 1604 -1, 0);
1605}
1606
1607static int ipmb_file_read_proc(char *page, char **start, off_t off,
1608 int count, int *eof, void *data)
1609{
1610 char *out = (char *) page;
1611 ipmi_smi_t intf = data;
c14979b9 1612 int i;
8a3628d5 1613 int rv = 0;
1da177e4 1614
e8b33617 1615 for (i = 0; i < IPMI_MAX_CHANNELS; i++)
c14979b9
CM		 1616 rv += sprintf(out+rv, "%x ", intf->channels[i].address);
1617 out[rv-1] = '\n'; /* Replace the final space with a newline */
1618 out[rv] = '\0';
1619 rv++;
1620 return rv;
1da177e4
LT		 1621}
1622
1623static int version_file_read_proc(char *page, char **start, off_t off,
1624 int count, int *eof, void *data)
1625{
1626 char *out = (char *) page;
1627 ipmi_smi_t intf = data;
1628
1629 return sprintf(out, "%d.%d\n",
50c812b2
CM		 1630 ipmi_version_major(&intf->bmc->id),
1631 ipmi_version_minor(&intf->bmc->id));
1da177e4
LT		 1632}
1633
1634static int stat_file_read_proc(char *page, char **start, off_t off,
1635 int count, int *eof, void *data)
1636{
1637 char *out = (char *) page;
1638 ipmi_smi_t intf = data;
1639
1640 out += sprintf(out, "sent_invalid_commands: %d\n",
1641 intf->sent_invalid_commands);
1642 out += sprintf(out, "sent_local_commands: %d\n",
1643 intf->sent_local_commands);
1644 out += sprintf(out, "handled_local_responses: %d\n",
1645 intf->handled_local_responses);
1646 out += sprintf(out, "unhandled_local_responses: %d\n",
1647 intf->unhandled_local_responses);
1648 out += sprintf(out, "sent_ipmb_commands: %d\n",
1649 intf->sent_ipmb_commands);
1650 out += sprintf(out, "sent_ipmb_command_errs: %d\n",
1651 intf->sent_ipmb_command_errs);
1652 out += sprintf(out, "retransmitted_ipmb_commands: %d\n",
1653 intf->retransmitted_ipmb_commands);
1654 out += sprintf(out, "timed_out_ipmb_commands: %d\n",
1655 intf->timed_out_ipmb_commands);
1656 out += sprintf(out, "timed_out_ipmb_broadcasts: %d\n",
1657 intf->timed_out_ipmb_broadcasts);
1658 out += sprintf(out, "sent_ipmb_responses: %d\n",
1659 intf->sent_ipmb_responses);
1660 out += sprintf(out, "handled_ipmb_responses: %d\n",
1661 intf->handled_ipmb_responses);
1662 out += sprintf(out, "invalid_ipmb_responses: %d\n",
1663 intf->invalid_ipmb_responses);
1664 out += sprintf(out, "unhandled_ipmb_responses: %d\n",
1665 intf->unhandled_ipmb_responses);
1666 out += sprintf(out, "sent_lan_commands: %d\n",
1667 intf->sent_lan_commands);
1668 out += sprintf(out, "sent_lan_command_errs: %d\n",
1669 intf->sent_lan_command_errs);
1670 out += sprintf(out, "retransmitted_lan_commands: %d\n",
1671 intf->retransmitted_lan_commands);
1672 out += sprintf(out, "timed_out_lan_commands: %d\n",
1673 intf->timed_out_lan_commands);
1674 out += sprintf(out, "sent_lan_responses: %d\n",
1675 intf->sent_lan_responses);
1676 out += sprintf(out, "handled_lan_responses: %d\n",
1677 intf->handled_lan_responses);
1678 out += sprintf(out, "invalid_lan_responses: %d\n",
1679 intf->invalid_lan_responses);
1680 out += sprintf(out, "unhandled_lan_responses: %d\n",
1681 intf->unhandled_lan_responses);
1682 out += sprintf(out, "handled_commands: %d\n",
1683 intf->handled_commands);
1684 out += sprintf(out, "invalid_commands: %d\n",
1685 intf->invalid_commands);
1686 out += sprintf(out, "unhandled_commands: %d\n",
1687 intf->unhandled_commands);
1688 out += sprintf(out, "invalid_events: %d\n",
1689 intf->invalid_events);
1690 out += sprintf(out, "events: %d\n",
1691 intf->events);
1692
1693 return (out - ((char *) page));
1694}
1695
1696int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
1697 read_proc_t *read_proc, write_proc_t *write_proc,
1698 void *data, struct module *owner)
1699{
1da177e4 1700 int rv = 0;
3b625943
CM		 1701#ifdef CONFIG_PROC_FS
1702 struct proc_dir_entry *file;
1da177e4
LT		 1703 struct ipmi_proc_entry *entry;
1704
1705 /* Create a list element. */
1706 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1707 if (!entry)
1708 return -ENOMEM;
1709 entry->name = kmalloc(strlen(name)+1, GFP_KERNEL);
1710 if (!entry->name) {
1711 kfree(entry);
1712 return -ENOMEM;
1713 }
1714 strcpy(entry->name, name);
1715
1716 file = create_proc_entry(name, 0, smi->proc_dir);
1717 if (!file) {
1718 kfree(entry->name);
1719 kfree(entry);
1720 rv = -ENOMEM;
1721 } else {
1722 file->nlink = 1;
1723 file->data = data;
1724 file->read_proc = read_proc;
1725 file->write_proc = write_proc;
1726 file->owner = owner;
1727
3b625943 1728 spin_lock(&smi->proc_entry_lock);
1da177e4
LT		 1729 /* Stick it on the list. */
1730 entry->next = smi->proc_entries;
1731 smi->proc_entries = entry;
3b625943 1732 spin_unlock(&smi->proc_entry_lock);
1da177e4 1733 }
3b625943 1734#endif /* CONFIG_PROC_FS */
1da177e4
LT		 1735
1736 return rv;
1737}
1738
1739static int add_proc_entries(ipmi_smi_t smi, int num)
1740{
1741 int rv = 0;
1742
3b625943 1743#ifdef CONFIG_PROC_FS
1da177e4
LT		 1744 sprintf(smi->proc_dir_name, "%d", num);
1745 smi->proc_dir = proc_mkdir(smi->proc_dir_name, proc_ipmi_root);
1746 if (!smi->proc_dir)
1747 rv = -ENOMEM;
1748 else {
1749 smi->proc_dir->owner = THIS_MODULE;
1750 }
1751
1752 if (rv == 0)
1753 rv = ipmi_smi_add_proc_entry(smi, "stats",
1754 stat_file_read_proc, NULL,
1755 smi, THIS_MODULE);
1756
1757 if (rv == 0)
1758 rv = ipmi_smi_add_proc_entry(smi, "ipmb",
1759 ipmb_file_read_proc, NULL,
1760 smi, THIS_MODULE);
1761
1762 if (rv == 0)
1763 rv = ipmi_smi_add_proc_entry(smi, "version",
1764 version_file_read_proc, NULL,
1765 smi, THIS_MODULE);
3b625943 1766#endif /* CONFIG_PROC_FS */
1da177e4
LT		 1767
1768 return rv;
1769}
1770
1771static void remove_proc_entries(ipmi_smi_t smi)
1772{
3b625943 1773#ifdef CONFIG_PROC_FS
1da177e4
LT		 1774 struct ipmi_proc_entry *entry;
1775
3b625943 1776 spin_lock(&smi->proc_entry_lock);
1da177e4
LT		 1777 while (smi->proc_entries) {
1778 entry = smi->proc_entries;
1779 smi->proc_entries = entry->next;
1780
1781 remove_proc_entry(entry->name, smi->proc_dir);
1782 kfree(entry->name);
1783 kfree(entry);
1784 }
3b625943 1785 spin_unlock(&smi->proc_entry_lock);
1da177e4 1786 remove_proc_entry(smi->proc_dir_name, proc_ipmi_root);
3b625943 1787#endif /* CONFIG_PROC_FS */
1da177e4
LT		 1788}
1789
50c812b2
CM		 1790static int __find_bmc_guid(struct device *dev, void *data)
1791{
1792 unsigned char *id = data;
1793 struct bmc_device *bmc = dev_get_drvdata(dev);
1794 return memcmp(bmc->guid, id, 16) == 0;
1795}
1796
1797static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv,
1798 unsigned char *guid)
1799{
1800 struct device *dev;
1801
1802 dev = driver_find_device(drv, NULL, guid, __find_bmc_guid);
1803 if (dev)
1804 return dev_get_drvdata(dev);
1805 else
1806 return NULL;
1807}
1808
1809struct prod_dev_id {
1810 unsigned int product_id;
1811 unsigned char device_id;
1812};
1813
1814static int __find_bmc_prod_dev_id(struct device *dev, void *data)
1815{
1816 struct prod_dev_id *id = data;
1817 struct bmc_device *bmc = dev_get_drvdata(dev);
1818
1819 return (bmc->id.product_id == id->product_id
50c812b2
CM		 1820 && bmc->id.device_id == id->device_id);
1821}
1822
1823static struct bmc_device *ipmi_find_bmc_prod_dev_id(
1824 struct device_driver *drv,
f0b55da0 1825 unsigned int product_id, unsigned char device_id)
50c812b2
CM		 1826{
1827 struct prod_dev_id id = {
1828 .product_id = product_id,
1829 .device_id = device_id,
1830 };
1831 struct device *dev;
1832
1833 dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id);
1834 if (dev)
1835 return dev_get_drvdata(dev);
1836 else
1837 return NULL;
1838}
1839
1840static ssize_t device_id_show(struct device *dev,
1841 struct device_attribute *attr,
1842 char *buf)
1843{
1844 struct bmc_device *bmc = dev_get_drvdata(dev);
1845
1846 return snprintf(buf, 10, "%u\n", bmc->id.device_id);
1847}
1848
1849static ssize_t provides_dev_sdrs_show(struct device *dev,
1850 struct device_attribute *attr,
1851 char *buf)
1852{
1853 struct bmc_device *bmc = dev_get_drvdata(dev);
1854
1855 return snprintf(buf, 10, "%u\n",
7947d2cc 1856 (bmc->id.device_revision & 0x80) >> 7);
50c812b2
CM		 1857}
1858
1859static ssize_t revision_show(struct device *dev, struct device_attribute *attr,
1860 char *buf)
1861{
1862 struct bmc_device *bmc = dev_get_drvdata(dev);
1863
1864 return snprintf(buf, 20, "%u\n",
7947d2cc 1865 bmc->id.device_revision & 0x0F);
50c812b2
CM		 1866}
1867
1868static ssize_t firmware_rev_show(struct device *dev,
1869 struct device_attribute *attr,
1870 char *buf)
1871{
1872 struct bmc_device *bmc = dev_get_drvdata(dev);
1873
1874 return snprintf(buf, 20, "%u.%x\n", bmc->id.firmware_revision_1,
1875 bmc->id.firmware_revision_2);
1876}
1877
1878static ssize_t ipmi_version_show(struct device *dev,
1879 struct device_attribute *attr,
1880 char *buf)
1881{
1882 struct bmc_device *bmc = dev_get_drvdata(dev);
1883
1884 return snprintf(buf, 20, "%u.%u\n",
1885 ipmi_version_major(&bmc->id),
1886 ipmi_version_minor(&bmc->id));
1887}
1888
1889static ssize_t add_dev_support_show(struct device *dev,
1890 struct device_attribute *attr,
1891 char *buf)
1892{
1893 struct bmc_device *bmc = dev_get_drvdata(dev);
1894
1895 return snprintf(buf, 10, "0x%02x\n",
1896 bmc->id.additional_device_support);
1897}
1898
1899static ssize_t manufacturer_id_show(struct device *dev,
1900 struct device_attribute *attr,
1901 char *buf)
1902{
1903 struct bmc_device *bmc = dev_get_drvdata(dev);
1904
1905 return snprintf(buf, 20, "0x%6.6x\n", bmc->id.manufacturer_id);
1906}
1907
1908static ssize_t product_id_show(struct device *dev,
1909 struct device_attribute *attr,
1910 char *buf)
1911{
1912 struct bmc_device *bmc = dev_get_drvdata(dev);
1913
1914 return snprintf(buf, 10, "0x%4.4x\n", bmc->id.product_id);
1915}
1916
1917static ssize_t aux_firmware_rev_show(struct device *dev,
1918 struct device_attribute *attr,
1919 char *buf)
1920{
1921 struct bmc_device *bmc = dev_get_drvdata(dev);
1922
1923 return snprintf(buf, 21, "0x%02x 0x%02x 0x%02x 0x%02x\n",
1924 bmc->id.aux_firmware_revision[3],
1925 bmc->id.aux_firmware_revision[2],
1926 bmc->id.aux_firmware_revision[1],
1927 bmc->id.aux_firmware_revision[0]);
1928}
1929
1930static ssize_t guid_show(struct device *dev, struct device_attribute *attr,
1931 char *buf)
1932{
1933 struct bmc_device *bmc = dev_get_drvdata(dev);
1934
1935 return snprintf(buf, 100, "%Lx%Lx\n",
1936 (long long) bmc->guid[0],
1937 (long long) bmc->guid[8]);
1938}
1939
5e59393e 1940static void remove_files(struct bmc_device *bmc)
50c812b2 1941{
f0b55da0
CM		 1942 if (!bmc->dev)
1943 return;
1944
50c812b2
CM		 1945 device_remove_file(&bmc->dev->dev,
1946 &bmc->device_id_attr);
1947 device_remove_file(&bmc->dev->dev,
1948 &bmc->provides_dev_sdrs_attr);
1949 device_remove_file(&bmc->dev->dev,
1950 &bmc->revision_attr);
1951 device_remove_file(&bmc->dev->dev,
1952 &bmc->firmware_rev_attr);
1953 device_remove_file(&bmc->dev->dev,
1954 &bmc->version_attr);
1955 device_remove_file(&bmc->dev->dev,
1956 &bmc->add_dev_support_attr);
1957 device_remove_file(&bmc->dev->dev,
1958 &bmc->manufacturer_id_attr);
1959 device_remove_file(&bmc->dev->dev,
1960 &bmc->product_id_attr);
5e59393e 1961
50c812b2
CM		 1962 if (bmc->id.aux_firmware_revision_set)
1963 device_remove_file(&bmc->dev->dev,
1964 &bmc->aux_firmware_rev_attr);
1965 if (bmc->guid_set)
1966 device_remove_file(&bmc->dev->dev,
1967 &bmc->guid_attr);
5e59393e
JG		 1968}
1969
1970static void
1971cleanup_bmc_device(struct kref *ref)
1972{
1973 struct bmc_device *bmc;
1974
1975 bmc = container_of(ref, struct bmc_device, refcount);
1976
1977 remove_files(bmc);
f0b55da0
CM		 1978 if (bmc->dev)
1979 platform_device_unregister(bmc->dev);
50c812b2
CM		 1980 kfree(bmc);
1981}
1982
1983static void ipmi_bmc_unregister(ipmi_smi_t intf)
1984{
1985 struct bmc_device *bmc = intf->bmc;
1986
1987 sysfs_remove_link(&intf->si_dev->kobj, "bmc");
1988 if (intf->my_dev_name) {
1989 sysfs_remove_link(&bmc->dev->dev.kobj, intf->my_dev_name);
1990 kfree(intf->my_dev_name);
1991 intf->my_dev_name = NULL;
1992 }
1993
1994 mutex_lock(&ipmidriver_mutex);
1995 kref_put(&bmc->refcount, cleanup_bmc_device);
f0b55da0 1996 intf->bmc = NULL;
50c812b2
CM		 1997 mutex_unlock(&ipmidriver_mutex);
1998}
1999
5e59393e
JG		 2000static int create_files(struct bmc_device *bmc)
2001{
2002 int err;
2003
f0b55da0
CM		 2004 bmc->device_id_attr.attr.name = "device_id";
2005 bmc->device_id_attr.attr.owner = THIS_MODULE;
2006 bmc->device_id_attr.attr.mode = S_IRUGO;
2007 bmc->device_id_attr.show = device_id_show;
2008
2009 bmc->provides_dev_sdrs_attr.attr.name = "provides_device_sdrs";
2010 bmc->provides_dev_sdrs_attr.attr.owner = THIS_MODULE;
2011 bmc->provides_dev_sdrs_attr.attr.mode = S_IRUGO;
2012 bmc->provides_dev_sdrs_attr.show = provides_dev_sdrs_show;
2013
2014 bmc->revision_attr.attr.name = "revision";
2015 bmc->revision_attr.attr.owner = THIS_MODULE;
2016 bmc->revision_attr.attr.mode = S_IRUGO;
2017 bmc->revision_attr.show = revision_show;
2018
2019 bmc->firmware_rev_attr.attr.name = "firmware_revision";
2020 bmc->firmware_rev_attr.attr.owner = THIS_MODULE;
2021 bmc->firmware_rev_attr.attr.mode = S_IRUGO;
2022 bmc->firmware_rev_attr.show = firmware_rev_show;
2023
2024 bmc->version_attr.attr.name = "ipmi_version";
2025 bmc->version_attr.attr.owner = THIS_MODULE;
2026 bmc->version_attr.attr.mode = S_IRUGO;
2027 bmc->version_attr.show = ipmi_version_show;
2028
2029 bmc->add_dev_support_attr.attr.name = "additional_device_support";
2030 bmc->add_dev_support_attr.attr.owner = THIS_MODULE;
2031 bmc->add_dev_support_attr.attr.mode = S_IRUGO;
2032 bmc->add_dev_support_attr.show = add_dev_support_show;
2033
2034 bmc->manufacturer_id_attr.attr.name = "manufacturer_id";
2035 bmc->manufacturer_id_attr.attr.owner = THIS_MODULE;
2036 bmc->manufacturer_id_attr.attr.mode = S_IRUGO;
2037 bmc->manufacturer_id_attr.show = manufacturer_id_show;
2038
2039 bmc->product_id_attr.attr.name = "product_id";
2040 bmc->product_id_attr.attr.owner = THIS_MODULE;
2041 bmc->product_id_attr.attr.mode = S_IRUGO;
2042 bmc->product_id_attr.show = product_id_show;
2043
2044 bmc->guid_attr.attr.name = "guid";
2045 bmc->guid_attr.attr.owner = THIS_MODULE;
2046 bmc->guid_attr.attr.mode = S_IRUGO;
2047 bmc->guid_attr.show = guid_show;
2048
2049 bmc->aux_firmware_rev_attr.attr.name = "aux_firmware_revision";
2050 bmc->aux_firmware_rev_attr.attr.owner = THIS_MODULE;
2051 bmc->aux_firmware_rev_attr.attr.mode = S_IRUGO;
2052 bmc->aux_firmware_rev_attr.show = aux_firmware_rev_show;
2053
5e59393e
JG		 2054 err = device_create_file(&bmc->dev->dev,
2055 &bmc->device_id_attr);
2056 if (err) goto out;
2057 err = device_create_file(&bmc->dev->dev,
2058 &bmc->provides_dev_sdrs_attr);
2059 if (err) goto out_devid;
2060 err = device_create_file(&bmc->dev->dev,
2061 &bmc->revision_attr);
2062 if (err) goto out_sdrs;
2063 err = device_create_file(&bmc->dev->dev,
2064 &bmc->firmware_rev_attr);
2065 if (err) goto out_rev;
2066 err = device_create_file(&bmc->dev->dev,
2067 &bmc->version_attr);
2068 if (err) goto out_firm;
2069 err = device_create_file(&bmc->dev->dev,
2070 &bmc->add_dev_support_attr);
2071 if (err) goto out_version;
2072 err = device_create_file(&bmc->dev->dev,
2073 &bmc->manufacturer_id_attr);
2074 if (err) goto out_add_dev;
2075 err = device_create_file(&bmc->dev->dev,
2076 &bmc->product_id_attr);
2077 if (err) goto out_manu;
2078 if (bmc->id.aux_firmware_revision_set) {
2079 err = device_create_file(&bmc->dev->dev,
2080 &bmc->aux_firmware_rev_attr);
2081 if (err) goto out_prod_id;
2082 }
2083 if (bmc->guid_set) {
2084 err = device_create_file(&bmc->dev->dev,
2085 &bmc->guid_attr);
2086 if (err) goto out_aux_firm;
2087 }
2088
2089 return 0;
2090
2091out_aux_firm:
2092 if (bmc->id.aux_firmware_revision_set)
2093 device_remove_file(&bmc->dev->dev,
2094 &bmc->aux_firmware_rev_attr);
2095out_prod_id:
2096 device_remove_file(&bmc->dev->dev,
2097 &bmc->product_id_attr);
2098out_manu:
2099 device_remove_file(&bmc->dev->dev,
2100 &bmc->manufacturer_id_attr);
2101out_add_dev:
2102 device_remove_file(&bmc->dev->dev,
2103 &bmc->add_dev_support_attr);
2104out_version:
2105 device_remove_file(&bmc->dev->dev,
2106 &bmc->version_attr);
2107out_firm:
2108 device_remove_file(&bmc->dev->dev,
2109 &bmc->firmware_rev_attr);
2110out_rev:
2111 device_remove_file(&bmc->dev->dev,
2112 &bmc->revision_attr);
2113out_sdrs:
2114 device_remove_file(&bmc->dev->dev,
2115 &bmc->provides_dev_sdrs_attr);
2116out_devid:
2117 device_remove_file(&bmc->dev->dev,
2118 &bmc->device_id_attr);
2119out:
2120 return err;
2121}
2122
50c812b2
CM		 2123static int ipmi_bmc_register(ipmi_smi_t intf)
2124{
2125 int rv;
2126 struct bmc_device *bmc = intf->bmc;
2127 struct bmc_device *old_bmc;
2128 int size;
2129 char dummy[1];
2130
2131 mutex_lock(&ipmidriver_mutex);
2132
2133 /*
2134 * Try to find if there is an bmc_device struct
2135 * representing the interfaced BMC already
2136 */
2137 if (bmc->guid_set)
2138 old_bmc = ipmi_find_bmc_guid(&ipmidriver, bmc->guid);
2139 else
2140 old_bmc = ipmi_find_bmc_prod_dev_id(&ipmidriver,
2141 bmc->id.product_id,
2142 bmc->id.device_id);
2143
2144 /*
2145 * If there is already an bmc_device, free the new one,
2146 * otherwise register the new BMC device
2147 */
2148 if (old_bmc) {
2149 kfree(bmc);
2150 intf->bmc = old_bmc;
2151 bmc = old_bmc;
2152
2153 kref_get(&bmc->refcount);
2154 mutex_unlock(&ipmidriver_mutex);
2155
2156 printk(KERN_INFO
2157 "ipmi: interfacing existing BMC (man_id: 0x%6.6x,"
2158 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
2159 bmc->id.manufacturer_id,
2160 bmc->id.product_id,
2161 bmc->id.device_id);
2162 } else {
f0b55da0
CM		 2163 char name[14];
2164 unsigned char orig_dev_id = bmc->id.device_id;
2165 int warn_printed = 0;
2166
2167 snprintf(name, sizeof(name),
2168 "ipmi_bmc.%4.4x", bmc->id.product_id);
2169
2170 while (ipmi_find_bmc_prod_dev_id(&ipmidriver,
2171 bmc->id.product_id,
2172 bmc->id.device_id))
2173 {
2174 if (!warn_printed) {
2175 printk(KERN_WARNING PFX
2176 "This machine has two different BMCs"
2177 " with the same product id and device"
2178 " id. This is an error in the"
2179 " firmware, but incrementing the"
2180 " device id to work around the problem."
2181 " Prod ID = 0x%x, Dev ID = 0x%x\n",
2182 bmc->id.product_id, bmc->id.device_id);
2183 warn_printed = 1;
2184 }
2185 bmc->id.device_id++; /* Wraps at 255 */
2186 if (bmc->id.device_id == orig_dev_id) {
2187 printk(KERN_ERR PFX
2188 "Out of device ids!\n");
2189 break;
2190 }
2191 }
2192
2193 bmc->dev = platform_device_alloc(name, bmc->id.device_id);
8a3628d5 2194 if (!bmc->dev) {
f0b55da0 2195 mutex_unlock(&ipmidriver_mutex);
50c812b2
CM		 2196 printk(KERN_ERR
2197 "ipmi_msghandler:"
2198 " Unable to allocate platform device\n");
2199 return -ENOMEM;
2200 }
2201 bmc->dev->dev.driver = &ipmidriver;
2202 dev_set_drvdata(&bmc->dev->dev, bmc);
2203 kref_init(&bmc->refcount);
2204
b48f5457 2205 rv = platform_device_add(bmc->dev);
50c812b2
CM		 2206 mutex_unlock(&ipmidriver_mutex);
2207 if (rv) {
f0b55da0
CM		 2208 platform_device_put(bmc->dev);
2209 bmc->dev = NULL;
50c812b2
CM		 2210 printk(KERN_ERR
2211 "ipmi_msghandler:"
2212 " Unable to register bmc device: %d\n",
2213 rv);
2214 /* Don't go to out_err, you can only do that if
2215 the device is registered already. */
2216 return rv;
2217 }
2218
5e59393e
JG		 2219 rv = create_files(bmc);
2220 if (rv) {
2221 mutex_lock(&ipmidriver_mutex);
2222 platform_device_unregister(bmc->dev);
2223 mutex_unlock(&ipmidriver_mutex);
2224
2225 return rv;
2226 }
50c812b2
CM		 2227
2228 printk(KERN_INFO
2229 "ipmi: Found new BMC (man_id: 0x%6.6x, "
2230 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
2231 bmc->id.manufacturer_id,
2232 bmc->id.product_id,
2233 bmc->id.device_id);
2234 }
2235
2236 /*
2237 * create symlink from system interface device to bmc device
2238 * and back.
2239 */
2240 rv = sysfs_create_link(&intf->si_dev->kobj,
2241 &bmc->dev->dev.kobj, "bmc");
2242 if (rv) {
2243 printk(KERN_ERR
2244 "ipmi_msghandler: Unable to create bmc symlink: %d\n",
2245 rv);
2246 goto out_err;
2247 }
2248
2249 size = snprintf(dummy, 0, "ipmi%d", intf->intf_num);
2250 intf->my_dev_name = kmalloc(size+1, GFP_KERNEL);
2251 if (!intf->my_dev_name) {
2252 rv = -ENOMEM;
2253 printk(KERN_ERR
2254 "ipmi_msghandler: allocate link from BMC: %d\n",
2255 rv);
2256 goto out_err;
2257 }
2258 snprintf(intf->my_dev_name, size+1, "ipmi%d", intf->intf_num);
2259
2260 rv = sysfs_create_link(&bmc->dev->dev.kobj, &intf->si_dev->kobj,
2261 intf->my_dev_name);
2262 if (rv) {
2263 kfree(intf->my_dev_name);
2264 intf->my_dev_name = NULL;
2265 printk(KERN_ERR
2266 "ipmi_msghandler:"
2267 " Unable to create symlink to bmc: %d\n",
2268 rv);
2269 goto out_err;
2270 }
2271
2272 return 0;
2273
2274out_err:
2275 ipmi_bmc_unregister(intf);
2276 return rv;
2277}
2278
2279static int
2280send_guid_cmd(ipmi_smi_t intf, int chan)
2281{
2282 struct kernel_ipmi_msg msg;
2283 struct ipmi_system_interface_addr si;
2284
2285 si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2286 si.channel = IPMI_BMC_CHANNEL;
2287 si.lun = 0;
2288
2289 msg.netfn = IPMI_NETFN_APP_REQUEST;
2290 msg.cmd = IPMI_GET_DEVICE_GUID_CMD;
2291 msg.data = NULL;
2292 msg.data_len = 0;
2293 return i_ipmi_request(NULL,
2294 intf,
2295 (struct ipmi_addr *) &si,
2296 0,
2297 &msg,
2298 intf,
2299 NULL,
2300 NULL,
2301 0,
2302 intf->channels[0].address,
2303 intf->channels[0].lun,
2304 -1, 0);
2305}
2306
2307static void
2308guid_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
2309{
2310 if ((msg->addr.addr_type != IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
2311 || (msg->msg.netfn != IPMI_NETFN_APP_RESPONSE)
2312 || (msg->msg.cmd != IPMI_GET_DEVICE_GUID_CMD))
2313 /* Not for me */
2314 return;
2315
2316 if (msg->msg.data[0] != 0) {
2317 /* Error from getting the GUID, the BMC doesn't have one. */
2318 intf->bmc->guid_set = 0;
2319 goto out;
2320 }
2321
2322 if (msg->msg.data_len < 17) {
2323 intf->bmc->guid_set = 0;
2324 printk(KERN_WARNING PFX
2325 "guid_handler: The GUID response from the BMC was too"
2326 " short, it was %d but should have been 17. Assuming"
2327 " GUID is not available.\n",
2328 msg->msg.data_len);
2329 goto out;
2330 }
2331
2332 memcpy(intf->bmc->guid, msg->msg.data, 16);
2333 intf->bmc->guid_set = 1;
2334 out:
2335 wake_up(&intf->waitq);
2336}
2337
2338static void
2339get_guid(ipmi_smi_t intf)
2340{
2341 int rv;
2342
2343 intf->bmc->guid_set = 0x2;
2344 intf->null_user_handler = guid_handler;
2345 rv = send_guid_cmd(intf, 0);
2346 if (rv)
2347 /* Send failed, no GUID available. */
2348 intf->bmc->guid_set = 0;
2349 wait_event(intf->waitq, intf->bmc->guid_set != 2);
2350 intf->null_user_handler = NULL;
2351}
2352
1da177e4
LT		 2353static int
2354send_channel_info_cmd(ipmi_smi_t intf, int chan)
2355{
2356 struct kernel_ipmi_msg msg;
2357 unsigned char data[1];
2358 struct ipmi_system_interface_addr si;
2359
2360 si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2361 si.channel = IPMI_BMC_CHANNEL;
2362 si.lun = 0;
2363
2364 msg.netfn = IPMI_NETFN_APP_REQUEST;
2365 msg.cmd = IPMI_GET_CHANNEL_INFO_CMD;
2366 msg.data = data;
2367 msg.data_len = 1;
2368 data[0] = chan;
2369 return i_ipmi_request(NULL,
2370 intf,
2371 (struct ipmi_addr *) &si,
2372 0,
2373 &msg,
56a55ec6 2374 intf,
1da177e4
LT		 2375 NULL,
2376 NULL,
2377 0,
c14979b9
CM		 2378 intf->channels[0].address,
2379 intf->channels[0].lun,
1da177e4
LT		 2380 -1, 0);
2381}
2382
2383static void
56a55ec6 2384channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
1da177e4
LT		 2385{
2386 int rv = 0;
2387 int chan;
2388
56a55ec6
CM		 2389 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
2390 && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
2391 && (msg->msg.cmd == IPMI_GET_CHANNEL_INFO_CMD))
1da177e4
LT		 2392 {
2393 /* It's the one we want */
56a55ec6 2394 if (msg->msg.data[0] != 0) {
1da177e4
LT		 2395 /* Got an error from the channel, just go on. */
2396
56a55ec6 2397 if (msg->msg.data[0] == IPMI_INVALID_COMMAND_ERR) {
1da177e4
LT		 2398 /* If the MC does not support this
2399 command, that is legal. We just
2400 assume it has one IPMB at channel
2401 zero. */
2402 intf->channels[0].medium
2403 = IPMI_CHANNEL_MEDIUM_IPMB;
2404 intf->channels[0].protocol
2405 = IPMI_CHANNEL_PROTOCOL_IPMB;
2406 rv = -ENOSYS;
2407
2408 intf->curr_channel = IPMI_MAX_CHANNELS;
2409 wake_up(&intf->waitq);
2410 goto out;
2411 }
2412 goto next_channel;
2413 }
56a55ec6 2414 if (msg->msg.data_len < 4) {
1da177e4
LT		 2415 /* Message not big enough, just go on. */
2416 goto next_channel;
2417 }
2418 chan = intf->curr_channel;
56a55ec6
CM		 2419 intf->channels[chan].medium = msg->msg.data[2] & 0x7f;
2420 intf->channels[chan].protocol = msg->msg.data[3] & 0x1f;
1da177e4
LT		 2421
2422 next_channel:
2423 intf->curr_channel++;
2424 if (intf->curr_channel >= IPMI_MAX_CHANNELS)
2425 wake_up(&intf->waitq);
2426 else
2427 rv = send_channel_info_cmd(intf, intf->curr_channel);
2428
2429 if (rv) {
2430 /* Got an error somehow, just give up. */
2431 intf->curr_channel = IPMI_MAX_CHANNELS;
2432 wake_up(&intf->waitq);
2433
2434 printk(KERN_WARNING PFX
2435 "Error sending channel information: %d\n",
2436 rv);
2437 }
2438 }
2439 out:
2440 return;
2441}
2442
2443int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
2444 void *send_info,
50c812b2
CM		 2445 struct ipmi_device_id *device_id,
2446 struct device *si_dev,
453823ba 2447 unsigned char slave_addr)
1da177e4
LT		 2448{
2449 int i, j;
2450 int rv;
393d2cc3 2451 ipmi_smi_t intf;
1da177e4 2452 unsigned long flags;
50c812b2
CM		 2453 int version_major;
2454 int version_minor;
1da177e4 2455
50c812b2
CM		 2456 version_major = ipmi_version_major(device_id);
2457 version_minor = ipmi_version_minor(device_id);
1da177e4
LT		 2458
2459 /* Make sure the driver is actually initialized, this handles
2460 problems with initialization order. */
2461 if (!initialized) {
2462 rv = ipmi_init_msghandler();
2463 if (rv)
2464 return rv;
2465 /* The init code doesn't return an error if it was turned
2466 off, but it won't initialize. Check that. */
2467 if (!initialized)
2468 return -ENODEV;
2469 }
2470
393d2cc3
CM		 2471 intf = kmalloc(sizeof(*intf), GFP_KERNEL);
2472 if (!intf)
1da177e4 2473 return -ENOMEM;
393d2cc3 2474 memset(intf, 0, sizeof(*intf));
50c812b2
CM		 2475 intf->bmc = kzalloc(sizeof(*intf->bmc), GFP_KERNEL);
2476 if (!intf->bmc) {
2477 kfree(intf);
2478 return -ENOMEM;
2479 }
393d2cc3
CM		 2480 intf->intf_num = -1;
2481 kref_init(&intf->refcount);
50c812b2
CM		 2482 intf->bmc->id = *device_id;
2483 intf->si_dev = si_dev;
393d2cc3
CM		 2484 for (j = 0; j < IPMI_MAX_CHANNELS; j++) {
2485 intf->channels[j].address = IPMI_BMC_SLAVE_ADDR;
2486 intf->channels[j].lun = 2;
2487 }
2488 if (slave_addr != 0)
2489 intf->channels[0].address = slave_addr;
2490 INIT_LIST_HEAD(&intf->users);
2491 intf->handlers = handlers;
2492 intf->send_info = send_info;
2493 spin_lock_init(&intf->seq_lock);
2494 for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++) {
2495 intf->seq_table[j].inuse = 0;
2496 intf->seq_table[j].seqid = 0;
2497 }
2498 intf->curr_seq = 0;
2499#ifdef CONFIG_PROC_FS
2500 spin_lock_init(&intf->proc_entry_lock);
2501#endif
2502 spin_lock_init(&intf->waiting_msgs_lock);
2503 INIT_LIST_HEAD(&intf->waiting_msgs);
2504 spin_lock_init(&intf->events_lock);
2505 INIT_LIST_HEAD(&intf->waiting_events);
2506 intf->waiting_events_count = 0;
d6dfd131 2507 mutex_init(&intf->cmd_rcvrs_mutex);
393d2cc3
CM		 2508 INIT_LIST_HEAD(&intf->cmd_rcvrs);
2509 init_waitqueue_head(&intf->waitq);
2510
2511 spin_lock_init(&intf->counter_lock);
2512 intf->proc_dir = NULL;
1da177e4
LT		 2513
2514 rv = -ENOMEM;
393d2cc3 2515 spin_lock_irqsave(&interfaces_lock, flags);
e8b33617 2516 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4 2517 if (ipmi_interfaces[i] == NULL) {
393d2cc3
CM		 2518 intf->intf_num = i;
2519 /* Reserve the entry till we are done. */
2520 ipmi_interfaces[i] = IPMI_INVALID_INTERFACE_ENTRY;
1da177e4 2521 rv = 0;
1da177e4
LT		 2522 break;
2523 }
2524 }
393d2cc3
CM		 2525 spin_unlock_irqrestore(&interfaces_lock, flags);
2526 if (rv)
2527 goto out;
1da177e4 2528
453823ba
CM		 2529 rv = handlers->start_processing(send_info, intf);
2530 if (rv)
2531 goto out;
1da177e4 2532
50c812b2
CM		 2533 get_guid(intf);
2534
393d2cc3
CM		 2535 if ((version_major > 1)
2536 || ((version_major == 1) && (version_minor >= 5)))
2537 {
2538 /* Start scanning the channels to see what is
2539 available. */
2540 intf->null_user_handler = channel_handler;
2541 intf->curr_channel = 0;
2542 rv = send_channel_info_cmd(intf, 0);
2543 if (rv)
2544 goto out;
1da177e4 2545
393d2cc3
CM		 2546 /* Wait for the channel info to be read. */
2547 wait_event(intf->waitq,
2548 intf->curr_channel >= IPMI_MAX_CHANNELS);
50c812b2 2549 intf->null_user_handler = NULL;
393d2cc3
CM		 2550 } else {
2551 /* Assume a single IPMB channel at zero. */
2552 intf->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB;
2553 intf->channels[0].protocol = IPMI_CHANNEL_PROTOCOL_IPMB;
1da177e4
LT		 2554 }
2555
393d2cc3
CM		 2556 if (rv == 0)
2557 rv = add_proc_entries(intf, i);
1da177e4 2558
50c812b2
CM		 2559 rv = ipmi_bmc_register(intf);
2560
393d2cc3 2561 out:
1da177e4 2562 if (rv) {
393d2cc3
CM		 2563 if (intf->proc_dir)
2564 remove_proc_entries(intf);
2565 kref_put(&intf->refcount, intf_free);
2566 if (i < MAX_IPMI_INTERFACES) {
2567 spin_lock_irqsave(&interfaces_lock, flags);
2568 ipmi_interfaces[i] = NULL;
2569 spin_unlock_irqrestore(&interfaces_lock, flags);
2570 }
2571 } else {
2572 spin_lock_irqsave(&interfaces_lock, flags);
2573 ipmi_interfaces[i] = intf;
2574 spin_unlock_irqrestore(&interfaces_lock, flags);
50c812b2 2575 call_smi_watchers(i, intf->si_dev);
1da177e4
LT		 2576 }
2577
2578 return rv;
2579}
2580
1da177e4
LT		 2581int ipmi_unregister_smi(ipmi_smi_t intf)
2582{
1da177e4
LT		 2583 int i;
2584 struct ipmi_smi_watcher *w;
2585 unsigned long flags;
2586
50c812b2
CM		 2587 ipmi_bmc_unregister(intf);
2588
393d2cc3
CM		 2589 spin_lock_irqsave(&interfaces_lock, flags);
2590 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
2591 if (ipmi_interfaces[i] == intf) {
2592 /* Set the interface number reserved until we
2593 * are done. */
2594 ipmi_interfaces[i] = IPMI_INVALID_INTERFACE_ENTRY;
2595 intf->intf_num = -1;
2596 break;
1da177e4 2597 }
1da177e4 2598 }
393d2cc3 2599 spin_unlock_irqrestore(&interfaces_lock,flags);
1da177e4 2600
393d2cc3
CM		 2601 if (i == MAX_IPMI_INTERFACES)
2602 return -ENODEV;
1da177e4 2603
393d2cc3 2604 remove_proc_entries(intf);
1da177e4
LT		 2605
2606 /* Call all the watcher interfaces to tell them that
2607 an interface is gone. */
2608 down_read(&smi_watchers_sem);
393d2cc3 2609 list_for_each_entry(w, &smi_watchers, link)
1da177e4 2610 w->smi_gone(i);
1da177e4 2611 up_read(&smi_watchers_sem);
393d2cc3
CM		 2612
2613 /* Allow the entry to be reused now. */
2614 spin_lock_irqsave(&interfaces_lock, flags);
2615 ipmi_interfaces[i] = NULL;
2616 spin_unlock_irqrestore(&interfaces_lock,flags);
2617
2618 kref_put(&intf->refcount, intf_free);
1da177e4
LT		 2619 return 0;
2620}
2621
2622static int handle_ipmb_get_msg_rsp(ipmi_smi_t intf,
2623 struct ipmi_smi_msg *msg)
2624{
2625 struct ipmi_ipmb_addr ipmb_addr;
2626 struct ipmi_recv_msg *recv_msg;
2627 unsigned long flags;
2628
2629
2630 /* This is 11, not 10, because the response must contain a
2631 * completion code. */
2632 if (msg->rsp_size < 11) {
2633 /* Message not big enough, just ignore it. */
2634 spin_lock_irqsave(&intf->counter_lock, flags);
2635 intf->invalid_ipmb_responses++;
2636 spin_unlock_irqrestore(&intf->counter_lock, flags);
2637 return 0;
2638 }
2639
2640 if (msg->rsp[2] != 0) {
2641 /* An error getting the response, just ignore it. */
2642 return 0;
2643 }
2644
2645 ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE;
2646 ipmb_addr.slave_addr = msg->rsp[6];
2647 ipmb_addr.channel = msg->rsp[3] & 0x0f;
2648 ipmb_addr.lun = msg->rsp[7] & 3;
2649
2650 /* It's a response from a remote entity. Look up the sequence
2651 number and handle the response. */
2652 if (intf_find_seq(intf,
2653 msg->rsp[7] >> 2,
2654 msg->rsp[3] & 0x0f,
2655 msg->rsp[8],
2656 (msg->rsp[4] >> 2) & (~1),
2657 (struct ipmi_addr *) &(ipmb_addr),
2658 &recv_msg))
2659 {
2660 /* We were unable to find the sequence number,
2661 so just nuke the message. */
2662 spin_lock_irqsave(&intf->counter_lock, flags);
2663 intf->unhandled_ipmb_responses++;
2664 spin_unlock_irqrestore(&intf->counter_lock, flags);
2665 return 0;
2666 }
2667
2668 memcpy(recv_msg->msg_data,
2669 &(msg->rsp[9]),
2670 msg->rsp_size - 9);
2671 /* THe other fields matched, so no need to set them, except
2672 for netfn, which needs to be the response that was
2673 returned, not the request value. */
2674 recv_msg->msg.netfn = msg->rsp[4] >> 2;
2675 recv_msg->msg.data = recv_msg->msg_data;
2676 recv_msg->msg.data_len = msg->rsp_size - 10;
2677 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
2678 spin_lock_irqsave(&intf->counter_lock, flags);
2679 intf->handled_ipmb_responses++;
2680 spin_unlock_irqrestore(&intf->counter_lock, flags);
2681 deliver_response(recv_msg);
2682
2683 return 0;
2684}
2685
2686static int handle_ipmb_get_msg_cmd(ipmi_smi_t intf,
2687 struct ipmi_smi_msg *msg)
2688{
393d2cc3
CM		 2689 struct cmd_rcvr *rcvr;
2690 int rv = 0;
2691 unsigned char netfn;
2692 unsigned char cmd;
c69c3127 2693 unsigned char chan;
393d2cc3
CM		 2694 ipmi_user_t user = NULL;
2695 struct ipmi_ipmb_addr *ipmb_addr;
2696 struct ipmi_recv_msg *recv_msg;
2697 unsigned long flags;
1da177e4
LT		 2698
2699 if (msg->rsp_size < 10) {
2700 /* Message not big enough, just ignore it. */
2701 spin_lock_irqsave(&intf->counter_lock, flags);
2702 intf->invalid_commands++;
2703 spin_unlock_irqrestore(&intf->counter_lock, flags);
2704 return 0;
2705 }
2706
2707 if (msg->rsp[2] != 0) {
2708 /* An error getting the response, just ignore it. */
2709 return 0;
2710 }
2711
2712 netfn = msg->rsp[4] >> 2;
2713 cmd = msg->rsp[8];
c69c3127 2714 chan = msg->rsp[3] & 0xf;
1da177e4 2715
e61fb5b6 2716 rcu_read_lock();
c69c3127 2717 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
393d2cc3
CM		 2718 if (rcvr) {
2719 user = rcvr->user;
2720 kref_get(&user->refcount);
2721 } else
2722 user = NULL;
e61fb5b6 2723 rcu_read_unlock();
1da177e4
LT		 2724
2725 if (user == NULL) {
2726 /* We didn't find a user, deliver an error response. */
2727 spin_lock_irqsave(&intf->counter_lock, flags);
2728 intf->unhandled_commands++;
2729 spin_unlock_irqrestore(&intf->counter_lock, flags);
2730
2731 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
2732 msg->data[1] = IPMI_SEND_MSG_CMD;
2733 msg->data[2] = msg->rsp[3];
2734 msg->data[3] = msg->rsp[6];
2735 msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3);
2736 msg->data[5] = ipmb_checksum(&(msg->data[3]), 2);
c14979b9 2737 msg->data[6] = intf->channels[msg->rsp[3] & 0xf].address;
1da177e4
LT		 2738 /* rqseq/lun */
2739 msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3);
2740 msg->data[8] = msg->rsp[8]; /* cmd */
2741 msg->data[9] = IPMI_INVALID_CMD_COMPLETION_CODE;
2742 msg->data[10] = ipmb_checksum(&(msg->data[6]), 4);
2743 msg->data_size = 11;
2744
2745#ifdef DEBUG_MSGING
2746 {
2747 int m;
2748 printk("Invalid command:");
e8b33617 2749 for (m = 0; m < msg->data_size; m++)
1da177e4
LT		 2750 printk(" %2.2x", msg->data[m]);
2751 printk("\n");
2752 }
2753#endif
2754 intf->handlers->sender(intf->send_info, msg, 0);
2755
2756 rv = -1; /* We used the message, so return the value that
2757 causes it to not be freed or queued. */
2758 } else {
2759 /* Deliver the message to the user. */
2760 spin_lock_irqsave(&intf->counter_lock, flags);
2761 intf->handled_commands++;
2762 spin_unlock_irqrestore(&intf->counter_lock, flags);
2763
2764 recv_msg = ipmi_alloc_recv_msg();
8a3628d5 2765 if (!recv_msg) {
1da177e4
LT		 2766 /* We couldn't allocate memory for the
2767 message, so requeue it for handling
2768 later. */
2769 rv = 1;
393d2cc3 2770 kref_put(&user->refcount, free_user);
1da177e4
LT		 2771 } else {
2772 /* Extract the source address from the data. */
2773 ipmb_addr = (struct ipmi_ipmb_addr *) &recv_msg->addr;
2774 ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE;
2775 ipmb_addr->slave_addr = msg->rsp[6];
2776 ipmb_addr->lun = msg->rsp[7] & 3;
2777 ipmb_addr->channel = msg->rsp[3] & 0xf;
2778
2779 /* Extract the rest of the message information
2780 from the IPMB header.*/
2781 recv_msg->user = user;
2782 recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
2783 recv_msg->msgid = msg->rsp[7] >> 2;
2784 recv_msg->msg.netfn = msg->rsp[4] >> 2;
2785 recv_msg->msg.cmd = msg->rsp[8];
2786 recv_msg->msg.data = recv_msg->msg_data;
2787
2788 /* We chop off 10, not 9 bytes because the checksum
2789 at the end also needs to be removed. */
2790 recv_msg->msg.data_len = msg->rsp_size - 10;
2791 memcpy(recv_msg->msg_data,
2792 &(msg->rsp[9]),
2793 msg->rsp_size - 10);
2794 deliver_response(recv_msg);
2795 }
2796 }
2797
2798 return rv;
2799}
2800
2801static int handle_lan_get_msg_rsp(ipmi_smi_t intf,
2802 struct ipmi_smi_msg *msg)
2803{
2804 struct ipmi_lan_addr lan_addr;
2805 struct ipmi_recv_msg *recv_msg;
2806 unsigned long flags;
2807
2808
2809 /* This is 13, not 12, because the response must contain a
2810 * completion code. */
2811 if (msg->rsp_size < 13) {
2812 /* Message not big enough, just ignore it. */
2813 spin_lock_irqsave(&intf->counter_lock, flags);
2814 intf->invalid_lan_responses++;
2815 spin_unlock_irqrestore(&intf->counter_lock, flags);
2816 return 0;
2817 }
2818
2819 if (msg->rsp[2] != 0) {
2820 /* An error getting the response, just ignore it. */
2821 return 0;
2822 }
2823
2824 lan_addr.addr_type = IPMI_LAN_ADDR_TYPE;
2825 lan_addr.session_handle = msg->rsp[4];
2826 lan_addr.remote_SWID = msg->rsp[8];
2827 lan_addr.local_SWID = msg->rsp[5];
2828 lan_addr.channel = msg->rsp[3] & 0x0f;
2829 lan_addr.privilege = msg->rsp[3] >> 4;
2830 lan_addr.lun = msg->rsp[9] & 3;
2831
2832 /* It's a response from a remote entity. Look up the sequence
2833 number and handle the response. */
2834 if (intf_find_seq(intf,
2835 msg->rsp[9] >> 2,
2836 msg->rsp[3] & 0x0f,
2837 msg->rsp[10],
2838 (msg->rsp[6] >> 2) & (~1),
2839 (struct ipmi_addr *) &(lan_addr),
2840 &recv_msg))
2841 {
2842 /* We were unable to find the sequence number,
2843 so just nuke the message. */
2844 spin_lock_irqsave(&intf->counter_lock, flags);
2845 intf->unhandled_lan_responses++;
2846 spin_unlock_irqrestore(&intf->counter_lock, flags);
2847 return 0;
2848 }
2849
2850 memcpy(recv_msg->msg_data,
2851 &(msg->rsp[11]),
2852 msg->rsp_size - 11);
2853 /* The other fields matched, so no need to set them, except
2854 for netfn, which needs to be the response that was
2855 returned, not the request value. */
2856 recv_msg->msg.netfn = msg->rsp[6] >> 2;
2857 recv_msg->msg.data = recv_msg->msg_data;
2858 recv_msg->msg.data_len = msg->rsp_size - 12;
2859 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
2860 spin_lock_irqsave(&intf->counter_lock, flags);
2861 intf->handled_lan_responses++;
2862 spin_unlock_irqrestore(&intf->counter_lock, flags);
2863 deliver_response(recv_msg);
2864
2865 return 0;
2866}
2867
2868static int handle_lan_get_msg_cmd(ipmi_smi_t intf,
2869 struct ipmi_smi_msg *msg)
2870{
393d2cc3
CM		 2871 struct cmd_rcvr *rcvr;
2872 int rv = 0;
2873 unsigned char netfn;
2874 unsigned char cmd;
c69c3127 2875 unsigned char chan;
393d2cc3
CM		 2876 ipmi_user_t user = NULL;
2877 struct ipmi_lan_addr *lan_addr;
2878 struct ipmi_recv_msg *recv_msg;
2879 unsigned long flags;
1da177e4
LT		 2880
2881 if (msg->rsp_size < 12) {
2882 /* Message not big enough, just ignore it. */
2883 spin_lock_irqsave(&intf->counter_lock, flags);
2884 intf->invalid_commands++;
2885 spin_unlock_irqrestore(&intf->counter_lock, flags);
2886 return 0;
2887 }
2888
2889 if (msg->rsp[2] != 0) {
2890 /* An error getting the response, just ignore it. */
2891 return 0;
2892 }
2893
2894 netfn = msg->rsp[6] >> 2;
2895 cmd = msg->rsp[10];
c69c3127 2896 chan = msg->rsp[3] & 0xf;
1da177e4 2897
e61fb5b6 2898 rcu_read_lock();
c69c3127 2899 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
393d2cc3
CM		 2900 if (rcvr) {
2901 user = rcvr->user;
2902 kref_get(&user->refcount);
2903 } else
2904 user = NULL;
e61fb5b6 2905 rcu_read_unlock();
1da177e4
LT		 2906
2907 if (user == NULL) {
393d2cc3 2908 /* We didn't find a user, just give up. */
1da177e4
LT		 2909 spin_lock_irqsave(&intf->counter_lock, flags);
2910 intf->unhandled_commands++;
2911 spin_unlock_irqrestore(&intf->counter_lock, flags);
2912
2913 rv = 0; /* Don't do anything with these messages, just
2914 allow them to be freed. */
2915 } else {
2916 /* Deliver the message to the user. */
2917 spin_lock_irqsave(&intf->counter_lock, flags);
2918 intf->handled_commands++;
2919 spin_unlock_irqrestore(&intf->counter_lock, flags);
2920
2921 recv_msg = ipmi_alloc_recv_msg();
8a3628d5 2922 if (!recv_msg) {
1da177e4
LT		 2923 /* We couldn't allocate memory for the
2924 message, so requeue it for handling
2925 later. */
2926 rv = 1;
393d2cc3 2927 kref_put(&user->refcount, free_user);
1da177e4
LT		 2928 } else {
2929 /* Extract the source address from the data. */
2930 lan_addr = (struct ipmi_lan_addr *) &recv_msg->addr;
2931 lan_addr->addr_type = IPMI_LAN_ADDR_TYPE;
2932 lan_addr->session_handle = msg->rsp[4];
2933 lan_addr->remote_SWID = msg->rsp[8];
2934 lan_addr->local_SWID = msg->rsp[5];
2935 lan_addr->lun = msg->rsp[9] & 3;
2936 lan_addr->channel = msg->rsp[3] & 0xf;
2937 lan_addr->privilege = msg->rsp[3] >> 4;
2938
2939 /* Extract the rest of the message information
2940 from the IPMB header.*/
2941 recv_msg->user = user;
2942 recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
2943 recv_msg->msgid = msg->rsp[9] >> 2;
2944 recv_msg->msg.netfn = msg->rsp[6] >> 2;
2945 recv_msg->msg.cmd = msg->rsp[10];
2946 recv_msg->msg.data = recv_msg->msg_data;
2947
2948 /* We chop off 12, not 11 bytes because the checksum
2949 at the end also needs to be removed. */
2950 recv_msg->msg.data_len = msg->rsp_size - 12;
2951 memcpy(recv_msg->msg_data,
2952 &(msg->rsp[11]),
2953 msg->rsp_size - 12);
2954 deliver_response(recv_msg);
2955 }
2956 }
2957
2958 return rv;
2959}
2960
2961static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg,
2962 struct ipmi_smi_msg *msg)
2963{
2964 struct ipmi_system_interface_addr *smi_addr;
2965
2966 recv_msg->msgid = 0;
2967 smi_addr = (struct ipmi_system_interface_addr *) &(recv_msg->addr);
2968 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
2969 smi_addr->channel = IPMI_BMC_CHANNEL;
2970 smi_addr->lun = msg->rsp[0] & 3;
2971 recv_msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE;
2972 recv_msg->msg.netfn = msg->rsp[0] >> 2;
2973 recv_msg->msg.cmd = msg->rsp[1];
2974 memcpy(recv_msg->msg_data, &(msg->rsp[3]), msg->rsp_size - 3);
2975 recv_msg->msg.data = recv_msg->msg_data;
2976 recv_msg->msg.data_len = msg->rsp_size - 3;
2977}
2978
1da177e4
LT		 2979static int handle_read_event_rsp(ipmi_smi_t intf,
2980 struct ipmi_smi_msg *msg)
2981{
2982 struct ipmi_recv_msg *recv_msg, *recv_msg2;
2983 struct list_head msgs;
2984 ipmi_user_t user;
2985 int rv = 0;
2986 int deliver_count = 0;
2987 unsigned long flags;
2988
2989 if (msg->rsp_size < 19) {
2990 /* Message is too small to be an IPMB event. */
2991 spin_lock_irqsave(&intf->counter_lock, flags);
2992 intf->invalid_events++;
2993 spin_unlock_irqrestore(&intf->counter_lock, flags);
2994 return 0;
2995 }
2996
2997 if (msg->rsp[2] != 0) {
2998 /* An error getting the event, just ignore it. */
2999 return 0;
3000 }
3001
3002 INIT_LIST_HEAD(&msgs);
3003
393d2cc3 3004 spin_lock_irqsave(&intf->events_lock, flags);
1da177e4
LT		 3005
3006 spin_lock(&intf->counter_lock);
3007 intf->events++;
3008 spin_unlock(&intf->counter_lock);
3009
3010 /* Allocate and fill in one message for every user that is getting
3011 events. */
393d2cc3
CM		 3012 rcu_read_lock();
3013 list_for_each_entry_rcu(user, &intf->users, link) {
8a3628d5 3014 if (!user->gets_events)
1da177e4
LT		 3015 continue;
3016
3017 recv_msg = ipmi_alloc_recv_msg();
8a3628d5 3018 if (!recv_msg) {
393d2cc3 3019 rcu_read_unlock();
8a3628d5
CM		 3020 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs,
3021 link) {
1da177e4
LT		 3022 list_del(&recv_msg->link);
3023 ipmi_free_recv_msg(recv_msg);
3024 }
3025 /* We couldn't allocate memory for the
3026 message, so requeue it for handling
3027 later. */
3028 rv = 1;
3029 goto out;
3030 }
3031
3032 deliver_count++;
3033
3034 copy_event_into_recv_msg(recv_msg, msg);
3035 recv_msg->user = user;
393d2cc3 3036 kref_get(&user->refcount);
1da177e4
LT		 3037 list_add_tail(&(recv_msg->link), &msgs);
3038 }
393d2cc3 3039 rcu_read_unlock();
1da177e4
LT		 3040
3041 if (deliver_count) {
3042 /* Now deliver all the messages. */
3043 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs, link) {
3044 list_del(&recv_msg->link);
3045 deliver_response(recv_msg);
3046 }
3047 } else if (intf->waiting_events_count < MAX_EVENTS_IN_QUEUE) {
3048 /* No one to receive the message, put it in queue if there's
3049 not already too many things in the queue. */
3050 recv_msg = ipmi_alloc_recv_msg();
8a3628d5 3051 if (!recv_msg) {
1da177e4
LT		 3052 /* We couldn't allocate memory for the
3053 message, so requeue it for handling
3054 later. */
3055 rv = 1;
3056 goto out;
3057 }
3058
3059 copy_event_into_recv_msg(recv_msg, msg);
3060 list_add_tail(&(recv_msg->link), &(intf->waiting_events));
4791c03d 3061 intf->waiting_events_count++;
1da177e4
LT		 3062 } else {
3063 /* There's too many things in the queue, discard this
3064 message. */
3065 printk(KERN_WARNING PFX "Event queue full, discarding an"
3066 " incoming event\n");
3067 }
3068
3069 out:
3070 spin_unlock_irqrestore(&(intf->events_lock), flags);
3071
3072 return rv;
3073}
3074
3075static int handle_bmc_rsp(ipmi_smi_t intf,
3076 struct ipmi_smi_msg *msg)
3077{
3078 struct ipmi_recv_msg *recv_msg;
1da177e4 3079 unsigned long flags;
393d2cc3 3080 struct ipmi_user *user;
1da177e4
LT		 3081
3082 recv_msg = (struct ipmi_recv_msg *) msg->user_data;
56a55ec6
CM		 3083 if (recv_msg == NULL)
3084 {
3085 printk(KERN_WARNING"IPMI message received with no owner. This\n"
3086 "could be because of a malformed message, or\n"
3087 "because of a hardware error. Contact your\n"
3088 "hardware vender for assistance\n");
3089 return 0;
3090 }
1da177e4 3091
393d2cc3 3092 user = recv_msg->user;
1da177e4 3093 /* Make sure the user still exists. */
393d2cc3 3094 if (user && !user->valid) {
56a55ec6
CM		 3095 /* The user for the message went away, so give up. */
3096 spin_lock_irqsave(&intf->counter_lock, flags);
3097 intf->unhandled_local_responses++;
3098 spin_unlock_irqrestore(&intf->counter_lock, flags);
1da177e4
LT		 3099 ipmi_free_recv_msg(recv_msg);
3100 } else {
3101 struct ipmi_system_interface_addr *smi_addr;
3102
3103 spin_lock_irqsave(&intf->counter_lock, flags);
3104 intf->handled_local_responses++;
3105 spin_unlock_irqrestore(&intf->counter_lock, flags);
3106 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
3107 recv_msg->msgid = msg->msgid;
3108 smi_addr = ((struct ipmi_system_interface_addr *)
3109 &(recv_msg->addr));
3110 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
3111 smi_addr->channel = IPMI_BMC_CHANNEL;
3112 smi_addr->lun = msg->rsp[0] & 3;
3113 recv_msg->msg.netfn = msg->rsp[0] >> 2;
3114 recv_msg->msg.cmd = msg->rsp[1];
3115 memcpy(recv_msg->msg_data,
3116 &(msg->rsp[2]),
3117 msg->rsp_size - 2);
3118 recv_msg->msg.data = recv_msg->msg_data;
3119 recv_msg->msg.data_len = msg->rsp_size - 2;
3120 deliver_response(recv_msg);
3121 }
3122
3123 return 0;
3124}
3125
3126/* Handle a new message. Return 1 if the message should be requeued,
3127 0 if the message should be freed, or -1 if the message should not
3128 be freed or requeued. */
3129static int handle_new_recv_msg(ipmi_smi_t intf,
3130 struct ipmi_smi_msg *msg)
3131{
3132 int requeue;
3133 int chan;
3134
3135#ifdef DEBUG_MSGING
3136 int m;
3137 printk("Recv:");
e8b33617 3138 for (m = 0; m < msg->rsp_size; m++)
1da177e4
LT		 3139 printk(" %2.2x", msg->rsp[m]);
3140 printk("\n");
3141#endif
3142 if (msg->rsp_size < 2) {
3143 /* Message is too small to be correct. */
3144 printk(KERN_WARNING PFX "BMC returned to small a message"
3145 " for netfn %x cmd %x, got %d bytes\n",
3146 (msg->data[0] >> 2) | 1, msg->data[1], msg->rsp_size);
3147
3148 /* Generate an error response for the message. */
3149 msg->rsp[0] = msg->data[0] | (1 << 2);
3150 msg->rsp[1] = msg->data[1];
3151 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
3152 msg->rsp_size = 3;
3153 } else if (((msg->rsp[0] >> 2) != ((msg->data[0] >> 2) | 1))/* Netfn */
3154 || (msg->rsp[1] != msg->data[1])) /* Command */
3155 {
3156 /* The response is not even marginally correct. */
3157 printk(KERN_WARNING PFX "BMC returned incorrect response,"
3158 " expected netfn %x cmd %x, got netfn %x cmd %x\n",
3159 (msg->data[0] >> 2) | 1, msg->data[1],
3160 msg->rsp[0] >> 2, msg->rsp[1]);
3161
3162 /* Generate an error response for the message. */
3163 msg->rsp[0] = msg->data[0] | (1 << 2);
3164 msg->rsp[1] = msg->data[1];
3165 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
3166 msg->rsp_size = 3;
3167 }
3168
3169 if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
3170 && (msg->rsp[1] == IPMI_SEND_MSG_CMD)
3171 && (msg->user_data != NULL))
3172 {
3173 /* It's a response to a response we sent. For this we
3174 deliver a send message response to the user. */
393d2cc3 3175 struct ipmi_recv_msg *recv_msg = msg->user_data;
1da177e4
LT		 3176
3177 requeue = 0;
3178 if (msg->rsp_size < 2)
3179 /* Message is too small to be correct. */
3180 goto out;
3181
3182 chan = msg->data[2] & 0x0f;
3183 if (chan >= IPMI_MAX_CHANNELS)
3184 /* Invalid channel number */
3185 goto out;
3186
393d2cc3
CM		 3187 if (!recv_msg)
3188 goto out;
3189
3190 /* Make sure the user still exists. */
3191 if (!recv_msg->user || !recv_msg->user->valid)
3192 goto out;
3193
3194 recv_msg->recv_type = IPMI_RESPONSE_RESPONSE_TYPE;
3195 recv_msg->msg.data = recv_msg->msg_data;
3196 recv_msg->msg.data_len = 1;
3197 recv_msg->msg_data[0] = msg->rsp[2];
3198 deliver_response(recv_msg);
1da177e4
LT		 3199 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
3200 && (msg->rsp[1] == IPMI_GET_MSG_CMD))
3201 {
3202 /* It's from the receive queue. */
3203 chan = msg->rsp[3] & 0xf;
3204 if (chan >= IPMI_MAX_CHANNELS) {
3205 /* Invalid channel number */
3206 requeue = 0;
3207 goto out;
3208 }
3209
3210 switch (intf->channels[chan].medium) {
3211 case IPMI_CHANNEL_MEDIUM_IPMB:
3212 if (msg->rsp[4] & 0x04) {
3213 /* It's a response, so find the
3214 requesting message and send it up. */
3215 requeue = handle_ipmb_get_msg_rsp(intf, msg);
3216 } else {
3217 /* It's a command to the SMS from some other
3218 entity. Handle that. */
3219 requeue = handle_ipmb_get_msg_cmd(intf, msg);
3220 }
3221 break;
3222
3223 case IPMI_CHANNEL_MEDIUM_8023LAN:
3224 case IPMI_CHANNEL_MEDIUM_ASYNC:
3225 if (msg->rsp[6] & 0x04) {
3226 /* It's a response, so find the
3227 requesting message and send it up. */
3228 requeue = handle_lan_get_msg_rsp(intf, msg);
3229 } else {
3230 /* It's a command to the SMS from some other
3231 entity. Handle that. */
3232 requeue = handle_lan_get_msg_cmd(intf, msg);
3233 }
3234 break;
3235
3236 default:
3237 /* We don't handle the channel type, so just
3238 * free the message. */
3239 requeue = 0;
3240 }
3241
3242 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
3243 && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD))
3244 {
3245 /* It's an asyncronous event. */
3246 requeue = handle_read_event_rsp(intf, msg);
3247 } else {
3248 /* It's a response from the local BMC. */
3249 requeue = handle_bmc_rsp(intf, msg);
3250 }
3251
3252 out:
3253 return requeue;
3254}
3255
3256/* Handle a new message from the lower layer. */
3257void ipmi_smi_msg_received(ipmi_smi_t intf,
3258 struct ipmi_smi_msg *msg)
3259{
3260 unsigned long flags;
3261 int rv;
3262
3263
1da177e4
LT		 3264 if ((msg->data_size >= 2)
3265 && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))
3266 && (msg->data[1] == IPMI_SEND_MSG_CMD)
393d2cc3
CM		 3267 && (msg->user_data == NULL))
3268 {
1da177e4
LT		 3269 /* This is the local response to a command send, start
3270 the timer for these. The user_data will not be
3271 NULL if this is a response send, and we will let
3272 response sends just go through. */
3273
3274 /* Check for errors, if we get certain errors (ones
3275 that mean basically we can try again later), we
3276 ignore them and start the timer. Otherwise we
3277 report the error immediately. */
3278 if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)
3279 && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)
46d52b09
CM		 3280 && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR)
3281 && (msg->rsp[2] != IPMI_BUS_ERR)
3282 && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR))
1da177e4
LT		 3283 {
3284 int chan = msg->rsp[3] & 0xf;
3285
3286 /* Got an error sending the message, handle it. */
3287 spin_lock_irqsave(&intf->counter_lock, flags);
3288 if (chan >= IPMI_MAX_CHANNELS)
3289 ; /* This shouldn't happen */
3290 else if ((intf->channels[chan].medium
3291 == IPMI_CHANNEL_MEDIUM_8023LAN)
3292 || (intf->channels[chan].medium
3293 == IPMI_CHANNEL_MEDIUM_ASYNC))
3294 intf->sent_lan_command_errs++;
3295 else
3296 intf->sent_ipmb_command_errs++;
3297 spin_unlock_irqrestore(&intf->counter_lock, flags);
3298 intf_err_seq(intf, msg->msgid, msg->rsp[2]);
3299 } else {
3300 /* The message was sent, start the timer. */
3301 intf_start_seq_timer(intf, msg->msgid);
3302 }
3303
3304 ipmi_free_smi_msg(msg);
393d2cc3 3305 goto out;
1da177e4
LT		 3306 }
3307
3308 /* To preserve message order, if the list is not empty, we
3309 tack this message onto the end of the list. */
393d2cc3
CM		 3310 spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
3311 if (!list_empty(&intf->waiting_msgs)) {
3312 list_add_tail(&msg->link, &intf->waiting_msgs);
177294d1 3313 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
393d2cc3 3314 goto out;
1da177e4 3315 }
393d2cc3 3316 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
1da177e4
LT		 3317
3318 rv = handle_new_recv_msg(intf, msg);
3319 if (rv > 0) {
3320 /* Could not handle the message now, just add it to a
3321 list to handle later. */
177294d1 3322 spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
393d2cc3 3323 list_add_tail(&msg->link, &intf->waiting_msgs);
177294d1 3324 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
1da177e4
LT		 3325 } else if (rv == 0) {
3326 ipmi_free_smi_msg(msg);
3327 }
3328
393d2cc3
CM		 3329 out:
3330 return;
1da177e4
LT		 3331}
3332
3333void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
3334{
3335 ipmi_user_t user;
3336
393d2cc3
CM		 3337 rcu_read_lock();
3338 list_for_each_entry_rcu(user, &intf->users, link) {
8a3628d5 3339 if (!user->handler->ipmi_watchdog_pretimeout)
1da177e4
LT		 3340 continue;
3341
3342 user->handler->ipmi_watchdog_pretimeout(user->handler_data);
3343 }
393d2cc3 3344 rcu_read_unlock();
1da177e4
LT		 3345}
3346
3347static void
3348handle_msg_timeout(struct ipmi_recv_msg *msg)
3349{
3350 msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
3351 msg->msg_data[0] = IPMI_TIMEOUT_COMPLETION_CODE;
3352 msg->msg.netfn |= 1; /* Convert to a response. */
3353 msg->msg.data_len = 1;
3354 msg->msg.data = msg->msg_data;
3355 deliver_response(msg);
3356}
3357
882fe011
CM		 3358static struct ipmi_smi_msg *
3359smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
3360 unsigned char seq, long seqid)
1da177e4 3361{
882fe011 3362 struct ipmi_smi_msg *smi_msg = ipmi_alloc_smi_msg();
1da177e4
LT		 3363 if (!smi_msg)
3364 /* If we can't allocate the message, then just return, we
3365 get 4 retries, so this should be ok. */
882fe011 3366 return NULL;
1da177e4
LT		 3367
3368 memcpy(smi_msg->data, recv_msg->msg.data, recv_msg->msg.data_len);
3369 smi_msg->data_size = recv_msg->msg.data_len;
3370 smi_msg->msgid = STORE_SEQ_IN_MSGID(seq, seqid);
3371
1da177e4
LT		 3372#ifdef DEBUG_MSGING
3373 {
3374 int m;
3375 printk("Resend: ");
e8b33617 3376 for (m = 0; m < smi_msg->data_size; m++)
1da177e4
LT		 3377 printk(" %2.2x", smi_msg->data[m]);
3378 printk("\n");
3379 }
3380#endif
882fe011 3381 return smi_msg;
1da177e4
LT		 3382}
3383
393d2cc3
CM		 3384static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
3385 struct list_head *timeouts, long timeout_period,
3386 int slot, unsigned long *flags)
3387{
3388 struct ipmi_recv_msg *msg;
3389
3390 if (!ent->inuse)
3391 return;
3392
3393 ent->timeout -= timeout_period;
3394 if (ent->timeout > 0)
3395 return;
3396
3397 if (ent->retries_left == 0) {
3398 /* The message has used all its retries. */
3399 ent->inuse = 0;
3400 msg = ent->recv_msg;
3401 list_add_tail(&msg->link, timeouts);
3402 spin_lock(&intf->counter_lock);
3403 if (ent->broadcast)
3404 intf->timed_out_ipmb_broadcasts++;
3405 else if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE)
3406 intf->timed_out_lan_commands++;
3407 else
3408 intf->timed_out_ipmb_commands++;
3409 spin_unlock(&intf->counter_lock);
3410 } else {
3411 struct ipmi_smi_msg *smi_msg;
3412 /* More retries, send again. */
3413
3414 /* Start with the max timer, set to normal
3415 timer after the message is sent. */
3416 ent->timeout = MAX_MSG_TIMEOUT;
3417 ent->retries_left--;
3418 spin_lock(&intf->counter_lock);
3419 if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE)
3420 intf->retransmitted_lan_commands++;
3421 else
3422 intf->retransmitted_ipmb_commands++;
3423 spin_unlock(&intf->counter_lock);
3424
3425 smi_msg = smi_from_recv_msg(intf, ent->recv_msg, slot,
3426 ent->seqid);
8a3628d5 3427 if (!smi_msg)
393d2cc3
CM		 3428 return;
3429
3430 spin_unlock_irqrestore(&intf->seq_lock, *flags);
3431 /* Send the new message. We send with a zero
3432 * priority. It timed out, I doubt time is
3433 * that critical now, and high priority
3434 * messages are really only for messages to the
3435 * local MC, which don't get resent. */
3436 intf->handlers->sender(intf->send_info,
3437 smi_msg, 0);
3438 spin_lock_irqsave(&intf->seq_lock, *flags);
3439 }
3440}
3441
3442static void ipmi_timeout_handler(long timeout_period)
1da177e4
LT		 3443{
3444 ipmi_smi_t intf;
3445 struct list_head timeouts;
3446 struct ipmi_recv_msg *msg, *msg2;
3447 struct ipmi_smi_msg *smi_msg, *smi_msg2;
3448 unsigned long flags;
3449 int i, j;
3450
3451 INIT_LIST_HEAD(&timeouts);
3452
3453 spin_lock(&interfaces_lock);
e8b33617 3454 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4 3455 intf = ipmi_interfaces[i];
393d2cc3 3456 if (IPMI_INVALID_INTERFACE(intf))
1da177e4 3457 continue;
393d2cc3
CM		 3458 kref_get(&intf->refcount);
3459 spin_unlock(&interfaces_lock);
1da177e4
LT		 3460
3461 /* See if any waiting messages need to be processed. */
393d2cc3 3462 spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
8a3628d5
CM		 3463 list_for_each_entry_safe(smi_msg, smi_msg2,
3464 &intf->waiting_msgs, link) {
3465 if (!handle_new_recv_msg(intf, smi_msg)) {
1da177e4
LT		 3466 list_del(&smi_msg->link);
3467 ipmi_free_smi_msg(smi_msg);
3468 } else {
3469 /* To preserve message order, quit if we
3470 can't handle a message. */
3471 break;
3472 }
3473 }
393d2cc3 3474 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
1da177e4
LT		 3475
3476 /* Go through the seq table and find any messages that
3477 have timed out, putting them in the timeouts
3478 list. */
393d2cc3
CM		 3479 spin_lock_irqsave(&intf->seq_lock, flags);
3480 for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++)
3481 check_msg_timeout(intf, &(intf->seq_table[j]),
3482 &timeouts, timeout_period, j,
3483 &flags);
3484 spin_unlock_irqrestore(&intf->seq_lock, flags);
3485
3486 list_for_each_entry_safe(msg, msg2, &timeouts, link)
1da177e4 3487 handle_msg_timeout(msg);
1da177e4 3488
393d2cc3
CM		 3489 kref_put(&intf->refcount, intf_free);
3490 spin_lock(&interfaces_lock);
1da177e4
LT		 3491 }
3492 spin_unlock(&interfaces_lock);
3493}
3494
3495static void ipmi_request_event(void)
3496{
3497 ipmi_smi_t intf;
3498 int i;
3499
3500 spin_lock(&interfaces_lock);
e8b33617 3501 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4 3502 intf = ipmi_interfaces[i];
393d2cc3 3503 if (IPMI_INVALID_INTERFACE(intf))
1da177e4
LT		 3504 continue;
3505
3506 intf->handlers->request_events(intf->send_info);
3507 }
3508 spin_unlock(&interfaces_lock);
3509}
3510
3511static struct timer_list ipmi_timer;
3512
3513/* Call every ~100 ms. */
3514#define IPMI_TIMEOUT_TIME 100
3515
3516/* How many jiffies does it take to get to the timeout time. */
3517#define IPMI_TIMEOUT_JIFFIES ((IPMI_TIMEOUT_TIME * HZ) / 1000)
3518
3519/* Request events from the queue every second (this is the number of
3520 IPMI_TIMEOUT_TIMES between event requests). Hopefully, in the
3521 future, IPMI will add a way to know immediately if an event is in
3522 the queue and this silliness can go away. */
3523#define IPMI_REQUEST_EV_TIME (1000 / (IPMI_TIMEOUT_TIME))
3524
8f43f84f 3525static atomic_t stop_operation;
1da177e4
LT		 3526static unsigned int ticks_to_req_ev = IPMI_REQUEST_EV_TIME;
3527
3528static void ipmi_timeout(unsigned long data)
3529{
8f43f84f 3530 if (atomic_read(&stop_operation))
1da177e4 3531 return;
1da177e4
LT		 3532
3533 ticks_to_req_ev--;
3534 if (ticks_to_req_ev == 0) {
3535 ipmi_request_event();
3536 ticks_to_req_ev = IPMI_REQUEST_EV_TIME;
3537 }
3538
3539 ipmi_timeout_handler(IPMI_TIMEOUT_TIME);
3540
8f43f84f 3541 mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);
1da177e4
LT		 3542}
3543
3544
3545static atomic_t smi_msg_inuse_count = ATOMIC_INIT(0);
3546static atomic_t recv_msg_inuse_count = ATOMIC_INIT(0);
3547
3548/* FIXME - convert these to slabs. */
3549static void free_smi_msg(struct ipmi_smi_msg *msg)
3550{
3551 atomic_dec(&smi_msg_inuse_count);
3552 kfree(msg);
3553}
3554
3555struct ipmi_smi_msg *ipmi_alloc_smi_msg(void)
3556{
3557 struct ipmi_smi_msg *rv;
3558 rv = kmalloc(sizeof(struct ipmi_smi_msg), GFP_ATOMIC);
3559 if (rv) {
3560 rv->done = free_smi_msg;
3561 rv->user_data = NULL;
3562 atomic_inc(&smi_msg_inuse_count);
3563 }
3564 return rv;
3565}
3566
3567static void free_recv_msg(struct ipmi_recv_msg *msg)
3568{
3569 atomic_dec(&recv_msg_inuse_count);
3570 kfree(msg);
3571}
3572
3573struct ipmi_recv_msg *ipmi_alloc_recv_msg(void)
3574{
3575 struct ipmi_recv_msg *rv;
3576
3577 rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC);
3578 if (rv) {
a9eec556 3579 rv->user = NULL;
1da177e4
LT		 3580 rv->done = free_recv_msg;
3581 atomic_inc(&recv_msg_inuse_count);
3582 }
3583 return rv;
3584}
3585
393d2cc3
CM		 3586void ipmi_free_recv_msg(struct ipmi_recv_msg *msg)
3587{
3588 if (msg->user)
3589 kref_put(&msg->user->refcount, free_user);
3590 msg->done(msg);
3591}
3592
1da177e4
LT		 3593#ifdef CONFIG_IPMI_PANIC_EVENT
3594
3595static void dummy_smi_done_handler(struct ipmi_smi_msg *msg)
3596{
3597}
3598
3599static void dummy_recv_done_handler(struct ipmi_recv_msg *msg)
3600{
3601}
3602
3603#ifdef CONFIG_IPMI_PANIC_STRING
56a55ec6 3604static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
1da177e4 3605{
56a55ec6
CM		 3606 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
3607 && (msg->msg.netfn == IPMI_NETFN_SENSOR_EVENT_RESPONSE)
3608 && (msg->msg.cmd == IPMI_GET_EVENT_RECEIVER_CMD)
3609 && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
1da177e4
LT		 3610 {
3611 /* A get event receiver command, save it. */
56a55ec6
CM		 3612 intf->event_receiver = msg->msg.data[1];
3613 intf->event_receiver_lun = msg->msg.data[2] & 0x3;
1da177e4
LT		 3614 }
3615}
3616
56a55ec6 3617static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
1da177e4 3618{
56a55ec6
CM		 3619 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
3620 && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
3621 && (msg->msg.cmd == IPMI_GET_DEVICE_ID_CMD)
3622 && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
1da177e4
LT		 3623 {
3624 /* A get device id command, save if we are an event
3625 receiver or generator. */
56a55ec6
CM		 3626 intf->local_sel_device = (msg->msg.data[6] >> 2) & 1;
3627 intf->local_event_generator = (msg->msg.data[6] >> 5) & 1;
1da177e4
LT		 3628 }
3629}
3630#endif
3631
3632static void send_panic_events(char *str)
3633{
3634 struct kernel_ipmi_msg msg;
3635 ipmi_smi_t intf;
3636 unsigned char data[16];
3637 int i;
3638 struct ipmi_system_interface_addr *si;
3639 struct ipmi_addr addr;
3640 struct ipmi_smi_msg smi_msg;
3641 struct ipmi_recv_msg recv_msg;
3642
3643 si = (struct ipmi_system_interface_addr *) &addr;
3644 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
3645 si->channel = IPMI_BMC_CHANNEL;
3646 si->lun = 0;
3647
3648 /* Fill in an event telling that we have failed. */
3649 msg.netfn = 0x04; /* Sensor or Event. */
3650 msg.cmd = 2; /* Platform event command. */
3651 msg.data = data;
3652 msg.data_len = 8;
cda315ab 3653 data[0] = 0x41; /* Kernel generator ID, IPMI table 5-4 */
1da177e4
LT		 3654 data[1] = 0x03; /* This is for IPMI 1.0. */
3655 data[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */
3656 data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */
3657 data[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */
3658
3659 /* Put a few breadcrumbs in. Hopefully later we can add more things
3660 to make the panic events more useful. */
3661 if (str) {
3662 data[3] = str[0];
3663 data[6] = str[1];
3664 data[7] = str[2];
3665 }
3666
3667 smi_msg.done = dummy_smi_done_handler;
3668 recv_msg.done = dummy_recv_done_handler;
3669
3670 /* For every registered interface, send the event. */
e8b33617 3671 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4 3672 intf = ipmi_interfaces[i];
393d2cc3 3673 if (IPMI_INVALID_INTERFACE(intf))
1da177e4
LT		 3674 continue;
3675
3676 /* Send the event announcing the panic. */
3677 intf->handlers->set_run_to_completion(intf->send_info, 1);
3678 i_ipmi_request(NULL,
3679 intf,
3680 &addr,
3681 0,
3682 &msg,
56a55ec6 3683 intf,
1da177e4
LT		 3684 &smi_msg,
3685 &recv_msg,
3686 0,
c14979b9
CM		 3687 intf->channels[0].address,
3688 intf->channels[0].lun,
1da177e4
LT		 3689 0, 1); /* Don't retry, and don't wait. */
3690 }
3691
3692#ifdef CONFIG_IPMI_PANIC_STRING
3693 /* On every interface, dump a bunch of OEM event holding the
3694 string. */
3695 if (!str)
3696 return;
3697
e8b33617 3698 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4
LT		 3699 char *p = str;
3700 struct ipmi_ipmb_addr *ipmb;
3701 int j;
3702
3703 intf = ipmi_interfaces[i];
393d2cc3 3704 if (IPMI_INVALID_INTERFACE(intf))
1da177e4
LT		 3705 continue;
3706
3707 /* First job here is to figure out where to send the
3708 OEM events. There's no way in IPMI to send OEM
3709 events using an event send command, so we have to
3710 find the SEL to put them in and stick them in
3711 there. */
3712
3713 /* Get capabilities from the get device id. */
3714 intf->local_sel_device = 0;
3715 intf->local_event_generator = 0;
3716 intf->event_receiver = 0;
3717
3718 /* Request the device info from the local MC. */
3719 msg.netfn = IPMI_NETFN_APP_REQUEST;
3720 msg.cmd = IPMI_GET_DEVICE_ID_CMD;
3721 msg.data = NULL;
3722 msg.data_len = 0;
3723 intf->null_user_handler = device_id_fetcher;
3724 i_ipmi_request(NULL,
3725 intf,
3726 &addr,
3727 0,
3728 &msg,
56a55ec6 3729 intf,
1da177e4
LT		 3730 &smi_msg,
3731 &recv_msg,
3732 0,
c14979b9
CM		 3733 intf->channels[0].address,
3734 intf->channels[0].lun,
1da177e4
LT		 3735 0, 1); /* Don't retry, and don't wait. */
3736
3737 if (intf->local_event_generator) {
3738 /* Request the event receiver from the local MC. */
3739 msg.netfn = IPMI_NETFN_SENSOR_EVENT_REQUEST;
3740 msg.cmd = IPMI_GET_EVENT_RECEIVER_CMD;
3741 msg.data = NULL;
3742 msg.data_len = 0;
3743 intf->null_user_handler = event_receiver_fetcher;
3744 i_ipmi_request(NULL,
3745 intf,
3746 &addr,
3747 0,
3748 &msg,
56a55ec6 3749 intf,
1da177e4
LT		 3750 &smi_msg,
3751 &recv_msg,
3752 0,
c14979b9
CM		 3753 intf->channels[0].address,
3754 intf->channels[0].lun,
1da177e4
LT		 3755 0, 1); /* no retry, and no wait. */
3756 }
3757 intf->null_user_handler = NULL;
3758
3759 /* Validate the event receiver. The low bit must not
3760 be 1 (it must be a valid IPMB address), it cannot
3761 be zero, and it must not be my address. */
3762 if (((intf->event_receiver & 1) == 0)
3763 && (intf->event_receiver != 0)
c14979b9 3764 && (intf->event_receiver != intf->channels[0].address))
1da177e4
LT		 3765 {
3766 /* The event receiver is valid, send an IPMB
3767 message. */
3768 ipmb = (struct ipmi_ipmb_addr *) &addr;
3769 ipmb->addr_type = IPMI_IPMB_ADDR_TYPE;
3770 ipmb->channel = 0; /* FIXME - is this right? */
3771 ipmb->lun = intf->event_receiver_lun;
3772 ipmb->slave_addr = intf->event_receiver;
3773 } else if (intf->local_sel_device) {
3774 /* The event receiver was not valid (or was
3775 me), but I am an SEL device, just dump it
3776 in my SEL. */
3777 si = (struct ipmi_system_interface_addr *) &addr;
3778 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
3779 si->channel = IPMI_BMC_CHANNEL;
3780 si->lun = 0;
3781 } else
3782 continue; /* No where to send the event. */
3783
3784
3785 msg.netfn = IPMI_NETFN_STORAGE_REQUEST; /* Storage. */
3786 msg.cmd = IPMI_ADD_SEL_ENTRY_CMD;
3787 msg.data = data;
3788 msg.data_len = 16;
3789
3790 j = 0;
3791 while (*p) {
3792 int size = strlen(p);
3793
3794 if (size > 11)
3795 size = 11;
3796 data[0] = 0;
3797 data[1] = 0;
3798 data[2] = 0xf0; /* OEM event without timestamp. */
c14979b9 3799 data[3] = intf->channels[0].address;
1da177e4
LT		 3800 data[4] = j++; /* sequence # */
3801 /* Always give 11 bytes, so strncpy will fill
3802 it with zeroes for me. */
3803 strncpy(data+5, p, 11);
3804 p += size;
3805
3806 i_ipmi_request(NULL,
3807 intf,
3808 &addr,
3809 0,
3810 &msg,
56a55ec6 3811 intf,
1da177e4
LT		 3812 &smi_msg,
3813 &recv_msg,
3814 0,
c14979b9
CM		 3815 intf->channels[0].address,
3816 intf->channels[0].lun,
1da177e4
LT		 3817 0, 1); /* no retry, and no wait. */
3818 }
3819 }
3820#endif /* CONFIG_IPMI_PANIC_STRING */
3821}
3822#endif /* CONFIG_IPMI_PANIC_EVENT */
3823
f18190bd 3824static int has_panicked = 0;
1da177e4
LT		 3825
3826static int panic_event(struct notifier_block *this,
3827 unsigned long event,
3828 void *ptr)
3829{
3830 int i;
3831 ipmi_smi_t intf;
3832
f18190bd 3833 if (has_panicked)
1da177e4 3834 return NOTIFY_DONE;
f18190bd 3835 has_panicked = 1;
1da177e4
LT		 3836
3837 /* For every registered interface, set it to run to completion. */
e8b33617 3838 for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
1da177e4 3839 intf = ipmi_interfaces[i];
393d2cc3 3840 if (IPMI_INVALID_INTERFACE(intf))
1da177e4
LT		 3841 continue;
3842
3843 intf->handlers->set_run_to_completion(intf->send_info, 1);
3844 }
3845
3846#ifdef CONFIG_IPMI_PANIC_EVENT
3847 send_panic_events(ptr);
3848#endif
3849
3850 return NOTIFY_DONE;
3851}
3852
3853static struct notifier_block panic_block = {
3854 .notifier_call = panic_event,
3855 .next = NULL,
3856 .priority = 200 /* priority: INT_MAX >= x >= 0 */
3857};
3858
3859static int ipmi_init_msghandler(void)
3860{
3861 int i;
50c812b2 3862 int rv;
1da177e4
LT		 3863
3864 if (initialized)
3865 return 0;
3866
50c812b2
CM		 3867 rv = driver_register(&ipmidriver);
3868 if (rv) {
3869 printk(KERN_ERR PFX "Could not register IPMI driver\n");
3870 return rv;
3871 }
3872
1da177e4 3873 printk(KERN_INFO "ipmi message handler version "
1fdd75bd 3874 IPMI_DRIVER_VERSION "\n");
1da177e4 3875
393d2cc3 3876 for (i = 0; i < MAX_IPMI_INTERFACES; i++)
1da177e4 3877 ipmi_interfaces[i] = NULL;
1da177e4 3878
3b625943 3879#ifdef CONFIG_PROC_FS
1da177e4
LT		 3880 proc_ipmi_root = proc_mkdir("ipmi", NULL);
3881 if (!proc_ipmi_root) {
3882 printk(KERN_ERR PFX "Unable to create IPMI proc dir");
3883 return -ENOMEM;
3884 }
3885
3886 proc_ipmi_root->owner = THIS_MODULE;
3b625943 3887#endif /* CONFIG_PROC_FS */
1da177e4 3888
409035e0
CM		 3889 setup_timer(&ipmi_timer, ipmi_timeout, 0);
3890 mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);
1da177e4 3891
e041c683 3892 atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
1da177e4
LT		 3893
3894 initialized = 1;
3895
3896 return 0;
3897}
3898
3899static __init int ipmi_init_msghandler_mod(void)
3900{
3901 ipmi_init_msghandler();
3902 return 0;
3903}
3904
3905static __exit void cleanup_ipmi(void)
3906{
3907 int count;
3908
3909 if (!initialized)
3910 return;
3911
e041c683 3912 atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
1da177e4
LT		 3913
3914 /* This can't be called if any interfaces exist, so no worry about
3915 shutting down the interfaces. */
3916
3917 /* Tell the timer to stop, then wait for it to stop. This avoids
3918 problems with race conditions removing the timer here. */
8f43f84f
CM		 3919 atomic_inc(&stop_operation);
3920 del_timer_sync(&ipmi_timer);
1da177e4 3921
3b625943 3922#ifdef CONFIG_PROC_FS
1da177e4 3923 remove_proc_entry(proc_ipmi_root->name, &proc_root);
3b625943 3924#endif /* CONFIG_PROC_FS */
1da177e4 3925
50c812b2
CM		 3926 driver_unregister(&ipmidriver);
3927
1da177e4
LT		 3928 initialized = 0;
3929
3930 /* Check for buffer leaks. */
3931 count = atomic_read(&smi_msg_inuse_count);
3932 if (count != 0)
3933 printk(KERN_WARNING PFX "SMI message count %d at exit\n",
3934 count);
3935 count = atomic_read(&recv_msg_inuse_count);
3936 if (count != 0)
3937 printk(KERN_WARNING PFX "recv message count %d at exit\n",
3938 count);
3939}
3940module_exit(cleanup_ipmi);
3941
3942module_init(ipmi_init_msghandler_mod);
3943MODULE_LICENSE("GPL");
1fdd75bd
CM		 3944MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3945MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI interface.");
3946MODULE_VERSION(IPMI_DRIVER_VERSION);
1da177e4
LT		 3947
3948EXPORT_SYMBOL(ipmi_create_user);
3949EXPORT_SYMBOL(ipmi_destroy_user);
3950EXPORT_SYMBOL(ipmi_get_version);
3951EXPORT_SYMBOL(ipmi_request_settime);
3952EXPORT_SYMBOL(ipmi_request_supply_msgs);
3953EXPORT_SYMBOL(ipmi_register_smi);
3954EXPORT_SYMBOL(ipmi_unregister_smi);
3955EXPORT_SYMBOL(ipmi_register_for_cmd);
3956EXPORT_SYMBOL(ipmi_unregister_for_cmd);
3957EXPORT_SYMBOL(ipmi_smi_msg_received);
3958EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout);
3959EXPORT_SYMBOL(ipmi_alloc_smi_msg);
3960EXPORT_SYMBOL(ipmi_addr_length);
3961EXPORT_SYMBOL(ipmi_validate_addr);
3962EXPORT_SYMBOL(ipmi_set_gets_events);
3963EXPORT_SYMBOL(ipmi_smi_watcher_register);
3964EXPORT_SYMBOL(ipmi_smi_watcher_unregister);
3965EXPORT_SYMBOL(ipmi_set_my_address);
3966EXPORT_SYMBOL(ipmi_get_my_address);
3967EXPORT_SYMBOL(ipmi_set_my_LUN);
3968EXPORT_SYMBOL(ipmi_get_my_LUN);
3969EXPORT_SYMBOL(ipmi_smi_add_proc_entry);
3970EXPORT_SYMBOL(ipmi_user_set_run_to_completion);
393d2cc3 3971EXPORT_SYMBOL(ipmi_free_recv_msg);
Linux kernel - Deliverables
This page took 0.43607 seconds and 5 git commands to generate.