[mirror_ubuntu-bionic-kernel.git] / drivers / block / paride / paride.c

/* 
        paride.c  (c) 1997-8  Grant R. Guenther <grant@torque.net>
                              Under the terms of the GNU General Public License.

	This is the base module for the family of device drivers
        that support parallel port IDE devices.  

*/

/* Changes:

	1.01	GRG 1998.05.03	Use spinlocks
	1.02	GRG 1998.05.05  init_proto, release_proto, ktti
	1.03	GRG 1998.08.15  eliminate compiler warning
	1.04    GRG 1998.11.28  added support for FRIQ 
	1.05    TMW 2000.06.06  use parport_find_number instead of
				parport_enumerate
	1.06    TMW 2001.03.26  more sane parport-or-not resource management
*/

#define PI_VERSION      "1.06"

#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/string.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/sched.h>	/* TASK_* */
#include <linux/parport.h>
#include <linux/slab.h>

#include "paride.h"

MODULE_LICENSE("GPL");

#define MAX_PROTOS	32

static struct pi_protocol *protocols[MAX_PROTOS];

static DEFINE_SPINLOCK(pi_spinlock);

void pi_write_regr(PIA * pi, int cont, int regr, int val)
{
	pi->proto->write_regr(pi, cont, regr, val);
}

EXPORT_SYMBOL(pi_write_regr);

int pi_read_regr(PIA * pi, int cont, int regr)
{
	return pi->proto->read_regr(pi, cont, regr);
}

EXPORT_SYMBOL(pi_read_regr);

void pi_write_block(PIA * pi, char *buf, int count)
{
	pi->proto->write_block(pi, buf, count);
}

EXPORT_SYMBOL(pi_write_block);

void pi_read_block(PIA * pi, char *buf, int count)
{
	pi->proto->read_block(pi, buf, count);
}

EXPORT_SYMBOL(pi_read_block);

static void pi_wake_up(void *p)
{
	PIA *pi = (PIA *) p;
	unsigned long flags;
	void (*cont) (void) = NULL;

	spin_lock_irqsave(&pi_spinlock, flags);

	if (pi->claim_cont && !parport_claim(pi->pardev)) {
		cont = pi->claim_cont;
		pi->claim_cont = NULL;
		pi->claimed = 1;
	}

	spin_unlock_irqrestore(&pi_spinlock, flags);

	wake_up(&(pi->parq));

	if (cont)
		cont();
}

int pi_schedule_claimed(PIA * pi, void (*cont) (void))
{
	unsigned long flags;

	spin_lock_irqsave(&pi_spinlock, flags);
	if (pi->pardev && parport_claim(pi->pardev)) {
		pi->claim_cont = cont;
		spin_unlock_irqrestore(&pi_spinlock, flags);
		return 0;
	}
	pi->claimed = 1;
	spin_unlock_irqrestore(&pi_spinlock, flags);
	return 1;
}
EXPORT_SYMBOL(pi_schedule_claimed);

void pi_do_claimed(PIA * pi, void (*cont) (void))
{
	if (pi_schedule_claimed(pi, cont))
		cont();
}

EXPORT_SYMBOL(pi_do_claimed);

static void pi_claim(PIA * pi)
{
	if (pi->claimed)
		return;
	pi->claimed = 1;
	if (pi->pardev)
		wait_event(pi->parq,
			   !parport_claim((struct pardevice *) pi->pardev));
}

static void pi_unclaim(PIA * pi)
{
	pi->claimed = 0;
	if (pi->pardev)
		parport_release((struct pardevice *) (pi->pardev));
}

void pi_connect(PIA * pi)
{
	pi_claim(pi);
	pi->proto->connect(pi);
}

EXPORT_SYMBOL(pi_connect);

void pi_disconnect(PIA * pi)
{
	pi->proto->disconnect(pi);
	pi_unclaim(pi);
}

EXPORT_SYMBOL(pi_disconnect);

static void pi_unregister_parport(PIA * pi)
{
	if (pi->pardev) {
		parport_unregister_device((struct pardevice *) (pi->pardev));
		pi->pardev = NULL;
	}
}

void pi_release(PIA * pi)
{
	pi_unregister_parport(pi);
	if (pi->proto->release_proto)
		pi->proto->release_proto(pi);
	module_put(pi->proto->owner);
}

EXPORT_SYMBOL(pi_release);

static int default_test_proto(PIA * pi, char *scratch, int verbose)
{
	int j, k;
	int e[2] = { 0, 0 };

	pi->proto->connect(pi);

	for (j = 0; j < 2; j++) {
		pi_write_regr(pi, 0, 6, 0xa0 + j * 0x10);
		for (k = 0; k < 256; k++) {
			pi_write_regr(pi, 0, 2, k ^ 0xaa);
			pi_write_regr(pi, 0, 3, k ^ 0x55);
			if (pi_read_regr(pi, 0, 2) != (k ^ 0xaa))
				e[j]++;
		}
	}
	pi->proto->disconnect(pi);

	if (verbose)
		printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
		       pi->device, pi->proto->name, pi->port,
		       pi->mode, e[0], e[1]);

	return (e[0] && e[1]);	/* not here if both > 0 */
}

static int pi_test_proto(PIA * pi, char *scratch, int verbose)
{
	int res;

	pi_claim(pi);
	if (pi->proto->test_proto)
		res = pi->proto->test_proto(pi, scratch, verbose);
	else
		res = default_test_proto(pi, scratch, verbose);
	pi_unclaim(pi);

	return res;
}

int paride_register(PIP * pr)
{
	int k;

	for (k = 0; k < MAX_PROTOS; k++)
		if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
			printk("paride: %s protocol already registered\n",
			       pr->name);
			return -1;
		}
	k = 0;
	while ((k < MAX_PROTOS) && (protocols[k]))
		k++;
	if (k == MAX_PROTOS) {
		printk("paride: protocol table full\n");
		return -1;
	}
	protocols[k] = pr;
	pr->index = k;
	printk("paride: %s registered as protocol %d\n", pr->name, k);
	return 0;
}

EXPORT_SYMBOL(paride_register);

void paride_unregister(PIP * pr)
{
	if (!pr)
		return;
	if (protocols[pr->index] != pr) {
		printk("paride: %s not registered\n", pr->name);
		return;
	}
	protocols[pr->index] = NULL;
}

EXPORT_SYMBOL(paride_unregister);

static int pi_register_parport(PIA *pi, int verbose, int unit)
{
	struct parport *port;
	struct pardev_cb par_cb;

	port = parport_find_base(pi->port);
	if (!port)
		return 0;
	memset(&par_cb, 0, sizeof(par_cb));
	par_cb.wakeup = pi_wake_up;
	par_cb.private = (void *)pi;
	pi->pardev = parport_register_dev_model(port, pi->device, &par_cb,
						unit);
	parport_put_port(port);
	if (!pi->pardev)
		return 0;

	init_waitqueue_head(&pi->parq);

	if (verbose)
		printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);

	pi->parname = (char *) port->name;

	return 1;
}

static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
{
	int best, range;

	if (pi->mode != -1) {
		if (pi->mode >= max)
			return 0;
		range = 3;
		if (pi->mode >= pi->proto->epp_first)
			range = 8;
		if ((range == 8) && (pi->port % 8))
			return 0;
		pi->reserved = range;
		return (!pi_test_proto(pi, scratch, verbose));
	}
	best = -1;
	for (pi->mode = 0; pi->mode < max; pi->mode++) {
		range = 3;
		if (pi->mode >= pi->proto->epp_first)
			range = 8;
		if ((range == 8) && (pi->port % 8))
			break;
		pi->reserved = range;
		if (!pi_test_proto(pi, scratch, verbose))
			best = pi->mode;
	}
	pi->mode = best;
	return (best > -1);
}

static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
{
	int max, s, e;

	s = unit;
	e = s + 1;

	if (s == -1) {
		s = 0;
		e = pi->proto->max_units;
	}

	if (!pi_register_parport(pi, verbose, s))
		return 0;

	if (pi->proto->test_port) {
		pi_claim(pi);
		max = pi->proto->test_port(pi);
		pi_unclaim(pi);
	} else
		max = pi->proto->max_mode;

	if (pi->proto->probe_unit) {
		pi_claim(pi);
		for (pi->unit = s; pi->unit < e; pi->unit++)
			if (pi->proto->probe_unit(pi)) {
				pi_unclaim(pi);
				if (pi_probe_mode(pi, max, scratch, verbose))
					return 1;
				pi_unregister_parport(pi);
				return 0;
			}
		pi_unclaim(pi);
		pi_unregister_parport(pi);
		return 0;
	}

	if (!pi_probe_mode(pi, max, scratch, verbose)) {
		pi_unregister_parport(pi);
		return 0;
	}
	return 1;

}

int pi_init(PIA * pi, int autoprobe, int port, int mode,
	int unit, int protocol, int delay, char *scratch,
	int devtype, int verbose, char *device)
{
	int p, k, s, e;
	int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };

	s = protocol;
	e = s + 1;

	if (!protocols[0])
		request_module("paride_protocol");

	if (autoprobe) {
		s = 0;
		e = MAX_PROTOS;
	} else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
		   (!protocols[s]) || (unit < 0) ||
		   (unit >= protocols[s]->max_units)) {
		printk("%s: Invalid parameters\n", device);
		return 0;
	}

	for (p = s; p < e; p++) {
		struct pi_protocol *proto = protocols[p];
		if (!proto)
			continue;
		/* still racy */
		if (!try_module_get(proto->owner))
			continue;
		pi->proto = proto;
		pi->private = 0;
		if (proto->init_proto && proto->init_proto(pi) < 0) {
			pi->proto = NULL;
			module_put(proto->owner);
			continue;
		}
		if (delay == -1)
			pi->delay = pi->proto->default_delay;
		else
			pi->delay = delay;
		pi->devtype = devtype;
		pi->device = device;

		pi->parname = NULL;
		pi->pardev = NULL;
		init_waitqueue_head(&pi->parq);
		pi->claimed = 0;
		pi->claim_cont = NULL;

		pi->mode = mode;
		if (port != -1) {
			pi->port = port;
			if (pi_probe_unit(pi, unit, scratch, verbose))
				break;
			pi->port = 0;
		} else {
			k = 0;
			while ((pi->port = lpts[k++]))
				if (pi_probe_unit
				    (pi, unit, scratch, verbose))
					break;
			if (pi->port)
				break;
		}
		if (pi->proto->release_proto)
			pi->proto->release_proto(pi);
		module_put(proto->owner);
	}

	if (!pi->port) {
		if (autoprobe)
			printk("%s: Autoprobe failed\n", device);
		else
			printk("%s: Adapter not found\n", device);
		return 0;
	}

	if (pi->parname)
		printk("%s: Sharing %s at 0x%x\n", pi->device,
		       pi->parname, pi->port);

	pi->proto->log_adapter(pi, scratch, verbose);

	return 1;
}

EXPORT_SYMBOL(pi_init);

static int pi_probe(struct pardevice *par_dev)
{
	struct device_driver *drv = par_dev->dev.driver;
	int len = strlen(drv->name);

	if (strncmp(par_dev->name, drv->name, len))
		return -ENODEV;

	return 0;
}

void *pi_register_driver(char *name)
{
	struct parport_driver *parp_drv;
	int ret;

	parp_drv = kzalloc(sizeof(*parp_drv), GFP_KERNEL);
	if (!parp_drv)
		return NULL;

	parp_drv->name = name;
	parp_drv->probe = pi_probe;
	parp_drv->devmodel = true;

	ret = parport_register_driver(parp_drv);
	if (ret) {
		kfree(parp_drv);
		return NULL;
	}
	return (void *)parp_drv;
}
EXPORT_SYMBOL(pi_register_driver);

void pi_unregister_driver(void *_drv)
{
	struct parport_driver *drv = _drv;

	parport_unregister_driver(drv);
	kfree(drv);
}
EXPORT_SYMBOL(pi_unregister_driver);
Commit	Line	Data
1da177e4 LT	1	/*
	2	paride.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
	3	Under the terms of the GNU General Public License.
	4
	5	This is the base module for the family of device drivers
	6	that support parallel port IDE devices.
	7
	8	*/
	9
	10	/* Changes:
	11
	12	1.01 GRG 1998.05.03 Use spinlocks
	13	1.02 GRG 1998.05.05 init_proto, release_proto, ktti
	14	1.03 GRG 1998.08.15 eliminate compiler warning
	15	1.04 GRG 1998.11.28 added support for FRIQ
	16	1.05 TMW 2000.06.06 use parport_find_number instead of
	17	parport_enumerate
	18	1.06 TMW 2001.03.26 more sane parport-or-not resource management
	19	*/
	20
	21	#define PI_VERSION "1.06"
	22
	23	#include <linux/module.h>
1da177e4 LT	24	#include <linux/kmod.h>
	25	#include <linux/types.h>
	26	#include <linux/kernel.h>
	27	#include <linux/ioport.h>
	28	#include <linux/string.h>
	29	#include <linux/spinlock.h>
	30	#include <linux/wait.h>
4e57b681	31	#include <linux/sched.h> /* TASK_* */
1da177e4	32	#include <linux/parport.h>
9f4ba6b0	33	#include <linux/slab.h>
1da177e4 LT	34
	35	#include "paride.h"
	36
	37	MODULE_LICENSE("GPL");
	38
	39	#define MAX_PROTOS 32
	40
	41	static struct pi_protocol *protocols[MAX_PROTOS];
	42
	43	static DEFINE_SPINLOCK(pi_spinlock);
	44
	45	void pi_write_regr(PIA * pi, int cont, int regr, int val)
	46	{
	47	pi->proto->write_regr(pi, cont, regr, val);
	48	}
	49
	50	EXPORT_SYMBOL(pi_write_regr);
	51
	52	int pi_read_regr(PIA * pi, int cont, int regr)
	53	{
	54	return pi->proto->read_regr(pi, cont, regr);
	55	}
	56
	57	EXPORT_SYMBOL(pi_read_regr);
	58
	59	void pi_write_block(PIA * pi, char *buf, int count)
	60	{
	61	pi->proto->write_block(pi, buf, count);
	62	}
	63
	64	EXPORT_SYMBOL(pi_write_block);
	65
	66	void pi_read_block(PIA * pi, char *buf, int count)
	67	{
	68	pi->proto->read_block(pi, buf, count);
	69	}
	70
	71	EXPORT_SYMBOL(pi_read_block);
	72
1da177e4 LT	73	static void pi_wake_up(void *p)
	74	{
	75	PIA pi = (PIA ) p;
	76	unsigned long flags;
	77	void (*cont) (void) = NULL;
	78
	79	spin_lock_irqsave(&pi_spinlock, flags);
	80
	81	if (pi->claim_cont && !parport_claim(pi->pardev)) {
	82	cont = pi->claim_cont;
	83	pi->claim_cont = NULL;
	84	pi->claimed = 1;
	85	}
	86
	87	spin_unlock_irqrestore(&pi_spinlock, flags);
	88
	89	wake_up(&(pi->parq));
	90
	91	if (cont)
	92	cont();
	93	}
	94
1da177e4 LT	95	int pi_schedule_claimed(PIA * pi, void (*cont) (void))
1da177e4 LT	96	{
1da177e4 LT	97	unsigned long flags;
	98
	99	spin_lock_irqsave(&pi_spinlock, flags);
	100	if (pi->pardev && parport_claim(pi->pardev)) {
	101	pi->claim_cont = cont;
	102	spin_unlock_irqrestore(&pi_spinlock, flags);
	103	return 0;
	104	}
	105	pi->claimed = 1;
	106	spin_unlock_irqrestore(&pi_spinlock, flags);
1da177e4 LT	107	return 1;
	108	}
	109	EXPORT_SYMBOL(pi_schedule_claimed);
	110
	111	void pi_do_claimed(PIA * pi, void (*cont) (void))
	112	{
	113	if (pi_schedule_claimed(pi, cont))
	114	cont();
	115	}
	116
	117	EXPORT_SYMBOL(pi_do_claimed);
	118
	119	static void pi_claim(PIA * pi)
	120	{
	121	if (pi->claimed)
	122	return;
	123	pi->claimed = 1;
1da177e4 LT	124	if (pi->pardev)
	125	wait_event(pi->parq,
	126	!parport_claim((struct pardevice *) pi->pardev));
1da177e4 LT	127	}
	128
	129	static void pi_unclaim(PIA * pi)
	130	{
	131	pi->claimed = 0;
1da177e4 LT	132	if (pi->pardev)
1da177e4 LT	133	parport_release((struct pardevice *) (pi->pardev));
1da177e4 LT	134	}
	135
	136	void pi_connect(PIA * pi)
	137	{
	138	pi_claim(pi);
	139	pi->proto->connect(pi);
	140	}
	141
	142	EXPORT_SYMBOL(pi_connect);
	143
	144	void pi_disconnect(PIA * pi)
	145	{
	146	pi->proto->disconnect(pi);
	147	pi_unclaim(pi);
	148	}
	149
	150	EXPORT_SYMBOL(pi_disconnect);
	151
	152	static void pi_unregister_parport(PIA * pi)
	153	{
1da177e4 LT	154	if (pi->pardev) {
	155	parport_unregister_device((struct pardevice *) (pi->pardev));
	156	pi->pardev = NULL;
	157	}
1da177e4 LT	158	}
	159
	160	void pi_release(PIA * pi)
	161	{
	162	pi_unregister_parport(pi);
1da177e4 LT	163	if (pi->proto->release_proto)
	164	pi->proto->release_proto(pi);
	165	module_put(pi->proto->owner);
	166	}
	167
	168	EXPORT_SYMBOL(pi_release);
	169
	170	static int default_test_proto(PIA * pi, char *scratch, int verbose)
	171	{
	172	int j, k;
	173	int e[2] = { 0, 0 };
	174
	175	pi->proto->connect(pi);
	176
	177	for (j = 0; j < 2; j++) {
	178	pi_write_regr(pi, 0, 6, 0xa0 + j * 0x10);
	179	for (k = 0; k < 256; k++) {
	180	pi_write_regr(pi, 0, 2, k ^ 0xaa);
	181	pi_write_regr(pi, 0, 3, k ^ 0x55);
	182	if (pi_read_regr(pi, 0, 2) != (k ^ 0xaa))
	183	e[j]++;
	184	}
	185	}
	186	pi->proto->disconnect(pi);
	187
	188	if (verbose)
	189	printk("%s: %s: port 0x%x, mode %d, test=(%d,%d)\n",
	190	pi->device, pi->proto->name, pi->port,
	191	pi->mode, e[0], e[1]);
	192
	193	return (e[0] && e[1]); /* not here if both > 0 */
	194	}
	195
	196	static int pi_test_proto(PIA * pi, char *scratch, int verbose)
	197	{
	198	int res;
	199
	200	pi_claim(pi);
	201	if (pi->proto->test_proto)
	202	res = pi->proto->test_proto(pi, scratch, verbose);
	203	else
	204	res = default_test_proto(pi, scratch, verbose);
	205	pi_unclaim(pi);
	206
	207	return res;
	208	}
	209
f4330002	210	int paride_register(PIP * pr)
1da177e4 LT	211	{
	212	int k;
	213
	214	for (k = 0; k < MAX_PROTOS; k++)
	215	if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
	216	printk("paride: %s protocol already registered\n",
	217	pr->name);
b4178ab5	218	return -1;
1da177e4 LT	219	}
	220	k = 0;
	221	while ((k < MAX_PROTOS) && (protocols[k]))
	222	k++;
	223	if (k == MAX_PROTOS) {
	224	printk("paride: protocol table full\n");
b4178ab5	225	return -1;
1da177e4 LT	226	}
	227	protocols[k] = pr;
	228	pr->index = k;
	229	printk("paride: %s registered as protocol %d\n", pr->name, k);
b4178ab5	230	return 0;
1da177e4 LT	231	}
1da177e4 LT	232
f4330002	233	EXPORT_SYMBOL(paride_register);
1da177e4	234
f4330002	235	void paride_unregister(PIP * pr)
1da177e4 LT	236	{
	237	if (!pr)
	238	return;
	239	if (protocols[pr->index] != pr) {
	240	printk("paride: %s not registered\n", pr->name);
	241	return;
	242	}
	243	protocols[pr->index] = NULL;
	244	}
	245
f4330002	246	EXPORT_SYMBOL(paride_unregister);
1da177e4	247
9f4ba6b0	248	static int pi_register_parport(PIA *pi, int verbose, int unit)
1da177e4	249	{
1da177e4	250	struct parport *port;
9f4ba6b0	251	struct pardev_cb par_cb;
1da177e4 LT	252
	253	port = parport_find_base(pi->port);
	254	if (!port)
	255	return 0;
9f4ba6b0 SM	256	memset(&par_cb, 0, sizeof(par_cb));
	257	par_cb.wakeup = pi_wake_up;
	258	par_cb.private = (void *)pi;
	259	pi->pardev = parport_register_dev_model(port, pi->device, &par_cb,
	260	unit);
1da177e4 LT	261	parport_put_port(port);
	262	if (!pi->pardev)
	263	return 0;
	264
	265	init_waitqueue_head(&pi->parq);
	266
	267	if (verbose)
	268	printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
	269
	270	pi->parname = (char *) port->name;
1da177e4 LT	271
	272	return 1;
	273	}
	274
	275	static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
	276	{
	277	int best, range;
	278
	279	if (pi->mode != -1) {
	280	if (pi->mode >= max)
	281	return 0;
	282	range = 3;
	283	if (pi->mode >= pi->proto->epp_first)
	284	range = 8;
	285	if ((range == 8) && (pi->port % 8))
	286	return 0;
	287	pi->reserved = range;
	288	return (!pi_test_proto(pi, scratch, verbose));
	289	}
	290	best = -1;
	291	for (pi->mode = 0; pi->mode < max; pi->mode++) {
	292	range = 3;
	293	if (pi->mode >= pi->proto->epp_first)
	294	range = 8;
	295	if ((range == 8) && (pi->port % 8))
	296	break;
	297	pi->reserved = range;
	298	if (!pi_test_proto(pi, scratch, verbose))
	299	best = pi->mode;
	300	}
	301	pi->mode = best;
	302	return (best > -1);
	303	}
	304
	305	static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
	306	{
	307	int max, s, e;
	308
	309	s = unit;
	310	e = s + 1;
	311
	312	if (s == -1) {
	313	s = 0;
	314	e = pi->proto->max_units;
	315	}
	316
9f4ba6b0	317	if (!pi_register_parport(pi, verbose, s))
1da177e4 LT	318	return 0;
	319
	320	if (pi->proto->test_port) {
	321	pi_claim(pi);
	322	max = pi->proto->test_port(pi);
	323	pi_unclaim(pi);
	324	} else
	325	max = pi->proto->max_mode;
	326
	327	if (pi->proto->probe_unit) {
	328	pi_claim(pi);
	329	for (pi->unit = s; pi->unit < e; pi->unit++)
	330	if (pi->proto->probe_unit(pi)) {
	331	pi_unclaim(pi);
	332	if (pi_probe_mode(pi, max, scratch, verbose))
	333	return 1;
	334	pi_unregister_parport(pi);
	335	return 0;
	336	}
	337	pi_unclaim(pi);
	338	pi_unregister_parport(pi);
	339	return 0;
	340	}
	341
	342	if (!pi_probe_mode(pi, max, scratch, verbose)) {
	343	pi_unregister_parport(pi);
	344	return 0;
	345	}
	346	return 1;
	347
	348	}
	349
	350	int pi_init(PIA * pi, int autoprobe, int port, int mode,
	351	int unit, int protocol, int delay, char *scratch,
	352	int devtype, int verbose, char *device)
	353	{
	354	int p, k, s, e;
	355	int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
	356
	357	s = protocol;
	358	e = s + 1;
	359
	360	if (!protocols[0])
	361	request_module("paride_protocol");
	362
	363	if (autoprobe) {
	364	s = 0;
	365	e = MAX_PROTOS;
	366	} else if ((s < 0) \|\| (s >= MAX_PROTOS) \|\| (port <= 0) \|\|
	367	(!protocols[s]) \|\| (unit < 0) \|\|
	368	(unit >= protocols[s]->max_units)) {
	369	printk("%s: Invalid parameters\n", device);
	370	return 0;
	371	}
	372
	373	for (p = s; p < e; p++) {
	374	struct pi_protocol *proto = protocols[p];
	375	if (!proto)
	376	continue;
	377	/* still racy */
	378	if (!try_module_get(proto->owner))
	379	continue;
	380	pi->proto = proto;
	381	pi->private = 0;
382	if (proto->init_proto && proto->init_proto(pi) < 0) {
383	pi->proto = NULL;
384	module_put(proto->owner);
385	continue;
386	}
387	if (delay == -1)
388	pi->delay = pi->proto->default_delay;
389	else
390	pi->delay = delay;
391	pi->devtype = devtype;
392	pi->device = device;
393
394	pi->parname = NULL;
395	pi->pardev = NULL;
396	init_waitqueue_head(&pi->parq);
397	pi->claimed = 0;
398	pi->claim_cont = NULL;
399
400	pi->mode = mode;
401	if (port != -1) {
402	pi->port = port;
403	if (pi_probe_unit(pi, unit, scratch, verbose))
404	break;
405	pi->port = 0;
406	} else {
407	k = 0;
408	while ((pi->port = lpts[k++]))
409	if (pi_probe_unit
410	(pi, unit, scratch, verbose))
411	break;
412	if (pi->port)
413	break;
414	}
415	if (pi->proto->release_proto)
416	pi->proto->release_proto(pi);
417	module_put(proto->owner);
418	}
419
420	if (!pi->port) {
421	if (autoprobe)
422	printk("%s: Autoprobe failed\n", device);
423	else
424	printk("%s: Adapter not found\n", device);
425	return 0;
426	}
1da177e4 LT	427
	428	if (pi->parname)
	429	printk("%s: Sharing %s at 0x%x\n", pi->device,
	430	pi->parname, pi->port);
	431
	432	pi->proto->log_adapter(pi, scratch, verbose);
	433
	434	return 1;
	435	}
	436
	437	EXPORT_SYMBOL(pi_init);
9f4ba6b0 SM	438
	439	static int pi_probe(struct pardevice *par_dev)
	440	{
	441	struct device_driver *drv = par_dev->dev.driver;
	442	int len = strlen(drv->name);
	443
	444	if (strncmp(par_dev->name, drv->name, len))
	445	return -ENODEV;
	446
	447	return 0;
	448	}
	449
	450	void pi_register_driver(char name)
	451	{
	452	struct parport_driver *parp_drv;
	453	int ret;
	454
	455	parp_drv = kzalloc(sizeof(*parp_drv), GFP_KERNEL);
	456	if (!parp_drv)
	457	return NULL;
	458
	459	parp_drv->name = name;
	460	parp_drv->probe = pi_probe;
	461	parp_drv->devmodel = true;
	462
	463	ret = parport_register_driver(parp_drv);
	464	if (ret) {
	465	kfree(parp_drv);
	466	return NULL;
	467	}
	468	return (void *)parp_drv;
	469	}
	470	EXPORT_SYMBOL(pi_register_driver);
	471
	472	void pi_unregister_driver(void *_drv)
	473	{
	474	struct parport_driver *drv = _drv;
	475
	476	parport_unregister_driver(drv);
	477	kfree(drv);
	478	}
	479	EXPORT_SYMBOL(pi_unregister_driver);