git.oblomov.eu Git - linux-2.6/blob - drivers/staging/asus_oled/asus_oled.c

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