[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / scsi / device_handler / scsi_dh.c

/*
 * SCSI device handler infrastruture.
 *
 * 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 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.
 *
 * 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.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Copyright IBM Corporation, 2007
 *      Authors:
 *               Chandra Seetharaman <sekharan@us.ibm.com>
 *               Mike Anderson <andmike@linux.vnet.ibm.com>
 */

#include <linux/slab.h>
#include <scsi/scsi_dh.h>
#include "../scsi_priv.h"

static DEFINE_SPINLOCK(list_lock);
static LIST_HEAD(scsi_dh_list);
static int scsi_dh_list_idx = 1;

static struct scsi_device_handler *get_device_handler(const char *name)
{
	struct scsi_device_handler *tmp, *found = NULL;

	spin_lock(&list_lock);
	list_for_each_entry(tmp, &scsi_dh_list, list) {
		if (!strncmp(tmp->name, name, strlen(tmp->name))) {
			found = tmp;
			break;
		}
	}
	spin_unlock(&list_lock);
	return found;
}

static struct scsi_device_handler *get_device_handler_by_idx(int idx)
{
	struct scsi_device_handler *tmp, *found = NULL;

	spin_lock(&list_lock);
	list_for_each_entry(tmp, &scsi_dh_list, list) {
		if (tmp->idx == idx) {
			found = tmp;
			break;
		}
	}
	spin_unlock(&list_lock);
	return found;
}

/*
 * device_handler_match - Attach a device handler to a device
 * @scsi_dh - The device handler to match against or NULL
 * @sdev - SCSI device to be tested against @scsi_dh
 *
 * Tests @sdev against the device handler @scsi_dh or against
 * all registered device_handler if @scsi_dh == NULL.
 * Returns the found device handler or NULL if not found.
 */
static struct scsi_device_handler *
device_handler_match(struct scsi_device_handler *scsi_dh,
		     struct scsi_device *sdev)
{
	struct scsi_device_handler *found_dh = NULL;
	int idx;

	idx = scsi_get_device_flags_keyed(sdev, sdev->vendor, sdev->model,
					  SCSI_DEVINFO_DH);
	found_dh = get_device_handler_by_idx(idx);

	if (scsi_dh && found_dh != scsi_dh)
		found_dh = NULL;

	return found_dh;
}

/*
 * scsi_dh_handler_attach - Attach a device handler to a device
 * @sdev - SCSI device the device handler should attach to
 * @scsi_dh - The device handler to attach
 */
static int scsi_dh_handler_attach(struct scsi_device *sdev,
				  struct scsi_device_handler *scsi_dh)
{
	int err = 0;

	if (sdev->scsi_dh_data) {
		if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
			err = -EBUSY;
		else
			kref_get(&sdev->scsi_dh_data->kref);
	} else if (scsi_dh->attach) {
		err = scsi_dh->attach(sdev);
		if (!err) {
			kref_init(&sdev->scsi_dh_data->kref);
			sdev->scsi_dh_data->sdev = sdev;
		}
	}
	return err;
}

static void __detach_handler (struct kref *kref)
{
	struct scsi_dh_data *scsi_dh_data = container_of(kref, struct scsi_dh_data, kref);
	scsi_dh_data->scsi_dh->detach(scsi_dh_data->sdev);
}

/*
 * scsi_dh_handler_detach - Detach a device handler from a device
 * @sdev - SCSI device the device handler should be detached from
 * @scsi_dh - Device handler to be detached
 *
 * Detach from a device handler. If a device handler is specified,
 * only detach if the currently attached handler matches @scsi_dh.
 */
static void scsi_dh_handler_detach(struct scsi_device *sdev,
				   struct scsi_device_handler *scsi_dh)
{
	if (!sdev->scsi_dh_data)
		return;

	if (scsi_dh && scsi_dh != sdev->scsi_dh_data->scsi_dh)
		return;

	if (!scsi_dh)
		scsi_dh = sdev->scsi_dh_data->scsi_dh;

	if (scsi_dh && scsi_dh->detach)
		kref_put(&sdev->scsi_dh_data->kref, __detach_handler);
}

/*
 * Functions for sysfs attribute 'dh_state'
 */
static ssize_t
store_dh_state(struct device *dev, struct device_attribute *attr,
	       const char *buf, size_t count)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	struct scsi_device_handler *scsi_dh;
	int err = -EINVAL;

	if (!sdev->scsi_dh_data) {
		/*
		 * Attach to a device handler
		 */
		if (!(scsi_dh = get_device_handler(buf)))
			return err;
		err = scsi_dh_handler_attach(sdev, scsi_dh);
	} else {
		scsi_dh = sdev->scsi_dh_data->scsi_dh;
		if (!strncmp(buf, "detach", 6)) {
			/*
			 * Detach from a device handler
			 */
			scsi_dh_handler_detach(sdev, scsi_dh);
			err = 0;
		} else if (!strncmp(buf, "activate", 8)) {
			/*
			 * Activate a device handler
			 */
			if (scsi_dh->activate)
				err = scsi_dh->activate(sdev, NULL, NULL);
			else
				err = 0;
		}
	}

	return err<0?err:count;
}

static ssize_t
show_dh_state(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);

	if (!sdev->scsi_dh_data)
		return snprintf(buf, 20, "detached\n");

	return snprintf(buf, 20, "%s\n", sdev->scsi_dh_data->scsi_dh->name);
}

static struct device_attribute scsi_dh_state_attr =
	__ATTR(dh_state, S_IRUGO | S_IWUSR, show_dh_state,
	       store_dh_state);

/*
 * scsi_dh_sysfs_attr_add - Callback for scsi_init_dh
 */
static int scsi_dh_sysfs_attr_add(struct device *dev, void *data)
{
	struct scsi_device *sdev;
	int err;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	err = device_create_file(&sdev->sdev_gendev,
				 &scsi_dh_state_attr);

	return 0;
}

/*
 * scsi_dh_sysfs_attr_remove - Callback for scsi_exit_dh
 */
static int scsi_dh_sysfs_attr_remove(struct device *dev, void *data)
{
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	device_remove_file(&sdev->sdev_gendev,
			   &scsi_dh_state_attr);

	return 0;
}

/*
 * scsi_dh_notifier - notifier chain callback
 */
static int scsi_dh_notifier(struct notifier_block *nb,
			    unsigned long action, void *data)
{
	struct device *dev = data;
	struct scsi_device *sdev;
	int err = 0;
	struct scsi_device_handler *devinfo = NULL;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	if (action == BUS_NOTIFY_ADD_DEVICE) {
		err = device_create_file(dev, &scsi_dh_state_attr);
		/* don't care about err */
		devinfo = device_handler_match(NULL, sdev);
		if (devinfo)
			err = scsi_dh_handler_attach(sdev, devinfo);
	} else if (action == BUS_NOTIFY_DEL_DEVICE) {
		device_remove_file(dev, &scsi_dh_state_attr);
		scsi_dh_handler_detach(sdev, NULL);
	}
	return err;
}

/*
 * scsi_dh_notifier_add - Callback for scsi_register_device_handler
 */
static int scsi_dh_notifier_add(struct device *dev, void *data)
{
	struct scsi_device_handler *scsi_dh = data;
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	if (!get_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	if (device_handler_match(scsi_dh, sdev))
		scsi_dh_handler_attach(sdev, scsi_dh);

	put_device(dev);

	return 0;
}

/*
 * scsi_dh_notifier_remove - Callback for scsi_unregister_device_handler
 */
static int scsi_dh_notifier_remove(struct device *dev, void *data)
{
	struct scsi_device_handler *scsi_dh = data;
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	if (!get_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	scsi_dh_handler_detach(sdev, scsi_dh);

	put_device(dev);

	return 0;
}

/*
 * scsi_register_device_handler - register a device handler personality
 *      module.
 * @scsi_dh - device handler to be registered.
 *
 * Returns 0 on success, -EBUSY if handler already registered.
 */
int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
{
	int i;

	if (get_device_handler(scsi_dh->name))
		return -EBUSY;

	spin_lock(&list_lock);
	scsi_dh->idx = scsi_dh_list_idx++;
	list_add(&scsi_dh->list, &scsi_dh_list);
	spin_unlock(&list_lock);

	for (i = 0; scsi_dh->devlist[i].vendor; i++) {
		scsi_dev_info_list_add_keyed(0,
					scsi_dh->devlist[i].vendor,
					scsi_dh->devlist[i].model,
					NULL,
					scsi_dh->idx,
					SCSI_DEVINFO_DH);
	}

	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh, scsi_dh_notifier_add);
	printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);

	return SCSI_DH_OK;
}
EXPORT_SYMBOL_GPL(scsi_register_device_handler);

/*
 * scsi_unregister_device_handler - register a device handler personality
 *      module.
 * @scsi_dh - device handler to be unregistered.
 *
 * Returns 0 on success, -ENODEV if handler not registered.
 */
int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
{
	int i;

	if (!get_device_handler(scsi_dh->name))
		return -ENODEV;

	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh,
			 scsi_dh_notifier_remove);

	for (i = 0; scsi_dh->devlist[i].vendor; i++) {
		scsi_dev_info_list_del_keyed(scsi_dh->devlist[i].vendor,
					     scsi_dh->devlist[i].model,
					     SCSI_DEVINFO_DH);
	}

	spin_lock(&list_lock);
	list_del(&scsi_dh->list);
	spin_unlock(&list_lock);
	printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);

	return SCSI_DH_OK;
}
EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);

/*
 * scsi_dh_activate - activate the path associated with the scsi_device
 *      corresponding to the given request queue.
 *     Returns immediately without waiting for activation to be completed.
 * @q    - Request queue that is associated with the scsi_device to be
 *         activated.
 * @fn   - Function to be called upon completion of the activation.
 *         Function fn is called with data (below) and the error code.
 *         Function fn may be called from the same calling context. So,
 *         do not hold the lock in the caller which may be needed in fn.
 * @data - data passed to the function fn upon completion.
 *
 */
int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
{
	int err = 0;
	unsigned long flags;
	struct scsi_device *sdev;
	struct scsi_device_handler *scsi_dh = NULL;

	spin_lock_irqsave(q->queue_lock, flags);
	sdev = q->queuedata;
	if (sdev && sdev->scsi_dh_data)
		scsi_dh = sdev->scsi_dh_data->scsi_dh;
	if (!scsi_dh || !get_device(&sdev->sdev_gendev) ||
	    sdev->sdev_state == SDEV_CANCEL ||
	    sdev->sdev_state == SDEV_DEL)
		err = SCSI_DH_NOSYS;
	if (sdev->sdev_state == SDEV_OFFLINE)
		err = SCSI_DH_DEV_OFFLINED;
	spin_unlock_irqrestore(q->queue_lock, flags);

	if (err) {
		if (fn)
			fn(data, err);
		return err;
	}

	if (scsi_dh->activate)
		err = scsi_dh->activate(sdev, fn, data);
	put_device(&sdev->sdev_gendev);
	return err;
}
EXPORT_SYMBOL_GPL(scsi_dh_activate);

/*
 * scsi_dh_set_params - set the parameters for the device as per the
 *      string specified in params.
 * @q - Request queue that is associated with the scsi_device for
 *      which the parameters to be set.
 * @params - parameters in the following format
 *      "no_of_params\0param1\0param2\0param3\0...\0"
 *      for example, string for 2 parameters with value 10 and 21
 *      is specified as "2\010\021\0".
 */
int scsi_dh_set_params(struct request_queue *q, const char *params)
{
	int err = -SCSI_DH_NOSYS;
	unsigned long flags;
	struct scsi_device *sdev;
	struct scsi_device_handler *scsi_dh = NULL;

	spin_lock_irqsave(q->queue_lock, flags);
	sdev = q->queuedata;
	if (sdev && sdev->scsi_dh_data)
		scsi_dh = sdev->scsi_dh_data->scsi_dh;
	if (scsi_dh && scsi_dh->set_params && get_device(&sdev->sdev_gendev))
		err = 0;
	spin_unlock_irqrestore(q->queue_lock, flags);

	if (err)
		return err;
	err = scsi_dh->set_params(sdev, params);
	put_device(&sdev->sdev_gendev);
	return err;
}
EXPORT_SYMBOL_GPL(scsi_dh_set_params);

/*
 * scsi_dh_handler_exist - Return TRUE(1) if a device handler exists for
 *	the given name. FALSE(0) otherwise.
 * @name - name of the device handler.
 */
int scsi_dh_handler_exist(const char *name)
{
	return (get_device_handler(name) != NULL);
}
EXPORT_SYMBOL_GPL(scsi_dh_handler_exist);

/*
 * scsi_dh_handler_attach - Attach device handler
 * @sdev - sdev the handler should be attached to
 * @name - name of the handler to attach
 */
int scsi_dh_attach(struct request_queue *q, const char *name)
{
	unsigned long flags;
	struct scsi_device *sdev;
	struct scsi_device_handler *scsi_dh;
	int err = 0;

	scsi_dh = get_device_handler(name);
	if (!scsi_dh)
		return -EINVAL;

	spin_lock_irqsave(q->queue_lock, flags);
	sdev = q->queuedata;
	if (!sdev || !get_device(&sdev->sdev_gendev))
		err = -ENODEV;
	spin_unlock_irqrestore(q->queue_lock, flags);

	if (!err) {
		err = scsi_dh_handler_attach(sdev, scsi_dh);
		put_device(&sdev->sdev_gendev);
	}
	return err;
}
EXPORT_SYMBOL_GPL(scsi_dh_attach);

/*
 * scsi_dh_handler_detach - Detach device handler
 * @sdev - sdev the handler should be detached from
 *
 * This function will detach the device handler only
 * if the sdev is not part of the internal list, ie
 * if it has been attached manually.
 */
void scsi_dh_detach(struct request_queue *q)
{
	unsigned long flags;
	struct scsi_device *sdev;
	struct scsi_device_handler *scsi_dh = NULL;

	spin_lock_irqsave(q->queue_lock, flags);
	sdev = q->queuedata;
	if (!sdev || !get_device(&sdev->sdev_gendev))
		sdev = NULL;
	spin_unlock_irqrestore(q->queue_lock, flags);

	if (!sdev)
		return;

	if (sdev->scsi_dh_data) {
		scsi_dh = sdev->scsi_dh_data->scsi_dh;
		scsi_dh_handler_detach(sdev, scsi_dh);
	}
	put_device(&sdev->sdev_gendev);
}
EXPORT_SYMBOL_GPL(scsi_dh_detach);

static struct notifier_block scsi_dh_nb = {
	.notifier_call = scsi_dh_notifier
};

static int __init scsi_dh_init(void)
{
	int r;

	r = scsi_dev_info_add_list(SCSI_DEVINFO_DH, "SCSI Device Handler");
	if (r)
		return r;

	r = bus_register_notifier(&scsi_bus_type, &scsi_dh_nb);

	if (!r)
		bus_for_each_dev(&scsi_bus_type, NULL, NULL,
				 scsi_dh_sysfs_attr_add);

	return r;
}

static void __exit scsi_dh_exit(void)
{
	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
			 scsi_dh_sysfs_attr_remove);
	bus_unregister_notifier(&scsi_bus_type, &scsi_dh_nb);
	scsi_dev_info_remove_list(SCSI_DEVINFO_DH);
}

module_init(scsi_dh_init);
module_exit(scsi_dh_exit);

MODULE_DESCRIPTION("SCSI device handler");
MODULE_AUTHOR("Chandra Seetharaman <sekharan@us.ibm.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
a6a8d9f8 CS	1	/*
	2	* SCSI device handler infrastruture.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License as published by the
	6	* Free Software Foundation; either version 2 of the License, or (at your
	7	* option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful, but
	10	* WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; if not, write to the Free Software Foundation, Inc.,
	16	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*
	18	* Copyright IBM Corporation, 2007
	19	* Authors:
	20	* Chandra Seetharaman <sekharan@us.ibm.com>
	21	* Mike Anderson <andmike@linux.vnet.ibm.com>
	22	*/
	23
5a0e3ad6	24	#include <linux/slab.h>
a6a8d9f8 CS	25	#include <scsi/scsi_dh.h>
	26	#include "../scsi_priv.h"
	27
	28	static DEFINE_SPINLOCK(list_lock);
	29	static LIST_HEAD(scsi_dh_list);
940d7faa	30	static int scsi_dh_list_idx = 1;
a6a8d9f8 CS	31
	32	static struct scsi_device_handler get_device_handler(const char name)
	33	{
	34	struct scsi_device_handler tmp, found = NULL;
	35
	36	spin_lock(&list_lock);
	37	list_for_each_entry(tmp, &scsi_dh_list, list) {
765cbc6d	38	if (!strncmp(tmp->name, name, strlen(tmp->name))) {
a6a8d9f8 CS	39	found = tmp;
	40	break;
	41	}
	42	}
	43	spin_unlock(&list_lock);
	44	return found;
	45	}
	46
940d7faa	47	static struct scsi_device_handler *get_device_handler_by_idx(int idx)
a6a8d9f8	48	{
940d7faa	49	struct scsi_device_handler tmp, found = NULL;
7c32c7a2 HR	50
7c32c7a2 HR	51	spin_lock(&list_lock);
940d7faa PJ	52	list_for_each_entry(tmp, &scsi_dh_list, list) {
	53	if (tmp->idx == idx) {
	54	found = tmp;
7c32c7a2	55	break;
765cbc6d HR	56	}
765cbc6d HR	57	}
7c32c7a2	58	spin_unlock(&list_lock);
7c32c7a2 HR	59	return found;
	60	}
	61
	62	/*
	63	* device_handler_match - Attach a device handler to a device
	64	* @scsi_dh - The device handler to match against or NULL
	65	* @sdev - SCSI device to be tested against @scsi_dh
	66	*
	67	* Tests @sdev against the device handler @scsi_dh or against
	68	* all registered device_handler if @scsi_dh == NULL.
	69	* Returns the found device handler or NULL if not found.
	70	*/
	71	static struct scsi_device_handler *
	72	device_handler_match(struct scsi_device_handler *scsi_dh,
	73	struct scsi_device *sdev)
	74	{
	75	struct scsi_device_handler *found_dh = NULL;
940d7faa	76	int idx;
7c32c7a2	77
940d7faa PJ	78	idx = scsi_get_device_flags_keyed(sdev, sdev->vendor, sdev->model,
	79	SCSI_DEVINFO_DH);
	80	found_dh = get_device_handler_by_idx(idx);
7c32c7a2	81
940d7faa PJ	82	if (scsi_dh && found_dh != scsi_dh)
940d7faa PJ	83	found_dh = NULL;
7c32c7a2 HR	84
7c32c7a2 HR	85	return found_dh;
a6a8d9f8 CS	86	}
	87
	88	/*
765cbc6d HR	89	* scsi_dh_handler_attach - Attach a device handler to a device
	90	* @sdev - SCSI device the device handler should attach to
	91	* @scsi_dh - The device handler to attach
	92	*/
	93	static int scsi_dh_handler_attach(struct scsi_device *sdev,
	94	struct scsi_device_handler *scsi_dh)
	95	{
	96	int err = 0;
	97
	98	if (sdev->scsi_dh_data) {
	99	if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
	100	err = -EBUSY;
6c10db72 CS	101	else
	102	kref_get(&sdev->scsi_dh_data->kref);
	103	} else if (scsi_dh->attach) {
765cbc6d	104	err = scsi_dh->attach(sdev);
6c10db72 CS	105	if (!err) {
	106	kref_init(&sdev->scsi_dh_data->kref);
	107	sdev->scsi_dh_data->sdev = sdev;
	108	}
	109	}
765cbc6d HR	110	return err;
	111	}
	112
6c10db72 CS	113	static void __detach_handler (struct kref *kref)
	114	{
	115	struct scsi_dh_data *scsi_dh_data = container_of(kref, struct scsi_dh_data, kref);
	116	scsi_dh_data->scsi_dh->detach(scsi_dh_data->sdev);
	117	}
	118
765cbc6d HR	119	/*
	120	* scsi_dh_handler_detach - Detach a device handler from a device
	121	* @sdev - SCSI device the device handler should be detached from
	122	* @scsi_dh - Device handler to be detached
a6a8d9f8	123	*
765cbc6d	124	* Detach from a device handler. If a device handler is specified,
4c05ae52	125	* only detach if the currently attached handler matches @scsi_dh.
a6a8d9f8	126	*/
765cbc6d HR	127	static void scsi_dh_handler_detach(struct scsi_device *sdev,
765cbc6d HR	128	struct scsi_device_handler *scsi_dh)
a6a8d9f8	129	{
765cbc6d HR	130	if (!sdev->scsi_dh_data)
765cbc6d HR	131	return;
a6a8d9f8	132
765cbc6d HR	133	if (scsi_dh && scsi_dh != sdev->scsi_dh_data->scsi_dh)
765cbc6d HR	134	return;
a6a8d9f8	135
765cbc6d HR	136	if (!scsi_dh)
	137	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	138
	139	if (scsi_dh && scsi_dh->detach)
6c10db72	140	kref_put(&sdev->scsi_dh_data->kref, __detach_handler);
765cbc6d HR	141	}
765cbc6d HR	142
4c05ae52 HR	143	/*
	144	* Functions for sysfs attribute 'dh_state'
	145	*/
	146	static ssize_t
	147	store_dh_state(struct device dev, struct device_attribute attr,
	148	const char *buf, size_t count)
	149	{
	150	struct scsi_device *sdev = to_scsi_device(dev);
	151	struct scsi_device_handler *scsi_dh;
	152	int err = -EINVAL;
	153
	154	if (!sdev->scsi_dh_data) {
	155	/*
	156	* Attach to a device handler
	157	*/
	158	if (!(scsi_dh = get_device_handler(buf)))
	159	return err;
	160	err = scsi_dh_handler_attach(sdev, scsi_dh);
	161	} else {
	162	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	163	if (!strncmp(buf, "detach", 6)) {
	164	/*
	165	* Detach from a device handler
	166	*/
	167	scsi_dh_handler_detach(sdev, scsi_dh);
	168	err = 0;
	169	} else if (!strncmp(buf, "activate", 8)) {
	170	/*
	171	* Activate a device handler
	172	*/
	173	if (scsi_dh->activate)
3ae31f6a	174	err = scsi_dh->activate(sdev, NULL, NULL);
4c05ae52 HR	175	else
	176	err = 0;
	177	}
	178	}
	179
	180	return err<0?err:count;
	181	}
	182
	183	static ssize_t
	184	show_dh_state(struct device dev, struct device_attribute attr, char *buf)
	185	{
	186	struct scsi_device *sdev = to_scsi_device(dev);
	187
	188	if (!sdev->scsi_dh_data)
	189	return snprintf(buf, 20, "detached\n");
	190
	191	return snprintf(buf, 20, "%s\n", sdev->scsi_dh_data->scsi_dh->name);
	192	}
	193
	194	static struct device_attribute scsi_dh_state_attr =
	195	__ATTR(dh_state, S_IRUGO \| S_IWUSR, show_dh_state,
	196	store_dh_state);
	197
	198	/*
	199	* scsi_dh_sysfs_attr_add - Callback for scsi_init_dh
	200	*/
	201	static int scsi_dh_sysfs_attr_add(struct device dev, void data)
	202	{
	203	struct scsi_device *sdev;
	204	int err;
	205
	206	if (!scsi_is_sdev_device(dev))
	207	return 0;
	208
	209	sdev = to_scsi_device(dev);
	210
	211	err = device_create_file(&sdev->sdev_gendev,
	212	&scsi_dh_state_attr);
	213
	214	return 0;
	215	}
	216
	217	/*
	218	* scsi_dh_sysfs_attr_remove - Callback for scsi_exit_dh
	219	*/
	220	static int scsi_dh_sysfs_attr_remove(struct device dev, void data)
	221	{
	222	struct scsi_device *sdev;
	223
	224	if (!scsi_is_sdev_device(dev))
	225	return 0;
	226
	227	sdev = to_scsi_device(dev);
	228
	229	device_remove_file(&sdev->sdev_gendev,
	230	&scsi_dh_state_attr);
	231
	232	return 0;
	233	}
	234
765cbc6d HR	235	/*
	236	* scsi_dh_notifier - notifier chain callback
	237	*/
	238	static int scsi_dh_notifier(struct notifier_block *nb,
	239	unsigned long action, void *data)
	240	{
	241	struct device *dev = data;
	242	struct scsi_device *sdev;
	243	int err = 0;
7c32c7a2	244	struct scsi_device_handler *devinfo = NULL;
765cbc6d HR	245
	246	if (!scsi_is_sdev_device(dev))
	247	return 0;
	248
	249	sdev = to_scsi_device(dev);
a6a8d9f8	250
765cbc6d	251	if (action == BUS_NOTIFY_ADD_DEVICE) {
5917290c CS	252	err = device_create_file(dev, &scsi_dh_state_attr);
5917290c CS	253	/* don't care about err */
7c32c7a2	254	devinfo = device_handler_match(NULL, sdev);
5917290c CS	255	if (devinfo)
5917290c CS	256	err = scsi_dh_handler_attach(sdev, devinfo);
765cbc6d	257	} else if (action == BUS_NOTIFY_DEL_DEVICE) {
4c05ae52	258	device_remove_file(dev, &scsi_dh_state_attr);
765cbc6d HR	259	scsi_dh_handler_detach(sdev, NULL);
765cbc6d HR	260	}
765cbc6d	261	return err;
a6a8d9f8	262	}
a6a8d9f8	263
765cbc6d HR	264	/*
	265	* scsi_dh_notifier_add - Callback for scsi_register_device_handler
	266	*/
	267	static int scsi_dh_notifier_add(struct device dev, void data)
	268	{
	269	struct scsi_device_handler *scsi_dh = data;
	270	struct scsi_device *sdev;
	271
	272	if (!scsi_is_sdev_device(dev))
	273	return 0;
	274
	275	if (!get_device(dev))
	276	return 0;
	277
	278	sdev = to_scsi_device(dev);
	279
	280	if (device_handler_match(scsi_dh, sdev))
	281	scsi_dh_handler_attach(sdev, scsi_dh);
	282
	283	put_device(dev);
	284
	285	return 0;
	286	}
	287
	288	/*
	289	* scsi_dh_notifier_remove - Callback for scsi_unregister_device_handler
	290	*/
a6a8d9f8 CS	291	static int scsi_dh_notifier_remove(struct device dev, void data)
	292	{
	293	struct scsi_device_handler *scsi_dh = data;
765cbc6d HR	294	struct scsi_device *sdev;
	295
	296	if (!scsi_is_sdev_device(dev))
	297	return 0;
	298
	299	if (!get_device(dev))
	300	return 0;
	301
	302	sdev = to_scsi_device(dev);
	303
	304	scsi_dh_handler_detach(sdev, scsi_dh);
	305
	306	put_device(dev);
a6a8d9f8	307
a6a8d9f8 CS	308	return 0;
	309	}
	310
765cbc6d HR	311	/*
	312	* scsi_register_device_handler - register a device handler personality
	313	* module.
	314	* @scsi_dh - device handler to be registered.
	315	*
	316	* Returns 0 on success, -EBUSY if handler already registered.
	317	*/
	318	int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
	319	{
940d7faa PJ	320	int i;
940d7faa PJ	321
765cbc6d HR	322	if (get_device_handler(scsi_dh->name))
	323	return -EBUSY;
	324
	325	spin_lock(&list_lock);
940d7faa	326	scsi_dh->idx = scsi_dh_list_idx++;
765cbc6d HR	327	list_add(&scsi_dh->list, &scsi_dh_list);
765cbc6d HR	328	spin_unlock(&list_lock);
940d7faa PJ	329
	330	for (i = 0; scsi_dh->devlist[i].vendor; i++) {
	331	scsi_dev_info_list_add_keyed(0,
	332	scsi_dh->devlist[i].vendor,
	333	scsi_dh->devlist[i].model,
	334	NULL,
	335	scsi_dh->idx,
	336	SCSI_DEVINFO_DH);
	337	}
	338
765cbc6d HR	339	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh, scsi_dh_notifier_add);
	340	printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
	341
	342	return SCSI_DH_OK;
	343	}
	344	EXPORT_SYMBOL_GPL(scsi_register_device_handler);
	345
a6a8d9f8 CS	346	/*
	347	* scsi_unregister_device_handler - register a device handler personality
	348	* module.
	349	* @scsi_dh - device handler to be unregistered.
	350	*
	351	* Returns 0 on success, -ENODEV if handler not registered.
	352	*/
	353	int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
	354	{
940d7faa	355	int i;
7c32c7a2	356
765cbc6d HR	357	if (!get_device_handler(scsi_dh->name))
765cbc6d HR	358	return -ENODEV;
a6a8d9f8 CS	359
a6a8d9f8 CS	360	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh,
765cbc6d HR	361	scsi_dh_notifier_remove);
765cbc6d HR	362
940d7faa PJ	363	for (i = 0; scsi_dh->devlist[i].vendor; i++) {
	364	scsi_dev_info_list_del_keyed(scsi_dh->devlist[i].vendor,
	365	scsi_dh->devlist[i].model,
	366	SCSI_DEVINFO_DH);
	367	}
	368
a6a8d9f8 CS	369	spin_lock(&list_lock);
	370	list_del(&scsi_dh->list);
	371	spin_unlock(&list_lock);
765cbc6d	372	printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
a6a8d9f8	373
765cbc6d	374	return SCSI_DH_OK;
a6a8d9f8 CS	375	}
	376	EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
	377
	378	/*
	379	* scsi_dh_activate - activate the path associated with the scsi_device
	380	* corresponding to the given request queue.
3ae31f6a CS	381	* Returns immediately without waiting for activation to be completed.
	382	* @q - Request queue that is associated with the scsi_device to be
	383	* activated.
	384	* @fn - Function to be called upon completion of the activation.
	385	* Function fn is called with data (below) and the error code.
	386	* Function fn may be called from the same calling context. So,
	387	* do not hold the lock in the caller which may be needed in fn.
	388	* @data - data passed to the function fn upon completion.
	389	*
a6a8d9f8	390	*/
3ae31f6a	391	int scsi_dh_activate(struct request_queue q, activate_complete fn, void data)
a6a8d9f8 CS	392	{
	393	int err = 0;
	394	unsigned long flags;
	395	struct scsi_device *sdev;
	396	struct scsi_device_handler *scsi_dh = NULL;
	397
	398	spin_lock_irqsave(q->queue_lock, flags);
	399	sdev = q->queuedata;
	400	if (sdev && sdev->scsi_dh_data)
	401	scsi_dh = sdev->scsi_dh_data->scsi_dh;
db422318 MH	402	if (!scsi_dh \|\| !get_device(&sdev->sdev_gendev) \|\|
	403	sdev->sdev_state == SDEV_CANCEL \|\|
	404	sdev->sdev_state == SDEV_DEL)
a6a8d9f8	405	err = SCSI_DH_NOSYS;
db422318 MH	406	if (sdev->sdev_state == SDEV_OFFLINE)
db422318 MH	407	err = SCSI_DH_DEV_OFFLINED;
a6a8d9f8 CS	408	spin_unlock_irqrestore(q->queue_lock, flags);
a6a8d9f8 CS	409
db422318 MH	410	if (err) {
	411	if (fn)
	412	fn(data, err);
a6a8d9f8	413	return err;
db422318	414	}
a6a8d9f8 CS	415
a6a8d9f8 CS	416	if (scsi_dh->activate)
3ae31f6a	417	err = scsi_dh->activate(sdev, fn, data);
a6a8d9f8 CS	418	put_device(&sdev->sdev_gendev);
	419	return err;
	420	}
	421	EXPORT_SYMBOL_GPL(scsi_dh_activate);
	422
18ee70c9 CS	423	/*
	424	* scsi_dh_set_params - set the parameters for the device as per the
	425	* string specified in params.
	426	* @q - Request queue that is associated with the scsi_device for
	427	* which the parameters to be set.
	428	* @params - parameters in the following format
	429	* "no_of_params\0param1\0param2\0param3\0...\0"
	430	* for example, string for 2 parameters with value 10 and 21
	431	* is specified as "2\010\021\0".
	432	*/
	433	int scsi_dh_set_params(struct request_queue q, const char params)
	434	{
	435	int err = -SCSI_DH_NOSYS;
	436	unsigned long flags;
	437	struct scsi_device *sdev;
	438	struct scsi_device_handler *scsi_dh = NULL;
	439
	440	spin_lock_irqsave(q->queue_lock, flags);
	441	sdev = q->queuedata;
	442	if (sdev && sdev->scsi_dh_data)
	443	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	444	if (scsi_dh && scsi_dh->set_params && get_device(&sdev->sdev_gendev))
	445	err = 0;
	446	spin_unlock_irqrestore(q->queue_lock, flags);
	447
	448	if (err)
	449	return err;
	450	err = scsi_dh->set_params(sdev, params);
	451	put_device(&sdev->sdev_gendev);
	452	return err;
	453	}
	454	EXPORT_SYMBOL_GPL(scsi_dh_set_params);
	455
a6a8d9f8 CS	456	/*
	457	* scsi_dh_handler_exist - Return TRUE(1) if a device handler exists for
	458	* the given name. FALSE(0) otherwise.
	459	* @name - name of the device handler.
	460	*/
	461	int scsi_dh_handler_exist(const char *name)
	462	{
	463	return (get_device_handler(name) != NULL);
	464	}
	465	EXPORT_SYMBOL_GPL(scsi_dh_handler_exist);
	466
ae11b1b3 HR	467	/*
	468	* scsi_dh_handler_attach - Attach device handler
	469	* @sdev - sdev the handler should be attached to
	470	* @name - name of the handler to attach
	471	*/
	472	int scsi_dh_attach(struct request_queue q, const char name)
	473	{
	474	unsigned long flags;
	475	struct scsi_device *sdev;
	476	struct scsi_device_handler *scsi_dh;
	477	int err = 0;
	478
	479	scsi_dh = get_device_handler(name);
	480	if (!scsi_dh)
	481	return -EINVAL;
	482
	483	spin_lock_irqsave(q->queue_lock, flags);
	484	sdev = q->queuedata;
	485	if (!sdev \|\| !get_device(&sdev->sdev_gendev))
	486	err = -ENODEV;
	487	spin_unlock_irqrestore(q->queue_lock, flags);
	488
	489	if (!err) {
	490	err = scsi_dh_handler_attach(sdev, scsi_dh);
ae11b1b3 HR	491	put_device(&sdev->sdev_gendev);
	492	}
	493	return err;
	494	}
	495	EXPORT_SYMBOL_GPL(scsi_dh_attach);
	496
	497	/*
	498	* scsi_dh_handler_detach - Detach device handler
	499	* @sdev - sdev the handler should be detached from
	500	*
	501	* This function will detach the device handler only
	502	* if the sdev is not part of the internal list, ie
	503	* if it has been attached manually.
	504	*/
	505	void scsi_dh_detach(struct request_queue *q)
	506	{
	507	unsigned long flags;
	508	struct scsi_device *sdev;
	509	struct scsi_device_handler *scsi_dh = NULL;
	510
	511	spin_lock_irqsave(q->queue_lock, flags);
	512	sdev = q->queuedata;
	513	if (!sdev \|\| !get_device(&sdev->sdev_gendev))
	514	sdev = NULL;
	515	spin_unlock_irqrestore(q->queue_lock, flags);
	516
	517	if (!sdev)
	518	return;
	519
	520	if (sdev->scsi_dh_data) {
ae11b1b3	521	scsi_dh = sdev->scsi_dh_data->scsi_dh;
6c10db72	522	scsi_dh_handler_detach(sdev, scsi_dh);
ae11b1b3 HR	523	}
	524	put_device(&sdev->sdev_gendev);
	525	}
	526	EXPORT_SYMBOL_GPL(scsi_dh_detach);
	527
765cbc6d HR	528	static struct notifier_block scsi_dh_nb = {
	529	.notifier_call = scsi_dh_notifier
	530	};
	531
	532	static int __init scsi_dh_init(void)
	533	{
	534	int r;
	535
940d7faa PJ	536	r = scsi_dev_info_add_list(SCSI_DEVINFO_DH, "SCSI Device Handler");
	537	if (r)
	538	return r;
	539
765cbc6d HR	540	r = bus_register_notifier(&scsi_bus_type, &scsi_dh_nb);
765cbc6d HR	541
4c05ae52 HR	542	if (!r)
	543	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
	544	scsi_dh_sysfs_attr_add);
	545
765cbc6d HR	546	return r;
	547	}
	548
	549	static void __exit scsi_dh_exit(void)
	550	{
4c05ae52 HR	551	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
4c05ae52 HR	552	scsi_dh_sysfs_attr_remove);
765cbc6d	553	bus_unregister_notifier(&scsi_bus_type, &scsi_dh_nb);
940d7faa	554	scsi_dev_info_remove_list(SCSI_DEVINFO_DH);
765cbc6d HR	555	}
	556
	557	module_init(scsi_dh_init);
	558	module_exit(scsi_dh_exit);
	559
a6a8d9f8 CS	560	MODULE_DESCRIPTION("SCSI device handler");
	561	MODULE_AUTHOR("Chandra Seetharaman <sekharan@us.ibm.com>");
	562	MODULE_LICENSE("GPL");