tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[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>

authored by

Dmitry Torokhov and committed by
Greg Kroah-Hartman b7df3910 76b7cddf

+268 -192
-1
drivers/media/common/ir-common.c
··· 252 252 if (ir_codes) 253 253 memcpy(ir->ir_codes, ir_codes, sizeof(ir->ir_codes)); 254 254 255 - init_input_dev(dev); 256 255 dev->keycode = ir->ir_codes; 257 256 dev->keycodesize = sizeof(IR_KEYTAB_TYPE); 258 257 dev->keycodemax = IR_KEYTAB_SIZE;
+70 -38
drivers/media/dvb/cinergyT2/cinergyT2.c
··· 137 137 struct urb *stream_urb [STREAM_URB_COUNT]; 138 138 139 139 #ifdef ENABLE_RC 140 - struct input_dev rc_input_dev; 140 + struct input_dev *rc_input_dev; 141 + char phys[64]; 141 142 struct work_struct rc_query_work; 142 143 int rc_input_event; 143 144 u32 rc_last_code; ··· 684 683 }; 685 684 686 685 #ifdef ENABLE_RC 686 + 687 687 static void cinergyt2_query_rc (void *data) 688 688 { 689 689 struct cinergyt2 *cinergyt2 = data; ··· 705 703 /* stop key repeat */ 706 704 if (cinergyt2->rc_input_event != KEY_MAX) { 707 705 dprintk(1, "rc_input_event=%d Up\n", cinergyt2->rc_input_event); 708 - input_report_key(&cinergyt2->rc_input_dev, 706 + input_report_key(cinergyt2->rc_input_dev, 709 707 cinergyt2->rc_input_event, 0); 710 708 cinergyt2->rc_input_event = KEY_MAX; 711 709 } ··· 724 722 /* keyrepeat bit -> just repeat last rc_input_event */ 725 723 } else { 726 724 cinergyt2->rc_input_event = KEY_MAX; 727 - for (i = 0; i < sizeof(rc_keys) / sizeof(rc_keys[0]); i += 3) { 725 + for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3) { 728 726 if (rc_keys[i + 0] == rc_events[n].type && 729 727 rc_keys[i + 1] == le32_to_cpu(rc_events[n].value)) { 730 728 cinergyt2->rc_input_event = rc_keys[i + 2]; ··· 738 736 cinergyt2->rc_last_code != ~0) { 739 737 /* emit a key-up so the double event is recognized */ 740 738 dprintk(1, "rc_input_event=%d UP\n", cinergyt2->rc_input_event); 741 - input_report_key(&cinergyt2->rc_input_dev, 739 + input_report_key(cinergyt2->rc_input_dev, 742 740 cinergyt2->rc_input_event, 0); 743 741 } 744 742 dprintk(1, "rc_input_event=%d\n", cinergyt2->rc_input_event); 745 - input_report_key(&cinergyt2->rc_input_dev, 743 + input_report_key(cinergyt2->rc_input_dev, 746 744 cinergyt2->rc_input_event, 1); 747 745 cinergyt2->rc_last_code = rc_events[n].value; 748 746 } ··· 754 752 755 753 up(&cinergyt2->sem); 756 754 } 757 - #endif 755 + 756 + static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) 757 + { 758 + struct input_dev *input_dev; 759 + int i; 760 + 761 + cinergyt2->rc_input_dev = input_dev = input_allocate_device(); 762 + if (!input_dev) 763 + return -ENOMEM; 764 + 765 + usb_make_path(cinergyt2->udev, cinergyt2->phys, sizeof(cinergyt2->phys)); 766 + strlcat(cinergyt2->phys, "/input0", sizeof(cinergyt2->phys)); 767 + cinergyt2->rc_input_event = KEY_MAX; 768 + cinergyt2->rc_last_code = ~0; 769 + INIT_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc, cinergyt2); 770 + 771 + input_dev->name = DRIVER_NAME " remote control"; 772 + input_dev->phys = cinergyt2->phys; 773 + input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP); 774 + for (i = 0; ARRAY_SIZE(rc_keys); i += 3) 775 + set_bit(rc_keys[i + 2], input_dev->keybit); 776 + input_dev->keycodesize = 0; 777 + input_dev->keycodemax = 0; 778 + 779 + input_register_device(cinergyt2->rc_input_dev); 780 + schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); 781 + } 782 + 783 + static void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) 784 + { 785 + cancel_delayed_work(&cinergyt2->rc_query_work); 786 + flush_scheduled_work(); 787 + input_unregister_device(cinergyt2->rc_input_dev); 788 + } 789 + 790 + static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) 791 + { 792 + cancel_delayed_work(&cinergyt2->rc_query_work); 793 + } 794 + 795 + static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) 796 + { 797 + schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); 798 + } 799 + 800 + #else 801 + 802 + static inline int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) { return 0; } 803 + static inline void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) { } 804 + static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) { } 805 + static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) { } 806 + 807 + #endif /* ENABLE_RC */ 758 808 759 809 static void cinergyt2_query (void *data) 760 810 { ··· 843 789 { 844 790 struct cinergyt2 *cinergyt2; 845 791 int err; 846 - #ifdef ENABLE_RC 847 - int i; 848 - #endif 849 792 850 793 if (!(cinergyt2 = kmalloc (sizeof(struct cinergyt2), GFP_KERNEL))) { 851 794 dprintk(1, "out of memory?!?\n"); ··· 897 846 &cinergyt2_fe_template, cinergyt2, 898 847 DVB_DEVICE_FRONTEND); 899 848 900 - #ifdef ENABLE_RC 901 - cinergyt2->rc_input_dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP); 902 - cinergyt2->rc_input_dev.keycodesize = 0; 903 - cinergyt2->rc_input_dev.keycodemax = 0; 904 - cinergyt2->rc_input_dev.name = DRIVER_NAME " remote control"; 849 + err = cinergyt2_register_rc(cinergyt2); 850 + if (err) 851 + goto bailout; 905 852 906 - for (i = 0; i < sizeof(rc_keys) / sizeof(rc_keys[0]); i += 3) 907 - set_bit(rc_keys[i + 2], cinergyt2->rc_input_dev.keybit); 908 - 909 - input_register_device(&cinergyt2->rc_input_dev); 910 - 911 - cinergyt2->rc_input_event = KEY_MAX; 912 - cinergyt2->rc_last_code = ~0; 913 - 914 - INIT_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc, cinergyt2); 915 - schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); 916 - #endif 917 853 return 0; 918 854 919 855 bailout: 920 856 dvb_dmxdev_release(&cinergyt2->dmxdev); 921 857 dvb_dmx_release(&cinergyt2->demux); 922 - dvb_unregister_adapter (&cinergyt2->adapter); 923 - cinergyt2_free_stream_urbs (cinergyt2); 858 + dvb_unregister_adapter(&cinergyt2->adapter); 859 + cinergyt2_free_stream_urbs(cinergyt2); 924 860 kfree(cinergyt2); 925 861 return -ENOMEM; 926 862 } ··· 919 881 if (down_interruptible(&cinergyt2->sem)) 920 882 return; 921 883 922 - #ifdef ENABLE_RC 923 - cancel_delayed_work(&cinergyt2->rc_query_work); 924 - flush_scheduled_work(); 925 - input_unregister_device(&cinergyt2->rc_input_dev); 926 - #endif 884 + cinergyt2_unregister_rc(cinergyt2); 927 885 928 886 cinergyt2->demux.dmx.close(&cinergyt2->demux.dmx); 929 887 dvb_net_release(&cinergyt2->dvbnet); ··· 942 908 943 909 if (state.event > PM_EVENT_ON) { 944 910 struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf); 945 - #ifdef ENABLE_RC 946 - cancel_delayed_work(&cinergyt2->rc_query_work); 947 - #endif 911 + 912 + cinergyt2_suspend_rc(cinergyt2); 948 913 cancel_delayed_work(&cinergyt2->query_work); 949 914 if (cinergyt2->streaming) 950 915 cinergyt2_stop_stream_xfer(cinergyt2); ··· 971 938 schedule_delayed_work(&cinergyt2->query_work, HZ/2); 972 939 } 973 940 974 - #ifdef ENABLE_RC 975 - schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); 976 - #endif 941 + cinergyt2_resume_rc(cinergyt2); 942 + 977 943 up(&cinergyt2->sem); 978 944 return 0; 979 945 }
+28 -22
drivers/media/dvb/dvb-usb/dvb-usb-remote.c
··· 39 39 d->last_event = event; 40 40 case REMOTE_KEY_REPEAT: 41 41 deb_rc("key repeated\n"); 42 - input_event(&d->rc_input_dev, EV_KEY, d->last_event, 1); 43 - input_event(&d->rc_input_dev, EV_KEY, d->last_event, 0); 44 - input_sync(&d->rc_input_dev); 42 + input_event(d->rc_input_dev, EV_KEY, event, 1); 43 + input_event(d->rc_input_dev, EV_KEY, d->last_event, 0); 44 + input_sync(d->rc_input_dev); 45 45 break; 46 46 default: 47 47 break; ··· 53 53 deb_rc("NO KEY PRESSED\n"); 54 54 if (d->last_state != REMOTE_NO_KEY_PRESSED) { 55 55 deb_rc("releasing event %d\n",d->last_event); 56 - input_event(&d->rc_input_dev, EV_KEY, d->last_event, 0); 57 - input_sync(&d->rc_input_dev); 56 + input_event(d->rc_input_dev, EV_KEY, d->last_event, 0); 57 + input_sync(d->rc_input_dev); 58 58 } 59 59 d->last_state = REMOTE_NO_KEY_PRESSED; 60 60 d->last_event = 0; ··· 63 63 deb_rc("KEY PRESSED\n"); 64 64 deb_rc("pressing event %d\n",event); 65 65 66 - input_event(&d->rc_input_dev, EV_KEY, event, 1); 67 - input_sync(&d->rc_input_dev); 66 + input_event(d->rc_input_dev, EV_KEY, event, 1); 67 + input_sync(d->rc_input_dev); 68 68 69 69 d->last_event = event; 70 70 d->last_state = REMOTE_KEY_PRESSED; ··· 73 73 deb_rc("KEY_REPEAT\n"); 74 74 if (d->last_state != REMOTE_NO_KEY_PRESSED) { 75 75 deb_rc("repeating event %d\n",d->last_event); 76 - input_event(&d->rc_input_dev, EV_KEY, d->last_event, 2); 77 - input_sync(&d->rc_input_dev); 76 + input_event(d->rc_input_dev, EV_KEY, d->last_event, 2); 77 + input_sync(d->rc_input_dev); 78 78 d->last_state = REMOTE_KEY_REPEAT; 79 79 } 80 80 default: ··· 89 89 int dvb_usb_remote_init(struct dvb_usb_device *d) 90 90 { 91 91 int i; 92 + 92 93 if (d->props.rc_key_map == NULL || 93 94 d->props.rc_query == NULL || 94 95 dvb_usb_disable_rc_polling) 95 96 return 0; 96 97 97 - /* Initialise the remote-control structures.*/ 98 - init_input_dev(&d->rc_input_dev); 98 + usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys)); 99 + strlcpy(d->rc_phys, "/ir0", sizeof(d->rc_phys)); 99 100 100 - d->rc_input_dev.evbit[0] = BIT(EV_KEY); 101 - d->rc_input_dev.keycodesize = sizeof(unsigned char); 102 - d->rc_input_dev.keycodemax = KEY_MAX; 103 - d->rc_input_dev.name = "IR-receiver inside an USB DVB receiver"; 101 + d->rc_input_dev = input_allocate_device(); 102 + if (!d->rc_input_dev) 103 + return -ENOMEM; 104 + 105 + d->rc_input_dev->evbit[0] = BIT(EV_KEY); 106 + d->rc_input_dev->keycodesize = sizeof(unsigned char); 107 + d->rc_input_dev->keycodemax = KEY_MAX; 108 + d->rc_input_dev->name = "IR-receiver inside an USB DVB receiver"; 109 + d->rc_input_dev->phys = d->rc_phys; 104 110 105 111 /* set the bits for the keys */ 106 - deb_rc("key map size: %d\n",d->props.rc_key_map_size); 112 + deb_rc("key map size: %d\n", d->props.rc_key_map_size); 107 113 for (i = 0; i < d->props.rc_key_map_size; i++) { 108 114 deb_rc("setting bit for event %d item %d\n",d->props.rc_key_map[i].event, i); 109 - set_bit(d->props.rc_key_map[i].event, d->rc_input_dev.keybit); 115 + set_bit(d->props.rc_key_map[i].event, d->rc_input_dev->keybit); 110 116 } 111 117 112 118 /* Start the remote-control polling. */ ··· 120 114 d->props.rc_interval = 100; /* default */ 121 115 122 116 /* setting these two values to non-zero, we have to manage key repeats */ 123 - d->rc_input_dev.rep[REP_PERIOD] = d->props.rc_interval; 124 - d->rc_input_dev.rep[REP_DELAY] = d->props.rc_interval + 150; 117 + d->rc_input_dev->rep[REP_PERIOD] = d->props.rc_interval; 118 + d->rc_input_dev->rep[REP_DELAY] = d->props.rc_interval + 150; 125 119 126 - input_register_device(&d->rc_input_dev); 120 + input_register_device(d->rc_input_dev); 127 121 128 122 INIT_WORK(&d->rc_query_work, dvb_usb_read_remote_control, d); 129 123 130 - info("schedule remote query interval to %d msecs.",d->props.rc_interval); 124 + info("schedule remote query interval to %d msecs.", d->props.rc_interval); 131 125 schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc_interval)); 132 126 133 127 d->state |= DVB_USB_STATE_REMOTE; ··· 140 134 if (d->state & DVB_USB_STATE_REMOTE) { 141 135 cancel_delayed_work(&d->rc_query_work); 142 136 flush_scheduled_work(); 143 - input_unregister_device(&d->rc_input_dev); 137 + input_unregister_device(d->rc_input_dev); 144 138 } 145 139 d->state &= ~DVB_USB_STATE_REMOTE; 146 140 return 0;
+2 -1
drivers/media/dvb/dvb-usb/dvb-usb.h
··· 300 300 int (*fe_init) (struct dvb_frontend *); 301 301 302 302 /* remote control */ 303 - struct input_dev rc_input_dev; 303 + struct input_dev *rc_input_dev; 304 + char rc_phys[64]; 304 305 struct work_struct rc_query_work; 305 306 u32 last_event; 306 307 int last_state;
+21 -16
drivers/media/dvb/ttpci/av7110_ir.c
··· 15 15 16 16 static int av_cnt; 17 17 static struct av7110 *av_list[4]; 18 - static struct input_dev input_dev; 18 + static struct input_dev *input_dev; 19 19 20 20 static u16 key_map [256] = { 21 21 KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, ··· 43 43 44 44 static void av7110_emit_keyup(unsigned long data) 45 45 { 46 - if (!data || !test_bit(data, input_dev.key)) 46 + if (!data || !test_bit(data, input_dev->key)) 47 47 return; 48 48 49 - input_event(&input_dev, EV_KEY, data, !!0); 49 + input_event(input_dev, EV_KEY, data, !!0); 50 50 } 51 51 52 52 ··· 112 112 if (timer_pending(&keyup_timer)) { 113 113 del_timer(&keyup_timer); 114 114 if (keyup_timer.data != keycode || new_toggle != old_toggle) { 115 - input_event(&input_dev, EV_KEY, keyup_timer.data, !!0); 116 - input_event(&input_dev, EV_KEY, keycode, !0); 115 + input_event(input_dev, EV_KEY, keyup_timer.data, !!0); 116 + input_event(input_dev, EV_KEY, keycode, !0); 117 117 } else 118 - input_event(&input_dev, EV_KEY, keycode, 2); 118 + input_event(input_dev, EV_KEY, keycode, 2); 119 119 120 120 } else 121 - input_event(&input_dev, EV_KEY, keycode, !0); 121 + input_event(input_dev, EV_KEY, keycode, !0); 122 122 123 123 keyup_timer.expires = jiffies + UP_TIMEOUT; 124 124 keyup_timer.data = keycode; ··· 132 132 { 133 133 int i; 134 134 135 - memset(input_dev.keybit, 0, sizeof(input_dev.keybit)); 135 + memset(input_dev->keybit, 0, sizeof(input_dev->keybit)); 136 136 137 - for (i = 0; i < sizeof(key_map) / sizeof(key_map[0]); i++) { 137 + for (i = 0; i < ARRAY_SIZE(key_map); i++) { 138 138 if (key_map[i] > KEY_MAX) 139 139 key_map[i] = 0; 140 140 else if (key_map[i] > KEY_RESERVED) 141 - set_bit(key_map[i], input_dev.keybit); 141 + set_bit(key_map[i], input_dev->keybit); 142 142 } 143 143 } 144 144 ··· 216 216 init_timer(&keyup_timer); 217 217 keyup_timer.data = 0; 218 218 219 - input_dev.name = "DVB on-card IR receiver"; 220 - set_bit(EV_KEY, input_dev.evbit); 221 - set_bit(EV_REP, input_dev.evbit); 219 + input_dev = input_allocate_device(); 220 + if (!input_dev) 221 + return -ENOMEM; 222 + 223 + input_dev->name = "DVB on-card IR receiver"; 224 + 225 + set_bit(EV_KEY, input_dev->evbit); 226 + set_bit(EV_REP, input_dev->evbit); 222 227 input_register_keys(); 223 - input_register_device(&input_dev); 224 - input_dev.timer.function = input_repeat_key; 228 + input_register_device(input_dev); 229 + input_dev->timer.function = input_repeat_key; 225 230 226 231 e = create_proc_entry("av7110_ir", S_IFREG | S_IRUGO | S_IWUSR, NULL); 227 232 if (e) { ··· 261 256 if (av_cnt == 1) { 262 257 del_timer_sync(&keyup_timer); 263 258 remove_proc_entry("av7110_ir", NULL); 264 - input_unregister_device(&input_dev); 259 + input_unregister_device(input_dev); 265 260 } 266 261 267 262 av_cnt--;
+13 -11
drivers/media/dvb/ttpci/budget-ci.c
··· 64 64 65 65 struct budget_ci { 66 66 struct budget budget; 67 - struct input_dev input_dev; 67 + struct input_dev *input_dev; 68 68 struct tasklet_struct msp430_irq_tasklet; 69 69 struct tasklet_struct ciintf_irq_tasklet; 70 70 int slot_status; ··· 145 145 static void msp430_ir_interrupt(unsigned long data) 146 146 { 147 147 struct budget_ci *budget_ci = (struct budget_ci *) data; 148 - struct input_dev *dev = &budget_ci->input_dev; 148 + struct input_dev *dev = budget_ci->input_dev; 149 149 unsigned int code = 150 150 ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8; 151 151 ··· 181 181 static int msp430_ir_init(struct budget_ci *budget_ci) 182 182 { 183 183 struct saa7146_dev *saa = budget_ci->budget.dev; 184 + struct input_dev *input_dev; 184 185 int i; 185 186 186 - memset(&budget_ci->input_dev, 0, sizeof(struct input_dev)); 187 + budget_ci->input_dev = input_dev = input_allocate_device(); 188 + if (!input_dev) 189 + return -ENOMEM; 187 190 188 191 sprintf(budget_ci->ir_dev_name, "Budget-CI dvb ir receiver %s", saa->name); 189 - budget_ci->input_dev.name = budget_ci->ir_dev_name; 190 192 191 - set_bit(EV_KEY, budget_ci->input_dev.evbit); 193 + input_dev->name = budget_ci->ir_dev_name; 192 194 193 - for (i = 0; i < sizeof(key_map) / sizeof(*key_map); i++) 195 + set_bit(EV_KEY, input_dev->evbit); 196 + for (i = 0; i < ARRAY_SIZE(key_map); i++) 194 197 if (key_map[i]) 195 - set_bit(key_map[i], budget_ci->input_dev.keybit); 198 + set_bit(key_map[i], input_dev->keybit); 196 199 197 - input_register_device(&budget_ci->input_dev); 200 + input_register_device(budget_ci->input_dev); 198 201 199 - budget_ci->input_dev.timer.function = msp430_ir_debounce; 202 + input_dev->timer.function = msp430_ir_debounce; 200 203 201 204 saa7146_write(saa, IER, saa7146_read(saa, IER) | MASK_06); 202 - 203 205 saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI); 204 206 205 207 return 0; ··· 210 208 static void msp430_ir_deinit(struct budget_ci *budget_ci) 211 209 { 212 210 struct saa7146_dev *saa = budget_ci->budget.dev; 213 - struct input_dev *dev = &budget_ci->input_dev; 211 + struct input_dev *dev = budget_ci->input_dev; 214 212 215 213 saa7146_write(saa, IER, saa7146_read(saa, IER) & ~MASK_06); 216 214 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
+32 -19
drivers/media/dvb/ttusb-dec/ttusb_dec.c
··· 152 152 struct list_head filter_info_list; 153 153 spinlock_t filter_info_list_lock; 154 154 155 - struct input_dev rc_input_dev; 155 + struct input_dev *rc_input_dev; 156 + char rc_phys[64]; 156 157 157 158 int active; /* Loaded successfully */ 158 159 }; ··· 236 235 * this should/could be added later ... 237 236 * for now lets report each signal as a key down and up*/ 238 237 dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]); 239 - input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],1); 240 - input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],0); 241 - input_sync(&dec->rc_input_dev); 238 + input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1); 239 + input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0); 240 + input_sync(dec->rc_input_dev); 242 241 } 243 242 244 243 exit: retval = usb_submit_urb(urb, GFP_ATOMIC); ··· 1182 1181 (unsigned long)dec); 1183 1182 } 1184 1183 1185 - static void ttusb_init_rc( struct ttusb_dec *dec) 1184 + static int ttusb_init_rc(struct ttusb_dec *dec) 1186 1185 { 1186 + struct input_dev *input_dev; 1187 1187 u8 b[] = { 0x00, 0x01 }; 1188 1188 int i; 1189 1189 1190 - init_input_dev(&dec->rc_input_dev); 1190 + usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys)); 1191 + strlcpy(dec->rc_phys, "/input0", sizeof(dec->rc_phys)); 1191 1192 1192 - dec->rc_input_dev.name = "ttusb_dec remote control"; 1193 - dec->rc_input_dev.evbit[0] = BIT(EV_KEY); 1194 - dec->rc_input_dev.keycodesize = sizeof(u16); 1195 - dec->rc_input_dev.keycodemax = 0x1a; 1196 - dec->rc_input_dev.keycode = rc_keys; 1193 + dec->rc_input_dev = input_dev = input_allocate_device(); 1194 + if (!input_dev) 1195 + return -ENOMEM; 1197 1196 1198 - for (i = 0; i < sizeof(rc_keys)/sizeof(rc_keys[0]); i++) 1199 - set_bit(rc_keys[i], dec->rc_input_dev.keybit); 1197 + input_dev->name = "ttusb_dec remote control"; 1198 + input_dev->phys = dec->rc_phys; 1199 + input_dev->evbit[0] = BIT(EV_KEY); 1200 + input_dev->keycodesize = sizeof(u16); 1201 + input_dev->keycodemax = 0x1a; 1202 + input_dev->keycode = rc_keys; 1200 1203 1201 - input_register_device(&dec->rc_input_dev); 1204 + for (i = 0; i < ARRAY_SIZE(rc_keys); i++) 1205 + set_bit(rc_keys[i], input_dev->keybit); 1202 1206 1203 - if(usb_submit_urb(dec->irq_urb,GFP_KERNEL)) { 1207 + input_register_device(input_dev); 1208 + 1209 + if (usb_submit_urb(dec->irq_urb, GFP_KERNEL)) 1204 1210 printk("%s: usb_submit_urb failed\n",__FUNCTION__); 1205 - } 1211 + 1206 1212 /* enable irq pipe */ 1207 1213 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL); 1214 + 1215 + return 0; 1208 1216 } 1209 1217 1210 1218 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec) ··· 1523 1513 * As the irq is submitted after the interface is changed, 1524 1514 * this is the best method i figured out. 1525 1515 * Any others?*/ 1526 - if(dec->interface == TTUSB_DEC_INTERFACE_IN) 1516 + if (dec->interface == TTUSB_DEC_INTERFACE_IN) 1527 1517 usb_kill_urb(dec->irq_urb); 1528 1518 1529 1519 usb_free_urb(dec->irq_urb); ··· 1531 1521 usb_buffer_free(dec->udev,IRQ_PACKET_SIZE, 1532 1522 dec->irq_buffer, dec->irq_dma_handle); 1533 1523 1534 - input_unregister_device(&dec->rc_input_dev); 1524 + if (dec->rc_input_dev) { 1525 + input_unregister_device(dec->rc_input_dev); 1526 + dec->rc_input_dev = NULL; 1527 + } 1535 1528 } 1536 1529 1537 1530 ··· 1672 1659 1673 1660 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN); 1674 1661 1675 - if(enable_rc) 1662 + if (enable_rc) 1676 1663 ttusb_init_rc(dec); 1677 1664 1678 1665 return 0;
+1 -1
drivers/media/video/bttvp.h
··· 240 240 241 241 /* for gpio-connected remote control */ 242 242 struct bttv_input { 243 - struct input_dev dev; 243 + struct input_dev *dev; 244 244 struct ir_input_state ir; 245 245 char name[32]; 246 246 char phys[32];
+32 -26
drivers/media/video/cx88/cx88-input.c
··· 260 260 261 261 struct cx88_IR { 262 262 struct cx88_core *core; 263 - struct input_dev input; 263 + struct input_dev *input; 264 264 struct ir_input_state ir; 265 265 char name[32]; 266 266 char phys[32]; ··· 315 315 if (ir->mask_keydown) { 316 316 /* bit set on keydown */ 317 317 if (gpio & ir->mask_keydown) { 318 - ir_input_keydown(&ir->input, &ir->ir, data, data); 318 + ir_input_keydown(ir->input, &ir->ir, data, data); 319 319 } else { 320 - ir_input_nokey(&ir->input, &ir->ir); 320 + ir_input_nokey(ir->input, &ir->ir); 321 321 } 322 322 323 323 } else if (ir->mask_keyup) { 324 324 /* bit cleared on keydown */ 325 325 if (0 == (gpio & ir->mask_keyup)) { 326 - ir_input_keydown(&ir->input, &ir->ir, data, data); 326 + ir_input_keydown(ir->input, &ir->ir, data, data); 327 327 } else { 328 - ir_input_nokey(&ir->input, &ir->ir); 328 + ir_input_nokey(ir->input, &ir->ir); 329 329 } 330 330 331 331 } else { 332 332 /* can't distinguish keydown/up :-/ */ 333 - ir_input_keydown(&ir->input, &ir->ir, data, data); 334 - ir_input_nokey(&ir->input, &ir->ir); 333 + ir_input_keydown(ir->input, &ir->ir, data, data); 334 + ir_input_nokey(ir->input, &ir->ir); 335 335 } 336 336 } 337 337 ··· 357 357 int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci) 358 358 { 359 359 struct cx88_IR *ir; 360 + struct input_dev *input_dev; 360 361 IR_KEYTAB_TYPE *ir_codes = NULL; 361 362 int ir_type = IR_TYPE_OTHER; 362 363 363 - ir = kmalloc(sizeof(*ir), GFP_KERNEL); 364 - if (NULL == ir) 364 + ir = kzalloc(sizeof(*ir), GFP_KERNEL); 365 + input_dev = input_allocate_device(); 366 + if (!ir || !input_dev) { 367 + kfree(ir); 368 + input_free_device(input_dev); 365 369 return -ENOMEM; 366 - memset(ir, 0, sizeof(*ir)); 370 + } 371 + 372 + ir->input = input_dev; 367 373 368 374 /* detect & configure */ 369 375 switch (core->board) { ··· 431 425 432 426 if (NULL == ir_codes) { 433 427 kfree(ir); 428 + input_free_device(input_dev); 434 429 return -ENODEV; 435 430 } 436 431 ··· 440 433 cx88_boards[core->board].name); 441 434 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci)); 442 435 443 - ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes); 444 - ir->input.name = ir->name; 445 - ir->input.phys = ir->phys; 446 - ir->input.id.bustype = BUS_PCI; 447 - ir->input.id.version = 1; 436 + ir_input_init(input_dev, &ir->ir, ir_type, ir_codes); 437 + input_dev->name = ir->name; 438 + input_dev->phys = ir->phys; 439 + input_dev->id.bustype = BUS_PCI; 440 + input_dev->id.version = 1; 448 441 if (pci->subsystem_vendor) { 449 - ir->input.id.vendor = pci->subsystem_vendor; 450 - ir->input.id.product = pci->subsystem_device; 442 + input_dev->id.vendor = pci->subsystem_vendor; 443 + input_dev->id.product = pci->subsystem_device; 451 444 } else { 452 - ir->input.id.vendor = pci->vendor; 453 - ir->input.id.product = pci->device; 445 + input_dev->id.vendor = pci->vendor; 446 + input_dev->id.product = pci->device; 454 447 } 455 - ir->input.dev = &pci->dev; 448 + input_dev->cdev.dev = &pci->dev; 456 449 457 450 /* record handles to ourself */ 458 451 ir->core = core; ··· 472 465 } 473 466 474 467 /* all done */ 475 - input_register_device(&ir->input); 476 - printk("%s: registered IR remote control\n", core->name); 468 + input_register_device(ir->input); 477 469 478 470 return 0; 479 471 } ··· 490 484 flush_scheduled_work(); 491 485 } 492 486 493 - input_unregister_device(&ir->input); 487 + input_unregister_device(ir->input); 494 488 kfree(ir); 495 489 496 490 /* done */ ··· 521 515 if (!ir->scount) { 522 516 /* nothing to sample */ 523 517 if (ir->ir.keypressed && time_after(jiffies, ir->release)) 524 - ir_input_nokey(&ir->input, &ir->ir); 518 + ir_input_nokey(ir->input, &ir->ir); 525 519 return; 526 520 } 527 521 ··· 563 557 564 558 ir_dprintk("Key Code: %x\n", (ircode >> 16) & 0x7f); 565 559 566 - ir_input_keydown(&ir->input, &ir->ir, (ircode >> 16) & 0x7f, (ircode >> 16) & 0xff); 560 + ir_input_keydown(ir->input, &ir->ir, (ircode >> 16) & 0x7f, (ircode >> 16) & 0xff); 567 561 ir->release = jiffies + msecs_to_jiffies(120); 568 562 break; 569 563 case CX88_BOARD_HAUPPAUGE: ··· 572 566 ir_dprintk("biphase decoded: %x\n", ircode); 573 567 if ((ircode & 0xfffff000) != 0x3000) 574 568 break; 575 - ir_input_keydown(&ir->input, &ir->ir, ircode & 0x3f, ircode); 569 + ir_input_keydown(ir->input, &ir->ir, ircode & 0x3f, ircode); 576 570 ir->release = jiffies + msecs_to_jiffies(120); 577 571 break; 578 572 }
+28 -24
drivers/media/video/ir-kbd-gpio.c
··· 158 158 159 159 struct IR { 160 160 struct bttv_sub_device *sub; 161 - struct input_dev input; 161 + struct input_dev *input; 162 162 struct ir_input_state ir; 163 163 char name[32]; 164 164 char phys[32]; ··· 217 217 if (ir->mask_keydown) { 218 218 /* bit set on keydown */ 219 219 if (gpio & ir->mask_keydown) { 220 - ir_input_keydown(&ir->input,&ir->ir,data,data); 220 + ir_input_keydown(ir->input, &ir->ir, data, data); 221 221 } else { 222 - ir_input_nokey(&ir->input,&ir->ir); 222 + ir_input_nokey(ir->input, &ir->ir); 223 223 } 224 224 225 225 } else if (ir->mask_keyup) { 226 226 /* bit cleared on keydown */ 227 227 if (0 == (gpio & ir->mask_keyup)) { 228 - ir_input_keydown(&ir->input,&ir->ir,data,data); 228 + ir_input_keydown(ir->input, &ir->ir, data, data); 229 229 } else { 230 - ir_input_nokey(&ir->input,&ir->ir); 230 + ir_input_nokey(ir->input, &ir->ir); 231 231 } 232 232 233 233 } else { 234 234 /* can't disturgissh keydown/up :-/ */ 235 - ir_input_keydown(&ir->input,&ir->ir,data,data); 236 - ir_input_nokey(&ir->input,&ir->ir); 235 + ir_input_keydown(ir->input, &ir->ir, data, data); 236 + ir_input_nokey(ir->input, &ir->ir); 237 237 } 238 238 } 239 239 ··· 268 268 { 269 269 struct bttv_sub_device *sub = to_bttv_sub_dev(dev); 270 270 struct IR *ir; 271 + struct input_dev *input_dev; 271 272 IR_KEYTAB_TYPE *ir_codes = NULL; 272 273 int ir_type = IR_TYPE_OTHER; 273 274 274 - ir = kmalloc(sizeof(*ir),GFP_KERNEL); 275 - if (NULL == ir) 275 + ir = kzalloc(sizeof(*ir), GFP_KERNEL); 276 + input_dev = input_allocate_device(); 277 + if (!ir || !input_dev) { 278 + kfree(ir); 279 + input_free_device(input_dev); 276 280 return -ENOMEM; 277 - memset(ir,0,sizeof(*ir)); 281 + } 278 282 279 283 /* detect & configure */ 280 284 switch (sub->core->type) { ··· 332 328 } 333 329 if (NULL == ir_codes) { 334 330 kfree(ir); 331 + input_free_device(input_dev); 335 332 return -ENODEV; 336 333 } 337 334 ··· 346 341 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", 347 342 pci_name(sub->core->pci)); 348 343 349 - ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes); 350 - ir->input.name = ir->name; 351 - ir->input.phys = ir->phys; 352 - ir->input.id.bustype = BUS_PCI; 353 - ir->input.id.version = 1; 344 + ir_input_init(input_dev, &ir->ir, ir_type, ir_codes); 345 + input_dev->name = ir->name; 346 + input_dev->phys = ir->phys; 347 + input_dev->id.bustype = BUS_PCI; 348 + input_dev->id.version = 1; 354 349 if (sub->core->pci->subsystem_vendor) { 355 - ir->input.id.vendor = sub->core->pci->subsystem_vendor; 356 - ir->input.id.product = sub->core->pci->subsystem_device; 350 + input_dev->id.vendor = sub->core->pci->subsystem_vendor; 351 + input_dev->id.product = sub->core->pci->subsystem_device; 357 352 } else { 358 - ir->input.id.vendor = sub->core->pci->vendor; 359 - ir->input.id.product = sub->core->pci->device; 353 + input_dev->id.vendor = sub->core->pci->vendor; 354 + input_dev->id.product = sub->core->pci->device; 360 355 } 361 - ir->input.dev = &sub->core->pci->dev; 356 + input_dev->cdev.dev = &sub->core->pci->dev; 362 357 363 358 if (ir->polling) { 364 359 INIT_WORK(&ir->work, ir_work, ir); ··· 369 364 } 370 365 371 366 /* all done */ 372 - dev_set_drvdata(dev,ir); 373 - input_register_device(&ir->input); 374 - printk(DEVNAME ": %s detected at %s\n",ir->input.name,ir->input.phys); 367 + dev_set_drvdata(dev, ir); 368 + input_register_device(ir->input); 375 369 376 370 return 0; 377 371 } ··· 384 380 flush_scheduled_work(); 385 381 } 386 382 387 - input_unregister_device(&ir->input); 383 + input_unregister_device(ir->input); 388 384 kfree(ir); 389 385 return 0; 390 386 }
+19 -14
drivers/media/video/ir-kbd-i2c.c
··· 121 121 122 122 }; 123 123 124 - struct IR; 125 124 struct IR { 126 125 struct i2c_client c; 127 - struct input_dev input; 126 + struct input_dev *input; 128 127 struct ir_input_state ir; 129 128 130 129 struct work_struct work; ··· 270 271 } 271 272 272 273 if (0 == rc) { 273 - ir_input_nokey(&ir->input,&ir->ir); 274 + ir_input_nokey(ir->input, &ir->ir); 274 275 } else { 275 - ir_input_keydown(&ir->input,&ir->ir, ir_key, ir_raw); 276 + ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw); 276 277 } 277 278 } 278 279 ··· 317 318 char *name; 318 319 int ir_type; 319 320 struct IR *ir; 321 + struct input_dev *input_dev; 320 322 321 - if (NULL == (ir = kmalloc(sizeof(struct IR),GFP_KERNEL))) 323 + ir = kzalloc(sizeof(struct IR), GFP_KERNEL); 324 + input_dev = input_allocate_device(); 325 + if (!ir || !input_dev) { 326 + kfree(ir); 327 + input_free_device(input_dev); 322 328 return -ENOMEM; 323 - memset(ir,0,sizeof(*ir)); 329 + } 330 + 324 331 ir->c = client_template; 332 + ir->input = input_dev; 325 333 326 334 i2c_set_clientdata(&ir->c, ir); 327 335 ir->c.adapter = adap; ··· 381 375 ir->c.dev.bus_id); 382 376 383 377 /* init + register input device */ 384 - ir_input_init(&ir->input,&ir->ir,ir_type,ir_codes); 385 - ir->input.id.bustype = BUS_I2C; 386 - ir->input.name = ir->c.name; 387 - ir->input.phys = ir->phys; 388 - input_register_device(&ir->input); 389 - printk(DEVNAME ": %s detected at %s [%s]\n", 390 - ir->input.name,ir->input.phys,adap->name); 378 + ir_input_init(input_dev, &ir->ir, ir_type, ir_codes); 379 + input_dev->id.bustype = BUS_I2C; 380 + input_dev->name = ir->c.name; 381 + input_dev->phys = ir->phys; 382 + 383 + input_register_device(ir->input); 391 384 392 385 /* start polling via eventd */ 393 386 INIT_WORK(&ir->work, ir_work, ir); ··· 407 402 flush_scheduled_work(); 408 403 409 404 /* unregister devices */ 410 - input_unregister_device(&ir->input); 405 + input_unregister_device(ir->input); 411 406 i2c_detach_client(&ir->c); 412 407 413 408 /* free memory */
+21 -18
drivers/media/video/saa7134/saa7134-input.c
··· 425 425 426 426 if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) || 427 427 (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) { 428 - ir_input_keydown(&ir->dev,&ir->ir,data,data); 428 + ir_input_keydown(ir->dev, &ir->ir, data, data); 429 429 } else { 430 - ir_input_nokey(&ir->dev,&ir->ir); 430 + ir_input_nokey(ir->dev, &ir->ir); 431 431 } 432 432 return 0; 433 433 } ··· 456 456 int saa7134_input_init1(struct saa7134_dev *dev) 457 457 { 458 458 struct saa7134_ir *ir; 459 + struct input_dev *input_dev; 459 460 IR_KEYTAB_TYPE *ir_codes = NULL; 460 461 u32 mask_keycode = 0; 461 462 u32 mask_keydown = 0; ··· 536 535 return -ENODEV; 537 536 } 538 537 539 - ir = kmalloc(sizeof(*ir),GFP_KERNEL); 540 - if (NULL == ir) 538 + ir = kzalloc(sizeof(*ir), GFP_KERNEL); 539 + input_dev = input_allocate_device(); 540 + if (!ir || !input_dev) { 541 + kfree(ir); 542 + input_free_device(input_dev); 541 543 return -ENOMEM; 542 - memset(ir,0,sizeof(*ir)); 544 + } 543 545 544 546 /* init hardware-specific stuff */ 545 547 ir->mask_keycode = mask_keycode; ··· 556 552 snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", 557 553 pci_name(dev->pci)); 558 554 559 - ir_input_init(&ir->dev, &ir->ir, ir_type, ir_codes); 560 - ir->dev.name = ir->name; 561 - ir->dev.phys = ir->phys; 562 - ir->dev.id.bustype = BUS_PCI; 563 - ir->dev.id.version = 1; 555 + ir_input_init(input_dev, &ir->ir, ir_type, ir_codes); 556 + input_dev->name = ir->name; 557 + input_dev->phys = ir->phys; 558 + input_dev->id.bustype = BUS_PCI; 559 + input_dev->id.version = 1; 564 560 if (dev->pci->subsystem_vendor) { 565 - ir->dev.id.vendor = dev->pci->subsystem_vendor; 566 - ir->dev.id.product = dev->pci->subsystem_device; 561 + input_dev->id.vendor = dev->pci->subsystem_vendor; 562 + input_dev->id.product = dev->pci->subsystem_device; 567 563 } else { 568 - ir->dev.id.vendor = dev->pci->vendor; 569 - ir->dev.id.product = dev->pci->device; 564 + input_dev->id.vendor = dev->pci->vendor; 565 + input_dev->id.product = dev->pci->device; 570 566 } 571 - ir->dev.dev = &dev->pci->dev; 567 + input_dev->cdev.dev = &dev->pci->dev; 572 568 573 569 /* all done */ 574 570 dev->remote = ir; ··· 580 576 add_timer(&ir->timer); 581 577 } 582 578 583 - input_register_device(&dev->remote->dev); 584 - printk("%s: registered input device for IR\n",dev->name); 579 + input_register_device(ir->dev); 585 580 return 0; 586 581 } 587 582 ··· 589 586 if (NULL == dev->remote) 590 587 return; 591 588 592 - input_unregister_device(&dev->remote->dev); 593 589 if (dev->remote->polling) 594 590 del_timer_sync(&dev->remote->timer); 591 + input_unregister_device(dev->remote->dev); 595 592 kfree(dev->remote); 596 593 dev->remote = NULL; 597 594 }
+1 -1
drivers/media/video/saa7134/saa7134.h
··· 351 351 352 352 /* IR input */ 353 353 struct saa7134_ir { 354 - struct input_dev dev; 354 + struct input_dev *dev; 355 355 struct ir_input_state ir; 356 356 char name[32]; 357 357 char phys[32];