lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[media] lirc_zilog: Split struct IR into structs IR, IR_tx, and IR_rx

Browse Source 
This change is a mostly mechanical break of the main struct IR
data structure into common, Rx, and Tx structures.  There were some
small logical changes required as well, such as eliminating "is_hdpvr",
to accomplish this.

This change is an intiial step in reworking lirc_zilog to decouple the
Rx and Tx handling as much as possible to fit with the new I2C
binding model.  This change actually makes lirc_zilog a little more
broken than it already was - memory deallocation in particular got worse.
However, this change makes the remaining problems easier to see and address.

Signed-off-by: Andy Walls <awalls@md.metrocast.net>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Andy Walls
2011-01-13 02:00:33 -03:00
committed by Mauro Carvalho Chehab
parent 02fcaaa3a5
commit 06da95a3ec
1 changed files with 171 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
drivers/staging/lirc/lirc_zilog.c
View File

@@ -60,17 +60,9 @@
#include <media/lirc_dev.h> #include <media/lirc_dev.h>
#include <media/lirc.h> #include <media/lirc.h>
struct IR { struct IR_rx {
struct lirc_driver l;
/* Device info */
struct mutex ir_lock;
int open;
bool is_hdpvr;
/* RX device */ /* RX device */
struct i2c_client c_rx; struct i2c_client c_rx;
int have_rx;
/* RX device buffer & lock */ /* RX device buffer & lock */
struct lirc_buffer buf; struct lirc_buffer buf;
@@ -84,11 +76,26 @@ struct IR {
/* RX read data */ /* RX read data */
unsigned char b[3]; unsigned char b[3];
bool hdpvr_data_fmt;
};
struct IR_tx {
/* TX device */ /* TX device */
struct i2c_client c_tx; struct i2c_client c_tx;
/* TX additional actions needed */
int need_boot; int need_boot;
int have_tx; bool post_tx_ready_poll;
};
struct IR {
struct lirc_driver l;
struct mutex ir_lock;
int open;
struct IR_rx *rx;
struct IR_tx *tx;
}; };
/* Minor -> data mapping */ /* Minor -> data mapping */
@@ -149,8 +156,12 @@ static int add_to_buf(struct IR *ir)
int ret; int ret;
int failures = 0; int failures = 0;
unsigned char sendbuf[1] = { 0 }; unsigned char sendbuf[1] = { 0 };
struct IR_rx *rx = ir->rx;
if (lirc_buffer_full(&ir->buf)) { if (rx == NULL)
return -ENXIO;
if (lirc_buffer_full(&rx->buf)) {
dprintk("buffer overflow\n"); dprintk("buffer overflow\n");
return -EOVERFLOW; return -EOVERFLOW;
} }
@@ -170,7 +181,7 @@ static int add_to_buf(struct IR *ir)
* Send random "poll command" (?) Windows driver does this * Send random "poll command" (?) Windows driver does this
* and it is a good point to detect chip failure. * and it is a good point to detect chip failure.
*/ */
ret = i2c_master_send(&ir->c_rx, sendbuf, 1); ret = i2c_master_send(&rx->c_rx, sendbuf, 1);
if (ret != 1) { if (ret != 1) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
if (failures >= 3) { if (failures >= 3) {
@@ -186,44 +197,45 @@ static int add_to_buf(struct IR *ir)
set_current_state(TASK_UNINTERRUPTIBLE); set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((100 * HZ + 999) / 1000); schedule_timeout((100 * HZ + 999) / 1000);
ir->need_boot = 1; if (ir->tx != NULL)
ir->tx->need_boot = 1;
++failures; ++failures;
mutex_unlock(&ir->ir_lock); mutex_unlock(&ir->ir_lock);
continue; continue;
} }
ret = i2c_master_recv(&ir->c_rx, keybuf, sizeof(keybuf)); ret = i2c_master_recv(&rx->c_rx, keybuf, sizeof(keybuf));
mutex_unlock(&ir->ir_lock); mutex_unlock(&ir->ir_lock);
if (ret != sizeof(keybuf)) { if (ret != sizeof(keybuf)) {
zilog_error("i2c_master_recv failed with %d -- " zilog_error("i2c_master_recv failed with %d -- "
"keeping last read buffer\n", ret); "keeping last read buffer\n", ret);
} else { } else {
ir->b[0] = keybuf[3]; rx->b[0] = keybuf[3];
ir->b[1] = keybuf[4]; rx->b[1] = keybuf[4];
ir->b[2] = keybuf[5]; rx->b[2] = keybuf[5];
dprintk("key (0x%02x/0x%02x)\n", ir->b[0], ir->b[1]); dprintk("key (0x%02x/0x%02x)\n", rx->b[0], rx->b[1]);
} }
/* key pressed ? */ /* key pressed ? */
if (ir->is_hdpvr) { if (rx->hdpvr_data_fmt) {
if (got_data && (keybuf[0] == 0x80)) if (got_data && (keybuf[0] == 0x80))
return 0; return 0;
else if (got_data && (keybuf[0] == 0x00)) else if (got_data && (keybuf[0] == 0x00))
return -ENODATA; return -ENODATA;
} else if ((ir->b[0] & 0x80) == 0) } else if ((rx->b[0] & 0x80) == 0)
return got_data ? 0 : -ENODATA; return got_data ? 0 : -ENODATA;
/* look what we have */ /* look what we have */
code = (((__u16)ir->b[0] & 0x7f) << 6) | (ir->b[1] >> 2); code = (((__u16)rx->b[0] & 0x7f) << 6) | (rx->b[1] >> 2);
codes[0] = (code >> 8) & 0xff; codes[0] = (code >> 8) & 0xff;
codes[1] = code & 0xff; codes[1] = code & 0xff;
/* return it */ /* return it */
lirc_buffer_write(&ir->buf, codes); lirc_buffer_write(&rx->buf, codes);
++got_data; ++got_data;
} while (!lirc_buffer_full(&ir->buf)); } while (!lirc_buffer_full(&rx->buf));
return 0; return 0;
} }
@@ -241,9 +253,13 @@ static int add_to_buf(struct IR *ir)
static int lirc_thread(void *arg) static int lirc_thread(void *arg)
{ {
struct IR *ir = arg; struct IR *ir = arg;
struct IR_rx *rx = ir->rx;
if (ir->t_notify != NULL) if (rx == NULL)
complete(ir->t_notify); return -ENXIO;
if (rx->t_notify != NULL)
complete(rx->t_notify);
dprintk("poll thread started\n"); dprintk("poll thread started\n");
@@ -264,23 +280,23 @@ static int lirc_thread(void *arg)
* lost keypresses. * lost keypresses.
*/ */
schedule_timeout((260 * HZ) / 1000); schedule_timeout((260 * HZ) / 1000);
if (ir->shutdown) if (rx->shutdown)
break; break;
if (!add_to_buf(ir)) if (!add_to_buf(ir))
wake_up_interruptible(&ir->buf.wait_poll); wake_up_interruptible(&rx->buf.wait_poll);
} else { } else {
/* if device not opened so we can sleep half a second */ /* if device not opened so we can sleep half a second */
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/2); schedule_timeout(HZ/2);
} }
} while (!ir->shutdown); } while (!rx->shutdown);
if (ir->t_notify2 != NULL) if (rx->t_notify2 != NULL)
wait_for_completion(ir->t_notify2); wait_for_completion(rx->t_notify2);
ir->task = NULL; rx->task = NULL;
if (ir->t_notify != NULL) if (rx->t_notify != NULL)
complete(ir->t_notify); complete(rx->t_notify);
dprintk("poll thread ended\n"); dprintk("poll thread ended\n");
return 0; return 0;
@@ -298,10 +314,10 @@ static int set_use_inc(void *data)
* this is completely broken code. lirc_unregister_driver() * this is completely broken code. lirc_unregister_driver()
* must be possible even when the device is open * must be possible even when the device is open
*/ */
if (ir->c_rx.addr) if (ir->rx != NULL)
i2c_use_client(&ir->c_rx); i2c_use_client(&ir->rx->c_rx);
if (ir->c_tx.addr) if (ir->tx != NULL)
i2c_use_client(&ir->c_tx); i2c_use_client(&ir->tx->c_tx);
return 0; return 0;
} }
@@ -310,10 +326,10 @@ static void set_use_dec(void *data)
{ {
struct IR *ir = data; struct IR *ir = data;
if (ir->c_rx.addr) if (ir->rx)
i2c_release_client(&ir->c_rx); i2c_release_client(&ir->rx->c_rx);
if (ir->c_tx.addr) if (ir->tx)
i2c_release_client(&ir->c_tx); i2c_release_client(&ir->tx->c_tx);
if (ir->l.owner != NULL) if (ir->l.owner != NULL)
module_put(ir->l.owner); module_put(ir->l.owner);
} }
@@ -452,7 +468,7 @@ corrupt:
} }
/* send a block of data to the IR TX device */ /* send a block of data to the IR TX device */
static int send_data_block(struct IR *ir, unsigned char *data_block) static int send_data_block(struct IR_tx *tx, unsigned char *data_block)
{ {
int i, j, ret; int i, j, ret;
unsigned char buf[5]; unsigned char buf[5];
@@ -466,7 +482,7 @@ static int send_data_block(struct IR *ir, unsigned char *data_block)
buf[1 + j] = data_block[i + j]; buf[1 + j] = data_block[i + j];
dprintk("%02x %02x %02x %02x %02x", dprintk("%02x %02x %02x %02x %02x",
buf[0], buf[1], buf[2], buf[3], buf[4]); buf[0], buf[1], buf[2], buf[3], buf[4]);
ret = i2c_master_send(&ir->c_tx, buf, tosend + 1); ret = i2c_master_send(&tx->c_tx, buf, tosend + 1);
if (ret != tosend + 1) { if (ret != tosend + 1) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
@@ -477,32 +493,32 @@ static int send_data_block(struct IR *ir, unsigned char *data_block)
} }
/* send boot data to the IR TX device */ /* send boot data to the IR TX device */
static int send_boot_data(struct IR *ir) static int send_boot_data(struct IR_tx *tx)
{ {
int ret; int ret;
unsigned char buf[4]; unsigned char buf[4];
/* send the boot block */ /* send the boot block */
ret = send_data_block(ir, tx_data->boot_data); ret = send_data_block(tx, tx_data->boot_data);
if (ret != 0) if (ret != 0)
return ret; return ret;
/* kick it off? */ /* kick it off? */
buf[0] = 0x00; buf[0] = 0x00;
buf[1] = 0x20; buf[1] = 0x20;
ret = i2c_master_send(&ir->c_tx, buf, 2); ret = i2c_master_send(&tx->c_tx, buf, 2);
if (ret != 2) { if (ret != 2) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
} }
ret = i2c_master_send(&ir->c_tx, buf, 1); ret = i2c_master_send(&tx->c_tx, buf, 1);
if (ret != 1) { if (ret != 1) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
} }
/* Here comes the firmware version... (hopefully) */ /* Here comes the firmware version... (hopefully) */
ret = i2c_master_recv(&ir->c_tx, buf, 4); ret = i2c_master_recv(&tx->c_tx, buf, 4);
if (ret != 4) { if (ret != 4) {
zilog_error("i2c_master_recv failed with %d\n", ret); zilog_error("i2c_master_recv failed with %d\n", ret);
return 0; return 0;
@@ -542,7 +558,7 @@ static void fw_unload(void)
} }
/* load "firmware" for the IR TX device */ /* load "firmware" for the IR TX device */
static int fw_load(struct IR *ir) static int fw_load(struct IR_tx *tx)
{ {
int ret; int ret;
unsigned int i; unsigned int i;
@@ -557,7 +573,7 @@ static int fw_load(struct IR *ir)
} }
/* Request codeset data file */ /* Request codeset data file */
ret = request_firmware(&fw_entry, "haup-ir-blaster.bin", &ir->c_tx.dev); ret = request_firmware(&fw_entry, "haup-ir-blaster.bin", &tx->c_tx.dev);
if (ret != 0) { if (ret != 0) {
zilog_error("firmware haup-ir-blaster.bin not available " zilog_error("firmware haup-ir-blaster.bin not available "
"(%d)\n", ret); "(%d)\n", ret);
@@ -684,20 +700,20 @@ out:
} }
/* initialise the IR TX device */ /* initialise the IR TX device */
static int tx_init(struct IR *ir) static int tx_init(struct IR_tx *tx)
{ {
int ret; int ret;
/* Load 'firmware' */ /* Load 'firmware' */
ret = fw_load(ir); ret = fw_load(tx);
if (ret != 0) if (ret != 0)
return ret; return ret;
/* Send boot block */ /* Send boot block */
ret = send_boot_data(ir); ret = send_boot_data(tx);
if (ret != 0) if (ret != 0)
return ret; return ret;
ir->need_boot = 0; tx->need_boot = 0;
/* Looks good */ /* Looks good */
return 0; return 0;
@@ -713,20 +729,20 @@ static loff_t lseek(struct file *filep, loff_t offset, int orig)
static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos) static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos)
{ {
struct IR *ir = filep->private_data; struct IR *ir = filep->private_data;
unsigned char buf[ir->buf.chunk_size]; struct IR_rx *rx = ir->rx;
int ret = 0, written = 0; int ret = 0, written = 0;
DECLARE_WAITQUEUE(wait, current); DECLARE_WAITQUEUE(wait, current);
dprintk("read called\n"); dprintk("read called\n");
if (ir->c_rx.addr == 0) if (rx == NULL)
return -ENODEV; return -ENODEV;
if (mutex_lock_interruptible(&ir->buf_lock)) if (mutex_lock_interruptible(&rx->buf_lock))
return -ERESTARTSYS; return -ERESTARTSYS;
if (n % ir->buf.chunk_size) { if (n % rx->buf.chunk_size) {
dprintk("read result = -EINVAL\n"); dprintk("read result = -EINVAL\n");
mutex_unlock(&ir->buf_lock); mutex_unlock(&rx->buf_lock);
return -EINVAL; return -EINVAL;
} }
@@ -735,7 +751,7 @@ static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos)
* to avoid losing scan code (in case when queue is awaken somewhere * to avoid losing scan code (in case when queue is awaken somewhere
* between while condition checking and scheduling) * between while condition checking and scheduling)
*/ */
add_wait_queue(&ir->buf.wait_poll, &wait); add_wait_queue(&rx->buf.wait_poll, &wait);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
/* /*
@@ -743,7 +759,7 @@ static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos)
* mode and 'copy_to_user' is happy, wait for data. * mode and 'copy_to_user' is happy, wait for data.
*/ */
while (written < n && ret == 0) { while (written < n && ret == 0) {
if (lirc_buffer_empty(&ir->buf)) { if (lirc_buffer_empty(&rx->buf)) {
/* /*
* According to the read(2) man page, 'written' can be * According to the read(2) man page, 'written' can be
* returned as less than 'n', instead of blocking * returned as less than 'n', instead of blocking
@@ -763,16 +779,17 @@ static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos)
schedule(); schedule();
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
} else { } else {
lirc_buffer_read(&ir->buf, buf); unsigned char buf[rx->buf.chunk_size];
lirc_buffer_read(&rx->buf, buf);
ret = copy_to_user((void *)outbuf+written, buf, ret = copy_to_user((void *)outbuf+written, buf,
ir->buf.chunk_size); rx->buf.chunk_size);
written += ir->buf.chunk_size; written += rx->buf.chunk_size;
} }
} }
remove_wait_queue(&ir->buf.wait_poll, &wait); remove_wait_queue(&rx->buf.wait_poll, &wait);
set_current_state(TASK_RUNNING); set_current_state(TASK_RUNNING);
mutex_unlock(&ir->buf_lock); mutex_unlock(&rx->buf_lock);
dprintk("read result = %s (%d)\n", dprintk("read result = %s (%d)\n",
ret ? "-EFAULT" : "OK", ret); ret ? "-EFAULT" : "OK", ret);
@@ -781,7 +798,7 @@ static ssize_t read(struct file *filep, char *outbuf, size_t n, loff_t *ppos)
} }
/* send a keypress to the IR TX device */ /* send a keypress to the IR TX device */
static int send_code(struct IR *ir, unsigned int code, unsigned int key) static int send_code(struct IR_tx *tx, unsigned int code, unsigned int key)
{ {
unsigned char data_block[TX_BLOCK_SIZE]; unsigned char data_block[TX_BLOCK_SIZE];
unsigned char buf[2]; unsigned char buf[2];
@@ -798,26 +815,26 @@ static int send_code(struct IR *ir, unsigned int code, unsigned int key)
return ret; return ret;
/* Send the data block */ /* Send the data block */
ret = send_data_block(ir, data_block); ret = send_data_block(tx, data_block);
if (ret != 0) if (ret != 0)
return ret; return ret;
/* Send data block length? */ /* Send data block length? */
buf[0] = 0x00; buf[0] = 0x00;
buf[1] = 0x40; buf[1] = 0x40;
ret = i2c_master_send(&ir->c_tx, buf, 2); ret = i2c_master_send(&tx->c_tx, buf, 2);
if (ret != 2) { if (ret != 2) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
} }
ret = i2c_master_send(&ir->c_tx, buf, 1); ret = i2c_master_send(&tx->c_tx, buf, 1);
if (ret != 1) { if (ret != 1) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
} }
/* Send finished download? */ /* Send finished download? */
ret = i2c_master_recv(&ir->c_tx, buf, 1); ret = i2c_master_recv(&tx->c_tx, buf, 1);
if (ret != 1) { if (ret != 1) {
zilog_error("i2c_master_recv failed with %d\n", ret); zilog_error("i2c_master_recv failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
@@ -831,7 +848,7 @@ static int send_code(struct IR *ir, unsigned int code, unsigned int key)
/* Send prepare command? */ /* Send prepare command? */
buf[0] = 0x00; buf[0] = 0x00;
buf[1] = 0x80; buf[1] = 0x80;
ret = i2c_master_send(&ir->c_tx, buf, 2); ret = i2c_master_send(&tx->c_tx, buf, 2);
if (ret != 2) { if (ret != 2) {
zilog_error("i2c_master_send failed with %d\n", ret); zilog_error("i2c_master_send failed with %d\n", ret);
return ret < 0 ? ret : -EFAULT; return ret < 0 ? ret : -EFAULT;
@@ -842,7 +859,7 @@ static int send_code(struct IR *ir, unsigned int code, unsigned int key)
* last i2c_master_recv always fails with a -5, so for now, we're * last i2c_master_recv always fails with a -5, so for now, we're
* going to skip this whole mess and say we're done on the HD PVR * going to skip this whole mess and say we're done on the HD PVR
*/ */
if (ir->is_hdpvr) { if (!tx->post_tx_ready_poll) {
dprintk("sent code %u, key %u\n", code, key); dprintk("sent code %u, key %u\n", code, key);
return 0; return 0;
} }
@@ -856,7 +873,7 @@ static int send_code(struct IR *ir, unsigned int code, unsigned int key)
for (i = 0; i < 20; ++i) { for (i = 0; i < 20; ++i) {
set_current_state(TASK_UNINTERRUPTIBLE); set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((50 * HZ + 999) / 1000); schedule_timeout((50 * HZ + 999) / 1000);
ret = i2c_master_send(&ir->c_tx, buf, 1); ret = i2c_master_send(&tx->c_tx, buf, 1);
if (ret == 1) if (ret == 1)
break; break;
dprintk("NAK expected: i2c_master_send " dprintk("NAK expected: i2c_master_send "
@@ -869,7 +886,7 @@ static int send_code(struct IR *ir, unsigned int code, unsigned int key)
} }
/* Seems to be an 'ok' response */ /* Seems to be an 'ok' response */
i = i2c_master_recv(&ir->c_tx, buf, 1); i = i2c_master_recv(&tx->c_tx, buf, 1);
if (i != 1) { if (i != 1) {
zilog_error("i2c_master_recv failed with %d\n", ret); zilog_error("i2c_master_recv failed with %d\n", ret);
return -EFAULT; return -EFAULT;
@@ -894,10 +911,11 @@ static ssize_t write(struct file *filep, const char *buf, size_t n,
loff_t *ppos) loff_t *ppos)
{ {
struct IR *ir = filep->private_data; struct IR *ir = filep->private_data;
struct IR_tx *tx = ir->tx;
size_t i; size_t i;
int failures = 0; int failures = 0;
if (ir->c_tx.addr == 0) if (tx == NULL)
return -ENODEV; return -ENODEV;
/* Validate user parameters */ /* Validate user parameters */
@@ -918,15 +936,15 @@ static ssize_t write(struct file *filep, const char *buf, size_t n,
} }
/* Send boot data first if required */ /* Send boot data first if required */
if (ir->need_boot == 1) { if (tx->need_boot == 1) {
ret = send_boot_data(ir); ret = send_boot_data(tx);
if (ret == 0) if (ret == 0)
ir->need_boot = 0; tx->need_boot = 0;
} }
/* Send the code */ /* Send the code */
if (ret == 0) { if (ret == 0) {
ret = send_code(ir, (unsigned)command >> 16, ret = send_code(tx, (unsigned)command >> 16,
(unsigned)command & 0xFFFF); (unsigned)command & 0xFFFF);
if (ret == -EPROTO) { if (ret == -EPROTO) {
mutex_unlock(&ir->ir_lock); mutex_unlock(&ir->ir_lock);
@@ -951,7 +969,7 @@ static ssize_t write(struct file *filep, const char *buf, size_t n,
} }
set_current_state(TASK_UNINTERRUPTIBLE); set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((100 * HZ + 999) / 1000); schedule_timeout((100 * HZ + 999) / 1000);
ir->need_boot = 1; tx->need_boot = 1;
++failures; ++failures;
} else } else
i += sizeof(int); i += sizeof(int);
@@ -968,22 +986,23 @@ static ssize_t write(struct file *filep, const char *buf, size_t n,
static unsigned int poll(struct file *filep, poll_table *wait) static unsigned int poll(struct file *filep, poll_table *wait)
{ {
struct IR *ir = filep->private_data; struct IR *ir = filep->private_data;
struct IR_rx *rx = ir->rx;
unsigned int ret; unsigned int ret;
dprintk("poll called\n"); dprintk("poll called\n");
if (ir->c_rx.addr == 0) if (rx == NULL)
return -ENODEV; return -ENODEV;
mutex_lock(&ir->buf_lock); mutex_lock(&rx->buf_lock);
poll_wait(filep, &ir->buf.wait_poll, wait); poll_wait(filep, &rx->buf.wait_poll, wait);
dprintk("poll result = %s\n", dprintk("poll result = %s\n",
lirc_buffer_empty(&ir->buf) ? "0" : "POLLIN|POLLRDNORM"); lirc_buffer_empty(&rx->buf) ? "0" : "POLLIN|POLLRDNORM");
ret = lirc_buffer_empty(&ir->buf) ? 0 : (POLLIN|POLLRDNORM); ret = lirc_buffer_empty(&rx->buf) ? 0 : (POLLIN|POLLRDNORM);
mutex_unlock(&ir->buf_lock); mutex_unlock(&rx->buf_lock);
return ret; return ret;
} }
@@ -993,9 +1012,9 @@ static long ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
int result; int result;
unsigned long mode, features = 0; unsigned long mode, features = 0;
if (ir->c_rx.addr != 0) if (ir->rx != NULL)
features |= LIRC_CAN_REC_LIRCCODE; features |= LIRC_CAN_REC_LIRCCODE;
if (ir->c_tx.addr != 0) if (ir->tx != NULL)
features |= LIRC_CAN_SEND_PULSE; features |= LIRC_CAN_SEND_PULSE;
switch (cmd) { switch (cmd) {
@@ -1146,23 +1165,26 @@ static const struct file_operations lirc_fops = {
static int ir_remove(struct i2c_client *client) static int ir_remove(struct i2c_client *client)
{ {
struct IR *ir = i2c_get_clientdata(client); struct IR *ir = i2c_get_clientdata(client);
struct IR_rx *rx = ir->rx;
struct IR_tx *tx = ir->tx;
/* FIXME make tx, rx senitive */
mutex_lock(&ir->ir_lock); mutex_lock(&ir->ir_lock);
if (ir->have_rx || ir->have_tx) { if (rx != NULL || tx != NULL) {
DECLARE_COMPLETION(tn); DECLARE_COMPLETION(tn);
DECLARE_COMPLETION(tn2); DECLARE_COMPLETION(tn2);
/* end up polling thread */ /* end up polling thread */
if (ir->task && !IS_ERR(ir->task)) { if (rx->task && !IS_ERR(rx->task)) {
ir->t_notify = &tn; rx->t_notify = &tn;
ir->t_notify2 = &tn2; rx->t_notify2 = &tn2;
ir->shutdown = 1; rx->shutdown = 1;
wake_up_process(ir->task); wake_up_process(rx->task);
complete(&tn2); complete(&tn2);
wait_for_completion(&tn); wait_for_completion(&tn);
ir->t_notify = NULL; rx->t_notify = NULL;
ir->t_notify2 = NULL; rx->t_notify2 = NULL;
} }
} else { } else {
@@ -1173,13 +1195,15 @@ static int ir_remove(struct i2c_client *client)
} }
/* unregister lirc driver */ /* unregister lirc driver */
/* FIXME make tx, rx senitive */
if (ir->l.minor >= 0 && ir->l.minor < MAX_IRCTL_DEVICES) { if (ir->l.minor >= 0 && ir->l.minor < MAX_IRCTL_DEVICES) {
lirc_unregister_driver(ir->l.minor); lirc_unregister_driver(ir->l.minor);
ir_devices[ir->l.minor] = NULL; ir_devices[ir->l.minor] = NULL;
} }
/* free memory */ /* free memory */
lirc_buffer_free(&ir->buf); /* FIXME make tx, rx senitive */
lirc_buffer_free(&rx->buf);
mutex_unlock(&ir->ir_lock); mutex_unlock(&ir->ir_lock);
kfree(ir); kfree(ir);
@@ -1240,18 +1264,37 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
have_rx ? "RX only" : "TX only"); have_rx ? "RX only" : "TX only");
ir = kzalloc(sizeof(struct IR), GFP_KERNEL); ir = kzalloc(sizeof(struct IR), GFP_KERNEL);
if (!ir) if (!ir)
goto out_nomem; goto out_nomem;
ret = lirc_buffer_init(&ir->buf, 2, BUFLEN / 2); if (have_tx) {
if (ret) ir->tx = kzalloc(sizeof(struct IR_tx), GFP_KERNEL);
goto out_nomem; if (ir->tx != NULL) {
ir->tx->need_boot = 1;
ir->tx->post_tx_ready_poll =
(id->driver_data & ID_FLAG_HDPVR) ? false : true;
}
}
if (have_rx) {
ir->rx = kzalloc(sizeof(struct IR_rx), GFP_KERNEL);
if (ir->rx == NULL) {
ret = -ENOMEM;
} else {
ir->rx->hdpvr_data_fmt =
(id->driver_data & ID_FLAG_HDPVR) ? true : false;
mutex_init(&ir->rx->buf_lock);
ret = lirc_buffer_init(&ir->rx->buf, 2, BUFLEN / 2);
}
if (ret && (ir->rx != NULL)) {
kfree(ir->rx);
ir->rx = NULL;
}
}
mutex_init(&ir->ir_lock); mutex_init(&ir->ir_lock);
mutex_init(&ir->buf_lock);
ir->need_boot = 1;
ir->is_hdpvr = (id->driver_data & ID_FLAG_HDPVR) ? true : false;
memcpy(&ir->l, &lirc_template, sizeof(struct lirc_driver)); memcpy(&ir->l, &lirc_template, sizeof(struct lirc_driver));
ir->l.minor = -1; ir->l.minor = -1;
@@ -1260,40 +1303,38 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
i2c_set_clientdata(client, ir); i2c_set_clientdata(client, ir);
/* initialise RX device */ /* initialise RX device */
if (have_rx) { if (ir->rx != NULL) {
DECLARE_COMPLETION(tn); DECLARE_COMPLETION(tn);
memcpy(&ir->c_rx, client, sizeof(struct i2c_client)); memcpy(&ir->rx->c_rx, client, sizeof(struct i2c_client));
ir->c_rx.addr = 0x71; ir->rx->c_rx.addr = 0x71;
strlcpy(ir->c_rx.name, ZILOG_HAUPPAUGE_IR_RX_NAME, strlcpy(ir->rx->c_rx.name, ZILOG_HAUPPAUGE_IR_RX_NAME,
I2C_NAME_SIZE); I2C_NAME_SIZE);
/* try to fire up polling thread */ /* try to fire up polling thread */
ir->t_notify = &tn; ir->rx->t_notify = &tn;
ir->task = kthread_run(lirc_thread, ir, "lirc_zilog"); ir->rx->task = kthread_run(lirc_thread, ir, "lirc_zilog");
if (IS_ERR(ir->task)) { if (IS_ERR(ir->rx->task)) {
ret = PTR_ERR(ir->task); ret = PTR_ERR(ir->rx->task);
zilog_error("lirc_register_driver: cannot run " zilog_error("lirc_register_driver: cannot run "
"poll thread %d\n", ret); "poll thread %d\n", ret);
goto err; goto err;
} }
wait_for_completion(&tn); wait_for_completion(&tn);
ir->t_notify = NULL; ir->rx->t_notify = NULL;
ir->have_rx = 1;
} }
/* initialise TX device */ /* initialise TX device */
if (have_tx) { if (ir->tx) {
memcpy(&ir->c_tx, client, sizeof(struct i2c_client)); memcpy(&ir->tx->c_tx, client, sizeof(struct i2c_client));
ir->c_tx.addr = 0x70; ir->tx->c_tx.addr = 0x70;
strlcpy(ir->c_tx.name, ZILOG_HAUPPAUGE_IR_TX_NAME, strlcpy(ir->tx->c_tx.name, ZILOG_HAUPPAUGE_IR_TX_NAME,
I2C_NAME_SIZE); I2C_NAME_SIZE);
ir->have_tx = 1;
} }
/* set lirc_dev stuff */ /* set lirc_dev stuff */
ir->l.code_length = 13; ir->l.code_length = 13;
ir->l.rbuf = &ir->buf; ir->l.rbuf = (ir->rx == NULL) ? NULL : &ir->rx->buf;
ir->l.fops = &lirc_fops; ir->l.fops = &lirc_fops;
ir->l.data = ir; ir->l.data = ir;
ir->l.minor = minor; ir->l.minor = minor;
@@ -1317,9 +1358,9 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
* after registering with lirc as otherwise hotplug seems to take * after registering with lirc as otherwise hotplug seems to take
* 10s to create the lirc device. * 10s to create the lirc device.
*/ */
if (have_tx) { if (ir->tx != NULL) {
/* Special TX init */ /* Special TX init */
ret = tx_init(ir); ret = tx_init(ir->tx);
if (ret != 0) if (ret != 0)
goto err; goto err;
} }
@@ -1327,18 +1368,21 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
return 0; return 0;
err: err:
/* FIXME - memory deallocation for all error cases needs work */
/* undo everything, hopefully... */ /* undo everything, hopefully... */
if (ir->c_rx.addr) if (ir->rx != NULL)
ir_remove(&ir->c_rx); ir_remove(&ir->rx->c_rx);
if (ir->c_tx.addr) if (ir->tx != NULL)
ir_remove(&ir->c_tx); ir_remove(&ir->tx->c_tx);
return ret; return ret;
out_nodev: out_nodev:
/* FIXME - memory deallocation for all error cases needs work */
zilog_error("no device found\n"); zilog_error("no device found\n");
return -ENODEV; return -ENODEV;
out_nomem: out_nomem:
/* FIXME - memory deallocation for all error cases needs work */
zilog_error("memory allocation failure\n"); zilog_error("memory allocation failure\n");
kfree(ir); kfree(ir);
return -ENOMEM; return -ENOMEM;