diff options
Diffstat (limited to 'kern/ipmi_kcs.patch')
| -rw-r--r-- | kern/ipmi_kcs.patch | 1592 |
1 files changed, 1592 insertions, 0 deletions
diff --git a/kern/ipmi_kcs.patch b/kern/ipmi_kcs.patch new file mode 100644 index 0000000..15f9a10 --- /dev/null +++ b/kern/ipmi_kcs.patch @@ -0,0 +1,1592 @@ +--- linux-2.4.2-virgin/drivers/char/misc.c Sun Apr 8 18:22:17 2001 ++++ linux-bmc/drivers/char/misc.c Tue Oct 30 17:18:07 2001 +@@ -273,6 +273,9 @@ + #ifdef CONFIG_TOSHIBA + tosh_init(); + #endif ++#ifdef CONFIG_IPMI_KCS ++ ipmi_kcs_init(); ++#endif + if (devfs_register_chrdev(MISC_MAJOR,"misc",&misc_fops)) { + printk("unable to get major %d for misc devices\n", + MISC_MAJOR); +--- linux-2.4.2-virgin/drivers/char/Config.in Sun Apr 8 18:22:22 2001 ++++ linux-bmc/drivers/char/Config.in Tue Oct 30 17:18:07 2001 +@@ -81,6 +81,11 @@ + dep_tristate 'Support for user-space parallel port device drivers' CONFIG_PPDEV $CONFIG_PARPORT + fi + ++tristate 'IPMI KCS Interface' CONFIG_IPMI_KCS ++if [ "$CONFIG_IPMI_KCS" != "n" ]; then ++ bool ' BMC watchdog timer support' CONFIG_BMC_WDT ++fi ++ + source drivers/i2c/Config.in + + source drivers/sensors/Config.in +--- linux-2.4.2-virgin/drivers/char/Makefile Sun Apr 8 18:22:17 2001 ++++ linux-bmc/drivers/char/Makefile Tue Oct 30 17:18:08 2001 +@@ -191,6 +191,8 @@ + obj-$(CONFIG_NWBUTTON) += nwbutton.o + obj-$(CONFIG_NWFLASH) += nwflash.o + ++obj-$(CONFIG_IPMI_KCS) += ipmi_kcs.o ++ + # Only one watchdog can succeed. We probe the hardware watchdog + # drivers first, then the softdog driver. This means if your hardware + # watchdog dies or is 'borrowed' for some reason the software watchdog +--- linux-2.4.2-virgin/include/linux/miscdevice.h Sun Apr 8 18:47:26 2001 ++++ linux-bmc/include/linux/miscdevice.h Tue Oct 30 17:32:42 2001 +@@ -31,6 +31,9 @@ + #define SGI_STREAMS_KEYBOARD 150 + /* drivers/sgi/char/usema.c */ + #define SGI_USEMACLONE 151 ++#define IPMI_KCS_MINOR 173 ++#define IPMI_BT_MINOR 210 ++#define IPMI_SMIC_MINOR 211 + + #define TUN_MINOR 200 + +--- /dev/null Fri Mar 23 23:37:44 2001 ++++ linux-bmc/drivers/char/ipmi_kcs.c Tue Oct 30 17:18:07 2001 +@@ -0,0 +1,1211 @@ ++/* ++ * Intelligent Platform Management Interface driver for Linux 2.2.x ++ * ++ * (c) Copyright 2000 San Mehat <nettwerk@valinux.com>, All Rights Reserved. ++ * http://www.valinux.com ++ * ++ * 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. ++ * ++ * Neither San Mehat nor VA Linux Systems admit liability nor provide ++ * warranty for any of this software. This material is provided ++ * "AS-IS" and at no charge. ++ * ++ * (c) Copyright 1999 San Mehat <nettwerk@valinux.com> ++ * ++ * Release 0.04. - Initial Release ++ * ++ * Release 0.05. - Fixed ring buffer bugs... better buffer handling ++ * ++ * Release 0.06. - Changed polling freq to 1/10 sec ++ * ++ * Release 0.07. - Integrated watchdog commands into IOCTL's and added ++ * support for blinking front panel LED ++ * ++ * Release 0.08. - Sensor read commands added as ioctl ++ * ++ * Release 0.09. - Changed polling freq back to 1 second ++ * - Fixed possible bug where a chip status variable was ++ * not declared volatile. ++ * - Fixed buffer memory leak ++ * - Fixed ioctl return value problem ++ * - Changed architecture so that applications calling ++ * driver ioctl()'s are put to sleep after request ++ * is sent. The reply is handled by the normal ++ * driver polling timer queue and ring buffer ++ * ++ * Release 0.10. - Modified kcs_write routine so once a write is complete ++ * if the interface isn't in a 'READ STATE' it's okay. ++ * ++ * Release 0.12. - Added Intel Nightshade MB fixups since NS boards don't ++ * support pre-timeout NMI support ++ * - FRU download support added ++ * - /proc/ipmi created with fru data and driver status ++ * Release 0.13. - Added ioctl for setting asset tag ++ * - Fixed bug in /proc ++ * - Added asset tag max length field ++ * Release 1.00 - Added intelligent proc reading so that asset tag is ++ * refreshed whenever /proc/ipmi is read ++ * - Code cleanup ++ * - When asset tag is set with data whoes size is < maximum, ++ * pad the rest out with NULLs ++ * Release 1.10 - Fixed SMP bug which was causing command failures when ++ * /proc/ipmi was being read while a command was being ++ * executed (added semaphore) ++ * - Fixed /proc/ipmi so commands only get issued once ++ * Release 1.20 - Removed a bunch of useless warning msgs ++ * Release 1.30 - Added more stringent error checking when ISA state ++ * enters ERROR_STATE ++ * - Added better unexpected OBF handling on transactions ++ * - Explicitly set power sensor state to NO BLINKY on ++ * startup ++ * Release 2.0 - Re-wrote kcs state machine ++ * - Removed high level functions from driver ++ * - removed driver read() and write() capabilities ++ * - /proc/ipmi renamed to /proc/ipmi_kcs ++ * - /proc/ipmi_kcs now contains only BMC info ++ * ++ * Release 2.1 - Added support of watchdog timer through /dev/watchdog ++ * ++ */ ++ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/version.h> ++#include <linux/types.h> ++#include <linux/errno.h> ++#include <linux/kernel.h> ++#include <linux/sched.h> ++#include <linux/smp_lock.h> ++#include <linux/miscdevice.h> ++#include "ipmi_kcs.h" ++#include <linux/malloc.h> ++#include <linux/ioport.h> ++#include <linux/fcntl.h> ++#include <asm/io.h> ++#include <asm/uaccess.h> ++#include <asm/system.h> ++#include <asm/semaphore.h> ++#include <linux/notifier.h> ++#include <linux/reboot.h> ++#include <linux/init.h> ++#include <linux/delay.h> ++#include <linux/timer.h> ++#include <linux/ipmi_ioctls.h> ++#include <linux/pci.h> ++ ++#ifdef CONFIG_PROC_FS ++#include <linux/proc_fs.h> ++#endif ++ ++#ifdef CONFIG_BMC_WDT ++#include <linux/watchdog.h> ++#endif ++ ++/* function prototypes */ ++ ++int ipmi_kcs_init(void); ++ ++static int kcs_open(struct inode *inode, struct file *file); ++static int kcs_release(struct inode *inode, struct file *file); ++static ssize_t kcs_read(struct file *file, char *buf, size_t count, ++ loff_t * ptr); ++static ssize_t kcs_write(struct file *file, const char *buf, size_t count, ++ loff_t * ppos); ++static long long kcs_llseek(struct file *file, long long offset, ++ int origin); ++static int kcs_ioctl(struct inode *inode, struct file *file, ++ unsigned int cmd, unsigned long arg); ++ ++#ifdef CONFIG_BMC_WDT ++static int wdt_is_open; ++static int watchdog_set(int cmd); ++static int watchdog_reset(void); ++static int wdt_open(struct inode *inode, struct file *file); ++static int wdt_release(struct inode *inode, struct file *file); ++static ssize_t wdt_write(struct file *file, const char *buf, size_t count, ++ loff_t * ppos); ++static int wdt_ioctl(struct inode *inode, struct file *file, ++ unsigned int cmd, unsigned long arg); ++ ++static struct file_operations wdt_fops = { ++ owner:THIS_MODULE, ++ write:wdt_write, ++ ioctl:wdt_ioctl, ++ open:wdt_open, ++ release:wdt_release, ++}; ++ ++static struct miscdevice wdt_miscdev = { ++ WATCHDOG_MINOR, ++ "bmc_wdt", ++ &wdt_fops ++}; ++ ++/* module parameters */ ++static int wdt_margin = 60; /* watchdog timer interval in seconds */ ++static int wdt_pre = 1; /* watchdog pre-timeout interval in seconds */ ++static int wdt_action = 0x03; /* Default is no pre-timeout interrupt and power cycle upon timeout */ ++ ++MODULE_PARM(wdt_margin, "i"); ++MODULE_PARM(wdt_pre, "i"); ++MODULE_PARM(wdt_action, "i"); ++ ++#define WATCHDOG_ENABLE 0x01 ++#define WATCHDOG_DISABLE 0x02 ++#endif ++ ++static unsigned char get_kcs_state(void); ++static unsigned char read_kcs_data(void); ++static void write_kcs_data(unsigned char data); ++static void write_kcs_cmd(unsigned char cmd); ++static int is_obf_set(void); ++static int clear_obf(void); ++static int wait_while_ibf(void); ++static int get_deviceid(void); ++static int kcs_do_xfer(BMC_REQUEST * request, int request_len, ++ BMC_RESPONSE * response, int *response_len); ++static int old_kcs_do_xfer(BMC_REQUEST * request, int request_len, ++ BMC_RESPONSE * response, int *response_len); ++static int new_kcs_do_xfer(BMC_REQUEST * request, int request_len, ++ BMC_RESPONSE * response, int *response_len); ++ ++#ifdef CONFIG_PROC_FS ++int ipmi_get_info(char *buf, char **start, off_t fpos, int length, ++ int *eof, void *unused); ++#endif ++ ++/* static globals */ ++static int kcs_refcnt = 0; ++static int driver_major = 2; ++static int driver_minor = 1; ++static int kcs_machine = 0; ++ ++static struct { ++ unsigned int tx_good; ++ unsigned int tx_bad; ++} kcs_stat; ++ ++static DEVICE_ID_RESPONSE dev_id; ++DECLARE_MUTEX(kcs_sem); ++ ++#ifdef CONFIG_PROC_FS ++static struct proc_dir_entry *ipmi_proc_entry; ++#endif ++ ++static struct file_operations kcs_fops = { ++ owner:THIS_MODULE, ++ write:kcs_write, ++ ioctl:kcs_ioctl, ++ open:kcs_open, ++ release:kcs_release, ++ read:kcs_read, ++}; ++ ++static struct miscdevice kcs_miscdev = { ++ IPMI_KCS_MINOR, ++ "ipmi_kcs", ++ &kcs_fops ++}; ++ ++static struct ipmi_driver_info drv_inf; ++ ++/***************/ ++ ++static long long kcs_llseek(struct file *file, long long offset, ++ int origin) ++{ ++ return -ESPIPE; ++} ++ ++static ssize_t kcs_write(struct file *file, const char *buf, size_t count, ++ loff_t * ppos) ++{ ++ return (-ENOSYS); ++} ++ ++static ssize_t kcs_read(struct file *file, char *buf, size_t count, ++ loff_t * ptr) ++{ ++ return (-ENOSYS); ++} ++ ++static int kcs_ioctl(struct inode *inode, ++ struct file *file, ++ unsigned int cmd, unsigned long arg) ++{ ++ switch (cmd) { ++ case IOCTL_IPMI_XFER: ++ { ++ IPMI_XFER user_buffer; ++ int rc; ++ int response_len = sizeof(user_buffer.response); ++ ++ if (!arg) ++ return (-EFAULT); ++ if (copy_from_user ++ ((void *) &user_buffer, (void *) arg, ++ sizeof(IPMI_XFER))) ++ return (-EFAULT); ++ if ((user_buffer.request_len < 2) ++ || (user_buffer.response_len < 3)) ++ return (-EINVAL); ++ ++ rc = kcs_do_xfer((BMC_REQUEST *) & user_buffer. ++ request, user_buffer.request_len, ++ (BMC_RESPONSE *) & user_buffer. ++ response, &response_len); ++ user_buffer.response_len = response_len; ++ copy_to_user((void *) arg, (void *) &user_buffer, ++ sizeof(IPMI_XFER)); ++ return (rc); ++ } ++ case IOCTL_DRIVER_INFO: ++ { ++ struct ipmi_driver_info user_buffer; ++ ++ if (!arg) ++ return (-EFAULT); ++ if (copy_from_user ++ ((void *) &user_buffer, (void *) arg, ++ sizeof(user_buffer))) ++ return (-EFAULT); ++ copy_to_user((void *) arg, (void *) &drv_inf, ++ sizeof(drv_inf)); ++ return (0); ++ } ++ default: ++ return -EINVAL; ++ } ++ return (0); ++} ++ ++static int get_deviceid() ++{ ++ unsigned char request_buffer[MAX_BUFFER_SIZE]; ++ unsigned char response_buffer[MAX_BUFFER_SIZE]; ++ BMC_REQUEST *bmc_req; ++ BMC_RESPONSE *bmc_resp; ++ int rc, response_len; ++ ++ memset(&dev_id, 0, sizeof(DEVICE_ID_RESPONSE)); ++ memset(request_buffer, 0, sizeof(request_buffer)); ++ memset(response_buffer, 0, sizeof(response_buffer)); ++ bmc_req = (BMC_REQUEST *) request_buffer; ++ bmc_resp = (BMC_RESPONSE *) response_buffer; ++ response_len = sizeof(response_buffer); ++ ++ bmc_req->lun = 0; ++ bmc_req->netfn = APP_REQUEST; ++ bmc_req->cmd = 0x01; /* GET_DEVICE_ID */ ++ ++#if defined(__ia64__) ++ rc = new_kcs_do_xfer(bmc_req, 2, bmc_resp, &response_len); ++#else ++ rc = old_kcs_do_xfer(bmc_req, 2, bmc_resp, &response_len); ++#endif ++ if (bmc_resp->cc != 0x00) { ++ printk("[IPMI_KCS] get_deviceid() failed (0x%.2x)\n", ++ bmc_resp->cc); ++ return (-EIO); ++ } ++ memcpy(&dev_id, bmc_resp->data, sizeof(DEVICE_ID_RESPONSE)); ++ return (0); ++} ++ ++static int kcs_open(struct inode *inode, struct file *file) ++{ ++ switch (MINOR(inode->i_rdev)) { ++ case IPMI_KCS_MINOR: ++ { ++ MOD_INC_USE_COUNT; ++ kcs_refcnt++; ++ return 0; ++ } ++ default: ++ return -ENODEV; ++ } ++} ++ ++static int kcs_release(struct inode *inode, struct file *file) ++{ ++ if (MINOR(inode->i_rdev) == IPMI_KCS_MINOR) { ++ kcs_refcnt--; ++ } ++ MOD_DEC_USE_COUNT; ++ return 0; ++} ++ ++#ifdef CONFIG_BMC_WDT ++static ssize_t wdt_write(struct file *file, const char *buf, size_t count, ++ loff_t * ppos) ++{ ++ /* Can't seek (pwrite) on this device */ ++ if (ppos != &file->f_pos) ++ return -ESPIPE; ++ ++ /* ++ * Stop and then restart the watchdog timer. ++ */ ++ if (count) { ++ if (watchdog_set(WATCHDOG_DISABLE)) ++ return -EIO; ++ if (watchdog_set(WATCHDOG_ENABLE)) ++ return -EIO; ++ if (watchdog_reset()) ++ return -EIO; ++ return 1; ++ } ++ return 0; ++} ++ ++static int wdt_ioctl(struct inode *inode, ++ struct file *file, ++ unsigned int cmd, unsigned long arg) ++{ ++ static struct watchdog_info ident = { ++ WDIOF_KEEPALIVEPING, 1, "BMC WDT" ++ }; ++ ++ switch (cmd) { ++ case WDIOC_GETSUPPORT: ++ if (copy_to_user ++ ((struct watchdog_info *) arg, &ident, sizeof(ident))) ++ return -EFAULT; ++ break; ++ ++ case WDIOC_GETSTATUS: ++ if (copy_to_user((int *) arg, &wdt_is_open, sizeof(int))) ++ return -EFAULT; ++ break; ++ ++ case WDIOC_KEEPALIVE: ++ if (watchdog_set(WATCHDOG_DISABLE)) ++ return -EIO; ++ if (watchdog_set(WATCHDOG_ENABLE)) ++ return -EIO; ++ if (watchdog_reset()) ++ return -EIO; ++ break; ++ ++ default: ++ return -ENOIOCTLCMD; ++ } ++ return 0; ++} ++ ++static int watchdog_set(int cmd) ++{ ++ unsigned char request_buffer[MAX_BUFFER_SIZE]; ++ unsigned char response_buffer[MAX_BUFFER_SIZE]; ++ BMC_REQUEST *bmc_req; ++ BMC_RESPONSE *bmc_resp; ++ int rc, response_len; ++ SET_WATCHDOG *set; ++ int fixup = 0; ++ ++ memset(request_buffer, 0, sizeof(request_buffer)); ++ memset(response_buffer, 0, sizeof(response_buffer)); ++ bmc_req = (BMC_REQUEST *) request_buffer; ++ bmc_resp = (BMC_RESPONSE *) response_buffer; ++ response_len = sizeof(response_buffer); ++ ++ bmc_req->lun = 0; ++ bmc_req->netfn = APP_REQUEST; ++ bmc_req->cmd = 0x24; /* Set Watchdog Timer */ ++ ++ set = (SET_WATCHDOG *) bmc_req->data; ++ ++ while (1) { ++ set->timer_use = 0x04; ++ ++ set->timeout_action = wdt_action & 0x0F; ++ set->pre_irq = (wdt_action >> 4) & 0x0F; ++ ++ if (cmd == WATCHDOG_DISABLE) { ++ set->timeout_action = 0x00; ++ set->pre_irq = 0x00; ++ } ++ set->pretimeout_interval = wdt_pre; ++ ++ if (fixup) { ++ set->pre_irq = 0x00; ++ set->pretimeout_interval = 0; ++ } ++ ++ set->tuefc_biosfrb2 = 0x00; ++ set->tuefc_biospost = 0x0; ++ set->tuefc_osload = 0x00; ++ set->tuefc_smsos = 0x01; ++ set->initial_count = wdt_margin * 10; ++ ++ rc = kcs_do_xfer(bmc_req, 2 + sizeof(SET_WATCHDOG), ++ bmc_resp, &response_len); ++ ++ if (bmc_resp->cc == 0xcc) { ++ fixup++; ++ if (fixup == 2) { ++ printk ++ ("[IPMI_KCS] Flakey NMI fixup failed\n"); ++ return (-EIO); ++ } ++ printk("[IPMI_KCS] Flakey NMI fixup enabled\n"); ++ continue; ++ } else if (bmc_resp->cc != 0x00) { ++ printk ++ ("[IPMI_KCS] Set watchdog timer failed (rc = 0x%.2x)\n", ++ bmc_resp->cc); ++ return (-EIO); ++ } ++ break; ++ } ++ return (0); ++} ++ ++static int watchdog_reset() ++{ ++ unsigned char request_buffer[MAX_BUFFER_SIZE]; ++ unsigned char response_buffer[MAX_BUFFER_SIZE]; ++ BMC_REQUEST *bmc_req; ++ BMC_RESPONSE *bmc_resp; ++ int rc, response_len; ++ ++ memset(request_buffer, 0, sizeof(request_buffer)); ++ memset(response_buffer, 0, sizeof(response_buffer)); ++ bmc_req = (BMC_REQUEST *) request_buffer; ++ bmc_resp = (BMC_RESPONSE *) response_buffer; ++ response_len = sizeof(response_buffer); ++ ++ bmc_req->lun = 0; ++ bmc_req->netfn = APP_REQUEST; ++ bmc_req->cmd = 0x22; /* Reset Watchdog Timer */ ++ ++ rc = kcs_do_xfer(bmc_req, 2, bmc_resp, &response_len); ++ if (bmc_resp->cc != 0x00) { ++ printk("[IPMI_KCS] Reset Watchdog Timer failed (0x%.2x)\n", ++ bmc_resp->cc); ++ return (-EIO); ++ } ++ return (0); ++} ++ ++static int wdt_open(struct inode *inode, struct file *file) ++{ ++ switch (MINOR(inode->i_rdev)) { ++ case WATCHDOG_MINOR: ++ if (wdt_is_open) ++ return -EBUSY; ++ ++ MOD_INC_USE_COUNT; ++ /* ++ * Activate ++ */ ++ wdt_is_open = 1; ++ if (watchdog_reset()) ++ return -EIO; ++ return 0; ++ default: ++ return -ENODEV; ++ } ++} ++ ++static int wdt_release(struct inode *inode, struct file *file) ++{ ++ lock_kernel(); ++ if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) { ++#ifndef CONFIG_WATCHDOG_NOWAYOUT ++ if (watchdog_set(WATCHDOG_DISABLE)) ++ return -EIO; ++#endif ++ wdt_is_open = 0; ++ MOD_DEC_USE_COUNT; ++ } ++ unlock_kernel(); ++ return 0; ++} ++ ++/* ++ * Notifier for system down ++ */ ++ ++static int wdt_notify_sys(struct notifier_block *this, unsigned long code, ++ void *unused) ++{ ++ if (code == SYS_DOWN || code == SYS_HALT) { ++ /* Turn the timer off */ ++ watchdog_set(WATCHDOG_DISABLE); ++ } ++ return NOTIFY_DONE; ++} ++ ++/* ++ * The BMC needs to learn about soft shutdowns in order to ++ * turn the watchdog timer off. ++ */ ++ ++static struct notifier_block wdt_notifier = { ++ wdt_notify_sys, ++ NULL, ++ 0 ++}; ++#endif ++ ++#ifdef MODULE ++int init_module(void) ++{ ++ return (ipmi_kcs_init()); ++} ++ ++void cleanup_module(void) ++{ ++ printk("[IPMI_KCS] Driver shutting down.\n"); ++#ifdef CONFIG_PROC_FS ++ remove_proc_entry("ipmi_kcs", 0); ++#endif ++ misc_deregister(&kcs_miscdev); ++#ifdef CONFIG_BMC_WDT ++ misc_deregister(&wdt_miscdev); ++ unregister_reboot_notifier(&wdt_notifier); ++#endif ++ release_region(KCS_BASE, 16); ++} ++#endif ++ ++int ipmi_kcs_init() ++{ ++ printk ++ ("IPMI KCS driver (San Mehat nettwerk@valinux.com) v%d.%d at io 0x%x\n", ++ driver_major, driver_minor, KCS_BASE); ++ request_region(KCS_BASE, 16, "ipmi_kcs"); ++ if ((inb_p(KCS_STATUS_REG) == 0xFF) && ++ (inb_p(KCS_DATAIN_REG) == 0xFF)) { ++ printk("--KCS ISA window not present. Driver exiting\n"); ++ release_region(KCS_BASE, 16); ++ return (-ENXIO); ++ } ++ ++ kcs_stat.tx_good = 0; ++ kcs_stat.tx_bad = 0; ++ memset(&drv_inf, 0, sizeof(drv_inf)); ++ strcpy(drv_inf.driver_name, "ipmi_kcs"); ++ drv_inf.major_ver = driver_major; ++ drv_inf.minor_ver = driver_minor; ++ ++ misc_register(&kcs_miscdev); ++#ifdef CONFIG_BMC_WDT ++ misc_register(&wdt_miscdev); ++ register_reboot_notifier(&wdt_notifier); ++#endif ++ get_deviceid(); ++ printk("--BMC version %x.%x, IPMI version %d.%d\n", ++ dev_id.major_firmware_revision, ++ dev_id.minor_firmware_revision, ++ dev_id.ipmi_version_major, dev_id.ipmi_version_minor); ++ if ((dev_id.ipmi_version_major == 0) && ++ (dev_id.ipmi_version_minor == 9)) { ++ printk("--Using legacy KCS state machine\n"); ++ kcs_machine = KCS_LEGACY; ++ drv_inf.flags |= KCS_FLAG_LEGACY; ++ } else { ++ printk("--Using new KCS state machine\n"); ++ kcs_machine = KCS_NEW; ++ } ++ if (!pci_present()) { ++ printk ++ ("--PCIBIOS not present. Unable to determine chipset vendor\n"); ++ drv_inf.flags |= KCS_FLAG_BLINKY; ++ } else { ++ int pci_index = 0; ++ unsigned char pci_bus, pci_device_fn; ++ unsigned short vendor, device; ++ ++ for (; pci_index < 0xff; pci_index++) { ++ if (pcibios_find_class(PCI_CLASS_BRIDGE_HOST << 8, ++ pci_index, ++ &pci_bus, ++ &pci_device_fn) != ++ PCIBIOS_SUCCESSFUL) { ++ break; ++ } ++ pcibios_read_config_word(pci_bus, pci_device_fn, ++ PCI_VENDOR_ID, &vendor); ++ pcibios_read_config_word(pci_bus, pci_device_fn, ++ PCI_DEVICE_ID, &device); ++ drv_inf.mb_chipset_vendor = vendor; ++ drv_inf.mb_chipset_device = device; ++ printk ++ ("--Motherboard Chipset vendor 0x%.4x, device 0x%.4x\n", ++ vendor, device); ++ if ((vendor == 0x8086) && (device == 0x71a0)) { ++ drv_inf.flags |= KCS_FLAG_BLINKY; ++ } ++ } ++ } ++ if (drv_inf.flags & KCS_FLAG_BLINKY) { ++ printk("--Intel Lancewood features enabled\n"); ++ } else ++ printk("--No vendor specific features enabled\n"); ++#ifdef CONFIG_PROC_FS ++ if (!(ipmi_proc_entry = create_proc_entry("ipmi_kcs", 0, 0))) ++ printk(KERN_ERR, ++ "--ERROR: Unable to register /proc/ipmi_kcs\n"); ++ else ++ ipmi_proc_entry->read_proc = ipmi_get_info; ++ ++#endif ++ return (0); ++} ++ ++static int kcs_do_xfer(BMC_REQUEST * request, ++ int request_len, ++ BMC_RESPONSE * response, int *response_len) ++{ ++ int rc = 0; ++ ++ down(&kcs_sem); ++ switch (kcs_machine) { ++ case KCS_LEGACY: ++ { ++ rc = old_kcs_do_xfer(request, request_len, ++ response, response_len); ++ break; ++ } ++ case KCS_NEW: ++ { ++ rc = new_kcs_do_xfer(request, request_len, ++ response, response_len); ++ break; ++ } ++ default: ++ { ++ printk ++ ("[IPMI_KCS] Undefined or bad KCS state machine selected (%d)\n", ++ kcs_machine); ++ get_deviceid(); ++ if ((dev_id.ipmi_version_major == 0) && ++ (dev_id.ipmi_version_minor == 9)) { ++ printk ++ ("Recalibrated to use legacy KCS state machine\n"); ++ kcs_machine = KCS_LEGACY; ++ } else { ++ printk ++ ("Recalibrated to use new KCS state machine\n"); ++ kcs_machine = KCS_NEW; ++ } ++ rc = -EAGAIN; ++ break; ++ } ++ } ++ if (rc == 0) ++ kcs_stat.tx_good++; ++ else ++ kcs_stat.tx_bad++; ++ up(&kcs_sem); ++ return (rc); ++} ++ ++static int new_kcs_do_xfer(BMC_REQUEST * request, ++ int request_len, ++ BMC_RESPONSE * response, int *response_len) ++{ ++ unsigned char *xmit_buffer, *recv_buffer; ++ int i = 0, rc = 0, state = SEND_INIT, bad = 0; ++ ++ xmit_buffer = (unsigned char *) request; ++ recv_buffer = (unsigned char *) response; ++ ++ while (1) { ++ if (state == END) ++ break; ++ else if (bad > 2) { ++ printk ++ ("[IPMI_KCS] Maximum retries exceeded. Aborting transfer\n"); ++ rc = -EIO; ++ break; ++ } ++ switch (state) { ++ case SEND_INIT: ++ { ++ i = 0; ++ state = SEND_START; ++ wait_while_ibf(); ++ if (clear_obf() != 0) { ++ state = ERROR; ++ break; ++ } ++ } ++ case SEND_START: ++ { ++ state = SEND_NEXT; ++ write_kcs_cmd(WRITE_START); ++ wait_while_ibf(); ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ } ++ case SEND_NEXT: ++ { ++ if (i == (request_len - 1)) { ++ state = SEND_END; ++ break; ++ } ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ write_kcs_data(xmit_buffer[i++]); ++ wait_while_ibf(); ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ if (clear_obf() != 0) { ++ state = ERROR; ++ break; ++ } ++ break; ++ } ++ case SEND_END: ++ { ++ write_kcs_cmd(WRITE_END); ++ wait_while_ibf(); ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ if (clear_obf() != 0) { ++ state = ERROR; ++ break; ++ } ++ write_kcs_data(xmit_buffer[i++]); ++ wait_while_ibf(); ++ state = RECV_START; ++ } ++ case RECV_START: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_WRITE_STATE: ++ case KCS_IDLE_STATE: ++ { ++ mdelay(BMC_RESPONSE_DELAY); ++ break; ++ } ++ case KCS_READ_STATE: ++ { ++ i = 0; ++ memset(recv_buffer, 0, ++ *response_len); ++ state = RECV_INIT; ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_INIT: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ case KCS_WRITE_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_IDLE_STATE: ++ { ++ state = RECV_END; ++ break; ++ } ++ case KCS_READ_STATE: ++ { ++ if (is_obf_set()) ++ state = RECV_NEXT; ++ else ++ mdelay(1); ++ break; ++ } ++ default: ++ { ++ mdelay(1); ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_NEXT: ++ { ++ if (i >= *response_len) { ++ rc = -EOVERFLOW; ++ state = ERROR; ++ break; ++ } ++ recv_buffer[i++] = read_kcs_data(); ++ write_kcs_data(KCS_READ); ++ wait_while_ibf(); ++ state = RECV_INIT2; ++ break; ++ } ++ case RECV_INIT2: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ case KCS_WRITE_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_IDLE_STATE: ++ { ++ if (wait_until_obf() == 0) { ++ clear_obf(); ++ state = RECV_END; ++ break; ++ } else { ++ state = ERROR; ++ break; ++ } ++ } ++ case KCS_READ_STATE: ++ { ++ if (wait_until_obf() == 0) ++ state = RECV_NEXT; ++ else ++ state = ERROR; ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_END: ++ { ++ if ((i < MIN_BMC_RESPONSE_SIZE) || ++ (response->netfn != ++ (request->netfn | 0x01)) ++ || (response->cmd != request->cmd)) { ++ mdelay(BMC_RETRY_DELAY); ++ bad++; ++ state = SEND_INIT; ++ printk ++ ("[IPMI_KCS] Request/Response CMD/NETFN mismatch error\n"); ++ ++ printk ++ (" RQcmd/RQnetfn=0x%x/0x%x,RScmd/RSnetfn=0x%x/0x%x\n", ++ request->cmd, request->netfn, ++ response->cmd, ++ response->netfn); ++ break; ++ } ++ ++ *response_len = i; ++ rc = 0; ++ state = END; ++ break; ++ } ++ case ERROR: ++ default: ++ { ++ printk ++ ("[IPMI_KCS] BMC in bad state. Retrying transfer\n"); ++ mdelay(BMC_RETRY_DELAY); ++ bad++; ++ state = SEND_INIT; ++ break; ++ } ++ } ++ } ++ return (rc); ++} ++ ++static int old_kcs_do_xfer(BMC_REQUEST * request, ++ int request_len, ++ BMC_RESPONSE * response, int *response_len) ++{ ++ unsigned char *xmit_buffer, *recv_buffer; ++ int i = 0, rc = 0, state = SEND_INIT, bad = 0; ++ ++ xmit_buffer = (unsigned char *) request; ++ recv_buffer = (unsigned char *) response; ++ ++ while (1) { ++ if (state == END) ++ break; ++ else if (bad > 2) { ++ printk ++ ("[IPMI_KCS] Maximum retries exceeded. Aborting transfer\n"); ++ rc = -EIO; ++ break; ++ } ++ switch (state) { ++ case SEND_INIT: ++ { ++ i = 0; ++ state = SEND_START; ++ wait_while_ibf(); ++ } ++ case SEND_START: ++ { ++ state = SEND_NEXT; ++ write_kcs_cmd(WRITE_START); ++ wait_while_ibf(); ++ } ++ case SEND_NEXT: ++ { ++ if (i == (request_len - 1)) { ++ state = SEND_END; ++ break; ++ } ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ write_kcs_data(xmit_buffer[i++]); ++ wait_while_ibf(); ++ break; ++ } ++ case SEND_END: ++ { ++ wait_while_ibf(); ++ write_kcs_cmd(WRITE_END); ++ wait_while_ibf(); ++ if (get_kcs_state() != KCS_WRITE_STATE) { ++ state = ERROR; ++ break; ++ } ++ write_kcs_data(xmit_buffer[i++]); ++ wait_while_ibf(); ++ state = RECV_START; ++ } ++ case RECV_START: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_WRITE_STATE: ++ case KCS_IDLE_STATE: ++ { ++ mdelay(BMC_RESPONSE_DELAY); ++ break; ++ } ++ case KCS_READ_STATE: ++ { ++ i = 0; ++ memset(recv_buffer, 0, ++ *response_len); ++ state = RECV_INIT; ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_INIT: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ case KCS_WRITE_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_IDLE_STATE: ++ { ++ state = RECV_END; ++ break; ++ } ++ case KCS_READ_STATE: ++ { ++ if (is_obf_set()) ++ state = RECV_NEXT; ++ else ++ mdelay(1); ++ break; ++ } ++ default: ++ { ++ mdelay(1); ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_NEXT: ++ { ++ if (i >= *response_len) { ++ rc = -EOVERFLOW; ++ state = ERROR; ++ break; ++ } ++ recv_buffer[i++] = read_kcs_data(); ++ wait_while_ibf(); ++ write_kcs_data(KCS_READ); ++ state = RECV_INIT2; ++ break; ++ } ++ case RECV_INIT2: ++ { ++ switch (get_kcs_state()) { ++ case KCS_ERROR_STATE: ++ case KCS_WRITE_STATE: ++ { ++ state = ERROR; ++ break; ++ } ++ case KCS_IDLE_STATE: ++ { ++ state = RECV_END; ++ break; ++ } ++ case KCS_READ_STATE: ++ { ++ if (is_obf_set()) ++ state = RECV_NEXT; ++ break; ++ } ++ } ++ break; ++ } ++ case RECV_END: ++ { ++ if ((i < MIN_BMC_RESPONSE_SIZE) || ++ (response->netfn != ++ (request->netfn | 0x01)) ++ || (response->cmd != request->cmd)) { ++ mdelay(BMC_RETRY_DELAY); ++ bad++; ++ state = SEND_INIT; ++ printk ++ ("[IPMI_KCS] Request/Response CMD/NETFN mismatch error\n"); ++ ++ printk ++ (" RQcmd/RQnetfn=0x%x/0x%x,RScmd/RSnetfn=0x%x/0x%x\n", ++ request->cmd, request->netfn, ++ response->cmd, ++ response->netfn); ++ break; ++ } ++ ++ *response_len = i; ++ rc = 0; ++ state = END; ++ break; ++ } ++ case ERROR: ++ default: ++ { ++ printk ++ ("[IPMI_KCS] BMC in bad state. Retrying transfer\n"); ++ mdelay(BMC_RETRY_DELAY); ++ bad++; ++ state = SEND_INIT; ++ break; ++ } ++ } ++ } ++ return (rc); ++} ++ ++#ifdef CONFIG_PROC_FS ++int ipmi_get_info(char *buf, char **start, off_t fpos, int length, ++ int *eof, void *unused) ++{ ++ char *p; ++ ++ if (get_deviceid() != 0) { ++ printk("[IPMI_KCS] Unable to get device ID\n"); ++ memset(&dev_id, 0, sizeof(dev_id)); ++ } ++ ++ p = buf; ++ p += sprintf(p, "Driver Version\t: %d.%d\n", ++ driver_major, driver_minor); ++ p += sprintf(p, "BMC Version\t: %x.%x\n", ++ dev_id.major_firmware_revision, ++ dev_id.minor_firmware_revision); ++ p += sprintf(p, "IPMI Version\t: %d.%d\n", ++ dev_id.ipmi_version_major, dev_id.ipmi_version_minor); ++ p += sprintf(p, "\nTotal Good Transactions\t: %d\n", ++ kcs_stat.tx_good); ++ p += sprintf(p, "Total Bad Transactions\t: %d\n", kcs_stat.tx_bad); ++ ++ return p - buf; ++} ++#endif ++ ++/* ++ * kcs chip mashing stuff ++ */ ++static int wait_while_ibf() ++{ ++ unsigned char status_byte; ++ ++ status_byte = inb_p(KCS_STATUS_REG); ++ if ((status_byte & KCS_IBF) == 0) ++ return (0); ++ mdelay(KCS_READY_DELAY); ++ status_byte = inb_p(KCS_STATUS_REG); ++ if (status_byte & KCS_IBF) ++ return (-1); ++ return (0); ++} ++ ++static int wait_until_obf() ++{ ++ int retries = 0; ++ ++ while (retries < 2) { ++ if (is_obf_set()) ++ return (0); ++ mdelay(KCS_READY_DELAY); ++ retries++; ++ } ++ return (-ETIMEDOUT); ++} ++ ++static unsigned char get_kcs_state() ++{ ++ unsigned char cs; ++ ++ cs = inb_p(KCS_STATUS_REG); ++ return (cs & KCS_STATE_MASK); ++} ++ ++static unsigned char read_kcs_data() ++{ ++ unsigned char data; ++ ++ data = inb_p(KCS_DATAOUT_REG); ++ return (data); ++} ++ ++static void write_kcs_data(unsigned char data) ++{ ++ outb_p(data, KCS_DATAIN_REG); ++} ++ ++static void write_kcs_cmd(unsigned char cmd) ++{ ++ outb_p(cmd, KCS_COMMAND_REG); ++} ++ ++static int is_obf_set() ++{ ++ unsigned char cs; ++ ++ cs = inb_p(KCS_STATUS_REG); ++ return ((cs & KCS_OBF) == KCS_OBF); ++} ++ ++static int clear_obf() ++{ ++ read_kcs_data(); ++ return (0); ++} +--- /dev/null Fri Mar 23 23:37:44 2001 ++++ linux-bmc/drivers/char/ipmi_kcs.h Tue Oct 30 17:18:07 2001 +@@ -0,0 +1,171 @@ ++/* ++ * Intelligent Platform Management Interface driver for Linux 2.x ++ * ++ * (c) Copyright 1999 San Mehat & VA Linux Systems ++ * 1382 Bordeaux Dr. ++ * Sunnyvale, California ++ * 94089 ++ * ++ * http://www.valinux.com ++ * ++ * This driver is provided under the GNU public license, incorporated ++ * herein by reference. The driver is provided without warranty or ++ * support. ++ * ++ * ++ */ ++ ++#include <linux/config.h> ++ ++#define KCS_LEGACY 1 ++#define KCS_NEW 2 ++ ++#define KCS_READY_DELAY 5 ++#define BMC_RESPONSE_DELAY 5 ++#define BMC_RETRY_DELAY 60 ++ ++#if defined(__ia64__) ++#define KCS_BASE 0x8a2 ++#else ++#define KCS_BASE 0xca2 ++#endif ++#define KCS_STATUS_REG (KCS_BASE + 1) ++#define KCS_COMMAND_REG (KCS_BASE + 1) ++#define KCS_DATAIN_REG (KCS_BASE + 0) ++#define KCS_DATAOUT_REG (KCS_BASE + 0) ++ ++/* State bits based on S1 & S0 below */ ++#define KCS_STATE_MASK 0xC0 ++#define KCS_IDLE_STATE 0x00 ++#define KCS_READ_STATE 0x40 ++#define KCS_WRITE_STATE 0x80 ++#define KCS_ERROR_STATE 0xC0 ++ ++#define KCS_IBF 0x02 ++#define KCS_OBF 0x01 ++#define KCS_SMS_ATN 0x04 ++ ++#define SEND_INIT 1 ++#define SEND_START 2 ++#define SEND_NEXT 3 ++#define SEND_END 4 ++#define RECV_START 5 ++#define RECV_INIT 6 ++#define RECV_NEXT 7 ++#define RECV_INIT2 8 ++#define RECV_END 9 ++#define END 10 ++#define ERROR 0 ++ ++/* SMS Transfer Stream Control Codes */ ++#define GET_STATUS_ABORT 0x60 ++#define WRITE_START 0x61 ++#define WRITE_END 0x62 ++#define KCS_READ 0x68 ++ ++#define MAX_INVALID_RESPONSE_COUNT 2 ++#define MIN_BMC_RESPONSE_SIZE 3 ++#define MAX_IMB_PACKET_SIZE 33 ++#define MAX_BMC_RESPONSE_SIZE (MIN_BMC_RESPONSE_SIZE + MAX_IMB_PACKET_SIZE) ++#define MAX_XFER_LENGTH (MAX_IMB_PACKET_SIZE * 2) ++ ++#define MAX_BUFFER_SIZE 64 ++ ++typedef struct bmc_response ++ { ++ unsigned char lun :2; ++ unsigned char netfn :6; ++ ++ unsigned char cmd; ++ unsigned char cc; ++ unsigned char data[1]; ++ }BMC_RESPONSE; ++ ++typedef struct bmc_request ++ { ++ unsigned char lun :2; ++ unsigned char netfn :6; ++ ++ unsigned char cmd; ++ unsigned char data[1]; ++ }BMC_REQUEST; ++ ++/* GET_DEVICE_ID RESPONSE */ ++typedef struct device_id_response ++ { ++ unsigned char device_id; ++ ++ unsigned char device_revision :4; ++ unsigned char reserved :3; ++ unsigned char provides_sdr :1; ++ ++ unsigned char major_firmware_revision :7; ++ #define NORMAL_OPERATION 0 ++ #define DEVICE_BUSY 1 ++ unsigned char device_available :1; ++ ++ unsigned char minor_firmware_revision; ++ ++ unsigned char ipmi_version_major :4; ++ unsigned char ipmi_version_minor :4; ++ ++ unsigned char supports_sensor_device :1; ++ unsigned char supports_sdr_device :1; ++ unsigned char supports_sel_device :1; ++ unsigned char supports_fru_device :1; ++ unsigned char supports_ipmb_receiver :1; ++ unsigned char supports_ipmb_generator :1; ++ unsigned char supports_bridge :1; ++ unsigned char supports_chassis_device :1; ++ ++ unsigned char manufacturer_id1; ++ unsigned char manufacturer_id2; ++ unsigned char manufacturer_id3; ++ ++ unsigned short product_id; ++ } DEVICE_ID_RESPONSE; ++ ++typedef struct set_watchdog ++ { ++ unsigned char timer_use :3; ++ unsigned char res1 :4; ++ unsigned char dontlog :1; ++ ++ unsigned char timeout_action :3; ++ unsigned char res2 :1; ++ unsigned char pre_irq :3; ++ unsigned char res3 :1; ++ ++ unsigned char pretimeout_interval; ++ ++ unsigned char tuefc_res1 :1; ++ unsigned char tuefc_biosfrb2 :1; ++ unsigned char tuefc_biospost :1; ++ unsigned char tuefc_osload :1; ++ unsigned char tuefc_smsos :1; ++ unsigned char tuefc_oem :1; ++ unsigned char tuefc_res2 :1; ++ unsigned char tuefc_res3 :1; ++ ++ unsigned short initial_count; ++ } SET_WATCHDOG; ++ ++typedef struct get_watchdog_response ++ { ++ unsigned char timer_use :3; ++ unsigned char res1 :3; ++ unsigned char timer_status :1; ++ unsigned char sel_log :1; ++ ++ unsigned char timeout_act :3; ++ unsigned char res2 :1; ++ unsigned char pre_irq_act :3; ++ unsigned char res3 :1; ++ ++ unsigned char pre_timeout __attribute__ ((packed)); ++ ++ unsigned char timer_use_xp __attribute__ ((packed)); ++ ++ unsigned short init_count __attribute__ ((packed)); ++ unsigned short current_count __attribute__ ((packed)); ++ } GET_WATCHDOG_RESPONSE; +--- /dev/null Fri Mar 23 23:37:44 2001 ++++ linux-bmc/include/linux/ipmi_ioctls.h Tue Oct 30 17:18:07 2001 +@@ -0,0 +1,152 @@ ++/* ++ * Intelligent Platform Management Interface driver for Linux 2.x ++ * ++ * (c) Copyright 1999 San Mehat & VA Linux Systems ++ * 1382 Bordeaux Dr. ++ * Sunnyvale, California ++ * 94089 ++ * ++ * http://www.valinux.com ++ * ++ * This driver is provided under the GNU public license, incorporated ++ * herein by reference. The driver is provided without warranty or ++ * support. ++ * ++ * IOCTL definitions for IPMI drivers ++ */ ++ ++/* ++ * Note: The following macros should be used on the IPMI_XFER structure. ++ * DO NOT try to muck with this structure directly.. use the macros ++ * to ensure future compatibility: ++ * ++ * INIT_XFER(IPMI_XFER *); ++ * -- Zero out a IPMI_XFER structure and initialize it for use ++ * ++ * SET_REQUEST_LUN(IPMI_XFER *, unsigned char lun); ++ * -- Set the request packet logical unit ++ * ++ * SET_REQUEST_NETFN(IPMI_XFER *, unsigned char netfn); ++ * -- Set the request packet network function code ++ * ++ * SET_REQUEST_CMD(IPMI_XFER *, unsigned char cmd); ++ * -- Set the request packet IPMI command code ++ * ++ * SET_REQUEST_DATA(IPMI_XFER *, unsigned char *data, int length); ++ * -- Set the request packet optional argument data field ++ * ++ * GET_RESPONSE_LUN(IPMI_XFER *, unsigned char lun); ++ * -- Get the response packet logical unit ++ * ++ * GET_RESPONSE_NETFN(IPMI_XFER *, unsigned char netfn); ++ * -- Get the response packet network function code ++ * ++ * GET_RESPONSE_CMD(IPMI_XFER *, unsigned char cmd); ++ * -- Get the response packet command ++ * ++ * GET_RESPONSE_CC(IPMI_XFER *, unsigned char cc); ++ * -- Get the response packet completion code ++ * ++ * GET_RESPONSE_DATA_LENGTH(IPMI_XFER *, int len); ++ * -- Get the response packet data length ++ * ++ * GET_RESPONSE_DATA(IPMI_XFER *, unsigned char *buffer); ++ * -- Copy the response packet data into local buffer ++ */ ++ ++#ifndef _IPMI_IOCTLS_H ++#define _IPMI_IOCTLS_H ++ ++#define IOCTL_IPMI_XFER 0x01 ++#define IOCTL_DRIVER_INFO 0x02 ++ ++typedef struct ipmi_xfer ++ { ++ unsigned char request[64]; ++ unsigned char response[64]; ++ int request_len; ++ int response_len; ++ } IPMI_XFER; ++ ++struct ipmi_driver_info ++ { ++ char driver_name[64]; /* Name of the driver */ ++ int major_ver; ++ int minor_ver; ++ unsigned short mb_chipset_vendor; /* PCI host bridge vendor tag */ ++ unsigned short mb_chipset_device; /* PCI host bridge vendor device id */ ++ unsigned int flags; /* driver specific flags */ ++ unsigned int reserved; ++ }; ++ ++/* flags definitions for the 'ipmi_kcs' driver */ ++#define KCS_FLAG_BLINKY 0x01 /* Set if blinky works (only on Intel L440GX) */ ++#define KCS_FLAG_LEGACY 0x02 /* Set if using legacy KCS interface ( < IPMI 1.0) */ ++ ++#define INIT_XFER(_xferp) \ ++ memset(_xferp, 0, sizeof(IPMI_XFER)); \ ++ _xferp->request_len = 2; \ ++ _xferp->response_len = sizeof(_xferp->response); ++ ++#define SET_REQUEST_LUN(_xferp, _lun) \ ++ { \ ++ unsigned char _netfn_copy; \ ++ \ ++ _netfn_copy = (_xferp->request[0] & 0xFC); \ ++ _xferp->request[0] = _lun; \ ++ _xferp->request[0]|= _netfn_copy; \ ++ } ++ ++#define SET_REQUEST_NETFN(_xferp, netfn) \ ++ { \ ++ unsigned char __lun_copy; \ ++ \ ++ __lun_copy = (_xferp->request[0] & 0x3); \ ++ _xferp->request[0] = (netfn << 2); \ ++ _xferp->request[0]|= __lun_copy; \ ++ } ++ ++#define SET_REQUEST_CMD(_xferp, _cmd) \ ++ _xferp->request[1] = _cmd; ++ ++#define SET_REQUEST_DATA(_xferp, datap, _len) \ ++ { \ ++ memcpy(&_xferp->request[2], datap, _len); \ ++ _xferp->request_len = (_len + 2); \ ++ } ++ ++#define GET_RESPONSE_LUN(_xferp, _lun) \ ++ _lun = (_xferp->response[0] & 0x3); ++ ++#define GET_RESPONSE_NETFN(_xferp, netfn) \ ++ netfn = ((_xferp->response[0] & 0xFC) >> 2); ++ ++#define GET_RESPONSE_CMD(_xferp, _cmd) \ ++ _cmd = _xferp->response[1]; ++ ++#define GET_RESPONSE_CC(_xferp, cc) \ ++ cc = _xferp->response[2]; ++ ++#define GET_RESPONSE_DATA_LENGTH(_xferp, _len) \ ++ _len = (_xferp->response_len - 3); ++ ++#define GET_RESPONSE_DATA(_xferp, datap) \ ++ memcpy(datap, &_xferp->response[3], (_xferp->response_len -3)); ++ ++/* ++ * The Netfn codes ++ */ ++#define CHASSIS_REQUEST 0x00 ++#define CHASSIS_RESPONSE 0x01 ++#define BRIDGE_REQUEST 0x02 ++#define BRIDGE_RESPONSE 0x03 ++#define SENSOR_REQUEST 0x04 ++#define SENSOR_RESPONSE 0x05 ++#define APP_REQUEST 0x06 ++#define APP_RESPONSE 0x07 ++#define FIRMWARE_REQUEST 0x08 ++#define FIRMWARE_RESPONSE 0x09 ++#define STORAGE_REQUEST 0x0A ++#define STORAGE_RESPONSE 0x0B ++ ++#endif |