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