Release 4.11 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
33
100.00%
1
100.00%
Total
33
100.00%
1
100.00%


EXPORT_SYMBOL(pi_write_regr);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%


EXPORT_SYMBOL(pi_read_regr);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%


EXPORT_SYMBOL(pi_write_block);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%


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();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
101
99.02%
2
66.67%
Dave Jones
1
0.98%
1
33.33%
Total
102
100.00%
3
100.00%



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
63
79.75%
2
40.00%
Al Viro
15
18.99%
2
40.00%
Dave Jones
1
1.27%
1
20.00%
Total
79
100.00%
5
100.00%


EXPORT_SYMBOL(pi_schedule_claimed);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Al Viro
26
86.67%
1
50.00%
Linus Torvalds (pre-git)
4
13.33%
1
50.00%
Total
30
100.00%
2
100.00%


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));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
49
100.00%
2
100.00%
Total
49
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
35
97.22%
1
50.00%
Christoph Hellwig
1
2.78%
1
50.00%
Total
36
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%


EXPORT_SYMBOL(pi_connect);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%


EXPORT_SYMBOL(pi_disconnect);



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
23
57.50%
2
50.00%
Al Viro
16
40.00%
1
25.00%
Christoph Hellwig
1
2.50%
1
25.00%
Total
40
100.00%
4
100.00%


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 */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
170
86.29%
1
50.00%
Al Viro
27
13.71%
1
50.00%
Total
197
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Al Viro
68
100.00%
1
100.00%
Total
68
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
122
95.31%
1
33.33%
Alexey Dobriyan
6
4.69%
2
66.67%
Total
128
100.00%
3
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
45
95.74%
1
33.33%
Alexey Dobriyan
1
2.13%
1
33.33%
Al Viro
1
2.13%
1
33.33%
Total
47
100.00%
3
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
98
66.22%
5
71.43%
Sudip Mukherjee
40
27.03%
1
14.29%
Linus Torvalds
10
6.76%
1
14.29%
Total
148
100.00%
7
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
206
100.00%
1
100.00%
Total
206
100.00%
1
100.00%



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;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
220
96.07%
1
33.33%
Linus Torvalds
7
3.06%
1
33.33%
Sudip Mukherjee
2
0.87%
1
33.33%
Total
229
100.00%
3
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
434
87.15%
5
71.43%
Al Viro
58
11.65%
1
14.29%
Christoph Hellwig
6
1.20%
1
14.29%
Total
498
100.00%
7
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Sudip Mukherjee
54
100.00%
1
100.00%
Total
54
100.00%
1
100.00%



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Sudip Mukherjee
85
100.00%
1
100.00%
Total
85
100.00%
1
100.00%


EXPORT_SYMBOL(pi_register_driver);



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

	parport_unregister_driver(drv);
	kfree(drv);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Sudip Mukherjee
26
100.00%
1
100.00%
Total
26
100.00%
1
100.00%


EXPORT_SYMBOL(pi_unregister_driver);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
1821
77.06%
11
39.29%
Sudip Mukherjee
220
9.31%
1
3.57%
Al Viro
216
9.14%
4
14.29%
Kai Germaschewski
53
2.24%
1
3.57%
Linus Torvalds
21
0.89%
3
10.71%
Alexey Dobriyan
9
0.38%
2
7.14%
Christoph Hellwig
8
0.34%
2
7.14%
Randy Dunlap
5
0.21%
1
3.57%
Thomas Gleixner
4
0.17%
1
3.57%
Tim Schmielau
4
0.17%
1
3.57%
Dave Jones
2
0.08%
1
3.57%
Total
2363
100.00%
28
100.00%
Directory: drivers/block/paride

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.