[deliverable/linux.git] / drivers / scsi / arcmsr / arcmsr_attr.c

/*
*******************************************************************************
**        O.S   : Linux
**   FILE NAME  : arcmsr_attr.c
**        BY    : Erich Chen
**   Description: attributes exported to sysfs and device host
*******************************************************************************
** Copyright (C) 2002 - 2005, Areca Technology Corporation All rights reserved
**
**     Web site: www.areca.com.tw
**       E-mail: erich@areca.com.tw
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License version 2 as
** published by the Free Software Foundation.
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
*******************************************************************************
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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.
*******************************************************************************
** For history of changes, see Documentation/scsi/ChangeLog.arcmsr
**     Firmware Specification, see Documentation/scsi/arcmsr_spec.txt
*******************************************************************************
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/delay.h>

#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_transport.h>
#include "arcmsr.h"

struct class_device_attribute *arcmsr_host_attrs[];

static ssize_t
arcmsr_sysfs_iop_message_read(struct kobject *kobj, char *buf, loff_t off,
    size_t count)
{
	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	struct MessageUnit __iomem *reg = acb->pmu;
	uint8_t *pQbuffer,*ptmpQbuffer;
	int32_t allxfer_len = 0;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	/* do message unit read. */
	ptmpQbuffer = (uint8_t *)buf;
	while ((acb->rqbuf_firstindex != acb->rqbuf_lastindex)
		&& (allxfer_len < 1031)) {
		pQbuffer = &acb->rqbuffer[acb->rqbuf_firstindex];
		memcpy(ptmpQbuffer, pQbuffer, 1);
		acb->rqbuf_firstindex++;
		acb->rqbuf_firstindex %= ARCMSR_MAX_QBUFFER;
		ptmpQbuffer++;
		allxfer_len++;
	}
	if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
		struct QBUFFER __iomem * prbuffer = (struct QBUFFER __iomem *)
					&reg->message_rbuffer;
		uint8_t __iomem * iop_data = (uint8_t __iomem *)prbuffer->data;
		int32_t iop_len;

		acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
		iop_len = readl(&prbuffer->data_len);
		while (iop_len > 0) {
			acb->rqbuffer[acb->rqbuf_lastindex] = readb(iop_data);
			acb->rqbuf_lastindex++;
			acb->rqbuf_lastindex %= ARCMSR_MAX_QBUFFER;
			iop_data++;
			iop_len--;
		}
		writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK,
				&reg->inbound_doorbell);
	}
	return (allxfer_len);
}

static ssize_t
arcmsr_sysfs_iop_message_write(struct kobject *kobj, char *buf, loff_t off,
    size_t count)
{
	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex;
	uint8_t *pQbuffer, *ptmpuserbuffer;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
	if (count > 1032)
		return -EINVAL;
	/* do message unit write. */
	ptmpuserbuffer = (uint8_t *)buf;
	user_len = (int32_t)count;
	wqbuf_lastindex = acb->wqbuf_lastindex;
	wqbuf_firstindex = acb->wqbuf_firstindex;
	if (wqbuf_lastindex != wqbuf_firstindex) {
		arcmsr_post_Qbuffer(acb);
		return 0;	/*need retry*/
	} else {
		my_empty_len = (wqbuf_firstindex-wqbuf_lastindex - 1)
				&(ARCMSR_MAX_QBUFFER - 1);
		if (my_empty_len >= user_len) {
			while (user_len > 0) {
				pQbuffer =
				&acb->wqbuffer[acb->wqbuf_lastindex];
				memcpy(pQbuffer, ptmpuserbuffer, 1);
				acb->wqbuf_lastindex++;
				acb->wqbuf_lastindex %= ARCMSR_MAX_QBUFFER;
				ptmpuserbuffer++;
				user_len--;
			}
			if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_CLEARED) {
				acb->acb_flags &=
					~ACB_F_MESSAGE_WQBUFFER_CLEARED;
				arcmsr_post_Qbuffer(acb);
			}
			return count;
		} else {
			return 0;	/*need retry*/
		}
	}
}

static ssize_t
arcmsr_sysfs_iop_message_clear(struct kobject *kobj, char *buf, loff_t off,
    size_t count)
{
	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	struct MessageUnit __iomem *reg = acb->pmu;
	uint8_t *pQbuffer;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
		acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
		writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK
				, &reg->inbound_doorbell);
	}
	acb->acb_flags |=
		(ACB_F_MESSAGE_WQBUFFER_CLEARED
		| ACB_F_MESSAGE_RQBUFFER_CLEARED
		| ACB_F_MESSAGE_WQBUFFER_READED);
	acb->rqbuf_firstindex = 0;
	acb->rqbuf_lastindex = 0;
	acb->wqbuf_firstindex = 0;
	acb->wqbuf_lastindex = 0;
	pQbuffer = acb->rqbuffer;
	memset(pQbuffer, 0, sizeof (struct QBUFFER));
	pQbuffer = acb->wqbuffer;
	memset(pQbuffer, 0, sizeof (struct QBUFFER));
	return 1;
}

static struct bin_attribute arcmsr_sysfs_message_read_attr = {
	.attr = {
		.name = "mu_read",
		.mode = S_IRUSR ,
		.owner = THIS_MODULE,
	},
	.size = 1032,
	.read = arcmsr_sysfs_iop_message_read,
};

static struct bin_attribute arcmsr_sysfs_message_write_attr = {
	.attr = {
		.name = "mu_write",
		.mode = S_IWUSR,
		.owner = THIS_MODULE,
	},
	.size = 1032,
	.write = arcmsr_sysfs_iop_message_write,
};

static struct bin_attribute arcmsr_sysfs_message_clear_attr = {
	.attr = {
		.name = "mu_clear",
		.mode = S_IWUSR,
		.owner = THIS_MODULE,
	},
	.size = 1,
	.write = arcmsr_sysfs_iop_message_clear,
};

int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb)
{
	struct Scsi_Host *host = acb->host;
	int error;

	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_read_attr);
	if (error) {
		printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n");
		goto error_bin_file_message_read;
	}
	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_write_attr);
	if (error) {
		printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n");
		goto error_bin_file_message_write;
	}
	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_clear_attr);
	if (error) {
		printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n");
		goto error_bin_file_message_clear;
	}
	return 0;
error_bin_file_message_clear:
	sysfs_remove_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_write_attr);
error_bin_file_message_write:
	sysfs_remove_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_read_attr);
error_bin_file_message_read:
	return error;
}

void
arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) {
	struct Scsi_Host *host = acb->host;

	sysfs_remove_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_clear_attr);
	sysfs_remove_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_write_attr);
	sysfs_remove_bin_file(&host->shost_classdev.kobj,
				&arcmsr_sysfs_message_read_attr);
}


static ssize_t
arcmsr_attr_host_driver_version(struct class_device *cdev, char *buf) {
	return snprintf(buf, PAGE_SIZE,
			"%s\n",
			ARCMSR_DRIVER_VERSION);
}

static ssize_t
arcmsr_attr_host_driver_posted_cmd(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			atomic_read(&acb->ccboutstandingcount));
}

static ssize_t
arcmsr_attr_host_driver_reset(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->num_resets);
}

static ssize_t
arcmsr_attr_host_driver_abort(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->num_aborts);
}

static ssize_t
arcmsr_attr_host_fw_model(struct class_device *cdev, char *buf) {
    struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
	return snprintf(buf, PAGE_SIZE,
			"%s\n",
			acb->firm_model);
}

static ssize_t
arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

	return snprintf(buf, PAGE_SIZE,
			"%s\n",
			acb->firm_version);
}

static ssize_t
arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->firm_request_len);
}

static ssize_t
arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->firm_numbers_queue);
}

static ssize_t
arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->firm_sdram_size);
}

static ssize_t
arcmsr_attr_host_fw_hd_channels(struct class_device *cdev, char *buf) {
	struct Scsi_Host *host = class_to_shost(cdev);
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

	return snprintf(buf, PAGE_SIZE,
			"%4d\n",
			acb->firm_hd_channels);
}

static CLASS_DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL);
static CLASS_DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL);
static CLASS_DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL);
static CLASS_DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL);
static CLASS_DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL);
static CLASS_DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL);
static CLASS_DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL);
static CLASS_DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL);
static CLASS_DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL);
static CLASS_DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL);

struct class_device_attribute *arcmsr_host_attrs[] = {
	&class_device_attr_host_driver_version,
	&class_device_attr_host_driver_posted_cmd,
	&class_device_attr_host_driver_reset,
	&class_device_attr_host_driver_abort,
	&class_device_attr_host_fw_model,
	&class_device_attr_host_fw_version,
	&class_device_attr_host_fw_request_len,
	&class_device_attr_host_fw_numbers_queue,
	&class_device_attr_host_fw_sdram_size,
	&class_device_attr_host_fw_hd_channels,
	NULL,
};
Commit	Line	Data
1c57e86d EC	1	/*
	2	*******************************************************************************
	3	** O.S : Linux
	4	** FILE NAME : arcmsr_attr.c
	5	** BY : Erich Chen
	6	** Description: attributes exported to sysfs and device host
	7	*******************************************************************************
	8	** Copyright (C) 2002 - 2005, Areca Technology Corporation All rights reserved
	9	**
	10	** Web site: www.areca.com.tw
	11	** E-mail: erich@areca.com.tw
	12	**
	13	** This program is free software; you can redistribute it and/or modify
	14	** it under the terms of the GNU General Public License version 2 as
	15	** published by the Free Software Foundation.
	16	** This program is distributed in the hope that it will be useful,
	17	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	** GNU General Public License for more details.
	20	*******************************************************************************
	21	** Redistribution and use in source and binary forms, with or without
	22	** modification, are permitted provided that the following conditions
	23	** are met:
	24	** 1. Redistributions of source code must retain the above copyright
	25	** notice, this list of conditions and the following disclaimer.
	26	** 2. Redistributions in binary form must reproduce the above copyright
	27	** notice, this list of conditions and the following disclaimer in the
	28	** documentation and/or other materials provided with the distribution.
	29	** 3. The name of the author may not be used to endorse or promote products
	30	** derived from this software without specific prior written permission.
	31	**
	32	** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	33	** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	34	** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	35	** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	36	** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING,BUT
	37	** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	38	** DATA, OR PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY
	39	** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	40	** (INCLUDING NEGLIGENCE OR OTHERWISE)ARISING IN ANY WAY OUT OF THE USE OF
	41	** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	42	*******************************************************************************
	43	** For history of changes, see Documentation/scsi/ChangeLog.arcmsr
	44	** Firmware Specification, see Documentation/scsi/arcmsr_spec.txt
	45	*******************************************************************************
	46	*/
	47	#include <linux/module.h>
	48	#include <linux/kernel.h>
	49	#include <linux/init.h>
	50	#include <linux/errno.h>
	51	#include <linux/delay.h>
1c57e86d EC	52
	53	#include <scsi/scsi_cmnd.h>
	54	#include <scsi/scsi_device.h>
	55	#include <scsi/scsi_host.h>
	56	#include <scsi/scsi_transport.h>
	57	#include "arcmsr.h"
	58
	59	struct class_device_attribute *arcmsr_host_attrs[];
	60
	61	static ssize_t
	62	arcmsr_sysfs_iop_message_read(struct kobject kobj, char buf, loff_t off,
	63	size_t count)
	64	{
	65	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
	66	struct Scsi_Host *host = class_to_shost(cdev);
	67	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	68	struct MessageUnit __iomem *reg = acb->pmu;
	69	uint8_t pQbuffer,ptmpQbuffer;
	70	int32_t allxfer_len = 0;
	71
	72	if (!capable(CAP_SYS_ADMIN))
	73	return -EACCES;
	74
	75	/* do message unit read. */
	76	ptmpQbuffer = (uint8_t *)buf;
	77	while ((acb->rqbuf_firstindex != acb->rqbuf_lastindex)
	78	&& (allxfer_len < 1031)) {
	79	pQbuffer = &acb->rqbuffer[acb->rqbuf_firstindex];
	80	memcpy(ptmpQbuffer, pQbuffer, 1);
	81	acb->rqbuf_firstindex++;
	82	acb->rqbuf_firstindex %= ARCMSR_MAX_QBUFFER;
	83	ptmpQbuffer++;
	84	allxfer_len++;
	85	}
	86	if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
	87	struct QBUFFER __iomem * prbuffer = (struct QBUFFER __iomem *)
	88	&reg->message_rbuffer;
	89	uint8_t __iomem * iop_data = (uint8_t __iomem *)prbuffer->data;
	90	int32_t iop_len;
	91
	92	acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
	93	iop_len = readl(&prbuffer->data_len);
	94	while (iop_len > 0) {
	95	acb->rqbuffer[acb->rqbuf_lastindex] = readb(iop_data);
	96	acb->rqbuf_lastindex++;
	97	acb->rqbuf_lastindex %= ARCMSR_MAX_QBUFFER;
	98	iop_data++;
	99	iop_len--;
	100	}
	101	writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK,
	102	&reg->inbound_doorbell);
	103	}
	104	return (allxfer_len);
	105	}
	106
	107	static ssize_t
	108	arcmsr_sysfs_iop_message_write(struct kobject kobj, char buf, loff_t off,
	109	size_t count)
	110	{
	111	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
	112	struct Scsi_Host *host = class_to_shost(cdev);
	113	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	114	int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex;
	115	uint8_t pQbuffer, ptmpuserbuffer;
116
117	if (!capable(CAP_SYS_ADMIN))
118	return -EACCES;
119	if (count > 1032)
120	return -EINVAL;
121	/* do message unit write. */
122	ptmpuserbuffer = (uint8_t *)buf;
123	user_len = (int32_t)count;
124	wqbuf_lastindex = acb->wqbuf_lastindex;
125	wqbuf_firstindex = acb->wqbuf_firstindex;
126	if (wqbuf_lastindex != wqbuf_firstindex) {
127	arcmsr_post_Qbuffer(acb);
128	return 0; /need retry/
129	} else {
130	my_empty_len = (wqbuf_firstindex-wqbuf_lastindex - 1)
131	&(ARCMSR_MAX_QBUFFER - 1);
132	if (my_empty_len >= user_len) {
133	while (user_len > 0) {
134	pQbuffer =
135	&acb->wqbuffer[acb->wqbuf_lastindex];
136	memcpy(pQbuffer, ptmpuserbuffer, 1);
137	acb->wqbuf_lastindex++;
138	acb->wqbuf_lastindex %= ARCMSR_MAX_QBUFFER;
139	ptmpuserbuffer++;
140	user_len--;
141	}
142	if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_CLEARED) {
143	acb->acb_flags &=
144	~ACB_F_MESSAGE_WQBUFFER_CLEARED;
145	arcmsr_post_Qbuffer(acb);
146	}
147	return count;
148	} else {
149	return 0; /need retry/
150	}
151	}
152	}
153
154	static ssize_t
155	arcmsr_sysfs_iop_message_clear(struct kobject kobj, char buf, loff_t off,
156	size_t count)
157	{
158	struct class_device *cdev = container_of(kobj,struct class_device,kobj);
159	struct Scsi_Host *host = class_to_shost(cdev);
160	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
161	struct MessageUnit __iomem *reg = acb->pmu;
162	uint8_t *pQbuffer;
163
164	if (!capable(CAP_SYS_ADMIN))
165	return -EACCES;
166
167	if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
168	acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
169	writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK
170	, &reg->inbound_doorbell);
171	}
172	acb->acb_flags \|=
173	(ACB_F_MESSAGE_WQBUFFER_CLEARED
174	\| ACB_F_MESSAGE_RQBUFFER_CLEARED
175	\| ACB_F_MESSAGE_WQBUFFER_READED);
176	acb->rqbuf_firstindex = 0;
177	acb->rqbuf_lastindex = 0;
178	acb->wqbuf_firstindex = 0;
179	acb->wqbuf_lastindex = 0;
180	pQbuffer = acb->rqbuffer;
181	memset(pQbuffer, 0, sizeof (struct QBUFFER));
182	pQbuffer = acb->wqbuffer;
183	memset(pQbuffer, 0, sizeof (struct QBUFFER));
184	return 1;
185	}
186
187	static struct bin_attribute arcmsr_sysfs_message_read_attr = {
188	.attr = {
189	.name = "mu_read",
190	.mode = S_IRUSR ,
191	.owner = THIS_MODULE,
192	},
193	.size = 1032,
194	.read = arcmsr_sysfs_iop_message_read,
195	};
196
197	static struct bin_attribute arcmsr_sysfs_message_write_attr = {
198	.attr = {
199	.name = "mu_write",
200	.mode = S_IWUSR,
201	.owner = THIS_MODULE,
202	},
203	.size = 1032,
204	.write = arcmsr_sysfs_iop_message_write,
205	};
206
207	static struct bin_attribute arcmsr_sysfs_message_clear_attr = {
208	.attr = {
209	.name = "mu_clear",
210	.mode = S_IWUSR,
211	.owner = THIS_MODULE,
212	},
213	.size = 1,
214	.write = arcmsr_sysfs_iop_message_clear,
215	};
216
217	int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb)
218	{
219	struct Scsi_Host *host = acb->host;
220	int error;
221
222	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
223	&arcmsr_sysfs_message_read_attr);
224	if (error) {
225	printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n");
226	goto error_bin_file_message_read;
227	}
228	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
229	&arcmsr_sysfs_message_write_attr);
230	if (error) {
231	printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n");
232	goto error_bin_file_message_write;
233	}
234	error = sysfs_create_bin_file(&host->shost_classdev.kobj,
235	&arcmsr_sysfs_message_clear_attr);
236	if (error) {
237	printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n");
238	goto error_bin_file_message_clear;
239	}
240	return 0;
241	error_bin_file_message_clear:
43d6b68d	242	sysfs_remove_bin_file(&host->shost_classdev.kobj,
1c57e86d	243	&arcmsr_sysfs_message_write_attr);
1c57e86d	244	error_bin_file_message_write:
43d6b68d	245	sysfs_remove_bin_file(&host->shost_classdev.kobj,
1c57e86d	246	&arcmsr_sysfs_message_read_attr);
1c57e86d EC	247	error_bin_file_message_read:
	248	return error;
	249	}
	250
	251	void
	252	arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) {
	253	struct Scsi_Host *host = acb->host;
1c57e86d	254
43d6b68d	255	sysfs_remove_bin_file(&host->shost_classdev.kobj,
1c57e86d	256	&arcmsr_sysfs_message_clear_attr);
43d6b68d	257	sysfs_remove_bin_file(&host->shost_classdev.kobj,
1c57e86d	258	&arcmsr_sysfs_message_write_attr);
43d6b68d	259	sysfs_remove_bin_file(&host->shost_classdev.kobj,
1c57e86d	260	&arcmsr_sysfs_message_read_attr);
1c57e86d EC	261	}
	262
	263
	264	static ssize_t
	265	arcmsr_attr_host_driver_version(struct class_device cdev, char buf) {
	266	return snprintf(buf, PAGE_SIZE,
d67a70ac	267	"%s\n",
1c57e86d EC	268	ARCMSR_DRIVER_VERSION);
	269	}
	270
	271	static ssize_t
	272	arcmsr_attr_host_driver_posted_cmd(struct class_device cdev, char buf) {
	273	struct Scsi_Host *host = class_to_shost(cdev);
	274	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	275	return snprintf(buf, PAGE_SIZE,
d67a70ac	276	"%4d\n",
1c57e86d EC	277	atomic_read(&acb->ccboutstandingcount));
	278	}
	279
	280	static ssize_t
	281	arcmsr_attr_host_driver_reset(struct class_device cdev, char buf) {
	282	struct Scsi_Host *host = class_to_shost(cdev);
	283	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	284	return snprintf(buf, PAGE_SIZE,
d67a70ac	285	"%4d\n",
1c57e86d EC	286	acb->num_resets);
	287	}
	288
	289	static ssize_t
	290	arcmsr_attr_host_driver_abort(struct class_device cdev, char buf) {
	291	struct Scsi_Host *host = class_to_shost(cdev);
	292	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	293	return snprintf(buf, PAGE_SIZE,
d67a70ac	294	"%4d\n",
1c57e86d EC	295	acb->num_aborts);
	296	}
	297
	298	static ssize_t
	299	arcmsr_attr_host_fw_model(struct class_device cdev, char buf) {
	300	struct Scsi_Host *host = class_to_shost(cdev);
	301	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	302	return snprintf(buf, PAGE_SIZE,
d67a70ac	303	"%s\n",
1c57e86d EC	304	acb->firm_model);
	305	}
	306
	307	static ssize_t
	308	arcmsr_attr_host_fw_version(struct class_device cdev, char buf) {
	309	struct Scsi_Host *host = class_to_shost(cdev);
	310	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	311
	312	return snprintf(buf, PAGE_SIZE,
d67a70ac	313	"%s\n",
1c57e86d EC	314	acb->firm_version);
	315	}
	316
	317	static ssize_t
	318	arcmsr_attr_host_fw_request_len(struct class_device cdev, char buf) {
	319	struct Scsi_Host *host = class_to_shost(cdev);
	320	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	321
	322	return snprintf(buf, PAGE_SIZE,
d67a70ac	323	"%4d\n",
1c57e86d EC	324	acb->firm_request_len);
	325	}
	326
	327	static ssize_t
	328	arcmsr_attr_host_fw_numbers_queue(struct class_device cdev, char buf) {
	329	struct Scsi_Host *host = class_to_shost(cdev);
	330	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	331
	332	return snprintf(buf, PAGE_SIZE,
d67a70ac	333	"%4d\n",
1c57e86d EC	334	acb->firm_numbers_queue);
	335	}
	336
	337	static ssize_t
	338	arcmsr_attr_host_fw_sdram_size(struct class_device cdev, char buf) {
	339	struct Scsi_Host *host = class_to_shost(cdev);
	340	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	341
	342	return snprintf(buf, PAGE_SIZE,
d67a70ac	343	"%4d\n",
1c57e86d EC	344	acb->firm_sdram_size);
	345	}
	346
	347	static ssize_t
	348	arcmsr_attr_host_fw_hd_channels(struct class_device cdev, char buf) {
	349	struct Scsi_Host *host = class_to_shost(cdev);
	350	struct AdapterControlBlock acb = (struct AdapterControlBlock ) host->hostdata;
	351
	352	return snprintf(buf, PAGE_SIZE,
d67a70ac	353	"%4d\n",
1c57e86d EC	354	acb->firm_hd_channels);
	355	}
	356
	357	static CLASS_DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL);
	358	static CLASS_DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL);
	359	static CLASS_DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL);
	360	static CLASS_DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL);
	361	static CLASS_DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL);
	362	static CLASS_DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL);
	363	static CLASS_DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL);
	364	static CLASS_DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL);
	365	static CLASS_DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL);
	366	static CLASS_DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL);
	367
	368	struct class_device_attribute *arcmsr_host_attrs[] = {
	369	&class_device_attr_host_driver_version,
	370	&class_device_attr_host_driver_posted_cmd,
	371	&class_device_attr_host_driver_reset,
	372	&class_device_attr_host_driver_abort,
	373	&class_device_attr_host_fw_model,
	374	&class_device_attr_host_fw_version,
	375	&class_device_attr_host_fw_request_len,
	376	&class_device_attr_host_fw_numbers_queue,
	377	&class_device_attr_host_fw_sdram_size,
	378	&class_device_attr_host_fw_hd_channels,
	379	NULL,
	380	};