ipmi_si_intf.c 67.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
/*
 * ipmi_si.c
 *
 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
 * BT).
 *
 * Author: MontaVista Software, Inc.
 *         Corey Minyard <minyard@mvista.com>
 *         source@mvista.com
 *
 * Copyright 2002 MontaVista Software Inc.
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 *
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * This file holds the "policy" for the interface to the SMI state
 * machine.  It does the configuration, handles timers and interrupts,
 * and drives the real SMI state machine.
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <asm/system.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/errno.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/ioport.h>
53
#include <linux/notifier.h>
54
#include <linux/mutex.h>
M
Matt Domsch 已提交
55
#include <linux/kthread.h>
L
Linus Torvalds 已提交
56 57 58 59 60 61 62
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <linux/rcupdate.h>
#include <linux/ipmi_smi.h>
#include <asm/io.h>
#include "ipmi_si_sm.h"
#include <linux/init.h>
63
#include <linux/dmi.h>
L
Linus Torvalds 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

/* Measure times between events in the driver. */
#undef DEBUG_TIMING

/* Call every 10 ms. */
#define SI_TIMEOUT_TIME_USEC	10000
#define SI_USEC_PER_JIFFY	(1000000/HZ)
#define SI_TIMEOUT_JIFFIES	(SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
#define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
                                       short timeout */

enum si_intf_state {
	SI_NORMAL,
	SI_GETTING_FLAGS,
	SI_GETTING_EVENTS,
	SI_CLEARING_FLAGS,
	SI_CLEARING_FLAGS_THEN_SET_IRQ,
	SI_GETTING_MESSAGES,
	SI_ENABLE_INTERRUPTS1,
	SI_ENABLE_INTERRUPTS2
	/* FIXME - add watchdog stuff. */
};

87 88 89 90 91
/* Some BT-specific defines we need here. */
#define IPMI_BT_INTMASK_REG		2
#define IPMI_BT_INTMASK_CLEAR_IRQ_BIT	2
#define IPMI_BT_INTMASK_ENABLE_IRQ_BIT	1

L
Linus Torvalds 已提交
92 93 94
enum si_type {
    SI_KCS, SI_SMIC, SI_BT
};
95
static char *si_to_str[] = { "KCS", "SMIC", "BT" };
L
Linus Torvalds 已提交
96

97 98 99 100 101 102 103
#define DEVICE_NAME "ipmi_si"

static struct device_driver ipmi_driver =
{
	.name = DEVICE_NAME,
	.bus = &platform_bus_type
};
104

L
Linus Torvalds 已提交
105 106
struct smi_info
{
C
Corey Minyard 已提交
107
	int                    intf_num;
L
Linus Torvalds 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	ipmi_smi_t             intf;
	struct si_sm_data      *si_sm;
	struct si_sm_handlers  *handlers;
	enum si_type           si_type;
	spinlock_t             si_lock;
	spinlock_t             msg_lock;
	struct list_head       xmit_msgs;
	struct list_head       hp_xmit_msgs;
	struct ipmi_smi_msg    *curr_msg;
	enum si_intf_state     si_state;

	/* Used to handle the various types of I/O that can occur with
           IPMI */
	struct si_sm_io io;
	int (*io_setup)(struct smi_info *info);
	void (*io_cleanup)(struct smi_info *info);
	int (*irq_setup)(struct smi_info *info);
	void (*irq_cleanup)(struct smi_info *info);
	unsigned int io_size;
127 128 129
	char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
	void (*addr_source_cleanup)(struct smi_info *info);
	void *addr_source_data;
L
Linus Torvalds 已提交
130

131 132 133 134 135 136
	/* Per-OEM handler, called from handle_flags().
	   Returns 1 when handle_flags() needs to be re-run
	   or 0 indicating it set si_state itself.
	*/
	int (*oem_data_avail_handler)(struct smi_info *smi_info);

L
Linus Torvalds 已提交
137 138 139 140 141 142
	/* Flags from the last GET_MSG_FLAGS command, used when an ATTN
	   is set to hold the flags until we are done handling everything
	   from the flags. */
#define RECEIVE_MSG_AVAIL	0x01
#define EVENT_MSG_BUFFER_FULL	0x02
#define WDT_PRE_TIMEOUT_INT	0x08
143 144 145 146 147 148
#define OEM0_DATA_AVAIL     0x20
#define OEM1_DATA_AVAIL     0x40
#define OEM2_DATA_AVAIL     0x80
#define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
                             OEM1_DATA_AVAIL | \
                             OEM2_DATA_AVAIL)
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	unsigned char       msg_flags;

	/* If set to true, this will request events the next time the
	   state machine is idle. */
	atomic_t            req_events;

	/* If true, run the state machine to completion on every send
	   call.  Generally used after a panic to make sure stuff goes
	   out. */
	int                 run_to_completion;

	/* The I/O port of an SI interface. */
	int                 port;

	/* The space between start addresses of the two ports.  For
	   instance, if the first port is 0xca2 and the spacing is 4, then
	   the second port is 0xca6. */
	unsigned int        spacing;

	/* zero if no irq; */
	int                 irq;

	/* The timer for this si. */
	struct timer_list   si_timer;

	/* The time (in jiffies) the last timeout occurred at. */
	unsigned long       last_timeout_jiffies;

	/* Used to gracefully stop the timer without race conditions. */
C
Corey Minyard 已提交
178
	atomic_t            stop_operation;
L
Linus Torvalds 已提交
179 180 181 182 183 184 185

	/* The driver will disable interrupts when it gets into a
	   situation where it cannot handle messages due to lack of
	   memory.  Once that situation clears up, it will re-enable
	   interrupts. */
	int interrupt_disabled;

186
	/* From the get device id response... */
187
	struct ipmi_device_id device_id;
L
Linus Torvalds 已提交
188

189 190 191 192 193 194 195 196
	/* Driver model stuff. */
	struct device *dev;
	struct platform_device *pdev;

	 /* True if we allocated the device, false if it came from
	  * someplace else (like PCI). */
	int dev_registered;

L
Linus Torvalds 已提交
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
	/* Slave address, could be reported from DMI. */
	unsigned char slave_addr;

	/* Counters and things for the proc filesystem. */
	spinlock_t count_lock;
	unsigned long short_timeouts;
	unsigned long long_timeouts;
	unsigned long timeout_restarts;
	unsigned long idles;
	unsigned long interrupts;
	unsigned long attentions;
	unsigned long flag_fetches;
	unsigned long hosed_count;
	unsigned long complete_transactions;
	unsigned long events;
	unsigned long watchdog_pretimeouts;
	unsigned long incoming_messages;
C
Corey Minyard 已提交
214

M
Matt Domsch 已提交
215
        struct task_struct *thread;
216 217

	struct list_head link;
L
Linus Torvalds 已提交
218 219
};

220 221 222 223 224
#define SI_MAX_PARMS 4

static int force_kipmid[SI_MAX_PARMS];
static int num_force_kipmid;

225 226
static int try_smi_init(struct smi_info *smi);

227
static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
228 229
static int register_xaction_notifier(struct notifier_block * nb)
{
230
	return atomic_notifier_chain_register(&xaction_notifier_list, nb);
231 232
}

L
Linus Torvalds 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static void deliver_recv_msg(struct smi_info *smi_info,
			     struct ipmi_smi_msg *msg)
{
	/* Deliver the message to the upper layer with the lock
           released. */
	spin_unlock(&(smi_info->si_lock));
	ipmi_smi_msg_received(smi_info->intf, msg);
	spin_lock(&(smi_info->si_lock));
}

static void return_hosed_msg(struct smi_info *smi_info)
{
	struct ipmi_smi_msg *msg = smi_info->curr_msg;

	/* Make it a reponse */
	msg->rsp[0] = msg->data[0] | 4;
	msg->rsp[1] = msg->data[1];
	msg->rsp[2] = 0xFF; /* Unknown error. */
	msg->rsp_size = 3;

	smi_info->curr_msg = NULL;
	deliver_recv_msg(smi_info, msg);
}

static enum si_sm_result start_next_msg(struct smi_info *smi_info)
{
	int              rv;
	struct list_head *entry = NULL;
#ifdef DEBUG_TIMING
	struct timeval t;
#endif

	/* No need to save flags, we aleady have interrupts off and we
	   already hold the SMI lock. */
	spin_lock(&(smi_info->msg_lock));

	/* Pick the high priority queue first. */
270
	if (!list_empty(&(smi_info->hp_xmit_msgs))) {
L
Linus Torvalds 已提交
271
		entry = smi_info->hp_xmit_msgs.next;
272
	} else if (!list_empty(&(smi_info->xmit_msgs))) {
L
Linus Torvalds 已提交
273 274 275
		entry = smi_info->xmit_msgs.next;
	}

276
	if (!entry) {
L
Linus Torvalds 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289
		smi_info->curr_msg = NULL;
		rv = SI_SM_IDLE;
	} else {
		int err;

		list_del(entry);
		smi_info->curr_msg = list_entry(entry,
						struct ipmi_smi_msg,
						link);
#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif
290 291
		err = atomic_notifier_call_chain(&xaction_notifier_list,
				0, smi_info);
292 293 294 295
		if (err & NOTIFY_STOP_MASK) {
			rv = SI_SM_CALL_WITHOUT_DELAY;
			goto out;
		}
L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305
		err = smi_info->handlers->start_transaction(
			smi_info->si_sm,
			smi_info->curr_msg->data,
			smi_info->curr_msg->data_size);
		if (err) {
			return_hosed_msg(smi_info);
		}

		rv = SI_SM_CALL_WITHOUT_DELAY;
	}
306
	out:
L
Linus Torvalds 已提交
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	spin_unlock(&(smi_info->msg_lock));

	return rv;
}

static void start_enable_irq(struct smi_info *smi_info)
{
	unsigned char msg[2];

	/* If we are enabling interrupts, we have to tell the
	   BMC to use them. */
	msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
	msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;

	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
	smi_info->si_state = SI_ENABLE_INTERRUPTS1;
}

static void start_clear_flags(struct smi_info *smi_info)
{
	unsigned char msg[3];

	/* Make sure the watchdog pre-timeout flag is not set at startup. */
	msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
	msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
	msg[2] = WDT_PRE_TIMEOUT_INT;

	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
	smi_info->si_state = SI_CLEARING_FLAGS;
}

/* When we have a situtaion where we run out of memory and cannot
   allocate messages, we just leave them in the BMC and run the system
   polled until we can allocate some memory.  Once we have some
   memory, we will re-enable the interrupt. */
static inline void disable_si_irq(struct smi_info *smi_info)
{
344
	if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
L
Linus Torvalds 已提交
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
		disable_irq_nosync(smi_info->irq);
		smi_info->interrupt_disabled = 1;
	}
}

static inline void enable_si_irq(struct smi_info *smi_info)
{
	if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
		enable_irq(smi_info->irq);
		smi_info->interrupt_disabled = 0;
	}
}

static void handle_flags(struct smi_info *smi_info)
{
360
 retry:
L
Linus Torvalds 已提交
361 362 363 364 365 366 367 368 369 370 371 372 373 374
	if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
		/* Watchdog pre-timeout */
		spin_lock(&smi_info->count_lock);
		smi_info->watchdog_pretimeouts++;
		spin_unlock(&smi_info->count_lock);

		start_clear_flags(smi_info);
		smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
		spin_unlock(&(smi_info->si_lock));
		ipmi_smi_watchdog_pretimeout(smi_info->intf);
		spin_lock(&(smi_info->si_lock));
	} else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
		/* Messages available. */
		smi_info->curr_msg = ipmi_alloc_smi_msg();
375
		if (!smi_info->curr_msg) {
L
Linus Torvalds 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
			disable_si_irq(smi_info);
			smi_info->si_state = SI_NORMAL;
			return;
		}
		enable_si_irq(smi_info);

		smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
		smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
		smi_info->curr_msg->data_size = 2;

		smi_info->handlers->start_transaction(
			smi_info->si_sm,
			smi_info->curr_msg->data,
			smi_info->curr_msg->data_size);
		smi_info->si_state = SI_GETTING_MESSAGES;
	} else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
		/* Events available. */
		smi_info->curr_msg = ipmi_alloc_smi_msg();
394
		if (!smi_info->curr_msg) {
L
Linus Torvalds 已提交
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
			disable_si_irq(smi_info);
			smi_info->si_state = SI_NORMAL;
			return;
		}
		enable_si_irq(smi_info);

		smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
		smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
		smi_info->curr_msg->data_size = 2;

		smi_info->handlers->start_transaction(
			smi_info->si_sm,
			smi_info->curr_msg->data,
			smi_info->curr_msg->data_size);
		smi_info->si_state = SI_GETTING_EVENTS;
410 411 412 413
	} else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
	           smi_info->oem_data_avail_handler) {
		if (smi_info->oem_data_avail_handler(smi_info))
			goto retry;
L
Linus Torvalds 已提交
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
	} else {
		smi_info->si_state = SI_NORMAL;
	}
}

static void handle_transaction_done(struct smi_info *smi_info)
{
	struct ipmi_smi_msg *msg;
#ifdef DEBUG_TIMING
	struct timeval t;

	do_gettimeofday(&t);
	printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif
	switch (smi_info->si_state) {
	case SI_NORMAL:
430
		if (!smi_info->curr_msg)
L
Linus Torvalds 已提交
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
			break;

		smi_info->curr_msg->rsp_size
			= smi_info->handlers->get_result(
				smi_info->si_sm,
				smi_info->curr_msg->rsp,
				IPMI_MAX_MSG_LENGTH);

		/* Do this here becase deliver_recv_msg() releases the
		   lock, and a new message can be put in during the
		   time the lock is released. */
		msg = smi_info->curr_msg;
		smi_info->curr_msg = NULL;
		deliver_recv_msg(smi_info, msg);
		break;

	case SI_GETTING_FLAGS:
	{
		unsigned char msg[4];
		unsigned int  len;

		/* We got the flags from the SMI, now handle them. */
		len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
		if (msg[2] != 0) {
			/* Error fetching flags, just give up for
			   now. */
			smi_info->si_state = SI_NORMAL;
		} else if (len < 4) {
			/* Hmm, no flags.  That's technically illegal, but
			   don't use uninitialized data. */
			smi_info->si_state = SI_NORMAL;
		} else {
			smi_info->msg_flags = msg[3];
			handle_flags(smi_info);
		}
		break;
	}

	case SI_CLEARING_FLAGS:
	case SI_CLEARING_FLAGS_THEN_SET_IRQ:
	{
		unsigned char msg[3];

		/* We cleared the flags. */
		smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
		if (msg[2] != 0) {
			/* Error clearing flags */
			printk(KERN_WARNING
			       "ipmi_si: Error clearing flags: %2.2x\n",
			       msg[2]);
		}
		if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
			start_enable_irq(smi_info);
		else
			smi_info->si_state = SI_NORMAL;
		break;
	}

	case SI_GETTING_EVENTS:
	{
		smi_info->curr_msg->rsp_size
			= smi_info->handlers->get_result(
				smi_info->si_sm,
				smi_info->curr_msg->rsp,
				IPMI_MAX_MSG_LENGTH);

		/* Do this here becase deliver_recv_msg() releases the
		   lock, and a new message can be put in during the
		   time the lock is released. */
		msg = smi_info->curr_msg;
		smi_info->curr_msg = NULL;
		if (msg->rsp[2] != 0) {
			/* Error getting event, probably done. */
			msg->done(msg);

			/* Take off the event flag. */
			smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
			handle_flags(smi_info);
		} else {
			spin_lock(&smi_info->count_lock);
			smi_info->events++;
			spin_unlock(&smi_info->count_lock);

			/* Do this before we deliver the message
			   because delivering the message releases the
			   lock and something else can mess with the
			   state. */
			handle_flags(smi_info);

			deliver_recv_msg(smi_info, msg);
		}
		break;
	}

	case SI_GETTING_MESSAGES:
	{
		smi_info->curr_msg->rsp_size
			= smi_info->handlers->get_result(
				smi_info->si_sm,
				smi_info->curr_msg->rsp,
				IPMI_MAX_MSG_LENGTH);

		/* Do this here becase deliver_recv_msg() releases the
		   lock, and a new message can be put in during the
		   time the lock is released. */
		msg = smi_info->curr_msg;
		smi_info->curr_msg = NULL;
		if (msg->rsp[2] != 0) {
			/* Error getting event, probably done. */
			msg->done(msg);

			/* Take off the msg flag. */
			smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
			handle_flags(smi_info);
		} else {
			spin_lock(&smi_info->count_lock);
			smi_info->incoming_messages++;
			spin_unlock(&smi_info->count_lock);

			/* Do this before we deliver the message
			   because delivering the message releases the
			   lock and something else can mess with the
			   state. */
			handle_flags(smi_info);

			deliver_recv_msg(smi_info, msg);
		}
		break;
	}

	case SI_ENABLE_INTERRUPTS1:
	{
		unsigned char msg[4];

		/* We got the flags from the SMI, now handle them. */
		smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
		if (msg[2] != 0) {
			printk(KERN_WARNING
			       "ipmi_si: Could not enable interrupts"
			       ", failed get, using polled mode.\n");
			smi_info->si_state = SI_NORMAL;
		} else {
			msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
			msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
			msg[2] = msg[3] | 1; /* enable msg queue int */
			smi_info->handlers->start_transaction(
				smi_info->si_sm, msg, 3);
			smi_info->si_state = SI_ENABLE_INTERRUPTS2;
		}
		break;
	}

	case SI_ENABLE_INTERRUPTS2:
	{
		unsigned char msg[4];

		/* We got the flags from the SMI, now handle them. */
		smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
		if (msg[2] != 0) {
			printk(KERN_WARNING
			       "ipmi_si: Could not enable interrupts"
			       ", failed set, using polled mode.\n");
		}
		smi_info->si_state = SI_NORMAL;
		break;
	}
	}
}

/* Called on timeouts and events.  Timeouts should pass the elapsed
   time, interrupts should pass in zero. */
static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
					   int time)
{
	enum si_sm_result si_sm_result;

 restart:
	/* There used to be a loop here that waited a little while
	   (around 25us) before giving up.  That turned out to be
	   pointless, the minimum delays I was seeing were in the 300us
	   range, which is far too long to wait in an interrupt.  So
	   we just run until the state machine tells us something
	   happened or it needs a delay. */
	si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
	time = 0;
	while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
	{
		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
	}

	if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
	{
		spin_lock(&smi_info->count_lock);
		smi_info->complete_transactions++;
		spin_unlock(&smi_info->count_lock);

		handle_transaction_done(smi_info);
		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
	}
	else if (si_sm_result == SI_SM_HOSED)
	{
		spin_lock(&smi_info->count_lock);
		smi_info->hosed_count++;
		spin_unlock(&smi_info->count_lock);

		/* Do the before return_hosed_msg, because that
		   releases the lock. */
		smi_info->si_state = SI_NORMAL;
		if (smi_info->curr_msg != NULL) {
			/* If we were handling a user message, format
                           a response to send to the upper layer to
                           tell it about the error. */
			return_hosed_msg(smi_info);
		}
		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
	}

	/* We prefer handling attn over new messages. */
	if (si_sm_result == SI_SM_ATTN)
	{
		unsigned char msg[2];

		spin_lock(&smi_info->count_lock);
		smi_info->attentions++;
		spin_unlock(&smi_info->count_lock);

		/* Got a attn, send down a get message flags to see
                   what's causing it.  It would be better to handle
                   this in the upper layer, but due to the way
                   interrupts work with the SMI, that's not really
                   possible. */
		msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
		msg[1] = IPMI_GET_MSG_FLAGS_CMD;

		smi_info->handlers->start_transaction(
			smi_info->si_sm, msg, 2);
		smi_info->si_state = SI_GETTING_FLAGS;
		goto restart;
	}

	/* If we are currently idle, try to start the next message. */
	if (si_sm_result == SI_SM_IDLE) {
		spin_lock(&smi_info->count_lock);
		smi_info->idles++;
		spin_unlock(&smi_info->count_lock);

		si_sm_result = start_next_msg(smi_info);
		if (si_sm_result != SI_SM_IDLE)
			goto restart;
        }

	if ((si_sm_result == SI_SM_IDLE)
	    && (atomic_read(&smi_info->req_events)))
	{
		/* We are idle and the upper layer requested that I fetch
		   events, so do so. */
		unsigned char msg[2];

		spin_lock(&smi_info->count_lock);
		smi_info->flag_fetches++;
		spin_unlock(&smi_info->count_lock);

		atomic_set(&smi_info->req_events, 0);
		msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
		msg[1] = IPMI_GET_MSG_FLAGS_CMD;

		smi_info->handlers->start_transaction(
			smi_info->si_sm, msg, 2);
		smi_info->si_state = SI_GETTING_FLAGS;
		goto restart;
	}

	return si_sm_result;
}

static void sender(void                *send_info,
		   struct ipmi_smi_msg *msg,
		   int                 priority)
{
	struct smi_info   *smi_info = send_info;
	enum si_sm_result result;
	unsigned long     flags;
#ifdef DEBUG_TIMING
	struct timeval    t;
#endif

	spin_lock_irqsave(&(smi_info->msg_lock), flags);
#ifdef DEBUG_TIMING
	do_gettimeofday(&t);
	printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif

	if (smi_info->run_to_completion) {
		/* If we are running to completion, then throw it in
		   the list and run transactions until everything is
		   clear.  Priority doesn't matter here. */
		list_add_tail(&(msg->link), &(smi_info->xmit_msgs));

		/* We have to release the msg lock and claim the smi
		   lock in this case, because of race conditions. */
		spin_unlock_irqrestore(&(smi_info->msg_lock), flags);

		spin_lock_irqsave(&(smi_info->si_lock), flags);
		result = smi_event_handler(smi_info, 0);
		while (result != SI_SM_IDLE) {
			udelay(SI_SHORT_TIMEOUT_USEC);
			result = smi_event_handler(smi_info,
						   SI_SHORT_TIMEOUT_USEC);
		}
		spin_unlock_irqrestore(&(smi_info->si_lock), flags);
		return;
	} else {
		if (priority > 0) {
			list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
		} else {
			list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
		}
	}
	spin_unlock_irqrestore(&(smi_info->msg_lock), flags);

	spin_lock_irqsave(&(smi_info->si_lock), flags);
	if ((smi_info->si_state == SI_NORMAL)
	    && (smi_info->curr_msg == NULL))
	{
		start_next_msg(smi_info);
	}
	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
}

static void set_run_to_completion(void *send_info, int i_run_to_completion)
{
	struct smi_info   *smi_info = send_info;
	enum si_sm_result result;
	unsigned long     flags;

	spin_lock_irqsave(&(smi_info->si_lock), flags);

	smi_info->run_to_completion = i_run_to_completion;
	if (i_run_to_completion) {
		result = smi_event_handler(smi_info, 0);
		while (result != SI_SM_IDLE) {
			udelay(SI_SHORT_TIMEOUT_USEC);
			result = smi_event_handler(smi_info,
						   SI_SHORT_TIMEOUT_USEC);
		}
	}

	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
}

C
Corey Minyard 已提交
781 782 783
static int ipmi_thread(void *data)
{
	struct smi_info *smi_info = data;
M
Matt Domsch 已提交
784
	unsigned long flags;
C
Corey Minyard 已提交
785 786 787
	enum si_sm_result smi_result;

	set_user_nice(current, 19);
M
Matt Domsch 已提交
788
	while (!kthread_should_stop()) {
C
Corey Minyard 已提交
789
		spin_lock_irqsave(&(smi_info->si_lock), flags);
790
		smi_result = smi_event_handler(smi_info, 0);
C
Corey Minyard 已提交
791
		spin_unlock_irqrestore(&(smi_info->si_lock), flags);
M
Matt Domsch 已提交
792 793
		if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
			/* do nothing */
C
Corey Minyard 已提交
794
		}
M
Matt Domsch 已提交
795
		else if (smi_result == SI_SM_CALL_WITH_DELAY)
796
			schedule();
M
Matt Domsch 已提交
797 798
		else
			schedule_timeout_interruptible(1);
C
Corey Minyard 已提交
799 800 801 802 803
	}
	return 0;
}


L
Linus Torvalds 已提交
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
static void poll(void *send_info)
{
	struct smi_info *smi_info = send_info;

	smi_event_handler(smi_info, 0);
}

static void request_events(void *send_info)
{
	struct smi_info *smi_info = send_info;

	atomic_set(&smi_info->req_events, 1);
}

static int initialized = 0;

static void smi_timeout(unsigned long data)
{
	struct smi_info   *smi_info = (struct smi_info *) data;
	enum si_sm_result smi_result;
	unsigned long     flags;
	unsigned long     jiffies_now;
C
Corey Minyard 已提交
826
	long              time_diff;
L
Linus Torvalds 已提交
827 828 829 830
#ifdef DEBUG_TIMING
	struct timeval    t;
#endif

C
Corey Minyard 已提交
831
	if (atomic_read(&smi_info->stop_operation))
L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839
		return;

	spin_lock_irqsave(&(smi_info->si_lock), flags);
#ifdef DEBUG_TIMING
	do_gettimeofday(&t);
	printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif
	jiffies_now = jiffies;
C
Corey Minyard 已提交
840
	time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
L
Linus Torvalds 已提交
841 842 843 844 845 846 847
		     * SI_USEC_PER_JIFFY);
	smi_result = smi_event_handler(smi_info, time_diff);

	spin_unlock_irqrestore(&(smi_info->si_lock), flags);

	smi_info->last_timeout_jiffies = jiffies_now;

848
	if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
L
Linus Torvalds 已提交
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
		/* Running with interrupts, only do long timeouts. */
		smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
		spin_lock_irqsave(&smi_info->count_lock, flags);
		smi_info->long_timeouts++;
		spin_unlock_irqrestore(&smi_info->count_lock, flags);
		goto do_add_timer;
	}

	/* If the state machine asks for a short delay, then shorten
           the timer timeout. */
	if (smi_result == SI_SM_CALL_WITH_DELAY) {
		spin_lock_irqsave(&smi_info->count_lock, flags);
		smi_info->short_timeouts++;
		spin_unlock_irqrestore(&smi_info->count_lock, flags);
		smi_info->si_timer.expires = jiffies + 1;
	} else {
		spin_lock_irqsave(&smi_info->count_lock, flags);
		smi_info->long_timeouts++;
		spin_unlock_irqrestore(&smi_info->count_lock, flags);
		smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
	}

 do_add_timer:
	add_timer(&(smi_info->si_timer));
}

875
static irqreturn_t si_irq_handler(int irq, void *data)
L
Linus Torvalds 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888
{
	struct smi_info *smi_info = data;
	unsigned long   flags;
#ifdef DEBUG_TIMING
	struct timeval  t;
#endif

	spin_lock_irqsave(&(smi_info->si_lock), flags);

	spin_lock(&smi_info->count_lock);
	smi_info->interrupts++;
	spin_unlock(&smi_info->count_lock);

C
Corey Minyard 已提交
889
	if (atomic_read(&smi_info->stop_operation))
L
Linus Torvalds 已提交
890 891 892 893 894 895 896 897 898 899 900 901
		goto out;

#ifdef DEBUG_TIMING
	do_gettimeofday(&t);
	printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif
	smi_event_handler(smi_info, 0);
 out:
	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
	return IRQ_HANDLED;
}

902
static irqreturn_t si_bt_irq_handler(int irq, void *data)
903 904 905 906 907 908
{
	struct smi_info *smi_info = data;
	/* We need to clear the IRQ flag for the BT interface. */
	smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
			     IPMI_BT_INTMASK_CLEAR_IRQ_BIT
			     | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
909
	return si_irq_handler(irq, data);
910 911
}

912 913 914 915
static int smi_start_processing(void       *send_info,
				ipmi_smi_t intf)
{
	struct smi_info *new_smi = send_info;
916
	int             enable = 0;
917 918 919 920 921 922 923 924

	new_smi->intf = intf;

	/* Set up the timer that drives the interface. */
	setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
	new_smi->last_timeout_jiffies = jiffies;
	mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);

925 926 927 928 929
	/*
	 * Check if the user forcefully enabled the daemon.
	 */
	if (new_smi->intf_num < num_force_kipmid)
		enable = force_kipmid[new_smi->intf_num];
930 931 932 933
	/*
	 * The BT interface is efficient enough to not need a thread,
	 * and there is no need for a thread if we have interrupts.
	 */
934 935 936 937
 	else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
		enable = 1;

	if (enable) {
938 939 940 941 942 943 944 945 946 947 948 949 950
		new_smi->thread = kthread_run(ipmi_thread, new_smi,
					      "kipmi%d", new_smi->intf_num);
		if (IS_ERR(new_smi->thread)) {
			printk(KERN_NOTICE "ipmi_si_intf: Could not start"
			       " kernel thread due to error %ld, only using"
			       " timers to drive the interface\n",
			       PTR_ERR(new_smi->thread));
			new_smi->thread = NULL;
		}
	}

	return 0;
}
951

C
Corey Minyard 已提交
952 953 954 955 956 957 958 959
static void set_maintenance_mode(void *send_info, int enable)
{
	struct smi_info   *smi_info = send_info;

	if (!enable)
		atomic_set(&smi_info->req_events, 0);
}

L
Linus Torvalds 已提交
960 961 962
static struct ipmi_smi_handlers handlers =
{
	.owner                  = THIS_MODULE,
963
	.start_processing       = smi_start_processing,
L
Linus Torvalds 已提交
964 965
	.sender			= sender,
	.request_events		= request_events,
C
Corey Minyard 已提交
966
	.set_maintenance_mode   = set_maintenance_mode,
L
Linus Torvalds 已提交
967 968 969 970 971 972 973
	.set_run_to_completion  = set_run_to_completion,
	.poll			= poll,
};

/* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
   a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */

974
static LIST_HEAD(smi_infos);
975
static DEFINE_MUTEX(smi_infos_lock);
976
static int smi_num; /* Used to sequence the SMIs */
L
Linus Torvalds 已提交
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045

#define DEFAULT_REGSPACING	1

static int           si_trydefaults = 1;
static char          *si_type[SI_MAX_PARMS];
#define MAX_SI_TYPE_STR 30
static char          si_type_str[MAX_SI_TYPE_STR];
static unsigned long addrs[SI_MAX_PARMS];
static int num_addrs;
static unsigned int  ports[SI_MAX_PARMS];
static int num_ports;
static int           irqs[SI_MAX_PARMS];
static int num_irqs;
static int           regspacings[SI_MAX_PARMS];
static int num_regspacings = 0;
static int           regsizes[SI_MAX_PARMS];
static int num_regsizes = 0;
static int           regshifts[SI_MAX_PARMS];
static int num_regshifts = 0;
static int slave_addrs[SI_MAX_PARMS];
static int num_slave_addrs = 0;


module_param_named(trydefaults, si_trydefaults, bool, 0);
MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
		 " default scan of the KCS and SMIC interface at the standard"
		 " address");
module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
MODULE_PARM_DESC(type, "Defines the type of each interface, each"
		 " interface separated by commas.  The types are 'kcs',"
		 " 'smic', and 'bt'.  For example si_type=kcs,bt will set"
		 " the first interface to kcs and the second to bt");
module_param_array(addrs, long, &num_addrs, 0);
MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
		 " addresses separated by commas.  Only use if an interface"
		 " is in memory.  Otherwise, set it to zero or leave"
		 " it blank.");
module_param_array(ports, int, &num_ports, 0);
MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
		 " addresses separated by commas.  Only use if an interface"
		 " is a port.  Otherwise, set it to zero or leave"
		 " it blank.");
module_param_array(irqs, int, &num_irqs, 0);
MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
		 " addresses separated by commas.  Only use if an interface"
		 " has an interrupt.  Otherwise, set it to zero or leave"
		 " it blank.");
module_param_array(regspacings, int, &num_regspacings, 0);
MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
		 " and each successive register used by the interface.  For"
		 " instance, if the start address is 0xca2 and the spacing"
		 " is 2, then the second address is at 0xca4.  Defaults"
		 " to 1.");
module_param_array(regsizes, int, &num_regsizes, 0);
MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
		 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
		 " 16-bit, 32-bit, or 64-bit register.  Use this if you"
		 " the 8-bit IPMI register has to be read from a larger"
		 " register.");
module_param_array(regshifts, int, &num_regshifts, 0);
MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
		 " IPMI register, in bits.  For instance, if the data"
		 " is read from a 32-bit word and the IPMI data is in"
		 " bit 8-15, then the shift would be 8");
module_param_array(slave_addrs, int, &num_slave_addrs, 0);
MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
		 " the controller.  Normally this is 0x20, but can be"
		 " overridden by this parm.  This is an array indexed"
		 " by interface number.");
1046 1047 1048 1049
module_param_array(force_kipmid, int, &num_force_kipmid, 0);
MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
		 " disabled(0).  Normally the IPMI driver auto-detects"
		 " this, but the value may be overridden by this parm.");
L
Linus Torvalds 已提交
1050 1051


1052
#define IPMI_IO_ADDR_SPACE  0
L
Linus Torvalds 已提交
1053
#define IPMI_MEM_ADDR_SPACE 1
1054
static char *addr_space_to_str[] = { "I/O", "memory" };
L
Linus Torvalds 已提交
1055

1056
static void std_irq_cleanup(struct smi_info *info)
L
Linus Torvalds 已提交
1057
{
1058 1059 1060 1061
	if (info->si_type == SI_BT)
		/* Disable the interrupt in the BT interface. */
		info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
	free_irq(info->irq, info);
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066 1067
}

static int std_irq_setup(struct smi_info *info)
{
	int rv;

1068
	if (!info->irq)
L
Linus Torvalds 已提交
1069 1070
		return 0;

1071 1072 1073
	if (info->si_type == SI_BT) {
		rv = request_irq(info->irq,
				 si_bt_irq_handler,
1074
				 IRQF_DISABLED,
1075 1076
				 DEVICE_NAME,
				 info);
1077
		if (!rv)
1078 1079 1080 1081 1082 1083
			/* Enable the interrupt in the BT interface. */
			info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
					 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
	} else
		rv = request_irq(info->irq,
				 si_irq_handler,
1084
				 IRQF_DISABLED,
1085 1086
				 DEVICE_NAME,
				 info);
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092 1093
	if (rv) {
		printk(KERN_WARNING
		       "ipmi_si: %s unable to claim interrupt %d,"
		       " running polled\n",
		       DEVICE_NAME, info->irq);
		info->irq = 0;
	} else {
1094
		info->irq_cleanup = std_irq_cleanup;
L
Linus Torvalds 已提交
1095 1096 1097 1098 1099 1100 1101 1102
		printk("  Using irq %d\n", info->irq);
	}

	return rv;
}

static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
{
1103
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1104

1105
	return inb(addr + (offset * io->regspacing));
L
Linus Torvalds 已提交
1106 1107 1108 1109 1110
}

static void port_outb(struct si_sm_io *io, unsigned int offset,
		      unsigned char b)
{
1111
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1112

1113
	outb(b, addr + (offset * io->regspacing));
L
Linus Torvalds 已提交
1114 1115 1116 1117
}

static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
{
1118
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1119

1120
	return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
L
Linus Torvalds 已提交
1121 1122 1123 1124 1125
}

static void port_outw(struct si_sm_io *io, unsigned int offset,
		      unsigned char b)
{
1126
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1127

1128
	outw(b << io->regshift, addr + (offset * io->regspacing));
L
Linus Torvalds 已提交
1129 1130 1131 1132
}

static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
{
1133
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1134

1135
	return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
L
Linus Torvalds 已提交
1136 1137 1138 1139 1140
}

static void port_outl(struct si_sm_io *io, unsigned int offset,
		      unsigned char b)
{
1141
	unsigned int addr = io->addr_data;
L
Linus Torvalds 已提交
1142

1143
	outl(b << io->regshift, addr+(offset * io->regspacing));
L
Linus Torvalds 已提交
1144 1145 1146 1147
}

static void port_cleanup(struct smi_info *info)
{
1148
	unsigned int addr = info->io.addr_data;
1149
	int          idx;
L
Linus Torvalds 已提交
1150

1151
	if (addr) {
1152 1153 1154 1155
	  	for (idx = 0; idx < info->io_size; idx++) {
			release_region(addr + idx * info->io.regspacing,
				       info->io.regsize);
		}
L
Linus Torvalds 已提交
1156 1157 1158 1159 1160
	}
}

static int port_setup(struct smi_info *info)
{
1161
	unsigned int addr = info->io.addr_data;
1162
	int          idx;
L
Linus Torvalds 已提交
1163

1164
	if (!addr)
L
Linus Torvalds 已提交
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
		return -ENODEV;

	info->io_cleanup = port_cleanup;

	/* Figure out the actual inb/inw/inl/etc routine to use based
	   upon the register size. */
	switch (info->io.regsize) {
	case 1:
		info->io.inputb = port_inb;
		info->io.outputb = port_outb;
		break;
	case 2:
		info->io.inputb = port_inw;
		info->io.outputb = port_outw;
		break;
	case 4:
		info->io.inputb = port_inl;
		info->io.outputb = port_outl;
		break;
	default:
		printk("ipmi_si: Invalid register size: %d\n",
		       info->io.regsize);
		return -EINVAL;
	}

1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
	/* Some BIOSes reserve disjoint I/O regions in their ACPI
	 * tables.  This causes problems when trying to register the
	 * entire I/O region.  Therefore we must register each I/O
	 * port separately.
	 */
  	for (idx = 0; idx < info->io_size; idx++) {
		if (request_region(addr + idx * info->io.regspacing,
				   info->io.regsize, DEVICE_NAME) == NULL) {
			/* Undo allocations */
			while (idx--) {
				release_region(addr + idx * info->io.regspacing,
					       info->io.regsize);
			}
			return -EIO;
		}
	}
L
Linus Torvalds 已提交
1206 1207 1208
	return 0;
}

1209
static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
L
Linus Torvalds 已提交
1210 1211 1212 1213
{
	return readb((io->addr)+(offset * io->regspacing));
}

1214
static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
L
Linus Torvalds 已提交
1215 1216 1217 1218 1219
		     unsigned char b)
{
	writeb(b, (io->addr)+(offset * io->regspacing));
}

1220
static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
L
Linus Torvalds 已提交
1221 1222
{
	return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1223
		& 0xff;
L
Linus Torvalds 已提交
1224 1225
}

1226
static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
L
Linus Torvalds 已提交
1227 1228 1229 1230 1231
		     unsigned char b)
{
	writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
}

1232
static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
L
Linus Torvalds 已提交
1233 1234
{
	return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1235
		& 0xff;
L
Linus Torvalds 已提交
1236 1237
}

1238
static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
L
Linus Torvalds 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247
		     unsigned char b)
{
	writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
}

#ifdef readq
static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
{
	return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1248
		& 0xff;
L
Linus Torvalds 已提交
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
}

static void mem_outq(struct si_sm_io *io, unsigned int offset,
		     unsigned char b)
{
	writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
}
#endif

static void mem_cleanup(struct smi_info *info)
{
1260
	unsigned long addr = info->io.addr_data;
L
Linus Torvalds 已提交
1261 1262 1263 1264 1265 1266 1267 1268
	int           mapsize;

	if (info->io.addr) {
		iounmap(info->io.addr);

		mapsize = ((info->io_size * info->io.regspacing)
			   - (info->io.regspacing - info->io.regsize));

1269
		release_mem_region(addr, mapsize);
L
Linus Torvalds 已提交
1270 1271 1272 1273 1274
	}
}

static int mem_setup(struct smi_info *info)
{
1275
	unsigned long addr = info->io.addr_data;
L
Linus Torvalds 已提交
1276 1277
	int           mapsize;

1278
	if (!addr)
L
Linus Torvalds 已提交
1279 1280 1281 1282 1283 1284 1285 1286
		return -ENODEV;

	info->io_cleanup = mem_cleanup;

	/* Figure out the actual readb/readw/readl/etc routine to use based
	   upon the register size. */
	switch (info->io.regsize) {
	case 1:
1287 1288
		info->io.inputb = intf_mem_inb;
		info->io.outputb = intf_mem_outb;
L
Linus Torvalds 已提交
1289 1290
		break;
	case 2:
1291 1292
		info->io.inputb = intf_mem_inw;
		info->io.outputb = intf_mem_outw;
L
Linus Torvalds 已提交
1293 1294
		break;
	case 4:
1295 1296
		info->io.inputb = intf_mem_inl;
		info->io.outputb = intf_mem_outl;
L
Linus Torvalds 已提交
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
		break;
#ifdef readq
	case 8:
		info->io.inputb = mem_inq;
		info->io.outputb = mem_outq;
		break;
#endif
	default:
		printk("ipmi_si: Invalid register size: %d\n",
		       info->io.regsize);
		return -EINVAL;
	}

	/* Calculate the total amount of memory to claim.  This is an
	 * unusual looking calculation, but it avoids claiming any
	 * more memory than it has to.  It will claim everything
	 * between the first address to the end of the last full
	 * register. */
	mapsize = ((info->io_size * info->io.regspacing)
		   - (info->io.regspacing - info->io.regsize));

1318
	if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
L
Linus Torvalds 已提交
1319 1320
		return -EIO;

1321
	info->io.addr = ioremap(addr, mapsize);
L
Linus Torvalds 已提交
1322
	if (info->io.addr == NULL) {
1323
		release_mem_region(addr, mapsize);
L
Linus Torvalds 已提交
1324 1325 1326 1327 1328
		return -EIO;
	}
	return 0;
}

1329 1330

static __devinit void hardcode_find_bmc(void)
L
Linus Torvalds 已提交
1331
{
1332
	int             i;
L
Linus Torvalds 已提交
1333 1334
	struct smi_info *info;

1335 1336 1337
	for (i = 0; i < SI_MAX_PARMS; i++) {
		if (!ports[i] && !addrs[i])
			continue;
L
Linus Torvalds 已提交
1338

1339 1340 1341
		info = kzalloc(sizeof(*info), GFP_KERNEL);
		if (!info)
			return;
L
Linus Torvalds 已提交
1342

1343
		info->addr_source = "hardcoded";
L
Linus Torvalds 已提交
1344

1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
		if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
			info->si_type = SI_KCS;
		} else if (strcmp(si_type[i], "smic") == 0) {
			info->si_type = SI_SMIC;
		} else if (strcmp(si_type[i], "bt") == 0) {
			info->si_type = SI_BT;
		} else {
			printk(KERN_WARNING
			       "ipmi_si: Interface type specified "
			       "for interface %d, was invalid: %s\n",
			       i, si_type[i]);
			kfree(info);
			continue;
		}
L
Linus Torvalds 已提交
1359

1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
		if (ports[i]) {
			/* An I/O port */
			info->io_setup = port_setup;
			info->io.addr_data = ports[i];
			info->io.addr_type = IPMI_IO_ADDR_SPACE;
		} else if (addrs[i]) {
			/* A memory port */
			info->io_setup = mem_setup;
			info->io.addr_data = addrs[i];
			info->io.addr_type = IPMI_MEM_ADDR_SPACE;
		} else {
			printk(KERN_WARNING
			       "ipmi_si: Interface type specified "
			       "for interface %d, "
			       "but port and address were not set or "
			       "set to zero.\n", i);
			kfree(info);
			continue;
		}
L
Linus Torvalds 已提交
1379

1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
		info->io.addr = NULL;
		info->io.regspacing = regspacings[i];
		if (!info->io.regspacing)
			info->io.regspacing = DEFAULT_REGSPACING;
		info->io.regsize = regsizes[i];
		if (!info->io.regsize)
			info->io.regsize = DEFAULT_REGSPACING;
		info->io.regshift = regshifts[i];
		info->irq = irqs[i];
		if (info->irq)
			info->irq_setup = std_irq_setup;
L
Linus Torvalds 已提交
1391

1392 1393 1394
		try_smi_init(info);
	}
}
L
Linus Torvalds 已提交
1395

1396
#ifdef CONFIG_ACPI
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419

#include <linux/acpi.h>

/* Once we get an ACPI failure, we don't try any more, because we go
   through the tables sequentially.  Once we don't find a table, there
   are no more. */
static int acpi_failure = 0;

/* For GPE-type interrupts. */
static u32 ipmi_acpi_gpe(void *context)
{
	struct smi_info *smi_info = context;
	unsigned long   flags;
#ifdef DEBUG_TIMING
	struct timeval t;
#endif

	spin_lock_irqsave(&(smi_info->si_lock), flags);

	spin_lock(&smi_info->count_lock);
	smi_info->interrupts++;
	spin_unlock(&smi_info->count_lock);

C
Corey Minyard 已提交
1420
	if (atomic_read(&smi_info->stop_operation))
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
		goto out;

#ifdef DEBUG_TIMING
	do_gettimeofday(&t);
	printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif
	smi_event_handler(smi_info, 0);
 out:
	spin_unlock_irqrestore(&(smi_info->si_lock), flags);

	return ACPI_INTERRUPT_HANDLED;
}

1434 1435 1436 1437 1438 1439 1440 1441
static void acpi_gpe_irq_cleanup(struct smi_info *info)
{
	if (!info->irq)
		return;

	acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
}

L
Linus Torvalds 已提交
1442 1443 1444 1445
static int acpi_gpe_irq_setup(struct smi_info *info)
{
	acpi_status status;

1446
	if (!info->irq)
L
Linus Torvalds 已提交
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
		return 0;

	/* FIXME - is level triggered right? */
	status = acpi_install_gpe_handler(NULL,
					  info->irq,
					  ACPI_GPE_LEVEL_TRIGGERED,
					  &ipmi_acpi_gpe,
					  info);
	if (status != AE_OK) {
		printk(KERN_WARNING
		       "ipmi_si: %s unable to claim ACPI GPE %d,"
		       " running polled\n",
		       DEVICE_NAME, info->irq);
		info->irq = 0;
		return -EINVAL;
	} else {
1463
		info->irq_cleanup = acpi_gpe_irq_cleanup;
L
Linus Torvalds 已提交
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
		printk("  Using ACPI GPE %d\n", info->irq);
		return 0;
	}
}

/*
 * Defined at
 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
 */
struct SPMITable {
	s8	Signature[4];
	u32	Length;
	u8	Revision;
	u8	Checksum;
	s8	OEMID[6];
	s8	OEMTableID[8];
	s8	OEMRevision[4];
	s8	CreatorID[4];
	s8	CreatorRevision[4];
	u8	InterfaceType;
	u8	IPMIlegacy;
	s16	SpecificationRevision;

	/*
	 * Bit 0 - SCI interrupt supported
	 * Bit 1 - I/O APIC/SAPIC
	 */
	u8	InterruptType;

	/* If bit 0 of InterruptType is set, then this is the SCI
           interrupt in the GPEx_STS register. */
	u8	GPE;

	s16	Reserved;

	/* If bit 1 of InterruptType is set, then this is the I/O
           APIC/SAPIC interrupt. */
	u32	GlobalSystemInterrupt;

	/* The actual register address. */
	struct acpi_generic_address addr;

	u8	UID[4];

	s8      spmi_id[1]; /* A '\0' terminated array starts here. */
};

1511
static __devinit int try_init_acpi(struct SPMITable *spmi)
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
{
	struct smi_info  *info;
	char             *io_type;
	u8 		 addr_space;

	if (spmi->IPMIlegacy != 1) {
	    printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
  	    return -ENODEV;
	}

	if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
		addr_space = IPMI_MEM_ADDR_SPACE;
	else
		addr_space = IPMI_IO_ADDR_SPACE;
1526 1527 1528 1529 1530 1531 1532 1533

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
		return -ENOMEM;
	}

	info->addr_source = "ACPI";
L
Linus Torvalds 已提交
1534 1535 1536 1537 1538

	/* Figure out the interface type. */
	switch (spmi->InterfaceType)
	{
	case 1:	/* KCS */
1539
		info->si_type = SI_KCS;
L
Linus Torvalds 已提交
1540 1541
		break;
	case 2:	/* SMIC */
1542
		info->si_type = SI_SMIC;
L
Linus Torvalds 已提交
1543 1544
		break;
	case 3:	/* BT */
1545
		info->si_type = SI_BT;
L
Linus Torvalds 已提交
1546 1547 1548 1549
		break;
	default:
		printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
			spmi->InterfaceType);
1550
		kfree(info);
L
Linus Torvalds 已提交
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
		return -EIO;
	}

	if (spmi->InterruptType & 1) {
		/* We've got a GPE interrupt. */
		info->irq = spmi->GPE;
		info->irq_setup = acpi_gpe_irq_setup;
	} else if (spmi->InterruptType & 2) {
		/* We've got an APIC/SAPIC interrupt. */
		info->irq = spmi->GlobalSystemInterrupt;
		info->irq_setup = std_irq_setup;
	} else {
		/* Use the default interrupt setting. */
		info->irq = 0;
		info->irq_setup = NULL;
	}

1568 1569 1570 1571 1572 1573
	if (spmi->addr.register_bit_width) {
		/* A (hopefully) properly formed register bit width. */
		info->io.regspacing = spmi->addr.register_bit_width / 8;
	} else {
		info->io.regspacing = DEFAULT_REGSPACING;
	}
1574 1575
	info->io.regsize = info->io.regspacing;
	info->io.regshift = spmi->addr.register_bit_offset;
L
Linus Torvalds 已提交
1576 1577 1578 1579

	if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
		io_type = "memory";
		info->io_setup = mem_setup;
1580
		info->io.addr_type = IPMI_IO_ADDR_SPACE;
L
Linus Torvalds 已提交
1581 1582 1583
	} else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
		io_type = "I/O";
		info->io_setup = port_setup;
1584
		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
L
Linus Torvalds 已提交
1585 1586 1587 1588 1589
	} else {
		kfree(info);
		printk("ipmi_si: Unknown ACPI I/O Address type\n");
		return -EIO;
	}
1590
	info->io.addr_data = spmi->addr.address;
L
Linus Torvalds 已提交
1591

1592
	try_smi_init(info);
L
Linus Torvalds 已提交
1593 1594 1595

	return 0;
}
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619

static __devinit void acpi_find_bmc(void)
{
	acpi_status      status;
	struct SPMITable *spmi;
	int              i;

	if (acpi_disabled)
		return;

	if (acpi_failure)
		return;

	for (i = 0; ; i++) {
		status = acpi_get_firmware_table("SPMI", i+1,
						 ACPI_LOGICAL_ADDRESSING,
						 (struct acpi_table_header **)
						 &spmi);
		if (status != AE_OK)
			return;

		try_init_acpi(spmi);
	}
}
L
Linus Torvalds 已提交
1620 1621
#endif

1622
#ifdef CONFIG_DMI
1623
struct dmi_ipmi_data
L
Linus Torvalds 已提交
1624 1625 1626 1627 1628 1629 1630
{
	u8   		type;
	u8   		addr_space;
	unsigned long	base_addr;
	u8   		irq;
	u8              offset;
	u8              slave_addr;
1631
};
L
Linus Torvalds 已提交
1632

1633 1634
static int __devinit decode_dmi(struct dmi_header *dm,
				struct dmi_ipmi_data *dmi)
L
Linus Torvalds 已提交
1635
{
C
Corey Minyard 已提交
1636
	u8              *data = (u8 *)dm;
L
Linus Torvalds 已提交
1637 1638
	unsigned long  	base_addr;
	u8		reg_spacing;
1639
	u8              len = dm->length;
L
Linus Torvalds 已提交
1640

1641
	dmi->type = data[4];
L
Linus Torvalds 已提交
1642 1643 1644 1645 1646 1647

	memcpy(&base_addr, data+8, sizeof(unsigned long));
	if (len >= 0x11) {
		if (base_addr & 1) {
			/* I/O */
			base_addr &= 0xFFFE;
1648
			dmi->addr_space = IPMI_IO_ADDR_SPACE;
L
Linus Torvalds 已提交
1649 1650 1651
		}
		else {
			/* Memory */
1652
			dmi->addr_space = IPMI_MEM_ADDR_SPACE;
L
Linus Torvalds 已提交
1653 1654 1655
		}
		/* If bit 4 of byte 0x10 is set, then the lsb for the address
		   is odd. */
1656
		dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
L
Linus Torvalds 已提交
1657

1658
		dmi->irq = data[0x11];
L
Linus Torvalds 已提交
1659 1660

		/* The top two bits of byte 0x10 hold the register spacing. */
1661
		reg_spacing = (data[0x10] & 0xC0) >> 6;
L
Linus Torvalds 已提交
1662 1663
		switch(reg_spacing){
		case 0x00: /* Byte boundaries */
1664
		    dmi->offset = 1;
L
Linus Torvalds 已提交
1665 1666
		    break;
		case 0x01: /* 32-bit boundaries */
1667
		    dmi->offset = 4;
L
Linus Torvalds 已提交
1668 1669
		    break;
		case 0x02: /* 16-byte boundaries */
1670
		    dmi->offset = 16;
L
Linus Torvalds 已提交
1671 1672 1673 1674 1675 1676 1677
		    break;
		default:
		    /* Some other interface, just ignore it. */
		    return -EIO;
		}
	} else {
		/* Old DMI spec. */
1678 1679 1680 1681 1682 1683
		/* Note that technically, the lower bit of the base
		 * address should be 1 if the address is I/O and 0 if
		 * the address is in memory.  So many systems get that
		 * wrong (and all that I have seen are I/O) so we just
		 * ignore that bit and assume I/O.  Systems that use
		 * memory should use the newer spec, anyway. */
1684 1685 1686
		dmi->base_addr = base_addr & 0xfffe;
		dmi->addr_space = IPMI_IO_ADDR_SPACE;
		dmi->offset = 1;
L
Linus Torvalds 已提交
1687 1688
	}

1689
	dmi->slave_addr = data[6];
L
Linus Torvalds 已提交
1690

1691
	return 0;
L
Linus Torvalds 已提交
1692 1693
}

1694
static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
L
Linus Torvalds 已提交
1695
{
1696
	struct smi_info *info;
L
Linus Torvalds 已提交
1697

1698 1699 1700 1701 1702
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		printk(KERN_ERR
		       "ipmi_si: Could not allocate SI data\n");
		return;
L
Linus Torvalds 已提交
1703 1704
	}

1705
	info->addr_source = "SMBIOS";
L
Linus Torvalds 已提交
1706

C
Corey Minyard 已提交
1707
	switch (ipmi_data->type) {
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
	case 0x01: /* KCS */
		info->si_type = SI_KCS;
		break;
	case 0x02: /* SMIC */
		info->si_type = SI_SMIC;
		break;
	case 0x03: /* BT */
		info->si_type = SI_BT;
		break;
	default:
		return;
L
Linus Torvalds 已提交
1719 1720
	}

1721 1722
	switch (ipmi_data->addr_space) {
	case IPMI_MEM_ADDR_SPACE:
L
Linus Torvalds 已提交
1723
		info->io_setup = mem_setup;
1724 1725 1726 1727
		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
		break;

	case IPMI_IO_ADDR_SPACE:
L
Linus Torvalds 已提交
1728
		info->io_setup = port_setup;
1729 1730 1731 1732
		info->io.addr_type = IPMI_IO_ADDR_SPACE;
		break;

	default:
L
Linus Torvalds 已提交
1733
		kfree(info);
1734 1735 1736 1737
		printk(KERN_WARNING
		       "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
		       ipmi_data->addr_space);
		return;
L
Linus Torvalds 已提交
1738
	}
1739
	info->io.addr_data = ipmi_data->base_addr;
L
Linus Torvalds 已提交
1740

1741 1742
	info->io.regspacing = ipmi_data->offset;
	if (!info->io.regspacing)
L
Linus Torvalds 已提交
1743 1744
		info->io.regspacing = DEFAULT_REGSPACING;
	info->io.regsize = DEFAULT_REGSPACING;
1745
	info->io.regshift = 0;
L
Linus Torvalds 已提交
1746 1747 1748

	info->slave_addr = ipmi_data->slave_addr;

1749 1750 1751
	info->irq = ipmi_data->irq;
	if (info->irq)
		info->irq_setup = std_irq_setup;
L
Linus Torvalds 已提交
1752

1753 1754
	try_smi_init(info);
}
L
Linus Torvalds 已提交
1755

1756 1757 1758 1759 1760 1761 1762
static void __devinit dmi_find_bmc(void)
{
	struct dmi_device    *dev = NULL;
	struct dmi_ipmi_data data;
	int                  rv;

	while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1763
		memset(&data, 0, sizeof(data));
1764 1765 1766 1767
		rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
		if (!rv)
			try_init_dmi(&data);
	}
L
Linus Torvalds 已提交
1768
}
1769
#endif /* CONFIG_DMI */
L
Linus Torvalds 已提交
1770 1771 1772

#ifdef CONFIG_PCI

1773 1774 1775 1776 1777 1778 1779
#define PCI_ERMC_CLASSCODE		0x0C0700
#define PCI_ERMC_CLASSCODE_MASK		0xffffff00
#define PCI_ERMC_CLASSCODE_TYPE_MASK	0xff
#define PCI_ERMC_CLASSCODE_TYPE_SMIC	0x00
#define PCI_ERMC_CLASSCODE_TYPE_KCS	0x01
#define PCI_ERMC_CLASSCODE_TYPE_BT	0x02

L
Linus Torvalds 已提交
1780 1781 1782 1783
#define PCI_HP_VENDOR_ID    0x103C
#define PCI_MMC_DEVICE_ID   0x121A
#define PCI_MMC_ADDR_CW     0x10

1784 1785 1786 1787 1788 1789
static void ipmi_pci_cleanup(struct smi_info *info)
{
	struct pci_dev *pdev = info->addr_source_data;

	pci_disable_device(pdev);
}
L
Linus Torvalds 已提交
1790

1791 1792
static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
				    const struct pci_device_id *ent)
L
Linus Torvalds 已提交
1793
{
1794 1795 1796 1797
	int rv;
	int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
	struct smi_info *info;
	int first_reg_offset = 0;
L
Linus Torvalds 已提交
1798

1799 1800
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
1801
		return -ENOMEM;
L
Linus Torvalds 已提交
1802

1803
	info->addr_source = "PCI";
L
Linus Torvalds 已提交
1804

1805 1806 1807 1808
	switch (class_type) {
	case PCI_ERMC_CLASSCODE_TYPE_SMIC:
		info->si_type = SI_SMIC;
		break;
L
Linus Torvalds 已提交
1809

1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
	case PCI_ERMC_CLASSCODE_TYPE_KCS:
		info->si_type = SI_KCS;
		break;

	case PCI_ERMC_CLASSCODE_TYPE_BT:
		info->si_type = SI_BT;
		break;

	default:
		kfree(info);
		printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
		       pci_name(pdev), class_type);
1822
		return -ENOMEM;
L
Linus Torvalds 已提交
1823 1824
	}

1825 1826 1827 1828 1829 1830
	rv = pci_enable_device(pdev);
	if (rv) {
		printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
		       pci_name(pdev));
		kfree(info);
		return rv;
L
Linus Torvalds 已提交
1831 1832
	}

1833 1834
	info->addr_source_cleanup = ipmi_pci_cleanup;
	info->addr_source_data = pdev;
L
Linus Torvalds 已提交
1835

1836 1837
	if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
		first_reg_offset = 1;
L
Linus Torvalds 已提交
1838

1839 1840 1841 1842 1843 1844
	if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
		info->io_setup = port_setup;
		info->io.addr_type = IPMI_IO_ADDR_SPACE;
	} else {
		info->io_setup = mem_setup;
		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
L
Linus Torvalds 已提交
1845
	}
1846
	info->io.addr_data = pci_resource_start(pdev, 0);
L
Linus Torvalds 已提交
1847

1848
	info->io.regspacing = DEFAULT_REGSPACING;
L
Linus Torvalds 已提交
1849
	info->io.regsize = DEFAULT_REGSPACING;
1850
	info->io.regshift = 0;
L
Linus Torvalds 已提交
1851

1852 1853 1854
	info->irq = pdev->irq;
	if (info->irq)
		info->irq_setup = std_irq_setup;
L
Linus Torvalds 已提交
1855

1856 1857
	info->dev = &pdev->dev;

1858 1859
	return try_smi_init(info);
}
L
Linus Torvalds 已提交
1860

1861 1862 1863
static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
{
}
L
Linus Torvalds 已提交
1864

1865 1866 1867
#ifdef CONFIG_PM
static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
L
Linus Torvalds 已提交
1868 1869 1870
	return 0;
}

1871
static int ipmi_pci_resume(struct pci_dev *pdev)
L
Linus Torvalds 已提交
1872
{
1873 1874
	return 0;
}
L
Linus Torvalds 已提交
1875 1876
#endif

1877 1878
static struct pci_device_id ipmi_pci_devices[] = {
	{ PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1879
	{ PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
};
MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);

static struct pci_driver ipmi_pci_driver = {
        .name =         DEVICE_NAME,
        .id_table =     ipmi_pci_devices,
        .probe =        ipmi_pci_probe,
        .remove =       __devexit_p(ipmi_pci_remove),
#ifdef CONFIG_PM
        .suspend =      ipmi_pci_suspend,
        .resume =       ipmi_pci_resume,
#endif
};
#endif /* CONFIG_PCI */
L
Linus Torvalds 已提交
1894 1895 1896 1897


static int try_get_dev_id(struct smi_info *smi_info)
{
1898 1899 1900 1901 1902
	unsigned char         msg[2];
	unsigned char         *resp;
	unsigned long         resp_len;
	enum si_sm_result     smi_result;
	int                   rv = 0;
L
Linus Torvalds 已提交
1903 1904

	resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1905
	if (!resp)
L
Linus Torvalds 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
		return -ENOMEM;

	/* Do a Get Device ID command, since it comes back with some
	   useful info. */
	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
	msg[1] = IPMI_GET_DEVICE_ID_CMD;
	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);

	smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
	for (;;)
	{
C
Corey Minyard 已提交
1917 1918
		if (smi_result == SI_SM_CALL_WITH_DELAY ||
		    smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1919
			schedule_timeout_uninterruptible(1);
L
Linus Torvalds 已提交
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
			smi_result = smi_info->handlers->event(
				smi_info->si_sm, 100);
		}
		else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
		{
			smi_result = smi_info->handlers->event(
				smi_info->si_sm, 0);
		}
		else
			break;
	}
	if (smi_result == SI_SM_HOSED) {
		/* We couldn't get the state machine to run, so whatever's at
		   the port is probably not an IPMI SMI interface. */
		rv = -ENODEV;
		goto out;
	}

	/* Otherwise, we got some data. */
	resp_len = smi_info->handlers->get_result(smi_info->si_sm,
						  resp, IPMI_MAX_MSG_LENGTH);
1941
	if (resp_len < 14) {
L
Linus Torvalds 已提交
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
		/* That's odd, it should be longer. */
		rv = -EINVAL;
		goto out;
	}

	if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
		/* That's odd, it shouldn't be able to fail. */
		rv = -EINVAL;
		goto out;
	}

	/* Record info from the get device id, in case we need it. */
1954
	ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
L
Linus Torvalds 已提交
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985

 out:
	kfree(resp);
	return rv;
}

static int type_file_read_proc(char *page, char **start, off_t off,
			       int count, int *eof, void *data)
{
	char            *out = (char *) page;
	struct smi_info *smi = data;

	switch (smi->si_type) {
	    case SI_KCS:
		return sprintf(out, "kcs\n");
	    case SI_SMIC:
		return sprintf(out, "smic\n");
	    case SI_BT:
		return sprintf(out, "bt\n");
	    default:
		return 0;
	}
}

static int stat_file_read_proc(char *page, char **start, off_t off,
			       int count, int *eof, void *data)
{
	char            *out = (char *) page;
	struct smi_info *smi = data;

	out += sprintf(out, "interrupts_enabled:    %d\n",
1986
		       smi->irq && !smi->interrupt_disabled);
L
Linus Torvalds 已提交
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
	out += sprintf(out, "short_timeouts:        %ld\n",
		       smi->short_timeouts);
	out += sprintf(out, "long_timeouts:         %ld\n",
		       smi->long_timeouts);
	out += sprintf(out, "timeout_restarts:      %ld\n",
		       smi->timeout_restarts);
	out += sprintf(out, "idles:                 %ld\n",
		       smi->idles);
	out += sprintf(out, "interrupts:            %ld\n",
		       smi->interrupts);
	out += sprintf(out, "attentions:            %ld\n",
		       smi->attentions);
	out += sprintf(out, "flag_fetches:          %ld\n",
		       smi->flag_fetches);
	out += sprintf(out, "hosed_count:           %ld\n",
		       smi->hosed_count);
	out += sprintf(out, "complete_transactions: %ld\n",
		       smi->complete_transactions);
	out += sprintf(out, "events:                %ld\n",
		       smi->events);
	out += sprintf(out, "watchdog_pretimeouts:  %ld\n",
		       smi->watchdog_pretimeouts);
	out += sprintf(out, "incoming_messages:     %ld\n",
		       smi->incoming_messages);

	return (out - ((char *) page));
}

2015 2016 2017 2018 2019 2020 2021 2022 2023
/*
 * oem_data_avail_to_receive_msg_avail
 * @info - smi_info structure with msg_flags set
 *
 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
 * Returns 1 indicating need to re-run handle_flags().
 */
static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
{
C
Corey Minyard 已提交
2024 2025
	smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
			      	RECEIVE_MSG_AVAIL);
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
	return 1;
}

/*
 * setup_dell_poweredge_oem_data_handler
 * @info - smi_info.device_id must be populated
 *
 * Systems that match, but have firmware version < 1.40 may assert
 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
 * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
 * as RECEIVE_MSG_AVAIL instead.
 *
 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
 * assert the OEM[012] bits, and if it did, the driver would have to
 * change to handle that properly, we don't actually check for the
 * firmware version.
 * Device ID = 0x20                BMC on PowerEdge 8G servers
 * Device Revision = 0x80
 * Firmware Revision1 = 0x01       BMC version 1.40
 * Firmware Revision2 = 0x40       BCD encoded
 * IPMI Version = 0x51             IPMI 1.5
 * Manufacturer ID = A2 02 00      Dell IANA
 *
C
Corey Minyard 已提交
2050 2051 2052
 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
 *
2053 2054 2055 2056
 */
#define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2057
#define DELL_IANA_MFR_ID 0x0002a2
2058 2059 2060
static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
{
	struct ipmi_device_id *id = &smi_info->device_id;
2061
	if (id->manufacturer_id == DELL_IANA_MFR_ID) {
C
Corey Minyard 已提交
2062 2063
		if (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID  &&
		    id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2064
		    id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
C
Corey Minyard 已提交
2065 2066 2067 2068 2069 2070 2071 2072 2073
			smi_info->oem_data_avail_handler =
				oem_data_avail_to_receive_msg_avail;
		}
		else if (ipmi_version_major(id) < 1 ||
			 (ipmi_version_major(id) == 1 &&
			  ipmi_version_minor(id) < 5)) {
			smi_info->oem_data_avail_handler =
				oem_data_avail_to_receive_msg_avail;
		}
2074 2075 2076
	}
}

2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
static void return_hosed_msg_badsize(struct smi_info *smi_info)
{
	struct ipmi_smi_msg *msg = smi_info->curr_msg;

	/* Make it a reponse */
	msg->rsp[0] = msg->data[0] | 4;
	msg->rsp[1] = msg->data[1];
	msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
	msg->rsp_size = 3;
	smi_info->curr_msg = NULL;
	deliver_recv_msg(smi_info, msg);
}

/*
 * dell_poweredge_bt_xaction_handler
 * @info - smi_info.device_id must be populated
 *
 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
 * not respond to a Get SDR command if the length of the data
 * requested is exactly 0x3A, which leads to command timeouts and no
 * data returned.  This intercepts such commands, and causes userspace
 * callers to try again with a different-sized buffer, which succeeds.
 */

#define STORAGE_NETFN 0x0A
#define STORAGE_CMD_GET_SDR 0x23
static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
					     unsigned long unused,
					     void *in)
{
	struct smi_info *smi_info = in;
	unsigned char *data = smi_info->curr_msg->data;
	unsigned int size   = smi_info->curr_msg->data_size;
	if (size >= 8 &&
	    (data[0]>>2) == STORAGE_NETFN &&
	    data[1] == STORAGE_CMD_GET_SDR &&
	    data[7] == 0x3A) {
		return_hosed_msg_badsize(smi_info);
		return NOTIFY_STOP;
	}
	return NOTIFY_DONE;
}

static struct notifier_block dell_poweredge_bt_xaction_notifier = {
	.notifier_call	= dell_poweredge_bt_xaction_handler,
};

/*
 * setup_dell_poweredge_bt_xaction_handler
 * @info - smi_info.device_id must be filled in already
 *
 * Fills in smi_info.device_id.start_transaction_pre_hook
 * when we know what function to use there.
 */
static void
setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
{
	struct ipmi_device_id *id = &smi_info->device_id;
2136
	if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2137 2138 2139 2140
	    smi_info->si_type == SI_BT)
		register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
}

2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
/*
 * setup_oem_data_handler
 * @info - smi_info.device_id must be filled in already
 *
 * Fills in smi_info.device_id.oem_data_available_handler
 * when we know what function to use there.
 */

static void setup_oem_data_handler(struct smi_info *smi_info)
{
	setup_dell_poweredge_oem_data_handler(smi_info);
}

2154 2155 2156 2157 2158
static void setup_xaction_handlers(struct smi_info *smi_info)
{
	setup_dell_poweredge_bt_xaction_handler(smi_info);
}

C
Corey Minyard 已提交
2159 2160
static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
{
2161 2162 2163 2164 2165 2166 2167
	if (smi_info->intf) {
		/* The timer and thread are only running if the
		   interface has been started up and registered. */
		if (smi_info->thread != NULL)
			kthread_stop(smi_info->thread);
		del_timer_sync(&smi_info->si_timer);
	}
C
Corey Minyard 已提交
2168 2169
}

2170
static __devinitdata struct ipmi_default_vals
2171 2172 2173
{
	int type;
	int port;
2174
} ipmi_defaults[] =
2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
{
	{ .type = SI_KCS, .port = 0xca2 },
	{ .type = SI_SMIC, .port = 0xca9 },
	{ .type = SI_BT, .port = 0xe4 },
	{ .port = 0 }
};

static __devinit void default_find_bmc(void)
{
	struct smi_info *info;
	int             i;

	for (i = 0; ; i++) {
		if (!ipmi_defaults[i].port)
			break;

		info = kzalloc(sizeof(*info), GFP_KERNEL);
		if (!info)
			return;

		info->addr_source = NULL;

		info->si_type = ipmi_defaults[i].type;
		info->io_setup = port_setup;
		info->io.addr_data = ipmi_defaults[i].port;
		info->io.addr_type = IPMI_IO_ADDR_SPACE;

		info->io.addr = NULL;
		info->io.regspacing = DEFAULT_REGSPACING;
		info->io.regsize = DEFAULT_REGSPACING;
		info->io.regshift = 0;

		if (try_smi_init(info) == 0) {
			/* Found one... */
			printk(KERN_INFO "ipmi_si: Found default %s state"
			       " machine at %s address 0x%lx\n",
			       si_to_str[info->si_type],
			       addr_space_to_str[info->io.addr_type],
			       info->io.addr_data);
			return;
		}
	}
}

static int is_new_interface(struct smi_info *info)
L
Linus Torvalds 已提交
2220
{
2221
	struct smi_info *e;
L
Linus Torvalds 已提交
2222

2223 2224 2225 2226 2227 2228
	list_for_each_entry(e, &smi_infos, link) {
		if (e->io.addr_type != info->io.addr_type)
			continue;
		if (e->io.addr_data == info->io.addr_data)
			return 0;
	}
L
Linus Torvalds 已提交
2229

2230 2231
	return 1;
}
L
Linus Torvalds 已提交
2232

2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
static int try_smi_init(struct smi_info *new_smi)
{
	int rv;

	if (new_smi->addr_source) {
		printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
		       " machine at %s address 0x%lx, slave address 0x%x,"
		       " irq %d\n",
		       new_smi->addr_source,
		       si_to_str[new_smi->si_type],
		       addr_space_to_str[new_smi->io.addr_type],
		       new_smi->io.addr_data,
		       new_smi->slave_addr, new_smi->irq);
	}

2248
	mutex_lock(&smi_infos_lock);
2249 2250 2251 2252 2253
	if (!is_new_interface(new_smi)) {
		printk(KERN_WARNING "ipmi_si: duplicate interface\n");
		rv = -EBUSY;
		goto out_err;
	}
L
Linus Torvalds 已提交
2254 2255 2256 2257 2258 2259

	/* So we know not to free it unless we have allocated one. */
	new_smi->intf = NULL;
	new_smi->si_sm = NULL;
	new_smi->handlers = NULL;

2260 2261
	switch (new_smi->si_type) {
	case SI_KCS:
L
Linus Torvalds 已提交
2262
		new_smi->handlers = &kcs_smi_handlers;
2263 2264 2265
		break;

	case SI_SMIC:
L
Linus Torvalds 已提交
2266
		new_smi->handlers = &smic_smi_handlers;
2267 2268 2269
		break;

	case SI_BT:
L
Linus Torvalds 已提交
2270
		new_smi->handlers = &bt_smi_handlers;
2271 2272 2273
		break;

	default:
L
Linus Torvalds 已提交
2274 2275 2276 2277 2278 2279 2280
		/* No support for anything else yet. */
		rv = -EIO;
		goto out_err;
	}

	/* Allocate the state machine's data and initialize it. */
	new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2281
	if (!new_smi->si_sm) {
L
Linus Torvalds 已提交
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301
		printk(" Could not allocate state machine memory\n");
		rv = -ENOMEM;
		goto out_err;
	}
	new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
							&new_smi->io);

	/* Now that we know the I/O size, we can set up the I/O. */
	rv = new_smi->io_setup(new_smi);
	if (rv) {
		printk(" Could not set up I/O space\n");
		goto out_err;
	}

	spin_lock_init(&(new_smi->si_lock));
	spin_lock_init(&(new_smi->msg_lock));
	spin_lock_init(&(new_smi->count_lock));

	/* Do low-level detection first. */
	if (new_smi->handlers->detect(new_smi->si_sm)) {
2302 2303 2304
		if (new_smi->addr_source)
			printk(KERN_INFO "ipmi_si: Interface detection"
			       " failed\n");
L
Linus Torvalds 已提交
2305 2306 2307 2308 2309
		rv = -ENODEV;
		goto out_err;
	}

	/* Attempt a get device id command.  If it fails, we probably
2310
           don't have a BMC here. */
L
Linus Torvalds 已提交
2311
	rv = try_get_dev_id(new_smi);
2312 2313 2314 2315
	if (rv) {
		if (new_smi->addr_source)
			printk(KERN_INFO "ipmi_si: There appears to be no BMC"
			       " at this location\n");
L
Linus Torvalds 已提交
2316
		goto out_err;
2317
	}
L
Linus Torvalds 已提交
2318

2319
	setup_oem_data_handler(new_smi);
2320
	setup_xaction_handlers(new_smi);
2321

L
Linus Torvalds 已提交
2322
	/* Try to claim any interrupts. */
2323 2324
	if (new_smi->irq_setup)
		new_smi->irq_setup(new_smi);
L
Linus Torvalds 已提交
2325 2326 2327 2328 2329 2330 2331 2332

	INIT_LIST_HEAD(&(new_smi->xmit_msgs));
	INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
	new_smi->curr_msg = NULL;
	atomic_set(&new_smi->req_events, 0);
	new_smi->run_to_completion = 0;

	new_smi->interrupt_disabled = 0;
C
Corey Minyard 已提交
2333
	atomic_set(&new_smi->stop_operation, 0);
2334 2335
	new_smi->intf_num = smi_num;
	smi_num++;
L
Linus Torvalds 已提交
2336 2337 2338 2339 2340 2341 2342 2343

	/* Start clearing the flags before we enable interrupts or the
	   timer to avoid racing with the timer. */
	start_clear_flags(new_smi);
	/* IRQ is defined to be set when non-zero. */
	if (new_smi->irq)
		new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;

2344 2345 2346 2347 2348 2349 2350 2351 2352
	if (!new_smi->dev) {
		/* If we don't already have a device from something
		 * else (like PCI), then register a new one. */
		new_smi->pdev = platform_device_alloc("ipmi_si",
						      new_smi->intf_num);
		if (rv) {
			printk(KERN_ERR
			       "ipmi_si_intf:"
			       " Unable to allocate platform device\n");
2353
			goto out_err;
2354 2355 2356 2357
		}
		new_smi->dev = &new_smi->pdev->dev;
		new_smi->dev->driver = &ipmi_driver;

2358
		rv = platform_device_add(new_smi->pdev);
2359 2360 2361 2362 2363 2364
		if (rv) {
			printk(KERN_ERR
			       "ipmi_si_intf:"
			       " Unable to register system interface device:"
			       " %d\n",
			       rv);
2365
			goto out_err;
2366 2367 2368 2369
		}
		new_smi->dev_registered = 1;
	}

L
Linus Torvalds 已提交
2370 2371
	rv = ipmi_register_smi(&handlers,
			       new_smi,
2372 2373
			       &new_smi->device_id,
			       new_smi->dev,
2374
			       "bmc",
2375
			       new_smi->slave_addr);
L
Linus Torvalds 已提交
2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
	if (rv) {
		printk(KERN_ERR
		       "ipmi_si: Unable to register device: error %d\n",
		       rv);
		goto out_err_stop_timer;
	}

	rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
				     type_file_read_proc, NULL,
				     new_smi, THIS_MODULE);
	if (rv) {
		printk(KERN_ERR
		       "ipmi_si: Unable to create proc entry: %d\n",
		       rv);
		goto out_err_stop_timer;
	}

	rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
				     stat_file_read_proc, NULL,
				     new_smi, THIS_MODULE);
	if (rv) {
		printk(KERN_ERR
		       "ipmi_si: Unable to create proc entry: %d\n",
		       rv);
		goto out_err_stop_timer;
	}

2403 2404
	list_add_tail(&new_smi->link, &smi_infos);

2405
	mutex_unlock(&smi_infos_lock);
L
Linus Torvalds 已提交
2406

2407
	printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
L
Linus Torvalds 已提交
2408 2409 2410 2411

	return 0;

 out_err_stop_timer:
C
Corey Minyard 已提交
2412 2413
	atomic_inc(&new_smi->stop_operation);
	wait_for_timer_and_thread(new_smi);
L
Linus Torvalds 已提交
2414 2415 2416 2417 2418

 out_err:
	if (new_smi->intf)
		ipmi_unregister_smi(new_smi->intf);

2419 2420
	if (new_smi->irq_cleanup)
		new_smi->irq_cleanup(new_smi);
L
Linus Torvalds 已提交
2421 2422 2423 2424

	/* Wait until we know that we are out of any interrupt
	   handlers might have been running before we freed the
	   interrupt. */
2425
	synchronize_sched();
L
Linus Torvalds 已提交
2426 2427 2428 2429 2430 2431

	if (new_smi->si_sm) {
		if (new_smi->handlers)
			new_smi->handlers->cleanup(new_smi->si_sm);
		kfree(new_smi->si_sm);
	}
2432 2433
	if (new_smi->addr_source_cleanup)
		new_smi->addr_source_cleanup(new_smi);
P
Paolo Galtieri 已提交
2434 2435
	if (new_smi->io_cleanup)
		new_smi->io_cleanup(new_smi);
L
Linus Torvalds 已提交
2436

2437 2438 2439 2440 2441
	if (new_smi->dev_registered)
		platform_device_unregister(new_smi->pdev);

	kfree(new_smi);

2442
	mutex_unlock(&smi_infos_lock);
2443

L
Linus Torvalds 已提交
2444 2445 2446
	return rv;
}

2447
static __devinit int init_ipmi_si(void)
L
Linus Torvalds 已提交
2448 2449 2450
{
	int  i;
	char *str;
2451
	int  rv;
L
Linus Torvalds 已提交
2452 2453 2454 2455 2456

	if (initialized)
		return 0;
	initialized = 1;

2457 2458 2459 2460 2461 2462 2463 2464 2465 2466
	/* Register the device drivers. */
	rv = driver_register(&ipmi_driver);
	if (rv) {
		printk(KERN_ERR
		       "init_ipmi_si: Unable to register driver: %d\n",
		       rv);
		return rv;
	}


L
Linus Torvalds 已提交
2467 2468 2469
	/* Parse out the si_type string into its components. */
	str = si_type_str;
	if (*str != '\0') {
C
Corey Minyard 已提交
2470
		for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
L
Linus Torvalds 已提交
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
			si_type[i] = str;
			str = strchr(str, ',');
			if (str) {
				*str = '\0';
				str++;
			} else {
				break;
			}
		}
	}

2482
	printk(KERN_INFO "IPMI System Interface driver.\n");
L
Linus Torvalds 已提交
2483

2484 2485
	hardcode_find_bmc();

2486
#ifdef CONFIG_DMI
2487
	dmi_find_bmc();
L
Linus Torvalds 已提交
2488 2489
#endif

2490 2491 2492 2493
#ifdef CONFIG_ACPI
	if (si_trydefaults)
		acpi_find_bmc();
#endif
L
Linus Torvalds 已提交
2494

2495 2496 2497 2498 2499
#ifdef CONFIG_PCI
	pci_module_init(&ipmi_pci_driver);
#endif

	if (si_trydefaults) {
2500
		mutex_lock(&smi_infos_lock);
2501 2502
		if (list_empty(&smi_infos)) {
			/* No BMC was found, try defaults. */
2503
			mutex_unlock(&smi_infos_lock);
2504 2505
			default_find_bmc();
		} else {
2506
			mutex_unlock(&smi_infos_lock);
2507
		}
L
Linus Torvalds 已提交
2508 2509
	}

2510
	mutex_lock(&smi_infos_lock);
2511
	if (list_empty(&smi_infos)) {
2512
		mutex_unlock(&smi_infos_lock);
2513 2514 2515
#ifdef CONFIG_PCI
		pci_unregister_driver(&ipmi_pci_driver);
#endif
2516
		driver_unregister(&ipmi_driver);
L
Linus Torvalds 已提交
2517 2518
		printk("ipmi_si: Unable to find any System Interface(s)\n");
		return -ENODEV;
2519
	} else {
2520
		mutex_unlock(&smi_infos_lock);
2521
		return 0;
L
Linus Torvalds 已提交
2522 2523 2524 2525
	}
}
module_init(init_ipmi_si);

2526
static void __devexit cleanup_one_si(struct smi_info *to_clean)
L
Linus Torvalds 已提交
2527 2528 2529 2530
{
	int           rv;
	unsigned long flags;

2531
	if (!to_clean)
L
Linus Torvalds 已提交
2532 2533
		return;

2534 2535
	list_del(&to_clean->link);

L
Linus Torvalds 已提交
2536 2537 2538 2539 2540
	/* Tell the timer and interrupt handlers that we are shutting
	   down. */
	spin_lock_irqsave(&(to_clean->si_lock), flags);
	spin_lock(&(to_clean->msg_lock));

C
Corey Minyard 已提交
2541
	atomic_inc(&to_clean->stop_operation);
2542 2543 2544

	if (to_clean->irq_cleanup)
		to_clean->irq_cleanup(to_clean);
L
Linus Torvalds 已提交
2545 2546 2547 2548 2549 2550 2551

	spin_unlock(&(to_clean->msg_lock));
	spin_unlock_irqrestore(&(to_clean->si_lock), flags);

	/* Wait until we know that we are out of any interrupt
	   handlers might have been running before we freed the
	   interrupt. */
2552
	synchronize_sched();
L
Linus Torvalds 已提交
2553

C
Corey Minyard 已提交
2554
	wait_for_timer_and_thread(to_clean);
L
Linus Torvalds 已提交
2555 2556 2557

	/* Interrupts and timeouts are stopped, now make sure the
	   interface is in a clean state. */
C
Corey Minyard 已提交
2558
	while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
L
Linus Torvalds 已提交
2559
		poll(to_clean);
2560
		schedule_timeout_uninterruptible(1);
L
Linus Torvalds 已提交
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573
	}

	rv = ipmi_unregister_smi(to_clean->intf);
	if (rv) {
		printk(KERN_ERR
		       "ipmi_si: Unable to unregister device: errno=%d\n",
		       rv);
	}

	to_clean->handlers->cleanup(to_clean->si_sm);

	kfree(to_clean->si_sm);

2574 2575
	if (to_clean->addr_source_cleanup)
		to_clean->addr_source_cleanup(to_clean);
P
Paolo Galtieri 已提交
2576 2577
	if (to_clean->io_cleanup)
		to_clean->io_cleanup(to_clean);
2578 2579 2580 2581 2582

	if (to_clean->dev_registered)
		platform_device_unregister(to_clean->pdev);

	kfree(to_clean);
L
Linus Torvalds 已提交
2583 2584 2585 2586
}

static __exit void cleanup_ipmi_si(void)
{
2587
	struct smi_info *e, *tmp_e;
L
Linus Torvalds 已提交
2588

2589
	if (!initialized)
L
Linus Torvalds 已提交
2590 2591
		return;

2592 2593 2594 2595
#ifdef CONFIG_PCI
	pci_unregister_driver(&ipmi_pci_driver);
#endif

2596
	mutex_lock(&smi_infos_lock);
2597 2598
	list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
		cleanup_one_si(e);
2599
	mutex_unlock(&smi_infos_lock);
2600 2601

	driver_unregister(&ipmi_driver);
L
Linus Torvalds 已提交
2602 2603 2604 2605
}
module_exit(cleanup_ipmi_si);

MODULE_LICENSE("GPL");
2606 2607
MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");