2 paride.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
5 This is the base module for the family of device drivers
6 that support parallel port IDE devices.
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
18 1.06 TMW 2001.03.26 more sane parport-or-not resource management
21 #define PI_VERSION "1.06"
23 #include <linux/module.h>
24 #include <linux/config.h>
25 #include <linux/kmod.h>
26 #include <linux/types.h>
27 #include <linux/kernel.h>
28 #include <linux/ioport.h>
29 #include <linux/string.h>
30 #include <linux/spinlock.h>
31 #include <linux/wait.h>
33 #ifdef CONFIG_PARPORT_MODULE
34 #define CONFIG_PARPORT
38 #include <linux/parport.h>
43 MODULE_LICENSE("GPL");
47 static struct pi_protocol *protocols[MAX_PROTOS];
49 static DEFINE_SPINLOCK(pi_spinlock);
51 void pi_write_regr(PIA * pi, int cont, int regr, int val)
53 pi->proto->write_regr(pi, cont, regr, val);
56 EXPORT_SYMBOL(pi_write_regr);
58 int pi_read_regr(PIA * pi, int cont, int regr)
60 return pi->proto->read_regr(pi, cont, regr);
63 EXPORT_SYMBOL(pi_read_regr);
65 void pi_write_block(PIA * pi, char *buf, int count)
67 pi->proto->write_block(pi, buf, count);
70 EXPORT_SYMBOL(pi_write_block);
72 void pi_read_block(PIA * pi, char *buf, int count)
74 pi->proto->read_block(pi, buf, count);
77 EXPORT_SYMBOL(pi_read_block);
81 static void pi_wake_up(void *p)
85 void (*cont) (void) = NULL;
87 spin_lock_irqsave(&pi_spinlock, flags);
89 if (pi->claim_cont && !parport_claim(pi->pardev)) {
90 cont = pi->claim_cont;
91 pi->claim_cont = NULL;
95 spin_unlock_irqrestore(&pi_spinlock, flags);
105 int pi_schedule_claimed(PIA * pi, void (*cont) (void))
107 #ifdef CONFIG_PARPORT
110 spin_lock_irqsave(&pi_spinlock, flags);
111 if (pi->pardev && parport_claim(pi->pardev)) {
112 pi->claim_cont = cont;
113 spin_unlock_irqrestore(&pi_spinlock, flags);
117 spin_unlock_irqrestore(&pi_spinlock, flags);
121 EXPORT_SYMBOL(pi_schedule_claimed);
123 void pi_do_claimed(PIA * pi, void (*cont) (void))
125 if (pi_schedule_claimed(pi, cont))
129 EXPORT_SYMBOL(pi_do_claimed);
131 static void pi_claim(PIA * pi)
136 #ifdef CONFIG_PARPORT
139 !parport_claim((struct pardevice *) pi->pardev));
143 static void pi_unclaim(PIA * pi)
146 #ifdef CONFIG_PARPORT
148 parport_release((struct pardevice *) (pi->pardev));
152 void pi_connect(PIA * pi)
155 pi->proto->connect(pi);
158 EXPORT_SYMBOL(pi_connect);
160 void pi_disconnect(PIA * pi)
162 pi->proto->disconnect(pi);
166 EXPORT_SYMBOL(pi_disconnect);
168 static void pi_unregister_parport(PIA * pi)
170 #ifdef CONFIG_PARPORT
172 parport_unregister_device((struct pardevice *) (pi->pardev));
178 void pi_release(PIA * pi)
180 pi_unregister_parport(pi);
181 #ifndef CONFIG_PARPORT
183 release_region(pi->port, pi->reserved);
184 #endif /* !CONFIG_PARPORT */
185 if (pi->proto->release_proto)
186 pi->proto->release_proto(pi);
187 module_put(pi->proto->owner);
190 EXPORT_SYMBOL(pi_release);
192 static int default_test_proto(PIA * pi, char *scratch, int verbose)
197 pi->proto->connect(pi);
199 for (j = 0; j < 2; j++) {
200 pi_write_regr(pi, 0, 6, 0xa0 + j * 0x10);
201 for (k = 0; k < 256; k++) {
202 pi_write_regr(pi, 0, 2, k ^ 0xaa);
203 pi_write_regr(pi, 0, 3, k ^ 0x55);
204 if (pi_read_regr(pi, 0, 2) != (k ^ 0xaa))
208 pi->proto->disconnect(pi);
211 printk("%s: %s: port 0x%x, mode %d, test=(%d,%d)\n",
212 pi->device, pi->proto->name, pi->port,
213 pi->mode, e[0], e[1]);
215 return (e[0] && e[1]); /* not here if both > 0 */
218 static int pi_test_proto(PIA * pi, char *scratch, int verbose)
223 if (pi->proto->test_proto)
224 res = pi->proto->test_proto(pi, scratch, verbose);
226 res = default_test_proto(pi, scratch, verbose);
232 int pi_register(PIP * pr)
236 for (k = 0; k < MAX_PROTOS; k++)
237 if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
238 printk("paride: %s protocol already registered\n",
243 while ((k < MAX_PROTOS) && (protocols[k]))
245 if (k == MAX_PROTOS) {
246 printk("paride: protocol table full\n");
251 printk("paride: %s registered as protocol %d\n", pr->name, k);
255 EXPORT_SYMBOL(pi_register);
257 void pi_unregister(PIP * pr)
261 if (protocols[pr->index] != pr) {
262 printk("paride: %s not registered\n", pr->name);
265 protocols[pr->index] = NULL;
268 EXPORT_SYMBOL(pi_unregister);
270 static int pi_register_parport(PIA * pi, int verbose)
272 #ifdef CONFIG_PARPORT
274 struct parport *port;
276 port = parport_find_base(pi->port);
280 pi->pardev = parport_register_device(port,
282 pi_wake_up, NULL, 0, (void *) pi);
283 parport_put_port(port);
287 init_waitqueue_head(&pi->parq);
290 printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
292 pi->parname = (char *) port->name;
298 static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
302 if (pi->mode != -1) {
306 if (pi->mode >= pi->proto->epp_first)
308 if ((range == 8) && (pi->port % 8))
310 pi->reserved = range;
311 return (!pi_test_proto(pi, scratch, verbose));
314 for (pi->mode = 0; pi->mode < max; pi->mode++) {
316 if (pi->mode >= pi->proto->epp_first)
318 if ((range == 8) && (pi->port % 8))
320 pi->reserved = range;
321 if (!pi_test_proto(pi, scratch, verbose))
328 static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
337 e = pi->proto->max_units;
340 if (!pi_register_parport(pi, verbose))
343 if (pi->proto->test_port) {
345 max = pi->proto->test_port(pi);
348 max = pi->proto->max_mode;
350 if (pi->proto->probe_unit) {
352 for (pi->unit = s; pi->unit < e; pi->unit++)
353 if (pi->proto->probe_unit(pi)) {
355 if (pi_probe_mode(pi, max, scratch, verbose))
357 pi_unregister_parport(pi);
361 pi_unregister_parport(pi);
365 if (!pi_probe_mode(pi, max, scratch, verbose)) {
366 pi_unregister_parport(pi);
373 int pi_init(PIA * pi, int autoprobe, int port, int mode,
374 int unit, int protocol, int delay, char *scratch,
375 int devtype, int verbose, char *device)
378 int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
384 request_module("paride_protocol");
389 } else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
390 (!protocols[s]) || (unit < 0) ||
391 (unit >= protocols[s]->max_units)) {
392 printk("%s: Invalid parameters\n", device);
396 for (p = s; p < e; p++) {
397 struct pi_protocol *proto = protocols[p];
401 if (!try_module_get(proto->owner))
405 if (proto->init_proto && proto->init_proto(pi) < 0) {
407 module_put(proto->owner);
411 pi->delay = pi->proto->default_delay;
414 pi->devtype = devtype;
419 init_waitqueue_head(&pi->parq);
421 pi->claim_cont = NULL;
426 if (pi_probe_unit(pi, unit, scratch, verbose))
431 while ((pi->port = lpts[k++]))
433 (pi, unit, scratch, verbose))
438 if (pi->proto->release_proto)
439 pi->proto->release_proto(pi);
440 module_put(proto->owner);
445 printk("%s: Autoprobe failed\n", device);
447 printk("%s: Adapter not found\n", device);
450 #ifndef CONFIG_PARPORT
451 if (!request_region(pi->port, pi->reserved, pi->device)) {
452 printk(KERN_WARNING "paride: Unable to request region 0x%x\n",
456 #endif /* !CONFIG_PARPORT */
459 printk("%s: Sharing %s at 0x%x\n", pi->device,
460 pi->parname, pi->port);
462 pi->proto->log_adapter(pi, scratch, verbose);
467 EXPORT_SYMBOL(pi_init);