580 lines
14 KiB
C
580 lines
14 KiB
C
/*
|
|
* Configuration OSM
|
|
*
|
|
* Copyright (C) 2005 Markus Lidel <Markus.Lidel@shadowconnect.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.
|
|
*
|
|
* Fixes/additions:
|
|
* Markus Lidel <Markus.Lidel@shadowconnect.com>
|
|
* initial version.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/i2o.h>
|
|
#include <linux/namei.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#define OSM_NAME "config-osm"
|
|
#define OSM_VERSION "1.248"
|
|
#define OSM_DESCRIPTION "I2O Configuration OSM"
|
|
|
|
/* access mode user rw */
|
|
#define S_IWRSR (S_IRUSR | S_IWUSR)
|
|
|
|
static struct i2o_driver i2o_config_driver;
|
|
|
|
/* Special file operations for sysfs */
|
|
struct fops_attribute {
|
|
struct bin_attribute bin;
|
|
struct file_operations fops;
|
|
};
|
|
|
|
/**
|
|
* sysfs_read_dummy
|
|
*/
|
|
static ssize_t sysfs_read_dummy(struct kobject *kobj, char *buf, loff_t offset,
|
|
size_t count)
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
/**
|
|
* sysfs_write_dummy
|
|
*/
|
|
static ssize_t sysfs_write_dummy(struct kobject *kobj, char *buf, loff_t offset,
|
|
size_t count)
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
/**
|
|
* sysfs_create_fops_file - Creates attribute with special file operations
|
|
* @kobj: kobject which should contains the attribute
|
|
* @attr: attributes which should be used to create file
|
|
*
|
|
* First creates attribute @attr in kobject @kobj. If it is the first time
|
|
* this function is called, merge old fops from sysfs with new one and
|
|
* write it back. Afterwords the new fops will be set for the created
|
|
* attribute.
|
|
*
|
|
* Returns 0 on success or negative error code on failure.
|
|
*/
|
|
static int sysfs_create_fops_file(struct kobject *kobj,
|
|
struct fops_attribute *attr)
|
|
{
|
|
struct file_operations tmp, *fops;
|
|
struct dentry *d;
|
|
struct qstr qstr;
|
|
int rc;
|
|
|
|
fops = &attr->fops;
|
|
|
|
if (fops->read)
|
|
attr->bin.read = sysfs_read_dummy;
|
|
|
|
if (fops->write)
|
|
attr->bin.write = sysfs_write_dummy;
|
|
|
|
if ((rc = sysfs_create_bin_file(kobj, &attr->bin)))
|
|
return rc;
|
|
|
|
qstr.name = attr->bin.attr.name;
|
|
qstr.len = strlen(qstr.name);
|
|
qstr.hash = full_name_hash(qstr.name, qstr.len);
|
|
|
|
if ((d = lookup_hash(&qstr, kobj->dentry))) {
|
|
if (!fops->owner) {
|
|
memcpy(&tmp, d->d_inode->i_fop, sizeof(tmp));
|
|
if (fops->read)
|
|
tmp.read = fops->read;
|
|
if (fops->write)
|
|
tmp.write = fops->write;
|
|
memcpy(fops, &tmp, sizeof(tmp));
|
|
}
|
|
|
|
d->d_inode->i_fop = fops;
|
|
} else
|
|
sysfs_remove_bin_file(kobj, &attr->bin);
|
|
|
|
return -ENOENT;
|
|
};
|
|
|
|
/**
|
|
* sysfs_remove_fops_file - Remove attribute with special file operations
|
|
* @kobj: kobject which contains the attribute
|
|
* @attr: attributes which are used to create file
|
|
*
|
|
* Only wrapper arround sysfs_remove_bin_file()
|
|
*
|
|
* Returns 0 on success or negative error code on failure.
|
|
*/
|
|
static inline int sysfs_remove_fops_file(struct kobject *kobj,
|
|
struct fops_attribute *attr)
|
|
{
|
|
return sysfs_remove_bin_file(kobj, &attr->bin);
|
|
};
|
|
|
|
/**
|
|
* i2o_config_read_hrt - Returns the HRT of the controller
|
|
* @kob: kernel object handle
|
|
* @buf: buffer into which the HRT should be copied
|
|
* @off: file offset
|
|
* @count: number of bytes to read
|
|
*
|
|
* Put @count bytes starting at @off into @buf from the HRT of the I2O
|
|
* controller corresponding to @kobj.
|
|
*
|
|
* Returns number of bytes copied into buffer.
|
|
*/
|
|
static ssize_t i2o_config_read_hrt(struct kobject *kobj, char *buf,
|
|
loff_t offset, size_t count)
|
|
{
|
|
struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
|
|
i2o_hrt *hrt = c->hrt.virt;
|
|
|
|
u32 size = (hrt->num_entries * hrt->entry_len + 2) * 4;
|
|
|
|
if (offset > size)
|
|
return 0;
|
|
|
|
if (offset + count > size)
|
|
count = size - offset;
|
|
|
|
memcpy(buf, (u8 *) hrt + offset, count);
|
|
|
|
return count;
|
|
};
|
|
|
|
/**
|
|
* i2o_config_read_lct - Returns the LCT of the controller
|
|
* @kob: kernel object handle
|
|
* @buf: buffer into which the LCT should be copied
|
|
* @off: file offset
|
|
* @count: number of bytes to read
|
|
*
|
|
* Put @count bytes starting at @off into @buf from the LCT of the I2O
|
|
* controller corresponding to @kobj.
|
|
*
|
|
* Returns number of bytes copied into buffer.
|
|
*/
|
|
static ssize_t i2o_config_read_lct(struct kobject *kobj, char *buf,
|
|
loff_t offset, size_t count)
|
|
{
|
|
struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
|
|
u32 size = c->lct->table_size * 4;
|
|
|
|
if (offset > size)
|
|
return 0;
|
|
|
|
if (offset + count > size)
|
|
count = size - offset;
|
|
|
|
memcpy(buf, (u8 *) c->lct + offset, count);
|
|
|
|
return count;
|
|
};
|
|
|
|
#define I2O_CONFIG_SW_ATTR(_name,_mode,_type,_swid) \
|
|
static ssize_t i2o_config_##_name##_read(struct file *file, char __user *buf, size_t count, loff_t * offset) { \
|
|
return i2o_config_sw_read(file, buf, count, offset, _type, _swid); \
|
|
};\
|
|
\
|
|
static ssize_t i2o_config_##_name##_write(struct file *file, const char __user *buf, size_t count, loff_t * offset) { \
|
|
return i2o_config_sw_write(file, buf, count, offset, _type, _swid); \
|
|
}; \
|
|
\
|
|
static struct fops_attribute i2o_config_attr_##_name = { \
|
|
.bin = { .attr = { .name = __stringify(_name), .mode = _mode, \
|
|
.owner = THIS_MODULE }, \
|
|
.size = 0, }, \
|
|
.fops = { .write = i2o_config_##_name##_write, \
|
|
.read = i2o_config_##_name##_read} \
|
|
};
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
|
|
/**
|
|
* i2o_config_dpt_reagion - Converts type and id to flash region
|
|
* @swtype: type of software module reading
|
|
* @swid: id of software which should be read
|
|
*
|
|
* Converts type and id from I2O spec to the matching region for DPT /
|
|
* Adaptec controllers.
|
|
*
|
|
* Returns region which match type and id or -1 on error.
|
|
*/
|
|
static u32 i2o_config_dpt_region(u8 swtype, u8 swid)
|
|
{
|
|
switch (swtype) {
|
|
case I2O_SOFTWARE_MODULE_IRTOS:
|
|
/*
|
|
* content: operation firmware
|
|
* region size:
|
|
* 0xbc000 for 2554, 3754, 2564, 3757
|
|
* 0x170000 for 2865
|
|
* 0x17c000 for 3966
|
|
*/
|
|
if (!swid)
|
|
return 0;
|
|
|
|
break;
|
|
|
|
case I2O_SOFTWARE_MODULE_IOP_PRIVATE:
|
|
/*
|
|
* content: BIOS and SMOR
|
|
* BIOS size: first 0x8000 bytes
|
|
* region size:
|
|
* 0x40000 for 2554, 3754, 2564, 3757
|
|
* 0x80000 for 2865, 3966
|
|
*/
|
|
if (!swid)
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case I2O_SOFTWARE_MODULE_IOP_CONFIG:
|
|
switch (swid) {
|
|
case 0:
|
|
/*
|
|
* content: NVRAM defaults
|
|
* region size: 0x2000 bytes
|
|
*/
|
|
return 2;
|
|
case 1:
|
|
/*
|
|
* content: serial number
|
|
* region size: 0x2000 bytes
|
|
*/
|
|
return 3;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return -1;
|
|
};
|
|
|
|
#endif
|
|
|
|
/**
|
|
* i2o_config_sw_read - Read a software module from controller
|
|
* @file: file pointer
|
|
* @buf: buffer into which the data should be copied
|
|
* @count: number of bytes to read
|
|
* @off: file offset
|
|
* @swtype: type of software module reading
|
|
* @swid: id of software which should be read
|
|
*
|
|
* Transfers @count bytes at offset @offset from IOP into buffer using
|
|
* type @swtype and id @swid as described in I2O spec.
|
|
*
|
|
* Returns number of bytes copied into buffer or error code on failure.
|
|
*/
|
|
static ssize_t i2o_config_sw_read(struct file *file, char __user * buf,
|
|
size_t count, loff_t * offset, u8 swtype,
|
|
u32 swid)
|
|
{
|
|
struct sysfs_dirent *sd = file->f_dentry->d_parent->d_fsdata;
|
|
struct kobject *kobj = sd->s_element;
|
|
struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
|
|
u32 m, function = I2O_CMD_SW_UPLOAD;
|
|
struct i2o_dma buffer;
|
|
struct i2o_message __iomem *msg;
|
|
u32 __iomem *mptr;
|
|
int rc, status;
|
|
|
|
m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
|
|
if (m == I2O_QUEUE_EMPTY)
|
|
return -EBUSY;
|
|
|
|
mptr = &msg->body[3];
|
|
|
|
if ((rc = i2o_dma_alloc(&c->pdev->dev, &buffer, count, GFP_KERNEL))) {
|
|
i2o_msg_nop(c, m);
|
|
return rc;
|
|
}
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (c->adaptec) {
|
|
mptr = &msg->body[4];
|
|
function = I2O_CMD_PRIVATE;
|
|
|
|
writel(TEN_WORD_MSG_SIZE | SGL_OFFSET_8, &msg->u.head[0]);
|
|
|
|
writel(I2O_VENDOR_DPT << 16 | I2O_DPT_FLASH_READ,
|
|
&msg->body[0]);
|
|
writel(i2o_config_dpt_region(swtype, swid), &msg->body[1]);
|
|
writel(*offset, &msg->body[2]);
|
|
writel(count, &msg->body[3]);
|
|
} else
|
|
#endif
|
|
writel(NINE_WORD_MSG_SIZE | SGL_OFFSET_7, &msg->u.head[0]);
|
|
|
|
writel(0xD0000000 | count, mptr++);
|
|
writel(buffer.phys, mptr);
|
|
|
|
writel(function << 24 | HOST_TID << 12 | ADAPTER_TID, &msg->u.head[1]);
|
|
writel(i2o_config_driver.context, &msg->u.head[2]);
|
|
writel(0, &msg->u.head[3]);
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (!c->adaptec)
|
|
#endif
|
|
{
|
|
writel((u32) swtype << 16 | (u32) 1 << 8, &msg->body[0]);
|
|
writel(0, &msg->body[1]);
|
|
writel(swid, &msg->body[2]);
|
|
}
|
|
|
|
status = i2o_msg_post_wait_mem(c, m, 60, &buffer);
|
|
|
|
if (status == I2O_POST_WAIT_OK) {
|
|
if (!(rc = copy_to_user(buf, buffer.virt, count))) {
|
|
rc = count;
|
|
*offset += count;
|
|
}
|
|
} else
|
|
rc = -EIO;
|
|
|
|
if (status != -ETIMEDOUT)
|
|
i2o_dma_free(&c->pdev->dev, &buffer);
|
|
|
|
return rc;
|
|
};
|
|
|
|
/**
|
|
* i2o_config_sw_write - Write a software module to controller
|
|
* @file: file pointer
|
|
* @buf: buffer into which the data should be copied
|
|
* @count: number of bytes to read
|
|
* @off: file offset
|
|
* @swtype: type of software module writing
|
|
* @swid: id of software which should be written
|
|
*
|
|
* Transfers @count bytes at offset @offset from buffer to IOP using
|
|
* type @swtype and id @swid as described in I2O spec.
|
|
*
|
|
* Returns number of bytes copied from buffer or error code on failure.
|
|
*/
|
|
static ssize_t i2o_config_sw_write(struct file *file, const char __user * buf,
|
|
size_t count, loff_t * offset, u8 swtype,
|
|
u32 swid)
|
|
{
|
|
struct sysfs_dirent *sd = file->f_dentry->d_parent->d_fsdata;
|
|
struct kobject *kobj = sd->s_element;
|
|
struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
|
|
u32 m, function = I2O_CMD_SW_DOWNLOAD;
|
|
struct i2o_dma buffer;
|
|
struct i2o_message __iomem *msg;
|
|
u32 __iomem *mptr;
|
|
int rc, status;
|
|
|
|
m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
|
|
if (m == I2O_QUEUE_EMPTY)
|
|
return -EBUSY;
|
|
|
|
mptr = &msg->body[3];
|
|
|
|
if ((rc = i2o_dma_alloc(&c->pdev->dev, &buffer, count, GFP_KERNEL)))
|
|
goto nop_msg;
|
|
|
|
if ((rc = copy_from_user(buffer.virt, buf, count)))
|
|
goto free_buffer;
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (c->adaptec) {
|
|
mptr = &msg->body[4];
|
|
function = I2O_CMD_PRIVATE;
|
|
|
|
writel(TEN_WORD_MSG_SIZE | SGL_OFFSET_8, &msg->u.head[0]);
|
|
|
|
writel(I2O_VENDOR_DPT << 16 | I2O_DPT_FLASH_WRITE,
|
|
&msg->body[0]);
|
|
writel(i2o_config_dpt_region(swtype, swid), &msg->body[1]);
|
|
writel(*offset, &msg->body[2]);
|
|
writel(count, &msg->body[3]);
|
|
} else
|
|
#endif
|
|
writel(NINE_WORD_MSG_SIZE | SGL_OFFSET_7, &msg->u.head[0]);
|
|
|
|
writel(0xD4000000 | count, mptr++);
|
|
writel(buffer.phys, mptr);
|
|
|
|
writel(function << 24 | HOST_TID << 12 | ADAPTER_TID, &msg->u.head[1]);
|
|
writel(i2o_config_driver.context, &msg->u.head[2]);
|
|
writel(0, &msg->u.head[3]);
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (!c->adaptec)
|
|
#endif
|
|
{
|
|
writel((u32) swtype << 16 | (u32) 1 << 8, &msg->body[0]);
|
|
writel(0, &msg->body[1]);
|
|
writel(swid, &msg->body[2]);
|
|
}
|
|
|
|
status = i2o_msg_post_wait_mem(c, m, 60, &buffer);
|
|
|
|
if (status != -ETIMEDOUT)
|
|
i2o_dma_free(&c->pdev->dev, &buffer);
|
|
|
|
if (status != I2O_POST_WAIT_OK)
|
|
return -EIO;
|
|
|
|
*offset += count;
|
|
|
|
return count;
|
|
|
|
free_buffer:
|
|
i2o_dma_free(&c->pdev->dev, &buffer);
|
|
|
|
nop_msg:
|
|
i2o_msg_nop(c, m);
|
|
|
|
return rc;
|
|
};
|
|
|
|
/* attribute for HRT in sysfs */
|
|
static struct bin_attribute i2o_config_hrt_attr = {
|
|
.attr = {
|
|
.name = "hrt",
|
|
.mode = S_IRUGO,
|
|
.owner = THIS_MODULE},
|
|
.size = 0,
|
|
.read = i2o_config_read_hrt
|
|
};
|
|
|
|
/* attribute for LCT in sysfs */
|
|
static struct bin_attribute i2o_config_lct_attr = {
|
|
.attr = {
|
|
.name = "lct",
|
|
.mode = S_IRUGO,
|
|
.owner = THIS_MODULE},
|
|
.size = 0,
|
|
.read = i2o_config_read_lct
|
|
};
|
|
|
|
/* IRTOS firmware access */
|
|
I2O_CONFIG_SW_ATTR(irtos, S_IWRSR, I2O_SOFTWARE_MODULE_IRTOS, 0);
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
|
|
/*
|
|
* attribute for BIOS / SMOR, nvram and serial number access on DPT / Adaptec
|
|
* controllers
|
|
*/
|
|
I2O_CONFIG_SW_ATTR(bios, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_PRIVATE, 0);
|
|
I2O_CONFIG_SW_ATTR(nvram, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_CONFIG, 0);
|
|
I2O_CONFIG_SW_ATTR(serial, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_CONFIG, 1);
|
|
|
|
#endif
|
|
|
|
/**
|
|
* i2o_config_notify_controller_add - Notify of added controller
|
|
* @c: the controller which was added
|
|
*
|
|
* If a I2O controller is added, we catch the notification to add sysfs
|
|
* entries.
|
|
*/
|
|
static void i2o_config_notify_controller_add(struct i2o_controller *c)
|
|
{
|
|
struct kobject *kobj = &c->exec->device.kobj;
|
|
|
|
sysfs_create_bin_file(kobj, &i2o_config_hrt_attr);
|
|
sysfs_create_bin_file(kobj, &i2o_config_lct_attr);
|
|
|
|
sysfs_create_fops_file(kobj, &i2o_config_attr_irtos);
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (c->adaptec) {
|
|
sysfs_create_fops_file(kobj, &i2o_config_attr_bios);
|
|
sysfs_create_fops_file(kobj, &i2o_config_attr_nvram);
|
|
sysfs_create_fops_file(kobj, &i2o_config_attr_serial);
|
|
}
|
|
#endif
|
|
};
|
|
|
|
/**
|
|
* i2o_config_notify_controller_remove - Notify of removed controller
|
|
* @c: the controller which was removed
|
|
*
|
|
* If a I2O controller is removed, we catch the notification to remove the
|
|
* sysfs entries.
|
|
*/
|
|
static void i2o_config_notify_controller_remove(struct i2o_controller *c)
|
|
{
|
|
struct kobject *kobj = &c->exec->device.kobj;
|
|
|
|
#ifdef CONFIG_I2O_EXT_ADAPTEC
|
|
if (c->adaptec) {
|
|
sysfs_remove_fops_file(kobj, &i2o_config_attr_serial);
|
|
sysfs_remove_fops_file(kobj, &i2o_config_attr_nvram);
|
|
sysfs_remove_fops_file(kobj, &i2o_config_attr_bios);
|
|
}
|
|
#endif
|
|
sysfs_remove_fops_file(kobj, &i2o_config_attr_irtos);
|
|
|
|
sysfs_remove_bin_file(kobj, &i2o_config_lct_attr);
|
|
sysfs_remove_bin_file(kobj, &i2o_config_hrt_attr);
|
|
};
|
|
|
|
/* Config OSM driver struct */
|
|
static struct i2o_driver i2o_config_driver = {
|
|
.name = OSM_NAME,
|
|
.notify_controller_add = i2o_config_notify_controller_add,
|
|
.notify_controller_remove = i2o_config_notify_controller_remove
|
|
};
|
|
|
|
#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
|
|
#include "i2o_config.c"
|
|
#endif
|
|
|
|
/**
|
|
* i2o_config_init - Configuration OSM initialization function
|
|
*
|
|
* Registers Configuration OSM in the I2O core and if old ioctl's are
|
|
* compiled in initialize them.
|
|
*
|
|
* Returns 0 on success or negative error code on failure.
|
|
*/
|
|
static int __init i2o_config_init(void)
|
|
{
|
|
printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
|
|
|
|
if (i2o_driver_register(&i2o_config_driver)) {
|
|
osm_err("handler register failed.\n");
|
|
return -EBUSY;
|
|
}
|
|
#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
|
|
if (i2o_config_old_init())
|
|
i2o_driver_unregister(&i2o_config_driver);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* i2o_config_exit - Configuration OSM exit function
|
|
*
|
|
* If old ioctl's are compiled in exit remove them and unregisters
|
|
* Configuration OSM from I2O core.
|
|
*/
|
|
static void i2o_config_exit(void)
|
|
{
|
|
#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
|
|
i2o_config_old_exit();
|
|
#endif
|
|
|
|
i2o_driver_unregister(&i2o_config_driver);
|
|
}
|
|
|
|
MODULE_AUTHOR("Markus Lidel <Markus.Lidel@shadowconnect.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION(OSM_DESCRIPTION);
|
|
MODULE_VERSION(OSM_VERSION);
|
|
|
|
module_init(i2o_config_init);
|
|
module_exit(i2o_config_exit);
|