[deliverable/linux.git] / drivers / usb / storage / libusual.c

/*
 * libusual
 *
 * The libusual contains the table of devices common for ub and usb-storage.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb_usual.h>
#include <linux/vmalloc.h>

/*
 */
#define USU_MOD_FL_THREAD   1	/* Thread is running */
#define USU_MOD_FL_PRESENT  2	/* The module is loaded */

struct mod_status {
	unsigned long fls;
};

static struct mod_status stat[3];
static DEFINE_SPINLOCK(usu_lock);

/*
 */
#define USB_US_DEFAULT_BIAS	USB_US_TYPE_STOR
static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS);

#define BIAS_NAME_SIZE  (sizeof("usb-storage"))
static const char *bias_names[3] = { "none", "usb-storage", "ub" };

static DECLARE_MUTEX_LOCKED(usu_init_notify);
static DECLARE_COMPLETION(usu_end_notify);
static atomic_t total_threads = ATOMIC_INIT(0);

static int usu_probe_thread(void *arg);

/*
 * The table.
 */
#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
		    vendorName, productName,useProtocol, useTransport, \
		    initFunction, flags) \
{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }

#define USUAL_DEV(useProto, useTrans, useType) \
{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
  .driver_info = ((useType)<<24) }

struct usb_device_id storage_usb_ids [] = {
#	include "unusual_devs.h"
	{ } /* Terminating entry */
};

#undef USUAL_DEV
#undef UNUSUAL_DEV

MODULE_DEVICE_TABLE(usb, storage_usb_ids);
EXPORT_SYMBOL_GPL(storage_usb_ids);

/*
 * @type: the module type as an integer
 */
void usb_usual_set_present(int type)
{
	struct mod_status *st;
	unsigned long flags;

	if (type <= 0 || type >= 3)
		return;
	st = &stat[type];
	spin_lock_irqsave(&usu_lock, flags);
	st->fls |= USU_MOD_FL_PRESENT;
	spin_unlock_irqrestore(&usu_lock, flags);
}
EXPORT_SYMBOL_GPL(usb_usual_set_present);

void usb_usual_clear_present(int type)
{
	struct mod_status *st;
	unsigned long flags;

	if (type <= 0 || type >= 3)
		return;
	st = &stat[type];
	spin_lock_irqsave(&usu_lock, flags);
	st->fls &= ~USU_MOD_FL_PRESENT;
	spin_unlock_irqrestore(&usu_lock, flags);
}
EXPORT_SYMBOL_GPL(usb_usual_clear_present);

/*
 * Match the calling driver type against the table.
 * Returns: 0 if the device matches.
 */
int usb_usual_check_type(const struct usb_device_id *id, int caller_type)
{
	int id_type = USB_US_TYPE(id->driver_info);

	if (caller_type <= 0 || caller_type >= 3)
		return -EINVAL;

	/* Drivers grab fixed assignment devices */
	if (id_type == caller_type)
		return 0;
	/* Drivers grab devices biased to them */
	if (id_type == USB_US_TYPE_NONE && caller_type == atomic_read(&usu_bias))
		return 0;
	return -ENODEV;
}
EXPORT_SYMBOL_GPL(usb_usual_check_type);

/*
 */
static int usu_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	unsigned long type;
	int rc;
	unsigned long flags;

	type = USB_US_TYPE(id->driver_info);
	if (type == 0)
		type = atomic_read(&usu_bias);

	spin_lock_irqsave(&usu_lock, flags);
	if ((stat[type].fls & (USU_MOD_FL_THREAD|USU_MOD_FL_PRESENT)) != 0) {
		spin_unlock_irqrestore(&usu_lock, flags);
		return -ENXIO;
	}
	stat[type].fls |= USU_MOD_FL_THREAD;
	spin_unlock_irqrestore(&usu_lock, flags);

	rc = kernel_thread(usu_probe_thread, (void*)type, CLONE_VM);
	if (rc < 0) {
		printk(KERN_WARNING "libusual: "
		    "Unable to start the thread for %s: %d\n",
		    bias_names[type], rc);
		spin_lock_irqsave(&usu_lock, flags);
		stat[type].fls &= ~USU_MOD_FL_THREAD;
		spin_unlock_irqrestore(&usu_lock, flags);
		return rc;	/* Not being -ENXIO causes a message printed */
	}
	atomic_inc(&total_threads);

	return -ENXIO;
}

static void usu_disconnect(struct usb_interface *intf)
{
	;	/* We should not be here. */
}

static struct usb_driver usu_driver = {
	.name =		"libusual",
	.probe =	usu_probe,
	.disconnect =	usu_disconnect,
	.id_table =	storage_usb_ids,
};

/*
 * A whole new thread for a purpose of request_module seems quite stupid.
 * The request_module forks once inside again. However, if we attempt
 * to load a storage module from our own modprobe thread, that module
 * references our symbols, which cannot be resolved until our module is
 * initialized. I wish there was a way to wait for the end of initialization.
 * The module notifier reports MODULE_STATE_COMING only.
 * So, we wait until module->init ends as the next best thing.
 */
static int usu_probe_thread(void *arg)
{
	int type = (unsigned long) arg;
	struct mod_status *st = &stat[type];
	int rc;
	unsigned long flags;

	daemonize("libusual_%d", type);	/* "usb-storage" is kinda too long */

	/* A completion does not work here because it's counted. */
	down(&usu_init_notify);
	up(&usu_init_notify);

	rc = request_module(bias_names[type]);
	spin_lock_irqsave(&usu_lock, flags);
	if (rc == 0 && (st->fls & USU_MOD_FL_PRESENT) == 0) {
		/*
		 * This should not happen, but let us keep tabs on it.
		 */
		printk(KERN_NOTICE "libusual: "
		    "modprobe for %s succeeded, but module is not present\n",
		    bias_names[type]);
	}
	st->fls &= ~USU_MOD_FL_THREAD;
	spin_unlock_irqrestore(&usu_lock, flags);

	complete_and_exit(&usu_end_notify, 0);
}

/*
 */
static int __init usb_usual_init(void)
{
	int rc;

	rc = usb_register(&usu_driver);
	up(&usu_init_notify);
	return rc;
}

static void __exit usb_usual_exit(void)
{
	/*
	 * We do not check for any drivers present, because
	 * they keep us pinned with symbol references.
	 */

	usb_deregister(&usu_driver);

	while (atomic_read(&total_threads) > 0) {
		wait_for_completion(&usu_end_notify);
		atomic_dec(&total_threads);
	}
}

/*
 * Validate and accept the bias parameter.
 */
static int usu_set_bias(const char *bias_s, struct kernel_param *kp)
{
	int i;
	int len;
	int bias_n = 0;

	len = strlen(bias_s);
	if (len == 0)
		return -EDOM;
	if (bias_s[len-1] == '\n')
		--len;

	for (i = 1; i < 3; i++) {
		if (strncmp(bias_s, bias_names[i], len) == 0) {
			bias_n = i;
			break;
		}
	}
	if (bias_n == 0)
		return -EINVAL;

	atomic_set(&usu_bias, bias_n);
	return 0;
}

static int usu_get_bias(char *buffer, struct kernel_param *kp)
{
	return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)]));
}

module_init(usb_usual_init);
module_exit(usb_usual_exit);

module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO|S_IWUSR);
__MODULE_PARM_TYPE(bias, "string");
MODULE_PARM_DESC(bias, "Bias to usb-storage or ub");

MODULE_LICENSE("GPL");
Commit	Line	Data
a00828e9 PZ	1	/*
	2	* libusual
	3	*
	4	* The libusual contains the table of devices common for ub and usb-storage.
	5	*/
	6	#include <linux/kernel.h>
	7	#include <linux/module.h>
	8	#include <linux/usb.h>
	9	#include <linux/usb_usual.h>
	10	#include <linux/vmalloc.h>
	11
	12	/*
	13	*/
	14	#define USU_MOD_FL_THREAD 1 /* Thread is running */
	15	#define USU_MOD_FL_PRESENT 2 /* The module is loaded */
	16
	17	struct mod_status {
	18	unsigned long fls;
	19	};
	20
	21	static struct mod_status stat[3];
	22	static DEFINE_SPINLOCK(usu_lock);
	23
	24	/*
	25	*/
	26	#define USB_US_DEFAULT_BIAS USB_US_TYPE_STOR
5ba35bd8	27	static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS);
a00828e9 PZ	28
a00828e9 PZ	29	#define BIAS_NAME_SIZE (sizeof("usb-storage"))
a00828e9 PZ	30	static const char *bias_names[3] = { "none", "usb-storage", "ub" };
	31
	32	static DECLARE_MUTEX_LOCKED(usu_init_notify);
	33	static DECLARE_COMPLETION(usu_end_notify);
	34	static atomic_t total_threads = ATOMIC_INIT(0);
	35
	36	static int usu_probe_thread(void *arg);
a00828e9 PZ	37
	38	/*
	39	* The table.
	40	*/
	41	#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
	42	vendorName, productName,useProtocol, useTransport, \
	43	initFunction, flags) \
	44	{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
	45	.driver_info = (flags)\|(USB_US_TYPE_STOR<<24) }
	46
	47	#define USUAL_DEV(useProto, useTrans, useType) \
	48	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
	49	.driver_info = ((useType)<<24) }
	50
	51	struct usb_device_id storage_usb_ids [] = {
	52	# include "unusual_devs.h"
	53	{ } /* Terminating entry */
	54	};
	55
	56	#undef USUAL_DEV
	57	#undef UNUSUAL_DEV
	58
	59	MODULE_DEVICE_TABLE(usb, storage_usb_ids);
	60	EXPORT_SYMBOL_GPL(storage_usb_ids);
	61
	62	/*
	63	* @type: the module type as an integer
	64	*/
	65	void usb_usual_set_present(int type)
	66	{
	67	struct mod_status *st;
	68	unsigned long flags;
	69
	70	if (type <= 0 \|\| type >= 3)
	71	return;
	72	st = &stat[type];
	73	spin_lock_irqsave(&usu_lock, flags);
	74	st->fls \|= USU_MOD_FL_PRESENT;
	75	spin_unlock_irqrestore(&usu_lock, flags);
	76	}
	77	EXPORT_SYMBOL_GPL(usb_usual_set_present);
	78
	79	void usb_usual_clear_present(int type)
	80	{
	81	struct mod_status *st;
	82	unsigned long flags;
	83
	84	if (type <= 0 \|\| type >= 3)
	85	return;
	86	st = &stat[type];
	87	spin_lock_irqsave(&usu_lock, flags);
	88	st->fls &= ~USU_MOD_FL_PRESENT;
	89	spin_unlock_irqrestore(&usu_lock, flags);
	90	}
	91	EXPORT_SYMBOL_GPL(usb_usual_clear_present);
	92
	93	/*
	94	* Match the calling driver type against the table.
	95	* Returns: 0 if the device matches.
	96	*/
	97	int usb_usual_check_type(const struct usb_device_id *id, int caller_type)
	98	{
	99	int id_type = USB_US_TYPE(id->driver_info);
	100
101	if (caller_type <= 0 \|\| caller_type >= 3)
102	return -EINVAL;
103
104	/* Drivers grab fixed assignment devices */
105	if (id_type == caller_type)
106	return 0;
107	/* Drivers grab devices biased to them */
5ba35bd8	108	if (id_type == USB_US_TYPE_NONE && caller_type == atomic_read(&usu_bias))
a00828e9 PZ	109	return 0;
	110	return -ENODEV;
	111	}
	112	EXPORT_SYMBOL_GPL(usb_usual_check_type);
	113
	114	/*
	115	*/
	116	static int usu_probe(struct usb_interface *intf,
	117	const struct usb_device_id *id)
	118	{
6d453b9e	119	unsigned long type;
a00828e9 PZ	120	int rc;
	121	unsigned long flags;
	122
	123	type = USB_US_TYPE(id->driver_info);
	124	if (type == 0)
5ba35bd8	125	type = atomic_read(&usu_bias);
a00828e9 PZ	126
	127	spin_lock_irqsave(&usu_lock, flags);
	128	if ((stat[type].fls & (USU_MOD_FL_THREAD\|USU_MOD_FL_PRESENT)) != 0) {
	129	spin_unlock_irqrestore(&usu_lock, flags);
	130	return -ENXIO;
	131	}
	132	stat[type].fls \|= USU_MOD_FL_THREAD;
	133	spin_unlock_irqrestore(&usu_lock, flags);
	134
	135	rc = kernel_thread(usu_probe_thread, (void*)type, CLONE_VM);
	136	if (rc < 0) {
	137	printk(KERN_WARNING "libusual: "
	138	"Unable to start the thread for %s: %d\n",
	139	bias_names[type], rc);
	140	spin_lock_irqsave(&usu_lock, flags);
	141	stat[type].fls &= ~USU_MOD_FL_THREAD;
	142	spin_unlock_irqrestore(&usu_lock, flags);
	143	return rc; /* Not being -ENXIO causes a message printed */
	144	}
	145	atomic_inc(&total_threads);
	146
	147	return -ENXIO;
	148	}
	149
	150	static void usu_disconnect(struct usb_interface *intf)
	151	{
	152	; /* We should not be here. */
	153	}
	154
	155	static struct usb_driver usu_driver = {
a00828e9 PZ	156	.name = "libusual",
	157	.probe = usu_probe,
	158	.disconnect = usu_disconnect,
	159	.id_table = storage_usb_ids,
	160	};
	161
	162	/*
	163	* A whole new thread for a purpose of request_module seems quite stupid.
	164	* The request_module forks once inside again. However, if we attempt
	165	* to load a storage module from our own modprobe thread, that module
	166	* references our symbols, which cannot be resolved until our module is
	167	* initialized. I wish there was a way to wait for the end of initialization.
	168	* The module notifier reports MODULE_STATE_COMING only.
	169	* So, we wait until module->init ends as the next best thing.
	170	*/
	171	static int usu_probe_thread(void *arg)
	172	{
	173	int type = (unsigned long) arg;
	174	struct mod_status *st = &stat[type];
	175	int rc;
	176	unsigned long flags;
	177
	178	daemonize("libusual_%d", type); /* "usb-storage" is kinda too long */
	179
	180	/* A completion does not work here because it's counted. */
	181	down(&usu_init_notify);
	182	up(&usu_init_notify);
	183
	184	rc = request_module(bias_names[type]);
	185	spin_lock_irqsave(&usu_lock, flags);
	186	if (rc == 0 && (st->fls & USU_MOD_FL_PRESENT) == 0) {
	187	/*
	188	* This should not happen, but let us keep tabs on it.
	189	*/
	190	printk(KERN_NOTICE "libusual: "
	191	"modprobe for %s succeeded, but module is not present\n",
	192	bias_names[type]);
	193	}
	194	st->fls &= ~USU_MOD_FL_THREAD;
	195	spin_unlock_irqrestore(&usu_lock, flags);
	196
	197	complete_and_exit(&usu_end_notify, 0);
	198	}
	199
	200	/*
	201	*/
	202	static int __init usb_usual_init(void)
	203	{
	204	int rc;
	205
a00828e9 PZ	206	rc = usb_register(&usu_driver);
	207	up(&usu_init_notify);
	208	return rc;
	209	}
	210
	211	static void __exit usb_usual_exit(void)
	212	{
	213	/*
	214	* We do not check for any drivers present, because
	215	* they keep us pinned with symbol references.
	216	*/
	217
	218	usb_deregister(&usu_driver);
	219
	220	while (atomic_read(&total_threads) > 0) {
	221	wait_for_completion(&usu_end_notify);
	222	atomic_dec(&total_threads);
	223	}
	224	}
	225
	226	/*
	227	* Validate and accept the bias parameter.
a00828e9	228	*/
5ba35bd8	229	static int usu_set_bias(const char bias_s, struct kernel_param kp)
a00828e9 PZ	230	{
a00828e9 PZ	231	int i;
5ba35bd8	232	int len;
a00828e9 PZ	233	int bias_n = 0;
a00828e9 PZ	234
5ba35bd8 PZ	235	len = strlen(bias_s);
	236	if (len == 0)
	237	return -EDOM;
	238	if (bias_s[len-1] == '\n')
	239	--len;
	240
	241	for (i = 1; i < 3; i++) {
	242	if (strncmp(bias_s, bias_names[i], len) == 0) {
	243	bias_n = i;
	244	break;
a00828e9 PZ	245	}
a00828e9 PZ	246	}
5ba35bd8 PZ	247	if (bias_n == 0)
	248	return -EINVAL;
	249
	250	atomic_set(&usu_bias, bias_n);
	251	return 0;
	252	}
	253
	254	static int usu_get_bias(char buffer, struct kernel_param kp)
	255	{
	256	return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)]));
a00828e9 PZ	257	}
	258
	259	module_init(usb_usual_init);
	260	module_exit(usb_usual_exit);
	261
5ba35bd8 PZ	262	module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO\|S_IWUSR);
5ba35bd8 PZ	263	__MODULE_PARM_TYPE(bias, "string");
a00828e9 PZ	264	MODULE_PARM_DESC(bias, "Bias to usb-storage or ub");
	265
	266	MODULE_LICENSE("GPL");