projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: another device ID for ipaq
[deliverable/linux.git] / drivers / usb / misc / phidgetkit.c
CommitLineData
1da177e4
LT		 1/*
2 * USB PhidgetInterfaceKit driver 1.0
3 *
69165c29
SY		 4 * Copyright (C) 2004, 2006 Sean Young <sean@mess.org>
5 * Copyright (C) 2005 Daniel Saakes <daniel@saakes.net>
1da177e4
LT		 6 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This is a driver for the USB PhidgetInterfaceKit.
14 */
15
1da177e4
LT		 16#include <linux/kernel.h>
17#include <linux/errno.h>
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/module.h>
21#include <linux/usb.h>
22
912b24c3
SY		 23#include "phidget.h"
24
1da177e4
LT		 25#define DRIVER_AUTHOR "Sean Young <sean@mess.org>"
26#define DRIVER_DESC "USB PhidgetInterfaceKit Driver"
27
28#define USB_VENDOR_ID_GLAB 0x06c2
29#define USB_DEVICE_ID_INTERFACEKIT004 0x0040
69165c29 30#define USB_DEVICE_ID_INTERFACEKIT01616 0x0044
1da177e4
LT		 31#define USB_DEVICE_ID_INTERFACEKIT888 0x0045
32#define USB_DEVICE_ID_INTERFACEKIT047 0x0051
33#define USB_DEVICE_ID_INTERFACEKIT088 0x0053
34
35#define USB_VENDOR_ID_WISEGROUP 0x0925
36#define USB_DEVICE_ID_INTERFACEKIT884 0x8201
37
69165c29
SY		 38#define MAX_INTERFACES 16
39
40#define URB_INT_SIZE 8
1da177e4
LT		 41
42struct driver_interfacekit {
43 int sensors;
44 int inputs;
45 int outputs;
46 int has_lcd;
47};
48#define ifkit(_sensors, _inputs, _outputs, _lcd) \
49static struct driver_interfacekit ph_##_sensors##_inputs##_outputs = { \
50 .sensors = _sensors, \
51 .inputs = _inputs, \
52 .outputs = _outputs, \
53 .has_lcd = _lcd, \
54};
55ifkit(0, 0, 4, 0);
56ifkit(8, 8, 8, 0);
57ifkit(0, 4, 7, 1);
58ifkit(8, 8, 4, 0);
59ifkit(0, 8, 8, 1);
69165c29 60ifkit(0, 16, 16, 0);
1da177e4 61
912b24c3
SY		 62static unsigned long device_no;
63
69165c29 64struct interfacekit {
1da177e4
LT		 65 struct usb_device *udev;
66 struct usb_interface *intf;
67 struct driver_interfacekit *ifkit;
912b24c3 68 struct device *dev;
69165c29 69 unsigned long outputs;
912b24c3 70 int dev_no;
69165c29
SY		 71 u8 inputs[MAX_INTERFACES];
72 u16 sensors[MAX_INTERFACES];
1da177e4
LT		 73 u8 lcd_files_on;
74
75 struct urb *irq;
76 unsigned char *data;
77 dma_addr_t data_dma;
69165c29
SY		 78
79 struct work_struct do_notify;
80 unsigned long input_events;
81 unsigned long sensor_events;
1da177e4
LT		 82};
83
84static struct usb_device_id id_table[] = {
85 {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT004),
86 .driver_info = (kernel_ulong_t)&ph_004},
87 {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT888),
88 .driver_info = (kernel_ulong_t)&ph_888},
89 {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT047),
90 .driver_info = (kernel_ulong_t)&ph_047},
91 {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT088),
92 .driver_info = (kernel_ulong_t)&ph_088},
69165c29
SY		 93 {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT01616),
94 .driver_info = (kernel_ulong_t)&ph_01616},
1da177e4
LT		 95 {USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_INTERFACEKIT884),
96 .driver_info = (kernel_ulong_t)&ph_884},
97 {}
98};
99MODULE_DEVICE_TABLE(usb, id_table);
100
69165c29 101static int change_outputs(struct interfacekit *kit, int output_num, int enable)
1da177e4 102{
69165c29 103 u8 *buffer;
1da177e4 104 int retval;
69165c29
SY		 105
106 if (enable)
107 set_bit(output_num, &kit->outputs);
108 else
109 clear_bit(output_num, &kit->outputs);
1da177e4 110
17590840 111 buffer = kzalloc(4, GFP_KERNEL);
1da177e4 112 if (!buffer) {
69165c29 113 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
1da177e4
LT		 114 return -ENOMEM;
115 }
69165c29
SY		 116 buffer[0] = (u8)kit->outputs;
117 buffer[1] = (u8)(kit->outputs >> 8);
1da177e4 118
69165c29 119 dev_dbg(&kit->udev->dev, "sending data: 0x%04x\n", (u16)kit->outputs);
1da177e4
LT		 120
121 retval = usb_control_msg(kit->udev,
122 usb_sndctrlpipe(kit->udev, 0),
123 0x09, 0x21, 0x0200, 0x0000, buffer, 4, 2000);
124
125 if (retval != 4)
126 dev_err(&kit->udev->dev, "usb_control_msg returned %d\n",
127 retval);
128 kfree(buffer);
129
130 return retval < 0 ? retval : 0;
131}
132
69165c29 133static int change_string(struct interfacekit *kit, const char *display, unsigned char row)
1da177e4
LT		 134{
135 unsigned char *buffer;
69165c29 136 unsigned char *form_buffer;
1da177e4
LT		 137 int retval = -ENOMEM;
138 int i,j, len, buf_ptr;
139
140 buffer = kmalloc(8, GFP_KERNEL);
141 form_buffer = kmalloc(30, GFP_KERNEL);
142 if ((!buffer) || (!form_buffer)) {
143 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
144 goto exit;
145 }
146
147 len = strlen(display);
148 if (len > 20)
149 len = 20;
150
151 dev_dbg(&kit->udev->dev, "Setting LCD line %d to %s\n", row, display);
152
153 form_buffer[0] = row * 0x40 + 0x80;
154 form_buffer[1] = 0x02;
155 buf_ptr = 2;
156 for (i = 0; i<len; i++)
157 form_buffer[buf_ptr++] = display[i];
158
159 for (i = 0; i < (20 - len); i++)
160 form_buffer[buf_ptr++] = 0x20;
161 form_buffer[buf_ptr++] = 0x01;
162 form_buffer[buf_ptr++] = row * 0x40 + 0x80 + strlen(display);
163
164 for (i = 0; i < buf_ptr; i += 7) {
165 if ((buf_ptr - i) > 7)
166 len = 7;
167 else
168 len = (buf_ptr - i);
169 for (j = 0; j < len; j++)
170 buffer[j] = form_buffer[i + j];
171 buffer[7] = len;
172
173 retval = usb_control_msg(kit->udev,
174 usb_sndctrlpipe(kit->udev, 0),
175 0x09, 0x21, 0x0200, 0x0000, buffer, 8, 2000);
176 if (retval < 0)
177 goto exit;
178 }
179
180 retval = 0;
181exit:
182 kfree(buffer);
183 kfree(form_buffer);
184
185 return retval;
186}
187
188#define set_lcd_line(number) \
912b24c3
SY		 189static ssize_t lcd_line_##number(struct device *dev, \
190 struct device_attribute *attr, \
191 const char *buf, size_t count) \
192{ \
193 struct interfacekit *kit = dev_get_drvdata(dev); \
194 change_string(kit, buf, number - 1); \
195 return count; \
da308e8d
SY		 196}
197
198#define lcd_line_attr(number) \
199 __ATTR(lcd_line_##number, S_IWUGO, NULL, lcd_line_##number)
200
1da177e4
LT		 201set_lcd_line(1);
202set_lcd_line(2);
203
060b8845 204static ssize_t set_backlight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4 205{
912b24c3 206 struct interfacekit *kit = dev_get_drvdata(dev);
1da177e4
LT		 207 int enabled;
208 unsigned char *buffer;
209 int retval = -ENOMEM;
210
17590840 211 buffer = kzalloc(8, GFP_KERNEL);
1da177e4
LT		 212 if (!buffer) {
213 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
214 goto exit;
215 }
216
217 if (sscanf(buf, "%d", &enabled) < 1) {
218 retval = -EINVAL;
219 goto exit;
220 }
1da177e4
LT		 221 if (enabled)
222 buffer[0] = 0x01;
223 buffer[7] = 0x11;
224
225 dev_dbg(&kit->udev->dev, "Setting backlight to %s\n", enabled ? "on" : "off");
226
227 retval = usb_control_msg(kit->udev,
228 usb_sndctrlpipe(kit->udev, 0),
229 0x09, 0x21, 0x0200, 0x0000, buffer, 8, 2000);
230 if (retval < 0)
231 goto exit;
232
233 retval = count;
234exit:
235 kfree(buffer);
236 return retval;
237}
da308e8d
SY		 238
239static struct device_attribute dev_lcd_line_attrs[] = {
240 lcd_line_attr(1),
241 lcd_line_attr(2),
242 __ATTR(backlight, S_IWUGO, NULL, set_backlight)
243};
1da177e4 244
69165c29 245static void remove_lcd_files(struct interfacekit *kit)
1da177e4 246{
da308e8d
SY		 247 int i;
248
1da177e4
LT		 249 if (kit->lcd_files_on) {
250 dev_dbg(&kit->udev->dev, "Removing lcd files\n");
da308e8d
SY		 251
252 for (i=0; i<ARRAY_SIZE(dev_lcd_line_attrs); i++)
253 device_remove_file(kit->dev, &dev_lcd_line_attrs[i]);
1da177e4
LT		 254 }
255}
256
060b8845 257static ssize_t enable_lcd_files(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4 258{
912b24c3 259 struct interfacekit *kit = dev_get_drvdata(dev);
1da177e4 260 int enable;
da308e8d 261 int i, rc;
1da177e4
LT		 262
263 if (kit->ifkit->has_lcd == 0)
264 return -ENODEV;
265
266 if (sscanf(buf, "%d", &enable) < 1)
267 return -EINVAL;
268
269 if (enable) {
270 if (!kit->lcd_files_on) {
271 dev_dbg(&kit->udev->dev, "Adding lcd files\n");
da308e8d
SY		 272 for (i=0; i<ARRAY_SIZE(dev_lcd_line_attrs); i++) {
273 rc = device_create_file(kit->dev,
274 &dev_lcd_line_attrs[i]);
275 if (rc)
276 goto out;
277 }
1da177e4
LT		 278 kit->lcd_files_on = 1;
279 }
280 } else {
281 if (kit->lcd_files_on) {
282 remove_lcd_files(kit);
283 kit->lcd_files_on = 0;
284 }
285 }
286
287 return count;
da308e8d
SY		 288out:
289 while (i-- > 0)
290 device_remove_file(kit->dev, &dev_lcd_line_attrs[i]);
291
292 return rc;
1da177e4 293}
da308e8d 294
1da177e4
LT		 295static DEVICE_ATTR(lcd, S_IWUGO, NULL, enable_lcd_files);
296
297static void interfacekit_irq(struct urb *urb, struct pt_regs *regs)
298{
69165c29 299 struct interfacekit *kit = urb->context;
1da177e4 300 unsigned char *buffer = kit->data;
69165c29 301 int i, level, sensor;
1da177e4 302 int status;
1da177e4
LT		 303
304 switch (urb->status) {
305 case 0: /* success */
306 break;
307 case -ECONNRESET: /* unlink */
308 case -ENOENT:
309 case -ESHUTDOWN:
310 return;
311 /* -EPIPE: should clear the halt */
312 default: /* error */
313 goto resubmit;
314 }
315
69165c29
SY		 316 /* digital inputs */
317 if (kit->ifkit->inputs == 16) {
318 for (i=0; i < 8; i++) {
319 level = (buffer[0] >> i) & 1;
320 if (kit->inputs[i] != level) {
321 kit->inputs[i] = level;
322 set_bit(i, &kit->input_events);
323 }
324 level = (buffer[1] >> i) & 1;
325 if (kit->inputs[8 + i] != level) {
326 kit->inputs[8 + i] = level;
327 set_bit(8 + i, &kit->input_events);
328 }
329 }
330 }
331 else if (kit->ifkit->inputs == 8) {
332 for (i=0; i < 8; i++) {
333 level = (buffer[1] >> i) & 1;
334 if (kit->inputs[i] != level) {
335 kit->inputs[i] = level;
336 set_bit(i, &kit->input_events);
337 }
338 }
1da177e4
LT		 339 }
340
69165c29
SY		 341 /* analog inputs */
342 if (kit->ifkit->sensors) {
343 sensor = (buffer[0] & 1) ? 4 : 0;
344
345 level = buffer[2] + (buffer[3] & 0x0f) * 256;
346 if (level != kit->sensors[sensor]) {
347 kit->sensors[sensor] = level;
348 set_bit(sensor, &kit->sensor_events);
349 }
350 sensor++;
351 level = buffer[4] + (buffer[3] & 0xf0) * 16;
352 if (level != kit->sensors[sensor]) {
353 kit->sensors[sensor] = level;
354 set_bit(sensor, &kit->sensor_events);
355 }
356 sensor++;
357 level = buffer[5] + (buffer[6] & 0x0f) * 256;
358 if (level != kit->sensors[sensor]) {
359 kit->sensors[sensor] = level;
360 set_bit(sensor, &kit->sensor_events);
361 }
362 sensor++;
363 level = buffer[7] + (buffer[6] & 0xf0) * 16;
364 if (level != kit->sensors[sensor]) {
365 kit->sensors[sensor] = level;
366 set_bit(sensor, &kit->sensor_events);
367 }
1da177e4
LT		 368 }
369
69165c29
SY		 370 if (kit->input_events || kit->sensor_events)
371 schedule_work(&kit->do_notify);
372
1da177e4
LT		 373resubmit:
374 status = usb_submit_urb(urb, SLAB_ATOMIC);
375 if (status)
376 err("can't resubmit intr, %s-%s/interfacekit0, status %d",
377 kit->udev->bus->bus_name,
378 kit->udev->devpath, status);
379}
380
69165c29
SY		 381static void do_notify(void *data)
382{
383 struct interfacekit *kit = data;
384 int i;
385 char sysfs_file[8];
386
387 for (i=0; i<kit->ifkit->inputs; i++) {
388 if (test_and_clear_bit(i, &kit->input_events)) {
389 sprintf(sysfs_file, "input%d", i + 1);
912b24c3 390 sysfs_notify(&kit->dev->kobj, NULL, sysfs_file);
69165c29
SY		 391 }
392 }
393
394 for (i=0; i<kit->ifkit->sensors; i++) {
395 if (test_and_clear_bit(i, &kit->sensor_events)) {
396 sprintf(sysfs_file, "sensor%d", i + 1);
912b24c3 397 sysfs_notify(&kit->dev->kobj, NULL, sysfs_file);
69165c29
SY		 398 }
399 }
400}
401
1da177e4 402#define show_set_output(value) \
912b24c3
SY		 403static ssize_t set_output##value(struct device *dev, \
404 struct device_attribute *attr, \
405 const char *buf, size_t count) \
1da177e4 406{ \
912b24c3 407 struct interfacekit *kit = dev_get_drvdata(dev); \
1da177e4
LT		 408 int enabled; \
409 int retval; \
410 \
69165c29 411 if (sscanf(buf, "%d", &enabled) < 1) \
1da177e4 412 return -EINVAL; \
1da177e4 413 \
69165c29 414 retval = change_outputs(kit, value - 1, enabled); \
1da177e4
LT		 415 \
416 return retval ? retval : count; \
417} \
418 \
912b24c3
SY		 419static ssize_t show_output##value(struct device *dev, \
420 struct device_attribute *attr, \
421 char *buf) \
1da177e4 422{ \
912b24c3 423 struct interfacekit *kit = dev_get_drvdata(dev); \
1da177e4 424 \
69165c29 425 return sprintf(buf, "%d\n", !!test_bit(value - 1, &kit->outputs));\
da308e8d
SY		 426}
427
428#define output_attr(value) \
429 __ATTR(output##value, S_IWUGO | S_IRUGO, \
430 show_output##value, set_output##value)
431
1da177e4
LT		 432show_set_output(1);
433show_set_output(2);
434show_set_output(3);
435show_set_output(4);
436show_set_output(5);
437show_set_output(6);
438show_set_output(7);
69165c29
SY		 439show_set_output(8);
440show_set_output(9);
441show_set_output(10);
442show_set_output(11);
443show_set_output(12);
444show_set_output(13);
445show_set_output(14);
446show_set_output(15);
447show_set_output(16);
1da177e4 448
da308e8d
SY		 449static struct device_attribute dev_output_attrs[] = {
450 output_attr(1), output_attr(2), output_attr(3), output_attr(4),
451 output_attr(5), output_attr(6), output_attr(7), output_attr(8),
452 output_attr(9), output_attr(10), output_attr(11), output_attr(12),
453 output_attr(13), output_attr(14), output_attr(15), output_attr(16)
454};
455
1da177e4 456#define show_input(value) \
da308e8d
SY		 457static ssize_t show_input##value(struct device *dev, \
458 struct device_attribute *attr, char *buf) \
1da177e4 459{ \
912b24c3 460 struct interfacekit *kit = dev_get_drvdata(dev); \
1da177e4 461 \
69165c29 462 return sprintf(buf, "%d\n", (int)kit->inputs[value - 1]); \
da308e8d
SY		 463}
464
465#define input_attr(value) \
466 __ATTR(input##value, S_IRUGO, show_input##value, NULL)
1da177e4
LT		 467
468show_input(1);
469show_input(2);
470show_input(3);
471show_input(4);
472show_input(5);
473show_input(6);
474show_input(7);
69165c29
SY		 475show_input(8);
476show_input(9);
477show_input(10);
478show_input(11);
479show_input(12);
480show_input(13);
481show_input(14);
482show_input(15);
483show_input(16);
1da177e4 484
da308e8d
SY		 485static struct device_attribute dev_input_attrs[] = {
486 input_attr(1), input_attr(2), input_attr(3), input_attr(4),
487 input_attr(5), input_attr(6), input_attr(7), input_attr(8),
488 input_attr(9), input_attr(10), input_attr(11), input_attr(12),
489 input_attr(13), input_attr(14), input_attr(15), input_attr(16)
490};
491
1da177e4 492#define show_sensor(value) \
912b24c3
SY		 493static ssize_t show_sensor##value(struct device *dev, \
494 struct device_attribute *attr, \
495 char *buf) \
1da177e4 496{ \
912b24c3 497 struct interfacekit *kit = dev_get_drvdata(dev); \
1da177e4 498 \
69165c29 499 return sprintf(buf, "%d\n", (int)kit->sensors[value - 1]); \
da308e8d
SY		 500}
501
502#define sensor_attr(value) \
503 __ATTR(sensor##value, S_IRUGO, show_sensor##value, NULL)
1da177e4
LT		 504
505show_sensor(1);
506show_sensor(2);
507show_sensor(3);
508show_sensor(4);
509show_sensor(5);
510show_sensor(6);
511show_sensor(7);
69165c29 512show_sensor(8);
1da177e4 513
da308e8d
SY		 514static struct device_attribute dev_sensor_attrs[] = {
515 sensor_attr(1), sensor_attr(2), sensor_attr(3), sensor_attr(4),
516 sensor_attr(5), sensor_attr(6), sensor_attr(7), sensor_attr(8)
517};
518
1da177e4
LT		 519static int interfacekit_probe(struct usb_interface *intf, const struct usb_device_id *id)
520{
521 struct usb_device *dev = interface_to_usbdev(intf);
522 struct usb_host_interface *interface;
523 struct usb_endpoint_descriptor *endpoint;
69165c29 524 struct interfacekit *kit;
1da177e4 525 struct driver_interfacekit *ifkit;
69165c29 526 int pipe, maxp, rc = -ENOMEM;
da308e8d 527 int bit, value, i;
1da177e4
LT		 528
529 ifkit = (struct driver_interfacekit *)id->driver_info;
530 if (!ifkit)
531 return -ENODEV;
532
533 interface = intf->cur_altsetting;
534 if (interface->desc.bNumEndpoints != 1)
535 return -ENODEV;
536
537 endpoint = &interface->endpoint[0].desc;
538 if (!(endpoint->bEndpointAddress & 0x80))
539 return -ENODEV;
540 /*
541 * bmAttributes
542 */
543 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
544 maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
545
17590840 546 kit = kzalloc(sizeof(*kit), GFP_KERNEL);
69165c29
SY		 547 if (!kit)
548 goto out;
1da177e4 549
912b24c3 550 kit->dev_no = -1;
69165c29
SY		 551 kit->ifkit = ifkit;
552 kit->data = usb_buffer_alloc(dev, URB_INT_SIZE, SLAB_ATOMIC, &kit->data_dma);
553 if (!kit->data)
554 goto out;
1da177e4
LT		 555
556 kit->irq = usb_alloc_urb(0, GFP_KERNEL);
69165c29
SY		 557 if (!kit->irq)
558 goto out;
1da177e4
LT		 559
560 kit->udev = usb_get_dev(dev);
561 kit->intf = intf;
69165c29 562 INIT_WORK(&kit->do_notify, do_notify, kit);
1da177e4 563 usb_fill_int_urb(kit->irq, kit->udev, pipe, kit->data,
69165c29 564 maxp > URB_INT_SIZE ? URB_INT_SIZE : maxp,
1da177e4
LT		 565 interfacekit_irq, kit, endpoint->bInterval);
566 kit->irq->transfer_dma = kit->data_dma;
567 kit->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
568
569 usb_set_intfdata(intf, kit);
570
912b24c3
SY		 571 do {
572 bit = find_first_zero_bit(&device_no, sizeof(device_no));
573 value = test_and_set_bit(bit, &device_no);
574 } while(value);
575 kit->dev_no = bit;
576
577 kit->dev = device_create(phidget_class, &kit->udev->dev, 0,
578 "interfacekit%d", kit->dev_no);
579 if (IS_ERR(kit->dev)) {
580 rc = PTR_ERR(kit->dev);
581 kit->dev = NULL;
582 goto out;
583 }
584 dev_set_drvdata(kit->dev, kit);
585
1da177e4 586 if (usb_submit_urb(kit->irq, GFP_KERNEL)) {
69165c29
SY		 587 rc = -EIO;
588 goto out;
1da177e4
LT		 589 }
590
da308e8d
SY		 591 for (i=0; i<ifkit->outputs; i++ ) {
592 rc = device_create_file(kit->dev, &dev_output_attrs[i]);
593 if (rc)
594 goto out2;
69165c29 595 }
1da177e4 596
da308e8d
SY		 597 for (i=0; i<ifkit->inputs; i++ ) {
598 rc = device_create_file(kit->dev, &dev_input_attrs[i]);
599 if (rc)
600 goto out3;
69165c29 601 }
1da177e4 602
da308e8d
SY		 603 for (i=0; i<ifkit->sensors; i++ ) {
604 rc = device_create_file(kit->dev, &dev_sensor_attrs[i]);
605 if (rc)
606 goto out4;
1da177e4 607 }
1da177e4 608
da308e8d
SY		 609 if (ifkit->has_lcd) {
610 rc = device_create_file(kit->dev, &dev_attr_lcd);
611 if (rc)
612 goto out4;
613
614 }
1da177e4
LT		 615
616 dev_info(&intf->dev, "USB PhidgetInterfaceKit %d/%d/%d attached\n",
617 ifkit->sensors, ifkit->inputs, ifkit->outputs);
618
619 return 0;
69165c29 620
da308e8d
SY		 621out4:
622 while (i-- > 0)
623 device_remove_file(kit->dev, &dev_sensor_attrs[i]);
624
625 i = ifkit->inputs;
626out3:
627 while (i-- > 0)
628 device_remove_file(kit->dev, &dev_input_attrs[i]);
629
630 i = ifkit->outputs;
631out2:
632 while (i-- > 0)
633 device_remove_file(kit->dev, &dev_output_attrs[i]);
69165c29
SY		 634out:
635 if (kit) {
636 if (kit->irq)
637 usb_free_urb(kit->irq);
638 if (kit->data)
639 usb_buffer_free(dev, URB_INT_SIZE, kit->data, kit->data_dma);
912b24c3
SY		 640 if (kit->dev)
641 device_unregister(kit->dev);
642 if (kit->dev_no >= 0)
643 clear_bit(kit->dev_no, &device_no);
644
69165c29
SY		 645 kfree(kit);
646 }
647
648 return rc;
1da177e4
LT		 649}
650
651static void interfacekit_disconnect(struct usb_interface *interface)
652{
69165c29 653 struct interfacekit *kit;
da308e8d 654 int i;
1da177e4
LT		 655
656 kit = usb_get_intfdata(interface);
657 usb_set_intfdata(interface, NULL);
658 if (!kit)
659 return;
660
69165c29
SY		 661 usb_kill_urb(kit->irq);
662 usb_free_urb(kit->irq);
663 usb_buffer_free(kit->udev, URB_INT_SIZE, kit->data, kit->data_dma);
664
665 cancel_delayed_work(&kit->do_notify);
666
da308e8d
SY		 667 for (i=0; i<kit->ifkit->outputs; i++)
668 device_remove_file(kit->dev, &dev_output_attrs[i]);
1da177e4 669
da308e8d
SY		 670 for (i=0; i<kit->ifkit->inputs; i++)
671 device_remove_file(kit->dev, &dev_input_attrs[i]);
1da177e4 672
da308e8d
SY		 673 for (i=0; i<kit->ifkit->sensors; i++)
674 device_remove_file(kit->dev, &dev_sensor_attrs[i]);
69165c29 675
da308e8d 676 if (kit->ifkit->has_lcd) {
912b24c3 677 device_remove_file(kit->dev, &dev_attr_lcd);
da308e8d
SY		 678 remove_lcd_files(kit);
679 }
912b24c3
SY		 680
681 device_unregister(kit->dev);
1da177e4
LT		 682
683 dev_info(&interface->dev, "USB PhidgetInterfaceKit %d/%d/%d detached\n",
684 kit->ifkit->sensors, kit->ifkit->inputs, kit->ifkit->outputs);
685
1da177e4 686 usb_put_dev(kit->udev);
912b24c3
SY		 687 clear_bit(kit->dev_no, &device_no);
688
1da177e4
LT		 689 kfree(kit);
690}
691
692static struct usb_driver interfacekit_driver = {
1da177e4
LT		 693 .name = "phidgetkit",
694 .probe = interfacekit_probe,
695 .disconnect = interfacekit_disconnect,
696 .id_table = id_table
697};
698
699static int __init interfacekit_init(void)
700{
701 int retval = 0;
702
703 retval = usb_register(&interfacekit_driver);
704 if (retval)
705 err("usb_register failed. Error number %d", retval);
706
707 return retval;
708}
709
710static void __exit interfacekit_exit(void)
711{
712 usb_deregister(&interfacekit_driver);
713}
714
715module_init(interfacekit_init);
716module_exit(interfacekit_exit);
717
718MODULE_AUTHOR(DRIVER_AUTHOR);
719MODULE_DESCRIPTION(DRIVER_DESC);
720MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.214474 seconds and 5 git commands to generate.