Skip to content

Commit

Permalink
parport: remove unused parport_register_device()
Browse files Browse the repository at this point in the history 
All the drivers that are using parallel port has been converted to use
the new device model api, and parport_register_device() is no longer
used.

Signed-off-by: Sudip Mukherjee <[email protected]>
Link: https://lore.kernel.org/r/[email protected]
Signed-off-by: Greg Kroah-Hartman <[email protected]>
  • Loading branch information
@sudipm-mukherjee @gregkh
sudipm-mukherjee authored and gregkh committed Apr 23, 2020
1 parent 6824f0c commit bae9def
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 204 deletions.
192 changes: 0 additions & 192 deletions drivers/parport/share.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -641,198 +641,6 @@ void parport_remove_port(struct parport *port)
}
EXPORT_SYMBOL(parport_remove_port);

/**
* parport_register_device - register a device on a parallel port
* @port: port to which the device is attached
* @name: a name to refer to the device
* @pf: preemption callback
* @kf: kick callback (wake-up)
* @irq_func: interrupt handler
* @flags: registration flags
* @handle: data for callback functions
*
* This function, called by parallel port device drivers,
* declares that a device is connected to a port, and tells the
* system all it needs to know.
*
* The @name is allocated by the caller and must not be
* deallocated until the caller calls @parport_unregister_device
* for that device.
*
* The preemption callback function, @pf, is called when this
* device driver has claimed access to the port but another
* device driver wants to use it. It is given @handle as its
* parameter, and should return zero if it is willing for the
* system to release the port to another driver on its behalf.
* If it wants to keep control of the port it should return
* non-zero, and no action will be taken. It is good manners for
* the driver to try to release the port at the earliest
* opportunity after its preemption callback rejects a preemption
* attempt. Note that if a preemption callback is happy for
* preemption to go ahead, there is no need to release the port;
* it is done automatically. This function may not block, as it
* may be called from interrupt context. If the device driver
* does not support preemption, @pf can be %NULL.
*
* The wake-up ("kick") callback function, @kf, is called when
* the port is available to be claimed for exclusive access; that
* is, parport_claim() is guaranteed to succeed when called from
* inside the wake-up callback function. If the driver wants to
* claim the port it should do so; otherwise, it need not take
* any action. This function may not block, as it may be called
* from interrupt context. If the device driver does not want to
* be explicitly invited to claim the port in this way, @kf can
* be %NULL.
*
* The interrupt handler, @irq_func, is called when an interrupt
* arrives from the parallel port. Note that if a device driver
* wants to use interrupts it should use parport_enable_irq(),
* and can also check the irq member of the parport structure
* representing the port.
*
* The parallel port (lowlevel) driver is the one that has called
* request_irq() and whose interrupt handler is called first.
* This handler does whatever needs to be done to the hardware to
* acknowledge the interrupt (for PC-style ports there is nothing
* special to be done). It then tells the IEEE 1284 code about
* the interrupt, which may involve reacting to an IEEE 1284
* event depending on the current IEEE 1284 phase. After this,
* it calls @irq_func. Needless to say, @irq_func will be called
* from interrupt context, and may not block.
*
* The %PARPORT_DEV_EXCL flag is for preventing port sharing, and
* so should only be used when sharing the port with other device
* drivers is impossible and would lead to incorrect behaviour.
* Use it sparingly! Normally, @flags will be zero.
*
* This function returns a pointer to a structure that represents
* the device on the port, or %NULL if there is not enough memory
* to allocate space for that structure.
**/

struct pardevice *
parport_register_device(struct parport *port, const char *name,
int (*pf)(void *), void (*kf)(void *),
void (*irq_func)(void *),
int flags, void *handle)
{
struct pardevice *tmp;

if (port->physport->flags & PARPORT_FLAG_EXCL) {
/* An exclusive device is registered. */
printk(KERN_DEBUG "%s: no more devices allowed\n", port->name);
return NULL;
}

if (flags & PARPORT_DEV_LURK) {
if (!pf || !kf) {
pr_info("%s: refused to register lurking device (%s) without callbacks\n",
port->name, name);
return NULL;
}
}

if (flags & PARPORT_DEV_EXCL) {
if (port->physport->devices) {
/*
* If a device is already registered and this new
* device wants exclusive access, then no need to
* continue as we can not grant exclusive access to
* this device.
*/
pr_err("%s: cannot grant exclusive access for device %s\n",
port->name, name);
return NULL;
}
}

/*
* We up our own module reference count, and that of the port
* on which a device is to be registered, to ensure that
* neither of us gets unloaded while we sleep in (e.g.)
* kmalloc.
*/
if (!try_module_get(port->ops->owner))
return NULL;

parport_get_port(port);

tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL);
if (!tmp)
goto out;

tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL);
if (!tmp->state)
goto out_free_pardevice;

tmp->name = name;
tmp->port = port;
tmp->daisy = -1;
tmp->preempt = pf;
tmp->wakeup = kf;
tmp->private = handle;
tmp->flags = flags;
tmp->irq_func = irq_func;
tmp->waiting = 0;
tmp->timeout = 5 * HZ;
tmp->devmodel = false;

/* Chain this onto the list */
tmp->prev = NULL;
/*
* This function must not run from an irq handler so we don' t need
* to clear irq on the local CPU. -arca
*/
spin_lock(&port->physport->pardevice_lock);

if (flags & PARPORT_DEV_EXCL) {
if (port->physport->devices) {
spin_unlock(&port->physport->pardevice_lock);
printk(KERN_DEBUG "%s: cannot grant exclusive access for device %s\n",
port->name, name);
goto out_free_all;
}
port->flags |= PARPORT_FLAG_EXCL;
}

tmp->next = port->physport->devices;
wmb(); /*
* Make sure that tmp->next is written before it's
* added to the list; see comments marked 'no locking
* required'
*/
if (port->physport->devices)
port->physport->devices->prev = tmp;
port->physport->devices = tmp;
spin_unlock(&port->physport->pardevice_lock);

init_waitqueue_head(&tmp->wait_q);
tmp->timeslice = parport_default_timeslice;
tmp->waitnext = tmp->waitprev = NULL;

/*
* This has to be run as last thing since init_state may need other
* pardevice fields. -arca
*/
port->ops->init_state(tmp, tmp->state);
if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) {
port->proc_device = tmp;
parport_device_proc_register(tmp);
}
return tmp;

out_free_all:
kfree(tmp->state);
out_free_pardevice:
kfree(tmp);
out:
parport_put_port(port);
module_put(port->ops->owner);

return NULL;
}
EXPORT_SYMBOL(parport_register_device);

static void free_pardevice(struct device *dev)
{
struct pardevice *par_dev = to_pardevice(dev);
Expand Down
12 changes: 0 additions & 12 deletions include/linux/parport.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -325,18 +325,6 @@ struct pardev_cb {
unsigned int flags;
};

/* parport_register_device declares that a device is connected to a
port, and tells the kernel all it needs to know.
- pf is the preemption function (may be NULL for no callback)
- kf is the wake-up function (may be NULL for no callback)
- irq_func is the interrupt handler (may be NULL for no interrupts)
- handle is a user pointer that gets handed to callback functions. */
struct pardevice *parport_register_device(struct parport *port,
const char *name,
int (*pf)(void *), void (*kf)(void *),
void (*irq_func)(void *),
int flags, void *handle);

/*
* parport_register_dev_model declares that a device is connected to a
* port, and tells the kernel all it needs to know.
Expand Down

0 comments on commit bae9def

Please sign in to comment.