drivers/hid/hid-picolcd.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Bruno Prémont <bonbons@linux-vserver.org>       *
   3  *                                                                         *
   4  *   Based on Logitech G13 driver (v0.4)                                   *
   5  *     Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu>   *
   6  *                                                                         *
   7  *   This program is free software: you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation, version 2 of the License.               *
  10  *                                                                         *
  11  *   This driver is distributed in the hope that it will be useful, but    *
  12  *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
  14  *   General Public License for more details.                              *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
  18  ***************************************************************************/
  19
  20 #include <linux/hid.h>
  21 #include <linux/hid-debug.h>
  22 #include <linux/input.h>
  23 #include "hid-ids.h"
  24 #include "usbhid/usbhid.h"
  25 #include <linux/usb.h>
  26
  27 #include <linux/fb.h>
  28 #include <linux/vmalloc.h>
  29 #include <linux/backlight.h>
  30
  31 #include <linux/seq_file.h>
  32 #include <linux/debugfs.h>
  33
  34 #include <linux/completion.h>
  35
  36 #define PICOLCD_NAME "PicoLCD (graphic)"
  37
  38 /* Report numbers */
  39 #define REPORT_ERROR_CODE      0x10 /* LCD: IN[16]  */
  40 #define   ERR_SUCCESS            0x00
  41 #define   ERR_PARAMETER_MISSING  0x01
  42 #define   ERR_DATA_MISSING       0x02
  43 #define   ERR_BLOCK_READ_ONLY    0x03
  44 #define   ERR_BLOCK_NOT_ERASABLE 0x04
  45 #define   ERR_BLOCK_TOO_BIG      0x05
  46 #define   ERR_SECTION_OVERFLOW   0x06
  47 #define   ERR_INVALID_CMD_LEN    0x07
  48 #define   ERR_INVALID_DATA_LEN   0x08
  49 #define REPORT_KEY_STATE       0x11 /* LCD: IN[2]   */
  50 #define REPORT_IR_DATA         0x21 /* LCD: IN[63]  */
  51 #define REPORT_EE_DATA         0x32 /* LCD: IN[63]  */
  52 #define REPORT_MEMORY          0x41 /* LCD: IN[63]  */
  53 #define REPORT_LED_STATE       0x81 /* LCD: OUT[1]  */
  54 #define REPORT_BRIGHTNESS      0x91 /* LCD: OUT[1]  */
  55 #define REPORT_CONTRAST        0x92 /* LCD: OUT[1]  */
  56 #define REPORT_RESET           0x93 /* LCD: OUT[2]  */
  57 #define REPORT_LCD_CMD         0x94 /* LCD: OUT[63] */
  58 #define REPORT_LCD_DATA        0x95 /* LCD: OUT[63] */
  59 #define REPORT_LCD_CMD_DATA    0x96 /* LCD: OUT[63] */
  60 #define REPORT_EE_READ         0xa3 /* LCD: OUT[63] */
  61 #define REPORT_EE_WRITE        0xa4 /* LCD: OUT[63] */
  62 #define REPORT_ERASE_MEMORY    0xb2 /* LCD: OUT[2]  */
  63 #define REPORT_READ_MEMORY     0xb3 /* LCD: OUT[3]  */
  64 #define REPORT_WRITE_MEMORY    0xb4 /* LCD: OUT[63] */
  65 #define REPORT_SPLASH_RESTART  0xc1 /* LCD: OUT[1]  */
  66 #define REPORT_EXIT_KEYBOARD   0xef /* LCD: OUT[2]  */
  67 #define REPORT_VERSION         0xf1 /* LCD: IN[2],OUT[1]    Bootloader: IN[2],OUT[1]   */
  68 #define REPORT_BL_ERASE_MEMORY 0xf2 /*                      Bootloader: IN[36],OUT[4]  */
  69 #define REPORT_BL_READ_MEMORY  0xf3 /*                      Bootloader: IN[36],OUT[4]  */
  70 #define REPORT_BL_WRITE_MEMORY 0xf4 /*                      Bootloader: IN[36],OUT[36] */
  71 #define REPORT_DEVID           0xf5 /* LCD: IN[5], OUT[1]   Bootloader: IN[5],OUT[1]   */
  72 #define REPORT_SPLASH_SIZE     0xf6 /* LCD: IN[4], OUT[1]   */
  73 #define REPORT_HOOK_VERSION    0xf7 /* LCD: IN[2], OUT[1]   */
  74 #define REPORT_EXIT_FLASHER    0xff /*                      Bootloader: OUT[2]         */
  75
  76 #if defined(CONFIG_FB) || defined(CONFIG_FB_MODULE)
  77 /* Framebuffer
  78  *
  79  * The PicoLCD use a Topway LCD module of 256x64 pixel
  80  * This display area is tiled over 4 controllers with 8 tiles
  81  * each. Each tile has 8x64 pixel, each data byte representing
  82  * a 1-bit wide vertical line of the tile.
  83  *
  84  * The display can be updated at a tile granularity.
  85  *
  86  *       Chip 1           Chip 2           Chip 3           Chip 4
  87  * +----------------+----------------+----------------+----------------+
  88  * |     Tile 1     |     Tile 1     |     Tile 1     |     Tile 1     |
  89  * +----------------+----------------+----------------+----------------+
  90  * |     Tile 2     |     Tile 2     |     Tile 2     |     Tile 2     |
  91  * +----------------+----------------+----------------+----------------+
  92  *                                  ...
  93  * +----------------+----------------+----------------+----------------+
  94  * |     Tile 8     |     Tile 8     |     Tile 8     |     Tile 8     |
  95  * +----------------+----------------+----------------+----------------+
  96  */
  97 #define PICOLCDFB_NAME "picolcdfb"
  98 #define PICOLCDFB_WIDTH (256)
  99 #define PICOLCDFB_HEIGHT (64)
 100 #define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8)
 101
 102 #define PICOLCDFB_UPDATE_RATE_LIMIT   10
 103 #define PICOLCDFB_UPDATE_RATE_DEFAULT  2
 104
 105 /* Framebuffer visual structures */
 106 static const struct fb_fix_screeninfo picolcdfb_fix = {
 107         .id          = PICOLCDFB_NAME,
 108         .type        = FB_TYPE_PACKED_PIXELS,
 109         .visual      = FB_VISUAL_MONO01,
 110         .xpanstep    = 0,
 111         .ypanstep    = 0,
 112         .ywrapstep   = 0,
 113         .line_length = PICOLCDFB_WIDTH / 8,
 114         .accel       = FB_ACCEL_NONE,
 115 };
 116
 117 static const struct fb_var_screeninfo picolcdfb_var = {
 118         .xres           = PICOLCDFB_WIDTH,
 119         .yres           = PICOLCDFB_HEIGHT,
 120         .xres_virtual   = PICOLCDFB_WIDTH,
 121         .yres_virtual   = PICOLCDFB_HEIGHT,
 122         .width          = 103,
 123         .height         = 26,
 124         .bits_per_pixel = 1,
 125         .grayscale      = 1,
 126 };
 127 #endif /* CONFIG_FB */
 128
 129 /* Input device
 130  *
 131  * The PicoLCD has an IR receiver header, a built-in keypad with 5 keys
 132  * and header for 4x4 key matrix. The built-in keys are part of the matrix.
 133  */
 134 static const unsigned short def_keymap[] = {
 135         KEY_RESERVED,   /* none */
 136         KEY_BACK,       /* col 4 + row 1 */
 137         KEY_HOMEPAGE,   /* col 3 + row 1 */
 138         KEY_RESERVED,   /* col 2 + row 1 */
 139         KEY_RESERVED,   /* col 1 + row 1 */
 140         KEY_SCROLLUP,   /* col 4 + row 2 */
 141         KEY_OK,         /* col 3 + row 2 */
 142         KEY_SCROLLDOWN, /* col 2 + row 2 */
 143         KEY_RESERVED,   /* col 1 + row 2 */
 144         KEY_RESERVED,   /* col 4 + row 3 */
 145         KEY_RESERVED,   /* col 3 + row 3 */
 146         KEY_RESERVED,   /* col 2 + row 3 */
 147         KEY_RESERVED,   /* col 1 + row 3 */
 148         KEY_RESERVED,   /* col 4 + row 4 */
 149         KEY_RESERVED,   /* col 3 + row 4 */
 150         KEY_RESERVED,   /* col 2 + row 4 */
 151         KEY_RESERVED,   /* col 1 + row 4 */
 152 };
 153 #define PICOLCD_KEYS ARRAY_SIZE(def_keymap)
 154
 155 /* Description of in-progress IO operation, used for operations
 156  * that trigger response from device */
 157 struct picolcd_pending {
 158         struct hid_report *out_report;
 159         struct hid_report *in_report;
 160         struct completion ready;
 161         int raw_size;
 162         u8 raw_data[64];
 163 };
 164
 165 /* Per device data structure */
 166 struct picolcd_data {
 167         struct hid_device *hdev;
 168 #ifdef CONFIG_DEBUG_FS
 169         int addr_sz;
 170 #endif
 171         u8 version[2];
 172         /* input stuff */
 173         u8 pressed_keys[2];
 174         struct input_dev *input_keys;
 175         struct input_dev *input_cir;
 176         unsigned short keycode[PICOLCD_KEYS];
 177
 178 #if defined(CONFIG_FB) || defined(CONFIG_FB_MODULE)
 179         /* Framebuffer stuff */
 180         u8 fb_update_rate;
 181         u8 fb_bpp;
 182         u8 *fb_vbitmap;         /* local copy of what was sent to PicoLCD */
 183         u8 *fb_bitmap;          /* framebuffer */
 184         struct fb_info *fb_info;
 185         struct fb_deferred_io fb_defio;
 186 #endif /* CONFIG_FB */
 187 #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)
 188         struct backlight_device *backlight;
 189         u8 lcd_brightness;
 190         u8 lcd_power;
 191 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
 192
 193         /* Housekeeping stuff */
 194         spinlock_t lock;
 195         struct mutex mutex;
 196         struct picolcd_pending *pending;
 197         int status;
 198 #define PICOLCD_BOOTLOADER 1
 199 #define PICOLCD_FAILED 2
 200 #define PICOLCD_READY_FB 4
 201 };
 202
 203
 204 /* Find a given report */
 205 #define picolcd_in_report(id, dev) picolcd_report(id, dev, HID_INPUT_REPORT)
 206 #define picolcd_out_report(id, dev) picolcd_report(id, dev, HID_OUTPUT_REPORT)
 207
 208 static struct hid_report *picolcd_report(int id, struct hid_device *hdev, int dir)
 209 {
 210         struct list_head *feature_report_list = &hdev->report_enum[dir].report_list;
 211         struct hid_report *report = NULL;
 212
 213         list_for_each_entry(report, feature_report_list, list) {
 214                 if (report->id == id)
 215                         return report;
 216         }
 217         dev_warn(&hdev->dev, "No report with id 0x%x found\n", id);
 218         return NULL;
 219 }
 220
 221 #ifdef CONFIG_DEBUG_FS
 222 static void picolcd_debug_out_report(struct picolcd_data *data,
 223                 struct hid_device *hdev, struct hid_report *report);
 224 #define usbhid_submit_report(a, b, c) \
 225         do { \
 226                 picolcd_debug_out_report(hid_get_drvdata(a), a, b); \
 227                 usbhid_submit_report(a, b, c); \
 228         } while (0)
 229 #endif
 230
 231 /* Submit a report and wait for a reply from device - if device fades away
 232  * or does not respond in time, return NULL */
 233 static struct picolcd_pending *picolcd_send_and_wait(struct hid_device *hdev,
 234                 int report_id, const u8 *raw_data, int size)
 235 {
 236         struct picolcd_data *data = hid_get_drvdata(hdev);
 237         struct picolcd_pending *work;
 238         struct hid_report *report = picolcd_out_report(report_id, hdev);
 239         unsigned long flags;
 240         int i, j, k;
 241
 242         if (!report || !data)
 243                 return NULL;
 244         if (data->status & PICOLCD_FAILED)
 245                 return NULL;
 246         work = kzalloc(sizeof(*work), GFP_KERNEL);
 247         if (!work)
 248                 return NULL;
 249
 250         init_completion(&work->ready);
 251         work->out_report = report;
 252         work->in_report  = NULL;
 253         work->raw_size   = 0;
 254
 255         mutex_lock(&data->mutex);
 256         spin_lock_irqsave(&data->lock, flags);
 257         for (i = k = 0; i < report->maxfield; i++)
 258                 for (j = 0; j < report->field[i]->report_count; j++) {
 259                         hid_set_field(report->field[i], j, k < size ? raw_data[k] : 0);
 260                         k++;
 261                 }
 262         data->pending = work;
 263         usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
 264         spin_unlock_irqrestore(&data->lock, flags);
 265         wait_for_completion_interruptible_timeout(&work->ready, HZ*2);
 266         spin_lock_irqsave(&data->lock, flags);
 267         data->pending = NULL;
 268         spin_unlock_irqrestore(&data->lock, flags);
 269         mutex_unlock(&data->mutex);
 270         return work;
 271 }
 272
 273 #if defined(CONFIG_FB) || defined(CONFIG_FB_MODULE)
 274 /* Send a given tile to PicoLCD */
 275 static int picolcd_fb_send_tile(struct hid_device *hdev, int chip, int tile)
 276 {
 277         struct picolcd_data *data = hid_get_drvdata(hdev);
 278         struct hid_report *report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, hdev);
 279         struct hid_report *report2 = picolcd_out_report(REPORT_LCD_DATA, hdev);
 280         unsigned long flags;
 281         u8 *tdata;
 282         int i;
 283
 284         if (!report1 || report1->maxfield != 1 || !report2 || report2->maxfield != 1)
 285                 return -ENODEV;
 286
 287         spin_lock_irqsave(&data->lock, flags);
 288         hid_set_field(report1->field[0],  0, chip << 2);
 289         hid_set_field(report1->field[0],  1, 0x02);
 290         hid_set_field(report1->field[0],  2, 0x00);
 291         hid_set_field(report1->field[0],  3, 0x00);
 292         hid_set_field(report1->field[0],  4, 0xb8 | tile);
 293         hid_set_field(report1->field[0],  5, 0x00);
 294         hid_set_field(report1->field[0],  6, 0x00);
 295         hid_set_field(report1->field[0],  7, 0x40);
 296         hid_set_field(report1->field[0],  8, 0x00);
 297         hid_set_field(report1->field[0],  9, 0x00);
 298         hid_set_field(report1->field[0], 10,   32);
 299
 300         hid_set_field(report2->field[0],  0, (chip << 2) | 0x01);
 301         hid_set_field(report2->field[0],  1, 0x00);
 302         hid_set_field(report2->field[0],  2, 0x00);
 303         hid_set_field(report2->field[0],  3,   32);
 304
 305         tdata = data->fb_vbitmap + (tile * 4 + chip) * 64;
 306         for (i = 0; i < 64; i++)
 307                 if (i < 32)
 308                         hid_set_field(report1->field[0], 11 + i, tdata[i]);
 309                 else
 310                         hid_set_field(report2->field[0], 4 + i - 32, tdata[i]);
 311
 312         usbhid_submit_report(data->hdev, report1, USB_DIR_OUT);
 313         usbhid_submit_report(data->hdev, report2, USB_DIR_OUT);
 314         spin_unlock_irqrestore(&data->lock, flags);
 315         return 0;
 316 }
 317
 318 /* Translate a single tile*/
 319 static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp,
 320                 int chip, int tile)
 321 {
 322         int i, b, changed = 0;
 323         u8 tdata[64];
 324         u8 *vdata = vbitmap + (tile * 4 + chip) * 64;
 325
 326         if (bpp == 1) {
 327                 for (b = 7; b >= 0; b--) {
 328                         const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32;
 329                         for (i = 0; i < 64; i++) {
 330                                 tdata[i] <<= 1;
 331                                 tdata[i] |= (bdata[i/8] >> (7 - i % 8)) & 0x01;
 332                         }
 333                 }
 334         } else if (bpp == 8) {
 335                 for (b = 7; b >= 0; b--) {
 336                         const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8;
 337                         for (i = 0; i < 64; i++) {
 338                                 tdata[i] <<= 1;
 339                                 tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00;
 340                         }
 341                 }
 342         } else {
 343                 /* Oops, we should never get here! */
 344                 WARN_ON(1);
 345                 return 0;
 346         }
 347
 348         for (i = 0; i < 64; i++)
 349                 if (tdata[i] != vdata[i]) {
 350                         changed = 1;
 351                         vdata[i] = tdata[i];
 352                 }
 353         return changed;
 354 }
 355
 356 /* Reconfigure LCD display */
 357 static int picolcd_fb_reset(struct picolcd_data *data, int clear)
 358 {
 359         struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev);
 360         int i, j;
 361         unsigned long flags;
 362         static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 };
 363
 364         if (!report || report->maxfield != 1)
 365                 return -ENODEV;
 366
 367         spin_lock_irqsave(&data->lock, flags);
 368         for (i = 0; i < 4; i++) {
 369                 for (j = 0; j < report->field[0]->maxusage; j++)
 370                         if (j == 0)
 371                                 hid_set_field(report->field[0], j, i << 2);
 372                         else if (j < sizeof(mapcmd))
 373                                 hid_set_field(report->field[0], j, mapcmd[j]);
 374                         else
 375                                 hid_set_field(report->field[0], j, 0);
 376                 usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
 377         }
 378
 379         data->status |= PICOLCD_READY_FB;
 380         spin_unlock_irqrestore(&data->lock, flags);
 381
 382         if (data->fb_bitmap) {
 383                 if (clear) {
 384                         memset(data->fb_vbitmap, 0xff, PICOLCDFB_SIZE);
 385                         memset(data->fb_bitmap, 0, PICOLCDFB_SIZE*data->fb_bpp);
 386                 } else {
 387                         /* invert 1 byte in each tile to force resend */
 388                         for (i = 0; i < PICOLCDFB_SIZE; i += 64)
 389                                 data->fb_vbitmap[i] = ~data->fb_vbitmap[i];
 390                 }
 391         }
 392
 393         /* schedule first output of framebuffer */
 394         if (data->fb_info)
 395                 schedule_delayed_work(&data->fb_info->deferred_work, 0);
 396
 397         return 0;
 398 }
 399
 400 /* Update fb_vbitmap from the screen_base and send changed tiles to device */
 401 static void picolcd_fb_update(struct picolcd_data *data)
 402 {
 403         int chip, tile, n;
 404         unsigned long flags;
 405
 406         spin_lock_irqsave(&data->lock, flags);
 407         if (!(data->status & PICOLCD_READY_FB)) {
 408                 spin_unlock_irqrestore(&data->lock, flags);
 409                 picolcd_fb_reset(data, 0);
 410         } else {
 411                 spin_unlock_irqrestore(&data->lock, flags);
 412         }
 413
 414         /*
 415          * Translate the framebuffer into the format needed by the PicoLCD.
 416          * See display layout above.
 417          * Do this one tile after the other and push those tiles that changed.
 418          *
 419          * Wait for our IO to complete as otherwise we might flood the queue!
 420          */
 421         n = 0;
 422         for (chip = 0; chip < 4; chip++)
 423                 for (tile = 0; tile < 8; tile++)
 424                         if (picolcd_fb_update_tile(data->fb_vbitmap,
 425                                         data->fb_bitmap, data->fb_bpp, chip, tile)) {
 426                                 n += 2;
 427                                 if (n >= HID_OUTPUT_FIFO_SIZE / 2) {
 428                                         usbhid_wait_io(data->hdev);
 429                                         n = 0;
 430                                 }
 431                                 picolcd_fb_send_tile(data->hdev, chip, tile);
 432                         }
 433         if (n)
 434                 usbhid_wait_io(data->hdev);
 435 }
 436
 437 /* Stub to call the system default and update the image on the picoLCD */
 438 static void picolcd_fb_fillrect(struct fb_info *info,
 439                 const struct fb_fillrect *rect)
 440 {
 441         if (!info->par)
 442                 return;
 443         sys_fillrect(info, rect);
 444
 445         schedule_delayed_work(&info->deferred_work, 0);
 446 }
 447
 448 /* Stub to call the system default and update the image on the picoLCD */
 449 static void picolcd_fb_copyarea(struct fb_info *info,
 450                 const struct fb_copyarea *area)
 451 {
 452         if (!info->par)
 453                 return;
 454         sys_copyarea(info, area);
 455
 456         schedule_delayed_work(&info->deferred_work, 0);
 457 }
 458
 459 /* Stub to call the system default and update the image on the picoLCD */
 460 static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image)
 461 {
 462         if (!info->par)
 463                 return;
 464         sys_imageblit(info, image);
 465
 466         schedule_delayed_work(&info->deferred_work, 0);
 467 }
 468
 469 /*
 470  * this is the slow path from userspace. they can seek and write to
 471  * the fb. it's inefficient to do anything less than a full screen draw
 472  */
 473 static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf,
 474                 size_t count, loff_t *ppos)
 475 {
 476         ssize_t ret;
 477         if (!info->par)
 478                 return -ENODEV;
 479         ret = fb_sys_write(info, buf, count, ppos);
 480         if (ret >= 0)
 481                 schedule_delayed_work(&info->deferred_work, 0);
 482         return ret;
 483 }
 484
 485 static int picolcd_fb_blank(int blank, struct fb_info *info)
 486 {
 487         if (!info->par)
 488                 return -ENODEV;
 489         /* We let fb notification do this for us via lcd/backlight device */
 490         return 0;
 491 }
 492
 493 static void picolcd_fb_destroy(struct fb_info *info)
 494 {
 495         struct picolcd_data *data = info->par;
 496         info->par = NULL;
 497         if (data)
 498                 data->fb_info = NULL;
 499         fb_deferred_io_cleanup(info);
 500         framebuffer_release(info);
 501 }
 502
 503 static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 504 {
 505         __u32 bpp      = var->bits_per_pixel;
 506         __u32 activate = var->activate;
 507
 508         /* only allow 1/8 bit depth (8-bit is grayscale) */
 509         *var = picolcdfb_var;
 510         var->activate = activate;
 511         if (bpp >= 8)
 512                 var->bits_per_pixel = 8;
 513         else
 514                 var->bits_per_pixel = 1;
 515         return 0;
 516 }
 517
 518 static int picolcd_set_par(struct fb_info *info)
 519 {
 520         struct picolcd_data *data = info->par;
 521         u8 *o_fb, *n_fb;
 522         if (info->var.bits_per_pixel == data->fb_bpp)
 523                 return 0;
 524         /* switch between 1/8 bit depths */
 525         if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8)
 526                 return -EINVAL;
 527
 528         o_fb = data->fb_bitmap;
 529         n_fb = vmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel);
 530         if (!n_fb)
 531                 return -ENOMEM;
 532
 533         fb_deferred_io_cleanup(info);
 534         /* translate FB content to new bits-per-pixel */
 535         if (info->var.bits_per_pixel == 1) {
 536                 int i, b;
 537                 for (i = 0; i < PICOLCDFB_SIZE; i++) {
 538                         u8 p = 0;
 539                         for (b = 0; b < 8; b++) {
 540                                 p <<= 1;
 541                                 p |= o_fb[i*8+b] ? 0x01 : 0x00;
 542                         }
 543                 }
 544                 info->fix.visual = FB_VISUAL_MONO01;
 545                 info->fix.line_length = PICOLCDFB_WIDTH / 8;
 546         } else {
 547                 int i;
 548                 for (i = 0; i < PICOLCDFB_SIZE * 8; i++)
 549                         n_fb[i] = o_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00;
 550                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 551                 info->fix.line_length = PICOLCDFB_WIDTH;
 552         }
 553
 554         data->fb_bitmap   = n_fb;
 555         data->fb_bpp      = info->var.bits_per_pixel;
 556         info->screen_base = (char __force __iomem *)n_fb;
 557         info->fix.smem_start = (unsigned long)n_fb;
 558         info->fix.smem_len   = PICOLCDFB_SIZE*data->fb_bpp;
 559         fb_deferred_io_init(info);
 560         vfree(o_fb);
 561         return 0;
 562 }
 563
 564 /* Note this can't be const because of struct fb_info definition */
 565 static struct fb_ops picolcdfb_ops = {
 566         .owner        = THIS_MODULE,
 567         .fb_destroy   = picolcd_fb_destroy,
 568         .fb_read      = fb_sys_read,
 569         .fb_write     = picolcd_fb_write,
 570         .fb_blank     = picolcd_fb_blank,
 571         .fb_fillrect  = picolcd_fb_fillrect,
 572         .fb_copyarea  = picolcd_fb_copyarea,
 573         .fb_imageblit = picolcd_fb_imageblit,
 574         .fb_check_var = picolcd_fb_check_var,
 575         .fb_set_par   = picolcd_set_par,
 576 };
 577
 578
 579 /* Callback from deferred IO workqueue */
 580 static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagelist)
 581 {
 582         picolcd_fb_update(info->par);
 583 }
 584
 585 static const struct fb_deferred_io picolcd_fb_defio = {
 586         .delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT,
 587         .deferred_io = picolcd_fb_deferred_io,
 588 };
 589
 590
 591 /*
 592  * The "fb_update_rate" sysfs attribute
 593  */
 594 static ssize_t picolcd_fb_update_rate_show(struct device *dev,
 595                 struct device_attribute *attr, char *buf)
 596 {
 597         struct picolcd_data *data = dev_get_drvdata(dev);
 598         unsigned i, fb_update_rate = data->fb_update_rate;
 599         size_t ret = 0;
 600
 601         for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++)
 602                 if (ret >= PAGE_SIZE)
 603                         break;
 604                 else if (i == fb_update_rate)
 605                         ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
 606                 else
 607                         ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
 608         if (ret > 0)
 609                 buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
 610         return ret;
 611 }
 612
 613 static ssize_t picolcd_fb_update_rate_store(struct device *dev,
 614                 struct device_attribute *attr, const char *buf, size_t count)
 615 {
 616         struct picolcd_data *data = dev_get_drvdata(dev);
 617         int i;
 618         unsigned u;
 619
 620         if (count < 1 || count > 10)
 621                 return -EINVAL;
 622
 623         i = sscanf(buf, "%u", &u);
 624         if (i != 1)
 625                 return -EINVAL;
 626
 627         if (u > PICOLCDFB_UPDATE_RATE_LIMIT)
 628                 return -ERANGE;
 629         else if (u == 0)
 630                 u = PICOLCDFB_UPDATE_RATE_DEFAULT;
 631
 632         data->fb_update_rate = u;
 633         data->fb_defio.delay = HZ / data->fb_update_rate;
 634         return count;
 635 }
 636
 637 static DEVICE_ATTR(fb_update_rate, 0666, picolcd_fb_update_rate_show,
 638                 picolcd_fb_update_rate_store);
 639
 640 /* initialize Framebuffer device */
 641 static int picolcd_init_framebuffer(struct picolcd_data *data)
 642 {
 643         struct device *dev = &data->hdev->dev;
 644         struct fb_info *info = NULL;
 645         int error = -ENOMEM;
 646         u8 *fb_vbitmap = NULL;
 647         u8 *fb_bitmap  = NULL;
 648
 649         fb_bitmap = vmalloc(PICOLCDFB_SIZE*picolcdfb_var.bits_per_pixel);
 650         if (fb_bitmap == NULL) {
 651                 dev_err(dev, "can't get a free page for framebuffer\n");
 652                 goto err_nomem;
 653         }
 654
 655         fb_vbitmap = kmalloc(PICOLCDFB_SIZE, GFP_KERNEL);
 656         if (fb_vbitmap == NULL) {
 657                 dev_err(dev, "can't alloc vbitmap image buffer\n");
 658                 goto err_nomem;
 659         }
 660
 661         data->fb_update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
 662         data->fb_defio = picolcd_fb_defio;
 663         info = framebuffer_alloc(0, dev);
 664         if (info == NULL) {
 665                 dev_err(dev, "failed to allocate a framebuffer\n");
 666                 goto err_nomem;
 667         }
 668
 669         info->fbdefio = &data->fb_defio;
 670         info->screen_base = (char __force __iomem *)fb_bitmap;
 671         info->fbops = &picolcdfb_ops;
 672         info->var = picolcdfb_var;
 673         info->fix = picolcdfb_fix;
 674         info->fix.smem_len   = PICOLCDFB_SIZE;
 675         info->fix.smem_start = (unsigned long)fb_bitmap;
 676         info->par = data;
 677         info->flags = FBINFO_FLAG_DEFAULT;
 678
 679         data->fb_vbitmap = fb_vbitmap;
 680         data->fb_bitmap  = fb_bitmap;
 681         data->fb_bpp     = picolcdfb_var.bits_per_pixel;
 682         error = picolcd_fb_reset(data, 1);
 683         if (error) {
 684                 dev_err(dev, "failed to configure display\n");
 685                 goto err_cleanup;
 686         }
 687         error = device_create_file(dev, &dev_attr_fb_update_rate);
 688         if (error) {
 689                 dev_err(dev, "failed to create sysfs attributes\n");
 690                 goto err_cleanup;
 691         }
 692         data->fb_info    = info;
 693         error = register_framebuffer(info);
 694         if (error) {
 695                 dev_err(dev, "failed to register framebuffer\n");
 696                 goto err_sysfs;
 697         }
 698         fb_deferred_io_init(info);
 699         /* schedule first output of framebuffer */
 700         schedule_delayed_work(&info->deferred_work, 0);
 701         return 0;
 702
 703 err_sysfs:
 704         device_remove_file(dev, &dev_attr_fb_update_rate);
 705 err_cleanup:
 706         data->fb_vbitmap = NULL;
 707         data->fb_bitmap  = NULL;
 708         data->fb_bpp     = 0;
 709         data->fb_info    = NULL;
 710
 711 err_nomem:
 712         framebuffer_release(info);
 713         vfree(fb_bitmap);
 714         kfree(fb_vbitmap);
 715         return error;
 716 }
 717
 718 static void picolcd_exit_framebuffer(struct picolcd_data *data)
 719 {
 720         struct fb_info *info = data->fb_info;
 721         u8 *fb_vbitmap = data->fb_vbitmap;
 722         u8 *fb_bitmap  = data->fb_bitmap;
 723
 724         if (!info)
 725                 return;
 726
 727         data->fb_vbitmap = NULL;
 728         data->fb_bitmap  = NULL;
 729         data->fb_bpp     = 0;
 730         data->fb_info    = NULL;
 731         device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate);
 732         fb_deferred_io_cleanup(info);
 733         unregister_framebuffer(info);
 734         vfree(fb_bitmap);
 735         kfree(fb_vbitmap);
 736 }
 737
 738 #define picolcd_fbinfo(d) ((d)->fb_info)
 739 #else
 740 static inline int picolcd_fb_reset(struct picolcd_data *data, int clear)
 741 {
 742         return 0;
 743 }
 744 static inline int picolcd_init_framebuffer(struct picolcd_data *data)
 745 {
 746         return 0;
 747 }
 748 static void picolcd_exit_framebuffer(struct picolcd_data *data)
 749 {
 750 }
 751 #define picolcd_fbinfo(d) NULL
 752 #endif /* CONFIG_FB */
 753
 754 #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)
 755 /*
 756  * backlight class device
 757  */
 758 static int picolcd_get_brightness(struct backlight_device *bdev)
 759 {
 760         struct picolcd_data *data = bl_get_data(bdev);
 761         return data->lcd_brightness;
 762 }
 763
 764 static int picolcd_set_brightness(struct backlight_device *bdev)
 765 {
 766         struct picolcd_data *data = bl_get_data(bdev);
 767         struct hid_report *report = picolcd_out_report(REPORT_BRIGHTNESS, data->hdev);
 768         unsigned long flags;
 769
 770         if (!report || report->maxfield != 1 || report->field[0]->report_count != 1)
 771                 return -ENODEV;
 772
 773         data->lcd_brightness = bdev->props.brightness & 0x0ff;
 774         data->lcd_power      = bdev->props.power;
 775         spin_lock_irqsave(&data->lock, flags);
 776         hid_set_field(report->field[0], 0, data->lcd_power == FB_BLANK_UNBLANK ? data->lcd_brightness : 0);
 777         usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
 778         spin_unlock_irqrestore(&data->lock, flags);
 779         return 0;
 780 }
 781
 782 static int picolcd_check_bl_fb(struct backlight_device *bdev, struct fb_info *fb)
 783 {
 784         return fb && fb == picolcd_fbinfo((struct picolcd_data *)bl_get_data(bdev));
 785 }
 786
 787 static const struct backlight_ops picolcd_blops = {
 788         .update_status  = picolcd_set_brightness,
 789         .get_brightness = picolcd_get_brightness,
 790         .check_fb       = picolcd_check_bl_fb,
 791 };
 792
 793 static int picolcd_init_backlight(struct picolcd_data *data, struct hid_report *report)
 794 {
 795         struct device *dev = &data->hdev->dev;
 796         struct backlight_device *bdev;
 797         struct backlight_properties props;
 798         if (!report)
 799                 return -ENODEV;
 800         if (report->maxfield != 1 || report->field[0]->report_count != 1 ||
 801                         report->field[0]->report_size != 8) {
 802                 dev_err(dev, "unsupported BRIGHTNESS report");
 803                 return -EINVAL;
 804         }
 805
 806         memset(&props, 0, sizeof(props));
 807         props.max_brightness = 0xff;
 808         bdev = backlight_device_register(dev_name(dev), dev, data,
 809                         &picolcd_blops, &props);
 810         if (IS_ERR(bdev)) {
 811                 dev_err(dev, "failed to register backlight\n");
 812                 return PTR_ERR(bdev);
 813         }
 814         bdev->props.brightness     = 0xff;
 815         data->lcd_brightness       = 0xff;
 816         data->backlight            = bdev;
 817         picolcd_set_brightness(bdev);
 818         return 0;
 819 }
 820
 821 static void picolcd_exit_backlight(struct picolcd_data *data)
 822 {
 823         struct backlight_device *bdev = data->backlight;
 824
 825         data->backlight = NULL;
 826         if (bdev)
 827                 backlight_device_unregister(bdev);
 828 }
 829
 830 static inline int picolcd_resume_backlight(struct picolcd_data *data)
 831 {
 832         if (!data->backlight)
 833                 return 0;
 834         return picolcd_set_brightness(data->backlight);
 835 }
 836
 837 #else
 838 static inline int picolcd_init_backlight(struct picolcd_data *data,
 839                 struct hid_report *report)
 840 {
 841         return 0;
 842 }
 843 static inline void picolcd_exit_backlight(struct picolcd_data *data)
 844 {
 845 }
 846 static inline int picolcd_resume_backlight(struct picolcd_data *data)
 847 {
 848         return 0;
 849 }
 850 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
 851
 852 /*
 853  * input class device
 854  */
 855 static int picolcd_raw_keypad(struct picolcd_data *data,
 856                 struct hid_report *report, u8 *raw_data, int size)
 857 {
 858         /*
 859          * Keypad event
 860          * First and second data bytes list currently pressed keys,
 861          * 0x00 means no key and at most 2 keys may be pressed at same time
 862          */
 863         int i, j;
 864
 865         /* determine newly pressed keys */
 866         for (i = 0; i < size; i++) {
 867                 unsigned int key_code;
 868                 if (raw_data[i] == 0)
 869                         continue;
 870                 for (j = 0; j < sizeof(data->pressed_keys); j++)
 871                         if (data->pressed_keys[j] == raw_data[i])
 872                                 goto key_already_down;
 873                 for (j = 0; j < sizeof(data->pressed_keys); j++)
 874                         if (data->pressed_keys[j] == 0) {
 875                                 data->pressed_keys[j] = raw_data[i];
 876                                 break;
 877                         }
 878                 input_event(data->input_keys, EV_MSC, MSC_SCAN, raw_data[i]);
 879                 if (raw_data[i] < PICOLCD_KEYS)
 880                         key_code = data->keycode[raw_data[i]];
 881                 else
 882                         key_code = KEY_UNKNOWN;
 883                 if (key_code != KEY_UNKNOWN) {
 884                         dbg_hid(PICOLCD_NAME " got key press for %u:%d",
 885                                         raw_data[i], key_code);
 886                         input_report_key(data->input_keys, key_code, 1);
 887                 }
 888                 input_sync(data->input_keys);
 889 key_already_down:
 890                 continue;
 891         }
 892
 893         /* determine newly released keys */
 894         for (j = 0; j < sizeof(data->pressed_keys); j++) {
 895                 unsigned int key_code;
 896                 if (data->pressed_keys[j] == 0)
 897                         continue;
 898                 for (i = 0; i < size; i++)
 899                         if (data->pressed_keys[j] == raw_data[i])
 900                                 goto key_still_down;
 901                 input_event(data->input_keys, EV_MSC, MSC_SCAN, data->pressed_keys[j]);
 902                 if (data->pressed_keys[j] < PICOLCD_KEYS)
 903                         key_code = data->keycode[data->pressed_keys[j]];
 904                 else
 905                         key_code = KEY_UNKNOWN;
 906                 if (key_code != KEY_UNKNOWN) {
 907                         dbg_hid(PICOLCD_NAME " got key release for %u:%d",
 908                                         data->pressed_keys[j], key_code);
 909                         input_report_key(data->input_keys, key_code, 0);
 910                 }
 911                 input_sync(data->input_keys);
 912                 data->pressed_keys[j] = 0;
 913 key_still_down:
 914                 continue;
 915         }
 916         return 1;
 917 }
 918
 919 static int picolcd_raw_cir(struct picolcd_data *data,
 920                 struct hid_report *report, u8 *raw_data, int size)
 921 {
 922         /* Need understanding of CIR data format to implement ... */
 923         return 1;
 924 }
 925
 926 static int picolcd_check_version(struct hid_device *hdev)
 927 {
 928         struct picolcd_data *data = hid_get_drvdata(hdev);
 929         struct picolcd_pending *verinfo;
 930         int ret = 0;
 931
 932         if (!data)
 933                 return -ENODEV;
 934
 935         verinfo = picolcd_send_and_wait(hdev, REPORT_VERSION, NULL, 0);
 936         if (!verinfo) {
 937                 dev_err(&hdev->dev, "no version response from PicoLCD");
 938                 return -ENODEV;
 939         }
 940
 941         if (verinfo->raw_size == 2) {
 942                 if (data->status & PICOLCD_BOOTLOADER) {
 943                         dev_info(&hdev->dev, "PicoLCD, bootloader version %d.%d\n",
 944                                         verinfo->raw_data[0], verinfo->raw_data[1]);
 945                         data->version[0] = verinfo->raw_data[0];
 946                         data->version[1] = verinfo->raw_data[1];
 947                 } else {
 948                         dev_info(&hdev->dev, "PicoLCD, firmware version %d.%d\n",
 949                                         verinfo->raw_data[1], verinfo->raw_data[0]);
 950                         data->version[0] = verinfo->raw_data[1];
 951                         data->version[1] = verinfo->raw_data[0];
 952                 }
 953         } else {
 954                 dev_err(&hdev->dev, "confused, got unexpected version response from PicoLCD\n");
 955                 ret = -EINVAL;
 956         }
 957         kfree(verinfo);
 958         return ret;
 959 }
 960
 961 /*
 962  * Reset our device and wait for answer to VERSION request
 963  */
 964 static int picolcd_reset(struct hid_device *hdev)
 965 {
 966         struct picolcd_data *data = hid_get_drvdata(hdev);
 967         struct hid_report *report = picolcd_out_report(REPORT_RESET, hdev);
 968         unsigned long flags;
 969         int error;
 970
 971         if (!data || !report || report->maxfield != 1)
 972                 return -ENODEV;
 973
 974         spin_lock_irqsave(&data->lock, flags);
 975         if (hdev->product == USB_DEVICE_ID_PICOLCD_BOOTLOADER)
 976                 data->status |= PICOLCD_BOOTLOADER;
 977
 978         /* perform the reset */
 979         hid_set_field(report->field[0], 0, 1);
 980         usbhid_submit_report(hdev, report, USB_DIR_OUT);
 981         spin_unlock_irqrestore(&data->lock, flags);
 982
 983         error = picolcd_check_version(hdev);
 984         if (error)
 985                 return error;
 986
 987         picolcd_resume_backlight(data);
 988 #if defined(CONFIG_FB) || defined(CONFIG_FB_MODULE)
 989         if (data->fb_info)
 990                 schedule_delayed_work(&data->fb_info->deferred_work, 0);
 991 #endif /* CONFIG_FB */
 992
 993         return 0;
 994 }
 995
 996 /*
 997  * The "operation_mode" sysfs attribute
 998  */
 999 static ssize_t picolcd_operation_mode_show(struct device *dev,
1000                 struct device_attribute *attr, char *buf)
1001 {
1002         struct picolcd_data *data = dev_get_drvdata(dev);
1003
1004         if (data->status & PICOLCD_BOOTLOADER)
1005                 return snprintf(buf, PAGE_SIZE, "[bootloader] lcd\n");
1006         else
1007                 return snprintf(buf, PAGE_SIZE, "bootloader [lcd]\n");
1008 }
1009
1010 static ssize_t picolcd_operation_mode_store(struct device *dev,
1011                 struct device_attribute *attr, const char *buf, size_t count)
1012 {
1013         struct picolcd_data *data = dev_get_drvdata(dev);
1014         struct hid_report *report = NULL;
1015         size_t cnt = count;
1016         int timeout = 5000;
1017         unsigned u;
1018         unsigned long flags;
1019
1020         if (cnt >= 3 && strncmp("lcd", buf, 3) == 0) {
1021                 if (data->status & PICOLCD_BOOTLOADER)
1022                         report = picolcd_out_report(REPORT_EXIT_FLASHER, data->hdev);
1023                 buf += 3;
1024                 cnt -= 3;
1025         } else if (cnt >= 10 && strncmp("bootloader", buf, 10) == 0) {
1026                 if (!(data->status & PICOLCD_BOOTLOADER))
1027                         report = picolcd_out_report(REPORT_EXIT_KEYBOARD, data->hdev);
1028                 buf += 10;
1029                 cnt -= 10;
1030         }
1031         if (!report)
1032                 return -EINVAL;
1033
1034         while (cnt > 0 && (*buf == ' ' || *buf == '\t')) {
1035                 buf++;
1036                 cnt--;
1037         }
1038         while (cnt > 0 && (buf[cnt-1] == '\n' || buf[cnt-1] == '\r'))
1039                 cnt--;
1040         if (cnt > 0) {
1041                 if (sscanf(buf, "%u", &u) != 1)
1042                         return -EINVAL;
1043                 if (u > 30000)
1044                         return -EINVAL;
1045                 else
1046                         timeout = u;
1047         }
1048
1049         spin_lock_irqsave(&data->lock, flags);
1050         hid_set_field(report->field[0], 0, timeout & 0xff);
1051         hid_set_field(report->field[0], 1, (timeout >> 8) & 0xff);
1052         usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
1053         spin_unlock_irqrestore(&data->lock, flags);
1054         return count;
1055 }
1056
1057 static DEVICE_ATTR(operation_mode, 0644, picolcd_operation_mode_show,
1058                 picolcd_operation_mode_store);
1059
1060
1061 #ifdef CONFIG_DEBUG_FS
1062 /*
1063  * Helper code for HID report level dumping/debugging
1064  */
1065 static const char *error_codes[] = {
1066         "success", "parameter missing", "data_missing", "block readonly",
1067         "block not erasable", "block too big", "section overflow",
1068         "invalid command length", "invalid data length",
1069 };
1070
1071 static void dump_buff_as_hex(char *dst, size_t dst_sz, const u8 *data,
1072                 const size_t data_len)
1073 {
1074         int i, j;
1075         for (i = j = 0; i < data_len && j + 3 < dst_sz; i++) {
1076                 dst[j++] = hex_asc[(data[i] >> 4) & 0x0f];
1077                 dst[j++] = hex_asc[data[i] & 0x0f];
1078                 dst[j++] = ' ';
1079         }
1080         if (j < dst_sz) {
1081                 dst[j--] = '\0';
1082                 dst[j] = '\n';
1083         } else
1084                 dst[j] = '\0';
1085 }
1086
1087 static void picolcd_debug_out_report(struct picolcd_data *data,
1088                 struct hid_device *hdev, struct hid_report *report)
1089 {
1090         u8 raw_data[70];
1091         int raw_size = (report->size >> 3) + 1;
1092         char *buff;
1093 #define BUFF_SZ 256
1094
1095         /* Avoid unnecessary overhead if debugfs is disabled */
1096         if (!hdev->debug_events)
1097                 return;
1098
1099         buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
1100         if (!buff)
1101                 return;
1102
1103         snprintf(buff, BUFF_SZ, "\nout report %d (size %d) =  ",
1104                         report->id, raw_size);
1105         hid_debug_event(hdev, buff);
1106         if (raw_size + 5 > sizeof(raw_data)) {
1107                 hid_debug_event(hdev, " TOO BIG\n");
1108                 return;
1109         } else {
1110                 raw_data[0] = report->id;
1111                 hid_output_report(report, raw_data);
1112                 dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size);
1113                 hid_debug_event(hdev, buff);
1114         }
1115
1116         switch (report->id) {
1117         case REPORT_LED_STATE:
1118                 /* 1 data byte with GPO state */
1119                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1120                         "REPORT_LED_STATE", report->id, raw_size-1);
1121                 hid_debug_event(hdev, buff);
1122                 snprintf(buff, BUFF_SZ, "\tGPO state: 0x%02x\n", raw_data[1]);
1123                 hid_debug_event(hdev, buff);
1124                 break;
1125         case REPORT_BRIGHTNESS:
1126                 /* 1 data byte with brightness */
1127                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1128                         "REPORT_BRIGHTNESS", report->id, raw_size-1);
1129                 hid_debug_event(hdev, buff);
1130                 snprintf(buff, BUFF_SZ, "\tBrightness: 0x%02x\n", raw_data[1]);
1131                 hid_debug_event(hdev, buff);
1132                 break;
1133         case REPORT_CONTRAST:
1134                 /* 1 data byte with contrast */
1135                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1136                         "REPORT_CONTRAST", report->id, raw_size-1);
1137                 hid_debug_event(hdev, buff);
1138                 snprintf(buff, BUFF_SZ, "\tContrast: 0x%02x\n", raw_data[1]);
1139                 hid_debug_event(hdev, buff);
1140                 break;
1141         case REPORT_RESET:
1142                 /* 2 data bytes with reset duration in ms */
1143                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1144                         "REPORT_RESET", report->id, raw_size-1);
1145                 hid_debug_event(hdev, buff);
1146                 snprintf(buff, BUFF_SZ, "\tDuration: 0x%02x%02x (%dms)\n",
1147                                 raw_data[2], raw_data[1], raw_data[2] << 8 | raw_data[1]);
1148                 hid_debug_event(hdev, buff);
1149                 break;
1150         case REPORT_LCD_CMD:
1151                 /* 63 data bytes with LCD commands */
1152                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1153                         "REPORT_LCD_CMD", report->id, raw_size-1);
1154                 hid_debug_event(hdev, buff);
1155                 /* TODO: format decoding */
1156                 break;
1157         case REPORT_LCD_DATA:
1158                 /* 63 data bytes with LCD data */
1159                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1160                         "REPORT_LCD_CMD", report->id, raw_size-1);
1161                 /* TODO: format decoding */
1162                 hid_debug_event(hdev, buff);
1163                 break;
1164         case REPORT_LCD_CMD_DATA:
1165                 /* 63 data bytes with LCD commands and data */
1166                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1167                         "REPORT_LCD_CMD", report->id, raw_size-1);
1168                 /* TODO: format decoding */
1169                 hid_debug_event(hdev, buff);
1170                 break;
1171         case REPORT_EE_READ:
1172                 /* 3 data bytes with read area description */
1173                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1174                         "REPORT_EE_READ", report->id, raw_size-1);
1175                 hid_debug_event(hdev, buff);
1176                 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1177                                 raw_data[2], raw_data[1]);
1178                 hid_debug_event(hdev, buff);
1179                 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1180                 hid_debug_event(hdev, buff);
1181                 break;
1182         case REPORT_EE_WRITE:
1183                 /* 3+1..20 data bytes with write area description */
1184                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1185                         "REPORT_EE_WRITE", report->id, raw_size-1);
1186                 hid_debug_event(hdev, buff);
1187                 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1188                                 raw_data[2], raw_data[1]);
1189                 hid_debug_event(hdev, buff);
1190                 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1191                 hid_debug_event(hdev, buff);
1192                 if (raw_data[3] == 0) {
1193                         snprintf(buff, BUFF_SZ, "\tNo data\n");
1194                 } else if (raw_data[3] + 4 <= raw_size) {
1195                         snprintf(buff, BUFF_SZ, "\tData: ");
1196                         hid_debug_event(hdev, buff);
1197                         dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
1198                 } else {
1199                         snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1200                 }
1201                 hid_debug_event(hdev, buff);
1202                 break;
1203         case REPORT_ERASE_MEMORY:
1204         case REPORT_BL_ERASE_MEMORY:
1205                 /* 3 data bytes with pointer inside erase block */
1206                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1207                         "REPORT_ERASE_MEMORY", report->id, raw_size-1);
1208                 hid_debug_event(hdev, buff);
1209                 switch (data->addr_sz) {
1210                 case 2:
1211                         snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x\n",
1212                                         raw_data[2], raw_data[1]);
1213                         break;
1214                 case 3:
1215                         snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x%02x\n",
1216                                         raw_data[3], raw_data[2], raw_data[1]);
1217                         break;
1218                 default:
1219                         snprintf(buff, BUFF_SZ, "\tNot supported\n");
1220                 }
1221                 hid_debug_event(hdev, buff);
1222                 break;
1223         case REPORT_READ_MEMORY:
1224         case REPORT_BL_READ_MEMORY:
1225                 /* 4 data bytes with read area description */
1226                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1227                         "REPORT_READ_MEMORY", report->id, raw_size-1);
1228                 hid_debug_event(hdev, buff);
1229                 switch (data->addr_sz) {
1230                 case 2:
1231                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1232                                         raw_data[2], raw_data[1]);
1233                         hid_debug_event(hdev, buff);
1234                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1235                         break;
1236                 case 3:
1237                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
1238                                         raw_data[3], raw_data[2], raw_data[1]);
1239                         hid_debug_event(hdev, buff);
1240                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
1241                         break;
1242                 default:
1243                         snprintf(buff, BUFF_SZ, "\tNot supported\n");
1244                 }
1245                 hid_debug_event(hdev, buff);
1246                 break;
1247         case REPORT_WRITE_MEMORY:
1248         case REPORT_BL_WRITE_MEMORY:
1249                 /* 4+1..32 data bytes with write adrea description */
1250                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1251                         "REPORT_WRITE_MEMORY", report->id, raw_size-1);
1252                 hid_debug_event(hdev, buff);
1253                 switch (data->addr_sz) {
1254                 case 2:
1255                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1256                                         raw_data[2], raw_data[1]);
1257                         hid_debug_event(hdev, buff);
1258                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1259                         hid_debug_event(hdev, buff);
1260                         if (raw_data[3] == 0) {
1261                                 snprintf(buff, BUFF_SZ, "\tNo data\n");
1262                         } else if (raw_data[3] + 4 <= raw_size) {
1263                                 snprintf(buff, BUFF_SZ, "\tData: ");
1264                                 hid_debug_event(hdev, buff);
1265                                 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
1266                         } else {
1267                                 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1268                         }
1269                         break;
1270                 case 3:
1271                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
1272                                         raw_data[3], raw_data[2], raw_data[1]);
1273                         hid_debug_event(hdev, buff);
1274                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
1275                         hid_debug_event(hdev, buff);
1276                         if (raw_data[4] == 0) {
1277                                 snprintf(buff, BUFF_SZ, "\tNo data\n");
1278                         } else if (raw_data[4] + 5 <= raw_size) {
1279                                 snprintf(buff, BUFF_SZ, "\tData: ");
1280                                 hid_debug_event(hdev, buff);
1281                                 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
1282                         } else {
1283                                 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1284                         }
1285                         break;
1286                 default:
1287                         snprintf(buff, BUFF_SZ, "\tNot supported\n");
1288                 }
1289                 hid_debug_event(hdev, buff);
1290                 break;
1291         case REPORT_SPLASH_RESTART:
1292                 /* TODO */
1293                 break;
1294         case REPORT_EXIT_KEYBOARD:
1295                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1296                         "REPORT_EXIT_KEYBOARD", report->id, raw_size-1);
1297                 hid_debug_event(hdev, buff);
1298                 snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n",
1299                                 raw_data[1] | (raw_data[2] << 8),
1300                                 raw_data[2], raw_data[1]);
1301                 hid_debug_event(hdev, buff);
1302                 break;
1303         case REPORT_VERSION:
1304                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1305                         "REPORT_VERSION", report->id, raw_size-1);
1306                 hid_debug_event(hdev, buff);
1307                 break;
1308         case REPORT_DEVID:
1309                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1310                         "REPORT_DEVID", report->id, raw_size-1);
1311                 hid_debug_event(hdev, buff);
1312                 break;
1313         case REPORT_SPLASH_SIZE:
1314                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1315                         "REPORT_SPLASH_SIZE", report->id, raw_size-1);
1316                 hid_debug_event(hdev, buff);
1317                 break;
1318         case REPORT_HOOK_VERSION:
1319                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1320                         "REPORT_HOOK_VERSION", report->id, raw_size-1);
1321                 hid_debug_event(hdev, buff);
1322                 break;
1323         case REPORT_EXIT_FLASHER:
1324                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1325                         "REPORT_VERSION", report->id, raw_size-1);
1326                 hid_debug_event(hdev, buff);
1327                 snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n",
1328                                 raw_data[1] | (raw_data[2] << 8),
1329                                 raw_data[2], raw_data[1]);
1330                 hid_debug_event(hdev, buff);
1331                 break;
1332         default:
1333                 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
1334                         "<unknown>", report->id, raw_size-1);
1335                 hid_debug_event(hdev, buff);
1336                 break;
1337         }
1338         wake_up_interruptible(&hdev->debug_wait);
1339         kfree(buff);
1340 }
1341
1342 static void picolcd_debug_raw_event(struct picolcd_data *data,
1343                 struct hid_device *hdev, struct hid_report *report,
1344                 u8 *raw_data, int size)
1345 {
1346         char *buff;
1347
1348 #define BUFF_SZ 256
1349         /* Avoid unnecessary overhead if debugfs is disabled */
1350         if (!hdev->debug_events)
1351                 return;
1352
1353         buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
1354         if (!buff)
1355                 return;
1356
1357         switch (report->id) {
1358         case REPORT_ERROR_CODE:
1359                 /* 2 data bytes with affected report and error code */
1360                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1361                         "REPORT_ERROR_CODE", report->id, size-1);
1362                 hid_debug_event(hdev, buff);
1363                 if (raw_data[2] < ARRAY_SIZE(error_codes))
1364                         snprintf(buff, BUFF_SZ, "\tError code 0x%02x (%s) in reply to report 0x%02x\n",
1365                                         raw_data[2], error_codes[raw_data[2]], raw_data[1]);
1366                 else
1367                         snprintf(buff, BUFF_SZ, "\tError code 0x%02x in reply to report 0x%02x\n",
1368                                         raw_data[2], raw_data[1]);
1369                 hid_debug_event(hdev, buff);
1370                 break;
1371         case REPORT_KEY_STATE:
1372                 /* 2 data bytes with key state */
1373                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1374                         "REPORT_KEY_STATE", report->id, size-1);
1375                 hid_debug_event(hdev, buff);
1376                 if (raw_data[1] == 0)
1377                         snprintf(buff, BUFF_SZ, "\tNo key pressed\n");
1378                 else if (raw_data[2] == 0)
1379                         snprintf(buff, BUFF_SZ, "\tOne key pressed: 0x%02x (%d)\n",
1380                                         raw_data[1], raw_data[1]);
1381                 else
1382                         snprintf(buff, BUFF_SZ, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n",
1383                                         raw_data[1], raw_data[1], raw_data[2], raw_data[2]);
1384                 hid_debug_event(hdev, buff);
1385                 break;
1386         case REPORT_IR_DATA:
1387                 /* Up to 20 byes of IR scancode data */
1388                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1389                         "REPORT_IR_DATA", report->id, size-1);
1390                 hid_debug_event(hdev, buff);
1391                 if (raw_data[1] == 0) {
1392                         snprintf(buff, BUFF_SZ, "\tUnexpectedly 0 data length\n");
1393                         hid_debug_event(hdev, buff);
1394                 } else if (raw_data[1] + 1 <= size) {
1395                         snprintf(buff, BUFF_SZ, "\tData length: %d\n\tIR Data: ",
1396                                         raw_data[1]-1);
1397                         hid_debug_event(hdev, buff);
1398                         dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]-1);
1399                         hid_debug_event(hdev, buff);
1400                 } else {
1401                         snprintf(buff, BUFF_SZ, "\tOverflowing data length: %d\n",
1402                                         raw_data[1]-1);
1403                         hid_debug_event(hdev, buff);
1404                 }
1405                 break;
1406         case REPORT_EE_DATA:
1407                 /* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */
1408                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1409                         "REPORT_EE_DATA", report->id, size-1);
1410                 hid_debug_event(hdev, buff);
1411                 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1412                                 raw_data[2], raw_data[1]);
1413                 hid_debug_event(hdev, buff);
1414                 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1415                 hid_debug_event(hdev, buff);
1416                 if (raw_data[3] == 0) {
1417                         snprintf(buff, BUFF_SZ, "\tNo data\n");
1418                         hid_debug_event(hdev, buff);
1419                 } else if (raw_data[3] + 4 <= size) {
1420                         snprintf(buff, BUFF_SZ, "\tData: ");
1421                         hid_debug_event(hdev, buff);
1422                         dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
1423                         hid_debug_event(hdev, buff);
1424                 } else {
1425                         snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1426                         hid_debug_event(hdev, buff);
1427                 }
1428                 break;
1429         case REPORT_MEMORY:
1430                 /* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRTIE_MEMORY */
1431                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1432                         "REPORT_MEMORY", report->id, size-1);
1433                 hid_debug_event(hdev, buff);
1434                 switch (data->addr_sz) {
1435                 case 2:
1436                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
1437                                         raw_data[2], raw_data[1]);
1438                         hid_debug_event(hdev, buff);
1439                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
1440                         hid_debug_event(hdev, buff);
1441                         if (raw_data[3] == 0) {
1442                                 snprintf(buff, BUFF_SZ, "\tNo data\n");
1443                         } else if (raw_data[3] + 4 <= size) {
1444                                 snprintf(buff, BUFF_SZ, "\tData: ");
1445                                 hid_debug_event(hdev, buff);
1446                                 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
1447                         } else {
1448                                 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1449                         }
1450                         break;
1451                 case 3:
1452                         snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
1453                                         raw_data[3], raw_data[2], raw_data[1]);
1454                         hid_debug_event(hdev, buff);
1455                         snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
1456                         hid_debug_event(hdev, buff);
1457                         if (raw_data[4] == 0) {
1458                                 snprintf(buff, BUFF_SZ, "\tNo data\n");
1459                         } else if (raw_data[4] + 5 <= size) {
1460                                 snprintf(buff, BUFF_SZ, "\tData: ");
1461                                 hid_debug_event(hdev, buff);
1462                                 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
1463                         } else {
1464                                 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
1465                         }
1466                         break;
1467                 default:
1468                         snprintf(buff, BUFF_SZ, "\tNot supported\n");
1469                 }
1470                 hid_debug_event(hdev, buff);
1471                 break;
1472         case REPORT_VERSION:
1473                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1474                         "REPORT_VERSION", report->id, size-1);
1475                 hid_debug_event(hdev, buff);
1476                 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
1477                                 raw_data[2], raw_data[1]);
1478                 hid_debug_event(hdev, buff);
1479                 break;
1480         case REPORT_BL_ERASE_MEMORY:
1481                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1482                         "REPORT_BL_ERASE_MEMORY", report->id, size-1);
1483                 hid_debug_event(hdev, buff);
1484                 /* TODO */
1485                 break;
1486         case REPORT_BL_READ_MEMORY:
1487                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1488                         "REPORT_BL_READ_MEMORY", report->id, size-1);
1489                 hid_debug_event(hdev, buff);
1490                 /* TODO */
1491                 break;
1492         case REPORT_BL_WRITE_MEMORY:
1493                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1494                         "REPORT_BL_WRITE_MEMORY", report->id, size-1);
1495                 hid_debug_event(hdev, buff);
1496                 /* TODO */
1497                 break;
1498         case REPORT_DEVID:
1499                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1500                         "REPORT_DEVID", report->id, size-1);
1501                 hid_debug_event(hdev, buff);
1502                 snprintf(buff, BUFF_SZ, "\tSerial: 0x%02x%02x%02x%02x\n",
1503                                 raw_data[1], raw_data[2], raw_data[3], raw_data[4]);
1504                 hid_debug_event(hdev, buff);
1505                 snprintf(buff, BUFF_SZ, "\tType: 0x%02x\n",
1506                                 raw_data[5]);
1507                 hid_debug_event(hdev, buff);
1508                 break;
1509         case REPORT_SPLASH_SIZE:
1510                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1511                         "REPORT_SPLASH_SIZE", report->id, size-1);
1512                 hid_debug_event(hdev, buff);
1513                 snprintf(buff, BUFF_SZ, "\tTotal splash space: %d\n",
1514                                 (raw_data[2] << 8) | raw_data[1]);
1515                 hid_debug_event(hdev, buff);
1516                 snprintf(buff, BUFF_SZ, "\tUsed splash space: %d\n",
1517                                 (raw_data[4] << 8) | raw_data[3]);
1518                 hid_debug_event(hdev, buff);
1519                 break;
1520         case REPORT_HOOK_VERSION:
1521                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1522                         "REPORT_HOOK_VERSION", report->id, size-1);
1523                 hid_debug_event(hdev, buff);
1524                 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
1525                                 raw_data[1], raw_data[2]);
1526                 hid_debug_event(hdev, buff);
1527                 break;
1528         default:
1529                 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
1530                         "<unknown>", report->id, size-1);
1531                 hid_debug_event(hdev, buff);
1532                 break;
1533         }
1534         wake_up_interruptible(&hdev->debug_wait);
1535         kfree(buff);
1536 }
1537 #else
1538 #define picolcd_debug_raw_event(data, hdev, report, raw_data, size)
1539 #endif
1540
1541 /*
1542  * Handle raw report as sent by device
1543  */
1544 static int picolcd_raw_event(struct hid_device *hdev,
1545                 struct hid_report *report, u8 *raw_data, int size)
1546 {
1547         struct picolcd_data *data = hid_get_drvdata(hdev);
1548         unsigned long flags;
1549         int ret = 0;
1550
1551         if (!data)
1552                 return 1;
1553
1554         if (report->id == REPORT_KEY_STATE) {
1555                 if (data->input_keys)
1556                         ret = picolcd_raw_keypad(data, report, raw_data+1, size-1);
1557         } else if (report->id == REPORT_IR_DATA) {
1558                 if (data->input_cir)
1559                         ret = picolcd_raw_cir(data, report, raw_data+1, size-1);
1560         } else {
1561                 spin_lock_irqsave(&data->lock, flags);
1562                 /*
1563                  * We let the caller of picolcd_send_and_wait() check if the
1564                  * report we got is one of the expected ones or not.
1565                  */
1566                 if (data->pending) {
1567                         memcpy(data->pending->raw_data, raw_data+1, size-1);
1568                         data->pending->raw_size  = size-1;
1569                         data->pending->in_report = report;
1570                         complete(&data->pending->ready);
1571                 }
1572                 spin_unlock_irqrestore(&data->lock, flags);
1573         }
1574
1575         picolcd_debug_raw_event(data, hdev, report, raw_data, size);
1576         return 1;
1577 }
1578
1579 /* initialize keypad input device */
1580 static int picolcd_init_keys(struct picolcd_data *data,
1581                 struct hid_report *report)
1582 {
1583         struct hid_device *hdev = data->hdev;
1584         struct input_dev *idev;
1585         int error, i;
1586
1587         if (!report)
1588                 return -ENODEV;
1589         if (report->maxfield != 1 || report->field[0]->report_count != 2 ||
1590                         report->field[0]->report_size != 8) {
1591                 dev_err(&hdev->dev, "unsupported KEY_STATE report");
1592                 return -EINVAL;
1593         }
1594
1595         idev = input_allocate_device();
1596         if (idev == NULL) {
1597                 dev_err(&hdev->dev, "failed to allocate input device");
1598                 return -ENOMEM;
1599         }
1600         input_set_drvdata(idev, hdev);
1601         memcpy(data->keycode, def_keymap, sizeof(def_keymap));
1602         idev->name = hdev->name;
1603         idev->phys = hdev->phys;
1604         idev->uniq = hdev->uniq;
1605         idev->id.bustype = hdev->bus;
1606         idev->id.vendor  = hdev->vendor;
1607         idev->id.product = hdev->product;
1608         idev->id.version = hdev->version;
1609         idev->dev.parent = hdev->dev.parent;
1610         idev->keycode     = &data->keycode;
1611         idev->keycodemax  = PICOLCD_KEYS;
1612         idev->keycodesize = sizeof(data->keycode[0]);
1613         input_set_capability(idev, EV_MSC, MSC_SCAN);
1614         set_bit(EV_REP, idev->evbit);
1615         for (i = 0; i < PICOLCD_KEYS; i++)
1616                 input_set_capability(idev, EV_KEY, data->keycode[i]);
1617         error = input_register_device(idev);
1618         if (error) {
1619                 dev_err(&hdev->dev, "error registering the input device");
1620                 input_free_device(idev);
1621                 return error;
1622         }
1623         data->input_keys = idev;
1624         return 0;
1625 }
1626
1627 static void picolcd_exit_keys(struct picolcd_data *data)
1628 {
1629         struct input_dev *idev = data->input_keys;
1630
1631         data->input_keys = NULL;
1632         if (idev)
1633                 input_unregister_device(idev);
1634 }
1635
1636 /* initialize CIR input device */
1637 static inline int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report)
1638 {
1639         /* support not implemented yet */
1640         return 0;
1641 }
1642
1643 static inline void picolcd_exit_cir(struct picolcd_data *data)
1644 {
1645 }
1646
1647 static int picolcd_probe_lcd(struct hid_device *hdev, struct picolcd_data *data)
1648 {
1649         struct hid_report *report;
1650         int error;
1651
1652         error = picolcd_check_version(hdev);
1653         if (error)
1654                 return error;
1655
1656         if (data->version[0] != 0 && data->version[1] != 3)
1657                 dev_info(&hdev->dev, "Device with untested firmware revision, "
1658                                 "please submit /sys/kernel/debug/hid/%s/rdesc for this device.\n",
1659                                 dev_name(&hdev->dev));
1660
1661         /* Setup keypad input device */
1662         error = picolcd_init_keys(data, picolcd_in_report(REPORT_KEY_STATE, hdev));
1663         if (error)
1664                 goto err;
1665
1666         /* Setup CIR input device */
1667         error = picolcd_init_cir(data, picolcd_in_report(REPORT_IR_DATA, hdev));
1668         if (error)
1669                 goto err;
1670
1671         /* Set up the framebuffer device */
1672         error = picolcd_init_framebuffer(data);
1673         if (error)
1674                 goto err;
1675
1676         /* Setup backlight class device */
1677         error = picolcd_init_backlight(data, picolcd_out_report(REPORT_BRIGHTNESS, hdev));
1678         if (error)
1679                 goto err;
1680
1681 #ifdef CONFIG_DEBUG_FS
1682         report = picolcd_out_report(REPORT_READ_MEMORY, hdev);
1683         if (report && report->maxfield == 1 && report->field[0]->report_size == 8)
1684                 data->addr_sz = report->field[0]->report_count - 1;
1685         else
1686                 data->addr_sz = -1;
1687 #endif
1688         return 0;
1689 err:
1690         picolcd_exit_backlight(data);
1691         picolcd_exit_framebuffer(data);
1692         picolcd_exit_cir(data);
1693         picolcd_exit_keys(data);
1694         return error;
1695 }
1696
1697 static int picolcd_probe_bootloader(struct hid_device *hdev, struct picolcd_data *data)
1698 {
1699         struct hid_report *report;
1700         int error;
1701
1702         error = picolcd_check_version(hdev);
1703         if (error)
1704                 return error;
1705
1706         if (data->version[0] != 1 && data->version[1] != 0)
1707                 dev_info(&hdev->dev, "Device with untested bootloader revision, "
1708                                 "please submit /sys/kernel/debug/hid/%s/rdesc for this device.\n",
1709                                 dev_name(&hdev->dev));
1710
1711 #ifdef CONFIG_DEBUG_FS
1712         report = picolcd_out_report(REPORT_BL_READ_MEMORY, hdev);
1713         if (report && report->maxfield == 1 && report->field[0]->report_size == 8)
1714                 data->addr_sz = report->field[0]->report_count - 1;
1715         else
1716                 data->addr_sz = -1;
1717 #endif
1718         return 0;
1719 }
1720
1721 static int picolcd_probe(struct hid_device *hdev,
1722                      const struct hid_device_id *id)
1723 {
1724         struct picolcd_data *data;
1725         int error = -ENOMEM;
1726
1727         dbg_hid(PICOLCD_NAME " hardware probe...\n");
1728
1729         /*
1730          * Let's allocate the picolcd data structure, set some reasonable
1731          * defaults, and associate it with the device
1732          */
1733         data = kzalloc(sizeof(struct picolcd_data), GFP_KERNEL);
1734         if (data == NULL) {
1735                 dev_err(&hdev->dev, "can't allocate space for Minibox PicoLCD device data\n");
1736                 error = -ENOMEM;
1737                 goto err_no_cleanup;
1738         }
1739
1740         spin_lock_init(&data->lock);
1741         mutex_init(&data->mutex);
1742         data->hdev = hdev;
1743         if (hdev->product == USB_DEVICE_ID_PICOLCD_BOOTLOADER)
1744                 data->status |= PICOLCD_BOOTLOADER;
1745         hid_set_drvdata(hdev, data);
1746
1747         /* Parse the device reports and start it up */
1748         error = hid_parse(hdev);
1749         if (error) {
1750                 dev_err(&hdev->dev, "device report parse failed\n");
1751                 goto err_cleanup_data;
1752         }
1753
1754         /* We don't use hidinput but hid_hw_start() fails if nothing is
1755          * claimed. So spoof claimed input. */
1756         hdev->claimed = HID_CLAIMED_INPUT;
1757         error = hid_hw_start(hdev, 0);
1758         hdev->claimed = 0;
1759         if (error) {
1760                 dev_err(&hdev->dev, "hardware start failed\n");
1761                 goto err_cleanup_data;
1762         }
1763
1764         error = hdev->ll_driver->open(hdev);
1765         if (error) {
1766                 dev_err(&hdev->dev, "failed to open input interrupt pipe for key and IR events\n");
1767                 goto err_cleanup_hid_hw;
1768         }
1769
1770         error = device_create_file(&hdev->dev, &dev_attr_operation_mode);
1771         if (error) {
1772                 dev_err(&hdev->dev, "failed to create sysfs attributes\n");
1773                 goto err_cleanup_hid_ll;
1774         }
1775
1776         if (data->status & PICOLCD_BOOTLOADER)
1777                 error = picolcd_probe_bootloader(hdev, data);
1778         else
1779                 error = picolcd_probe_lcd(hdev, data);
1780         if (error)
1781                 goto err_cleanup_sysfs;
1782
1783         dbg_hid(PICOLCD_NAME " activated and initialized\n");
1784         return 0;
1785
1786 err_cleanup_sysfs:
1787         device_remove_file(&hdev->dev, &dev_attr_operation_mode);
1788 err_cleanup_hid_ll:
1789         hdev->ll_driver->close(hdev);
1790 err_cleanup_hid_hw:
1791         hid_hw_stop(hdev);
1792 err_cleanup_data:
1793         kfree(data);
1794 err_no_cleanup:
1795         hid_set_drvdata(hdev, NULL);
1796
1797         return error;
1798 }
1799
1800 static void picolcd_remove(struct hid_device *hdev)
1801 {
1802         struct picolcd_data *data = hid_get_drvdata(hdev);
1803         unsigned long flags;
1804
1805         dbg_hid(PICOLCD_NAME " hardware remove...\n");
1806         spin_lock_irqsave(&data->lock, flags);
1807         data->status |= PICOLCD_FAILED;
1808         spin_unlock_irqrestore(&data->lock, flags);
1809
1810         device_remove_file(&hdev->dev, &dev_attr_operation_mode);
1811         hdev->ll_driver->close(hdev);
1812         hid_hw_stop(hdev);
1813         hid_set_drvdata(hdev, NULL);
1814
1815         /* Shortcut potential pending reply that will never arrive */
1816         spin_lock_irqsave(&data->lock, flags);
1817         if (data->pending)
1818                 complete(&data->pending->ready);
1819         spin_unlock_irqrestore(&data->lock, flags);
1820
1821         /* Clean up the framebuffer */
1822         picolcd_exit_backlight(data);
1823         picolcd_exit_framebuffer(data);
1824         /* Cleanup input */
1825         picolcd_exit_cir(data);
1826         picolcd_exit_keys(data);
1827
1828         mutex_destroy(&data->mutex);
1829         /* Finally, clean up the picolcd data itself */
1830         kfree(data);
1831 }
1832
1833 static const struct hid_device_id picolcd_devices[] = {
1834         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
1835         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
1836         { }
1837 };
1838 MODULE_DEVICE_TABLE(hid, picolcd_devices);
1839
1840 static struct hid_driver picolcd_driver = {
1841         .name =          "hid-picolcd",
1842         .id_table =      picolcd_devices,
1843         .probe =         picolcd_probe,
1844         .remove =        picolcd_remove,
1845         .raw_event =     picolcd_raw_event,
1846 };
1847
1848 static int __init picolcd_init(void)
1849 {
1850         return hid_register_driver(&picolcd_driver);
1851 }
1852
1853 static void __exit picolcd_exit(void)
1854 {
1855         hid_unregister_driver(&picolcd_driver);
1856 }
1857
1858 module_init(picolcd_init);
1859 module_exit(picolcd_exit);
1860 MODULE_DESCRIPTION("Minibox graphics PicoLCD Driver");
1861 MODULE_LICENSE("GPL v2");