1/* 2 * Asus OLED USB driver 3 * 4 * Copyright (C) 2007,2008 Jakub Schmidtke (sjakub@gmail.com) 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * 22 * 23 * This module is based on usbled and asus-laptop modules. 24 * 25 * 26 * Asus OLED support is based on asusoled program taken from 27 * <http://lapsus.berlios.de/asus_oled.html>. 28 * 29 * 30 */ 31 32#include <linux/kernel.h> 33#include <linux/errno.h> 34#include <linux/init.h> 35#include <linux/slab.h> 36#include <linux/module.h> 37#include <linux/usb.h> 38#include <linux/platform_device.h> 39#include <linux/ctype.h> 40 41#define ASUS_OLED_VERSION "0.04-dev" 42#define ASUS_OLED_NAME "asus-oled" 43#define ASUS_OLED_UNDERSCORE_NAME "asus_oled" 44 45#define ASUS_OLED_ERROR "Asus OLED Display Error: " 46 47#define ASUS_OLED_STATIC 's' 48#define ASUS_OLED_ROLL 'r' 49#define ASUS_OLED_FLASH 'f' 50 51#define ASUS_OLED_MAX_WIDTH 1792 52#define ASUS_OLED_DISP_HEIGHT 32 53#define ASUS_OLED_PACKET_BUF_SIZE 256 54 55#define USB_VENDOR_ID_ASUS 0x0b05 56#define USB_DEVICE_ID_ASUS_LCM 0x1726 57#define USB_DEVICE_ID_ASUS_LCM2 0x175b 58 59MODULE_AUTHOR("Jakub Schmidtke, sjakub@gmail.com"); 60MODULE_DESCRIPTION("Asus OLED Driver v" ASUS_OLED_VERSION); 61MODULE_LICENSE("GPL"); 62 63static struct class *oled_class; 64static int oled_num; 65 66static uint start_off; 67 68module_param(start_off, uint, 0644); 69 70MODULE_PARM_DESC(start_off, 71 "Set to 1 to switch off OLED display after it is attached"); 72 73enum oled_pack_mode { 74 PACK_MODE_G1, 75 PACK_MODE_G50, 76 PACK_MODE_LAST 77}; 78 79struct oled_dev_desc_str { 80 uint16_t idVendor; 81 uint16_t idProduct; 82 /* width of display */ 83 uint16_t devWidth; 84 /* formula to be used while packing the picture */ 85 enum oled_pack_mode packMode; 86 const char *devDesc; 87}; 88 89/* table of devices that work with this driver */ 90static const struct usb_device_id id_table[] = { 91 /* Asus G1/G2 (and variants)*/ 92 { USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM) }, 93 /* Asus G50V (and possibly others - G70? G71?)*/ 94 { USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM2) }, 95 { }, 96}; 97 98/* parameters of specific devices */ 99static struct oled_dev_desc_str oled_dev_desc_table[] = { 100 { USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM, 128, PACK_MODE_G1, 101 "G1/G2" }, 102 { USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM2, 256, PACK_MODE_G50, 103 "G50" }, 104 { }, 105}; 106 107MODULE_DEVICE_TABLE(usb, id_table); 108 109struct asus_oled_header { 110 uint8_t magic1; 111 uint8_t magic2; 112 uint8_t flags; 113 uint8_t value3; 114 uint8_t buffer1; 115 uint8_t buffer2; 116 uint8_t value6; 117 uint8_t value7; 118 uint8_t value8; 119 uint8_t padding2[7]; 120} __attribute((packed)); 121 122struct asus_oled_packet { 123 struct asus_oled_header header; 124 uint8_t bitmap[ASUS_OLED_PACKET_BUF_SIZE]; 125} __attribute((packed)); 126 127struct asus_oled_dev { 128 struct usb_device *udev; 129 uint8_t pic_mode; 130 uint16_t dev_width; 131 enum oled_pack_mode pack_mode; 132 size_t height; 133 size_t width; 134 size_t x_shift; 135 size_t y_shift; 136 size_t buf_offs; 137 uint8_t last_val; 138 size_t buf_size; 139 char *buf; 140 uint8_t enabled; 141 struct device *dev; 142}; 143 144static void setup_packet_header(struct asus_oled_packet *packet, char flags, 145 char value3, char buffer1, char buffer2, char value6, 146 char value7, char value8) 147{ 148 memset(packet, 0, sizeof(struct asus_oled_header)); 149 packet->header.magic1 = 0x55; 150 packet->header.magic2 = 0xaa; 151 packet->header.flags = flags; 152 packet->header.value3 = value3; 153 packet->header.buffer1 = buffer1; 154 packet->header.buffer2 = buffer2; 155 packet->header.value6 = value6; 156 packet->header.value7 = value7; 157 packet->header.value8 = value8; 158} 159 160static void enable_oled(struct asus_oled_dev *odev, uint8_t enabl) 161{ 162 int retval; 163 int act_len; 164 struct asus_oled_packet *packet; 165 166 packet = kzalloc(sizeof(struct asus_oled_packet), GFP_KERNEL); 167 168 if (!packet) { 169 dev_err(&odev->udev->dev, "out of memory\n"); 170 return; 171 } 172 173 setup_packet_header(packet, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00); 174 175 if (enabl) 176 packet->bitmap[0] = 0xaf; 177 else 178 packet->bitmap[0] = 0xae; 179 180 retval = usb_bulk_msg(odev->udev, 181 usb_sndbulkpipe(odev->udev, 2), 182 packet, 183 sizeof(struct asus_oled_header) + 1, 184 &act_len, 185 -1); 186 187 if (retval) 188 dev_dbg(&odev->udev->dev, "retval = %d\n", retval); 189 190 odev->enabled = enabl; 191 192 kfree(packet); 193} 194 195static ssize_t set_enabled(struct device *dev, struct device_attribute *attr, 196 const char *buf, size_t count) 197{ 198 struct usb_interface *intf = to_usb_interface(dev); 199 struct asus_oled_dev *odev = usb_get_intfdata(intf); 200 unsigned long value; 201 if (kstrtoul(buf, 10, &value)) 202 return -EINVAL; 203 204 enable_oled(odev, value); 205 206 return count; 207} 208 209static ssize_t class_set_enabled(struct device *device, 210 struct device_attribute *attr, 211 const char *buf, size_t count) 212{ 213 struct asus_oled_dev *odev = 214 (struct asus_oled_dev *) dev_get_drvdata(device); 215 unsigned long value; 216 217 if (kstrtoul(buf, 10, &value)) 218 return -EINVAL; 219 220 enable_oled(odev, value); 221 222 return count; 223} 224 225static ssize_t get_enabled(struct device *dev, struct device_attribute *attr, 226 char *buf) 227{ 228 struct usb_interface *intf = to_usb_interface(dev); 229 struct asus_oled_dev *odev = usb_get_intfdata(intf); 230 231 return sprintf(buf, "%d\n", odev->enabled); 232} 233 234static ssize_t class_get_enabled(struct device *device, 235 struct device_attribute *attr, char *buf) 236{ 237 struct asus_oled_dev *odev = 238 (struct asus_oled_dev *) dev_get_drvdata(device); 239 240 return sprintf(buf, "%d\n", odev->enabled); 241} 242 243static void send_packets(struct usb_device *udev, 244 struct asus_oled_packet *packet, 245 char *buf, uint8_t p_type, size_t p_num) 246{ 247 size_t i; 248 int act_len; 249 250 for (i = 0; i < p_num; i++) { 251 int retval; 252 253 switch (p_type) { 254 case ASUS_OLED_ROLL: 255 setup_packet_header(packet, 0x40, 0x80, p_num, 256 i + 1, 0x00, 0x01, 0xff); 257 break; 258 case ASUS_OLED_STATIC: 259 setup_packet_header(packet, 0x10 + i, 0x80, 0x01, 260 0x01, 0x00, 0x01, 0x00); 261 break; 262 case ASUS_OLED_FLASH: 263 setup_packet_header(packet, 0x10 + i, 0x80, 0x01, 264 0x01, 0x00, 0x00, 0xff); 265 break; 266 } 267 268 memcpy(packet->bitmap, buf + (ASUS_OLED_PACKET_BUF_SIZE*i), 269 ASUS_OLED_PACKET_BUF_SIZE); 270 271 retval = usb_bulk_msg(udev, usb_sndctrlpipe(udev, 2), 272 packet, sizeof(struct asus_oled_packet), 273 &act_len, -1); 274 275 if (retval) 276 dev_dbg(&udev->dev, "retval = %d\n", retval); 277 } 278} 279 280static void send_packet(struct usb_device *udev, 281 struct asus_oled_packet *packet, 282 size_t offset, size_t len, char *buf, uint8_t b1, 283 uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5, 284 uint8_t b6) { 285 int retval; 286 int act_len; 287 288 setup_packet_header(packet, b1, b2, b3, b4, b5, b6, 0x00); 289 memcpy(packet->bitmap, buf + offset, len); 290 291 retval = usb_bulk_msg(udev, 292 usb_sndctrlpipe(udev, 2), 293 packet, 294 sizeof(struct asus_oled_packet), 295 &act_len, 296 -1); 297 298 if (retval) 299 dev_dbg(&udev->dev, "retval = %d\n", retval); 300} 301 302 303static void send_packets_g50(struct usb_device *udev, 304 struct asus_oled_packet *packet, char *buf) 305{ 306 send_packet(udev, packet, 0, 0x100, buf, 307 0x10, 0x00, 0x02, 0x01, 0x00, 0x01); 308 send_packet(udev, packet, 0x100, 0x080, buf, 309 0x10, 0x00, 0x02, 0x02, 0x80, 0x00); 310 311 send_packet(udev, packet, 0x180, 0x100, buf, 312 0x11, 0x00, 0x03, 0x01, 0x00, 0x01); 313 send_packet(udev, packet, 0x280, 0x100, buf, 314 0x11, 0x00, 0x03, 0x02, 0x00, 0x01); 315 send_packet(udev, packet, 0x380, 0x080, buf, 316 0x11, 0x00, 0x03, 0x03, 0x80, 0x00); 317} 318 319 320static void send_data(struct asus_oled_dev *odev) 321{ 322 size_t packet_num = odev->buf_size / ASUS_OLED_PACKET_BUF_SIZE; 323 struct asus_oled_packet *packet; 324 325 packet = kzalloc(sizeof(struct asus_oled_packet), GFP_KERNEL); 326 327 if (!packet) { 328 dev_err(&odev->udev->dev, "out of memory\n"); 329 return; 330 } 331 332 if (odev->pack_mode == PACK_MODE_G1) { 333 /* When sending roll-mode data the display updated only 334 first packet. I have no idea why, but when static picture 335 is sent just before rolling picture everything works fine. */ 336 if (odev->pic_mode == ASUS_OLED_ROLL) 337 send_packets(odev->udev, packet, odev->buf, 338 ASUS_OLED_STATIC, 2); 339 340 /* Only ROLL mode can use more than 2 packets.*/ 341 if (odev->pic_mode != ASUS_OLED_ROLL && packet_num > 2) 342 packet_num = 2; 343 344 send_packets(odev->udev, packet, odev->buf, 345 odev->pic_mode, packet_num); 346 } else if (odev->pack_mode == PACK_MODE_G50) { 347 send_packets_g50(odev->udev, packet, odev->buf); 348 } 349 350 kfree(packet); 351} 352 353static int append_values(struct asus_oled_dev *odev, uint8_t val, size_t count) 354{ 355 odev->last_val = val; 356 357 if (val == 0) { 358 odev->buf_offs += count; 359 return 0; 360 } 361 362 while (count-- > 0) { 363 size_t x = odev->buf_offs % odev->width; 364 size_t y = odev->buf_offs / odev->width; 365 size_t i; 366 367 x += odev->x_shift; 368 y += odev->y_shift; 369 370 switch (odev->pack_mode) { 371 case PACK_MODE_G1: 372 /* i = (x/128)*640 + 127 - x + (y/8)*128; 373 This one for 128 is the same, but might be better 374 for different widths? */ 375 i = (x/odev->dev_width)*640 + 376 odev->dev_width - 1 - x + 377 (y/8)*odev->dev_width; 378 break; 379 380 case PACK_MODE_G50: 381 i = (odev->dev_width - 1 - x)/8 + y*odev->dev_width/8; 382 break; 383 384 default: 385 i = 0; 386 printk(ASUS_OLED_ERROR "Unknown OLED Pack Mode: %d!\n", 387 odev->pack_mode); 388 break; 389 } 390 391 if (i >= odev->buf_size) { 392 printk(ASUS_OLED_ERROR "Buffer overflow! Report a bug:" 393 "offs: %d >= %d i: %d (x: %d y: %d)\n", 394 (int) odev->buf_offs, (int) odev->buf_size, 395 (int) i, (int) x, (int) y); 396 return -EIO; 397 } 398 399 switch (odev->pack_mode) { 400 case PACK_MODE_G1: 401 odev->buf[i] &= ~(1<<(y%8)); 402 break; 403 404 case PACK_MODE_G50: 405 odev->buf[i] &= ~(1<<(x%8)); 406 break; 407 408 default: 409 /* cannot get here; stops gcc complaining*/ 410 ; 411 } 412 413 odev->buf_offs++; 414 } 415 416 return 0; 417} 418 419static ssize_t odev_set_picture(struct asus_oled_dev *odev, 420 const char *buf, size_t count) 421{ 422 size_t offs = 0, max_offs; 423 424 if (count < 1) 425 return 0; 426 427 if (tolower(buf[0]) == 'b') { 428 /* binary mode, set the entire memory*/ 429 430 size_t i; 431 432 odev->buf_size = (odev->dev_width * ASUS_OLED_DISP_HEIGHT) / 8; 433 434 kfree(odev->buf); 435 odev->buf = kmalloc(odev->buf_size, GFP_KERNEL); 436 if (odev->buf == NULL) { 437 odev->buf_size = 0; 438 printk(ASUS_OLED_ERROR "Out of memory!\n"); 439 return -ENOMEM; 440 } 441 442 memset(odev->buf, 0xff, odev->buf_size); 443 444 for (i = 1; i < count && i <= 32 * 32; i++) { 445 odev->buf[i-1] = buf[i]; 446 odev->buf_offs = i-1; 447 } 448 449 odev->width = odev->dev_width / 8; 450 odev->height = ASUS_OLED_DISP_HEIGHT; 451 odev->x_shift = 0; 452 odev->y_shift = 0; 453 odev->last_val = 0; 454 455 send_data(odev); 456 457 return count; 458 } 459 460 if (buf[0] == '<') { 461 size_t i; 462 size_t w = 0, h = 0; 463 size_t w_mem, h_mem; 464 465 if (count < 10 || buf[2] != ':') 466 goto error_header; 467 468 469 switch (tolower(buf[1])) { 470 case ASUS_OLED_STATIC: 471 case ASUS_OLED_ROLL: 472 case ASUS_OLED_FLASH: 473 odev->pic_mode = buf[1]; 474 break; 475 default: 476 printk(ASUS_OLED_ERROR "Wrong picture mode: '%c'.\n", 477 buf[1]); 478 return -EIO; 479 break; 480 } 481 482 for (i = 3; i < count; ++i) { 483 if (buf[i] >= '0' && buf[i] <= '9') { 484 w = 10*w + (buf[i] - '0'); 485 486 if (w > ASUS_OLED_MAX_WIDTH) 487 goto error_width; 488 } else if (tolower(buf[i]) == 'x') { 489 break; 490 } else { 491 goto error_width; 492 } 493 } 494 495 for (++i; i < count; ++i) { 496 if (buf[i] >= '0' && buf[i] <= '9') { 497 h = 10*h + (buf[i] - '0'); 498 499 if (h > ASUS_OLED_DISP_HEIGHT) 500 goto error_height; 501 } else if (tolower(buf[i]) == '>') { 502 break; 503 } else { 504 goto error_height; 505 } 506 } 507 508 if (w < 1 || w > ASUS_OLED_MAX_WIDTH) 509 goto error_width; 510 511 if (h < 1 || h > ASUS_OLED_DISP_HEIGHT) 512 goto error_height; 513 514 if (i >= count || buf[i] != '>') 515 goto error_header; 516 517 offs = i+1; 518 519 if (w % (odev->dev_width) != 0) 520 w_mem = (w/(odev->dev_width) + 1)*(odev->dev_width); 521 else 522 w_mem = w; 523 524 if (h < ASUS_OLED_DISP_HEIGHT) 525 h_mem = ASUS_OLED_DISP_HEIGHT; 526 else 527 h_mem = h; 528 529 odev->buf_size = w_mem * h_mem / 8; 530 531 kfree(odev->buf); 532 odev->buf = kmalloc(odev->buf_size, GFP_KERNEL); 533 534 if (odev->buf == NULL) { 535 odev->buf_size = 0; 536 printk(ASUS_OLED_ERROR "Out of memory!\n"); 537 return -ENOMEM; 538 } 539 540 memset(odev->buf, 0xff, odev->buf_size); 541 542 odev->buf_offs = 0; 543 odev->width = w; 544 odev->height = h; 545 odev->x_shift = 0; 546 odev->y_shift = 0; 547 odev->last_val = 0; 548 549 if (odev->pic_mode == ASUS_OLED_FLASH) { 550 if (h < ASUS_OLED_DISP_HEIGHT/2) 551 odev->y_shift = (ASUS_OLED_DISP_HEIGHT/2 - h)/2; 552 } else { 553 if (h < ASUS_OLED_DISP_HEIGHT) 554 odev->y_shift = (ASUS_OLED_DISP_HEIGHT - h)/2; 555 } 556 557 if (w < (odev->dev_width)) 558 odev->x_shift = ((odev->dev_width) - w)/2; 559 } 560 561 max_offs = odev->width * odev->height; 562 563 while (offs < count && odev->buf_offs < max_offs) { 564 int ret = 0; 565 566 if (buf[offs] == '1' || buf[offs] == '#') { 567 ret = append_values(odev, 1, 1); 568 if (ret < 0) 569 return ret; 570 } else if (buf[offs] == '0' || buf[offs] == ' ') { 571 ret = append_values(odev, 0, 1); 572 if (ret < 0) 573 return ret; 574 } else if (buf[offs] == '\n') { 575 /* New line detected. Lets assume, that all characters 576 till the end of the line were equal to the last 577 character in this line.*/ 578 if (odev->buf_offs % odev->width != 0) 579 ret = append_values(odev, odev->last_val, 580 odev->width - 581 (odev->buf_offs % 582 odev->width)); 583 if (ret < 0) 584 return ret; 585 } 586 587 offs++; 588 } 589 590 if (odev->buf_offs >= max_offs) 591 send_data(odev); 592 593 return count; 594 595error_width: 596 printk(ASUS_OLED_ERROR "Wrong picture width specified.\n"); 597 return -EIO; 598 599error_height: 600 printk(ASUS_OLED_ERROR "Wrong picture height specified.\n"); 601 return -EIO; 602 603error_header: 604 printk(ASUS_OLED_ERROR "Wrong picture header.\n"); 605 return -EIO; 606} 607 608static ssize_t set_picture(struct device *dev, struct device_attribute *attr, 609 const char *buf, size_t count) 610{ 611 struct usb_interface *intf = to_usb_interface(dev); 612 613 return odev_set_picture(usb_get_intfdata(intf), buf, count); 614} 615 616static ssize_t class_set_picture(struct device *device, 617 struct device_attribute *attr, 618 const char *buf, size_t count) 619{ 620 return odev_set_picture((struct asus_oled_dev *) 621 dev_get_drvdata(device), buf, count); 622} 623 624#define ASUS_OLED_DEVICE_ATTR(_file) dev_attr_asus_oled_##_file 625 626static DEVICE_ATTR(asus_oled_enabled, S_IWUSR | S_IRUGO, 627 get_enabled, set_enabled); 628static DEVICE_ATTR(asus_oled_picture, S_IWUSR , NULL, set_picture); 629 630static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, 631 class_get_enabled, class_set_enabled); 632static DEVICE_ATTR(picture, S_IWUSR, NULL, class_set_picture); 633 634static int asus_oled_probe(struct usb_interface *interface, 635 const struct usb_device_id *id) 636{ 637 struct usb_device *udev = interface_to_usbdev(interface); 638 struct asus_oled_dev *odev = NULL; 639 int retval = -ENOMEM; 640 uint16_t dev_width = 0; 641 enum oled_pack_mode pack_mode = PACK_MODE_LAST; 642 const struct oled_dev_desc_str *dev_desc = oled_dev_desc_table; 643 const char *desc = NULL; 644 645 if (!id) { 646 /* Even possible? Just to make sure...*/ 647 dev_err(&interface->dev, "No usb_device_id provided!\n"); 648 return -ENODEV; 649 } 650 651 for (; dev_desc->idVendor; dev_desc++) { 652 if (dev_desc->idVendor == id->idVendor 653 && dev_desc->idProduct == id->idProduct) { 654 dev_width = dev_desc->devWidth; 655 desc = dev_desc->devDesc; 656 pack_mode = dev_desc->packMode; 657 break; 658 } 659 } 660 661 if (!desc || dev_width < 1 || pack_mode == PACK_MODE_LAST) { 662 dev_err(&interface->dev, 663 "Missing or incomplete device description!\n"); 664 return -ENODEV; 665 } 666 667 odev = kzalloc(sizeof(struct asus_oled_dev), GFP_KERNEL); 668 669 if (odev == NULL) { 670 dev_err(&interface->dev, "Out of memory\n"); 671 return -ENOMEM; 672 } 673 674 odev->udev = usb_get_dev(udev); 675 odev->pic_mode = ASUS_OLED_STATIC; 676 odev->dev_width = dev_width; 677 odev->pack_mode = pack_mode; 678 odev->height = 0; 679 odev->width = 0; 680 odev->x_shift = 0; 681 odev->y_shift = 0; 682 odev->buf_offs = 0; 683 odev->buf_size = 0; 684 odev->last_val = 0; 685 odev->buf = NULL; 686 odev->enabled = 1; 687 odev->dev = NULL; 688 689 usb_set_intfdata(interface, odev); 690 691 retval = device_create_file(&interface->dev, 692 &ASUS_OLED_DEVICE_ATTR(enabled)); 693 if (retval) 694 goto err_files; 695 696 retval = device_create_file(&interface->dev, 697 &ASUS_OLED_DEVICE_ATTR(picture)); 698 if (retval) 699 goto err_files; 700 701 odev->dev = device_create(oled_class, &interface->dev, MKDEV(0, 0), 702 NULL, "oled_%d", ++oled_num); 703 704 if (IS_ERR(odev->dev)) { 705 retval = PTR_ERR(odev->dev); 706 goto err_files; 707 } 708 709 dev_set_drvdata(odev->dev, odev); 710 711 retval = device_create_file(odev->dev, &dev_attr_enabled); 712 if (retval) 713 goto err_class_enabled; 714 715 retval = device_create_file(odev->dev, &dev_attr_picture); 716 if (retval) 717 goto err_class_picture; 718 719 dev_info(&interface->dev, 720 "Attached Asus OLED device: %s [width %u, pack_mode %d]\n", 721 desc, odev->dev_width, odev->pack_mode); 722 723 if (start_off) 724 enable_oled(odev, 0); 725 726 return 0; 727 728err_class_picture: 729 device_remove_file(odev->dev, &dev_attr_picture); 730 731err_class_enabled: 732 device_remove_file(odev->dev, &dev_attr_enabled); 733 device_unregister(odev->dev); 734 735err_files: 736 device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(enabled)); 737 device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(picture)); 738 739 usb_set_intfdata(interface, NULL); 740 usb_put_dev(odev->udev); 741 kfree(odev); 742 743 return retval; 744} 745 746static void asus_oled_disconnect(struct usb_interface *interface) 747{ 748 struct asus_oled_dev *odev; 749 750 odev = usb_get_intfdata(interface); 751 usb_set_intfdata(interface, NULL); 752 753 device_remove_file(odev->dev, &dev_attr_picture); 754 device_remove_file(odev->dev, &dev_attr_enabled); 755 device_unregister(odev->dev); 756 757 device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(picture)); 758 device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(enabled)); 759 760 usb_put_dev(odev->udev); 761 762 kfree(odev->buf); 763 764 kfree(odev); 765 766 dev_info(&interface->dev, "Disconnected Asus OLED device\n"); 767} 768 769static struct usb_driver oled_driver = { 770 .name = ASUS_OLED_NAME, 771 .probe = asus_oled_probe, 772 .disconnect = asus_oled_disconnect, 773 .id_table = id_table, 774}; 775 776static CLASS_ATTR_STRING(version, S_IRUGO, 777 ASUS_OLED_UNDERSCORE_NAME " " ASUS_OLED_VERSION); 778 779static int __init asus_oled_init(void) 780{ 781 int retval = 0; 782 oled_class = class_create(THIS_MODULE, ASUS_OLED_UNDERSCORE_NAME); 783 784 if (IS_ERR(oled_class)) { 785 err("Error creating " ASUS_OLED_UNDERSCORE_NAME " class"); 786 return PTR_ERR(oled_class); 787 } 788 789 retval = class_create_file(oled_class, &class_attr_version.attr); 790 if (retval) { 791 err("Error creating class version file"); 792 goto error; 793 } 794 795 retval = usb_register(&oled_driver); 796 797 if (retval) { 798 err("usb_register failed. Error number %d", retval); 799 goto error; 800 } 801 802 return retval; 803 804error: 805 class_destroy(oled_class); 806 return retval; 807} 808 809static void __exit asus_oled_exit(void) 810{ 811 usb_deregister(&oled_driver); 812 class_remove_file(oled_class, &class_attr_version.attr); 813 class_destroy(oled_class); 814} 815 816module_init(asus_oled_init); 817module_exit(asus_oled_exit); 818 819