Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Staging: sep: Implement some proper open/close methods

Browse source 
Use the mutex as a protection for open close rather than leaving it hanging
invalidly across userspace.

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Alan Cox 2009-08-14 15:41:16 +01:00 committed by Greg Kroah-Hartman
parent 6f13ea3df5
commit 4c29e97998
2 changed files with 54 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/staging/sep/sep_dev.h
View file

@ -32,6 +32,8 @@ struct sep_device {
/* pointer to pci dev */
struct pci_dev *pdev;
unsigned long in_use;
unsigned long io_bus;
unsigned long io_end_bus;
unsigned long io_memory_size;

93
drivers/staging/sep/sep_driver.c
View file

@ -296,53 +296,67 @@ static void *sep_shared_area_bus_to_virt(struct sep_device *sep,
}
/*----------------------------------------------------------------------
open function of the character driver - must only lock the mutex
must also release the memory data pool allocations
------------------------------------------------------------------------*/
/**
* sep_try_open - attempt to open a SEP device
* @sep: device to attempt to open
*
* Atomically attempt to get ownership of a SEP device.
* Returns 1 if the device was opened, 0 on failure.
*/
static int sep_try_open(struct sep_device *sep)
{
if (!test_and_set_bit(0, &sep->in_use))
return 1;
return 0;
}
/**
* sep_open - device open method
* @inode: inode of sep device
* @filp: file handle to sep device
*
* Open method for the SEP device. Called when userspace opens
* the SEP device node. Must also release the memory data pool
* allocations.
*
* Returns zero on success otherwise an error code.
*/
static int sep_open(struct inode *inode, struct file *filp)
{
int error = 0;
dbg("SEP Driver:--------> open start\n");
/* check the blocking mode */
if (filp->f_flags & O_NDELAY)
error = mutex_trylock(&sep_mutex);
else
/* lock mutex */
mutex_lock(&sep_mutex);
/* check the error */
if (error) {
edbg("SEP Driver: down_interruptible failed\n");
goto end_function;
}
/* Bind to the device, we only have one which makes it easy */
filp->private_data = sep_dev;
if (sep_dev == NULL)
return -ENODEV;
/* check the blocking mode */
if (filp->f_flags & O_NDELAY) {
if (sep_try_open(sep_dev) == 0)
return -EAGAIN;
} else
if (wait_event_interruptible(sep_event, sep_try_open(sep_dev)) < 0)
return -EINTR;
/* Bind to the device, we only have one which makes it easy */
filp->private_data = sep_dev;
/* release data pool allocations */
sep_dev->data_pool_bytes_allocated = 0;
end_function:
dbg("SEP Driver:<-------- open end\n");
return error;
return 0;
}
/**
* sep_release - close a SEP device
* @inode: inode of SEP device
* @filp: file handle being closed
*
* Called on the final close of a SEP device. As the open protects against
* multiple simultaenous opens that means this method is called when the
* final reference to the open handle is dropped.
*/
/*------------------------------------------------------------
release function
-------------------------------------------------------------*/
static int sep_release(struct inode *inode_ptr, struct file *filp)
static int sep_release(struct inode *inode, struct file *filp)
{
struct sep_driver *sep = filp->private_data;
dbg("----------->SEP Driver: sep_release start\n");
struct sep_device *sep = filp->private_data;
#if 0 /*!SEP_DRIVER_POLLING_MODE */
/* close IMR */
sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, 0x7FFF);
@ -350,15 +364,12 @@ static int sep_release(struct inode *inode_ptr, struct file *filp)
free_irq(SEP_DIRVER_IRQ_NUM, sep);
#endif
/* unlock the sep mutex */
mutex_unlock(&sep_mutex);
dbg("SEP Driver:<-------- sep_release end\n");
/* Ensure any blocked open progresses */
clear_bit(0, &sep->in_use);
wake_up(&sep_event);
return 0;
}
/*---------------------------------------------------------------
map function - this functions maps the message shared area
-----------------------------------------------------------------*/