2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
2007-05-08 14:23:51 +07:00
|
|
|
* Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* 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 <linux/sched.h>
|
2011-05-27 06:25:55 +07:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#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>
|
2005-11-07 15:59:59 +07:00
|
|
|
#include <linux/notifier.h>
|
2006-03-26 16:37:20 +07:00
|
|
|
#include <linux/mutex.h>
|
2005-11-07 16:00:04 +07:00
|
|
|
#include <linux/kthread.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/rcupdate.h>
|
2010-12-08 09:10:16 +07:00
|
|
|
#include <linux/ipmi.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/ipmi_smi.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include "ipmi_si_sm.h"
|
2005-09-07 05:18:37 +07:00
|
|
|
#include <linux/dmi.h>
|
2006-12-07 11:41:07 +07:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/ctype.h>
|
2009-11-18 07:05:34 +07:00
|
|
|
#include <linux/pnp.h>
|
2008-05-23 13:22:42 +07:00
|
|
|
#include <linux/of_device.h>
|
|
|
|
#include <linux/of_platform.h>
|
2010-11-17 03:33:51 +07:00
|
|
|
#include <linux/of_address.h>
|
|
|
|
#include <linux/of_irq.h>
|
2007-05-08 14:23:51 +07:00
|
|
|
|
2013-09-05 18:36:36 +07:00
|
|
|
#ifdef CONFIG_PARISC
|
|
|
|
#include <asm/hardware.h> /* for register_parisc_driver() stuff */
|
|
|
|
#include <asm/parisc-device.h>
|
|
|
|
#endif
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
#define PFX "ipmi_si: "
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* 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
|
2008-04-29 15:01:10 +07:00
|
|
|
short timeout */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
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,
|
2007-05-08 14:23:54 +07:00
|
|
|
SI_ENABLE_INTERRUPTS2,
|
|
|
|
SI_DISABLE_INTERRUPTS1,
|
|
|
|
SI_DISABLE_INTERRUPTS2
|
2005-04-17 05:20:36 +07:00
|
|
|
/* FIXME - add watchdog stuff. */
|
|
|
|
};
|
|
|
|
|
2005-05-01 22:59:11 +07:00
|
|
|
/* 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
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
enum si_type {
|
|
|
|
SI_KCS, SI_SMIC, SI_BT
|
|
|
|
};
|
2006-12-07 11:41:07 +07:00
|
|
|
static char *si_to_str[] = { "kcs", "smic", "bt" };
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
static char *ipmi_addr_src_to_str[] = { NULL, "hotmod", "hardcoded", "SPMI",
|
|
|
|
"ACPI", "SMBIOS", "PCI",
|
|
|
|
"device-tree", "default" };
|
|
|
|
|
2006-03-26 16:37:21 +07:00
|
|
|
#define DEVICE_NAME "ipmi_si"
|
|
|
|
|
2011-02-24 04:37:59 +07:00
|
|
|
static struct platform_driver ipmi_driver;
|
2008-04-29 15:01:07 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Indexes into stats[] in smi_info below.
|
|
|
|
*/
|
2008-04-29 15:01:08 +07:00
|
|
|
enum si_stat_indexes {
|
|
|
|
/*
|
|
|
|
* Number of times the driver requested a timer while an operation
|
|
|
|
* was in progress.
|
|
|
|
*/
|
|
|
|
SI_STAT_short_timeouts = 0,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Number of times the driver requested a timer while nothing was in
|
|
|
|
* progress.
|
|
|
|
*/
|
|
|
|
SI_STAT_long_timeouts,
|
|
|
|
|
|
|
|
/* Number of times the interface was idle while being polled. */
|
|
|
|
SI_STAT_idles,
|
|
|
|
|
|
|
|
/* Number of interrupts the driver handled. */
|
|
|
|
SI_STAT_interrupts,
|
|
|
|
|
|
|
|
/* Number of time the driver got an ATTN from the hardware. */
|
|
|
|
SI_STAT_attentions,
|
2008-04-29 15:01:07 +07:00
|
|
|
|
2008-04-29 15:01:08 +07:00
|
|
|
/* Number of times the driver requested flags from the hardware. */
|
|
|
|
SI_STAT_flag_fetches,
|
|
|
|
|
|
|
|
/* Number of times the hardware didn't follow the state machine. */
|
|
|
|
SI_STAT_hosed_count,
|
|
|
|
|
|
|
|
/* Number of completed messages. */
|
|
|
|
SI_STAT_complete_transactions,
|
|
|
|
|
|
|
|
/* Number of IPMI events received from the hardware. */
|
|
|
|
SI_STAT_events,
|
|
|
|
|
|
|
|
/* Number of watchdog pretimeouts. */
|
|
|
|
SI_STAT_watchdog_pretimeouts,
|
|
|
|
|
2012-09-20 08:48:02 +07:00
|
|
|
/* Number of asynchronous messages received. */
|
2008-04-29 15:01:08 +07:00
|
|
|
SI_STAT_incoming_messages,
|
|
|
|
|
|
|
|
|
|
|
|
/* This *must* remain last, add new values above this. */
|
|
|
|
SI_NUM_STATS
|
|
|
|
};
|
2008-04-29 15:01:07 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
struct smi_info {
|
2005-11-07 16:00:03 +07:00
|
|
|
int intf_num;
|
2005-04-17 05:20:36 +07:00
|
|
|
ipmi_smi_t intf;
|
|
|
|
struct si_sm_data *si_sm;
|
|
|
|
struct si_sm_handlers *handlers;
|
|
|
|
enum si_type si_type;
|
|
|
|
spinlock_t si_lock;
|
|
|
|
struct list_head xmit_msgs;
|
|
|
|
struct list_head hp_xmit_msgs;
|
|
|
|
struct ipmi_smi_msg *curr_msg;
|
|
|
|
enum si_intf_state si_state;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Used to handle the various types of I/O that can occur with
|
|
|
|
* IPMI
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
2010-05-27 04:43:45 +07:00
|
|
|
enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
|
2006-03-26 16:37:20 +07:00
|
|
|
void (*addr_source_cleanup)(struct smi_info *info);
|
|
|
|
void *addr_source_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-09-07 05:18:41 +07:00
|
|
|
int (*oem_data_avail_handler)(struct smi_info *smi_info);
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
#define RECEIVE_MSG_AVAIL 0x01
|
|
|
|
#define EVENT_MSG_BUFFER_FULL 0x02
|
|
|
|
#define WDT_PRE_TIMEOUT_INT 0x08
|
2005-09-07 05:18:41 +07:00
|
|
|
#define OEM0_DATA_AVAIL 0x20
|
|
|
|
#define OEM1_DATA_AVAIL 0x40
|
|
|
|
#define OEM2_DATA_AVAIL 0x80
|
|
|
|
#define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
|
2008-04-29 15:01:10 +07:00
|
|
|
OEM1_DATA_AVAIL | \
|
|
|
|
OEM2_DATA_AVAIL)
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char msg_flags;
|
|
|
|
|
2009-04-22 02:24:03 +07:00
|
|
|
/* Does the BMC have an event buffer? */
|
|
|
|
char has_event_buffer;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If set to true, this will request events the next time the
|
|
|
|
* state machine is idle.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_t req_events;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If true, run the state machine to completion on every send
|
|
|
|
* call. Generally used after a panic to make sure stuff goes
|
|
|
|
* out.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
int run_to_completion;
|
|
|
|
|
|
|
|
/* The I/O port of an SI interface. */
|
|
|
|
int port;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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. */
|
2005-11-07 16:00:03 +07:00
|
|
|
atomic_t stop_operation;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
int interrupt_disabled;
|
|
|
|
|
2006-03-26 16:37:21 +07:00
|
|
|
/* From the get device id response... */
|
2005-09-07 05:18:41 +07:00
|
|
|
struct ipmi_device_id device_id;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:21 +07:00
|
|
|
/* Driver model stuff. */
|
|
|
|
struct device *dev;
|
|
|
|
struct platform_device *pdev;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* True if we allocated the device, false if it came from
|
|
|
|
* someplace else (like PCI).
|
|
|
|
*/
|
2006-03-26 16:37:21 +07:00
|
|
|
int dev_registered;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Slave address, could be reported from DMI. */
|
|
|
|
unsigned char slave_addr;
|
|
|
|
|
|
|
|
/* Counters and things for the proc filesystem. */
|
2008-04-29 15:01:07 +07:00
|
|
|
atomic_t stats[SI_NUM_STATS];
|
2005-11-07 16:00:03 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
struct task_struct *thread;
|
2006-03-26 16:37:20 +07:00
|
|
|
|
|
|
|
struct list_head link;
|
2010-12-08 09:10:16 +07:00
|
|
|
union ipmi_smi_info_union addr_info;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2008-04-29 15:01:07 +07:00
|
|
|
#define smi_inc_stat(smi, stat) \
|
|
|
|
atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
|
|
|
|
#define smi_get_stat(smi, stat) \
|
|
|
|
((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
|
|
|
|
|
2006-10-03 15:13:59 +07:00
|
|
|
#define SI_MAX_PARMS 4
|
|
|
|
|
|
|
|
static int force_kipmid[SI_MAX_PARMS];
|
|
|
|
static int num_force_kipmid;
|
2010-06-30 05:05:29 +07:00
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
static int pci_registered;
|
|
|
|
#endif
|
2010-09-23 03:05:15 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
static int pnp_registered;
|
|
|
|
#endif
|
2013-09-05 18:36:36 +07:00
|
|
|
#ifdef CONFIG_PARISC
|
|
|
|
static int parisc_registered;
|
|
|
|
#endif
|
2006-10-03 15:13:59 +07:00
|
|
|
|
2010-03-11 06:23:06 +07:00
|
|
|
static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
|
|
|
|
static int num_max_busy_us;
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
static int unload_when_empty = 1;
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
static int add_smi(struct smi_info *smi);
|
2006-03-26 16:37:20 +07:00
|
|
|
static int try_smi_init(struct smi_info *smi);
|
2006-12-07 11:41:07 +07:00
|
|
|
static void cleanup_one_si(struct smi_info *to_clean);
|
2011-02-11 05:08:38 +07:00
|
|
|
static void cleanup_ipmi_si(void);
|
2006-03-26 16:37:20 +07:00
|
|
|
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 16:16:30 +07:00
|
|
|
static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
|
2008-04-29 15:01:10 +07:00
|
|
|
static int register_xaction_notifier(struct notifier_block *nb)
|
2005-11-07 15:59:59 +07:00
|
|
|
{
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 16:16:30 +07:00
|
|
|
return atomic_notifier_chain_register(&xaction_notifier_list, nb);
|
2005-11-07 15:59:59 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void deliver_recv_msg(struct smi_info *smi_info,
|
|
|
|
struct ipmi_smi_msg *msg)
|
|
|
|
{
|
2012-03-29 04:42:49 +07:00
|
|
|
/* Deliver the message to the upper layer. */
|
|
|
|
ipmi_smi_msg_received(smi_info->intf, msg);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-12-07 11:41:14 +07:00
|
|
|
static void return_hosed_msg(struct smi_info *smi_info, int cCode)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct ipmi_smi_msg *msg = smi_info->curr_msg;
|
|
|
|
|
2006-12-07 11:41:14 +07:00
|
|
|
if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
|
|
|
|
cCode = IPMI_ERR_UNSPECIFIED;
|
|
|
|
/* else use it as is */
|
|
|
|
|
2011-03-31 08:57:33 +07:00
|
|
|
/* Make it a response */
|
2005-04-17 05:20:36 +07:00
|
|
|
msg->rsp[0] = msg->data[0] | 4;
|
|
|
|
msg->rsp[1] = msg->data[1];
|
2006-12-07 11:41:14 +07:00
|
|
|
msg->rsp[2] = cCode;
|
2005-04-17 05:20:36 +07:00
|
|
|
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
|
|
|
|
|
|
|
|
/* Pick the high priority queue first. */
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!list_empty(&(smi_info->hp_xmit_msgs))) {
|
2005-04-17 05:20:36 +07:00
|
|
|
entry = smi_info->hp_xmit_msgs.next;
|
2006-03-26 16:37:20 +07:00
|
|
|
} else if (!list_empty(&(smi_info->xmit_msgs))) {
|
2005-04-17 05:20:36 +07:00
|
|
|
entry = smi_info->xmit_msgs.next;
|
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!entry) {
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
2008-04-29 15:01:10 +07:00
|
|
|
printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 16:16:30 +07:00
|
|
|
err = atomic_notifier_call_chain(&xaction_notifier_list,
|
|
|
|
0, smi_info);
|
2005-11-07 15:59:59 +07:00
|
|
|
if (err & NOTIFY_STOP_MASK) {
|
|
|
|
rv = SI_SM_CALL_WITHOUT_DELAY;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
err = smi_info->handlers->start_transaction(
|
|
|
|
smi_info->si_sm,
|
|
|
|
smi_info->curr_msg->data,
|
|
|
|
smi_info->curr_msg->data_size);
|
2008-04-29 15:01:10 +07:00
|
|
|
if (err)
|
2006-12-07 11:41:14 +07:00
|
|
|
return_hosed_msg(smi_info, err);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rv = SI_SM_CALL_WITHOUT_DELAY;
|
|
|
|
}
|
2008-04-29 15:01:10 +07:00
|
|
|
out:
|
2005-04-17 05:20:36 +07:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_enable_irq(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
unsigned char msg[2];
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If we are enabling interrupts, we have to tell the
|
|
|
|
* BMC to use them.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-05-08 14:23:54 +07:00
|
|
|
static void start_disable_irq(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
unsigned char msg[2];
|
|
|
|
|
|
|
|
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_DISABLE_INTERRUPTS1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline void disable_si_irq(struct smi_info *smi_info)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
|
2007-05-08 14:23:54 +07:00
|
|
|
start_disable_irq(smi_info);
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->interrupt_disabled = 1;
|
2010-05-27 04:43:48 +07:00
|
|
|
if (!atomic_read(&smi_info->stop_operation))
|
|
|
|
mod_timer(&smi_info->si_timer,
|
|
|
|
jiffies + SI_TIMEOUT_JIFFIES);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void enable_si_irq(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
|
2007-05-08 14:23:54 +07:00
|
|
|
start_enable_irq(smi_info);
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->interrupt_disabled = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_flags(struct smi_info *smi_info)
|
|
|
|
{
|
2005-09-07 05:18:41 +07:00
|
|
|
retry:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
|
|
|
|
/* Watchdog pre-timeout */
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, watchdog_pretimeouts);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
start_clear_flags(smi_info);
|
|
|
|
smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
|
|
|
|
ipmi_smi_watchdog_pretimeout(smi_info->intf);
|
|
|
|
} else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
|
|
|
|
/* Messages available. */
|
|
|
|
smi_info->curr_msg = ipmi_alloc_smi_msg();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!smi_info->curr_msg) {
|
2005-04-17 05:20:36 +07:00
|
|
|
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();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!smi_info->curr_msg) {
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
2006-09-17 02:15:41 +07:00
|
|
|
} else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
|
2008-04-29 15:01:10 +07:00
|
|
|
smi_info->oem_data_avail_handler) {
|
2006-09-17 02:15:41 +07:00
|
|
|
if (smi_info->oem_data_avail_handler(smi_info))
|
|
|
|
goto retry;
|
2008-04-29 15:01:10 +07:00
|
|
|
} else
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
2008-04-29 15:01:10 +07:00
|
|
|
printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
switch (smi_info->si_state) {
|
|
|
|
case SI_NORMAL:
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!smi_info->curr_msg)
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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) {
|
2008-04-29 15:01:10 +07:00
|
|
|
/* Error fetching flags, just give up for now. */
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->si_state = SI_NORMAL;
|
|
|
|
} else if (len < 4) {
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Hmm, no flags. That's technically illegal, but
|
|
|
|
* don't use uninitialized data.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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 */
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(smi_info->dev,
|
|
|
|
"Error clearing flags: %2.2x\n", msg[2]);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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 {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, events);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Do this before we deliver the message
|
|
|
|
* because delivering the message releases the
|
|
|
|
* lock and something else can mess with the
|
|
|
|
* state.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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 {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, incoming_messages);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Do this before we deliver the message
|
|
|
|
* because delivering the message releases the
|
|
|
|
* lock and something else can mess with the
|
|
|
|
* state.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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) {
|
2013-05-17 02:04:26 +07:00
|
|
|
dev_warn(smi_info->dev,
|
|
|
|
"Couldn't get irq info: %x.\n", msg[2]);
|
|
|
|
dev_warn(smi_info->dev,
|
|
|
|
"Maybe ok, but ipmi might run very slowly.\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->si_state = SI_NORMAL;
|
|
|
|
} else {
|
|
|
|
msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
|
|
|
|
msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
|
2007-05-08 14:23:54 +07:00
|
|
|
msg[2] = (msg[3] |
|
|
|
|
IPMI_BMC_RCV_MSG_INTR |
|
|
|
|
IPMI_BMC_EVT_MSG_INTR);
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
2013-05-17 02:04:26 +07:00
|
|
|
if (msg[2] != 0) {
|
|
|
|
dev_warn(smi_info->dev,
|
|
|
|
"Couldn't set irq info: %x.\n", msg[2]);
|
|
|
|
dev_warn(smi_info->dev,
|
|
|
|
"Maybe ok, but ipmi might run very slowly.\n");
|
|
|
|
} else
|
2010-05-27 04:43:48 +07:00
|
|
|
smi_info->interrupt_disabled = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->si_state = SI_NORMAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-05-08 14:23:54 +07:00
|
|
|
|
|
|
|
case SI_DISABLE_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) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(smi_info->dev, "Could not disable interrupts"
|
|
|
|
", failed get.\n");
|
2007-05-08 14:23:54 +07:00
|
|
|
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] &
|
|
|
|
~(IPMI_BMC_RCV_MSG_INTR |
|
|
|
|
IPMI_BMC_EVT_MSG_INTR));
|
|
|
|
smi_info->handlers->start_transaction(
|
|
|
|
smi_info->si_sm, msg, 3);
|
|
|
|
smi_info->si_state = SI_DISABLE_INTERRUPTS2;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SI_DISABLE_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) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(smi_info->dev, "Could not disable interrupts"
|
|
|
|
", failed set.\n");
|
2007-05-08 14:23:54 +07:00
|
|
|
}
|
|
|
|
smi_info->si_state = SI_NORMAL;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Called on timeouts and events. Timeouts should pass the elapsed
|
|
|
|
* time, interrupts should pass in zero. Must be called with
|
|
|
|
* si_lock held and interrupts disabled.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
|
|
|
|
int time)
|
|
|
|
{
|
|
|
|
enum si_sm_result si_sm_result;
|
|
|
|
|
|
|
|
restart:
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, complete_transactions);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
handle_transaction_done(smi_info);
|
|
|
|
si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
|
2008-04-29 15:01:10 +07:00
|
|
|
} else if (si_sm_result == SI_SM_HOSED) {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, hosed_count);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Do the before return_hosed_msg, because that
|
|
|
|
* releases the lock.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_info->si_state = SI_NORMAL;
|
|
|
|
if (smi_info->curr_msg != NULL) {
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If we were handling a user message, format
|
|
|
|
* a response to send to the upper layer to
|
|
|
|
* tell it about the error.
|
|
|
|
*/
|
2006-12-07 11:41:14 +07:00
|
|
|
return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:01 +07:00
|
|
|
/*
|
|
|
|
* We prefer handling attn over new messages. But don't do
|
|
|
|
* this if there is not yet an upper layer to handle anything.
|
|
|
|
*/
|
2008-04-29 15:01:10 +07:00
|
|
|
if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) {
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char msg[2];
|
|
|
|
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, attentions);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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) {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, idles);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
si_sm_result = start_next_msg(smi_info);
|
|
|
|
if (si_sm_result != SI_SM_IDLE)
|
|
|
|
goto restart;
|
2008-04-29 15:01:10 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if ((si_sm_result == SI_SM_IDLE)
|
2008-04-29 15:01:10 +07:00
|
|
|
&& (atomic_read(&smi_info->req_events))) {
|
|
|
|
/*
|
|
|
|
* We are idle and the upper layer requested that I fetch
|
|
|
|
* events, so do so.
|
|
|
|
*/
|
2006-12-07 11:41:04 +07:00
|
|
|
atomic_set(&smi_info->req_events, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-07 11:41:04 +07:00
|
|
|
smi_info->curr_msg = ipmi_alloc_smi_msg();
|
|
|
|
if (!smi_info->curr_msg)
|
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-07 11:41:04 +07:00
|
|
|
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;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
smi_info->handlers->start_transaction(
|
2006-12-07 11:41:04 +07:00
|
|
|
smi_info->si_sm,
|
|
|
|
smi_info->curr_msg->data,
|
|
|
|
smi_info->curr_msg->data_size);
|
|
|
|
smi_info->si_state = SI_GETTING_EVENTS;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto restart;
|
|
|
|
}
|
2006-12-07 11:41:04 +07:00
|
|
|
out:
|
2005-04-17 05:20:36 +07:00
|
|
|
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
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
if (atomic_read(&smi_info->stop_operation)) {
|
|
|
|
msg->rsp[0] = msg->data[0] | 4;
|
|
|
|
msg->rsp[1] = msg->data[1];
|
|
|
|
msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
|
|
|
|
msg->rsp_size = 3;
|
|
|
|
deliver_recv_msg(smi_info, msg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#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) {
|
2008-04-29 15:01:02 +07:00
|
|
|
/*
|
|
|
|
* If we are running to completion, then throw it in
|
|
|
|
* the list and run transactions until everything is
|
|
|
|
* clear. Priority doesn't matter here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Run to completion means we are single-threaded, no
|
|
|
|
* need for locks.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-03-29 04:42:50 +07:00
|
|
|
spin_lock_irqsave(&smi_info->si_lock, flags);
|
2008-04-29 15:01:02 +07:00
|
|
|
if (priority > 0)
|
|
|
|
list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
|
|
|
|
else
|
|
|
|
list_add_tail(&msg->link, &smi_info->xmit_msgs);
|
|
|
|
|
2012-03-29 04:42:48 +07:00
|
|
|
if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
|
2012-03-29 04:42:50 +07:00
|
|
|
/*
|
|
|
|
* last_timeout_jiffies is updated here to avoid
|
|
|
|
* smi_timeout() handler passing very large time_diff
|
|
|
|
* value to smi_event_handler() that causes
|
|
|
|
* the send command to abort.
|
|
|
|
*/
|
|
|
|
smi_info->last_timeout_jiffies = jiffies;
|
|
|
|
|
|
|
|
mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
|
|
|
|
|
|
|
|
if (smi_info->thread)
|
|
|
|
wake_up_process(smi_info->thread);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
start_next_msg(smi_info);
|
2012-03-29 04:42:48 +07:00
|
|
|
smi_event_handler(smi_info, 0);
|
|
|
|
}
|
2008-04-29 15:01:02 +07:00
|
|
|
spin_unlock_irqrestore(&smi_info->si_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-11 06:23:06 +07:00
|
|
|
/*
|
|
|
|
* Use -1 in the nsec value of the busy waiting timespec to tell that
|
|
|
|
* we are spinning in kipmid looking for something and not delaying
|
|
|
|
* between checks
|
|
|
|
*/
|
|
|
|
static inline void ipmi_si_set_not_busy(struct timespec *ts)
|
|
|
|
{
|
|
|
|
ts->tv_nsec = -1;
|
|
|
|
}
|
|
|
|
static inline int ipmi_si_is_busy(struct timespec *ts)
|
|
|
|
{
|
|
|
|
return ts->tv_nsec != -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmi_thread_busy_wait(enum si_sm_result smi_result,
|
|
|
|
const struct smi_info *smi_info,
|
|
|
|
struct timespec *busy_until)
|
|
|
|
{
|
|
|
|
unsigned int max_busy_us = 0;
|
|
|
|
|
|
|
|
if (smi_info->intf_num < num_max_busy_us)
|
|
|
|
max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
|
|
|
|
if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
|
|
|
|
ipmi_si_set_not_busy(busy_until);
|
|
|
|
else if (!ipmi_si_is_busy(busy_until)) {
|
|
|
|
getnstimeofday(busy_until);
|
|
|
|
timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
|
|
|
|
} else {
|
|
|
|
struct timespec now;
|
|
|
|
getnstimeofday(&now);
|
|
|
|
if (unlikely(timespec_compare(&now, busy_until) > 0)) {
|
|
|
|
ipmi_si_set_not_busy(busy_until);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A busy-waiting loop for speeding up IPMI operation.
|
|
|
|
*
|
|
|
|
* Lousy hardware makes this hard. This is only enabled for systems
|
|
|
|
* that are not BT and do not have interrupts. It starts spinning
|
|
|
|
* when an operation is complete or until max_busy tells it to stop
|
|
|
|
* (if that is enabled). See the paragraph on kimid_max_busy_us in
|
|
|
|
* Documentation/IPMI.txt for details.
|
|
|
|
*/
|
2005-11-07 16:00:03 +07:00
|
|
|
static int ipmi_thread(void *data)
|
|
|
|
{
|
|
|
|
struct smi_info *smi_info = data;
|
2005-11-07 16:00:04 +07:00
|
|
|
unsigned long flags;
|
2005-11-07 16:00:03 +07:00
|
|
|
enum si_sm_result smi_result;
|
2010-03-11 06:23:06 +07:00
|
|
|
struct timespec busy_until;
|
2005-11-07 16:00:03 +07:00
|
|
|
|
2010-03-11 06:23:06 +07:00
|
|
|
ipmi_si_set_not_busy(&busy_until);
|
2005-11-07 16:00:03 +07:00
|
|
|
set_user_nice(current, 19);
|
2005-11-07 16:00:04 +07:00
|
|
|
while (!kthread_should_stop()) {
|
2010-03-11 06:23:06 +07:00
|
|
|
int busy_wait;
|
|
|
|
|
2005-11-07 16:00:03 +07:00
|
|
|
spin_lock_irqsave(&(smi_info->si_lock), flags);
|
2006-03-31 17:30:40 +07:00
|
|
|
smi_result = smi_event_handler(smi_info, 0);
|
2005-11-07 16:00:03 +07:00
|
|
|
spin_unlock_irqrestore(&(smi_info->si_lock), flags);
|
2010-03-11 06:23:06 +07:00
|
|
|
busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
|
|
|
|
&busy_until);
|
2008-04-29 15:01:10 +07:00
|
|
|
if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
|
|
|
|
; /* do nothing */
|
2010-03-11 06:23:06 +07:00
|
|
|
else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
|
2006-06-27 16:54:04 +07:00
|
|
|
schedule();
|
2010-05-27 04:43:49 +07:00
|
|
|
else if (smi_result == SI_SM_IDLE)
|
|
|
|
schedule_timeout_interruptible(100);
|
2005-11-07 16:00:04 +07:00
|
|
|
else
|
2010-06-30 05:05:31 +07:00
|
|
|
schedule_timeout_interruptible(1);
|
2005-11-07 16:00:03 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void poll(void *send_info)
|
|
|
|
{
|
|
|
|
struct smi_info *smi_info = send_info;
|
2012-03-29 04:42:50 +07:00
|
|
|
unsigned long flags = 0;
|
|
|
|
int run_to_completion = smi_info->run_to_completion;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-07 11:41:06 +07:00
|
|
|
/*
|
|
|
|
* Make sure there is some delay in the poll loop so we can
|
|
|
|
* drive time forward and timeout things.
|
|
|
|
*/
|
|
|
|
udelay(10);
|
2012-03-29 04:42:50 +07:00
|
|
|
if (!run_to_completion)
|
|
|
|
spin_lock_irqsave(&smi_info->si_lock, flags);
|
2006-12-07 11:41:06 +07:00
|
|
|
smi_event_handler(smi_info, 10);
|
2012-03-29 04:42:50 +07:00
|
|
|
if (!run_to_completion)
|
|
|
|
spin_unlock_irqrestore(&smi_info->si_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void request_events(void *send_info)
|
|
|
|
{
|
|
|
|
struct smi_info *smi_info = send_info;
|
|
|
|
|
2009-04-22 02:24:03 +07:00
|
|
|
if (atomic_read(&smi_info->stop_operation) ||
|
|
|
|
!smi_info->has_event_buffer)
|
2006-12-07 11:41:07 +07:00
|
|
|
return;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_set(&smi_info->req_events, 1);
|
|
|
|
}
|
|
|
|
|
2006-12-10 17:19:06 +07:00
|
|
|
static int initialized;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
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;
|
2005-11-07 15:59:56 +07:00
|
|
|
long time_diff;
|
2010-05-27 04:43:49 +07:00
|
|
|
long timeout;
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef DEBUG_TIMING
|
|
|
|
struct timeval t;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&(smi_info->si_lock), flags);
|
|
|
|
#ifdef DEBUG_TIMING
|
|
|
|
do_gettimeofday(&t);
|
2008-04-29 15:01:10 +07:00
|
|
|
printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
jiffies_now = jiffies;
|
2005-11-07 15:59:56 +07:00
|
|
|
time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Running with interrupts, only do long timeouts. */
|
2010-05-27 04:43:49 +07:00
|
|
|
timeout = jiffies + SI_TIMEOUT_JIFFIES;
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, long_timeouts);
|
2010-05-27 04:43:49 +07:00
|
|
|
goto do_mod_timer;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If the state machine asks for a short delay, then shorten
|
|
|
|
* the timer timeout.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
if (smi_result == SI_SM_CALL_WITH_DELAY) {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, short_timeouts);
|
2010-05-27 04:43:49 +07:00
|
|
|
timeout = jiffies + 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, long_timeouts);
|
2010-05-27 04:43:49 +07:00
|
|
|
timeout = jiffies + SI_TIMEOUT_JIFFIES;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:49 +07:00
|
|
|
do_mod_timer:
|
|
|
|
if (smi_result != SI_SM_IDLE)
|
|
|
|
mod_timer(&(smi_info->si_timer), timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
static irqreturn_t si_irq_handler(int irq, void *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct smi_info *smi_info = data;
|
|
|
|
unsigned long flags;
|
|
|
|
#ifdef DEBUG_TIMING
|
|
|
|
struct timeval t;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&(smi_info->si_lock), flags);
|
|
|
|
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, interrupts);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef DEBUG_TIMING
|
|
|
|
do_gettimeofday(&t);
|
2008-04-29 15:01:10 +07:00
|
|
|
printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
smi_event_handler(smi_info, 0);
|
|
|
|
spin_unlock_irqrestore(&(smi_info->si_lock), flags);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
static irqreturn_t si_bt_irq_handler(int irq, void *data)
|
2005-05-01 22:59:11 +07:00
|
|
|
{
|
|
|
|
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);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
return si_irq_handler(irq, data);
|
2005-05-01 22:59:11 +07:00
|
|
|
}
|
|
|
|
|
2006-03-31 17:30:39 +07:00
|
|
|
static int smi_start_processing(void *send_info,
|
|
|
|
ipmi_smi_t intf)
|
|
|
|
{
|
|
|
|
struct smi_info *new_smi = send_info;
|
2006-10-03 15:13:59 +07:00
|
|
|
int enable = 0;
|
2006-03-31 17:30:39 +07:00
|
|
|
|
|
|
|
new_smi->intf = intf;
|
|
|
|
|
2007-10-18 17:07:08 +07:00
|
|
|
/* Try to claim any interrupts. */
|
|
|
|
if (new_smi->irq_setup)
|
|
|
|
new_smi->irq_setup(new_smi);
|
|
|
|
|
2006-03-31 17:30:39 +07:00
|
|
|
/* 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);
|
|
|
|
|
2006-10-03 15:13:59 +07:00
|
|
|
/*
|
|
|
|
* Check if the user forcefully enabled the daemon.
|
|
|
|
*/
|
|
|
|
if (new_smi->intf_num < num_force_kipmid)
|
|
|
|
enable = force_kipmid[new_smi->intf_num];
|
2006-10-01 13:28:20 +07:00
|
|
|
/*
|
|
|
|
* The BT interface is efficient enough to not need a thread,
|
|
|
|
* and there is no need for a thread if we have interrupts.
|
|
|
|
*/
|
2008-04-29 15:01:10 +07:00
|
|
|
else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
|
2006-10-03 15:13:59 +07:00
|
|
|
enable = 1;
|
|
|
|
|
|
|
|
if (enable) {
|
2006-03-31 17:30:39 +07:00
|
|
|
new_smi->thread = kthread_run(ipmi_thread, new_smi,
|
|
|
|
"kipmi%d", new_smi->intf_num);
|
|
|
|
if (IS_ERR(new_smi->thread)) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_notice(new_smi->dev, "Could not start"
|
|
|
|
" kernel thread due to error %ld, only using"
|
|
|
|
" timers to drive the interface\n",
|
|
|
|
PTR_ERR(new_smi->thread));
|
2006-03-31 17:30:39 +07:00
|
|
|
new_smi->thread = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-05-01 22:59:11 +07:00
|
|
|
|
2010-12-08 09:10:16 +07:00
|
|
|
static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
|
|
|
|
{
|
|
|
|
struct smi_info *smi = send_info;
|
|
|
|
|
|
|
|
data->addr_src = smi->addr_source;
|
|
|
|
data->dev = smi->dev;
|
|
|
|
data->addr_info = smi->addr_info;
|
|
|
|
get_device(smi->dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-07 11:41:02 +07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
static struct ipmi_smi_handlers handlers = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.owner = THIS_MODULE,
|
2006-03-31 17:30:39 +07:00
|
|
|
.start_processing = smi_start_processing,
|
2010-12-08 09:10:16 +07:00
|
|
|
.get_smi_info = get_smi_info,
|
2005-04-17 05:20:36 +07:00
|
|
|
.sender = sender,
|
|
|
|
.request_events = request_events,
|
2006-12-07 11:41:02 +07:00
|
|
|
.set_maintenance_mode = set_maintenance_mode,
|
2005-04-17 05:20:36 +07:00
|
|
|
.set_run_to_completion = set_run_to_completion,
|
|
|
|
.poll = poll,
|
|
|
|
};
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
static LIST_HEAD(smi_infos);
|
2006-03-31 17:30:41 +07:00
|
|
|
static DEFINE_MUTEX(smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
static int smi_num; /* Used to sequence the SMIs */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#define DEFAULT_REGSPACING 1
|
2007-05-08 14:23:51 +07:00
|
|
|
#define DEFAULT_REGSIZE 1
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-02-28 08:05:12 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
static bool si_tryacpi = 1;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DMI
|
|
|
|
static bool si_trydmi = 1;
|
|
|
|
#endif
|
2013-02-28 08:05:13 +07:00
|
|
|
static bool si_tryplatform = 1;
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
static bool si_trypci = 1;
|
|
|
|
#endif
|
2012-01-13 06:02:20 +07:00
|
|
|
static bool si_trydefaults = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
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];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_addrs;
|
2005-04-17 05:20:36 +07:00
|
|
|
static unsigned int ports[SI_MAX_PARMS];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_ports;
|
2005-04-17 05:20:36 +07:00
|
|
|
static int irqs[SI_MAX_PARMS];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_irqs;
|
2005-04-17 05:20:36 +07:00
|
|
|
static int regspacings[SI_MAX_PARMS];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_regspacings;
|
2005-04-17 05:20:36 +07:00
|
|
|
static int regsizes[SI_MAX_PARMS];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_regsizes;
|
2005-04-17 05:20:36 +07:00
|
|
|
static int regshifts[SI_MAX_PARMS];
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_regshifts;
|
2010-03-11 06:23:07 +07:00
|
|
|
static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
|
2007-10-15 01:35:30 +07:00
|
|
|
static unsigned int num_slave_addrs;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
#define IPMI_IO_ADDR_SPACE 0
|
|
|
|
#define IPMI_MEM_ADDR_SPACE 1
|
2006-12-10 17:19:08 +07:00
|
|
|
static char *addr_space_to_str[] = { "i/o", "mem" };
|
2006-12-07 11:41:07 +07:00
|
|
|
|
|
|
|
static int hotmod_handler(const char *val, struct kernel_param *kp);
|
|
|
|
|
|
|
|
module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
|
|
|
|
MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
|
|
|
|
" Documentation/IPMI.txt in the kernel sources for the"
|
|
|
|
" gory details.");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-02-28 08:05:12 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
module_param_named(tryacpi, si_tryacpi, bool, 0);
|
|
|
|
MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
|
|
|
|
" default scan of the interfaces identified via ACPI");
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DMI
|
|
|
|
module_param_named(trydmi, si_trydmi, bool, 0);
|
|
|
|
MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
|
|
|
|
" default scan of the interfaces identified via DMI");
|
|
|
|
#endif
|
2013-02-28 08:05:13 +07:00
|
|
|
module_param_named(tryplatform, si_tryplatform, bool, 0);
|
|
|
|
MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
|
|
|
|
" default scan of the interfaces identified via platform"
|
|
|
|
" interfaces like openfirmware");
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
module_param_named(trypci, si_trypci, bool, 0);
|
|
|
|
MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
|
|
|
|
" default scan of the interfaces identified via pci");
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
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");
|
2007-10-15 01:35:30 +07:00
|
|
|
module_param_array(addrs, ulong, &num_addrs, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
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.");
|
2007-10-15 01:35:30 +07:00
|
|
|
module_param_array(ports, uint, &num_ports, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
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.");
|
2006-10-03 15:13:59 +07:00
|
|
|
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.");
|
2006-12-07 11:41:07 +07:00
|
|
|
module_param(unload_when_empty, int, 0);
|
|
|
|
MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
|
|
|
|
" specified or found, default is 1. Setting to 0"
|
|
|
|
" is useful for hot add of devices using hotmod.");
|
2010-03-11 06:23:06 +07:00
|
|
|
module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
|
|
|
|
MODULE_PARM_DESC(kipmid_max_busy_us,
|
|
|
|
"Max time (in microseconds) to busy-wait for IPMI data before"
|
|
|
|
" sleeping. 0 (default) means to wait forever. Set to 100-500"
|
|
|
|
" if kipmid is using up a lot of CPU time.");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
static void std_irq_cleanup(struct smi_info *info)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
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);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int std_irq_setup(struct smi_info *info)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info->irq)
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
|
2005-05-01 22:59:11 +07:00
|
|
|
if (info->si_type == SI_BT) {
|
|
|
|
rv = request_irq(info->irq,
|
|
|
|
si_bt_irq_handler,
|
2014-01-25 03:00:50 +07:00
|
|
|
IRQF_SHARED,
|
2005-05-01 22:59:11 +07:00
|
|
|
DEVICE_NAME,
|
|
|
|
info);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!rv)
|
2005-05-01 22:59:11 +07:00
|
|
|
/* 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,
|
2014-01-25 03:00:50 +07:00
|
|
|
IRQF_SHARED,
|
2005-05-01 22:59:11 +07:00
|
|
|
DEVICE_NAME,
|
|
|
|
info);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(info->dev, "%s unable to claim interrupt %d,"
|
|
|
|
" running polled\n",
|
|
|
|
DEVICE_NAME, info->irq);
|
2005-04-17 05:20:36 +07:00
|
|
|
info->irq = 0;
|
|
|
|
} else {
|
2006-03-26 16:37:20 +07:00
|
|
|
info->irq_cleanup = std_irq_cleanup;
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(info->dev, "Using irq %d\n", info->irq);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
return inb(addr + (offset * io->regspacing));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void port_outb(struct si_sm_io *io, unsigned int offset,
|
|
|
|
unsigned char b)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
outb(b, addr + (offset * io->regspacing));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void port_outw(struct si_sm_io *io, unsigned int offset,
|
|
|
|
unsigned char b)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
outw(b << io->regshift, addr + (offset * io->regspacing));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void port_outl(struct si_sm_io *io, unsigned int offset,
|
|
|
|
unsigned char b)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = io->addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
outl(b << io->regshift, addr+(offset * io->regspacing));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void port_cleanup(struct smi_info *info)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = info->io.addr_data;
|
2006-05-31 11:25:57 +07:00
|
|
|
int idx;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (addr) {
|
2008-04-29 15:01:10 +07:00
|
|
|
for (idx = 0; idx < info->io_size; idx++)
|
2006-05-31 11:25:57 +07:00
|
|
|
release_region(addr + idx * info->io.regspacing,
|
|
|
|
info->io.regsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int port_setup(struct smi_info *info)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned int addr = info->io.addr_data;
|
2006-05-31 11:25:57 +07:00
|
|
|
int idx;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!addr)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
info->io_cleanup = port_cleanup;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Figure out the actual inb/inw/inl/etc routine to use based
|
|
|
|
* upon the register size.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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:
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(info->dev, "Invalid register size: %d\n",
|
|
|
|
info->io.regsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Some BIOSes reserve disjoint I/O regions in their ACPI
|
2006-05-31 11:25:57 +07:00
|
|
|
* tables. This causes problems when trying to register the
|
|
|
|
* entire I/O region. Therefore we must register each I/O
|
|
|
|
* port separately.
|
|
|
|
*/
|
2008-04-29 15:01:10 +07:00
|
|
|
for (idx = 0; idx < info->io_size; idx++) {
|
2006-05-31 11:25:57 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return readb((io->addr)+(offset * io->regspacing));
|
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char b)
|
|
|
|
{
|
|
|
|
writeb(b, (io->addr)+(offset * io->regspacing));
|
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
|
2006-11-09 08:44:56 +07:00
|
|
|
& 0xff;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char b)
|
|
|
|
{
|
|
|
|
writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
|
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
|
2006-11-09 08:44:56 +07:00
|
|
|
& 0xff;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-02-03 18:04:40 +07:00
|
|
|
static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
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)
|
2006-11-09 08:44:56 +07:00
|
|
|
& 0xff;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned long addr = info->io.addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
int mapsize;
|
|
|
|
|
|
|
|
if (info->io.addr) {
|
|
|
|
iounmap(info->io.addr);
|
|
|
|
|
|
|
|
mapsize = ((info->io_size * info->io.regspacing)
|
|
|
|
- (info->io.regspacing - info->io.regsize));
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
release_mem_region(addr, mapsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mem_setup(struct smi_info *info)
|
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
unsigned long addr = info->io.addr_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
int mapsize;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!addr)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
info->io_cleanup = mem_cleanup;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Figure out the actual readb/readw/readl/etc routine to use based
|
|
|
|
* upon the register size.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
switch (info->io.regsize) {
|
|
|
|
case 1:
|
2006-02-03 18:04:40 +07:00
|
|
|
info->io.inputb = intf_mem_inb;
|
|
|
|
info->io.outputb = intf_mem_outb;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 2:
|
2006-02-03 18:04:40 +07:00
|
|
|
info->io.inputb = intf_mem_inw;
|
|
|
|
info->io.outputb = intf_mem_outw;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 4:
|
2006-02-03 18:04:40 +07:00
|
|
|
info->io.inputb = intf_mem_inl;
|
|
|
|
info->io.outputb = intf_mem_outl;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
#ifdef readq
|
|
|
|
case 8:
|
|
|
|
info->io.inputb = mem_inq;
|
|
|
|
info->io.outputb = mem_outq;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(info->dev, "Invalid register size: %d\n",
|
|
|
|
info->io.regsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Calculate the total amount of memory to claim. This is an
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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
|
2008-04-29 15:01:10 +07:00
|
|
|
* register.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
mapsize = ((info->io_size * info->io.regspacing)
|
|
|
|
- (info->io.regspacing - info->io.regsize));
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EIO;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr = ioremap(addr, mapsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (info->io.addr == NULL) {
|
2006-03-26 16:37:20 +07:00
|
|
|
release_mem_region(addr, mapsize);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
/*
|
|
|
|
* Parms come in as <op1>[:op2[:op3...]]. ops are:
|
|
|
|
* add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
|
|
|
|
* Options are:
|
|
|
|
* rsp=<regspacing>
|
|
|
|
* rsi=<regsize>
|
|
|
|
* rsh=<regshift>
|
|
|
|
* irq=<irq>
|
|
|
|
* ipmb=<ipmb addr>
|
|
|
|
*/
|
|
|
|
enum hotmod_op { HM_ADD, HM_REMOVE };
|
|
|
|
struct hotmod_vals {
|
|
|
|
char *name;
|
|
|
|
int val;
|
|
|
|
};
|
|
|
|
static struct hotmod_vals hotmod_ops[] = {
|
|
|
|
{ "add", HM_ADD },
|
|
|
|
{ "remove", HM_REMOVE },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
static struct hotmod_vals hotmod_si[] = {
|
|
|
|
{ "kcs", SI_KCS },
|
|
|
|
{ "smic", SI_SMIC },
|
|
|
|
{ "bt", SI_BT },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
static struct hotmod_vals hotmod_as[] = {
|
|
|
|
{ "mem", IPMI_MEM_ADDR_SPACE },
|
|
|
|
{ "i/o", IPMI_IO_ADDR_SPACE },
|
|
|
|
{ NULL }
|
|
|
|
};
|
2006-12-10 17:19:08 +07:00
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
|
|
|
|
{
|
|
|
|
char *s;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
s = strchr(*curr, ',');
|
|
|
|
if (!s) {
|
|
|
|
printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
*s = '\0';
|
|
|
|
s++;
|
|
|
|
for (i = 0; hotmod_ops[i].name; i++) {
|
2006-12-10 17:19:08 +07:00
|
|
|
if (strcmp(*curr, v[i].name) == 0) {
|
2006-12-07 11:41:07 +07:00
|
|
|
*val = v[i].val;
|
|
|
|
*curr = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-12-10 17:19:08 +07:00
|
|
|
static int check_hotmod_int_op(const char *curr, const char *option,
|
|
|
|
const char *name, int *val)
|
|
|
|
{
|
|
|
|
char *n;
|
|
|
|
|
|
|
|
if (strcmp(curr, name) == 0) {
|
|
|
|
if (!option) {
|
|
|
|
printk(KERN_WARNING PFX
|
|
|
|
"No option given for '%s'\n",
|
|
|
|
curr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
*val = simple_strtoul(option, &n, 0);
|
|
|
|
if ((*n != '\0') || (*option == '\0')) {
|
|
|
|
printk(KERN_WARNING PFX
|
|
|
|
"Bad option given for '%s'\n",
|
|
|
|
curr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
static struct smi_info *smi_info_alloc(void)
|
|
|
|
{
|
|
|
|
struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
|
|
|
|
|
2012-03-29 04:42:50 +07:00
|
|
|
if (info)
|
2010-10-27 04:21:17 +07:00
|
|
|
spin_lock_init(&info->si_lock);
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
static int hotmod_handler(const char *val, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
char *str = kstrdup(val, GFP_KERNEL);
|
2006-12-10 17:19:08 +07:00
|
|
|
int rv;
|
2006-12-07 11:41:07 +07:00
|
|
|
char *next, *curr, *s, *n, *o;
|
|
|
|
enum hotmod_op op;
|
|
|
|
enum si_type si_type;
|
|
|
|
int addr_space;
|
|
|
|
unsigned long addr;
|
|
|
|
int regspacing;
|
|
|
|
int regsize;
|
|
|
|
int regshift;
|
|
|
|
int irq;
|
|
|
|
int ipmb;
|
|
|
|
int ival;
|
2006-12-10 17:19:08 +07:00
|
|
|
int len;
|
2006-12-07 11:41:07 +07:00
|
|
|
struct smi_info *info;
|
|
|
|
|
|
|
|
if (!str)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Kill any trailing spaces, as we can get a "\n" from echo. */
|
2006-12-10 17:19:08 +07:00
|
|
|
len = strlen(str);
|
|
|
|
ival = len - 1;
|
2006-12-07 11:41:07 +07:00
|
|
|
while ((ival >= 0) && isspace(str[ival])) {
|
|
|
|
str[ival] = '\0';
|
|
|
|
ival--;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (curr = str; curr; curr = next) {
|
|
|
|
regspacing = 1;
|
|
|
|
regsize = 1;
|
|
|
|
regshift = 0;
|
|
|
|
irq = 0;
|
2010-03-11 06:23:07 +07:00
|
|
|
ipmb = 0; /* Choose the default if not specified */
|
2006-12-07 11:41:07 +07:00
|
|
|
|
|
|
|
next = strchr(curr, ':');
|
|
|
|
if (next) {
|
|
|
|
*next = '\0';
|
|
|
|
next++;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = parse_str(hotmod_ops, &ival, "operation", &curr);
|
|
|
|
if (rv)
|
|
|
|
break;
|
|
|
|
op = ival;
|
|
|
|
|
|
|
|
rv = parse_str(hotmod_si, &ival, "interface type", &curr);
|
|
|
|
if (rv)
|
|
|
|
break;
|
|
|
|
si_type = ival;
|
|
|
|
|
|
|
|
rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
|
|
|
|
if (rv)
|
|
|
|
break;
|
|
|
|
|
|
|
|
s = strchr(curr, ',');
|
|
|
|
if (s) {
|
|
|
|
*s = '\0';
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
addr = simple_strtoul(curr, &n, 0);
|
|
|
|
if ((*n != '\0') || (*curr == '\0')) {
|
|
|
|
printk(KERN_WARNING PFX "Invalid hotmod address"
|
|
|
|
" '%s'\n", curr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (s) {
|
|
|
|
curr = s;
|
|
|
|
s = strchr(curr, ',');
|
|
|
|
if (s) {
|
|
|
|
*s = '\0';
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
o = strchr(curr, '=');
|
|
|
|
if (o) {
|
|
|
|
*o = '\0';
|
|
|
|
o++;
|
|
|
|
}
|
2006-12-10 17:19:08 +07:00
|
|
|
rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
|
|
|
|
if (rv < 0)
|
2006-12-07 11:41:07 +07:00
|
|
|
goto out;
|
2006-12-10 17:19:08 +07:00
|
|
|
else if (rv)
|
|
|
|
continue;
|
|
|
|
rv = check_hotmod_int_op(curr, o, "rsi", ®size);
|
|
|
|
if (rv < 0)
|
|
|
|
goto out;
|
|
|
|
else if (rv)
|
|
|
|
continue;
|
|
|
|
rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
|
|
|
|
if (rv < 0)
|
|
|
|
goto out;
|
|
|
|
else if (rv)
|
|
|
|
continue;
|
|
|
|
rv = check_hotmod_int_op(curr, o, "irq", &irq);
|
|
|
|
if (rv < 0)
|
|
|
|
goto out;
|
|
|
|
else if (rv)
|
|
|
|
continue;
|
|
|
|
rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
|
|
|
|
if (rv < 0)
|
|
|
|
goto out;
|
|
|
|
else if (rv)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rv = -EINVAL;
|
|
|
|
printk(KERN_WARNING PFX
|
|
|
|
"Invalid hotmod option '%s'\n",
|
|
|
|
curr);
|
|
|
|
goto out;
|
2006-12-07 11:41:07 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (op == HM_ADD) {
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2006-12-07 11:41:07 +07:00
|
|
|
if (!info) {
|
|
|
|
rv = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_HOTMOD;
|
2006-12-07 11:41:07 +07:00
|
|
|
info->si_type = si_type;
|
|
|
|
info->io.addr_data = addr;
|
|
|
|
info->io.addr_type = addr_space;
|
|
|
|
if (addr_space == IPMI_MEM_ADDR_SPACE)
|
|
|
|
info->io_setup = mem_setup;
|
|
|
|
else
|
|
|
|
info->io_setup = port_setup;
|
|
|
|
|
|
|
|
info->io.addr = NULL;
|
|
|
|
info->io.regspacing = regspacing;
|
|
|
|
if (!info->io.regspacing)
|
|
|
|
info->io.regspacing = DEFAULT_REGSPACING;
|
|
|
|
info->io.regsize = regsize;
|
|
|
|
if (!info->io.regsize)
|
|
|
|
info->io.regsize = DEFAULT_REGSPACING;
|
|
|
|
info->io.regshift = regshift;
|
|
|
|
info->irq = irq;
|
|
|
|
if (info->irq)
|
|
|
|
info->irq_setup = std_irq_setup;
|
|
|
|
info->slave_addr = ipmb;
|
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
rv = add_smi(info);
|
|
|
|
if (rv) {
|
2010-08-11 08:03:10 +07:00
|
|
|
kfree(info);
|
2014-01-25 03:00:53 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
rv = try_smi_init(info);
|
|
|
|
if (rv) {
|
|
|
|
cleanup_one_si(info);
|
|
|
|
goto out;
|
2010-08-11 08:03:10 +07:00
|
|
|
}
|
2006-12-07 11:41:07 +07:00
|
|
|
} else {
|
|
|
|
/* remove */
|
|
|
|
struct smi_info *e, *tmp_e;
|
|
|
|
|
|
|
|
mutex_lock(&smi_infos_lock);
|
|
|
|
list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
|
|
|
|
if (e->io.addr_type != addr_space)
|
|
|
|
continue;
|
|
|
|
if (e->si_type != si_type)
|
|
|
|
continue;
|
|
|
|
if (e->io.addr_data == addr)
|
|
|
|
cleanup_one_si(e);
|
|
|
|
}
|
|
|
|
mutex_unlock(&smi_infos_lock);
|
|
|
|
}
|
|
|
|
}
|
2006-12-10 17:19:08 +07:00
|
|
|
rv = len;
|
2006-12-07 11:41:07 +07:00
|
|
|
out:
|
|
|
|
kfree(str);
|
|
|
|
return rv;
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int hardcode_find_bmc(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2011-02-24 04:37:59 +07:00
|
|
|
int ret = -ENODEV;
|
2006-03-26 16:37:20 +07:00
|
|
|
int i;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct smi_info *info;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
for (i = 0; i < SI_MAX_PARMS; i++) {
|
|
|
|
if (!ports[i] && !addrs[i])
|
|
|
|
continue;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info)
|
2011-02-24 04:37:59 +07:00
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_HARDCODED;
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "probing via hardcoded address\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-10 17:19:08 +07:00
|
|
|
if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_KCS;
|
2006-12-10 17:19:08 +07:00
|
|
|
} else if (strcmp(si_type[i], "smic") == 0) {
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_SMIC;
|
2006-12-10 17:19:08 +07:00
|
|
|
} else if (strcmp(si_type[i], "bt") == 0) {
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_BT;
|
|
|
|
} else {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Interface type specified "
|
2006-03-26 16:37:20 +07:00
|
|
|
"for interface %d, was invalid: %s\n",
|
|
|
|
i, si_type[i]);
|
|
|
|
kfree(info);
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
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 {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Interface type specified "
|
|
|
|
"for interface %d, but port and address were "
|
|
|
|
"not set or set to zero.\n", i);
|
2006-03-26 16:37:20 +07:00
|
|
|
kfree(info);
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
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;
|
2010-03-11 06:23:07 +07:00
|
|
|
info->slave_addr = slave_addrs[i];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 08:03:10 +07:00
|
|
|
if (!add_smi(info)) {
|
2010-05-27 04:43:46 +07:00
|
|
|
if (try_smi_init(info))
|
|
|
|
cleanup_one_si(info);
|
2011-02-24 04:37:59 +07:00
|
|
|
ret = 0;
|
2010-08-11 08:03:10 +07:00
|
|
|
} else {
|
|
|
|
kfree(info);
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2011-02-24 04:37:59 +07:00
|
|
|
return ret;
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-24 23:09:07 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <linux/acpi.h>
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2006-12-10 17:19:06 +07:00
|
|
|
static int acpi_failure;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* For GPE-type interrupts. */
|
2010-12-13 12:38:46 +07:00
|
|
|
static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
|
|
|
|
u32 gpe_number, void *context)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct smi_info *smi_info = context;
|
|
|
|
unsigned long flags;
|
|
|
|
#ifdef DEBUG_TIMING
|
|
|
|
struct timeval t;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&(smi_info->si_lock), flags);
|
|
|
|
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_inc_stat(smi_info, interrupts);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#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);
|
|
|
|
spin_unlock_irqrestore(&(smi_info->si_lock), flags);
|
|
|
|
|
|
|
|
return ACPI_INTERRUPT_HANDLED;
|
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
static void acpi_gpe_irq_cleanup(struct smi_info *info)
|
|
|
|
{
|
|
|
|
if (!info->irq)
|
|
|
|
return;
|
|
|
|
|
|
|
|
acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int acpi_gpe_irq_setup(struct smi_info *info)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info->irq)
|
2005-04-17 05:20:36 +07:00
|
|
|
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) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
|
|
|
|
" running polled\n", DEVICE_NAME, info->irq);
|
2005-04-17 05:20:36 +07:00
|
|
|
info->irq = 0;
|
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
2006-03-26 16:37:20 +07:00
|
|
|
info->irq_cleanup = acpi_gpe_irq_cleanup;
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Defined at
|
2010-10-18 16:03:14 +07:00
|
|
|
* http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If bit 0 of InterruptType is set, then this is the SCI
|
|
|
|
* interrupt in the GPEx_STS register.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
u8 GPE;
|
|
|
|
|
|
|
|
s16 Reserved;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If bit 1 of InterruptType is set, then this is the I/O
|
|
|
|
* APIC/SAPIC interrupt.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
u32 GlobalSystemInterrupt;
|
|
|
|
|
|
|
|
/* The actual register address. */
|
|
|
|
struct acpi_generic_address addr;
|
|
|
|
|
|
|
|
u8 UID[4];
|
|
|
|
|
|
|
|
s8 spmi_id[1]; /* A '\0' terminated array starts here. */
|
|
|
|
};
|
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int try_init_spmi(struct SPMITable *spmi)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct smi_info *info;
|
2014-01-25 03:00:53 +07:00
|
|
|
int rv;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (spmi->IPMIlegacy != 1) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
|
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX "Could not allocate SI data (3)\n");
|
2006-03-26 16:37:20 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_SPMI;
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "probing via SPMI\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Figure out the interface type. */
|
2008-04-29 15:01:10 +07:00
|
|
|
switch (spmi->InterfaceType) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case 1: /* KCS */
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_KCS;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 2: /* SMIC */
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_SMIC;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 3: /* BT */
|
2006-03-26 16:37:20 +07:00
|
|
|
info->si_type = SI_BT;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
default:
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Unknown ACPI/SPMI SI type %d\n",
|
|
|
|
spmi->InterfaceType);
|
2006-03-26 16:37:20 +07:00
|
|
|
kfree(info);
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-02-02 23:48:22 +07:00
|
|
|
if (spmi->addr.bit_width) {
|
2005-05-01 22:59:10 +07:00
|
|
|
/* A (hopefully) properly formed register bit width. */
|
2007-02-02 23:48:22 +07:00
|
|
|
info->io.regspacing = spmi->addr.bit_width / 8;
|
2005-05-01 22:59:10 +07:00
|
|
|
} else {
|
|
|
|
info->io.regspacing = DEFAULT_REGSPACING;
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.regsize = info->io.regspacing;
|
2007-02-02 23:48:22 +07:00
|
|
|
info->io.regshift = spmi->addr.bit_offset;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-02-02 23:48:22 +07:00
|
|
|
if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
|
2005-04-17 05:20:36 +07:00
|
|
|
info->io_setup = mem_setup;
|
2007-05-13 00:36:58 +07:00
|
|
|
info->io.addr_type = IPMI_MEM_ADDR_SPACE;
|
2007-02-02 23:48:22 +07:00
|
|
|
} else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
|
2005-04-17 05:20:36 +07:00
|
|
|
info->io_setup = port_setup;
|
2007-05-13 00:36:58 +07:00
|
|
|
info->io.addr_type = IPMI_IO_ADDR_SPACE;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
kfree(info);
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Unknown ACPI I/O Address type\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr_data = spmi->addr.address;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 08:03:10 +07:00
|
|
|
pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n",
|
|
|
|
(info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
|
|
|
|
info->io.addr_data, info->io.regsize, info->io.regspacing,
|
|
|
|
info->irq);
|
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
rv = add_smi(info);
|
|
|
|
if (rv)
|
2010-08-11 08:03:10 +07:00
|
|
|
kfree(info);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
return rv;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static void spmi_find_bmc(void)
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
struct SPMITable *spmi;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (acpi_failure)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; ; i++) {
|
2007-02-02 23:48:22 +07:00
|
|
|
status = acpi_get_table(ACPI_SIG_SPMI, i+1,
|
|
|
|
(struct acpi_table_header **)&spmi);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (status != AE_OK)
|
|
|
|
return;
|
|
|
|
|
2009-11-18 07:05:29 +07:00
|
|
|
try_init_spmi(spmi);
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
|
|
|
}
|
2009-11-18 07:05:34 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int ipmi_pnp_probe(struct pnp_dev *dev,
|
2009-11-18 07:05:34 +07:00
|
|
|
const struct pnp_device_id *dev_id)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev;
|
|
|
|
struct smi_info *info;
|
2010-09-23 03:04:53 +07:00
|
|
|
struct resource *res, *res_second;
|
2009-11-18 07:05:34 +07:00
|
|
|
acpi_handle handle;
|
|
|
|
acpi_status status;
|
|
|
|
unsigned long long tmp;
|
2014-01-25 03:00:53 +07:00
|
|
|
int rv;
|
2009-11-18 07:05:34 +07:00
|
|
|
|
|
|
|
acpi_dev = pnp_acpi_device(dev);
|
|
|
|
if (!acpi_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2009-11-18 07:05:34 +07:00
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_ACPI;
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "probing via ACPI\n");
|
2009-11-18 07:05:34 +07:00
|
|
|
|
|
|
|
handle = acpi_dev->handle;
|
2010-12-08 09:10:16 +07:00
|
|
|
info->addr_info.acpi_info.acpi_handle = handle;
|
2009-11-18 07:05:34 +07:00
|
|
|
|
|
|
|
/* _IFT tells us the interface type: KCS, BT, etc */
|
|
|
|
status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
goto err_free;
|
|
|
|
|
|
|
|
switch (tmp) {
|
|
|
|
case 1:
|
|
|
|
info->si_type = SI_KCS;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
info->si_type = SI_SMIC;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
info->si_type = SI_BT;
|
|
|
|
break;
|
|
|
|
default:
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
|
2009-11-18 07:05:34 +07:00
|
|
|
goto err_free;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_IO, 0);
|
|
|
|
if (res) {
|
2009-11-18 07:05:34 +07:00
|
|
|
info->io_setup = port_setup;
|
|
|
|
info->io.addr_type = IPMI_IO_ADDR_SPACE;
|
|
|
|
} else {
|
2010-05-27 04:43:52 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_MEM, 0);
|
|
|
|
if (res) {
|
|
|
|
info->io_setup = mem_setup;
|
|
|
|
info->io.addr_type = IPMI_MEM_ADDR_SPACE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!res) {
|
2009-11-18 07:05:34 +07:00
|
|
|
dev_err(&dev->dev, "no I/O or memory address\n");
|
|
|
|
goto err_free;
|
|
|
|
}
|
2010-05-27 04:43:52 +07:00
|
|
|
info->io.addr_data = res->start;
|
2009-11-18 07:05:34 +07:00
|
|
|
|
|
|
|
info->io.regspacing = DEFAULT_REGSPACING;
|
2010-09-23 03:04:53 +07:00
|
|
|
res_second = pnp_get_resource(dev,
|
ipmi: fix ACPI detection with regspacing
After the commit that changed ipmi_si detecting sequence from SMBIOS/ACPI
to ACPI/SMBIOS,
| commit 754d453185275951d39792865927ec494fa1ebd8
| Author: Matthew Garrett <mjg@redhat.com>
| Date: Wed May 26 14:43:47 2010 -0700
|
| ipmi: change device discovery order
|
| The ipmi spec provides an ordering for si discovery. Change the driver to
| match, with the exception of preferring smbios to SPMI as HPs (at least)
| contain accurate information in the former but not the latter.
ipmi_si can not be initialized.
[ 138.799739] calling init_ipmi_devintf+0x0/0x109 @ 1
[ 138.805050] ipmi device interface
[ 138.818131] initcall init_ipmi_devintf+0x0/0x109 returned 0 after 12797 usecs
[ 138.822998] calling init_ipmi_si+0x0/0xa90 @ 1
[ 138.840276] IPMI System Interface driver.
[ 138.846137] ipmi_si: probing via ACPI
[ 138.849225] ipmi_si 00:09: [io 0x0ca2] regsize 1 spacing 1 irq 0
[ 138.864438] ipmi_si: Adding ACPI-specified kcs state machine
[ 138.870893] ipmi_si: probing via SMBIOS
[ 138.880945] ipmi_si: Adding SMBIOS-specified kcs state machineipmi_si: duplicate interface
[ 138.896511] ipmi_si: probing via SPMI
[ 138.899861] ipmi_si: Adding SPMI-specified kcs state machineipmi_si: duplicate interface
[ 138.917095] ipmi_si: Trying ACPI-specified kcs state machine at i/o address 0xca2, slave address 0x0, irq 0
[ 138.928658] ipmi_si: Interface detection failed
[ 138.953411] initcall init_ipmi_si+0x0/0xa90 returned 0 after 110847 usecs
in smbios has
DMI/SMBIOS
Handle 0x00C5, DMI type 38, 18 bytes
IPMI Device Information
Interface Type: KCS (Keyboard Control Style)
Specification Version: 2.0
I2C Slave Address: 0x00
NV Storage Device: Not Present
Base Address: 0x0000000000000CA2 (I/O)
Register Spacing: 32-bit Boundaries
in DSDT has
Device (BMC)
{
Name (_HID, EisaId ("IPI0001"))
Method (_STA, 0, NotSerialized)
{
If (LEqual (OSN, Zero))
{
Return (Zero)
}
Return (0x0F)
}
Name (_STR, Unicode ("IPMI_KCS"))
Name (_UID, Zero)
Name (_CRS, ResourceTemplate ()
{
IO (Decode16,
0x0CA2, // Range Minimum
0x0CA2, // Range Maximum
0x00, // Alignment
0x01, // Length
)
IO (Decode16,
0x0CA6, // Range Minimum
0x0CA6, // Range Maximum
0x00, // Alignment
0x01, // Length
)
})
Method (_IFT, 0, NotSerialized)
{
Return (One)
}
Method (_SRV, 0, NotSerialized)
{
Return (0x0200)
}
}
so the reg spacing should be 4 instead of 1.
Try to calculate regspacing for this kind of system.
Observed on a Sun Fire X4800. Other OSes work and pass certification.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: Bjorn Helgaas <bjorn.helgaas@hp.com>
Acked-by: Matthew Garrett <mjg@redhat.com>
Cc: Len Brown <len.brown@intel.com>
Cc: Myron Stowe <myron.stowe@hp.com>
Cc: Corey Minyard <minyard@acm.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-10 07:18:22 +07:00
|
|
|
(info->io.addr_type == IPMI_IO_ADDR_SPACE) ?
|
|
|
|
IORESOURCE_IO : IORESOURCE_MEM,
|
|
|
|
1);
|
2010-09-23 03:04:53 +07:00
|
|
|
if (res_second) {
|
|
|
|
if (res_second->start > info->io.addr_data)
|
|
|
|
info->io.regspacing = res_second->start - info->io.addr_data;
|
ipmi: fix ACPI detection with regspacing
After the commit that changed ipmi_si detecting sequence from SMBIOS/ACPI
to ACPI/SMBIOS,
| commit 754d453185275951d39792865927ec494fa1ebd8
| Author: Matthew Garrett <mjg@redhat.com>
| Date: Wed May 26 14:43:47 2010 -0700
|
| ipmi: change device discovery order
|
| The ipmi spec provides an ordering for si discovery. Change the driver to
| match, with the exception of preferring smbios to SPMI as HPs (at least)
| contain accurate information in the former but not the latter.
ipmi_si can not be initialized.
[ 138.799739] calling init_ipmi_devintf+0x0/0x109 @ 1
[ 138.805050] ipmi device interface
[ 138.818131] initcall init_ipmi_devintf+0x0/0x109 returned 0 after 12797 usecs
[ 138.822998] calling init_ipmi_si+0x0/0xa90 @ 1
[ 138.840276] IPMI System Interface driver.
[ 138.846137] ipmi_si: probing via ACPI
[ 138.849225] ipmi_si 00:09: [io 0x0ca2] regsize 1 spacing 1 irq 0
[ 138.864438] ipmi_si: Adding ACPI-specified kcs state machine
[ 138.870893] ipmi_si: probing via SMBIOS
[ 138.880945] ipmi_si: Adding SMBIOS-specified kcs state machineipmi_si: duplicate interface
[ 138.896511] ipmi_si: probing via SPMI
[ 138.899861] ipmi_si: Adding SPMI-specified kcs state machineipmi_si: duplicate interface
[ 138.917095] ipmi_si: Trying ACPI-specified kcs state machine at i/o address 0xca2, slave address 0x0, irq 0
[ 138.928658] ipmi_si: Interface detection failed
[ 138.953411] initcall init_ipmi_si+0x0/0xa90 returned 0 after 110847 usecs
in smbios has
DMI/SMBIOS
Handle 0x00C5, DMI type 38, 18 bytes
IPMI Device Information
Interface Type: KCS (Keyboard Control Style)
Specification Version: 2.0
I2C Slave Address: 0x00
NV Storage Device: Not Present
Base Address: 0x0000000000000CA2 (I/O)
Register Spacing: 32-bit Boundaries
in DSDT has
Device (BMC)
{
Name (_HID, EisaId ("IPI0001"))
Method (_STA, 0, NotSerialized)
{
If (LEqual (OSN, Zero))
{
Return (Zero)
}
Return (0x0F)
}
Name (_STR, Unicode ("IPMI_KCS"))
Name (_UID, Zero)
Name (_CRS, ResourceTemplate ()
{
IO (Decode16,
0x0CA2, // Range Minimum
0x0CA2, // Range Maximum
0x00, // Alignment
0x01, // Length
)
IO (Decode16,
0x0CA6, // Range Minimum
0x0CA6, // Range Maximum
0x00, // Alignment
0x01, // Length
)
})
Method (_IFT, 0, NotSerialized)
{
Return (One)
}
Method (_SRV, 0, NotSerialized)
{
Return (0x0200)
}
}
so the reg spacing should be 4 instead of 1.
Try to calculate regspacing for this kind of system.
Observed on a Sun Fire X4800. Other OSes work and pass certification.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Cc: Bjorn Helgaas <bjorn.helgaas@hp.com>
Acked-by: Matthew Garrett <mjg@redhat.com>
Cc: Len Brown <len.brown@intel.com>
Cc: Myron Stowe <myron.stowe@hp.com>
Cc: Corey Minyard <minyard@acm.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-10 07:18:22 +07:00
|
|
|
}
|
2009-11-18 07:05:34 +07:00
|
|
|
info->io.regsize = DEFAULT_REGSPACING;
|
|
|
|
info->io.regshift = 0;
|
|
|
|
|
|
|
|
/* If _GPE exists, use it; otherwise use standard interrupts */
|
|
|
|
status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
info->irq = tmp;
|
|
|
|
info->irq_setup = acpi_gpe_irq_setup;
|
|
|
|
} else if (pnp_irq_valid(dev, 0)) {
|
|
|
|
info->irq = pnp_irq(dev, 0);
|
|
|
|
info->irq_setup = std_irq_setup;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:51 +07:00
|
|
|
info->dev = &dev->dev;
|
2009-11-18 07:05:34 +07:00
|
|
|
pnp_set_drvdata(dev, info);
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n",
|
|
|
|
res, info->io.regsize, info->io.regspacing,
|
|
|
|
info->irq);
|
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
rv = add_smi(info);
|
|
|
|
if (rv)
|
|
|
|
kfree(info);
|
2010-08-11 08:03:10 +07:00
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
return rv;
|
2009-11-18 07:05:34 +07:00
|
|
|
|
|
|
|
err_free:
|
|
|
|
kfree(info);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-11-20 01:26:26 +07:00
|
|
|
static void ipmi_pnp_remove(struct pnp_dev *dev)
|
2009-11-18 07:05:34 +07:00
|
|
|
{
|
|
|
|
struct smi_info *info = pnp_get_drvdata(dev);
|
|
|
|
|
|
|
|
cleanup_one_si(info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct pnp_device_id pnp_dev_table[] = {
|
|
|
|
{"IPI0001", 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct pnp_driver ipmi_pnp_driver = {
|
|
|
|
.name = DEVICE_NAME,
|
|
|
|
.probe = ipmi_pnp_probe,
|
2012-12-22 06:12:08 +07:00
|
|
|
.remove = ipmi_pnp_remove,
|
2009-11-18 07:05:34 +07:00
|
|
|
.id_table = pnp_dev_table,
|
|
|
|
};
|
2013-09-05 18:36:35 +07:00
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
2006-01-12 03:17:44 +07:00
|
|
|
#ifdef CONFIG_DMI
|
2008-04-29 15:01:10 +07:00
|
|
|
struct dmi_ipmi_data {
|
2005-04-17 05:20:36 +07:00
|
|
|
u8 type;
|
|
|
|
u8 addr_space;
|
|
|
|
unsigned long base_addr;
|
|
|
|
u8 irq;
|
|
|
|
u8 offset;
|
|
|
|
u8 slave_addr;
|
2006-03-26 16:37:20 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int decode_dmi(const struct dmi_header *dm,
|
2006-03-26 16:37:20 +07:00
|
|
|
struct dmi_ipmi_data *dmi)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-04 02:15:40 +07:00
|
|
|
const u8 *data = (const u8 *)dm;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long base_addr;
|
|
|
|
u8 reg_spacing;
|
2005-09-07 05:18:37 +07:00
|
|
|
u8 len = dm->length;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->type = data[4];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
memcpy(&base_addr, data+8, sizeof(unsigned long));
|
|
|
|
if (len >= 0x11) {
|
|
|
|
if (base_addr & 1) {
|
|
|
|
/* I/O */
|
|
|
|
base_addr &= 0xFFFE;
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->addr_space = IPMI_IO_ADDR_SPACE;
|
2008-04-29 15:01:10 +07:00
|
|
|
} else
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Memory */
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->addr_space = IPMI_MEM_ADDR_SPACE;
|
2008-04-29 15:01:10 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* If bit 4 of byte 0x10 is set, then the lsb for the address
|
|
|
|
is odd. */
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->irq = data[0x11];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* The top two bits of byte 0x10 hold the register spacing. */
|
2005-09-07 05:18:37 +07:00
|
|
|
reg_spacing = (data[0x10] & 0xC0) >> 6;
|
2008-04-29 15:01:10 +07:00
|
|
|
switch (reg_spacing) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case 0x00: /* Byte boundaries */
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->offset = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 0x01: /* 32-bit boundaries */
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->offset = 4;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 0x02: /* 16-byte boundaries */
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->offset = 16;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Some other interface, just ignore it. */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Old DMI spec. */
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Note that technically, the lower bit of the base
|
2005-05-01 22:59:10 +07:00
|
|
|
* 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
|
2008-04-29 15:01:10 +07:00
|
|
|
* memory should use the newer spec, anyway.
|
|
|
|
*/
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->base_addr = base_addr & 0xfffe;
|
|
|
|
dmi->addr_space = IPMI_IO_ADDR_SPACE;
|
|
|
|
dmi->offset = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
dmi->slave_addr = data[6];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
struct smi_info *info;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX "Could not allocate SI data\n");
|
2006-03-26 16:37:20 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_SMBIOS;
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "probing via SMBIOS\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-07 05:18:45 +07:00
|
|
|
switch (ipmi_data->type) {
|
2006-03-26 16:37:20 +07:00
|
|
|
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:
|
2007-07-31 14:39:05 +07:00
|
|
|
kfree(info);
|
2006-03-26 16:37:20 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
switch (ipmi_data->addr_space) {
|
|
|
|
case IPMI_MEM_ADDR_SPACE:
|
2005-04-17 05:20:36 +07:00
|
|
|
info->io_setup = mem_setup;
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr_type = IPMI_MEM_ADDR_SPACE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPMI_IO_ADDR_SPACE:
|
2005-04-17 05:20:36 +07:00
|
|
|
info->io_setup = port_setup;
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr_type = IPMI_IO_ADDR_SPACE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(info);
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Unknown SMBIOS I/O Address type: %d\n",
|
2006-03-26 16:37:20 +07:00
|
|
|
ipmi_data->addr_space);
|
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr_data = ipmi_data->base_addr;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.regspacing = ipmi_data->offset;
|
|
|
|
if (!info->io.regspacing)
|
2005-04-17 05:20:36 +07:00
|
|
|
info->io.regspacing = DEFAULT_REGSPACING;
|
|
|
|
info->io.regsize = DEFAULT_REGSPACING;
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.regshift = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
info->slave_addr = ipmi_data->slave_addr;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
info->irq = ipmi_data->irq;
|
|
|
|
if (info->irq)
|
|
|
|
info->irq_setup = std_irq_setup;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 08:03:10 +07:00
|
|
|
pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n",
|
|
|
|
(info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
|
|
|
|
info->io.addr_data, info->io.regsize, info->io.regspacing,
|
|
|
|
info->irq);
|
|
|
|
|
2010-08-11 08:03:10 +07:00
|
|
|
if (add_smi(info))
|
|
|
|
kfree(info);
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static void dmi_find_bmc(void)
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
2007-10-04 02:15:40 +07:00
|
|
|
const struct dmi_device *dev = NULL;
|
2006-03-26 16:37:20 +07:00
|
|
|
struct dmi_ipmi_data data;
|
|
|
|
int rv;
|
|
|
|
|
|
|
|
while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
|
2006-10-03 15:13:52 +07:00
|
|
|
memset(&data, 0, sizeof(data));
|
2007-10-04 02:15:40 +07:00
|
|
|
rv = decode_dmi((const struct dmi_header *) dev->device_data,
|
|
|
|
&data);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!rv)
|
|
|
|
try_init_dmi(&data);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-01-12 03:17:44 +07:00
|
|
|
#endif /* CONFIG_DMI */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
#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
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define PCI_HP_VENDOR_ID 0x103C
|
|
|
|
#define PCI_MMC_DEVICE_ID 0x121A
|
|
|
|
#define PCI_MMC_ADDR_CW 0x10
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
static void ipmi_pci_cleanup(struct smi_info *info)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = info->addr_source_data;
|
|
|
|
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int ipmi_pci_probe_regspacing(struct smi_info *info)
|
2012-10-17 03:53:40 +07:00
|
|
|
{
|
|
|
|
if (info->si_type == SI_KCS) {
|
|
|
|
unsigned char status;
|
|
|
|
int regspacing;
|
|
|
|
|
|
|
|
info->io.regsize = DEFAULT_REGSIZE;
|
|
|
|
info->io.regshift = 0;
|
|
|
|
info->io_size = 2;
|
|
|
|
info->handlers = &kcs_smi_handlers;
|
|
|
|
|
|
|
|
/* detect 1, 4, 16byte spacing */
|
|
|
|
for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
|
|
|
|
info->io.regspacing = regspacing;
|
|
|
|
if (info->io_setup(info)) {
|
|
|
|
dev_err(info->dev,
|
|
|
|
"Could not setup I/O space\n");
|
|
|
|
return DEFAULT_REGSPACING;
|
|
|
|
}
|
|
|
|
/* write invalid cmd */
|
|
|
|
info->io.outputb(&info->io, 1, 0x10);
|
|
|
|
/* read status back */
|
|
|
|
status = info->io.inputb(&info->io, 1);
|
|
|
|
info->io_cleanup(info);
|
|
|
|
if (status)
|
|
|
|
return regspacing;
|
|
|
|
regspacing *= 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return DEFAULT_REGSPACING;
|
|
|
|
}
|
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int ipmi_pci_probe(struct pci_dev *pdev,
|
2006-03-26 16:37:20 +07:00
|
|
|
const struct pci_device_id *ent)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
int rv;
|
|
|
|
int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
|
|
|
|
struct smi_info *info;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!info)
|
2006-10-20 13:29:09 +07:00
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_PCI;
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(&pdev->dev, "probing via PCI");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
switch (class_type) {
|
|
|
|
case PCI_ERMC_CLASSCODE_TYPE_SMIC:
|
|
|
|
info->si_type = SI_SMIC;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
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);
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
|
2006-10-20 13:29:09 +07:00
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
rv = pci_enable_device(pdev);
|
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_err(&pdev->dev, "couldn't enable PCI device\n");
|
2006-03-26 16:37:20 +07:00
|
|
|
kfree(info);
|
|
|
|
return rv;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
info->addr_source_cleanup = ipmi_pci_cleanup;
|
|
|
|
info->addr_source_data = pdev;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
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;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.addr_data = pci_resource_start(pdev, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-10-17 03:53:40 +07:00
|
|
|
info->io.regspacing = ipmi_pci_probe_regspacing(info);
|
|
|
|
info->io.regsize = DEFAULT_REGSIZE;
|
2006-03-26 16:37:20 +07:00
|
|
|
info->io.regshift = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
info->irq = pdev->irq;
|
|
|
|
if (info->irq)
|
|
|
|
info->irq_setup = std_irq_setup;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:21 +07:00
|
|
|
info->dev = &pdev->dev;
|
2007-05-08 14:23:59 +07:00
|
|
|
pci_set_drvdata(pdev, info);
|
2006-03-26 16:37:21 +07:00
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
|
|
|
|
&pdev->resource[0], info->io.regsize, info->io.regspacing,
|
|
|
|
info->irq);
|
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
rv = add_smi(info);
|
|
|
|
if (rv) {
|
2010-08-11 08:03:10 +07:00
|
|
|
kfree(info);
|
2014-01-25 03:00:53 +07:00
|
|
|
pci_disable_device(pdev);
|
|
|
|
}
|
2010-08-11 08:03:10 +07:00
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
return rv;
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-20 01:26:26 +07:00
|
|
|
static void ipmi_pci_remove(struct pci_dev *pdev)
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
2007-05-08 14:23:59 +07:00
|
|
|
struct smi_info *info = pci_get_drvdata(pdev);
|
|
|
|
cleanup_one_si(info);
|
2014-01-25 03:00:53 +07:00
|
|
|
pci_disable_device(pdev);
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
static struct pci_device_id ipmi_pci_devices[] = {
|
|
|
|
{ PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
|
2007-09-19 12:46:32 +07:00
|
|
|
{ PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
|
|
|
|
{ 0, }
|
2006-03-26 16:37:20 +07:00
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
|
|
|
|
|
|
|
|
static struct pci_driver ipmi_pci_driver = {
|
2008-04-29 15:01:10 +07:00
|
|
|
.name = DEVICE_NAME,
|
|
|
|
.id_table = ipmi_pci_devices,
|
|
|
|
.probe = ipmi_pci_probe,
|
2012-12-22 06:12:08 +07:00
|
|
|
.remove = ipmi_pci_remove,
|
2006-03-26 16:37:20 +07:00
|
|
|
};
|
|
|
|
#endif /* CONFIG_PCI */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-19 00:19:24 +07:00
|
|
|
static struct of_device_id ipmi_match[];
|
2012-11-20 01:22:51 +07:00
|
|
|
static int ipmi_probe(struct platform_device *dev)
|
2007-05-08 14:23:51 +07:00
|
|
|
{
|
2011-02-24 04:37:59 +07:00
|
|
|
#ifdef CONFIG_OF
|
2011-05-19 00:19:24 +07:00
|
|
|
const struct of_device_id *match;
|
2007-05-08 14:23:51 +07:00
|
|
|
struct smi_info *info;
|
|
|
|
struct resource resource;
|
2010-11-17 03:33:50 +07:00
|
|
|
const __be32 *regsize, *regspacing, *regshift;
|
2010-04-14 06:12:29 +07:00
|
|
|
struct device_node *np = dev->dev.of_node;
|
2007-05-08 14:23:51 +07:00
|
|
|
int ret;
|
|
|
|
int proplen;
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(&dev->dev, "probing via device tree\n");
|
2007-05-08 14:23:51 +07:00
|
|
|
|
2011-05-19 00:19:24 +07:00
|
|
|
match = of_match_device(ipmi_match, &dev->dev);
|
|
|
|
if (!match)
|
2011-02-24 04:37:59 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2007-05-08 14:23:51 +07:00
|
|
|
ret = of_address_to_resource(np, 0, &resource);
|
|
|
|
if (ret) {
|
|
|
|
dev_warn(&dev->dev, PFX "invalid address from OF\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-15 13:42:12 +07:00
|
|
|
regsize = of_get_property(np, "reg-size", &proplen);
|
2007-05-08 14:23:51 +07:00
|
|
|
if (regsize && proplen != 4) {
|
|
|
|
dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-08-15 13:42:12 +07:00
|
|
|
regspacing = of_get_property(np, "reg-spacing", &proplen);
|
2007-05-08 14:23:51 +07:00
|
|
|
if (regspacing && proplen != 4) {
|
|
|
|
dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-08-15 13:42:12 +07:00
|
|
|
regshift = of_get_property(np, "reg-shift", &proplen);
|
2007-05-08 14:23:51 +07:00
|
|
|
if (regshift && proplen != 4) {
|
|
|
|
dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2007-05-08 14:23:51 +07:00
|
|
|
|
|
|
|
if (!info) {
|
|
|
|
dev_err(&dev->dev,
|
2010-05-27 04:43:52 +07:00
|
|
|
"could not allocate memory for OF probe\n");
|
2007-05-08 14:23:51 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-05-19 00:19:24 +07:00
|
|
|
info->si_type = (enum si_type) match->data;
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_DEVICETREE;
|
2007-05-08 14:23:51 +07:00
|
|
|
info->irq_setup = std_irq_setup;
|
|
|
|
|
2008-05-15 06:05:39 +07:00
|
|
|
if (resource.flags & 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;
|
|
|
|
}
|
|
|
|
|
2007-05-08 14:23:51 +07:00
|
|
|
info->io.addr_data = resource.start;
|
|
|
|
|
2010-11-17 03:33:50 +07:00
|
|
|
info->io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
|
|
|
|
info->io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
|
|
|
|
info->io.regshift = regshift ? be32_to_cpup(regshift) : 0;
|
2007-05-08 14:23:51 +07:00
|
|
|
|
2010-04-14 06:12:29 +07:00
|
|
|
info->irq = irq_of_parse_and_map(dev->dev.of_node, 0);
|
2007-05-08 14:23:51 +07:00
|
|
|
info->dev = &dev->dev;
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
|
2007-05-08 14:23:51 +07:00
|
|
|
info->io.addr_data, info->io.regsize, info->io.regspacing,
|
|
|
|
info->irq);
|
|
|
|
|
2009-05-05 02:40:54 +07:00
|
|
|
dev_set_drvdata(&dev->dev, info);
|
2007-05-08 14:23:51 +07:00
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
ret = add_smi(info);
|
|
|
|
if (ret) {
|
2010-08-11 08:03:10 +07:00
|
|
|
kfree(info);
|
2014-01-25 03:00:53 +07:00
|
|
|
return ret;
|
2010-08-11 08:03:10 +07:00
|
|
|
}
|
2011-02-24 04:37:59 +07:00
|
|
|
#endif
|
2010-08-11 08:03:10 +07:00
|
|
|
return 0;
|
2007-05-08 14:23:51 +07:00
|
|
|
}
|
|
|
|
|
2012-11-20 01:26:26 +07:00
|
|
|
static int ipmi_remove(struct platform_device *dev)
|
2007-05-08 14:23:51 +07:00
|
|
|
{
|
2011-02-24 04:37:59 +07:00
|
|
|
#ifdef CONFIG_OF
|
2009-05-05 02:40:54 +07:00
|
|
|
cleanup_one_si(dev_get_drvdata(&dev->dev));
|
2011-02-24 04:37:59 +07:00
|
|
|
#endif
|
2007-05-08 14:23:51 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct of_device_id ipmi_match[] =
|
|
|
|
{
|
2008-04-29 15:01:10 +07:00
|
|
|
{ .type = "ipmi", .compatible = "ipmi-kcs",
|
|
|
|
.data = (void *)(unsigned long) SI_KCS },
|
|
|
|
{ .type = "ipmi", .compatible = "ipmi-smic",
|
|
|
|
.data = (void *)(unsigned long) SI_SMIC },
|
|
|
|
{ .type = "ipmi", .compatible = "ipmi-bt",
|
|
|
|
.data = (void *)(unsigned long) SI_BT },
|
2007-05-08 14:23:51 +07:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2011-02-24 04:37:59 +07:00
|
|
|
static struct platform_driver ipmi_driver = {
|
2010-04-14 06:13:02 +07:00
|
|
|
.driver = {
|
2011-02-24 04:37:59 +07:00
|
|
|
.name = DEVICE_NAME,
|
2010-04-14 06:13:02 +07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.of_match_table = ipmi_match,
|
|
|
|
},
|
2011-02-24 04:37:59 +07:00
|
|
|
.probe = ipmi_probe,
|
2012-12-22 06:12:08 +07:00
|
|
|
.remove = ipmi_remove,
|
2007-05-08 14:23:51 +07:00
|
|
|
};
|
|
|
|
|
2013-09-05 18:36:36 +07:00
|
|
|
#ifdef CONFIG_PARISC
|
|
|
|
static int ipmi_parisc_probe(struct parisc_device *dev)
|
|
|
|
{
|
|
|
|
struct smi_info *info;
|
2014-01-29 02:12:35 +07:00
|
|
|
int rv;
|
2013-09-05 18:36:36 +07:00
|
|
|
|
|
|
|
info = smi_info_alloc();
|
|
|
|
|
|
|
|
if (!info) {
|
|
|
|
dev_err(&dev->dev,
|
|
|
|
"could not allocate memory for PARISC probe\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->si_type = SI_KCS;
|
|
|
|
info->addr_source = SI_DEVICETREE;
|
|
|
|
info->io_setup = mem_setup;
|
|
|
|
info->io.addr_type = IPMI_MEM_ADDR_SPACE;
|
|
|
|
info->io.addr_data = dev->hpa.start;
|
|
|
|
info->io.regsize = 1;
|
|
|
|
info->io.regspacing = 1;
|
|
|
|
info->io.regshift = 0;
|
|
|
|
info->irq = 0; /* no interrupt */
|
|
|
|
info->irq_setup = NULL;
|
|
|
|
info->dev = &dev->dev;
|
|
|
|
|
|
|
|
dev_dbg(&dev->dev, "addr 0x%lx\n", info->io.addr_data);
|
|
|
|
|
|
|
|
dev_set_drvdata(&dev->dev, info);
|
|
|
|
|
2014-01-25 03:00:53 +07:00
|
|
|
rv = add_smi(info);
|
|
|
|
if (rv) {
|
2013-09-05 18:36:36 +07:00
|
|
|
kfree(info);
|
2014-01-25 03:00:53 +07:00
|
|
|
return rv;
|
2013-09-05 18:36:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmi_parisc_remove(struct parisc_device *dev)
|
|
|
|
{
|
|
|
|
cleanup_one_si(dev_get_drvdata(&dev->dev));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct parisc_device_id ipmi_parisc_tbl[] = {
|
|
|
|
{ HPHW_MC, HVERSION_REV_ANY_ID, 0x004, 0xC0 },
|
|
|
|
{ 0, }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct parisc_driver ipmi_parisc_driver = {
|
|
|
|
.name = "ipmi",
|
|
|
|
.id_table = ipmi_parisc_tbl,
|
|
|
|
.probe = ipmi_parisc_probe,
|
|
|
|
.remove = ipmi_parisc_remove,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_PARISC */
|
|
|
|
|
2009-04-22 02:24:03 +07:00
|
|
|
static int wait_for_msg_done(struct smi_info *smi_info)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:21 +07:00
|
|
|
enum si_sm_result smi_result;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
|
2008-04-29 15:01:10 +07:00
|
|
|
for (;;) {
|
2005-11-07 16:00:02 +07:00
|
|
|
if (smi_result == SI_SM_CALL_WITH_DELAY ||
|
|
|
|
smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
|
2005-09-10 14:27:30 +07:00
|
|
|
schedule_timeout_uninterruptible(1);
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_result = smi_info->handlers->event(
|
2014-01-25 03:00:52 +07:00
|
|
|
smi_info->si_sm, jiffies_to_usecs(1));
|
2008-04-29 15:01:10 +07:00
|
|
|
} else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
|
2005-04-17 05:20:36 +07:00
|
|
|
smi_result = smi_info->handlers->event(
|
|
|
|
smi_info->si_sm, 0);
|
2008-04-29 15:01:10 +07:00
|
|
|
} else
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
2009-04-22 02:24:03 +07:00
|
|
|
if (smi_result == SI_SM_HOSED)
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* We couldn't get the state machine to run, so whatever's at
|
|
|
|
* the port is probably not an IPMI SMI interface.
|
|
|
|
*/
|
2009-04-22 02:24:03 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int try_get_dev_id(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
unsigned char msg[2];
|
|
|
|
unsigned char *resp;
|
|
|
|
unsigned long resp_len;
|
|
|
|
int rv = 0;
|
|
|
|
|
|
|
|
resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
|
|
|
|
if (!resp)
|
|
|
|
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);
|
|
|
|
|
|
|
|
rv = wait_for_msg_done(smi_info);
|
|
|
|
if (rv)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|
|
|
|
resp, IPMI_MAX_MSG_LENGTH);
|
|
|
|
|
2007-10-18 17:07:11 +07:00
|
|
|
/* Check and record info from the get device id, in case we need it. */
|
|
|
|
rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(resp);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2009-04-22 02:24:03 +07:00
|
|
|
static int try_enable_event_buffer(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
unsigned char msg[3];
|
|
|
|
unsigned char *resp;
|
|
|
|
unsigned long resp_len;
|
|
|
|
int rv = 0;
|
|
|
|
|
|
|
|
resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
|
|
|
|
if (!resp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
rv = wait_for_msg_done(smi_info);
|
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Error getting response from get"
|
|
|
|
" global enables command, the event buffer is not"
|
2009-04-22 02:24:03 +07:00
|
|
|
" enabled.\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|
|
|
|
resp, IPMI_MAX_MSG_LENGTH);
|
|
|
|
|
|
|
|
if (resp_len < 4 ||
|
|
|
|
resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
|
|
|
|
resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
|
|
|
|
resp[2] != 0) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Invalid return from get global"
|
|
|
|
" enables command, cannot enable the event buffer.\n");
|
2009-04-22 02:24:03 +07:00
|
|
|
rv = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resp[3] & IPMI_BMC_EVT_MSG_BUFF)
|
|
|
|
/* buffer is already enabled, nothing to do. */
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
msg[0] = IPMI_NETFN_APP_REQUEST << 2;
|
|
|
|
msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
|
|
|
|
msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
|
|
|
|
smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
|
|
|
|
|
|
|
|
rv = wait_for_msg_done(smi_info);
|
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Error getting response from set"
|
|
|
|
" global, enables command, the event buffer is not"
|
2009-04-22 02:24:03 +07:00
|
|
|
" enabled.\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|
|
|
|
resp, IPMI_MAX_MSG_LENGTH);
|
|
|
|
|
|
|
|
if (resp_len < 3 ||
|
|
|
|
resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
|
|
|
|
resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX "Invalid return from get global,"
|
|
|
|
"enables command, not enable the event buffer.\n");
|
2009-04-22 02:24:03 +07:00
|
|
|
rv = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resp[2] != 0)
|
|
|
|
/*
|
|
|
|
* An error when setting the event buffer bit means
|
|
|
|
* that the event buffer is not supported.
|
|
|
|
*/
|
|
|
|
rv = -ENOENT;
|
|
|
|
out:
|
|
|
|
kfree(resp);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
static int smi_type_proc_show(struct seq_file *m, void *v)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2011-05-27 06:25:55 +07:00
|
|
|
struct smi_info *smi = m->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
return seq_printf(m, "%s\n", si_to_str[smi->si_type]);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
static int smi_type_proc_open(struct inode *inode, struct file *file)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-04-01 05:16:14 +07:00
|
|
|
return single_open(file, smi_type_proc_show, PDE_DATA(inode));
|
2011-05-27 06:25:55 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations smi_type_proc_ops = {
|
|
|
|
.open = smi_type_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int smi_si_stats_proc_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct smi_info *smi = m->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "interrupts_enabled: %d\n",
|
2006-03-26 16:37:20 +07:00
|
|
|
smi->irq && !smi->interrupt_disabled);
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "short_timeouts: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, short_timeouts));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "long_timeouts: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, long_timeouts));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "idles: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, idles));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "interrupts: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, interrupts));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "attentions: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, attentions));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "flag_fetches: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, flag_fetches));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "hosed_count: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, hosed_count));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "complete_transactions: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, complete_transactions));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "events: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, events));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "watchdog_pretimeouts: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, watchdog_pretimeouts));
|
2011-05-27 06:25:55 +07:00
|
|
|
seq_printf(m, "incoming_messages: %u\n",
|
2008-04-29 15:01:07 +07:00
|
|
|
smi_get_stat(smi, incoming_messages));
|
2011-05-27 06:25:55 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
static int smi_si_stats_proc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-04-01 05:16:14 +07:00
|
|
|
return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode));
|
2006-12-07 11:41:07 +07:00
|
|
|
}
|
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
static const struct file_operations smi_si_stats_proc_ops = {
|
|
|
|
.open = smi_si_stats_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int smi_params_proc_show(struct seq_file *m, void *v)
|
2006-12-07 11:41:07 +07:00
|
|
|
{
|
2011-05-27 06:25:55 +07:00
|
|
|
struct smi_info *smi = m->private;
|
2006-12-07 11:41:07 +07:00
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
return seq_printf(m,
|
2006-12-07 11:41:07 +07:00
|
|
|
"%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
|
|
|
|
si_to_str[smi->si_type],
|
|
|
|
addr_space_to_str[smi->io.addr_type],
|
|
|
|
smi->io.addr_data,
|
|
|
|
smi->io.regspacing,
|
|
|
|
smi->io.regsize,
|
|
|
|
smi->io.regshift,
|
|
|
|
smi->irq,
|
|
|
|
smi->slave_addr);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-05-27 06:25:55 +07:00
|
|
|
static int smi_params_proc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-04-01 05:16:14 +07:00
|
|
|
return single_open(file, smi_params_proc_show, PDE_DATA(inode));
|
2011-05-27 06:25:55 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations smi_params_proc_ops = {
|
|
|
|
.open = smi_params_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2005-09-07 05:18:41 +07:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
2005-09-07 05:18:45 +07:00
|
|
|
smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
|
2008-04-29 15:01:10 +07:00
|
|
|
RECEIVE_MSG_AVAIL);
|
2005-09-07 05:18:41 +07:00
|
|
|
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
|
|
|
|
*
|
2005-11-07 15:59:58 +07:00
|
|
|
* Additionally, PowerEdge systems with IPMI < 1.5 may also assert
|
|
|
|
* OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
|
|
|
|
*
|
2005-09-07 05:18:41 +07:00
|
|
|
*/
|
|
|
|
#define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
|
|
|
|
#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
|
|
|
|
#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
|
2006-03-26 16:37:21 +07:00
|
|
|
#define DELL_IANA_MFR_ID 0x0002a2
|
2005-09-07 05:18:41 +07:00
|
|
|
static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
struct ipmi_device_id *id = &smi_info->device_id;
|
2006-03-26 16:37:21 +07:00
|
|
|
if (id->manufacturer_id == DELL_IANA_MFR_ID) {
|
2005-11-07 15:59:58 +07:00
|
|
|
if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
|
|
|
|
id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
|
2006-03-26 16:37:21 +07:00
|
|
|
id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
|
2005-11-07 15:59:58 +07:00
|
|
|
smi_info->oem_data_avail_handler =
|
|
|
|
oem_data_avail_to_receive_msg_avail;
|
2008-04-29 15:01:10 +07:00
|
|
|
} else if (ipmi_version_major(id) < 1 ||
|
|
|
|
(ipmi_version_major(id) == 1 &&
|
|
|
|
ipmi_version_minor(id) < 5)) {
|
2005-11-07 15:59:58 +07:00
|
|
|
smi_info->oem_data_avail_handler =
|
|
|
|
oem_data_avail_to_receive_msg_avail;
|
|
|
|
}
|
2005-09-07 05:18:41 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-07 15:59:59 +07:00
|
|
|
#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;
|
|
|
|
|
2011-03-31 08:57:33 +07:00
|
|
|
/* Make it a response */
|
2005-11-07 15:59:59 +07:00
|
|
|
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;
|
2006-03-26 16:37:21 +07:00
|
|
|
if (id->manufacturer_id == DELL_IANA_MFR_ID &&
|
2005-11-07 15:59:59 +07:00
|
|
|
smi_info->si_type == SI_BT)
|
|
|
|
register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
|
|
|
|
}
|
|
|
|
|
2005-09-07 05:18:41 +07:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2005-11-07 15:59:59 +07:00
|
|
|
static void setup_xaction_handlers(struct smi_info *smi_info)
|
|
|
|
{
|
|
|
|
setup_dell_poweredge_bt_xaction_handler(smi_info);
|
|
|
|
}
|
|
|
|
|
2005-11-07 16:00:03 +07:00
|
|
|
static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
|
|
|
|
{
|
2006-03-31 17:30:39 +07:00
|
|
|
if (smi_info->intf) {
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* The timer and thread are only running if the
|
|
|
|
* interface has been started up and registered.
|
|
|
|
*/
|
2006-03-31 17:30:39 +07:00
|
|
|
if (smi_info->thread != NULL)
|
|
|
|
kthread_stop(smi_info->thread);
|
|
|
|
del_timer_sync(&smi_info->si_timer);
|
|
|
|
}
|
2005-11-07 16:00:03 +07:00
|
|
|
}
|
|
|
|
|
2012-11-20 01:24:36 +07:00
|
|
|
static struct ipmi_default_vals
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
|
|
|
int type;
|
|
|
|
int port;
|
2006-04-19 12:21:52 +07:00
|
|
|
} ipmi_defaults[] =
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
|
|
|
{ .type = SI_KCS, .port = 0xca2 },
|
|
|
|
{ .type = SI_SMIC, .port = 0xca9 },
|
|
|
|
{ .type = SI_BT, .port = 0xe4 },
|
|
|
|
{ .port = 0 }
|
|
|
|
};
|
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static void default_find_bmc(void)
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
|
|
|
struct smi_info *info;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; ; i++) {
|
|
|
|
if (!ipmi_defaults[i].port)
|
|
|
|
break;
|
2008-09-23 04:41:31 +07:00
|
|
|
#ifdef CONFIG_PPC
|
2007-03-05 15:30:48 +07:00
|
|
|
if (check_legacy_ioport(ipmi_defaults[i].port))
|
|
|
|
continue;
|
|
|
|
#endif
|
2010-10-27 04:21:17 +07:00
|
|
|
info = smi_info_alloc();
|
2008-08-21 04:09:14 +07:00
|
|
|
if (!info)
|
|
|
|
return;
|
2007-03-05 15:30:48 +07:00
|
|
|
|
2010-05-27 04:43:45 +07:00
|
|
|
info->addr_source = SI_DEFAULT;
|
2006-03-26 16:37:20 +07:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
if (add_smi(info) == 0) {
|
|
|
|
if ((try_smi_init(info)) == 0) {
|
|
|
|
/* Found one... */
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Found default %s"
|
2010-05-27 04:43:46 +07:00
|
|
|
" 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);
|
|
|
|
} else
|
|
|
|
cleanup_one_si(info);
|
2010-08-11 08:03:10 +07:00
|
|
|
} else {
|
|
|
|
kfree(info);
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_new_interface(struct smi_info *info)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
struct smi_info *e;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
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;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
return 1;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
static int add_smi(struct smi_info *new_smi)
|
2006-03-26 16:37:20 +07:00
|
|
|
{
|
2010-05-27 04:43:46 +07:00
|
|
|
int rv = 0;
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Adding %s-specified %s state machine",
|
2010-05-27 04:43:46 +07:00
|
|
|
ipmi_addr_src_to_str[new_smi->addr_source],
|
|
|
|
si_to_str[new_smi->si_type]);
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_lock(&smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!is_new_interface(new_smi)) {
|
2010-08-11 08:03:10 +07:00
|
|
|
printk(KERN_CONT " duplicate interface\n");
|
2006-03-26 16:37:20 +07:00
|
|
|
rv = -EBUSY;
|
|
|
|
goto out_err;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* 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;
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
list_add_tail(&new_smi->link, &smi_infos);
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
mutex_unlock(&smi_infos_lock);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int try_smi_init(struct smi_info *new_smi)
|
|
|
|
{
|
|
|
|
int rv = 0;
|
|
|
|
int i;
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Trying %s-specified %s state"
|
2010-05-27 04:43:46 +07:00
|
|
|
" machine at %s address 0x%lx, slave address 0x%x,"
|
|
|
|
" irq %d\n",
|
|
|
|
ipmi_addr_src_to_str[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);
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
switch (new_smi->si_type) {
|
|
|
|
case SI_KCS:
|
2005-04-17 05:20:36 +07:00
|
|
|
new_smi->handlers = &kcs_smi_handlers;
|
2006-03-26 16:37:20 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SI_SMIC:
|
2005-04-17 05:20:36 +07:00
|
|
|
new_smi->handlers = &smic_smi_handlers;
|
2006-03-26 16:37:20 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SI_BT:
|
2005-04-17 05:20:36 +07:00
|
|
|
new_smi->handlers = &bt_smi_handlers;
|
2006-03-26 16:37:20 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2005-04-17 05:20:36 +07:00
|
|
|
/* 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);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!new_smi->si_sm) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX
|
|
|
|
"Could not allocate state machine memory\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
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) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX "Could not set up I/O space\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do low-level detection first. */
|
|
|
|
if (new_smi->handlers->detect(new_smi->si_sm)) {
|
2006-03-26 16:37:20 +07:00
|
|
|
if (new_smi->addr_source)
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "Interface detection failed\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
rv = -ENODEV;
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Attempt a get device id command. If it fails, we probably
|
|
|
|
* don't have a BMC here.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
rv = try_get_dev_id(new_smi);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (rv) {
|
|
|
|
if (new_smi->addr_source)
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_INFO PFX "There appears to be no BMC"
|
2006-03-26 16:37:20 +07:00
|
|
|
" at this location\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_err;
|
2006-03-26 16:37:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-07 05:18:41 +07:00
|
|
|
setup_oem_data_handler(new_smi);
|
2005-11-07 15:59:59 +07:00
|
|
|
setup_xaction_handlers(new_smi);
|
2005-09-07 05:18:41 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
2008-04-29 15:01:07 +07:00
|
|
|
for (i = 0; i < SI_NUM_STATS; i++)
|
|
|
|
atomic_set(&new_smi->stats[i], 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:48 +07:00
|
|
|
new_smi->interrupt_disabled = 1;
|
2005-11-07 16:00:03 +07:00
|
|
|
atomic_set(&new_smi->stop_operation, 0);
|
2006-03-26 16:37:20 +07:00
|
|
|
new_smi->intf_num = smi_num;
|
|
|
|
smi_num++;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-22 02:24:03 +07:00
|
|
|
rv = try_enable_event_buffer(new_smi);
|
|
|
|
if (rv == 0)
|
|
|
|
new_smi->has_event_buffer = 1;
|
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Start clearing the flags before we enable interrupts or the
|
|
|
|
* timer to avoid racing with the timer.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
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;
|
|
|
|
|
2006-03-26 16:37:21 +07:00
|
|
|
if (!new_smi->dev) {
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* If we don't already have a device from something
|
|
|
|
* else (like PCI), then register a new one.
|
|
|
|
*/
|
2006-03-26 16:37:21 +07:00
|
|
|
new_smi->pdev = platform_device_alloc("ipmi_si",
|
|
|
|
new_smi->intf_num);
|
2009-04-22 02:24:02 +07:00
|
|
|
if (!new_smi->pdev) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX
|
|
|
|
"Unable to allocate platform device\n");
|
2006-03-31 17:30:39 +07:00
|
|
|
goto out_err;
|
2006-03-26 16:37:21 +07:00
|
|
|
}
|
|
|
|
new_smi->dev = &new_smi->pdev->dev;
|
2008-11-13 04:25:00 +07:00
|
|
|
new_smi->dev->driver = &ipmi_driver.driver;
|
2006-03-26 16:37:21 +07:00
|
|
|
|
2006-11-16 16:19:08 +07:00
|
|
|
rv = platform_device_add(new_smi->pdev);
|
2006-03-26 16:37:21 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX
|
|
|
|
"Unable to register system interface device:"
|
2006-03-26 16:37:21 +07:00
|
|
|
" %d\n",
|
|
|
|
rv);
|
2006-03-31 17:30:39 +07:00
|
|
|
goto out_err;
|
2006-03-26 16:37:21 +07:00
|
|
|
}
|
|
|
|
new_smi->dev_registered = 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
rv = ipmi_register_smi(&handlers,
|
|
|
|
new_smi,
|
2006-03-26 16:37:21 +07:00
|
|
|
&new_smi->device_id,
|
|
|
|
new_smi->dev,
|
2006-12-07 11:40:59 +07:00
|
|
|
"bmc",
|
2006-03-31 17:30:39 +07:00
|
|
|
new_smi->slave_addr);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_err(new_smi->dev, "Unable to register device: error %d\n",
|
|
|
|
rv);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_err_stop_timer;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
|
2011-05-27 06:25:55 +07:00
|
|
|
&smi_type_proc_ops,
|
2009-03-26 02:48:06 +07:00
|
|
|
new_smi);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_err_stop_timer;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
|
2011-05-27 06:25:55 +07:00
|
|
|
&smi_si_stats_proc_ops,
|
2009-03-26 02:48:06 +07:00
|
|
|
new_smi);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_err_stop_timer;
|
|
|
|
}
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
|
2011-05-27 06:25:55 +07:00
|
|
|
&smi_params_proc_ops,
|
2009-03-26 02:48:06 +07:00
|
|
|
new_smi);
|
2006-12-07 11:41:07 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|
2006-12-07 11:41:07 +07:00
|
|
|
goto out_err_stop_timer;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:52 +07:00
|
|
|
dev_info(new_smi->dev, "IPMI %s interface initialized\n",
|
|
|
|
si_to_str[new_smi->si_type]);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_err_stop_timer:
|
2005-11-07 16:00:03 +07:00
|
|
|
atomic_inc(&new_smi->stop_operation);
|
|
|
|
wait_for_timer_and_thread(new_smi);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out_err:
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->interrupt_disabled = 1;
|
|
|
|
|
|
|
|
if (new_smi->intf) {
|
2005-04-17 05:20:36 +07:00
|
|
|
ipmi_unregister_smi(new_smi->intf);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->intf = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
if (new_smi->irq_cleanup) {
|
2006-03-26 16:37:20 +07:00
|
|
|
new_smi->irq_cleanup(new_smi);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->irq_cleanup = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Wait until we know that we are out of any interrupt
|
|
|
|
* handlers might have been running before we freed the
|
|
|
|
* interrupt.
|
|
|
|
*/
|
2005-05-01 22:59:04 +07:00
|
|
|
synchronize_sched();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (new_smi->si_sm) {
|
|
|
|
if (new_smi->handlers)
|
|
|
|
new_smi->handlers->cleanup(new_smi->si_sm);
|
|
|
|
kfree(new_smi->si_sm);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->si_sm = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2010-05-27 04:43:46 +07:00
|
|
|
if (new_smi->addr_source_cleanup) {
|
2006-03-26 16:37:20 +07:00
|
|
|
new_smi->addr_source_cleanup(new_smi);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->addr_source_cleanup = NULL;
|
|
|
|
}
|
|
|
|
if (new_smi->io_cleanup) {
|
2005-12-16 03:34:28 +07:00
|
|
|
new_smi->io_cleanup(new_smi);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->io_cleanup = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
if (new_smi->dev_registered) {
|
2006-03-26 16:37:21 +07:00
|
|
|
platform_device_unregister(new_smi->pdev);
|
2010-05-27 04:43:46 +07:00
|
|
|
new_smi->dev_registered = 0;
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2012-11-20 01:22:51 +07:00
|
|
|
static int init_ipmi_si(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *str;
|
2006-03-26 16:37:21 +07:00
|
|
|
int rv;
|
2010-05-27 04:43:46 +07:00
|
|
|
struct smi_info *e;
|
2010-05-27 04:43:49 +07:00
|
|
|
enum ipmi_addr_src type = SI_INVALID;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (initialized)
|
|
|
|
return 0;
|
|
|
|
initialized = 1;
|
|
|
|
|
2013-02-28 08:05:13 +07:00
|
|
|
if (si_tryplatform) {
|
|
|
|
rv = platform_driver_register(&ipmi_driver);
|
|
|
|
if (rv) {
|
|
|
|
printk(KERN_ERR PFX "Unable to register "
|
|
|
|
"driver: %d\n", rv);
|
|
|
|
return rv;
|
|
|
|
}
|
2006-03-26 16:37:21 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Parse out the si_type string into its components. */
|
|
|
|
str = si_type_str;
|
|
|
|
if (*str != '\0') {
|
2005-09-07 05:18:45 +07:00
|
|
|
for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
si_type[i] = str;
|
|
|
|
str = strchr(str, ',');
|
|
|
|
if (str) {
|
|
|
|
*str = '\0';
|
|
|
|
str++;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-07 05:18:42 +07:00
|
|
|
printk(KERN_INFO "IPMI System Interface driver.\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
/* If the user gave us a device, they presumably want us to use it */
|
2011-02-24 04:37:59 +07:00
|
|
|
if (!hardcode_find_bmc())
|
2010-05-27 04:43:46 +07:00
|
|
|
return 0;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
#ifdef CONFIG_PCI
|
2013-02-28 08:05:13 +07:00
|
|
|
if (si_trypci) {
|
|
|
|
rv = pci_register_driver(&ipmi_pci_driver);
|
|
|
|
if (rv)
|
|
|
|
printk(KERN_ERR PFX "Unable to register "
|
|
|
|
"PCI driver: %d\n", rv);
|
|
|
|
else
|
|
|
|
pci_registered = 1;
|
|
|
|
}
|
2006-03-26 16:37:20 +07:00
|
|
|
#endif
|
|
|
|
|
2010-05-27 04:43:47 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
2013-02-28 08:05:12 +07:00
|
|
|
if (si_tryacpi) {
|
|
|
|
pnp_register_driver(&ipmi_pnp_driver);
|
|
|
|
pnp_registered = 1;
|
|
|
|
}
|
2010-05-27 04:43:47 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_DMI
|
2013-02-28 08:05:12 +07:00
|
|
|
if (si_trydmi)
|
|
|
|
dmi_find_bmc();
|
2010-05-27 04:43:47 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI
|
2013-02-28 08:05:12 +07:00
|
|
|
if (si_tryacpi)
|
|
|
|
spmi_find_bmc();
|
2010-05-27 04:43:47 +07:00
|
|
|
#endif
|
|
|
|
|
2013-09-05 18:36:36 +07:00
|
|
|
#ifdef CONFIG_PARISC
|
|
|
|
register_parisc_driver(&ipmi_parisc_driver);
|
|
|
|
parisc_registered = 1;
|
|
|
|
/* poking PC IO addresses will crash machine, don't do it */
|
|
|
|
si_trydefaults = 0;
|
|
|
|
#endif
|
|
|
|
|
2010-05-27 04:43:49 +07:00
|
|
|
/* We prefer devices with interrupts, but in the case of a machine
|
|
|
|
with multiple BMCs we assume that there will be several instances
|
|
|
|
of a given type so if we succeed in registering a type then also
|
|
|
|
try to register everything else of the same type */
|
2010-05-27 04:43:46 +07:00
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
mutex_lock(&smi_infos_lock);
|
|
|
|
list_for_each_entry(e, &smi_infos, link) {
|
2010-05-27 04:43:49 +07:00
|
|
|
/* Try to register a device if it has an IRQ and we either
|
|
|
|
haven't successfully registered a device yet or this
|
|
|
|
device has the same type as one we successfully registered */
|
|
|
|
if (e->irq && (!type || e->addr_source == type)) {
|
2010-05-27 04:43:46 +07:00
|
|
|
if (!try_smi_init(e)) {
|
2010-05-27 04:43:49 +07:00
|
|
|
type = e->addr_source;
|
2010-05-27 04:43:46 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:49 +07:00
|
|
|
/* type will only have been set if we successfully registered an si */
|
|
|
|
if (type) {
|
|
|
|
mutex_unlock(&smi_infos_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
/* Fall back to the preferred device */
|
|
|
|
|
|
|
|
list_for_each_entry(e, &smi_infos, link) {
|
2010-05-27 04:43:49 +07:00
|
|
|
if (!e->irq && (!type || e->addr_source == type)) {
|
2010-05-27 04:43:46 +07:00
|
|
|
if (!try_smi_init(e)) {
|
2010-05-27 04:43:49 +07:00
|
|
|
type = e->addr_source;
|
2010-05-27 04:43:46 +07:00
|
|
|
}
|
|
|
|
}
|
2010-05-27 04:43:46 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&smi_infos_lock);
|
|
|
|
|
2010-05-27 04:43:49 +07:00
|
|
|
if (type)
|
|
|
|
return 0;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (si_trydefaults) {
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_lock(&smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
if (list_empty(&smi_infos)) {
|
|
|
|
/* No BMC was found, try defaults. */
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_unlock(&smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
default_find_bmc();
|
2010-05-27 04:43:46 +07:00
|
|
|
} else
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_unlock(&smi_infos_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_lock(&smi_infos_lock);
|
2006-12-07 11:41:07 +07:00
|
|
|
if (unload_when_empty && list_empty(&smi_infos)) {
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_unlock(&smi_infos_lock);
|
2011-02-11 05:08:38 +07:00
|
|
|
cleanup_ipmi_si();
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_WARNING PFX
|
|
|
|
"Unable to find any System Interface(s)\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
2006-03-26 16:37:20 +07:00
|
|
|
} else {
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_unlock(&smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
module_init(init_ipmi_si);
|
|
|
|
|
2006-12-07 11:41:07 +07:00
|
|
|
static void cleanup_one_si(struct smi_info *to_clean)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-05-27 04:43:46 +07:00
|
|
|
int rv = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!to_clean)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
list_del(&to_clean->link);
|
|
|
|
|
2007-05-08 14:23:54 +07:00
|
|
|
/* Tell the driver that we are shutting down. */
|
2005-11-07 16:00:03 +07:00
|
|
|
atomic_inc(&to_clean->stop_operation);
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Make sure the timer and thread are stopped and will not run
|
|
|
|
* again.
|
|
|
|
*/
|
2005-11-07 16:00:03 +07:00
|
|
|
wait_for_timer_and_thread(to_clean);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 15:01:10 +07:00
|
|
|
/*
|
|
|
|
* Timeouts are stopped, now make sure the interrupts are off
|
|
|
|
* for the device. A little tricky with locks to make sure
|
|
|
|
* there are no races.
|
|
|
|
*/
|
2007-05-08 14:23:54 +07:00
|
|
|
spin_lock_irqsave(&to_clean->si_lock, flags);
|
|
|
|
while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|
|
|
|
spin_unlock_irqrestore(&to_clean->si_lock, flags);
|
|
|
|
poll(to_clean);
|
|
|
|
schedule_timeout_uninterruptible(1);
|
|
|
|
spin_lock_irqsave(&to_clean->si_lock, flags);
|
|
|
|
}
|
|
|
|
disable_si_irq(to_clean);
|
|
|
|
spin_unlock_irqrestore(&to_clean->si_lock, flags);
|
|
|
|
while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|
|
|
|
poll(to_clean);
|
|
|
|
schedule_timeout_uninterruptible(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clean up interrupts and make sure that everything is done. */
|
|
|
|
if (to_clean->irq_cleanup)
|
|
|
|
to_clean->irq_cleanup(to_clean);
|
2005-09-07 05:18:45 +07:00
|
|
|
while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
poll(to_clean);
|
2005-09-10 14:27:30 +07:00
|
|
|
schedule_timeout_uninterruptible(1);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
if (to_clean->intf)
|
|
|
|
rv = ipmi_unregister_smi(to_clean->intf);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rv) {
|
2010-05-27 04:43:52 +07:00
|
|
|
printk(KERN_ERR PFX "Unable to unregister device: errno=%d\n",
|
2005-04-17 05:20:36 +07:00
|
|
|
rv);
|
|
|
|
}
|
|
|
|
|
2010-05-27 04:43:46 +07:00
|
|
|
if (to_clean->handlers)
|
|
|
|
to_clean->handlers->cleanup(to_clean->si_sm);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
kfree(to_clean->si_sm);
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (to_clean->addr_source_cleanup)
|
|
|
|
to_clean->addr_source_cleanup(to_clean);
|
2005-12-16 03:34:28 +07:00
|
|
|
if (to_clean->io_cleanup)
|
|
|
|
to_clean->io_cleanup(to_clean);
|
2006-03-26 16:37:21 +07:00
|
|
|
|
|
|
|
if (to_clean->dev_registered)
|
|
|
|
platform_device_unregister(to_clean->pdev);
|
|
|
|
|
|
|
|
kfree(to_clean);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-03-24 06:42:54 +07:00
|
|
|
static void cleanup_ipmi_si(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-03-26 16:37:20 +07:00
|
|
|
struct smi_info *e, *tmp_e;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
if (!initialized)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
2006-03-26 16:37:20 +07:00
|
|
|
#ifdef CONFIG_PCI
|
2010-06-30 05:05:29 +07:00
|
|
|
if (pci_registered)
|
|
|
|
pci_unregister_driver(&ipmi_pci_driver);
|
2006-03-26 16:37:20 +07:00
|
|
|
#endif
|
2009-12-17 14:50:25 +07:00
|
|
|
#ifdef CONFIG_ACPI
|
2010-09-23 03:05:15 +07:00
|
|
|
if (pnp_registered)
|
|
|
|
pnp_unregister_driver(&ipmi_pnp_driver);
|
2009-11-18 07:05:34 +07:00
|
|
|
#endif
|
2013-09-05 18:36:36 +07:00
|
|
|
#ifdef CONFIG_PARISC
|
|
|
|
if (parisc_registered)
|
|
|
|
unregister_parisc_driver(&ipmi_parisc_driver);
|
|
|
|
#endif
|
2006-03-26 16:37:20 +07:00
|
|
|
|
2011-02-24 04:37:59 +07:00
|
|
|
platform_driver_unregister(&ipmi_driver);
|
2007-05-08 14:23:51 +07:00
|
|
|
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_lock(&smi_infos_lock);
|
2006-03-26 16:37:20 +07:00
|
|
|
list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
|
|
|
|
cleanup_one_si(e);
|
2006-03-31 17:30:41 +07:00
|
|
|
mutex_unlock(&smi_infos_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
module_exit(cleanup_ipmi_si);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2005-09-07 05:18:42 +07:00
|
|
|
MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
|
2008-04-29 15:01:10 +07:00
|
|
|
MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
|
|
|
|
" system interfaces.");
|