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 42struct 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 59static const struct driver_interfacekit ph_004 = ifkit(0, 0, 4, 0, 0); 60static const struct driver_interfacekit ph_888n = ifkit(8, 8, 8, 0, 1); 61static const struct driver_interfacekit ph_888o = ifkit(8, 8, 8, 0, 0); 62static const struct driver_interfacekit ph_047 = ifkit(0, 4, 7, 1, 0); 63static const struct driver_interfacekit ph_884 = ifkit(8, 8, 4, 0, 0); 64static const struct driver_interfacekit ph_088 = ifkit(0, 8, 8, 1, 0); 65static const struct driver_interfacekit ph_01616 = ifkit(0, 16, 16, 0, 0); 66 67static unsigned long device_no; 68 69struct 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 90static 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}; 107MODULE_DEVICE_TABLE(usb, id_table); 108 109static 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 139static 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; 187exit: 188 kfree(buffer); 189 kfree(form_buffer); 190 191 return retval; 192} 193 194#define set_lcd_line(number) \ 195static 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 207set_lcd_line(1); 208set_lcd_line(2); 209 210static 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; 240exit: 241 kfree(buffer); 242 return retval; 243} 244 245static 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 251static 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 263static 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; 294out: 295 while (i-- > 0) 296 device_remove_file(kit->dev, &dev_lcd_line_attrs[i]); 297 298 return rc; 299} 300 301static DEVICE_ATTR(lcd, S_IWUGO, NULL, enable_lcd_files); 302 303static 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 379resubmit: 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 387static 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 409static 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) \ 417static 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 \ 438static 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 451show_set_output(1); 452show_set_output(2); 453show_set_output(3); 454show_set_output(4); 455show_set_output(5); 456show_set_output(6); 457show_set_output(7); 458show_set_output(8); 459show_set_output(9); 460show_set_output(10); 461show_set_output(11); 462show_set_output(12); 463show_set_output(13); 464show_set_output(14); 465show_set_output(15); 466show_set_output(16); 467 468static 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) \ 476static 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 487show_input(1); 488show_input(2); 489show_input(3); 490show_input(4); 491show_input(5); 492show_input(6); 493show_input(7); 494show_input(8); 495show_input(9); 496show_input(10); 497show_input(11); 498show_input(12); 499show_input(13); 500show_input(14); 501show_input(15); 502show_input(16); 503 504static 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) \ 512static 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 524show_sensor(1); 525show_sensor(2); 526show_sensor(3); 527show_sensor(4); 528show_sensor(5); 529show_sensor(6); 530show_sensor(7); 531show_sensor(8); 532 533static 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 538static 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 641out4: 642 while (i-- > 0) 643 device_remove_file(kit->dev, &dev_sensor_attrs[i]); 644 645 i = ifkit->inputs; 646out3: 647 while (i-- > 0) 648 device_remove_file(kit->dev, &dev_input_attrs[i]); 649 650 i = ifkit->outputs; 651out2: 652 while (i-- > 0) 653 device_remove_file(kit->dev, &dev_output_attrs[i]); 654out: 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 670static 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 712static struct usb_driver interfacekit_driver = { 713 .name = "phidgetkit", 714 .probe = interfacekit_probe, 715 .disconnect = interfacekit_disconnect, 716 .id_table = id_table 717}; 718 719static 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 730static void __exit interfacekit_exit(void) 731{ 732 usb_deregister(&interfacekit_driver); 733} 734 735module_init(interfacekit_init); 736module_exit(interfacekit_exit); 737 738MODULE_AUTHOR(DRIVER_AUTHOR); 739MODULE_DESCRIPTION(DRIVER_DESC); 740MODULE_LICENSE("GPL"); 741