1612de10dSAdrian Bunk /*
21da177e4SLinus Torvalds * Parallel-port resource manager code.
31da177e4SLinus Torvalds *
41da177e4SLinus Torvalds * Authors: David Campbell <campbell@tirian.che.curtin.edu.au>
51da177e4SLinus Torvalds * Tim Waugh <tim@cyberelk.demon.co.uk>
61da177e4SLinus Torvalds * Jose Renau <renau@acm.org>
71da177e4SLinus Torvalds * Philip Blundell <philb@gnu.org>
81da177e4SLinus Torvalds * Andrea Arcangeli
91da177e4SLinus Torvalds *
101da177e4SLinus Torvalds * based on work by Grant Guenther <grant@torque.net>
111da177e4SLinus Torvalds * and Philip Blundell
121da177e4SLinus Torvalds *
131da177e4SLinus Torvalds * Any part of this program may be used in documents licensed under
141da177e4SLinus Torvalds * the GNU Free Documentation License, Version 1.1 or any later version
151da177e4SLinus Torvalds * published by the Free Software Foundation.
161da177e4SLinus Torvalds */
171da177e4SLinus Torvalds
181da177e4SLinus Torvalds #undef PARPORT_DEBUG_SHARING /* undef for production */
191da177e4SLinus Torvalds
201da177e4SLinus Torvalds #include <linux/module.h>
211da177e4SLinus Torvalds #include <linux/string.h>
221da177e4SLinus Torvalds #include <linux/threads.h>
231da177e4SLinus Torvalds #include <linux/parport.h>
241da177e4SLinus Torvalds #include <linux/delay.h>
251da177e4SLinus Torvalds #include <linux/errno.h>
261da177e4SLinus Torvalds #include <linux/interrupt.h>
271da177e4SLinus Torvalds #include <linux/ioport.h>
281da177e4SLinus Torvalds #include <linux/kernel.h>
291da177e4SLinus Torvalds #include <linux/slab.h>
30174cd4b1SIngo Molnar #include <linux/sched/signal.h>
311da177e4SLinus Torvalds #include <linux/kmod.h>
326fa45a22SSudip Mukherjee #include <linux/device.h>
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds #include <linux/spinlock.h>
3514cc3e2bSIngo Molnar #include <linux/mutex.h>
361da177e4SLinus Torvalds #include <asm/irq.h>
371da177e4SLinus Torvalds
381da177e4SLinus Torvalds #undef PARPORT_PARANOID
391da177e4SLinus Torvalds
401da177e4SLinus Torvalds #define PARPORT_DEFAULT_TIMESLICE (HZ/5)
411da177e4SLinus Torvalds
421da177e4SLinus Torvalds unsigned long parport_default_timeslice = PARPORT_DEFAULT_TIMESLICE;
431da177e4SLinus Torvalds int parport_default_spintime = DEFAULT_SPIN_TIME;
441da177e4SLinus Torvalds
451da177e4SLinus Torvalds static LIST_HEAD(portlist);
461da177e4SLinus Torvalds static DEFINE_SPINLOCK(parportlist_lock);
471da177e4SLinus Torvalds
481da177e4SLinus Torvalds /* list of all allocated ports, sorted by ->number */
491da177e4SLinus Torvalds static LIST_HEAD(all_ports);
501da177e4SLinus Torvalds static DEFINE_SPINLOCK(full_list_lock);
511da177e4SLinus Torvalds
521da177e4SLinus Torvalds static LIST_HEAD(drivers);
531da177e4SLinus Torvalds
5414cc3e2bSIngo Molnar static DEFINE_MUTEX(registration_lock);
551da177e4SLinus Torvalds
561da177e4SLinus Torvalds /* What you can do to a port that's gone away.. */
dead_write_lines(struct parport * p,unsigned char b)571da177e4SLinus Torvalds static void dead_write_lines(struct parport *p, unsigned char b){}
dead_read_lines(struct parport * p)581da177e4SLinus Torvalds static unsigned char dead_read_lines(struct parport *p) { return 0; }
dead_frob_lines(struct parport * p,unsigned char b,unsigned char c)591da177e4SLinus Torvalds static unsigned char dead_frob_lines(struct parport *p, unsigned char b,
601da177e4SLinus Torvalds unsigned char c) { return 0; }
dead_onearg(struct parport * p)611da177e4SLinus Torvalds static void dead_onearg(struct parport *p){}
dead_initstate(struct pardevice * d,struct parport_state * s)621da177e4SLinus Torvalds static void dead_initstate(struct pardevice *d, struct parport_state *s) { }
dead_state(struct parport * p,struct parport_state * s)631da177e4SLinus Torvalds static void dead_state(struct parport *p, struct parport_state *s) { }
dead_write(struct parport * p,const void * b,size_t l,int f)641da177e4SLinus Torvalds static size_t dead_write(struct parport *p, const void *b, size_t l, int f)
651da177e4SLinus Torvalds { return 0; }
dead_read(struct parport * p,void * b,size_t l,int f)661da177e4SLinus Torvalds static size_t dead_read(struct parport *p, void *b, size_t l, int f)
671da177e4SLinus Torvalds { return 0; }
681da177e4SLinus Torvalds static struct parport_operations dead_ops = {
691da177e4SLinus Torvalds .write_data = dead_write_lines, /* data */
701da177e4SLinus Torvalds .read_data = dead_read_lines,
711da177e4SLinus Torvalds
721da177e4SLinus Torvalds .write_control = dead_write_lines, /* control */
731da177e4SLinus Torvalds .read_control = dead_read_lines,
741da177e4SLinus Torvalds .frob_control = dead_frob_lines,
751da177e4SLinus Torvalds
761da177e4SLinus Torvalds .read_status = dead_read_lines, /* status */
771da177e4SLinus Torvalds
781da177e4SLinus Torvalds .enable_irq = dead_onearg, /* enable_irq */
791da177e4SLinus Torvalds .disable_irq = dead_onearg, /* disable_irq */
801da177e4SLinus Torvalds
811da177e4SLinus Torvalds .data_forward = dead_onearg, /* data_forward */
821da177e4SLinus Torvalds .data_reverse = dead_onearg, /* data_reverse */
831da177e4SLinus Torvalds
841da177e4SLinus Torvalds .init_state = dead_initstate, /* init_state */
851da177e4SLinus Torvalds .save_state = dead_state,
861da177e4SLinus Torvalds .restore_state = dead_state,
871da177e4SLinus Torvalds
881da177e4SLinus Torvalds .epp_write_data = dead_write, /* epp */
891da177e4SLinus Torvalds .epp_read_data = dead_read,
901da177e4SLinus Torvalds .epp_write_addr = dead_write,
911da177e4SLinus Torvalds .epp_read_addr = dead_read,
921da177e4SLinus Torvalds
931da177e4SLinus Torvalds .ecp_write_data = dead_write, /* ecp */
941da177e4SLinus Torvalds .ecp_read_data = dead_read,
951da177e4SLinus Torvalds .ecp_write_addr = dead_write,
961da177e4SLinus Torvalds
971da177e4SLinus Torvalds .compat_write_data = dead_write, /* compat */
981da177e4SLinus Torvalds .nibble_read_data = dead_read, /* nibble */
991da177e4SLinus Torvalds .byte_read_data = dead_read, /* byte */
1001da177e4SLinus Torvalds
1011da177e4SLinus Torvalds .owner = NULL,
1021da177e4SLinus Torvalds };
1031da177e4SLinus Torvalds
1046fa45a22SSudip Mukherjee static struct device_type parport_device_type = {
1056fa45a22SSudip Mukherjee .name = "parport",
1066fa45a22SSudip Mukherjee };
1076fa45a22SSudip Mukherjee
is_parport(struct device * dev)1086fa45a22SSudip Mukherjee static int is_parport(struct device *dev)
1096fa45a22SSudip Mukherjee {
1106fa45a22SSudip Mukherjee return dev->type == &parport_device_type;
1116fa45a22SSudip Mukherjee }
1126fa45a22SSudip Mukherjee
parport_probe(struct device * dev)1136fa45a22SSudip Mukherjee static int parport_probe(struct device *dev)
1146fa45a22SSudip Mukherjee {
1156fa45a22SSudip Mukherjee struct parport_driver *drv;
1166fa45a22SSudip Mukherjee
1176fa45a22SSudip Mukherjee if (is_parport(dev))
1186fa45a22SSudip Mukherjee return -ENODEV;
1196fa45a22SSudip Mukherjee
1206fa45a22SSudip Mukherjee drv = to_parport_driver(dev->driver);
1216fa45a22SSudip Mukherjee if (!drv->probe) {
1226fa45a22SSudip Mukherjee /* if driver has not defined a custom probe */
1236fa45a22SSudip Mukherjee struct pardevice *par_dev = to_pardevice(dev);
1246fa45a22SSudip Mukherjee
1256fa45a22SSudip Mukherjee if (strcmp(par_dev->name, drv->name))
1266fa45a22SSudip Mukherjee return -ENODEV;
1276fa45a22SSudip Mukherjee return 0;
1286fa45a22SSudip Mukherjee }
1296fa45a22SSudip Mukherjee /* if driver defined its own probe */
1306fa45a22SSudip Mukherjee return drv->probe(to_pardevice(dev));
1316fa45a22SSudip Mukherjee }
1326fa45a22SSudip Mukherjee
1336fa45a22SSudip Mukherjee static struct bus_type parport_bus_type = {
1346fa45a22SSudip Mukherjee .name = "parport",
1356fa45a22SSudip Mukherjee .probe = parport_probe,
1366fa45a22SSudip Mukherjee };
1376fa45a22SSudip Mukherjee
parport_bus_init(void)1386fa45a22SSudip Mukherjee int parport_bus_init(void)
1396fa45a22SSudip Mukherjee {
140a3ac7917SLinus Torvalds return bus_register(&parport_bus_type);
1416fa45a22SSudip Mukherjee }
1426fa45a22SSudip Mukherjee
parport_bus_exit(void)1436fa45a22SSudip Mukherjee void parport_bus_exit(void)
1446fa45a22SSudip Mukherjee {
1456fa45a22SSudip Mukherjee bus_unregister(&parport_bus_type);
1466fa45a22SSudip Mukherjee }
1476fa45a22SSudip Mukherjee
1486fa45a22SSudip Mukherjee /*
1496fa45a22SSudip Mukherjee * iterates through all the drivers registered with the bus and sends the port
1506fa45a22SSudip Mukherjee * details to the match_port callback of the driver, so that the driver can
151e9527365SGeliang Tang * know about the new port that just registered with the bus and decide if it
1526fa45a22SSudip Mukherjee * wants to use this new port.
1536fa45a22SSudip Mukherjee */
driver_check(struct device_driver * dev_drv,void * _port)1546fa45a22SSudip Mukherjee static int driver_check(struct device_driver *dev_drv, void *_port)
1556fa45a22SSudip Mukherjee {
1566fa45a22SSudip Mukherjee struct parport *port = _port;
1576fa45a22SSudip Mukherjee struct parport_driver *drv = to_parport_driver(dev_drv);
1586fa45a22SSudip Mukherjee
1596fa45a22SSudip Mukherjee if (drv->match_port)
1606fa45a22SSudip Mukherjee drv->match_port(port);
1616fa45a22SSudip Mukherjee return 0;
1626fa45a22SSudip Mukherjee }
1636fa45a22SSudip Mukherjee
1641da177e4SLinus Torvalds /* Call attach(port) for each registered driver. */
attach_driver_chain(struct parport * port)1651da177e4SLinus Torvalds static void attach_driver_chain(struct parport *port)
1661da177e4SLinus Torvalds {
1671da177e4SLinus Torvalds /* caller has exclusive registration_lock */
1681da177e4SLinus Torvalds struct parport_driver *drv;
1696fa45a22SSudip Mukherjee
1701da177e4SLinus Torvalds list_for_each_entry(drv, &drivers, list)
1711da177e4SLinus Torvalds drv->attach(port);
1726fa45a22SSudip Mukherjee
1736fa45a22SSudip Mukherjee /*
1746fa45a22SSudip Mukherjee * call the driver_check function of the drivers registered in
1756fa45a22SSudip Mukherjee * new device model
1766fa45a22SSudip Mukherjee */
1776fa45a22SSudip Mukherjee
1786fa45a22SSudip Mukherjee bus_for_each_drv(&parport_bus_type, NULL, port, driver_check);
1796fa45a22SSudip Mukherjee }
1806fa45a22SSudip Mukherjee
driver_detach(struct device_driver * _drv,void * _port)1816fa45a22SSudip Mukherjee static int driver_detach(struct device_driver *_drv, void *_port)
1826fa45a22SSudip Mukherjee {
1836fa45a22SSudip Mukherjee struct parport *port = _port;
1846fa45a22SSudip Mukherjee struct parport_driver *drv = to_parport_driver(_drv);
1856fa45a22SSudip Mukherjee
1866fa45a22SSudip Mukherjee if (drv->detach)
1876fa45a22SSudip Mukherjee drv->detach(port);
1886fa45a22SSudip Mukherjee return 0;
1891da177e4SLinus Torvalds }
1901da177e4SLinus Torvalds
1911da177e4SLinus Torvalds /* Call detach(port) for each registered driver. */
detach_driver_chain(struct parport * port)1921da177e4SLinus Torvalds static void detach_driver_chain(struct parport *port)
1931da177e4SLinus Torvalds {
1941da177e4SLinus Torvalds struct parport_driver *drv;
1951da177e4SLinus Torvalds /* caller has exclusive registration_lock */
1961da177e4SLinus Torvalds list_for_each_entry(drv, &drivers, list)
1971da177e4SLinus Torvalds drv->detach(port);
1986fa45a22SSudip Mukherjee
1996fa45a22SSudip Mukherjee /*
2006fa45a22SSudip Mukherjee * call the detach function of the drivers registered in
2016fa45a22SSudip Mukherjee * new device model
2026fa45a22SSudip Mukherjee */
2036fa45a22SSudip Mukherjee
2046fa45a22SSudip Mukherjee bus_for_each_drv(&parport_bus_type, NULL, port, driver_detach);
2051da177e4SLinus Torvalds }
2061da177e4SLinus Torvalds
2071da177e4SLinus Torvalds /* Ask kmod for some lowlevel drivers. */
get_lowlevel_driver(void)2081da177e4SLinus Torvalds static void get_lowlevel_driver(void)
2091da177e4SLinus Torvalds {
2107b7a0a30SSudip Mukherjee /*
2117b7a0a30SSudip Mukherjee * There is no actual module called this: you should set
2127b7a0a30SSudip Mukherjee * up an alias for modutils.
2137b7a0a30SSudip Mukherjee */
2141da177e4SLinus Torvalds request_module("parport_lowlevel");
2151da177e4SLinus Torvalds }
2161da177e4SLinus Torvalds
2176fa45a22SSudip Mukherjee /*
2186fa45a22SSudip Mukherjee * iterates through all the devices connected to the bus and sends the device
2196fa45a22SSudip Mukherjee * details to the match_port callback of the driver, so that the driver can
2206fa45a22SSudip Mukherjee * know what are all the ports that are connected to the bus and choose the
2216fa45a22SSudip Mukherjee * port to which it wants to register its device.
2226fa45a22SSudip Mukherjee */
port_check(struct device * dev,void * dev_drv)2236fa45a22SSudip Mukherjee static int port_check(struct device *dev, void *dev_drv)
2246fa45a22SSudip Mukherjee {
2256fa45a22SSudip Mukherjee struct parport_driver *drv = dev_drv;
2266fa45a22SSudip Mukherjee
2276fa45a22SSudip Mukherjee /* only send ports, do not send other devices connected to bus */
2286fa45a22SSudip Mukherjee if (is_parport(dev))
2296fa45a22SSudip Mukherjee drv->match_port(to_parport_dev(dev));
2306fa45a22SSudip Mukherjee return 0;
2316fa45a22SSudip Mukherjee }
2326fa45a22SSudip Mukherjee
233231ec2f2SSudip Mukherjee /*
234231ec2f2SSudip Mukherjee * Iterates through all the devices connected to the bus and return 1
235231ec2f2SSudip Mukherjee * if the device is a parallel port.
236231ec2f2SSudip Mukherjee */
237231ec2f2SSudip Mukherjee
port_detect(struct device * dev,void * dev_drv)238231ec2f2SSudip Mukherjee static int port_detect(struct device *dev, void *dev_drv)
239231ec2f2SSudip Mukherjee {
240231ec2f2SSudip Mukherjee if (is_parport(dev))
241231ec2f2SSudip Mukherjee return 1;
242231ec2f2SSudip Mukherjee return 0;
243231ec2f2SSudip Mukherjee }
244231ec2f2SSudip Mukherjee
2451da177e4SLinus Torvalds /**
2464c9a3a6cSMauro Carvalho Chehab * __parport_register_driver - register a parallel port device driver
2471da177e4SLinus Torvalds * @drv: structure describing the driver
2486fa45a22SSudip Mukherjee * @owner: owner module of drv
2496fa45a22SSudip Mukherjee * @mod_name: module name string
2501da177e4SLinus Torvalds *
2511da177e4SLinus Torvalds * This can be called by a parallel port device driver in order
2521da177e4SLinus Torvalds * to receive notifications about ports being found in the
2531da177e4SLinus Torvalds * system, as well as ports no longer available.
2541da177e4SLinus Torvalds *
2556fa45a22SSudip Mukherjee * If devmodel is true then the new device model is used
2566fa45a22SSudip Mukherjee * for registration.
2576fa45a22SSudip Mukherjee *
2581da177e4SLinus Torvalds * The @drv structure is allocated by the caller and must not be
2591da177e4SLinus Torvalds * deallocated until after calling parport_unregister_driver().
2601da177e4SLinus Torvalds *
2616fa45a22SSudip Mukherjee * If using the non device model:
2621da177e4SLinus Torvalds * The driver's attach() function may block. The port that
2631da177e4SLinus Torvalds * attach() is given will be valid for the duration of the
2641da177e4SLinus Torvalds * callback, but if the driver wants to take a copy of the
2651da177e4SLinus Torvalds * pointer it must call parport_get_port() to do so. Calling
2661da177e4SLinus Torvalds * parport_register_device() on that port will do this for you.
2671da177e4SLinus Torvalds *
2681da177e4SLinus Torvalds * The driver's detach() function may block. The port that
2691da177e4SLinus Torvalds * detach() is given will be valid for the duration of the
2701da177e4SLinus Torvalds * callback, but if the driver wants to take a copy of the
2711da177e4SLinus Torvalds * pointer it must call parport_get_port() to do so.
2721da177e4SLinus Torvalds *
2736fa45a22SSudip Mukherjee *
2746fa45a22SSudip Mukherjee * Returns 0 on success. The non device model will always succeeds.
2756fa45a22SSudip Mukherjee * but the new device model can fail and will return the error code.
2761da177e4SLinus Torvalds **/
2771da177e4SLinus Torvalds
__parport_register_driver(struct parport_driver * drv,struct module * owner,const char * mod_name)2786fa45a22SSudip Mukherjee int __parport_register_driver(struct parport_driver *drv, struct module *owner,
2796fa45a22SSudip Mukherjee const char *mod_name)
2801da177e4SLinus Torvalds {
2816fa45a22SSudip Mukherjee /* using device model */
2826fa45a22SSudip Mukherjee int ret;
2836fa45a22SSudip Mukherjee
2846fa45a22SSudip Mukherjee /* initialize common driver fields */
2856fa45a22SSudip Mukherjee drv->driver.name = drv->name;
2866fa45a22SSudip Mukherjee drv->driver.bus = &parport_bus_type;
2876fa45a22SSudip Mukherjee drv->driver.owner = owner;
2886fa45a22SSudip Mukherjee drv->driver.mod_name = mod_name;
2896fa45a22SSudip Mukherjee ret = driver_register(&drv->driver);
2906fa45a22SSudip Mukherjee if (ret)
2916fa45a22SSudip Mukherjee return ret;
2926fa45a22SSudip Mukherjee
293231ec2f2SSudip Mukherjee /*
294231ec2f2SSudip Mukherjee * check if bus has any parallel port registered, if
295231ec2f2SSudip Mukherjee * none is found then load the lowlevel driver.
296231ec2f2SSudip Mukherjee */
297231ec2f2SSudip Mukherjee ret = bus_for_each_dev(&parport_bus_type, NULL, NULL,
298231ec2f2SSudip Mukherjee port_detect);
299231ec2f2SSudip Mukherjee if (!ret)
300231ec2f2SSudip Mukherjee get_lowlevel_driver();
301231ec2f2SSudip Mukherjee
3026fa45a22SSudip Mukherjee mutex_lock(®istration_lock);
3036fa45a22SSudip Mukherjee if (drv->match_port)
3046fa45a22SSudip Mukherjee bus_for_each_dev(&parport_bus_type, NULL, drv,
3056fa45a22SSudip Mukherjee port_check);
3066fa45a22SSudip Mukherjee mutex_unlock(®istration_lock);
3076fa45a22SSudip Mukherjee
3086fa45a22SSudip Mukherjee return 0;
3096fa45a22SSudip Mukherjee }
3106fa45a22SSudip Mukherjee EXPORT_SYMBOL(__parport_register_driver);
3116fa45a22SSudip Mukherjee
port_detach(struct device * dev,void * _drv)3126fa45a22SSudip Mukherjee static int port_detach(struct device *dev, void *_drv)
3136fa45a22SSudip Mukherjee {
3146fa45a22SSudip Mukherjee struct parport_driver *drv = _drv;
3156fa45a22SSudip Mukherjee
3166fa45a22SSudip Mukherjee if (is_parport(dev) && drv->detach)
3176fa45a22SSudip Mukherjee drv->detach(to_parport_dev(dev));
3181da177e4SLinus Torvalds
3191da177e4SLinus Torvalds return 0;
3201da177e4SLinus Torvalds }
3211da177e4SLinus Torvalds
3221da177e4SLinus Torvalds /**
3231da177e4SLinus Torvalds * parport_unregister_driver - deregister a parallel port device driver
3241da177e4SLinus Torvalds * @drv: structure describing the driver that was given to
3251da177e4SLinus Torvalds * parport_register_driver()
3261da177e4SLinus Torvalds *
3271da177e4SLinus Torvalds * This should be called by a parallel port device driver that
3281da177e4SLinus Torvalds * has registered itself using parport_register_driver() when it
3291da177e4SLinus Torvalds * is about to be unloaded.
3301da177e4SLinus Torvalds *
3311da177e4SLinus Torvalds * When it returns, the driver's attach() routine will no longer
3321da177e4SLinus Torvalds * be called, and for each port that attach() was called for, the
3331da177e4SLinus Torvalds * detach() routine will have been called.
3341da177e4SLinus Torvalds *
3351da177e4SLinus Torvalds * All the driver's attach() and detach() calls are guaranteed to have
3361da177e4SLinus Torvalds * finished by the time this function returns.
3371da177e4SLinus Torvalds **/
3381da177e4SLinus Torvalds
parport_unregister_driver(struct parport_driver * drv)3391da177e4SLinus Torvalds void parport_unregister_driver(struct parport_driver *drv)
3401da177e4SLinus Torvalds {
34114cc3e2bSIngo Molnar mutex_lock(®istration_lock);
3426fa45a22SSudip Mukherjee bus_for_each_dev(&parport_bus_type, NULL, drv, port_detach);
3436fa45a22SSudip Mukherjee driver_unregister(&drv->driver);
34414cc3e2bSIngo Molnar mutex_unlock(®istration_lock);
3451da177e4SLinus Torvalds }
34627c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_unregister_driver);
3471da177e4SLinus Torvalds
free_port(struct device * dev)3486fa45a22SSudip Mukherjee static void free_port(struct device *dev)
3491da177e4SLinus Torvalds {
3501da177e4SLinus Torvalds int d;
3516fa45a22SSudip Mukherjee struct parport *port = to_parport_dev(dev);
3526fa45a22SSudip Mukherjee
3531da177e4SLinus Torvalds spin_lock(&full_list_lock);
3541da177e4SLinus Torvalds list_del(&port->full_list);
3551da177e4SLinus Torvalds spin_unlock(&full_list_lock);
3561da177e4SLinus Torvalds for (d = 0; d < 5; d++) {
3571da177e4SLinus Torvalds kfree(port->probe_info[d].class_name);
3581da177e4SLinus Torvalds kfree(port->probe_info[d].mfr);
3591da177e4SLinus Torvalds kfree(port->probe_info[d].model);
3601da177e4SLinus Torvalds kfree(port->probe_info[d].cmdset);
3611da177e4SLinus Torvalds kfree(port->probe_info[d].description);
3621da177e4SLinus Torvalds }
3631da177e4SLinus Torvalds
3641da177e4SLinus Torvalds kfree(port->name);
3651da177e4SLinus Torvalds kfree(port);
3661da177e4SLinus Torvalds }
3671da177e4SLinus Torvalds
3681da177e4SLinus Torvalds /**
3691da177e4SLinus Torvalds * parport_get_port - increment a port's reference count
3701da177e4SLinus Torvalds * @port: the port
3711da177e4SLinus Torvalds *
3727d469722SRandy Dunlap * This ensures that a struct parport pointer remains valid
3731da177e4SLinus Torvalds * until the matching parport_put_port() call.
3741da177e4SLinus Torvalds **/
3751da177e4SLinus Torvalds
parport_get_port(struct parport * port)3761da177e4SLinus Torvalds struct parport *parport_get_port(struct parport *port)
3771da177e4SLinus Torvalds {
3786fa45a22SSudip Mukherjee struct device *dev = get_device(&port->bus_dev);
3796fa45a22SSudip Mukherjee
3806fa45a22SSudip Mukherjee return to_parport_dev(dev);
3811da177e4SLinus Torvalds }
38227c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_get_port);
3831da177e4SLinus Torvalds
parport_del_port(struct parport * port)3846fa45a22SSudip Mukherjee void parport_del_port(struct parport *port)
3856fa45a22SSudip Mukherjee {
3866fa45a22SSudip Mukherjee device_unregister(&port->bus_dev);
3876fa45a22SSudip Mukherjee }
3886fa45a22SSudip Mukherjee EXPORT_SYMBOL(parport_del_port);
3896fa45a22SSudip Mukherjee
3901da177e4SLinus Torvalds /**
3911da177e4SLinus Torvalds * parport_put_port - decrement a port's reference count
3921da177e4SLinus Torvalds * @port: the port
3931da177e4SLinus Torvalds *
3941da177e4SLinus Torvalds * This should be called once for each call to parport_get_port(),
3956fa45a22SSudip Mukherjee * once the port is no longer needed. When the reference count reaches
3966fa45a22SSudip Mukherjee * zero (port is no longer used), free_port is called.
3971da177e4SLinus Torvalds **/
3981da177e4SLinus Torvalds
parport_put_port(struct parport * port)3991da177e4SLinus Torvalds void parport_put_port(struct parport *port)
4001da177e4SLinus Torvalds {
4016fa45a22SSudip Mukherjee put_device(&port->bus_dev);
4021da177e4SLinus Torvalds }
40327c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_put_port);
4041da177e4SLinus Torvalds
4051da177e4SLinus Torvalds /**
4061da177e4SLinus Torvalds * parport_register_port - register a parallel port
4071da177e4SLinus Torvalds * @base: base I/O address
4081da177e4SLinus Torvalds * @irq: IRQ line
4091da177e4SLinus Torvalds * @dma: DMA channel
4101da177e4SLinus Torvalds * @ops: pointer to the port driver's port operations structure
4111da177e4SLinus Torvalds *
4121da177e4SLinus Torvalds * When a parallel port (lowlevel) driver finds a port that
4131da177e4SLinus Torvalds * should be made available to parallel port device drivers, it
4141da177e4SLinus Torvalds * should call parport_register_port(). The @base, @irq, and
4151da177e4SLinus Torvalds * @dma parameters are for the convenience of port drivers, and
4161da177e4SLinus Torvalds * for ports where they aren't meaningful needn't be set to
4171da177e4SLinus Torvalds * anything special. They can be altered afterwards by adjusting
4181da177e4SLinus Torvalds * the relevant members of the parport structure that is returned
4191da177e4SLinus Torvalds * and represents the port. They should not be tampered with
4201da177e4SLinus Torvalds * after calling parport_announce_port, however.
4211da177e4SLinus Torvalds *
4221da177e4SLinus Torvalds * If there are parallel port device drivers in the system that
4231da177e4SLinus Torvalds * have registered themselves using parport_register_driver(),
4241da177e4SLinus Torvalds * they are not told about the port at this time; that is done by
4251da177e4SLinus Torvalds * parport_announce_port().
4261da177e4SLinus Torvalds *
4271da177e4SLinus Torvalds * The @ops structure is allocated by the caller, and must not be
4281da177e4SLinus Torvalds * deallocated before calling parport_remove_port().
4291da177e4SLinus Torvalds *
4301da177e4SLinus Torvalds * If there is no memory to allocate a new parport structure,
4311da177e4SLinus Torvalds * this function will return %NULL.
4321da177e4SLinus Torvalds **/
4331da177e4SLinus Torvalds
parport_register_port(unsigned long base,int irq,int dma,struct parport_operations * ops)4341da177e4SLinus Torvalds struct parport *parport_register_port(unsigned long base, int irq, int dma,
4351da177e4SLinus Torvalds struct parport_operations *ops)
4361da177e4SLinus Torvalds {
4371da177e4SLinus Torvalds struct list_head *l;
4381da177e4SLinus Torvalds struct parport *tmp;
4391da177e4SLinus Torvalds int num;
4401da177e4SLinus Torvalds int device;
4411da177e4SLinus Torvalds char *name;
4426fa45a22SSudip Mukherjee int ret;
4431da177e4SLinus Torvalds
444c32df4e1SAlexandru Gheorghiu tmp = kzalloc(sizeof(struct parport), GFP_KERNEL);
44547ec57ecSSudip Mukherjee if (!tmp)
4461da177e4SLinus Torvalds return NULL;
4471da177e4SLinus Torvalds
4481da177e4SLinus Torvalds /* Init our structure */
4491da177e4SLinus Torvalds tmp->base = base;
4501da177e4SLinus Torvalds tmp->irq = irq;
4511da177e4SLinus Torvalds tmp->dma = dma;
4521da177e4SLinus Torvalds tmp->muxport = tmp->daisy = tmp->muxsel = -1;
4531da177e4SLinus Torvalds tmp->modes = 0;
4541da177e4SLinus Torvalds INIT_LIST_HEAD(&tmp->list);
4551da177e4SLinus Torvalds tmp->devices = tmp->cad = NULL;
4561da177e4SLinus Torvalds tmp->flags = 0;
4571da177e4SLinus Torvalds tmp->ops = ops;
4581da177e4SLinus Torvalds tmp->physport = tmp;
4591da177e4SLinus Torvalds memset(tmp->probe_info, 0, 5 * sizeof(struct parport_device_info));
4601da177e4SLinus Torvalds rwlock_init(&tmp->cad_lock);
4611da177e4SLinus Torvalds spin_lock_init(&tmp->waitlist_lock);
4621da177e4SLinus Torvalds spin_lock_init(&tmp->pardevice_lock);
4631da177e4SLinus Torvalds tmp->ieee1284.mode = IEEE1284_MODE_COMPAT;
4641da177e4SLinus Torvalds tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
465a529f150SThomas Gleixner sema_init(&tmp->ieee1284.irq, 0);
4661da177e4SLinus Torvalds tmp->spintime = parport_default_spintime;
4671da177e4SLinus Torvalds atomic_set(&tmp->ref_count, 1);
4681da177e4SLinus Torvalds INIT_LIST_HEAD(&tmp->full_list);
4691da177e4SLinus Torvalds
470*7c0bf4daSJoel Granados name = kmalloc(PARPORT_NAME_MAX_LEN, GFP_KERNEL);
4711da177e4SLinus Torvalds if (!name) {
4721da177e4SLinus Torvalds kfree(tmp);
4731da177e4SLinus Torvalds return NULL;
4741da177e4SLinus Torvalds }
4751da177e4SLinus Torvalds /* Search for the lowest free parport number. */
4761da177e4SLinus Torvalds
4771da177e4SLinus Torvalds spin_lock(&full_list_lock);
4781da177e4SLinus Torvalds for (l = all_ports.next, num = 0; l != &all_ports; l = l->next, num++) {
4791da177e4SLinus Torvalds struct parport *p = list_entry(l, struct parport, full_list);
4801da177e4SLinus Torvalds if (p->number != num)
4811da177e4SLinus Torvalds break;
4821da177e4SLinus Torvalds }
4831da177e4SLinus Torvalds tmp->portnum = tmp->number = num;
4841da177e4SLinus Torvalds list_add_tail(&tmp->full_list, l);
4851da177e4SLinus Torvalds spin_unlock(&full_list_lock);
4861da177e4SLinus Torvalds
4871da177e4SLinus Torvalds /*
4881da177e4SLinus Torvalds * Now that the portnum is known finish doing the Init.
4891da177e4SLinus Torvalds */
4901da177e4SLinus Torvalds sprintf(name, "parport%d", tmp->portnum = tmp->number);
4911da177e4SLinus Torvalds tmp->name = name;
4926fa45a22SSudip Mukherjee tmp->bus_dev.bus = &parport_bus_type;
4936fa45a22SSudip Mukherjee tmp->bus_dev.release = free_port;
4946fa45a22SSudip Mukherjee dev_set_name(&tmp->bus_dev, name);
4956fa45a22SSudip Mukherjee tmp->bus_dev.type = &parport_device_type;
4961da177e4SLinus Torvalds
4971da177e4SLinus Torvalds for (device = 0; device < 5; device++)
4981da177e4SLinus Torvalds /* assume the worst */
4991da177e4SLinus Torvalds tmp->probe_info[device].class = PARPORT_CLASS_LEGACY;
5001da177e4SLinus Torvalds
5011da177e4SLinus Torvalds tmp->waithead = tmp->waittail = NULL;
5021da177e4SLinus Torvalds
5036fa45a22SSudip Mukherjee ret = device_register(&tmp->bus_dev);
5046fa45a22SSudip Mukherjee if (ret) {
5056fa45a22SSudip Mukherjee put_device(&tmp->bus_dev);
5066fa45a22SSudip Mukherjee return NULL;
5076fa45a22SSudip Mukherjee }
5086fa45a22SSudip Mukherjee
5091da177e4SLinus Torvalds return tmp;
5101da177e4SLinus Torvalds }
51127c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_register_port);
5121da177e4SLinus Torvalds
5131da177e4SLinus Torvalds /**
5141da177e4SLinus Torvalds * parport_announce_port - tell device drivers about a parallel port
5151da177e4SLinus Torvalds * @port: parallel port to announce
5161da177e4SLinus Torvalds *
5171da177e4SLinus Torvalds * After a port driver has registered a parallel port with
5181da177e4SLinus Torvalds * parport_register_port, and performed any necessary
5191da177e4SLinus Torvalds * initialisation or adjustments, it should call
5201da177e4SLinus Torvalds * parport_announce_port() in order to notify all device drivers
5211da177e4SLinus Torvalds * that have called parport_register_driver(). Their attach()
5221da177e4SLinus Torvalds * functions will be called, with @port as the parameter.
5231da177e4SLinus Torvalds **/
5241da177e4SLinus Torvalds
parport_announce_port(struct parport * port)5251da177e4SLinus Torvalds void parport_announce_port(struct parport *port)
5261da177e4SLinus Torvalds {
5271da177e4SLinus Torvalds int i;
5281da177e4SLinus Torvalds
5291da177e4SLinus Torvalds #ifdef CONFIG_PARPORT_1284
5301da177e4SLinus Torvalds /* Analyse the IEEE1284.3 topology of the port. */
5311da177e4SLinus Torvalds parport_daisy_init(port);
5321da177e4SLinus Torvalds #endif
5331da177e4SLinus Torvalds
534c15a3837SDavid Brownell if (!port->dev)
535decf26f6SJoe Perches pr_warn("%s: fix this legacy no-device port driver!\n",
536c15a3837SDavid Brownell port->name);
537c15a3837SDavid Brownell
5381da177e4SLinus Torvalds parport_proc_register(port);
53914cc3e2bSIngo Molnar mutex_lock(®istration_lock);
5401da177e4SLinus Torvalds spin_lock_irq(&parportlist_lock);
5411da177e4SLinus Torvalds list_add_tail(&port->list, &portlist);
5421da177e4SLinus Torvalds for (i = 1; i < 3; i++) {
5431da177e4SLinus Torvalds struct parport *slave = port->slaves[i-1];
5441da177e4SLinus Torvalds if (slave)
5451da177e4SLinus Torvalds list_add_tail(&slave->list, &portlist);
5461da177e4SLinus Torvalds }
5471da177e4SLinus Torvalds spin_unlock_irq(&parportlist_lock);
5481da177e4SLinus Torvalds
5491da177e4SLinus Torvalds /* Let drivers know that new port(s) has arrived. */
5501da177e4SLinus Torvalds attach_driver_chain(port);
5511da177e4SLinus Torvalds for (i = 1; i < 3; i++) {
5521da177e4SLinus Torvalds struct parport *slave = port->slaves[i-1];
5531da177e4SLinus Torvalds if (slave)
5541da177e4SLinus Torvalds attach_driver_chain(slave);
5551da177e4SLinus Torvalds }
55614cc3e2bSIngo Molnar mutex_unlock(®istration_lock);
5571da177e4SLinus Torvalds }
55827c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_announce_port);
5591da177e4SLinus Torvalds
5601da177e4SLinus Torvalds /**
5611da177e4SLinus Torvalds * parport_remove_port - deregister a parallel port
5621da177e4SLinus Torvalds * @port: parallel port to deregister
5631da177e4SLinus Torvalds *
5641da177e4SLinus Torvalds * When a parallel port driver is forcibly unloaded, or a
5651da177e4SLinus Torvalds * parallel port becomes inaccessible, the port driver must call
5661da177e4SLinus Torvalds * this function in order to deal with device drivers that still
5671da177e4SLinus Torvalds * want to use it.
5681da177e4SLinus Torvalds *
5691da177e4SLinus Torvalds * The parport structure associated with the port has its
5701da177e4SLinus Torvalds * operations structure replaced with one containing 'null'
5711da177e4SLinus Torvalds * operations that return errors or just don't do anything.
5721da177e4SLinus Torvalds *
5731da177e4SLinus Torvalds * Any drivers that have registered themselves using
5741da177e4SLinus Torvalds * parport_register_driver() are notified that the port is no
5751da177e4SLinus Torvalds * longer accessible by having their detach() routines called
5761da177e4SLinus Torvalds * with @port as the parameter.
5771da177e4SLinus Torvalds **/
5781da177e4SLinus Torvalds
parport_remove_port(struct parport * port)5791da177e4SLinus Torvalds void parport_remove_port(struct parport *port)
5801da177e4SLinus Torvalds {
5811da177e4SLinus Torvalds int i;
5821da177e4SLinus Torvalds
58314cc3e2bSIngo Molnar mutex_lock(®istration_lock);
5841da177e4SLinus Torvalds
5851da177e4SLinus Torvalds /* Spread the word. */
5861da177e4SLinus Torvalds detach_driver_chain(port);
5871da177e4SLinus Torvalds
5881da177e4SLinus Torvalds #ifdef CONFIG_PARPORT_1284
5891da177e4SLinus Torvalds /* Forget the IEEE1284.3 topology of the port. */
5901da177e4SLinus Torvalds parport_daisy_fini(port);
5911da177e4SLinus Torvalds for (i = 1; i < 3; i++) {
5921da177e4SLinus Torvalds struct parport *slave = port->slaves[i-1];
5931da177e4SLinus Torvalds if (!slave)
5941da177e4SLinus Torvalds continue;
5951da177e4SLinus Torvalds detach_driver_chain(slave);
5961da177e4SLinus Torvalds parport_daisy_fini(slave);
5971da177e4SLinus Torvalds }
5981da177e4SLinus Torvalds #endif
5991da177e4SLinus Torvalds
6001da177e4SLinus Torvalds port->ops = &dead_ops;
6011da177e4SLinus Torvalds spin_lock(&parportlist_lock);
6021da177e4SLinus Torvalds list_del_init(&port->list);
6031da177e4SLinus Torvalds for (i = 1; i < 3; i++) {
6041da177e4SLinus Torvalds struct parport *slave = port->slaves[i-1];
6051da177e4SLinus Torvalds if (slave)
6061da177e4SLinus Torvalds list_del_init(&slave->list);
6071da177e4SLinus Torvalds }
6081da177e4SLinus Torvalds spin_unlock(&parportlist_lock);
6091da177e4SLinus Torvalds
61014cc3e2bSIngo Molnar mutex_unlock(®istration_lock);
6111da177e4SLinus Torvalds
6121da177e4SLinus Torvalds parport_proc_unregister(port);
6131da177e4SLinus Torvalds
6141da177e4SLinus Torvalds for (i = 1; i < 3; i++) {
6151da177e4SLinus Torvalds struct parport *slave = port->slaves[i-1];
6161da177e4SLinus Torvalds if (slave)
6171da177e4SLinus Torvalds parport_put_port(slave);
6181da177e4SLinus Torvalds }
6191da177e4SLinus Torvalds }
62027c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_remove_port);
6211da177e4SLinus Torvalds
free_pardevice(struct device * dev)6226fa45a22SSudip Mukherjee static void free_pardevice(struct device *dev)
6236fa45a22SSudip Mukherjee {
6246fa45a22SSudip Mukherjee struct pardevice *par_dev = to_pardevice(dev);
6256fa45a22SSudip Mukherjee
6266fa45a22SSudip Mukherjee kfree(par_dev->name);
6276fa45a22SSudip Mukherjee kfree(par_dev);
6286fa45a22SSudip Mukherjee }
6296fa45a22SSudip Mukherjee
6306824f0ceSSudip Mukherjee /**
6316824f0ceSSudip Mukherjee * parport_register_dev_model - register a device on a parallel port
6326824f0ceSSudip Mukherjee * @port: port to which the device is attached
6336824f0ceSSudip Mukherjee * @name: a name to refer to the device
6346824f0ceSSudip Mukherjee * @par_dev_cb: struct containing callbacks
6356824f0ceSSudip Mukherjee * @id: device number to be given to the device
6366824f0ceSSudip Mukherjee *
6376824f0ceSSudip Mukherjee * This function, called by parallel port device drivers,
6386824f0ceSSudip Mukherjee * declares that a device is connected to a port, and tells the
6396824f0ceSSudip Mukherjee * system all it needs to know.
6406824f0ceSSudip Mukherjee *
6416824f0ceSSudip Mukherjee * The struct pardev_cb contains pointer to callbacks. preemption
6426824f0ceSSudip Mukherjee * callback function, @preempt, is called when this device driver
6436824f0ceSSudip Mukherjee * has claimed access to the port but another device driver wants
6446824f0ceSSudip Mukherjee * to use it. It is given, @private, as its parameter, and should
6456824f0ceSSudip Mukherjee * return zero if it is willing for the system to release the port
6466824f0ceSSudip Mukherjee * to another driver on its behalf. If it wants to keep control of
6476824f0ceSSudip Mukherjee * the port it should return non-zero, and no action will be taken.
6486824f0ceSSudip Mukherjee * It is good manners for the driver to try to release the port at
6496824f0ceSSudip Mukherjee * the earliest opportunity after its preemption callback rejects a
6506824f0ceSSudip Mukherjee * preemption attempt. Note that if a preemption callback is happy
6516824f0ceSSudip Mukherjee * for preemption to go ahead, there is no need to release the
6526824f0ceSSudip Mukherjee * port; it is done automatically. This function may not block, as
6536824f0ceSSudip Mukherjee * it may be called from interrupt context. If the device driver
6546824f0ceSSudip Mukherjee * does not support preemption, @preempt can be %NULL.
6556824f0ceSSudip Mukherjee *
6566824f0ceSSudip Mukherjee * The wake-up ("kick") callback function, @wakeup, is called when
6576824f0ceSSudip Mukherjee * the port is available to be claimed for exclusive access; that
6586824f0ceSSudip Mukherjee * is, parport_claim() is guaranteed to succeed when called from
6596824f0ceSSudip Mukherjee * inside the wake-up callback function. If the driver wants to
6606824f0ceSSudip Mukherjee * claim the port it should do so; otherwise, it need not take
6616824f0ceSSudip Mukherjee * any action. This function may not block, as it may be called
6626824f0ceSSudip Mukherjee * from interrupt context. If the device driver does not want to
6636824f0ceSSudip Mukherjee * be explicitly invited to claim the port in this way, @wakeup can
6646824f0ceSSudip Mukherjee * be %NULL.
6656824f0ceSSudip Mukherjee *
6666824f0ceSSudip Mukherjee * The interrupt handler, @irq_func, is called when an interrupt
6676824f0ceSSudip Mukherjee * arrives from the parallel port. Note that if a device driver
6686824f0ceSSudip Mukherjee * wants to use interrupts it should use parport_enable_irq(),
6696824f0ceSSudip Mukherjee * and can also check the irq member of the parport structure
6706824f0ceSSudip Mukherjee * representing the port.
6716824f0ceSSudip Mukherjee *
6726824f0ceSSudip Mukherjee * The parallel port (lowlevel) driver is the one that has called
6736824f0ceSSudip Mukherjee * request_irq() and whose interrupt handler is called first.
6746824f0ceSSudip Mukherjee * This handler does whatever needs to be done to the hardware to
6756824f0ceSSudip Mukherjee * acknowledge the interrupt (for PC-style ports there is nothing
6766824f0ceSSudip Mukherjee * special to be done). It then tells the IEEE 1284 code about
6776824f0ceSSudip Mukherjee * the interrupt, which may involve reacting to an IEEE 1284
6786824f0ceSSudip Mukherjee * event depending on the current IEEE 1284 phase. After this,
6796824f0ceSSudip Mukherjee * it calls @irq_func. Needless to say, @irq_func will be called
6806824f0ceSSudip Mukherjee * from interrupt context, and may not block.
6816824f0ceSSudip Mukherjee *
6826824f0ceSSudip Mukherjee * The %PARPORT_DEV_EXCL flag is for preventing port sharing, and
6836824f0ceSSudip Mukherjee * so should only be used when sharing the port with other device
6846824f0ceSSudip Mukherjee * drivers is impossible and would lead to incorrect behaviour.
6856824f0ceSSudip Mukherjee * Use it sparingly! Normally, @flags will be zero.
6866824f0ceSSudip Mukherjee *
6876824f0ceSSudip Mukherjee * This function returns a pointer to a structure that represents
6886824f0ceSSudip Mukherjee * the device on the port, or %NULL if there is not enough memory
6896824f0ceSSudip Mukherjee * to allocate space for that structure.
6906824f0ceSSudip Mukherjee **/
6916824f0ceSSudip Mukherjee
6926fa45a22SSudip Mukherjee struct pardevice *
parport_register_dev_model(struct parport * port,const char * name,const struct pardev_cb * par_dev_cb,int id)6936fa45a22SSudip Mukherjee parport_register_dev_model(struct parport *port, const char *name,
6946fa45a22SSudip Mukherjee const struct pardev_cb *par_dev_cb, int id)
6956fa45a22SSudip Mukherjee {
6966fa45a22SSudip Mukherjee struct pardevice *par_dev;
6976fa45a22SSudip Mukherjee int ret;
6986fa45a22SSudip Mukherjee char *devname;
6996fa45a22SSudip Mukherjee
7006fa45a22SSudip Mukherjee if (port->physport->flags & PARPORT_FLAG_EXCL) {
7016fa45a22SSudip Mukherjee /* An exclusive device is registered. */
7026fa45a22SSudip Mukherjee pr_err("%s: no more devices allowed\n", port->name);
7036fa45a22SSudip Mukherjee return NULL;
7046fa45a22SSudip Mukherjee }
7056fa45a22SSudip Mukherjee
7066fa45a22SSudip Mukherjee if (par_dev_cb->flags & PARPORT_DEV_LURK) {
7076fa45a22SSudip Mukherjee if (!par_dev_cb->preempt || !par_dev_cb->wakeup) {
7086fa45a22SSudip Mukherjee pr_info("%s: refused to register lurking device (%s) without callbacks\n",
7096fa45a22SSudip Mukherjee port->name, name);
7106fa45a22SSudip Mukherjee return NULL;
7116fa45a22SSudip Mukherjee }
7126fa45a22SSudip Mukherjee }
7136fa45a22SSudip Mukherjee
71450566ac8SSudip Mukherjee if (par_dev_cb->flags & PARPORT_DEV_EXCL) {
71550566ac8SSudip Mukherjee if (port->physport->devices) {
71650566ac8SSudip Mukherjee /*
71750566ac8SSudip Mukherjee * If a device is already registered and this new
71850566ac8SSudip Mukherjee * device wants exclusive access, then no need to
71950566ac8SSudip Mukherjee * continue as we can not grant exclusive access to
72050566ac8SSudip Mukherjee * this device.
72150566ac8SSudip Mukherjee */
72250566ac8SSudip Mukherjee pr_err("%s: cannot grant exclusive access for device %s\n",
72350566ac8SSudip Mukherjee port->name, name);
72450566ac8SSudip Mukherjee return NULL;
72550566ac8SSudip Mukherjee }
72650566ac8SSudip Mukherjee }
72750566ac8SSudip Mukherjee
7286fa45a22SSudip Mukherjee if (!try_module_get(port->ops->owner))
7296fa45a22SSudip Mukherjee return NULL;
7306fa45a22SSudip Mukherjee
7316fa45a22SSudip Mukherjee parport_get_port(port);
7326fa45a22SSudip Mukherjee
7336fa45a22SSudip Mukherjee par_dev = kzalloc(sizeof(*par_dev), GFP_KERNEL);
7346fa45a22SSudip Mukherjee if (!par_dev)
7356fa45a22SSudip Mukherjee goto err_put_port;
7366fa45a22SSudip Mukherjee
7376fa45a22SSudip Mukherjee par_dev->state = kzalloc(sizeof(*par_dev->state), GFP_KERNEL);
7386fa45a22SSudip Mukherjee if (!par_dev->state)
7396fa45a22SSudip Mukherjee goto err_put_par_dev;
7406fa45a22SSudip Mukherjee
7416fa45a22SSudip Mukherjee devname = kstrdup(name, GFP_KERNEL);
7426fa45a22SSudip Mukherjee if (!devname)
7436fa45a22SSudip Mukherjee goto err_free_par_dev;
7446fa45a22SSudip Mukherjee
7456fa45a22SSudip Mukherjee par_dev->name = devname;
7466fa45a22SSudip Mukherjee par_dev->port = port;
7476fa45a22SSudip Mukherjee par_dev->daisy = -1;
7486fa45a22SSudip Mukherjee par_dev->preempt = par_dev_cb->preempt;
7496fa45a22SSudip Mukherjee par_dev->wakeup = par_dev_cb->wakeup;
7506fa45a22SSudip Mukherjee par_dev->private = par_dev_cb->private;
7516fa45a22SSudip Mukherjee par_dev->flags = par_dev_cb->flags;
7526fa45a22SSudip Mukherjee par_dev->irq_func = par_dev_cb->irq_func;
7536fa45a22SSudip Mukherjee par_dev->waiting = 0;
7546fa45a22SSudip Mukherjee par_dev->timeout = 5 * HZ;
7556fa45a22SSudip Mukherjee
7566fa45a22SSudip Mukherjee par_dev->dev.parent = &port->bus_dev;
7576fa45a22SSudip Mukherjee par_dev->dev.bus = &parport_bus_type;
7586fa45a22SSudip Mukherjee ret = dev_set_name(&par_dev->dev, "%s.%d", devname, id);
7596fa45a22SSudip Mukherjee if (ret)
7606fa45a22SSudip Mukherjee goto err_free_devname;
7616fa45a22SSudip Mukherjee par_dev->dev.release = free_pardevice;
7626fa45a22SSudip Mukherjee par_dev->devmodel = true;
7636fa45a22SSudip Mukherjee ret = device_register(&par_dev->dev);
76468d35c7bSSudip Mukherjee if (ret) {
7651c7ebeabSYueHaibing kfree(par_dev->state);
76668d35c7bSSudip Mukherjee put_device(&par_dev->dev);
76768d35c7bSSudip Mukherjee goto err_put_port;
76868d35c7bSSudip Mukherjee }
7696fa45a22SSudip Mukherjee
7706fa45a22SSudip Mukherjee /* Chain this onto the list */
7716fa45a22SSudip Mukherjee par_dev->prev = NULL;
7726fa45a22SSudip Mukherjee /*
7736fa45a22SSudip Mukherjee * This function must not run from an irq handler so we don' t need
7746fa45a22SSudip Mukherjee * to clear irq on the local CPU. -arca
7756fa45a22SSudip Mukherjee */
7766fa45a22SSudip Mukherjee spin_lock(&port->physport->pardevice_lock);
7776fa45a22SSudip Mukherjee
7786fa45a22SSudip Mukherjee if (par_dev_cb->flags & PARPORT_DEV_EXCL) {
7796fa45a22SSudip Mukherjee if (port->physport->devices) {
7806fa45a22SSudip Mukherjee spin_unlock(&port->physport->pardevice_lock);
7816fa45a22SSudip Mukherjee pr_debug("%s: cannot grant exclusive access for device %s\n",
7826fa45a22SSudip Mukherjee port->name, name);
7831c7ebeabSYueHaibing kfree(par_dev->state);
784cabea695SSudip Mukherjee device_unregister(&par_dev->dev);
785cabea695SSudip Mukherjee goto err_put_port;
7866fa45a22SSudip Mukherjee }
7876fa45a22SSudip Mukherjee port->flags |= PARPORT_FLAG_EXCL;
7886fa45a22SSudip Mukherjee }
7896fa45a22SSudip Mukherjee
7906fa45a22SSudip Mukherjee par_dev->next = port->physport->devices;
7916fa45a22SSudip Mukherjee wmb(); /*
7926fa45a22SSudip Mukherjee * Make sure that tmp->next is written before it's
7936fa45a22SSudip Mukherjee * added to the list; see comments marked 'no locking
7946fa45a22SSudip Mukherjee * required'
7956fa45a22SSudip Mukherjee */
7966fa45a22SSudip Mukherjee if (port->physport->devices)
7976fa45a22SSudip Mukherjee port->physport->devices->prev = par_dev;
7986fa45a22SSudip Mukherjee port->physport->devices = par_dev;
7996fa45a22SSudip Mukherjee spin_unlock(&port->physport->pardevice_lock);
8006fa45a22SSudip Mukherjee
8016fa45a22SSudip Mukherjee init_waitqueue_head(&par_dev->wait_q);
8026fa45a22SSudip Mukherjee par_dev->timeslice = parport_default_timeslice;
8036fa45a22SSudip Mukherjee par_dev->waitnext = NULL;
8046fa45a22SSudip Mukherjee par_dev->waitprev = NULL;
8056fa45a22SSudip Mukherjee
8066fa45a22SSudip Mukherjee /*
8076fa45a22SSudip Mukherjee * This has to be run as last thing since init_state may need other
8086fa45a22SSudip Mukherjee * pardevice fields. -arca
8096fa45a22SSudip Mukherjee */
8106fa45a22SSudip Mukherjee port->ops->init_state(par_dev, par_dev->state);
81103270c6aSSudip Mukherjee if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) {
8126fa45a22SSudip Mukherjee port->proc_device = par_dev;
8136fa45a22SSudip Mukherjee parport_device_proc_register(par_dev);
81403270c6aSSudip Mukherjee }
8156fa45a22SSudip Mukherjee
8166fa45a22SSudip Mukherjee return par_dev;
8176fa45a22SSudip Mukherjee
8186fa45a22SSudip Mukherjee err_free_devname:
8196fa45a22SSudip Mukherjee kfree(devname);
8206fa45a22SSudip Mukherjee err_free_par_dev:
8216fa45a22SSudip Mukherjee kfree(par_dev->state);
8226fa45a22SSudip Mukherjee err_put_par_dev:
8236fa45a22SSudip Mukherjee if (!par_dev->devmodel)
8246fa45a22SSudip Mukherjee kfree(par_dev);
8256fa45a22SSudip Mukherjee err_put_port:
8266fa45a22SSudip Mukherjee parport_put_port(port);
8276fa45a22SSudip Mukherjee module_put(port->ops->owner);
8286fa45a22SSudip Mukherjee
8296fa45a22SSudip Mukherjee return NULL;
8306fa45a22SSudip Mukherjee }
8316fa45a22SSudip Mukherjee EXPORT_SYMBOL(parport_register_dev_model);
8326fa45a22SSudip Mukherjee
8331da177e4SLinus Torvalds /**
8341da177e4SLinus Torvalds * parport_unregister_device - deregister a device on a parallel port
8351da177e4SLinus Torvalds * @dev: pointer to structure representing device
8361da177e4SLinus Torvalds *
8371da177e4SLinus Torvalds * This undoes the effect of parport_register_device().
8381da177e4SLinus Torvalds **/
8391da177e4SLinus Torvalds
parport_unregister_device(struct pardevice * dev)8401da177e4SLinus Torvalds void parport_unregister_device(struct pardevice *dev)
8411da177e4SLinus Torvalds {
8421da177e4SLinus Torvalds struct parport *port;
8431da177e4SLinus Torvalds
8441da177e4SLinus Torvalds #ifdef PARPORT_PARANOID
845b95b9d6cSSudip Mukherjee if (!dev) {
846decf26f6SJoe Perches pr_err("%s: passed NULL\n", __func__);
8471da177e4SLinus Torvalds return;
8481da177e4SLinus Torvalds }
8491da177e4SLinus Torvalds #endif
8501da177e4SLinus Torvalds
8511da177e4SLinus Torvalds port = dev->port->physport;
8521da177e4SLinus Torvalds
85305ad709dSAlan Cox if (port->proc_device == dev) {
85405ad709dSAlan Cox port->proc_device = NULL;
85505ad709dSAlan Cox clear_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags);
85605ad709dSAlan Cox parport_device_proc_unregister(dev);
85705ad709dSAlan Cox }
85805ad709dSAlan Cox
8591da177e4SLinus Torvalds if (port->cad == dev) {
8601da177e4SLinus Torvalds printk(KERN_DEBUG "%s: %s forgot to release port\n",
8611da177e4SLinus Torvalds port->name, dev->name);
8621da177e4SLinus Torvalds parport_release(dev);
8631da177e4SLinus Torvalds }
8641da177e4SLinus Torvalds
8651da177e4SLinus Torvalds spin_lock(&port->pardevice_lock);
8661da177e4SLinus Torvalds if (dev->next)
8671da177e4SLinus Torvalds dev->next->prev = dev->prev;
8681da177e4SLinus Torvalds if (dev->prev)
8691da177e4SLinus Torvalds dev->prev->next = dev->next;
8701da177e4SLinus Torvalds else
8711da177e4SLinus Torvalds port->devices = dev->next;
8721da177e4SLinus Torvalds
8731da177e4SLinus Torvalds if (dev->flags & PARPORT_DEV_EXCL)
8741da177e4SLinus Torvalds port->flags &= ~PARPORT_FLAG_EXCL;
8751da177e4SLinus Torvalds
8761da177e4SLinus Torvalds spin_unlock(&port->pardevice_lock);
8771da177e4SLinus Torvalds
8787b7a0a30SSudip Mukherjee /*
8797b7a0a30SSudip Mukherjee * Make sure we haven't left any pointers around in the wait
8807b7a0a30SSudip Mukherjee * list.
8817b7a0a30SSudip Mukherjee */
882cbeb4b7aSAlexander Gordeev spin_lock_irq(&port->waitlist_lock);
8831da177e4SLinus Torvalds if (dev->waitprev || dev->waitnext || port->waithead == dev) {
8841da177e4SLinus Torvalds if (dev->waitprev)
8851da177e4SLinus Torvalds dev->waitprev->waitnext = dev->waitnext;
8861da177e4SLinus Torvalds else
8871da177e4SLinus Torvalds port->waithead = dev->waitnext;
8881da177e4SLinus Torvalds if (dev->waitnext)
8891da177e4SLinus Torvalds dev->waitnext->waitprev = dev->waitprev;
8901da177e4SLinus Torvalds else
8911da177e4SLinus Torvalds port->waittail = dev->waitprev;
8921da177e4SLinus Torvalds }
893cbeb4b7aSAlexander Gordeev spin_unlock_irq(&port->waitlist_lock);
8941da177e4SLinus Torvalds
8951da177e4SLinus Torvalds kfree(dev->state);
8966fa45a22SSudip Mukherjee device_unregister(&dev->dev);
8971da177e4SLinus Torvalds
8981da177e4SLinus Torvalds module_put(port->ops->owner);
8991da177e4SLinus Torvalds parport_put_port(port);
9001da177e4SLinus Torvalds }
90127c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_unregister_device);
9021da177e4SLinus Torvalds
9031da177e4SLinus Torvalds /**
9041da177e4SLinus Torvalds * parport_find_number - find a parallel port by number
9051da177e4SLinus Torvalds * @number: parallel port number
9061da177e4SLinus Torvalds *
9071da177e4SLinus Torvalds * This returns the parallel port with the specified number, or
9081da177e4SLinus Torvalds * %NULL if there is none.
9091da177e4SLinus Torvalds *
9101da177e4SLinus Torvalds * There is an implicit parport_get_port() done already; to throw
9111da177e4SLinus Torvalds * away the reference to the port that parport_find_number()
9121da177e4SLinus Torvalds * gives you, use parport_put_port().
9131da177e4SLinus Torvalds */
9141da177e4SLinus Torvalds
parport_find_number(int number)9151da177e4SLinus Torvalds struct parport *parport_find_number(int number)
9161da177e4SLinus Torvalds {
9171da177e4SLinus Torvalds struct parport *port, *result = NULL;
9181da177e4SLinus Torvalds
9191da177e4SLinus Torvalds if (list_empty(&portlist))
9201da177e4SLinus Torvalds get_lowlevel_driver();
9211da177e4SLinus Torvalds
9221da177e4SLinus Torvalds spin_lock(&parportlist_lock);
9231da177e4SLinus Torvalds list_for_each_entry(port, &portlist, list) {
9241da177e4SLinus Torvalds if (port->number == number) {
9251da177e4SLinus Torvalds result = parport_get_port(port);
9261da177e4SLinus Torvalds break;
9271da177e4SLinus Torvalds }
9281da177e4SLinus Torvalds }
9291da177e4SLinus Torvalds spin_unlock(&parportlist_lock);
9301da177e4SLinus Torvalds return result;
9311da177e4SLinus Torvalds }
93227c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_find_number);
9331da177e4SLinus Torvalds
9341da177e4SLinus Torvalds /**
9351da177e4SLinus Torvalds * parport_find_base - find a parallel port by base address
9361da177e4SLinus Torvalds * @base: base I/O address
9371da177e4SLinus Torvalds *
9381da177e4SLinus Torvalds * This returns the parallel port with the specified base
9391da177e4SLinus Torvalds * address, or %NULL if there is none.
9401da177e4SLinus Torvalds *
9411da177e4SLinus Torvalds * There is an implicit parport_get_port() done already; to throw
9421da177e4SLinus Torvalds * away the reference to the port that parport_find_base()
9431da177e4SLinus Torvalds * gives you, use parport_put_port().
9441da177e4SLinus Torvalds */
9451da177e4SLinus Torvalds
parport_find_base(unsigned long base)9461da177e4SLinus Torvalds struct parport *parport_find_base(unsigned long base)
9471da177e4SLinus Torvalds {
9481da177e4SLinus Torvalds struct parport *port, *result = NULL;
9491da177e4SLinus Torvalds
9501da177e4SLinus Torvalds if (list_empty(&portlist))
9511da177e4SLinus Torvalds get_lowlevel_driver();
9521da177e4SLinus Torvalds
9531da177e4SLinus Torvalds spin_lock(&parportlist_lock);
9541da177e4SLinus Torvalds list_for_each_entry(port, &portlist, list) {
9551da177e4SLinus Torvalds if (port->base == base) {
9561da177e4SLinus Torvalds result = parport_get_port(port);
9571da177e4SLinus Torvalds break;
9581da177e4SLinus Torvalds }
9591da177e4SLinus Torvalds }
9601da177e4SLinus Torvalds spin_unlock(&parportlist_lock);
9611da177e4SLinus Torvalds return result;
9621da177e4SLinus Torvalds }
96327c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_find_base);
9641da177e4SLinus Torvalds
9651da177e4SLinus Torvalds /**
9661da177e4SLinus Torvalds * parport_claim - claim access to a parallel port device
9671da177e4SLinus Torvalds * @dev: pointer to structure representing a device on the port
9681da177e4SLinus Torvalds *
9691da177e4SLinus Torvalds * This function will not block and so can be used from interrupt
9701da177e4SLinus Torvalds * context. If parport_claim() succeeds in claiming access to
9711da177e4SLinus Torvalds * the port it returns zero and the port is available to use. It
9721da177e4SLinus Torvalds * may fail (returning non-zero) if the port is in use by another
9731da177e4SLinus Torvalds * driver and that driver is not willing to relinquish control of
9741da177e4SLinus Torvalds * the port.
9751da177e4SLinus Torvalds **/
9761da177e4SLinus Torvalds
parport_claim(struct pardevice * dev)9771da177e4SLinus Torvalds int parport_claim(struct pardevice *dev)
9781da177e4SLinus Torvalds {
9791da177e4SLinus Torvalds struct pardevice *oldcad;
9801da177e4SLinus Torvalds struct parport *port = dev->port->physport;
9811da177e4SLinus Torvalds unsigned long flags;
9821da177e4SLinus Torvalds
9831da177e4SLinus Torvalds if (port->cad == dev) {
984decf26f6SJoe Perches pr_info("%s: %s already owner\n", dev->port->name, dev->name);
9851da177e4SLinus Torvalds return 0;
9861da177e4SLinus Torvalds }
9871da177e4SLinus Torvalds
9881da177e4SLinus Torvalds /* Preempt any current device */
9891da177e4SLinus Torvalds write_lock_irqsave(&port->cad_lock, flags);
990e0a7f1f0SSudip Mukherjee oldcad = port->cad;
991e0a7f1f0SSudip Mukherjee if (oldcad) {
9921da177e4SLinus Torvalds if (oldcad->preempt) {
9931da177e4SLinus Torvalds if (oldcad->preempt(oldcad->private))
9941da177e4SLinus Torvalds goto blocked;
9951da177e4SLinus Torvalds port->ops->save_state(port, dev->state);
9961da177e4SLinus Torvalds } else
9971da177e4SLinus Torvalds goto blocked;
9981da177e4SLinus Torvalds
9991da177e4SLinus Torvalds if (port->cad != oldcad) {
10007b7a0a30SSudip Mukherjee /*
10017b7a0a30SSudip Mukherjee * I think we'll actually deadlock rather than
10027b7a0a30SSudip Mukherjee * get here, but just in case..
10037b7a0a30SSudip Mukherjee */
1004decf26f6SJoe Perches pr_warn("%s: %s released port when preempted!\n",
10051da177e4SLinus Torvalds port->name, oldcad->name);
10061da177e4SLinus Torvalds if (port->cad)
10071da177e4SLinus Torvalds goto blocked;
10081da177e4SLinus Torvalds }
10091da177e4SLinus Torvalds }
10101da177e4SLinus Torvalds
10111da177e4SLinus Torvalds /* Can't fail from now on, so mark ourselves as no longer waiting. */
10121da177e4SLinus Torvalds if (dev->waiting & 1) {
10131da177e4SLinus Torvalds dev->waiting = 0;
10141da177e4SLinus Torvalds
10151da177e4SLinus Torvalds /* Take ourselves out of the wait list again. */
10161da177e4SLinus Torvalds spin_lock_irq(&port->waitlist_lock);
10171da177e4SLinus Torvalds if (dev->waitprev)
10181da177e4SLinus Torvalds dev->waitprev->waitnext = dev->waitnext;
10191da177e4SLinus Torvalds else
10201da177e4SLinus Torvalds port->waithead = dev->waitnext;
10211da177e4SLinus Torvalds if (dev->waitnext)
10221da177e4SLinus Torvalds dev->waitnext->waitprev = dev->waitprev;
10231da177e4SLinus Torvalds else
10241da177e4SLinus Torvalds port->waittail = dev->waitprev;
10251da177e4SLinus Torvalds spin_unlock_irq(&port->waitlist_lock);
10261da177e4SLinus Torvalds dev->waitprev = dev->waitnext = NULL;
10271da177e4SLinus Torvalds }
10281da177e4SLinus Torvalds
10291da177e4SLinus Torvalds /* Now we do the change of devices */
10301da177e4SLinus Torvalds port->cad = dev;
10311da177e4SLinus Torvalds
10321da177e4SLinus Torvalds #ifdef CONFIG_PARPORT_1284
10331da177e4SLinus Torvalds /* If it's a mux port, select it. */
10341da177e4SLinus Torvalds if (dev->port->muxport >= 0) {
10351da177e4SLinus Torvalds /* FIXME */
10361da177e4SLinus Torvalds port->muxsel = dev->port->muxport;
10371da177e4SLinus Torvalds }
10381da177e4SLinus Torvalds
10391da177e4SLinus Torvalds /* If it's a daisy chain device, select it. */
10401da177e4SLinus Torvalds if (dev->daisy >= 0) {
10411da177e4SLinus Torvalds /* This could be lazier. */
10421da177e4SLinus Torvalds if (!parport_daisy_select(port, dev->daisy,
10431da177e4SLinus Torvalds IEEE1284_MODE_COMPAT))
10441da177e4SLinus Torvalds port->daisy = dev->daisy;
10451da177e4SLinus Torvalds }
10461da177e4SLinus Torvalds #endif /* IEEE1284.3 support */
10471da177e4SLinus Torvalds
10481da177e4SLinus Torvalds /* Restore control registers */
10491da177e4SLinus Torvalds port->ops->restore_state(port, dev->state);
10501da177e4SLinus Torvalds write_unlock_irqrestore(&port->cad_lock, flags);
10511da177e4SLinus Torvalds dev->time = jiffies;
10521da177e4SLinus Torvalds return 0;
10531da177e4SLinus Torvalds
10541da177e4SLinus Torvalds blocked:
10557b7a0a30SSudip Mukherjee /*
10567b7a0a30SSudip Mukherjee * If this is the first time we tried to claim the port, register an
10577b7a0a30SSudip Mukherjee * interest. This is only allowed for devices sleeping in
10587b7a0a30SSudip Mukherjee * parport_claim_or_block(), or those with a wakeup function.
10597b7a0a30SSudip Mukherjee */
10601da177e4SLinus Torvalds
10611da177e4SLinus Torvalds /* The cad_lock is still held for writing here */
10621da177e4SLinus Torvalds if (dev->waiting & 2 || dev->wakeup) {
10631da177e4SLinus Torvalds spin_lock(&port->waitlist_lock);
10641da177e4SLinus Torvalds if (test_and_set_bit(0, &dev->waiting) == 0) {
10651da177e4SLinus Torvalds /* First add ourselves to the end of the wait list. */
10661da177e4SLinus Torvalds dev->waitnext = NULL;
10671da177e4SLinus Torvalds dev->waitprev = port->waittail;
10681da177e4SLinus Torvalds if (port->waittail) {
10691da177e4SLinus Torvalds port->waittail->waitnext = dev;
10701da177e4SLinus Torvalds port->waittail = dev;
10711da177e4SLinus Torvalds } else
10721da177e4SLinus Torvalds port->waithead = port->waittail = dev;
10731da177e4SLinus Torvalds }
10741da177e4SLinus Torvalds spin_unlock(&port->waitlist_lock);
10751da177e4SLinus Torvalds }
10761da177e4SLinus Torvalds write_unlock_irqrestore(&port->cad_lock, flags);
10771da177e4SLinus Torvalds return -EAGAIN;
10781da177e4SLinus Torvalds }
107927c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_claim);
10801da177e4SLinus Torvalds
10811da177e4SLinus Torvalds /**
10821da177e4SLinus Torvalds * parport_claim_or_block - claim access to a parallel port device
10831da177e4SLinus Torvalds * @dev: pointer to structure representing a device on the port
10841da177e4SLinus Torvalds *
10851da177e4SLinus Torvalds * This behaves like parport_claim(), but will block if necessary
10861da177e4SLinus Torvalds * to wait for the port to be free. A return value of 1
10871da177e4SLinus Torvalds * indicates that it slept; 0 means that it succeeded without
10881da177e4SLinus Torvalds * needing to sleep. A negative error code indicates failure.
10891da177e4SLinus Torvalds **/
10901da177e4SLinus Torvalds
parport_claim_or_block(struct pardevice * dev)10911da177e4SLinus Torvalds int parport_claim_or_block(struct pardevice *dev)
10921da177e4SLinus Torvalds {
10931da177e4SLinus Torvalds int r;
10941da177e4SLinus Torvalds
10957b7a0a30SSudip Mukherjee /*
10967b7a0a30SSudip Mukherjee * Signal to parport_claim() that we can wait even without a
10977b7a0a30SSudip Mukherjee * wakeup function.
10987b7a0a30SSudip Mukherjee */
10991da177e4SLinus Torvalds dev->waiting = 2;
11001da177e4SLinus Torvalds
11011da177e4SLinus Torvalds /* Try to claim the port. If this fails, we need to sleep. */
11021da177e4SLinus Torvalds r = parport_claim(dev);
11031da177e4SLinus Torvalds if (r == -EAGAIN) {
11041da177e4SLinus Torvalds #ifdef PARPORT_DEBUG_SHARING
1105aa3d6e7cSJoe Perches printk(KERN_DEBUG "%s: parport_claim() returned -EAGAIN\n",
1106aa3d6e7cSJoe Perches dev->name);
11071da177e4SLinus Torvalds #endif
11081da177e4SLinus Torvalds /*
11091da177e4SLinus Torvalds * FIXME!!! Use the proper locking for dev->waiting,
11101da177e4SLinus Torvalds * and make this use the "wait_event_interruptible()"
11111da177e4SLinus Torvalds * interfaces. The cli/sti that used to be here
11121da177e4SLinus Torvalds * did nothing.
11131da177e4SLinus Torvalds *
11141da177e4SLinus Torvalds * See also parport_release()
11151da177e4SLinus Torvalds */
11161da177e4SLinus Torvalds
11177b7a0a30SSudip Mukherjee /*
11187b7a0a30SSudip Mukherjee * If dev->waiting is clear now, an interrupt
11197b7a0a30SSudip Mukherjee * gave us the port and we would deadlock if we slept.
11207b7a0a30SSudip Mukherjee */
11211da177e4SLinus Torvalds if (dev->waiting) {
112276ae0536SArnd Bergmann wait_event_interruptible(dev->wait_q,
112376ae0536SArnd Bergmann !dev->waiting);
112413efa75dSSudip Mukherjee if (signal_pending(current))
11251da177e4SLinus Torvalds return -EINTR;
11261da177e4SLinus Torvalds r = 1;
11271da177e4SLinus Torvalds } else {
11281da177e4SLinus Torvalds r = 0;
11291da177e4SLinus Torvalds #ifdef PARPORT_DEBUG_SHARING
11301da177e4SLinus Torvalds printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n",
11311da177e4SLinus Torvalds dev->name);
11321da177e4SLinus Torvalds #endif
11331da177e4SLinus Torvalds }
11341da177e4SLinus Torvalds
11351da177e4SLinus Torvalds #ifdef PARPORT_DEBUG_SHARING
11361da177e4SLinus Torvalds if (dev->port->physport->cad != dev)
1137a162188fSSudip Mukherjee printk(KERN_DEBUG "%s: exiting parport_claim_or_block but %s owns port!\n",
1138a162188fSSudip Mukherjee dev->name, dev->port->physport->cad ?
11391da177e4SLinus Torvalds dev->port->physport->cad->name : "nobody");
11401da177e4SLinus Torvalds #endif
11411da177e4SLinus Torvalds }
11421da177e4SLinus Torvalds dev->waiting = 0;
11431da177e4SLinus Torvalds return r;
11441da177e4SLinus Torvalds }
114527c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_claim_or_block);
11461da177e4SLinus Torvalds
11471da177e4SLinus Torvalds /**
11481da177e4SLinus Torvalds * parport_release - give up access to a parallel port device
11491da177e4SLinus Torvalds * @dev: pointer to structure representing parallel port device
11501da177e4SLinus Torvalds *
11511da177e4SLinus Torvalds * This function cannot fail, but it should not be called without
11521da177e4SLinus Torvalds * the port claimed. Similarly, if the port is already claimed
11531da177e4SLinus Torvalds * you should not try claiming it again.
11541da177e4SLinus Torvalds **/
11551da177e4SLinus Torvalds
parport_release(struct pardevice * dev)11561da177e4SLinus Torvalds void parport_release(struct pardevice *dev)
11571da177e4SLinus Torvalds {
11581da177e4SLinus Torvalds struct parport *port = dev->port->physport;
11591da177e4SLinus Torvalds struct pardevice *pd;
11601da177e4SLinus Torvalds unsigned long flags;
11611da177e4SLinus Torvalds
11621da177e4SLinus Torvalds /* Make sure that dev is the current device */
11631da177e4SLinus Torvalds write_lock_irqsave(&port->cad_lock, flags);
11641da177e4SLinus Torvalds if (port->cad != dev) {
11651da177e4SLinus Torvalds write_unlock_irqrestore(&port->cad_lock, flags);
1166decf26f6SJoe Perches pr_warn("%s: %s tried to release parport when not owner\n",
1167a162188fSSudip Mukherjee port->name, dev->name);
11681da177e4SLinus Torvalds return;
11691da177e4SLinus Torvalds }
11701da177e4SLinus Torvalds
11711da177e4SLinus Torvalds #ifdef CONFIG_PARPORT_1284
11721da177e4SLinus Torvalds /* If this is on a mux port, deselect it. */
11731da177e4SLinus Torvalds if (dev->port->muxport >= 0) {
11741da177e4SLinus Torvalds /* FIXME */
11751da177e4SLinus Torvalds port->muxsel = -1;
11761da177e4SLinus Torvalds }
11771da177e4SLinus Torvalds
11781da177e4SLinus Torvalds /* If this is a daisy device, deselect it. */
11791da177e4SLinus Torvalds if (dev->daisy >= 0) {
11801da177e4SLinus Torvalds parport_daisy_deselect_all(port);
11811da177e4SLinus Torvalds port->daisy = -1;
11821da177e4SLinus Torvalds }
11831da177e4SLinus Torvalds #endif
11841da177e4SLinus Torvalds
11851da177e4SLinus Torvalds port->cad = NULL;
11861da177e4SLinus Torvalds write_unlock_irqrestore(&port->cad_lock, flags);
11871da177e4SLinus Torvalds
11881da177e4SLinus Torvalds /* Save control registers */
11891da177e4SLinus Torvalds port->ops->save_state(port, dev->state);
11901da177e4SLinus Torvalds
11917b7a0a30SSudip Mukherjee /*
11927b7a0a30SSudip Mukherjee * If anybody is waiting, find out who's been there longest and
11937b7a0a30SSudip Mukherjee * then wake them up. (Note: no locking required)
11947b7a0a30SSudip Mukherjee */
11951da177e4SLinus Torvalds /* !!! LOCKING IS NEEDED HERE */
11961da177e4SLinus Torvalds for (pd = port->waithead; pd; pd = pd->waitnext) {
11971da177e4SLinus Torvalds if (pd->waiting & 2) { /* sleeping in claim_or_block */
11981da177e4SLinus Torvalds parport_claim(pd);
11991da177e4SLinus Torvalds if (waitqueue_active(&pd->wait_q))
12001da177e4SLinus Torvalds wake_up_interruptible(&pd->wait_q);
12011da177e4SLinus Torvalds return;
12021da177e4SLinus Torvalds } else if (pd->wakeup) {
12031da177e4SLinus Torvalds pd->wakeup(pd->private);
12041da177e4SLinus Torvalds if (dev->port->cad) /* racy but no matter */
12051da177e4SLinus Torvalds return;
12061da177e4SLinus Torvalds } else {
1207decf26f6SJoe Perches pr_err("%s: don't know how to wake %s\n",
1208decf26f6SJoe Perches port->name, pd->name);
12091da177e4SLinus Torvalds }
12101da177e4SLinus Torvalds }
12111da177e4SLinus Torvalds
12127b7a0a30SSudip Mukherjee /*
12137b7a0a30SSudip Mukherjee * Nobody was waiting, so walk the list to see if anyone is
12147b7a0a30SSudip Mukherjee * interested in being woken up. (Note: no locking required)
12157b7a0a30SSudip Mukherjee */
12161da177e4SLinus Torvalds /* !!! LOCKING IS NEEDED HERE */
1217b95b9d6cSSudip Mukherjee for (pd = port->devices; !port->cad && pd; pd = pd->next) {
12181da177e4SLinus Torvalds if (pd->wakeup && pd != dev)
12191da177e4SLinus Torvalds pd->wakeup(pd->private);
12201da177e4SLinus Torvalds }
12211da177e4SLinus Torvalds }
122227c6db26SSudip Mukherjee EXPORT_SYMBOL(parport_release);
12231da177e4SLinus Torvalds
parport_irq_handler(int irq,void * dev_id)12243f2e40dfSJeff Garzik irqreturn_t parport_irq_handler(int irq, void *dev_id)
12253f2e40dfSJeff Garzik {
12263f2e40dfSJeff Garzik struct parport *port = dev_id;
12273f2e40dfSJeff Garzik
1228f230d101SJeff Garzik parport_generic_irq(port);
12293f2e40dfSJeff Garzik
12303f2e40dfSJeff Garzik return IRQ_HANDLED;
12313f2e40dfSJeff Garzik }
12323f2e40dfSJeff Garzik EXPORT_SYMBOL(parport_irq_handler);
12331da177e4SLinus Torvalds
12341da177e4SLinus Torvalds MODULE_LICENSE("GPL");
1235