err.no Git - linux-2.6/blob - drivers/char/ipmi/ipmi_msghandler.c

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