[PATCH] drivers/media: convert to dynamic input_dev allocation

Input: convert drivers/media to dynamic input_dev allocation

This is required for input_dev sysfs integration

Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/media/common/ir-common.c b/drivers/media/common/ir-common.c
index a0e700d7a4a4ad5b5fb6c3ff7b052ff1b0449791..06f4d4686a6c7176f441061cf89ed27a4ef1e4a0 100644 (file)
--- a/drivers/media/common/ir-common.c
+++ b/drivers/media/common/ir-common.c
@@ -252,7 +252,6 @@ void ir_input_init(struct input_dev *dev, struct ir_input_state *ir,
        if (ir_codes)
                memcpy(ir->ir_codes, ir_codes, sizeof(ir->ir_codes));
 
-        init_input_dev(dev);
        dev->keycode     = ir->ir_codes;
        dev->keycodesize = sizeof(IR_KEYTAB_TYPE);
        dev->keycodemax  = IR_KEYTAB_SIZE;

diff --git a/drivers/media/dvb/cinergyT2/cinergyT2.c b/drivers/media/dvb/cinergyT2/cinergyT2.c
index 6db0929ef53dbfa3a0e1f0875bddc037cb525ed9..a1607e7d6d6bfba74eddb9798d42de0b16f69aa8 100644 (file)
--- a/drivers/media/dvb/cinergyT2/cinergyT2.c
+++ b/drivers/media/dvb/cinergyT2/cinergyT2.c
@@ -137,7 +137,8 @@ struct cinergyt2 {
        struct urb *stream_urb [STREAM_URB_COUNT];
 
 #ifdef ENABLE_RC
-       struct input_dev rc_input_dev;
+       struct input_dev *rc_input_dev;
+       char phys[64];
        struct work_struct rc_query_work;
        int rc_input_event;
        u32 rc_last_code;
@@ -683,6 +684,7 @@ static struct dvb_device cinergyt2_fe_template = {
 };
 
 #ifdef ENABLE_RC
+
 static void cinergyt2_query_rc (void *data)
 {
        struct cinergyt2 *cinergyt2 = data;
@@ -703,7 +705,7 @@ static void cinergyt2_query_rc (void *data)
                        /* stop key repeat */
                        if (cinergyt2->rc_input_event != KEY_MAX) {
                                dprintk(1, "rc_input_event=%d Up\n", cinergyt2->rc_input_event);
-                               input_report_key(&cinergyt2->rc_input_dev,
+                               input_report_key(cinergyt2->rc_input_dev,
                                                 cinergyt2->rc_input_event, 0);
                                cinergyt2->rc_input_event = KEY_MAX;
                        }
@@ -722,7 +724,7 @@ static void cinergyt2_query_rc (void *data)
                        /* keyrepeat bit -> just repeat last rc_input_event */
                } else {
                        cinergyt2->rc_input_event = KEY_MAX;
-                       for (i = 0; i < sizeof(rc_keys) / sizeof(rc_keys[0]); i += 3) {
+                       for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3) {
                                if (rc_keys[i + 0] == rc_events[n].type &&
                                    rc_keys[i + 1] == le32_to_cpu(rc_events[n].value)) {
                                        cinergyt2->rc_input_event = rc_keys[i + 2];
@@ -736,11 +738,11 @@ static void cinergyt2_query_rc (void *data)
                            cinergyt2->rc_last_code != ~0) {
                                /* emit a key-up so the double event is recognized */
                                dprintk(1, "rc_input_event=%d UP\n", cinergyt2->rc_input_event);
-                               input_report_key(&cinergyt2->rc_input_dev,
+                               input_report_key(cinergyt2->rc_input_dev,
                                                 cinergyt2->rc_input_event, 0);
                        }
                        dprintk(1, "rc_input_event=%d\n", cinergyt2->rc_input_event);
-                       input_report_key(&cinergyt2->rc_input_dev,
+                       input_report_key(cinergyt2->rc_input_dev,
                                         cinergyt2->rc_input_event, 1);
                        cinergyt2->rc_last_code = rc_events[n].value;
                }
@@ -752,7 +754,59 @@ out:
 
        up(&cinergyt2->sem);
 }
-#endif
+
+static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2)
+{
+       struct input_dev *input_dev;
+       int i;
+
+       cinergyt2->rc_input_dev = input_dev = input_allocate_device();
+       if (!input_dev)
+               return -ENOMEM;
+
+       usb_make_path(cinergyt2->udev, cinergyt2->phys, sizeof(cinergyt2->phys));
+       strlcat(cinergyt2->phys, "/input0", sizeof(cinergyt2->phys));
+       cinergyt2->rc_input_event = KEY_MAX;
+       cinergyt2->rc_last_code = ~0;
+       INIT_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc, cinergyt2);
+
+       input_dev->name = DRIVER_NAME " remote control";
+       input_dev->phys = cinergyt2->phys;
+       input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
+       for (i = 0; ARRAY_SIZE(rc_keys); i += 3)
+               set_bit(rc_keys[i + 2], input_dev->keybit);
+       input_dev->keycodesize = 0;
+       input_dev->keycodemax = 0;
+
+       input_register_device(cinergyt2->rc_input_dev);
+       schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
+}
+
+static void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2)
+{
+       cancel_delayed_work(&cinergyt2->rc_query_work);
+       flush_scheduled_work();
+       input_unregister_device(cinergyt2->rc_input_dev);
+}
+
+static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2)
+{
+       cancel_delayed_work(&cinergyt2->rc_query_work);
+}
+
+static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2)
+{
+       schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
+}
+
+#else
+
+static inline int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) { return 0; }
+static inline void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) { }
+static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) { }
+static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) { }
+
+#endif /* ENABLE_RC */
 
 static void cinergyt2_query (void *data)
 {
@@ -789,9 +843,6 @@ static int cinergyt2_probe (struct usb_interface *intf,
 {
        struct cinergyt2 *cinergyt2;
        int err;
-#ifdef ENABLE_RC
-       int i;
-#endif
 
        if (!(cinergyt2 = kmalloc (sizeof(struct cinergyt2), GFP_KERNEL))) {
                dprintk(1, "out of memory?!?\n");
@@ -846,30 +897,17 @@ static int cinergyt2_probe (struct usb_interface *intf,
                            &cinergyt2_fe_template, cinergyt2,
                            DVB_DEVICE_FRONTEND);
 
-#ifdef ENABLE_RC
-       cinergyt2->rc_input_dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
-       cinergyt2->rc_input_dev.keycodesize = 0;
-       cinergyt2->rc_input_dev.keycodemax = 0;
-       cinergyt2->rc_input_dev.name = DRIVER_NAME " remote control";
-
-       for (i = 0; i < sizeof(rc_keys) / sizeof(rc_keys[0]); i += 3)
-               set_bit(rc_keys[i + 2], cinergyt2->rc_input_dev.keybit);
-
-       input_register_device(&cinergyt2->rc_input_dev);
-
-       cinergyt2->rc_input_event = KEY_MAX;
-       cinergyt2->rc_last_code = ~0;
+       err = cinergyt2_register_rc(cinergyt2);
+       if (err)
+               goto bailout;
 
-       INIT_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc, cinergyt2);
-       schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
-#endif
        return 0;
 
 bailout:
        dvb_dmxdev_release(&cinergyt2->dmxdev);
        dvb_dmx_release(&cinergyt2->demux);
-       dvb_unregister_adapter (&cinergyt2->adapter);
-       cinergyt2_free_stream_urbs (cinergyt2);
+       dvb_unregister_adapter(&cinergyt2->adapter);
+       cinergyt2_free_stream_urbs(cinergyt2);
        kfree(cinergyt2);
        return -ENOMEM;
 }
@@ -881,11 +919,7 @@ static void cinergyt2_disconnect (struct usb_interface *intf)
        if (down_interruptible(&cinergyt2->sem))
                return;
 
-#ifdef ENABLE_RC
-       cancel_delayed_work(&cinergyt2->rc_query_work);
-       flush_scheduled_work();
-       input_unregister_device(&cinergyt2->rc_input_dev);
-#endif
+       cinergyt2_unregister_rc(cinergyt2);
 
        cinergyt2->demux.dmx.close(&cinergyt2->demux.dmx);
        dvb_net_release(&cinergyt2->dvbnet);
@@ -908,9 +942,8 @@ static int cinergyt2_suspend (struct usb_interface *intf, pm_message_t state)
 
        if (state.event > PM_EVENT_ON) {
                struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
-#ifdef ENABLE_RC
-               cancel_delayed_work(&cinergyt2->rc_query_work);
-#endif
+
+               cinergyt2_suspend_rc(cinergyt2);
                cancel_delayed_work(&cinergyt2->query_work);
                if (cinergyt2->streaming)
                        cinergyt2_stop_stream_xfer(cinergyt2);
@@ -938,9 +971,8 @@ static int cinergyt2_resume (struct usb_interface *intf)
                schedule_delayed_work(&cinergyt2->query_work, HZ/2);
        }
 
-#ifdef ENABLE_RC
-       schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
-#endif
+       cinergyt2_resume_rc(cinergyt2);
+
        up(&cinergyt2->sem);
        return 0;
 }

diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
index fc7800f1743ee5c8747a6ea5d0dd17540ed738c8..e5c6d9835e06d24cac72b3ae3f342cab98b055da 100644 (file)
--- a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
@@ -39,9 +39,9 @@ static void dvb_usb_read_remote_control(void *data)
                        d->last_event = event;
                case REMOTE_KEY_REPEAT:
                        deb_rc("key repeated\n");
-                       input_event(&d->rc_input_dev, EV_KEY, d->last_event, 1);
-                       input_event(&d->rc_input_dev, EV_KEY, d->last_event, 0);
-                       input_sync(&d->rc_input_dev);
+                       input_event(d->rc_input_dev, EV_KEY, event, 1);
+                       input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
+                       input_sync(d->rc_input_dev);
                        break;
                default:
                        break;
@@ -53,8 +53,8 @@ static void dvb_usb_read_remote_control(void *data)
                        deb_rc("NO KEY PRESSED\n");
                        if (d->last_state != REMOTE_NO_KEY_PRESSED) {
                                deb_rc("releasing event %d\n",d->last_event);
-                               input_event(&d->rc_input_dev, EV_KEY, d->last_event, 0);
-                               input_sync(&d->rc_input_dev);
+                               input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
+                               input_sync(d->rc_input_dev);
                        }
                        d->last_state = REMOTE_NO_KEY_PRESSED;
                        d->last_event = 0;
@@ -63,8 +63,8 @@ static void dvb_usb_read_remote_control(void *data)
                        deb_rc("KEY PRESSED\n");
                        deb_rc("pressing event %d\n",event);
 
-                       input_event(&d->rc_input_dev, EV_KEY, event, 1);
-                       input_sync(&d->rc_input_dev);
+                       input_event(d->rc_input_dev, EV_KEY, event, 1);
+                       input_sync(d->rc_input_dev);
 
                        d->last_event = event;
                        d->last_state = REMOTE_KEY_PRESSED;
@@ -73,8 +73,8 @@ static void dvb_usb_read_remote_control(void *data)
                        deb_rc("KEY_REPEAT\n");
                        if (d->last_state != REMOTE_NO_KEY_PRESSED) {
                                deb_rc("repeating event %d\n",d->last_event);
-                               input_event(&d->rc_input_dev, EV_KEY, d->last_event, 2);
-                               input_sync(&d->rc_input_dev);
+                               input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
+                               input_sync(d->rc_input_dev);
                                d->last_state = REMOTE_KEY_REPEAT;
                        }
                default:
@@ -89,24 +89,30 @@ schedule:
 int dvb_usb_remote_init(struct dvb_usb_device *d)
 {
        int i;
+
        if (d->props.rc_key_map == NULL ||
                d->props.rc_query == NULL ||
                dvb_usb_disable_rc_polling)
                return 0;
 
-       /* Initialise the remote-control structures.*/
-       init_input_dev(&d->rc_input_dev);
+       usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
+       strlcpy(d->rc_phys, "/ir0", sizeof(d->rc_phys));
+
+       d->rc_input_dev = input_allocate_device();
+       if (!d->rc_input_dev)
+               return -ENOMEM;
 
-       d->rc_input_dev.evbit[0] = BIT(EV_KEY);
-       d->rc_input_dev.keycodesize = sizeof(unsigned char);
-       d->rc_input_dev.keycodemax = KEY_MAX;
-       d->rc_input_dev.name = "IR-receiver inside an USB DVB receiver";
+       d->rc_input_dev->evbit[0] = BIT(EV_KEY);
+       d->rc_input_dev->keycodesize = sizeof(unsigned char);
+       d->rc_input_dev->keycodemax = KEY_MAX;
+       d->rc_input_dev->name = "IR-receiver inside an USB DVB receiver";
+       d->rc_input_dev->phys = d->rc_phys;
 
        /* set the bits for the keys */
-       deb_rc("key map size: %d\n",d->props.rc_key_map_size);
+       deb_rc("key map size: %d\n", d->props.rc_key_map_size);
        for (i = 0; i < d->props.rc_key_map_size; i++) {
                deb_rc("setting bit for event %d item %d\n",d->props.rc_key_map[i].event, i);
-               set_bit(d->props.rc_key_map[i].event, d->rc_input_dev.keybit);
+               set_bit(d->props.rc_key_map[i].event, d->rc_input_dev->keybit);
        }
 
        /* Start the remote-control polling. */
@@ -114,14 +120,14 @@ int dvb_usb_remote_init(struct dvb_usb_device *d)
                d->props.rc_interval = 100; /* default */
 
        /* setting these two values to non-zero, we have to manage key repeats */
-       d->rc_input_dev.rep[REP_PERIOD] = d->props.rc_interval;
-       d->rc_input_dev.rep[REP_DELAY]  = d->props.rc_interval + 150;
+       d->rc_input_dev->rep[REP_PERIOD] = d->props.rc_interval;
+       d->rc_input_dev->rep[REP_DELAY]  = d->props.rc_interval + 150;
 
-       input_register_device(&d->rc_input_dev);
+       input_register_device(d->rc_input_dev);
 
        INIT_WORK(&d->rc_query_work, dvb_usb_read_remote_control, d);
 
-       info("schedule remote query interval to %d msecs.",d->props.rc_interval);
+       info("schedule remote query interval to %d msecs.", d->props.rc_interval);
        schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc_interval));
 
        d->state |= DVB_USB_STATE_REMOTE;
@@ -134,7 +140,7 @@ int dvb_usb_remote_exit(struct dvb_usb_device *d)
        if (d->state & DVB_USB_STATE_REMOTE) {
                cancel_delayed_work(&d->rc_query_work);
                flush_scheduled_work();
-               input_unregister_device(&d->rc_input_dev);
+               input_unregister_device(d->rc_input_dev);
        }
        d->state &= ~DVB_USB_STATE_REMOTE;
        return 0;

diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h
index 0e4f1035b0dd56535407e20417e738fd3162983b..b4a1a98006c7d9f8abcf95686cb93db84b401fde 100644 (file)
--- a/drivers/media/dvb/dvb-usb/dvb-usb.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb.h
@@ -300,7 +300,8 @@ struct dvb_usb_device {
        int (*fe_init)  (struct dvb_frontend *);
 
        /* remote control */
-       struct input_dev rc_input_dev;
+       struct input_dev *rc_input_dev;
+       char rc_phys[64];
        struct work_struct rc_query_work;
        u32 last_event;
        int last_state;

diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c
index 357a3728ec68fe28a8a1650a117240b19d95f53f..f5e59fc924afeaf1f75ebd320544a05eba209ba3 100644 (file)
--- a/drivers/media/dvb/ttpci/av7110_ir.c
+++ b/drivers/media/dvb/ttpci/av7110_ir.c
@@ -15,7 +15,7 @@
 
 static int av_cnt;
 static struct av7110 *av_list[4];
-static struct input_dev input_dev;
+static struct input_dev *input_dev;
 
 static u16 key_map [256] = {
        KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7,
@@ -43,10 +43,10 @@ static u16 key_map [256] = {
 
 static void av7110_emit_keyup(unsigned long data)
 {
-       if (!data || !test_bit(data, input_dev.key))
+       if (!data || !test_bit(data, input_dev->key))
                return;
 
-       input_event(&input_dev, EV_KEY, data, !!0);
+       input_event(input_dev, EV_KEY, data, !!0);
 }
 
 
@@ -112,13 +112,13 @@ static void av7110_emit_key(unsigned long parm)
        if (timer_pending(&keyup_timer)) {
                del_timer(&keyup_timer);
                if (keyup_timer.data != keycode || new_toggle != old_toggle) {
-                       input_event(&input_dev, EV_KEY, keyup_timer.data, !!0);
-                       input_event(&input_dev, EV_KEY, keycode, !0);
+                       input_event(input_dev, EV_KEY, keyup_timer.data, !!0);
+                       input_event(input_dev, EV_KEY, keycode, !0);
                } else
-                       input_event(&input_dev, EV_KEY, keycode, 2);
+                       input_event(input_dev, EV_KEY, keycode, 2);
 
        } else
-               input_event(&input_dev, EV_KEY, keycode, !0);
+               input_event(input_dev, EV_KEY, keycode, !0);
 
        keyup_timer.expires = jiffies + UP_TIMEOUT;
        keyup_timer.data = keycode;
@@ -132,13 +132,13 @@ static void input_register_keys(void)
 {
        int i;
 
-       memset(input_dev.keybit, 0, sizeof(input_dev.keybit));
+       memset(input_dev->keybit, 0, sizeof(input_dev->keybit));
 
-       for (i = 0; i < sizeof(key_map) / sizeof(key_map[0]); i++) {
+       for (i = 0; i < ARRAY_SIZE(key_map); i++) {
                if (key_map[i] > KEY_MAX)
                        key_map[i] = 0;
                else if (key_map[i] > KEY_RESERVED)
-                       set_bit(key_map[i], input_dev.keybit);
+                       set_bit(key_map[i], input_dev->keybit);
        }
 }
 
@@ -216,12 +216,17 @@ int __init av7110_ir_init(struct av7110 *av7110)
                init_timer(&keyup_timer);
                keyup_timer.data = 0;
 
-               input_dev.name = "DVB on-card IR receiver";
-               set_bit(EV_KEY, input_dev.evbit);
-               set_bit(EV_REP, input_dev.evbit);
+               input_dev = input_allocate_device();
+               if (!input_dev)
+                       return -ENOMEM;
+
+               input_dev->name = "DVB on-card IR receiver";
+
+               set_bit(EV_KEY, input_dev->evbit);
+               set_bit(EV_REP, input_dev->evbit);
                input_register_keys();
-               input_register_device(&input_dev);
-               input_dev.timer.function = input_repeat_key;
+               input_register_device(input_dev);
+               input_dev->timer.function = input_repeat_key;
 
                e = create_proc_entry("av7110_ir", S_IFREG | S_IRUGO | S_IWUSR, NULL);
                if (e) {
@@ -256,7 +261,7 @@ void __exit av7110_ir_exit(struct av7110 *av7110)
        if (av_cnt == 1) {
                del_timer_sync(&keyup_timer);
                remove_proc_entry("av7110_ir", NULL);
-               input_unregister_device(&input_dev);
+               input_unregister_device(input_dev);
        }
 
        av_cnt--;

diff --git a/drivers/media/dvb/ttpci/budget-ci.c b/drivers/media/dvb/ttpci/budget-ci.c
index 2980db3ef22f8c2a90021bd334a5614a0d049893..51c30ba68140acd5d636d63f644b14e4a54b831b 100644 (file)
--- a/drivers/media/dvb/ttpci/budget-ci.c
+++ b/drivers/media/dvb/ttpci/budget-ci.c
@@ -64,7 +64,7 @@
 
 struct budget_ci {
        struct budget budget;
-       struct input_dev input_dev;
+       struct input_dev *input_dev;
        struct tasklet_struct msp430_irq_tasklet;
        struct tasklet_struct ciintf_irq_tasklet;
        int slot_status;
@@ -145,7 +145,7 @@ static void msp430_ir_debounce(unsigned long data)
 static void msp430_ir_interrupt(unsigned long data)
 {
        struct budget_ci *budget_ci = (struct budget_ci *) data;
-       struct input_dev *dev = &budget_ci->input_dev;
+       struct input_dev *dev = budget_ci->input_dev;
        unsigned int code =
                ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
 
@@ -181,25 +181,27 @@ static void msp430_ir_interrupt(unsigned long data)
 static int msp430_ir_init(struct budget_ci *budget_ci)
 {
        struct saa7146_dev *saa = budget_ci->budget.dev;
+       struct input_dev *input_dev;
        int i;
 
-       memset(&budget_ci->input_dev, 0, sizeof(struct input_dev));
+       budget_ci->input_dev = input_dev = input_allocate_device();
+       if (!input_dev)
+               return -ENOMEM;
 
        sprintf(budget_ci->ir_dev_name, "Budget-CI dvb ir receiver %s", saa->name);
-       budget_ci->input_dev.name = budget_ci->ir_dev_name;
 
-       set_bit(EV_KEY, budget_ci->input_dev.evbit);
+       input_dev->name = budget_ci->ir_dev_name;
 
-       for (i = 0; i < sizeof(key_map) / sizeof(*key_map); i++)
+       set_bit(EV_KEY, input_dev->evbit);
+       for (i = 0; i < ARRAY_SIZE(key_map); i++)
                if (key_map[i])
-                       set_bit(key_map[i], budget_ci->input_dev.keybit);
+                       set_bit(key_map[i], input_dev->keybit);
 
-       input_register_device(&budget_ci->input_dev);
+       input_register_device(budget_ci->input_dev);
 
-       budget_ci->input_dev.timer.function = msp430_ir_debounce;
+       input_dev->timer.function = msp430_ir_debounce;
 
        saa7146_write(saa, IER, saa7146_read(saa, IER) | MASK_06);
-
        saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI);
 
        return 0;
@@ -208,7 +210,7 @@ static int msp430_ir_init(struct budget_ci *budget_ci)
 static void msp430_ir_deinit(struct budget_ci *budget_ci)
 {
        struct saa7146_dev *saa = budget_ci->budget.dev;
-       struct input_dev *dev = &budget_ci->input_dev;
+       struct input_dev *dev = budget_ci->input_dev;
 
        saa7146_write(saa, IER, saa7146_read(saa, IER) & ~MASK_06);
        saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);

diff --git a/drivers/media/dvb/ttusb-dec/ttusb_dec.c b/drivers/media/dvb/ttusb-dec/ttusb_dec.c
index 3d08fc83a7541a45c5a5e076925fe80ef008baca..832d179f26fa417e541d1cf4701256d7aa2e20ea 100644 (file)
--- a/drivers/media/dvb/ttusb-dec/ttusb_dec.c
+++ b/drivers/media/dvb/ttusb-dec/ttusb_dec.c
@@ -152,7 +152,8 @@ struct ttusb_dec {
        struct list_head        filter_info_list;
        spinlock_t              filter_info_list_lock;
 
-       struct input_dev        rc_input_dev;
+       struct input_dev        *rc_input_dev;
+       char                    rc_phys[64];
 
        int                     active; /* Loaded successfully */
 };
@@ -235,9 +236,9 @@ static void ttusb_dec_handle_irq( struct urb *urb, struct pt_regs *regs)
                 * this should/could be added later ...
                 * for now lets report each signal as a key down and up*/
                dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]);
-               input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],1);
-               input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],0);
-               input_sync(&dec->rc_input_dev);
+               input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
+               input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0);
+               input_sync(dec->rc_input_dev);
        }
 
 exit:  retval = usb_submit_urb(urb, GFP_ATOMIC);
@@ -1181,29 +1182,38 @@ static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
                     (unsigned long)dec);
 }
 
-static void ttusb_init_rc( struct ttusb_dec *dec)
+static int ttusb_init_rc(struct ttusb_dec *dec)
 {
+       struct input_dev *input_dev;
        u8 b[] = { 0x00, 0x01 };
        int i;
 
-       init_input_dev(&dec->rc_input_dev);
+       usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
+       strlcpy(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
 
-       dec->rc_input_dev.name = "ttusb_dec remote control";
-       dec->rc_input_dev.evbit[0] = BIT(EV_KEY);
-       dec->rc_input_dev.keycodesize = sizeof(u16);
-       dec->rc_input_dev.keycodemax = 0x1a;
-       dec->rc_input_dev.keycode = rc_keys;
+       dec->rc_input_dev = input_dev = input_allocate_device();
+       if (!input_dev)
+               return -ENOMEM;
+
+       input_dev->name = "ttusb_dec remote control";
+       input_dev->phys = dec->rc_phys;
+       input_dev->evbit[0] = BIT(EV_KEY);
+       input_dev->keycodesize = sizeof(u16);
+       input_dev->keycodemax = 0x1a;
+       input_dev->keycode = rc_keys;
 
-        for (i = 0; i < sizeof(rc_keys)/sizeof(rc_keys[0]); i++)
-                set_bit(rc_keys[i], dec->rc_input_dev.keybit);
+       for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
+                set_bit(rc_keys[i], input_dev->keybit);
 
-       input_register_device(&dec->rc_input_dev);
+       input_register_device(input_dev);
 
-       if(usb_submit_urb(dec->irq_urb,GFP_KERNEL)) {
+       if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
                printk("%s: usb_submit_urb failed\n",__FUNCTION__);
-       }
+
        /* enable irq pipe */
        ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
+
+       return 0;
 }
 
 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
@@ -1513,7 +1523,7 @@ static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
          * As the irq is submitted after the interface is changed,
          * this is the best method i figured out.
          * Any others?*/
-       if(dec->interface == TTUSB_DEC_INTERFACE_IN)
+       if (dec->interface == TTUSB_DEC_INTERFACE_IN)
                usb_kill_urb(dec->irq_urb);
 
        usb_free_urb(dec->irq_urb);
@@ -1521,7 +1531,10 @@ static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
        usb_buffer_free(dec->udev,IRQ_PACKET_SIZE,
                           dec->irq_buffer, dec->irq_dma_handle);
 
-       input_unregister_device(&dec->rc_input_dev);
+       if (dec->rc_input_dev) {
+               input_unregister_device(dec->rc_input_dev);
+               dec->rc_input_dev = NULL;
+       }
 }
 
 
@@ -1659,7 +1672,7 @@ static int ttusb_dec_probe(struct usb_interface *intf,
 
        ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
 
-       if(enable_rc)
+       if (enable_rc)
                ttusb_init_rc(dec);
 
        return 0;

diff --git a/drivers/media/video/bttvp.h b/drivers/media/video/bttvp.h
index 7a312f79340aa3786ef721e4c1bae0f7d00883e9..e0e7c7a84bc53015d1c4064d48b323aea570a691 100644 (file)
--- a/drivers/media/video/bttvp.h
+++ b/drivers/media/video/bttvp.h
@@ -240,7 +240,7 @@ struct bttv_pll_info {
 
 /* for gpio-connected remote control */
 struct bttv_input {
-       struct input_dev      dev;
+       struct input_dev      *dev;
        struct ir_input_state ir;
        char                  name[32];
        char                  phys[32];

diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index d81b21d6e05d0ded4fbee113170c801dc2f22f08..c27fe4c36f69f0927d95e0b5b918df68f351de29 100644 (file)
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -260,7 +260,7 @@ static IR_KEYTAB_TYPE ir_codes_cinergy_1400[IR_KEYTAB_SIZE] = {
 
 struct cx88_IR {
        struct cx88_core *core;
-       struct input_dev input;
+       struct input_dev *input;
        struct ir_input_state ir;
        char name[32];
        char phys[32];
@@ -315,23 +315,23 @@ static void cx88_ir_handle_key(struct cx88_IR *ir)
        if (ir->mask_keydown) {
                /* bit set on keydown */
                if (gpio & ir->mask_keydown) {
-                       ir_input_keydown(&ir->input, &ir->ir, data, data);
+                       ir_input_keydown(ir->input, &ir->ir, data, data);
                } else {
-                       ir_input_nokey(&ir->input, &ir->ir);
+                       ir_input_nokey(ir->input, &ir->ir);
                }
 
        } else if (ir->mask_keyup) {
                /* bit cleared on keydown */
                if (0 == (gpio & ir->mask_keyup)) {
-                       ir_input_keydown(&ir->input, &ir->ir, data, data);
+                       ir_input_keydown(ir->input, &ir->ir, data, data);
                } else {
-                       ir_input_nokey(&ir->input, &ir->ir);
+                       ir_input_nokey(ir->input, &ir->ir);
                }
 
        } else {
                /* can't distinguish keydown/up :-/ */
-               ir_input_keydown(&ir->input, &ir->ir, data, data);
-               ir_input_nokey(&ir->input, &ir->ir);
+               ir_input_keydown(ir->input, &ir->ir, data, data);
+               ir_input_nokey(ir->input, &ir->ir);
        }
 }
 
@@ -357,13 +357,19 @@ static void cx88_ir_work(void *data)
 int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
 {
        struct cx88_IR *ir;
+       struct input_dev *input_dev;
        IR_KEYTAB_TYPE *ir_codes = NULL;
        int ir_type = IR_TYPE_OTHER;
 
-       ir = kmalloc(sizeof(*ir), GFP_KERNEL);
-       if (NULL == ir)
+       ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!ir || !input_dev) {
+               kfree(ir);
+               input_free_device(input_dev);
                return -ENOMEM;
-       memset(ir, 0, sizeof(*ir));
+       }
+
+       ir->input = input_dev;
 
        /* detect & configure */
        switch (core->board) {
@@ -425,6 +431,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
 
        if (NULL == ir_codes) {
                kfree(ir);
+               input_free_device(input_dev);
                return -ENODEV;
        }
 
@@ -433,19 +440,19 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 cx88_boards[core->board].name);
        snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci));
 
-       ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes);
-       ir->input.name = ir->name;
-       ir->input.phys = ir->phys;
-       ir->input.id.bustype = BUS_PCI;
-       ir->input.id.version = 1;
+       ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
+       input_dev->name = ir->name;
+       input_dev->phys = ir->phys;
+       input_dev->id.bustype = BUS_PCI;
+       input_dev->id.version = 1;
        if (pci->subsystem_vendor) {
-               ir->input.id.vendor = pci->subsystem_vendor;
-               ir->input.id.product = pci->subsystem_device;
+               input_dev->id.vendor = pci->subsystem_vendor;
+               input_dev->id.product = pci->subsystem_device;
        } else {
-               ir->input.id.vendor = pci->vendor;
-               ir->input.id.product = pci->device;
+               input_dev->id.vendor = pci->vendor;
+               input_dev->id.product = pci->device;
        }
-       ir->input.dev = &pci->dev;
+       input_dev->cdev.dev = &pci->dev;
 
        /* record handles to ourself */
        ir->core = core;
@@ -465,8 +472,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
        }
 
        /* all done */
-       input_register_device(&ir->input);
-       printk("%s: registered IR remote control\n", core->name);
+       input_register_device(ir->input);
 
        return 0;
 }
@@ -484,7 +490,7 @@ int cx88_ir_fini(struct cx88_core *core)
                flush_scheduled_work();
        }
 
-       input_unregister_device(&ir->input);
+       input_unregister_device(ir->input);
        kfree(ir);
 
        /* done */
@@ -515,7 +521,7 @@ void cx88_ir_irq(struct cx88_core *core)
        if (!ir->scount) {
                /* nothing to sample */
                if (ir->ir.keypressed && time_after(jiffies, ir->release))
-                       ir_input_nokey(&ir->input, &ir->ir);
+                       ir_input_nokey(ir->input, &ir->ir);
                return;
        }
 
@@ -557,7 +563,7 @@ void cx88_ir_irq(struct cx88_core *core)
 
                ir_dprintk("Key Code: %x\n", (ircode >> 16) & 0x7f);
 
-               ir_input_keydown(&ir->input, &ir->ir, (ircode >> 16) & 0x7f, (ircode >> 16) & 0xff);
+               ir_input_keydown(ir->input, &ir->ir, (ircode >> 16) & 0x7f, (ircode >> 16) & 0xff);
                ir->release = jiffies + msecs_to_jiffies(120);
                break;
        case CX88_BOARD_HAUPPAUGE:
@@ -566,7 +572,7 @@ void cx88_ir_irq(struct cx88_core *core)
                ir_dprintk("biphase decoded: %x\n", ircode);
                if ((ircode & 0xfffff000) != 0x3000)
                        break;
-               ir_input_keydown(&ir->input, &ir->ir, ircode & 0x3f, ircode);
+               ir_input_keydown(ir->input, &ir->ir, ircode & 0x3f, ircode);
                ir->release = jiffies + msecs_to_jiffies(120);
                break;
        }

diff --git a/drivers/media/video/ir-kbd-gpio.c b/drivers/media/video/ir-kbd-gpio.c
index cf292da8fdd5752066411011319570b101b34c02..234151e48edc40ea73c383cc8796dd3e48ba0c98 100644 (file)
--- a/drivers/media/video/ir-kbd-gpio.c
+++ b/drivers/media/video/ir-kbd-gpio.c
@@ -158,7 +158,7 @@ static IR_KEYTAB_TYPE ir_codes_apac_viewcomp[IR_KEYTAB_SIZE] = {
 
 struct IR {
        struct bttv_sub_device  *sub;
-       struct input_dev        input;
+       struct input_dev        *input;
        struct ir_input_state   ir;
        char                    name[32];
        char                    phys[32];
@@ -217,23 +217,23 @@ static void ir_handle_key(struct IR *ir)
        if (ir->mask_keydown) {
                /* bit set on keydown */
                if (gpio & ir->mask_keydown) {
-                       ir_input_keydown(&ir->input,&ir->ir,data,data);
+                       ir_input_keydown(ir->input, &ir->ir, data, data);
                } else {
-                       ir_input_nokey(&ir->input,&ir->ir);
+                       ir_input_nokey(ir->input, &ir->ir);
                }
 
        } else if (ir->mask_keyup) {
                /* bit cleared on keydown */
                if (0 == (gpio & ir->mask_keyup)) {
-                       ir_input_keydown(&ir->input,&ir->ir,data,data);
+                       ir_input_keydown(ir->input, &ir->ir, data, data);
                } else {
-                       ir_input_nokey(&ir->input,&ir->ir);
+                       ir_input_nokey(ir->input, &ir->ir);
                }
 
        } else {
                /* can't disturgissh keydown/up :-/ */
-               ir_input_keydown(&ir->input,&ir->ir,data,data);
-               ir_input_nokey(&ir->input,&ir->ir);
+               ir_input_keydown(ir->input, &ir->ir, data, data);
+               ir_input_nokey(ir->input, &ir->ir);
        }
 }
 
@@ -268,13 +268,17 @@ static int ir_probe(struct device *dev)
 {
        struct bttv_sub_device *sub = to_bttv_sub_dev(dev);
        struct IR *ir;
+       struct input_dev *input_dev;
        IR_KEYTAB_TYPE *ir_codes = NULL;
        int ir_type = IR_TYPE_OTHER;
 
-       ir = kmalloc(sizeof(*ir),GFP_KERNEL);
-       if (NULL == ir)
+       ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!ir || !input_dev) {
+               kfree(ir);
+               input_free_device(input_dev);
                return -ENOMEM;
-       memset(ir,0,sizeof(*ir));
+       }
 
        /* detect & configure */
        switch (sub->core->type) {
@@ -328,6 +332,7 @@ static int ir_probe(struct device *dev)
        }
        if (NULL == ir_codes) {
                kfree(ir);
+               input_free_device(input_dev);
                return -ENODEV;
        }
 
@@ -341,19 +346,19 @@ static int ir_probe(struct device *dev)
        snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
                 pci_name(sub->core->pci));
 
-       ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes);
-       ir->input.name = ir->name;
-       ir->input.phys = ir->phys;
-       ir->input.id.bustype = BUS_PCI;
-       ir->input.id.version = 1;
+       ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
+       input_dev->name = ir->name;
+       input_dev->phys = ir->phys;
+       input_dev->id.bustype = BUS_PCI;
+       input_dev->id.version = 1;
        if (sub->core->pci->subsystem_vendor) {
-               ir->input.id.vendor  = sub->core->pci->subsystem_vendor;
-               ir->input.id.product = sub->core->pci->subsystem_device;
+               input_dev->id.vendor  = sub->core->pci->subsystem_vendor;
+               input_dev->id.product = sub->core->pci->subsystem_device;
        } else {
-               ir->input.id.vendor  = sub->core->pci->vendor;
-               ir->input.id.product = sub->core->pci->device;
+               input_dev->id.vendor  = sub->core->pci->vendor;
+               input_dev->id.product = sub->core->pci->device;
        }
-       ir->input.dev = &sub->core->pci->dev;
+       input_dev->cdev.dev = &sub->core->pci->dev;
 
        if (ir->polling) {
                INIT_WORK(&ir->work, ir_work, ir);
@@ -364,9 +369,8 @@ static int ir_probe(struct device *dev)
        }
 
        /* all done */
-       dev_set_drvdata(dev,ir);
-       input_register_device(&ir->input);
-       printk(DEVNAME ": %s detected at %s\n",ir->input.name,ir->input.phys);
+       dev_set_drvdata(dev, ir);
+       input_register_device(ir->input);
 
        return 0;
 }
@@ -380,7 +384,7 @@ static int ir_remove(struct device *dev)
                flush_scheduled_work();
        }
 
-       input_unregister_device(&ir->input);
+       input_unregister_device(ir->input);
        kfree(ir);
        return 0;
 }

diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 67105b9804a2388888a66778c7523ec37ea4085d..9703d3d351f94309b651b49a53fa9ab2cdee1e6b 100644 (file)
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -121,10 +121,9 @@ static IR_KEYTAB_TYPE ir_codes_purpletv[IR_KEYTAB_SIZE] = {
 
 };
 
-struct IR;
 struct IR {
        struct i2c_client      c;
-       struct input_dev       input;
+       struct input_dev       *input;
        struct ir_input_state  ir;
 
        struct work_struct     work;
@@ -271,9 +270,9 @@ static void ir_key_poll(struct IR *ir)
        }
 
        if (0 == rc) {
-               ir_input_nokey(&ir->input,&ir->ir);
+               ir_input_nokey(ir->input, &ir->ir);
        } else {
-               ir_input_keydown(&ir->input,&ir->ir, ir_key, ir_raw);
+               ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
        }
 }
 
@@ -318,11 +317,18 @@ static int ir_attach(struct i2c_adapter *adap, int addr,
        char *name;
        int ir_type;
         struct IR *ir;
+       struct input_dev *input_dev;
 
-        if (NULL == (ir = kmalloc(sizeof(struct IR),GFP_KERNEL)))
+       ir = kzalloc(sizeof(struct IR), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!ir || !input_dev) {
+               kfree(ir);
+               input_free_device(input_dev);
                 return -ENOMEM;
-       memset(ir,0,sizeof(*ir));
+       }
+
        ir->c = client_template;
+       ir->input = input_dev;
 
        i2c_set_clientdata(&ir->c, ir);
        ir->c.adapter = adap;
@@ -375,13 +381,12 @@ static int ir_attach(struct i2c_adapter *adap, int addr,
                 ir->c.dev.bus_id);
 
        /* init + register input device */
-       ir_input_init(&ir->input,&ir->ir,ir_type,ir_codes);
-       ir->input.id.bustype = BUS_I2C;
-       ir->input.name       = ir->c.name;
-       ir->input.phys       = ir->phys;
-       input_register_device(&ir->input);
-       printk(DEVNAME ": %s detected at %s [%s]\n",
-              ir->input.name,ir->input.phys,adap->name);
+       ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
+       input_dev->id.bustype   = BUS_I2C;
+       input_dev->name         = ir->c.name;
+       input_dev->phys         = ir->phys;
+
+       input_register_device(ir->input);
 
        /* start polling via eventd */
        INIT_WORK(&ir->work, ir_work, ir);
@@ -402,7 +407,7 @@ static int ir_detach(struct i2c_client *client)
        flush_scheduled_work();
 
        /* unregister devices */
-       input_unregister_device(&ir->input);
+       input_unregister_device(ir->input);
        i2c_detach_client(&ir->c);
 
        /* free memory */

diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index 1f456c4d76f2dd90706811ce400de0eab48a2610..242cb235cf926226b48819be95efed9b07316e22 100644 (file)
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -425,9 +425,9 @@ static int build_key(struct saa7134_dev *dev)
 
        if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
            (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
-               ir_input_keydown(&ir->dev,&ir->ir,data,data);
+               ir_input_keydown(ir->dev, &ir->ir, data, data);
        } else {
-               ir_input_nokey(&ir->dev,&ir->ir);
+               ir_input_nokey(ir->dev, &ir->ir);
        }
        return 0;
 }
@@ -456,6 +456,7 @@ static void saa7134_input_timer(unsigned long data)
 int saa7134_input_init1(struct saa7134_dev *dev)
 {
        struct saa7134_ir *ir;
+       struct input_dev *input_dev;
        IR_KEYTAB_TYPE *ir_codes = NULL;
        u32 mask_keycode = 0;
        u32 mask_keydown = 0;
@@ -535,10 +536,13 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                return -ENODEV;
        }
 
-       ir = kmalloc(sizeof(*ir),GFP_KERNEL);
-       if (NULL == ir)
+       ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!ir || !input_dev) {
+               kfree(ir);
+               input_free_device(input_dev);
                return -ENOMEM;
-       memset(ir,0,sizeof(*ir));
+       }
 
        /* init hardware-specific stuff */
        ir->mask_keycode = mask_keycode;
@@ -552,19 +556,19 @@ int saa7134_input_init1(struct saa7134_dev *dev)
        snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
                 pci_name(dev->pci));
 
-       ir_input_init(&ir->dev, &ir->ir, ir_type, ir_codes);
-       ir->dev.name = ir->name;
-       ir->dev.phys = ir->phys;
-       ir->dev.id.bustype = BUS_PCI;
-       ir->dev.id.version = 1;
+       ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
+       input_dev->name = ir->name;
+       input_dev->phys = ir->phys;
+       input_dev->id.bustype = BUS_PCI;
+       input_dev->id.version = 1;
        if (dev->pci->subsystem_vendor) {
-               ir->dev.id.vendor  = dev->pci->subsystem_vendor;
-               ir->dev.id.product = dev->pci->subsystem_device;
+               input_dev->id.vendor  = dev->pci->subsystem_vendor;
+               input_dev->id.product = dev->pci->subsystem_device;
        } else {
-               ir->dev.id.vendor  = dev->pci->vendor;
-               ir->dev.id.product = dev->pci->device;
+               input_dev->id.vendor  = dev->pci->vendor;
+               input_dev->id.product = dev->pci->device;
        }
-       ir->dev.dev = &dev->pci->dev;
+       input_dev->cdev.dev = &dev->pci->dev;
 
        /* all done */
        dev->remote = ir;
@@ -576,8 +580,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                add_timer(&ir->timer);
        }
 
-       input_register_device(&dev->remote->dev);
-       printk("%s: registered input device for IR\n",dev->name);
+       input_register_device(ir->dev);
        return 0;
 }
 
@@ -586,9 +589,9 @@ void saa7134_input_fini(struct saa7134_dev *dev)
        if (NULL == dev->remote)
                return;
 
-       input_unregister_device(&dev->remote->dev);
        if (dev->remote->polling)
                del_timer_sync(&dev->remote->timer);
+       input_unregister_device(dev->remote->dev);
        kfree(dev->remote);
        dev->remote = NULL;
 }

diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index 3ea09142ec9c44807b5fbb361647b0ceacb26ab7..860b89530e2a452c6ab78485dd865b8c47b58058 100644 (file)
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -351,7 +351,7 @@ struct saa7134_oss {
 
 /* IR input */
 struct saa7134_ir {
-       struct input_dev           dev;
+       struct input_dev           *dev;
        struct ir_input_state      ir;
        char                       name[32];
        char                       phys[32];