xref: /linux/drivers/parport/share.c (revision 680e6ffa15103ab610c0fc1241d2f98c801b13e2)
1 /*
2  * Parallel-port resource manager code.
3  *
4  * Authors: David Campbell <campbell@tirian.che.curtin.edu.au>
5  *          Tim Waugh <tim@cyberelk.demon.co.uk>
6  *          Jose Renau <renau@acm.org>
7  *          Philip Blundell <philb@gnu.org>
8  *	    Andrea Arcangeli
9  *
10  * based on work by Grant Guenther <grant@torque.net>
11  *          and Philip Blundell
12  *
13  * Any part of this program may be used in documents licensed under
14  * the GNU Free Documentation License, Version 1.1 or any later version
15  * published by the Free Software Foundation.
16  */
17 
18 #undef PARPORT_DEBUG_SHARING		/* undef for production */
19 
20 #include <linux/module.h>
21 #include <linux/string.h>
22 #include <linux/threads.h>
23 #include <linux/parport.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/interrupt.h>
27 #include <linux/ioport.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/sched/signal.h>
31 #include <linux/kmod.h>
32 #include <linux/device.h>
33 
34 #include <linux/spinlock.h>
35 #include <linux/mutex.h>
36 #include <asm/irq.h>
37 
38 #undef PARPORT_PARANOID
39 
40 #define PARPORT_DEFAULT_TIMESLICE	(HZ/5)
41 
42 unsigned long parport_default_timeslice = PARPORT_DEFAULT_TIMESLICE;
43 int parport_default_spintime =  DEFAULT_SPIN_TIME;
44 
45 static LIST_HEAD(portlist);
46 static DEFINE_SPINLOCK(parportlist_lock);
47 
48 /* list of all allocated ports, sorted by ->number */
49 static LIST_HEAD(all_ports);
50 static DEFINE_SPINLOCK(full_list_lock);
51 
52 static LIST_HEAD(drivers);
53 
54 static DEFINE_MUTEX(registration_lock);
55 
56 /* What you can do to a port that's gone away.. */
57 static void dead_write_lines(struct parport *p, unsigned char b){}
58 static unsigned char dead_read_lines(struct parport *p) { return 0; }
59 static unsigned char dead_frob_lines(struct parport *p, unsigned char b,
60 			     unsigned char c) { return 0; }
61 static void dead_onearg(struct parport *p){}
62 static void dead_initstate(struct pardevice *d, struct parport_state *s) { }
63 static void dead_state(struct parport *p, struct parport_state *s) { }
64 static size_t dead_write(struct parport *p, const void *b, size_t l, int f)
65 { return 0; }
66 static size_t dead_read(struct parport *p, void *b, size_t l, int f)
67 { return 0; }
68 static struct parport_operations dead_ops = {
69 	.write_data	= dead_write_lines,	/* data */
70 	.read_data	= dead_read_lines,
71 
72 	.write_control	= dead_write_lines,	/* control */
73 	.read_control	= dead_read_lines,
74 	.frob_control	= dead_frob_lines,
75 
76 	.read_status	= dead_read_lines,	/* status */
77 
78 	.enable_irq	= dead_onearg,		/* enable_irq */
79 	.disable_irq	= dead_onearg,		/* disable_irq */
80 
81 	.data_forward	= dead_onearg,		/* data_forward */
82 	.data_reverse	= dead_onearg,		/* data_reverse */
83 
84 	.init_state	= dead_initstate,	/* init_state */
85 	.save_state	= dead_state,
86 	.restore_state	= dead_state,
87 
88 	.epp_write_data	= dead_write,		/* epp */
89 	.epp_read_data	= dead_read,
90 	.epp_write_addr	= dead_write,
91 	.epp_read_addr	= dead_read,
92 
93 	.ecp_write_data	= dead_write,		/* ecp */
94 	.ecp_read_data	= dead_read,
95 	.ecp_write_addr	= dead_write,
96 
97 	.compat_write_data	= dead_write,	/* compat */
98 	.nibble_read_data	= dead_read,	/* nibble */
99 	.byte_read_data		= dead_read,	/* byte */
100 
101 	.owner		= NULL,
102 };
103 
104 static struct device_type parport_device_type = {
105 	.name = "parport",
106 };
107 
108 static int is_parport(struct device *dev)
109 {
110 	return dev->type == &parport_device_type;
111 }
112 
113 static int parport_probe(struct device *dev)
114 {
115 	struct parport_driver *drv;
116 
117 	if (is_parport(dev))
118 		return -ENODEV;
119 
120 	drv = to_parport_driver(dev->driver);
121 	if (!drv->probe) {
122 		/* if driver has not defined a custom probe */
123 		struct pardevice *par_dev = to_pardevice(dev);
124 
125 		if (strcmp(par_dev->name, drv->name))
126 			return -ENODEV;
127 		return 0;
128 	}
129 	/* if driver defined its own probe */
130 	return drv->probe(to_pardevice(dev));
131 }
132 
133 static struct bus_type parport_bus_type = {
134 	.name = "parport",
135 	.probe = parport_probe,
136 };
137 
138 int parport_bus_init(void)
139 {
140 	int retval;
141 
142 	retval = bus_register(&parport_bus_type);
143 	if (retval)
144 		return retval;
145 	daisy_drv_init();
146 
147 	return 0;
148 }
149 
150 void parport_bus_exit(void)
151 {
152 	daisy_drv_exit();
153 	bus_unregister(&parport_bus_type);
154 }
155 
156 /*
157  * iterates through all the drivers registered with the bus and sends the port
158  * details to the match_port callback of the driver, so that the driver can
159  * know about the new port that just registered with the bus and decide if it
160  * wants to use this new port.
161  */
162 static int driver_check(struct device_driver *dev_drv, void *_port)
163 {
164 	struct parport *port = _port;
165 	struct parport_driver *drv = to_parport_driver(dev_drv);
166 
167 	if (drv->match_port)
168 		drv->match_port(port);
169 	return 0;
170 }
171 
172 /* Call attach(port) for each registered driver. */
173 static void attach_driver_chain(struct parport *port)
174 {
175 	/* caller has exclusive registration_lock */
176 	struct parport_driver *drv;
177 
178 	list_for_each_entry(drv, &drivers, list)
179 		drv->attach(port);
180 
181 	/*
182 	 * call the driver_check function of the drivers registered in
183 	 * new device model
184 	 */
185 
186 	bus_for_each_drv(&parport_bus_type, NULL, port, driver_check);
187 }
188 
189 static int driver_detach(struct device_driver *_drv, void *_port)
190 {
191 	struct parport *port = _port;
192 	struct parport_driver *drv = to_parport_driver(_drv);
193 
194 	if (drv->detach)
195 		drv->detach(port);
196 	return 0;
197 }
198 
199 /* Call detach(port) for each registered driver. */
200 static void detach_driver_chain(struct parport *port)
201 {
202 	struct parport_driver *drv;
203 	/* caller has exclusive registration_lock */
204 	list_for_each_entry(drv, &drivers, list)
205 		drv->detach(port);
206 
207 	/*
208 	 * call the detach function of the drivers registered in
209 	 * new device model
210 	 */
211 
212 	bus_for_each_drv(&parport_bus_type, NULL, port, driver_detach);
213 }
214 
215 /* Ask kmod for some lowlevel drivers. */
216 static void get_lowlevel_driver(void)
217 {
218 	/*
219 	 * There is no actual module called this: you should set
220 	 * up an alias for modutils.
221 	 */
222 	request_module("parport_lowlevel");
223 }
224 
225 /*
226  * iterates through all the devices connected to the bus and sends the device
227  * details to the match_port callback of the driver, so that the driver can
228  * know what are all the ports that are connected to the bus and choose the
229  * port to which it wants to register its device.
230  */
231 static int port_check(struct device *dev, void *dev_drv)
232 {
233 	struct parport_driver *drv = dev_drv;
234 
235 	/* only send ports, do not send other devices connected to bus */
236 	if (is_parport(dev))
237 		drv->match_port(to_parport_dev(dev));
238 	return 0;
239 }
240 
241 /**
242  *	parport_register_driver - register a parallel port device driver
243  *	@drv: structure describing the driver
244  *	@owner: owner module of drv
245  *	@mod_name: module name string
246  *
247  *	This can be called by a parallel port device driver in order
248  *	to receive notifications about ports being found in the
249  *	system, as well as ports no longer available.
250  *
251  *	If devmodel is true then the new device model is used
252  *	for registration.
253  *
254  *	The @drv structure is allocated by the caller and must not be
255  *	deallocated until after calling parport_unregister_driver().
256  *
257  *	If using the non device model:
258  *	The driver's attach() function may block.  The port that
259  *	attach() is given will be valid for the duration of the
260  *	callback, but if the driver wants to take a copy of the
261  *	pointer it must call parport_get_port() to do so.  Calling
262  *	parport_register_device() on that port will do this for you.
263  *
264  *	The driver's detach() function may block.  The port that
265  *	detach() is given will be valid for the duration of the
266  *	callback, but if the driver wants to take a copy of the
267  *	pointer it must call parport_get_port() to do so.
268  *
269  *
270  *	Returns 0 on success. The non device model will always succeeds.
271  *	but the new device model can fail and will return the error code.
272  **/
273 
274 int __parport_register_driver(struct parport_driver *drv, struct module *owner,
275 			      const char *mod_name)
276 {
277 	if (list_empty(&portlist))
278 		get_lowlevel_driver();
279 
280 	if (drv->devmodel) {
281 		/* using device model */
282 		int ret;
283 
284 		/* initialize common driver fields */
285 		drv->driver.name = drv->name;
286 		drv->driver.bus = &parport_bus_type;
287 		drv->driver.owner = owner;
288 		drv->driver.mod_name = mod_name;
289 		ret = driver_register(&drv->driver);
290 		if (ret)
291 			return ret;
292 
293 		mutex_lock(&registration_lock);
294 		if (drv->match_port)
295 			bus_for_each_dev(&parport_bus_type, NULL, drv,
296 					 port_check);
297 		mutex_unlock(&registration_lock);
298 	} else {
299 		struct parport *port;
300 
301 		drv->devmodel = false;
302 
303 		mutex_lock(&registration_lock);
304 		list_for_each_entry(port, &portlist, list)
305 			drv->attach(port);
306 		list_add(&drv->list, &drivers);
307 		mutex_unlock(&registration_lock);
308 	}
309 
310 	return 0;
311 }
312 EXPORT_SYMBOL(__parport_register_driver);
313 
314 static int port_detach(struct device *dev, void *_drv)
315 {
316 	struct parport_driver *drv = _drv;
317 
318 	if (is_parport(dev) && drv->detach)
319 		drv->detach(to_parport_dev(dev));
320 
321 	return 0;
322 }
323 
324 /**
325  *	parport_unregister_driver - deregister a parallel port device driver
326  *	@drv: structure describing the driver that was given to
327  *	      parport_register_driver()
328  *
329  *	This should be called by a parallel port device driver that
330  *	has registered itself using parport_register_driver() when it
331  *	is about to be unloaded.
332  *
333  *	When it returns, the driver's attach() routine will no longer
334  *	be called, and for each port that attach() was called for, the
335  *	detach() routine will have been called.
336  *
337  *	All the driver's attach() and detach() calls are guaranteed to have
338  *	finished by the time this function returns.
339  **/
340 
341 void parport_unregister_driver(struct parport_driver *drv)
342 {
343 	struct parport *port;
344 
345 	mutex_lock(&registration_lock);
346 	if (drv->devmodel) {
347 		bus_for_each_dev(&parport_bus_type, NULL, drv, port_detach);
348 		driver_unregister(&drv->driver);
349 	} else {
350 		list_del_init(&drv->list);
351 		list_for_each_entry(port, &portlist, list)
352 			drv->detach(port);
353 	}
354 	mutex_unlock(&registration_lock);
355 }
356 EXPORT_SYMBOL(parport_unregister_driver);
357 
358 static void free_port(struct device *dev)
359 {
360 	int d;
361 	struct parport *port = to_parport_dev(dev);
362 
363 	spin_lock(&full_list_lock);
364 	list_del(&port->full_list);
365 	spin_unlock(&full_list_lock);
366 	for (d = 0; d < 5; d++) {
367 		kfree(port->probe_info[d].class_name);
368 		kfree(port->probe_info[d].mfr);
369 		kfree(port->probe_info[d].model);
370 		kfree(port->probe_info[d].cmdset);
371 		kfree(port->probe_info[d].description);
372 	}
373 
374 	kfree(port->name);
375 	kfree(port);
376 }
377 
378 /**
379  *	parport_get_port - increment a port's reference count
380  *	@port: the port
381  *
382  *	This ensures that a struct parport pointer remains valid
383  *	until the matching parport_put_port() call.
384  **/
385 
386 struct parport *parport_get_port(struct parport *port)
387 {
388 	struct device *dev = get_device(&port->bus_dev);
389 
390 	return to_parport_dev(dev);
391 }
392 EXPORT_SYMBOL(parport_get_port);
393 
394 void parport_del_port(struct parport *port)
395 {
396 	device_unregister(&port->bus_dev);
397 }
398 EXPORT_SYMBOL(parport_del_port);
399 
400 /**
401  *	parport_put_port - decrement a port's reference count
402  *	@port: the port
403  *
404  *	This should be called once for each call to parport_get_port(),
405  *	once the port is no longer needed. When the reference count reaches
406  *	zero (port is no longer used), free_port is called.
407  **/
408 
409 void parport_put_port(struct parport *port)
410 {
411 	put_device(&port->bus_dev);
412 }
413 EXPORT_SYMBOL(parport_put_port);
414 
415 /**
416  *	parport_register_port - register a parallel port
417  *	@base: base I/O address
418  *	@irq: IRQ line
419  *	@dma: DMA channel
420  *	@ops: pointer to the port driver's port operations structure
421  *
422  *	When a parallel port (lowlevel) driver finds a port that
423  *	should be made available to parallel port device drivers, it
424  *	should call parport_register_port().  The @base, @irq, and
425  *	@dma parameters are for the convenience of port drivers, and
426  *	for ports where they aren't meaningful needn't be set to
427  *	anything special.  They can be altered afterwards by adjusting
428  *	the relevant members of the parport structure that is returned
429  *	and represents the port.  They should not be tampered with
430  *	after calling parport_announce_port, however.
431  *
432  *	If there are parallel port device drivers in the system that
433  *	have registered themselves using parport_register_driver(),
434  *	they are not told about the port at this time; that is done by
435  *	parport_announce_port().
436  *
437  *	The @ops structure is allocated by the caller, and must not be
438  *	deallocated before calling parport_remove_port().
439  *
440  *	If there is no memory to allocate a new parport structure,
441  *	this function will return %NULL.
442  **/
443 
444 struct parport *parport_register_port(unsigned long base, int irq, int dma,
445 				      struct parport_operations *ops)
446 {
447 	struct list_head *l;
448 	struct parport *tmp;
449 	int num;
450 	int device;
451 	char *name;
452 	int ret;
453 
454 	tmp = kzalloc(sizeof(struct parport), GFP_KERNEL);
455 	if (!tmp)
456 		return NULL;
457 
458 	/* Init our structure */
459 	tmp->base = base;
460 	tmp->irq = irq;
461 	tmp->dma = dma;
462 	tmp->muxport = tmp->daisy = tmp->muxsel = -1;
463 	tmp->modes = 0;
464 	INIT_LIST_HEAD(&tmp->list);
465 	tmp->devices = tmp->cad = NULL;
466 	tmp->flags = 0;
467 	tmp->ops = ops;
468 	tmp->physport = tmp;
469 	memset(tmp->probe_info, 0, 5 * sizeof(struct parport_device_info));
470 	rwlock_init(&tmp->cad_lock);
471 	spin_lock_init(&tmp->waitlist_lock);
472 	spin_lock_init(&tmp->pardevice_lock);
473 	tmp->ieee1284.mode = IEEE1284_MODE_COMPAT;
474 	tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
475 	sema_init(&tmp->ieee1284.irq, 0);
476 	tmp->spintime = parport_default_spintime;
477 	atomic_set(&tmp->ref_count, 1);
478 	INIT_LIST_HEAD(&tmp->full_list);
479 
480 	name = kmalloc(15, GFP_KERNEL);
481 	if (!name) {
482 		kfree(tmp);
483 		return NULL;
484 	}
485 	/* Search for the lowest free parport number. */
486 
487 	spin_lock(&full_list_lock);
488 	for (l = all_ports.next, num = 0; l != &all_ports; l = l->next, num++) {
489 		struct parport *p = list_entry(l, struct parport, full_list);
490 		if (p->number != num)
491 			break;
492 	}
493 	tmp->portnum = tmp->number = num;
494 	list_add_tail(&tmp->full_list, l);
495 	spin_unlock(&full_list_lock);
496 
497 	/*
498 	 * Now that the portnum is known finish doing the Init.
499 	 */
500 	sprintf(name, "parport%d", tmp->portnum = tmp->number);
501 	tmp->name = name;
502 	tmp->bus_dev.bus = &parport_bus_type;
503 	tmp->bus_dev.release = free_port;
504 	dev_set_name(&tmp->bus_dev, name);
505 	tmp->bus_dev.type = &parport_device_type;
506 
507 	for (device = 0; device < 5; device++)
508 		/* assume the worst */
509 		tmp->probe_info[device].class = PARPORT_CLASS_LEGACY;
510 
511 	tmp->waithead = tmp->waittail = NULL;
512 
513 	ret = device_register(&tmp->bus_dev);
514 	if (ret) {
515 		put_device(&tmp->bus_dev);
516 		return NULL;
517 	}
518 
519 	return tmp;
520 }
521 EXPORT_SYMBOL(parport_register_port);
522 
523 /**
524  *	parport_announce_port - tell device drivers about a parallel port
525  *	@port: parallel port to announce
526  *
527  *	After a port driver has registered a parallel port with
528  *	parport_register_port, and performed any necessary
529  *	initialisation or adjustments, it should call
530  *	parport_announce_port() in order to notify all device drivers
531  *	that have called parport_register_driver().  Their attach()
532  *	functions will be called, with @port as the parameter.
533  **/
534 
535 void parport_announce_port(struct parport *port)
536 {
537 	int i;
538 
539 #ifdef CONFIG_PARPORT_1284
540 	/* Analyse the IEEE1284.3 topology of the port. */
541 	parport_daisy_init(port);
542 #endif
543 
544 	if (!port->dev)
545 		printk(KERN_WARNING "%s: fix this legacy no-device port driver!\n",
546 		       port->name);
547 
548 	parport_proc_register(port);
549 	mutex_lock(&registration_lock);
550 	spin_lock_irq(&parportlist_lock);
551 	list_add_tail(&port->list, &portlist);
552 	for (i = 1; i < 3; i++) {
553 		struct parport *slave = port->slaves[i-1];
554 		if (slave)
555 			list_add_tail(&slave->list, &portlist);
556 	}
557 	spin_unlock_irq(&parportlist_lock);
558 
559 	/* Let drivers know that new port(s) has arrived. */
560 	attach_driver_chain(port);
561 	for (i = 1; i < 3; i++) {
562 		struct parport *slave = port->slaves[i-1];
563 		if (slave)
564 			attach_driver_chain(slave);
565 	}
566 	mutex_unlock(&registration_lock);
567 }
568 EXPORT_SYMBOL(parport_announce_port);
569 
570 /**
571  *	parport_remove_port - deregister a parallel port
572  *	@port: parallel port to deregister
573  *
574  *	When a parallel port driver is forcibly unloaded, or a
575  *	parallel port becomes inaccessible, the port driver must call
576  *	this function in order to deal with device drivers that still
577  *	want to use it.
578  *
579  *	The parport structure associated with the port has its
580  *	operations structure replaced with one containing 'null'
581  *	operations that return errors or just don't do anything.
582  *
583  *	Any drivers that have registered themselves using
584  *	parport_register_driver() are notified that the port is no
585  *	longer accessible by having their detach() routines called
586  *	with @port as the parameter.
587  **/
588 
589 void parport_remove_port(struct parport *port)
590 {
591 	int i;
592 
593 	mutex_lock(&registration_lock);
594 
595 	/* Spread the word. */
596 	detach_driver_chain(port);
597 
598 #ifdef CONFIG_PARPORT_1284
599 	/* Forget the IEEE1284.3 topology of the port. */
600 	parport_daisy_fini(port);
601 	for (i = 1; i < 3; i++) {
602 		struct parport *slave = port->slaves[i-1];
603 		if (!slave)
604 			continue;
605 		detach_driver_chain(slave);
606 		parport_daisy_fini(slave);
607 	}
608 #endif
609 
610 	port->ops = &dead_ops;
611 	spin_lock(&parportlist_lock);
612 	list_del_init(&port->list);
613 	for (i = 1; i < 3; i++) {
614 		struct parport *slave = port->slaves[i-1];
615 		if (slave)
616 			list_del_init(&slave->list);
617 	}
618 	spin_unlock(&parportlist_lock);
619 
620 	mutex_unlock(&registration_lock);
621 
622 	parport_proc_unregister(port);
623 
624 	for (i = 1; i < 3; i++) {
625 		struct parport *slave = port->slaves[i-1];
626 		if (slave)
627 			parport_put_port(slave);
628 	}
629 }
630 EXPORT_SYMBOL(parport_remove_port);
631 
632 /**
633  *	parport_register_device - register a device on a parallel port
634  *	@port: port to which the device is attached
635  *	@name: a name to refer to the device
636  *	@pf: preemption callback
637  *	@kf: kick callback (wake-up)
638  *	@irq_func: interrupt handler
639  *	@flags: registration flags
640  *	@handle: data for callback functions
641  *
642  *	This function, called by parallel port device drivers,
643  *	declares that a device is connected to a port, and tells the
644  *	system all it needs to know.
645  *
646  *	The @name is allocated by the caller and must not be
647  *	deallocated until the caller calls @parport_unregister_device
648  *	for that device.
649  *
650  *	The preemption callback function, @pf, is called when this
651  *	device driver has claimed access to the port but another
652  *	device driver wants to use it.  It is given @handle as its
653  *	parameter, and should return zero if it is willing for the
654  *	system to release the port to another driver on its behalf.
655  *	If it wants to keep control of the port it should return
656  *	non-zero, and no action will be taken.  It is good manners for
657  *	the driver to try to release the port at the earliest
658  *	opportunity after its preemption callback rejects a preemption
659  *	attempt.  Note that if a preemption callback is happy for
660  *	preemption to go ahead, there is no need to release the port;
661  *	it is done automatically.  This function may not block, as it
662  *	may be called from interrupt context.  If the device driver
663  *	does not support preemption, @pf can be %NULL.
664  *
665  *	The wake-up ("kick") callback function, @kf, is called when
666  *	the port is available to be claimed for exclusive access; that
667  *	is, parport_claim() is guaranteed to succeed when called from
668  *	inside the wake-up callback function.  If the driver wants to
669  *	claim the port it should do so; otherwise, it need not take
670  *	any action.  This function may not block, as it may be called
671  *	from interrupt context.  If the device driver does not want to
672  *	be explicitly invited to claim the port in this way, @kf can
673  *	be %NULL.
674  *
675  *	The interrupt handler, @irq_func, is called when an interrupt
676  *	arrives from the parallel port.  Note that if a device driver
677  *	wants to use interrupts it should use parport_enable_irq(),
678  *	and can also check the irq member of the parport structure
679  *	representing the port.
680  *
681  *	The parallel port (lowlevel) driver is the one that has called
682  *	request_irq() and whose interrupt handler is called first.
683  *	This handler does whatever needs to be done to the hardware to
684  *	acknowledge the interrupt (for PC-style ports there is nothing
685  *	special to be done).  It then tells the IEEE 1284 code about
686  *	the interrupt, which may involve reacting to an IEEE 1284
687  *	event depending on the current IEEE 1284 phase.  After this,
688  *	it calls @irq_func.  Needless to say, @irq_func will be called
689  *	from interrupt context, and may not block.
690  *
691  *	The %PARPORT_DEV_EXCL flag is for preventing port sharing, and
692  *	so should only be used when sharing the port with other device
693  *	drivers is impossible and would lead to incorrect behaviour.
694  *	Use it sparingly!  Normally, @flags will be zero.
695  *
696  *	This function returns a pointer to a structure that represents
697  *	the device on the port, or %NULL if there is not enough memory
698  *	to allocate space for that structure.
699  **/
700 
701 struct pardevice *
702 parport_register_device(struct parport *port, const char *name,
703 			int (*pf)(void *), void (*kf)(void *),
704 			void (*irq_func)(void *),
705 			int flags, void *handle)
706 {
707 	struct pardevice *tmp;
708 
709 	if (port->physport->flags & PARPORT_FLAG_EXCL) {
710 		/* An exclusive device is registered. */
711 		printk(KERN_DEBUG "%s: no more devices allowed\n",
712 			port->name);
713 		return NULL;
714 	}
715 
716 	if (flags & PARPORT_DEV_LURK) {
717 		if (!pf || !kf) {
718 			printk(KERN_INFO "%s: refused to register lurking device (%s) without callbacks\n", port->name, name);
719 			return NULL;
720 		}
721 	}
722 
723 	if (flags & PARPORT_DEV_EXCL) {
724 		if (port->physport->devices) {
725 			/*
726 			 * If a device is already registered and this new
727 			 * device wants exclusive access, then no need to
728 			 * continue as we can not grant exclusive access to
729 			 * this device.
730 			 */
731 			pr_err("%s: cannot grant exclusive access for device %s\n",
732 			       port->name, name);
733 			return NULL;
734 		}
735 	}
736 
737 	/*
738 	 * We up our own module reference count, and that of the port
739 	 * on which a device is to be registered, to ensure that
740 	 * neither of us gets unloaded while we sleep in (e.g.)
741 	 * kmalloc.
742 	 */
743 	if (!try_module_get(port->ops->owner))
744 		return NULL;
745 
746 	parport_get_port(port);
747 
748 	tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL);
749 	if (!tmp)
750 		goto out;
751 
752 	tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL);
753 	if (!tmp->state)
754 		goto out_free_pardevice;
755 
756 	tmp->name = name;
757 	tmp->port = port;
758 	tmp->daisy = -1;
759 	tmp->preempt = pf;
760 	tmp->wakeup = kf;
761 	tmp->private = handle;
762 	tmp->flags = flags;
763 	tmp->irq_func = irq_func;
764 	tmp->waiting = 0;
765 	tmp->timeout = 5 * HZ;
766 	tmp->devmodel = false;
767 
768 	/* Chain this onto the list */
769 	tmp->prev = NULL;
770 	/*
771 	 * This function must not run from an irq handler so we don' t need
772 	 * to clear irq on the local CPU. -arca
773 	 */
774 	spin_lock(&port->physport->pardevice_lock);
775 
776 	if (flags & PARPORT_DEV_EXCL) {
777 		if (port->physport->devices) {
778 			spin_unlock(&port->physport->pardevice_lock);
779 			printk(KERN_DEBUG
780 				"%s: cannot grant exclusive access for device %s\n",
781 				port->name, name);
782 			goto out_free_all;
783 		}
784 		port->flags |= PARPORT_FLAG_EXCL;
785 	}
786 
787 	tmp->next = port->physport->devices;
788 	wmb(); /*
789 		* Make sure that tmp->next is written before it's
790 		* added to the list; see comments marked 'no locking
791 		* required'
792 		*/
793 	if (port->physport->devices)
794 		port->physport->devices->prev = tmp;
795 	port->physport->devices = tmp;
796 	spin_unlock(&port->physport->pardevice_lock);
797 
798 	init_waitqueue_head(&tmp->wait_q);
799 	tmp->timeslice = parport_default_timeslice;
800 	tmp->waitnext = tmp->waitprev = NULL;
801 
802 	/*
803 	 * This has to be run as last thing since init_state may need other
804 	 * pardevice fields. -arca
805 	 */
806 	port->ops->init_state(tmp, tmp->state);
807 	if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) {
808 		port->proc_device = tmp;
809 		parport_device_proc_register(tmp);
810 	}
811 	return tmp;
812 
813  out_free_all:
814 	kfree(tmp->state);
815  out_free_pardevice:
816 	kfree(tmp);
817  out:
818 	parport_put_port(port);
819 	module_put(port->ops->owner);
820 
821 	return NULL;
822 }
823 EXPORT_SYMBOL(parport_register_device);
824 
825 static void free_pardevice(struct device *dev)
826 {
827 	struct pardevice *par_dev = to_pardevice(dev);
828 
829 	kfree(par_dev->name);
830 	kfree(par_dev);
831 }
832 
833 struct pardevice *
834 parport_register_dev_model(struct parport *port, const char *name,
835 			   const struct pardev_cb *par_dev_cb, int id)
836 {
837 	struct pardevice *par_dev;
838 	int ret;
839 	char *devname;
840 
841 	if (port->physport->flags & PARPORT_FLAG_EXCL) {
842 		/* An exclusive device is registered. */
843 		pr_err("%s: no more devices allowed\n", port->name);
844 		return NULL;
845 	}
846 
847 	if (par_dev_cb->flags & PARPORT_DEV_LURK) {
848 		if (!par_dev_cb->preempt || !par_dev_cb->wakeup) {
849 			pr_info("%s: refused to register lurking device (%s) without callbacks\n",
850 				port->name, name);
851 			return NULL;
852 		}
853 	}
854 
855 	if (par_dev_cb->flags & PARPORT_DEV_EXCL) {
856 		if (port->physport->devices) {
857 			/*
858 			 * If a device is already registered and this new
859 			 * device wants exclusive access, then no need to
860 			 * continue as we can not grant exclusive access to
861 			 * this device.
862 			 */
863 			pr_err("%s: cannot grant exclusive access for device %s\n",
864 			       port->name, name);
865 			return NULL;
866 		}
867 	}
868 
869 	if (!try_module_get(port->ops->owner))
870 		return NULL;
871 
872 	parport_get_port(port);
873 
874 	par_dev = kzalloc(sizeof(*par_dev), GFP_KERNEL);
875 	if (!par_dev)
876 		goto err_put_port;
877 
878 	par_dev->state = kzalloc(sizeof(*par_dev->state), GFP_KERNEL);
879 	if (!par_dev->state)
880 		goto err_put_par_dev;
881 
882 	devname = kstrdup(name, GFP_KERNEL);
883 	if (!devname)
884 		goto err_free_par_dev;
885 
886 	par_dev->name = devname;
887 	par_dev->port = port;
888 	par_dev->daisy = -1;
889 	par_dev->preempt = par_dev_cb->preempt;
890 	par_dev->wakeup = par_dev_cb->wakeup;
891 	par_dev->private = par_dev_cb->private;
892 	par_dev->flags = par_dev_cb->flags;
893 	par_dev->irq_func = par_dev_cb->irq_func;
894 	par_dev->waiting = 0;
895 	par_dev->timeout = 5 * HZ;
896 
897 	par_dev->dev.parent = &port->bus_dev;
898 	par_dev->dev.bus = &parport_bus_type;
899 	ret = dev_set_name(&par_dev->dev, "%s.%d", devname, id);
900 	if (ret)
901 		goto err_free_devname;
902 	par_dev->dev.release = free_pardevice;
903 	par_dev->devmodel = true;
904 	ret = device_register(&par_dev->dev);
905 	if (ret) {
906 		put_device(&par_dev->dev);
907 		goto err_put_port;
908 	}
909 
910 	/* Chain this onto the list */
911 	par_dev->prev = NULL;
912 	/*
913 	 * This function must not run from an irq handler so we don' t need
914 	 * to clear irq on the local CPU. -arca
915 	 */
916 	spin_lock(&port->physport->pardevice_lock);
917 
918 	if (par_dev_cb->flags & PARPORT_DEV_EXCL) {
919 		if (port->physport->devices) {
920 			spin_unlock(&port->physport->pardevice_lock);
921 			pr_debug("%s: cannot grant exclusive access for device %s\n",
922 				 port->name, name);
923 			device_unregister(&par_dev->dev);
924 			goto err_put_port;
925 		}
926 		port->flags |= PARPORT_FLAG_EXCL;
927 	}
928 
929 	par_dev->next = port->physport->devices;
930 	wmb();	/*
931 		 * Make sure that tmp->next is written before it's
932 		 * added to the list; see comments marked 'no locking
933 		 * required'
934 		 */
935 	if (port->physport->devices)
936 		port->physport->devices->prev = par_dev;
937 	port->physport->devices = par_dev;
938 	spin_unlock(&port->physport->pardevice_lock);
939 
940 	init_waitqueue_head(&par_dev->wait_q);
941 	par_dev->timeslice = parport_default_timeslice;
942 	par_dev->waitnext = NULL;
943 	par_dev->waitprev = NULL;
944 
945 	/*
946 	 * This has to be run as last thing since init_state may need other
947 	 * pardevice fields. -arca
948 	 */
949 	port->ops->init_state(par_dev, par_dev->state);
950 	if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) {
951 		port->proc_device = par_dev;
952 		parport_device_proc_register(par_dev);
953 	}
954 
955 	return par_dev;
956 
957 err_free_devname:
958 	kfree(devname);
959 err_free_par_dev:
960 	kfree(par_dev->state);
961 err_put_par_dev:
962 	if (!par_dev->devmodel)
963 		kfree(par_dev);
964 err_put_port:
965 	parport_put_port(port);
966 	module_put(port->ops->owner);
967 
968 	return NULL;
969 }
970 EXPORT_SYMBOL(parport_register_dev_model);
971 
972 /**
973  *	parport_unregister_device - deregister a device on a parallel port
974  *	@dev: pointer to structure representing device
975  *
976  *	This undoes the effect of parport_register_device().
977  **/
978 
979 void parport_unregister_device(struct pardevice *dev)
980 {
981 	struct parport *port;
982 
983 #ifdef PARPORT_PARANOID
984 	if (!dev) {
985 		printk(KERN_ERR "parport_unregister_device: passed NULL\n");
986 		return;
987 	}
988 #endif
989 
990 	port = dev->port->physport;
991 
992 	if (port->proc_device == dev) {
993 		port->proc_device = NULL;
994 		clear_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags);
995 		parport_device_proc_unregister(dev);
996 	}
997 
998 	if (port->cad == dev) {
999 		printk(KERN_DEBUG "%s: %s forgot to release port\n",
1000 		       port->name, dev->name);
1001 		parport_release(dev);
1002 	}
1003 
1004 	spin_lock(&port->pardevice_lock);
1005 	if (dev->next)
1006 		dev->next->prev = dev->prev;
1007 	if (dev->prev)
1008 		dev->prev->next = dev->next;
1009 	else
1010 		port->devices = dev->next;
1011 
1012 	if (dev->flags & PARPORT_DEV_EXCL)
1013 		port->flags &= ~PARPORT_FLAG_EXCL;
1014 
1015 	spin_unlock(&port->pardevice_lock);
1016 
1017 	/*
1018 	 * Make sure we haven't left any pointers around in the wait
1019 	 * list.
1020 	 */
1021 	spin_lock_irq(&port->waitlist_lock);
1022 	if (dev->waitprev || dev->waitnext || port->waithead == dev) {
1023 		if (dev->waitprev)
1024 			dev->waitprev->waitnext = dev->waitnext;
1025 		else
1026 			port->waithead = dev->waitnext;
1027 		if (dev->waitnext)
1028 			dev->waitnext->waitprev = dev->waitprev;
1029 		else
1030 			port->waittail = dev->waitprev;
1031 	}
1032 	spin_unlock_irq(&port->waitlist_lock);
1033 
1034 	kfree(dev->state);
1035 	if (dev->devmodel)
1036 		device_unregister(&dev->dev);
1037 	else
1038 		kfree(dev);
1039 
1040 	module_put(port->ops->owner);
1041 	parport_put_port(port);
1042 }
1043 EXPORT_SYMBOL(parport_unregister_device);
1044 
1045 /**
1046  *	parport_find_number - find a parallel port by number
1047  *	@number: parallel port number
1048  *
1049  *	This returns the parallel port with the specified number, or
1050  *	%NULL if there is none.
1051  *
1052  *	There is an implicit parport_get_port() done already; to throw
1053  *	away the reference to the port that parport_find_number()
1054  *	gives you, use parport_put_port().
1055  */
1056 
1057 struct parport *parport_find_number(int number)
1058 {
1059 	struct parport *port, *result = NULL;
1060 
1061 	if (list_empty(&portlist))
1062 		get_lowlevel_driver();
1063 
1064 	spin_lock(&parportlist_lock);
1065 	list_for_each_entry(port, &portlist, list) {
1066 		if (port->number == number) {
1067 			result = parport_get_port(port);
1068 			break;
1069 		}
1070 	}
1071 	spin_unlock(&parportlist_lock);
1072 	return result;
1073 }
1074 EXPORT_SYMBOL(parport_find_number);
1075 
1076 /**
1077  *	parport_find_base - find a parallel port by base address
1078  *	@base: base I/O address
1079  *
1080  *	This returns the parallel port with the specified base
1081  *	address, or %NULL if there is none.
1082  *
1083  *	There is an implicit parport_get_port() done already; to throw
1084  *	away the reference to the port that parport_find_base()
1085  *	gives you, use parport_put_port().
1086  */
1087 
1088 struct parport *parport_find_base(unsigned long base)
1089 {
1090 	struct parport *port, *result = NULL;
1091 
1092 	if (list_empty(&portlist))
1093 		get_lowlevel_driver();
1094 
1095 	spin_lock(&parportlist_lock);
1096 	list_for_each_entry(port, &portlist, list) {
1097 		if (port->base == base) {
1098 			result = parport_get_port(port);
1099 			break;
1100 		}
1101 	}
1102 	spin_unlock(&parportlist_lock);
1103 	return result;
1104 }
1105 EXPORT_SYMBOL(parport_find_base);
1106 
1107 /**
1108  *	parport_claim - claim access to a parallel port device
1109  *	@dev: pointer to structure representing a device on the port
1110  *
1111  *	This function will not block and so can be used from interrupt
1112  *	context.  If parport_claim() succeeds in claiming access to
1113  *	the port it returns zero and the port is available to use.  It
1114  *	may fail (returning non-zero) if the port is in use by another
1115  *	driver and that driver is not willing to relinquish control of
1116  *	the port.
1117  **/
1118 
1119 int parport_claim(struct pardevice *dev)
1120 {
1121 	struct pardevice *oldcad;
1122 	struct parport *port = dev->port->physport;
1123 	unsigned long flags;
1124 
1125 	if (port->cad == dev) {
1126 		printk(KERN_INFO "%s: %s already owner\n",
1127 		       dev->port->name,dev->name);
1128 		return 0;
1129 	}
1130 
1131 	/* Preempt any current device */
1132 	write_lock_irqsave(&port->cad_lock, flags);
1133 	oldcad = port->cad;
1134 	if (oldcad) {
1135 		if (oldcad->preempt) {
1136 			if (oldcad->preempt(oldcad->private))
1137 				goto blocked;
1138 			port->ops->save_state(port, dev->state);
1139 		} else
1140 			goto blocked;
1141 
1142 		if (port->cad != oldcad) {
1143 			/*
1144 			 * I think we'll actually deadlock rather than
1145 			 * get here, but just in case..
1146 			 */
1147 			printk(KERN_WARNING
1148 			       "%s: %s released port when preempted!\n",
1149 			       port->name, oldcad->name);
1150 			if (port->cad)
1151 				goto blocked;
1152 		}
1153 	}
1154 
1155 	/* Can't fail from now on, so mark ourselves as no longer waiting.  */
1156 	if (dev->waiting & 1) {
1157 		dev->waiting = 0;
1158 
1159 		/* Take ourselves out of the wait list again.  */
1160 		spin_lock_irq(&port->waitlist_lock);
1161 		if (dev->waitprev)
1162 			dev->waitprev->waitnext = dev->waitnext;
1163 		else
1164 			port->waithead = dev->waitnext;
1165 		if (dev->waitnext)
1166 			dev->waitnext->waitprev = dev->waitprev;
1167 		else
1168 			port->waittail = dev->waitprev;
1169 		spin_unlock_irq(&port->waitlist_lock);
1170 		dev->waitprev = dev->waitnext = NULL;
1171 	}
1172 
1173 	/* Now we do the change of devices */
1174 	port->cad = dev;
1175 
1176 #ifdef CONFIG_PARPORT_1284
1177 	/* If it's a mux port, select it. */
1178 	if (dev->port->muxport >= 0) {
1179 		/* FIXME */
1180 		port->muxsel = dev->port->muxport;
1181 	}
1182 
1183 	/* If it's a daisy chain device, select it. */
1184 	if (dev->daisy >= 0) {
1185 		/* This could be lazier. */
1186 		if (!parport_daisy_select(port, dev->daisy,
1187 					   IEEE1284_MODE_COMPAT))
1188 			port->daisy = dev->daisy;
1189 	}
1190 #endif /* IEEE1284.3 support */
1191 
1192 	/* Restore control registers */
1193 	port->ops->restore_state(port, dev->state);
1194 	write_unlock_irqrestore(&port->cad_lock, flags);
1195 	dev->time = jiffies;
1196 	return 0;
1197 
1198 blocked:
1199 	/*
1200 	 * If this is the first time we tried to claim the port, register an
1201 	 * interest.  This is only allowed for devices sleeping in
1202 	 * parport_claim_or_block(), or those with a wakeup function.
1203 	 */
1204 
1205 	/* The cad_lock is still held for writing here */
1206 	if (dev->waiting & 2 || dev->wakeup) {
1207 		spin_lock(&port->waitlist_lock);
1208 		if (test_and_set_bit(0, &dev->waiting) == 0) {
1209 			/* First add ourselves to the end of the wait list. */
1210 			dev->waitnext = NULL;
1211 			dev->waitprev = port->waittail;
1212 			if (port->waittail) {
1213 				port->waittail->waitnext = dev;
1214 				port->waittail = dev;
1215 			} else
1216 				port->waithead = port->waittail = dev;
1217 		}
1218 		spin_unlock(&port->waitlist_lock);
1219 	}
1220 	write_unlock_irqrestore(&port->cad_lock, flags);
1221 	return -EAGAIN;
1222 }
1223 EXPORT_SYMBOL(parport_claim);
1224 
1225 /**
1226  *	parport_claim_or_block - claim access to a parallel port device
1227  *	@dev: pointer to structure representing a device on the port
1228  *
1229  *	This behaves like parport_claim(), but will block if necessary
1230  *	to wait for the port to be free.  A return value of 1
1231  *	indicates that it slept; 0 means that it succeeded without
1232  *	needing to sleep.  A negative error code indicates failure.
1233  **/
1234 
1235 int parport_claim_or_block(struct pardevice *dev)
1236 {
1237 	int r;
1238 
1239 	/*
1240 	 * Signal to parport_claim() that we can wait even without a
1241 	 * wakeup function.
1242 	 */
1243 	dev->waiting = 2;
1244 
1245 	/* Try to claim the port.  If this fails, we need to sleep.  */
1246 	r = parport_claim(dev);
1247 	if (r == -EAGAIN) {
1248 #ifdef PARPORT_DEBUG_SHARING
1249 		printk(KERN_DEBUG "%s: parport_claim() returned -EAGAIN\n", dev->name);
1250 #endif
1251 		/*
1252 		 * FIXME!!! Use the proper locking for dev->waiting,
1253 		 * and make this use the "wait_event_interruptible()"
1254 		 * interfaces. The cli/sti that used to be here
1255 		 * did nothing.
1256 		 *
1257 		 * See also parport_release()
1258 		 */
1259 
1260 		/*
1261 		 * If dev->waiting is clear now, an interrupt
1262 		 * gave us the port and we would deadlock if we slept.
1263 		 */
1264 		if (dev->waiting) {
1265 			wait_event_interruptible(dev->wait_q,
1266 						 !dev->waiting);
1267 			if (signal_pending(current))
1268 				return -EINTR;
1269 			r = 1;
1270 		} else {
1271 			r = 0;
1272 #ifdef PARPORT_DEBUG_SHARING
1273 			printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n",
1274 			       dev->name);
1275 #endif
1276 		}
1277 
1278 #ifdef PARPORT_DEBUG_SHARING
1279 		if (dev->port->physport->cad != dev)
1280 			printk(KERN_DEBUG "%s: exiting parport_claim_or_block but %s owns port!\n",
1281 			       dev->name, dev->port->physport->cad ?
1282 			       dev->port->physport->cad->name:"nobody");
1283 #endif
1284 	}
1285 	dev->waiting = 0;
1286 	return r;
1287 }
1288 EXPORT_SYMBOL(parport_claim_or_block);
1289 
1290 /**
1291  *	parport_release - give up access to a parallel port device
1292  *	@dev: pointer to structure representing parallel port device
1293  *
1294  *	This function cannot fail, but it should not be called without
1295  *	the port claimed.  Similarly, if the port is already claimed
1296  *	you should not try claiming it again.
1297  **/
1298 
1299 void parport_release(struct pardevice *dev)
1300 {
1301 	struct parport *port = dev->port->physport;
1302 	struct pardevice *pd;
1303 	unsigned long flags;
1304 
1305 	/* Make sure that dev is the current device */
1306 	write_lock_irqsave(&port->cad_lock, flags);
1307 	if (port->cad != dev) {
1308 		write_unlock_irqrestore(&port->cad_lock, flags);
1309 		printk(KERN_WARNING "%s: %s tried to release parport when not owner\n",
1310 		       port->name, dev->name);
1311 		return;
1312 	}
1313 
1314 #ifdef CONFIG_PARPORT_1284
1315 	/* If this is on a mux port, deselect it. */
1316 	if (dev->port->muxport >= 0) {
1317 		/* FIXME */
1318 		port->muxsel = -1;
1319 	}
1320 
1321 	/* If this is a daisy device, deselect it. */
1322 	if (dev->daisy >= 0) {
1323 		parport_daisy_deselect_all(port);
1324 		port->daisy = -1;
1325 	}
1326 #endif
1327 
1328 	port->cad = NULL;
1329 	write_unlock_irqrestore(&port->cad_lock, flags);
1330 
1331 	/* Save control registers */
1332 	port->ops->save_state(port, dev->state);
1333 
1334 	/*
1335 	 * If anybody is waiting, find out who's been there longest and
1336 	 * then wake them up. (Note: no locking required)
1337 	 */
1338 	/* !!! LOCKING IS NEEDED HERE */
1339 	for (pd = port->waithead; pd; pd = pd->waitnext) {
1340 		if (pd->waiting & 2) { /* sleeping in claim_or_block */
1341 			parport_claim(pd);
1342 			if (waitqueue_active(&pd->wait_q))
1343 				wake_up_interruptible(&pd->wait_q);
1344 			return;
1345 		} else if (pd->wakeup) {
1346 			pd->wakeup(pd->private);
1347 			if (dev->port->cad) /* racy but no matter */
1348 				return;
1349 		} else {
1350 			printk(KERN_ERR "%s: don't know how to wake %s\n", port->name, pd->name);
1351 		}
1352 	}
1353 
1354 	/*
1355 	 * Nobody was waiting, so walk the list to see if anyone is
1356 	 * interested in being woken up. (Note: no locking required)
1357 	 */
1358 	/* !!! LOCKING IS NEEDED HERE */
1359 	for (pd = port->devices; !port->cad && pd; pd = pd->next) {
1360 		if (pd->wakeup && pd != dev)
1361 			pd->wakeup(pd->private);
1362 	}
1363 }
1364 EXPORT_SYMBOL(parport_release);
1365 
1366 irqreturn_t parport_irq_handler(int irq, void *dev_id)
1367 {
1368 	struct parport *port = dev_id;
1369 
1370 	parport_generic_irq(port);
1371 
1372 	return IRQ_HANDLED;
1373 }
1374 EXPORT_SYMBOL(parport_irq_handler);
1375 
1376 MODULE_LICENSE("GPL");
1377