git.oblomov.eu Git - linux-2.6/blob - drivers/usb/misc/phidgetkit.c

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