paride.c revision f4330002d11f032559954cbff68a5cad95b6d27f 
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>
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>
31#include <linux/sched.h>	/* TASK_* */
32
33#ifdef CONFIG_PARPORT_MODULE
34#define CONFIG_PARPORT
35#endif
36
37#ifdef CONFIG_PARPORT
38#include <linux/parport.h>
39#endif
40
41#include "paride.h"
42
43MODULE_LICENSE("GPL");
44
45#define MAX_PROTOS	32
46
47static struct pi_protocol *protocols[MAX_PROTOS];
48
49static DEFINE_SPINLOCK(pi_spinlock);
50
51void pi_write_regr(PIA * pi, int cont, int regr, int val)
52{
53	pi->proto->write_regr(pi, cont, regr, val);
54}
55
56EXPORT_SYMBOL(pi_write_regr);
57
58int pi_read_regr(PIA * pi, int cont, int regr)
59{
60	return pi->proto->read_regr(pi, cont, regr);
61}
62
63EXPORT_SYMBOL(pi_read_regr);
64
65void pi_write_block(PIA * pi, char *buf, int count)
66{
67	pi->proto->write_block(pi, buf, count);
68}
69
70EXPORT_SYMBOL(pi_write_block);
71
72void pi_read_block(PIA * pi, char *buf, int count)
73{
74	pi->proto->read_block(pi, buf, count);
75}
76
77EXPORT_SYMBOL(pi_read_block);
78
79#ifdef CONFIG_PARPORT
80
81static void pi_wake_up(void *p)
82{
83	PIA *pi = (PIA *) p;
84	unsigned long flags;
85	void (*cont) (void) = NULL;
86
87	spin_lock_irqsave(&pi_spinlock, flags);
88
89	if (pi->claim_cont && !parport_claim(pi->pardev)) {
90		cont = pi->claim_cont;
91		pi->claim_cont = NULL;
92		pi->claimed = 1;
93	}
94
95	spin_unlock_irqrestore(&pi_spinlock, flags);
96
97	wake_up(&(pi->parq));
98
99	if (cont)
100		cont();
101}
102
103#endif
104
105int pi_schedule_claimed(PIA * pi, void (*cont) (void))
106{
107#ifdef CONFIG_PARPORT
108	unsigned long flags;
109
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);
114		return 0;
115	}
116	pi->claimed = 1;
117	spin_unlock_irqrestore(&pi_spinlock, flags);
118#endif
119	return 1;
120}
121EXPORT_SYMBOL(pi_schedule_claimed);
122
123void pi_do_claimed(PIA * pi, void (*cont) (void))
124{
125	if (pi_schedule_claimed(pi, cont))
126		cont();
127}
128
129EXPORT_SYMBOL(pi_do_claimed);
130
131static void pi_claim(PIA * pi)
132{
133	if (pi->claimed)
134		return;
135	pi->claimed = 1;
136#ifdef CONFIG_PARPORT
137	if (pi->pardev)
138		wait_event(pi->parq,
139			   !parport_claim((struct pardevice *) pi->pardev));
140#endif
141}
142
143static void pi_unclaim(PIA * pi)
144{
145	pi->claimed = 0;
146#ifdef CONFIG_PARPORT
147	if (pi->pardev)
148		parport_release((struct pardevice *) (pi->pardev));
149#endif
150}
151
152void pi_connect(PIA * pi)
153{
154	pi_claim(pi);
155	pi->proto->connect(pi);
156}
157
158EXPORT_SYMBOL(pi_connect);
159
160void pi_disconnect(PIA * pi)
161{
162	pi->proto->disconnect(pi);
163	pi_unclaim(pi);
164}
165
166EXPORT_SYMBOL(pi_disconnect);
167
168static void pi_unregister_parport(PIA * pi)
169{
170#ifdef CONFIG_PARPORT
171	if (pi->pardev) {
172		parport_unregister_device((struct pardevice *) (pi->pardev));
173		pi->pardev = NULL;
174	}
175#endif
176}
177
178void pi_release(PIA * pi)
179{
180	pi_unregister_parport(pi);
181#ifndef CONFIG_PARPORT
182	if (pi->reserved)
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);
188}
189
190EXPORT_SYMBOL(pi_release);
191
192static int default_test_proto(PIA * pi, char *scratch, int verbose)
193{
194	int j, k;
195	int e[2] = { 0, 0 };
196
197	pi->proto->connect(pi);
198
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))
205				e[j]++;
206		}
207	}
208	pi->proto->disconnect(pi);
209
210	if (verbose)
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]);
214
215	return (e[0] && e[1]);	/* not here if both > 0 */
216}
217
218static int pi_test_proto(PIA * pi, char *scratch, int verbose)
219{
220	int res;
221
222	pi_claim(pi);
223	if (pi->proto->test_proto)
224		res = pi->proto->test_proto(pi, scratch, verbose);
225	else
226		res = default_test_proto(pi, scratch, verbose);
227	pi_unclaim(pi);
228
229	return res;
230}
231
232int paride_register(PIP * pr)
233{
234	int k;
235
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",
239			       pr->name);
240			return 0;
241		}
242	k = 0;
243	while ((k < MAX_PROTOS) && (protocols[k]))
244		k++;
245	if (k == MAX_PROTOS) {
246		printk("paride: protocol table full\n");
247		return 0;
248	}
249	protocols[k] = pr;
250	pr->index = k;
251	printk("paride: %s registered as protocol %d\n", pr->name, k);
252	return 1;
253}
254
255EXPORT_SYMBOL(paride_register);
256
257void paride_unregister(PIP * pr)
258{
259	if (!pr)
260		return;
261	if (protocols[pr->index] != pr) {
262		printk("paride: %s not registered\n", pr->name);
263		return;
264	}
265	protocols[pr->index] = NULL;
266}
267
268EXPORT_SYMBOL(paride_unregister);
269
270static int pi_register_parport(PIA * pi, int verbose)
271{
272#ifdef CONFIG_PARPORT
273
274	struct parport *port;
275
276	port = parport_find_base(pi->port);
277	if (!port)
278		return 0;
279
280	pi->pardev = parport_register_device(port,
281					     pi->device, NULL,
282					     pi_wake_up, NULL, 0, (void *) pi);
283	parport_put_port(port);
284	if (!pi->pardev)
285		return 0;
286
287	init_waitqueue_head(&pi->parq);
288
289	if (verbose)
290		printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
291
292	pi->parname = (char *) port->name;
293#endif
294
295	return 1;
296}
297
298static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
299{
300	int best, range;
301
302	if (pi->mode != -1) {
303		if (pi->mode >= max)
304			return 0;
305		range = 3;
306		if (pi->mode >= pi->proto->epp_first)
307			range = 8;
308		if ((range == 8) && (pi->port % 8))
309			return 0;
310		pi->reserved = range;
311		return (!pi_test_proto(pi, scratch, verbose));
312	}
313	best = -1;
314	for (pi->mode = 0; pi->mode < max; pi->mode++) {
315		range = 3;
316		if (pi->mode >= pi->proto->epp_first)
317			range = 8;
318		if ((range == 8) && (pi->port % 8))
319			break;
320		pi->reserved = range;
321		if (!pi_test_proto(pi, scratch, verbose))
322			best = pi->mode;
323	}
324	pi->mode = best;
325	return (best > -1);
326}
327
328static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
329{
330	int max, s, e;
331
332	s = unit;
333	e = s + 1;
334
335	if (s == -1) {
336		s = 0;
337		e = pi->proto->max_units;
338	}
339
340	if (!pi_register_parport(pi, verbose))
341		return 0;
342
343	if (pi->proto->test_port) {
344		pi_claim(pi);
345		max = pi->proto->test_port(pi);
346		pi_unclaim(pi);
347	} else
348		max = pi->proto->max_mode;
349
350	if (pi->proto->probe_unit) {
351		pi_claim(pi);
352		for (pi->unit = s; pi->unit < e; pi->unit++)
353			if (pi->proto->probe_unit(pi)) {
354				pi_unclaim(pi);
355				if (pi_probe_mode(pi, max, scratch, verbose))
356					return 1;
357				pi_unregister_parport(pi);
358				return 0;
359			}
360		pi_unclaim(pi);
361		pi_unregister_parport(pi);
362		return 0;
363	}
364
365	if (!pi_probe_mode(pi, max, scratch, verbose)) {
366		pi_unregister_parport(pi);
367		return 0;
368	}
369	return 1;
370
371}
372
373int 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)
376{
377	int p, k, s, e;
378	int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
379
380	s = protocol;
381	e = s + 1;
382
383	if (!protocols[0])
384		request_module("paride_protocol");
385
386	if (autoprobe) {
387		s = 0;
388		e = MAX_PROTOS;
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);
393		return 0;
394	}
395
396	for (p = s; p < e; p++) {
397		struct pi_protocol *proto = protocols[p];
398		if (!proto)
399			continue;
400		/* still racy */
401		if (!try_module_get(proto->owner))
402			continue;
403		pi->proto = proto;
404		pi->private = 0;
405		if (proto->init_proto && proto->init_proto(pi) < 0) {
406			pi->proto = NULL;
407			module_put(proto->owner);
408			continue;
409		}
410		if (delay == -1)
411			pi->delay = pi->proto->default_delay;
412		else
413			pi->delay = delay;
414		pi->devtype = devtype;
415		pi->device = device;
416
417		pi->parname = NULL;
418		pi->pardev = NULL;
419		init_waitqueue_head(&pi->parq);
420		pi->claimed = 0;
421		pi->claim_cont = NULL;
422
423		pi->mode = mode;
424		if (port != -1) {
425			pi->port = port;
426			if (pi_probe_unit(pi, unit, scratch, verbose))
427				break;
428			pi->port = 0;
429		} else {
430			k = 0;
431			while ((pi->port = lpts[k++]))
432				if (pi_probe_unit
433				    (pi, unit, scratch, verbose))
434					break;
435			if (pi->port)
436				break;
437		}
438		if (pi->proto->release_proto)
439			pi->proto->release_proto(pi);
440		module_put(proto->owner);
441	}
442
443	if (!pi->port) {
444		if (autoprobe)
445			printk("%s: Autoprobe failed\n", device);
446		else
447			printk("%s: Adapter not found\n", device);
448		return 0;
449	}
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",
453		       pi->port);
454		return 0;
455	}
456#endif				/* !CONFIG_PARPORT */
457
458	if (pi->parname)
459		printk("%s: Sharing %s at 0x%x\n", pi->device,
460		       pi->parname, pi->port);
461
462	pi->proto->log_adapter(pi, scratch, verbose);
463
464	return 1;
465}
466
467EXPORT_SYMBOL(pi_init);
468