drivers/hid/hid-picolcd_fb.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010-2012 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/vmalloc.h>
  22 #include "usbhid/usbhid.h"
  23 #include <linux/usb.h>
  24
  25 #include <linux/fb.h>
  26 #include <linux/module.h>
  27
  28 #include "hid-picolcd.h"
  29
  30 /* Framebuffer
  31  *
  32  * The PicoLCD use a Topway LCD module of 256x64 pixel
  33  * This display area is tiled over 4 controllers with 8 tiles
  34  * each. Each tile has 8x64 pixel, each data byte representing
  35  * a 1-bit wide vertical line of the tile.
  36  *
  37  * The display can be updated at a tile granularity.
  38  *
  39  *       Chip 1           Chip 2           Chip 3           Chip 4
  40  * +----------------+----------------+----------------+----------------+
  41  * |     Tile 1     |     Tile 1     |     Tile 1     |     Tile 1     |
  42  * +----------------+----------------+----------------+----------------+
  43  * |     Tile 2     |     Tile 2     |     Tile 2     |     Tile 2     |
  44  * +----------------+----------------+----------------+----------------+
  45  *                                  ...
  46  * +----------------+----------------+----------------+----------------+
  47  * |     Tile 8     |     Tile 8     |     Tile 8     |     Tile 8     |
  48  * +----------------+----------------+----------------+----------------+
  49  */
  50 #define PICOLCDFB_NAME "picolcdfb"
  51 #define PICOLCDFB_WIDTH (256)
  52 #define PICOLCDFB_HEIGHT (64)
  53 #define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8)
  54
  55 #define PICOLCDFB_UPDATE_RATE_LIMIT   10
  56 #define PICOLCDFB_UPDATE_RATE_DEFAULT  2
  57
  58 /* Framebuffer visual structures */
  59 static const struct fb_fix_screeninfo picolcdfb_fix = {
  60         .id          = PICOLCDFB_NAME,
  61         .type        = FB_TYPE_PACKED_PIXELS,
  62         .visual      = FB_VISUAL_MONO01,
  63         .xpanstep    = 0,
  64         .ypanstep    = 0,
  65         .ywrapstep   = 0,
  66         .line_length = PICOLCDFB_WIDTH / 8,
  67         .accel       = FB_ACCEL_NONE,
  68 };
  69
  70 static const struct fb_var_screeninfo picolcdfb_var = {
  71         .xres           = PICOLCDFB_WIDTH,
  72         .yres           = PICOLCDFB_HEIGHT,
  73         .xres_virtual   = PICOLCDFB_WIDTH,
  74         .yres_virtual   = PICOLCDFB_HEIGHT,
  75         .width          = 103,
  76         .height         = 26,
  77         .bits_per_pixel = 1,
  78         .grayscale      = 1,
  79         .red            = {
  80                 .offset = 0,
  81                 .length = 1,
  82                 .msb_right = 0,
  83         },
  84         .green          = {
  85                 .offset = 0,
  86                 .length = 1,
  87                 .msb_right = 0,
  88         },
  89         .blue           = {
  90                 .offset = 0,
  91                 .length = 1,
  92                 .msb_right = 0,
  93         },
  94         .transp         = {
  95                 .offset = 0,
  96                 .length = 0,
  97                 .msb_right = 0,
  98         },
  99 };
 100
 101 /* Send a given tile to PicoLCD */
 102 static int picolcd_fb_send_tile(struct picolcd_data *data, u8 *vbitmap,
 103                 int chip, int tile)
 104 {
 105         struct hid_report *report1, *report2;
 106         unsigned long flags;
 107         u8 *tdata;
 108         int i;
 109
 110         report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev);
 111         if (!report1 || report1->maxfield != 1)
 112                 return -ENODEV;
 113         report2 = picolcd_out_report(REPORT_LCD_DATA, data->hdev);
 114         if (!report2 || report2->maxfield != 1)
 115                 return -ENODEV;
 116
 117         spin_lock_irqsave(&data->lock, flags);
 118         if ((data->status & PICOLCD_FAILED)) {
 119                 spin_unlock_irqrestore(&data->lock, flags);
 120                 return -ENODEV;
 121         }
 122         hid_set_field(report1->field[0],  0, chip << 2);
 123         hid_set_field(report1->field[0],  1, 0x02);
 124         hid_set_field(report1->field[0],  2, 0x00);
 125         hid_set_field(report1->field[0],  3, 0x00);
 126         hid_set_field(report1->field[0],  4, 0xb8 | tile);
 127         hid_set_field(report1->field[0],  5, 0x00);
 128         hid_set_field(report1->field[0],  6, 0x00);
 129         hid_set_field(report1->field[0],  7, 0x40);
 130         hid_set_field(report1->field[0],  8, 0x00);
 131         hid_set_field(report1->field[0],  9, 0x00);
 132         hid_set_field(report1->field[0], 10,   32);
 133
 134         hid_set_field(report2->field[0],  0, (chip << 2) | 0x01);
 135         hid_set_field(report2->field[0],  1, 0x00);
 136         hid_set_field(report2->field[0],  2, 0x00);
 137         hid_set_field(report2->field[0],  3,   32);
 138
 139         tdata = vbitmap + (tile * 4 + chip) * 64;
 140         for (i = 0; i < 64; i++)
 141                 if (i < 32)
 142                         hid_set_field(report1->field[0], 11 + i, tdata[i]);
 143                 else
 144                         hid_set_field(report2->field[0], 4 + i - 32, tdata[i]);
 145
 146         usbhid_submit_report(data->hdev, report1, USB_DIR_OUT);
 147         usbhid_submit_report(data->hdev, report2, USB_DIR_OUT);
 148         spin_unlock_irqrestore(&data->lock, flags);
 149         return 0;
 150 }
 151
 152 /* Translate a single tile*/
 153 static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp,
 154                 int chip, int tile)
 155 {
 156         int i, b, changed = 0;
 157         u8 tdata[64];
 158         u8 *vdata = vbitmap + (tile * 4 + chip) * 64;
 159
 160         if (bpp == 1) {
 161                 for (b = 7; b >= 0; b--) {
 162                         const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32;
 163                         for (i = 0; i < 64; i++) {
 164                                 tdata[i] <<= 1;
 165                                 tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01;
 166                         }
 167                 }
 168         } else if (bpp == 8) {
 169                 for (b = 7; b >= 0; b--) {
 170                         const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8;
 171                         for (i = 0; i < 64; i++) {
 172                                 tdata[i] <<= 1;
 173                                 tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00;
 174                         }
 175                 }
 176         } else {
 177                 /* Oops, we should never get here! */
 178                 WARN_ON(1);
 179                 return 0;
 180         }
 181
 182         for (i = 0; i < 64; i++)
 183                 if (tdata[i] != vdata[i]) {
 184                         changed = 1;
 185                         vdata[i] = tdata[i];
 186                 }
 187         return changed;
 188 }
 189
 190 void picolcd_fb_refresh(struct picolcd_data *data)
 191 {
 192         if (data->fb_info)
 193                 schedule_delayed_work(&data->fb_info->deferred_work, 0);
 194 }
 195
 196 /* Reconfigure LCD display */
 197 int picolcd_fb_reset(struct picolcd_data *data, int clear)
 198 {
 199         struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev);
 200         struct picolcd_fb_data *fbdata = data->fb_info->par;
 201         int i, j;
 202         unsigned long flags;
 203         static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 };
 204
 205         if (!report || report->maxfield != 1)
 206                 return -ENODEV;
 207
 208         spin_lock_irqsave(&data->lock, flags);
 209         for (i = 0; i < 4; i++) {
 210                 for (j = 0; j < report->field[0]->maxusage; j++)
 211                         if (j == 0)
 212                                 hid_set_field(report->field[0], j, i << 2);
 213                         else if (j < sizeof(mapcmd))
 214                                 hid_set_field(report->field[0], j, mapcmd[j]);
 215                         else
 216                                 hid_set_field(report->field[0], j, 0);
 217                 usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
 218         }
 219         spin_unlock_irqrestore(&data->lock, flags);
 220
 221         if (clear) {
 222                 memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE);
 223                 memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp);
 224         }
 225         fbdata->force = 1;
 226
 227         /* schedule first output of framebuffer */
 228         if (fbdata->ready)
 229                 schedule_delayed_work(&data->fb_info->deferred_work, 0);
 230         else
 231                 fbdata->ready = 1;
 232
 233         return 0;
 234 }
 235
 236 /* Update fb_vbitmap from the screen_base and send changed tiles to device */
 237 static void picolcd_fb_update(struct fb_info *info)
 238 {
 239         int chip, tile, n;
 240         unsigned long flags;
 241         struct picolcd_fb_data *fbdata = info->par;
 242         struct picolcd_data *data;
 243
 244         mutex_lock(&info->lock);
 245
 246         spin_lock_irqsave(&fbdata->lock, flags);
 247         if (!fbdata->ready && fbdata->picolcd)
 248                 picolcd_fb_reset(fbdata->picolcd, 0);
 249         spin_unlock_irqrestore(&fbdata->lock, flags);
 250
 251         /*
 252          * Translate the framebuffer into the format needed by the PicoLCD.
 253          * See display layout above.
 254          * Do this one tile after the other and push those tiles that changed.
 255          *
 256          * Wait for our IO to complete as otherwise we might flood the queue!
 257          */
 258         n = 0;
 259         for (chip = 0; chip < 4; chip++)
 260                 for (tile = 0; tile < 8; tile++) {
 261                         if (!fbdata->force && !picolcd_fb_update_tile(
 262                                         fbdata->vbitmap, fbdata->bitmap,
 263                                         fbdata->bpp, chip, tile))
 264                                 continue;
 265                         n += 2;
 266                         if (n >= HID_OUTPUT_FIFO_SIZE / 2) {
 267                                 spin_lock_irqsave(&fbdata->lock, flags);
 268                                 data = fbdata->picolcd;
 269                                 spin_unlock_irqrestore(&fbdata->lock, flags);
 270                                 mutex_unlock(&info->lock);
 271                                 if (!data)
 272                                         return;
 273                                 usbhid_wait_io(data->hdev);
 274                                 mutex_lock(&info->lock);
 275                                 n = 0;
 276                         }
 277                         spin_lock_irqsave(&fbdata->lock, flags);
 278                         data = fbdata->picolcd;
 279                         spin_unlock_irqrestore(&fbdata->lock, flags);
 280                         if (!data || picolcd_fb_send_tile(data,
 281                                         fbdata->vbitmap, chip, tile))
 282                                 goto out;
 283                 }
 284         fbdata->force = false;
 285         if (n) {
 286                 spin_lock_irqsave(&fbdata->lock, flags);
 287                 data = fbdata->picolcd;
 288                 spin_unlock_irqrestore(&fbdata->lock, flags);
 289                 mutex_unlock(&info->lock);
 290                 if (data)
 291                         usbhid_wait_io(data->hdev);
 292                 return;
 293         }
 294 out:
 295         mutex_unlock(&info->lock);
 296 }
 297
 298 /* Stub to call the system default and update the image on the picoLCD */
 299 static void picolcd_fb_fillrect(struct fb_info *info,
 300                 const struct fb_fillrect *rect)
 301 {
 302         if (!info->par)
 303                 return;
 304         sys_fillrect(info, rect);
 305
 306         schedule_delayed_work(&info->deferred_work, 0);
 307 }
 308
 309 /* Stub to call the system default and update the image on the picoLCD */
 310 static void picolcd_fb_copyarea(struct fb_info *info,
 311                 const struct fb_copyarea *area)
 312 {
 313         if (!info->par)
 314                 return;
 315         sys_copyarea(info, area);
 316
 317         schedule_delayed_work(&info->deferred_work, 0);
 318 }
 319
 320 /* Stub to call the system default and update the image on the picoLCD */
 321 static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image)
 322 {
 323         if (!info->par)
 324                 return;
 325         sys_imageblit(info, image);
 326
 327         schedule_delayed_work(&info->deferred_work, 0);
 328 }
 329
 330 /*
 331  * this is the slow path from userspace. they can seek and write to
 332  * the fb. it's inefficient to do anything less than a full screen draw
 333  */
 334 static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf,
 335                 size_t count, loff_t *ppos)
 336 {
 337         ssize_t ret;
 338         if (!info->par)
 339                 return -ENODEV;
 340         ret = fb_sys_write(info, buf, count, ppos);
 341         if (ret >= 0)
 342                 schedule_delayed_work(&info->deferred_work, 0);
 343         return ret;
 344 }
 345
 346 static int picolcd_fb_blank(int blank, struct fb_info *info)
 347 {
 348         /* We let fb notification do this for us via lcd/backlight device */
 349         return 0;
 350 }
 351
 352 static void picolcd_fb_destroy(struct fb_info *info)
 353 {
 354         struct picolcd_fb_data *fbdata = info->par;
 355
 356         /* make sure no work is deferred */
 357         fb_deferred_io_cleanup(info);
 358
 359         /* No thridparty should ever unregister our framebuffer! */
 360         WARN_ON(fbdata->picolcd != NULL);
 361
 362         vfree((u8 *)info->fix.smem_start);
 363         framebuffer_release(info);
 364 }
 365
 366 static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 367 {
 368         __u32 bpp      = var->bits_per_pixel;
 369         __u32 activate = var->activate;
 370
 371         /* only allow 1/8 bit depth (8-bit is grayscale) */
 372         *var = picolcdfb_var;
 373         var->activate = activate;
 374         if (bpp >= 8) {
 375                 var->bits_per_pixel = 8;
 376                 var->red.length     = 8;
 377                 var->green.length   = 8;
 378                 var->blue.length    = 8;
 379         } else {
 380                 var->bits_per_pixel = 1;
 381                 var->red.length     = 1;
 382                 var->green.length   = 1;
 383                 var->blue.length    = 1;
 384         }
 385         return 0;
 386 }
 387
 388 static int picolcd_set_par(struct fb_info *info)
 389 {
 390         struct picolcd_fb_data *fbdata = info->par;
 391         u8 *tmp_fb, *o_fb;
 392         if (info->var.bits_per_pixel == fbdata->bpp)
 393                 return 0;
 394         /* switch between 1/8 bit depths */
 395         if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8)
 396                 return -EINVAL;
 397
 398         o_fb   = fbdata->bitmap;
 399         tmp_fb = kmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel, GFP_KERNEL);
 400         if (!tmp_fb)
 401                 return -ENOMEM;
 402
 403         /* translate FB content to new bits-per-pixel */
 404         if (info->var.bits_per_pixel == 1) {
 405                 int i, b;
 406                 for (i = 0; i < PICOLCDFB_SIZE; i++) {
 407                         u8 p = 0;
 408                         for (b = 0; b < 8; b++) {
 409                                 p <<= 1;
 410                                 p |= o_fb[i*8+b] ? 0x01 : 0x00;
 411                         }
 412                         tmp_fb[i] = p;
 413                 }
 414                 memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
 415                 info->fix.visual = FB_VISUAL_MONO01;
 416                 info->fix.line_length = PICOLCDFB_WIDTH / 8;
 417         } else {
 418                 int i;
 419                 memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE);
 420                 for (i = 0; i < PICOLCDFB_SIZE * 8; i++)
 421                         o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00;
 422                 info->fix.visual = FB_VISUAL_DIRECTCOLOR;
 423                 info->fix.line_length = PICOLCDFB_WIDTH;
 424         }
 425
 426         kfree(tmp_fb);
 427         fbdata->bpp = info->var.bits_per_pixel;
 428         return 0;
 429 }
 430
 431 /* Note this can't be const because of struct fb_info definition */
 432 static struct fb_ops picolcdfb_ops = {
 433         .owner        = THIS_MODULE,
 434         .fb_destroy   = picolcd_fb_destroy,
 435         .fb_read      = fb_sys_read,
 436         .fb_write     = picolcd_fb_write,
 437         .fb_blank     = picolcd_fb_blank,
 438         .fb_fillrect  = picolcd_fb_fillrect,
 439         .fb_copyarea  = picolcd_fb_copyarea,
 440         .fb_imageblit = picolcd_fb_imageblit,
 441         .fb_check_var = picolcd_fb_check_var,
 442         .fb_set_par   = picolcd_set_par,
 443 };
 444
 445
 446 /* Callback from deferred IO workqueue */
 447 static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagelist)
 448 {
 449         picolcd_fb_update(info);
 450 }
 451
 452 static const struct fb_deferred_io picolcd_fb_defio = {
 453         .delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT,
 454         .deferred_io = picolcd_fb_deferred_io,
 455 };
 456
 457
 458 /*
 459  * The "fb_update_rate" sysfs attribute
 460  */
 461 static ssize_t picolcd_fb_update_rate_show(struct device *dev,
 462                 struct device_attribute *attr, char *buf)
 463 {
 464         struct picolcd_data *data = dev_get_drvdata(dev);
 465         struct picolcd_fb_data *fbdata = data->fb_info->par;
 466         unsigned i, fb_update_rate = fbdata->update_rate;
 467         size_t ret = 0;
 468
 469         for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++)
 470                 if (ret >= PAGE_SIZE)
 471                         break;
 472                 else if (i == fb_update_rate)
 473                         ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
 474                 else
 475                         ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
 476         if (ret > 0)
 477                 buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
 478         return ret;
 479 }
 480
 481 static ssize_t picolcd_fb_update_rate_store(struct device *dev,
 482                 struct device_attribute *attr, const char *buf, size_t count)
 483 {
 484         struct picolcd_data *data = dev_get_drvdata(dev);
 485         struct picolcd_fb_data *fbdata = data->fb_info->par;
 486         int i;
 487         unsigned u;
 488
 489         if (count < 1 || count > 10)
 490                 return -EINVAL;
 491
 492         i = sscanf(buf, "%u", &u);
 493         if (i != 1)
 494                 return -EINVAL;
 495
 496         if (u > PICOLCDFB_UPDATE_RATE_LIMIT)
 497                 return -ERANGE;
 498         else if (u == 0)
 499                 u = PICOLCDFB_UPDATE_RATE_DEFAULT;
 500
 501         fbdata->update_rate = u;
 502         data->fb_info->fbdefio->delay = HZ / fbdata->update_rate;
 503         return count;
 504 }
 505
 506 static DEVICE_ATTR(fb_update_rate, 0666, picolcd_fb_update_rate_show,
 507                 picolcd_fb_update_rate_store);
 508
 509 /* initialize Framebuffer device */
 510 int picolcd_init_framebuffer(struct picolcd_data *data)
 511 {
 512         struct device *dev = &data->hdev->dev;
 513         struct fb_info *info = NULL;
 514         struct picolcd_fb_data *fbdata = NULL;
 515         int i, error = -ENOMEM;
 516         u32 *palette;
 517
 518         /* The extra memory is:
 519          * - 256*u32 for pseudo_palette
 520          * - struct fb_deferred_io
 521          */
 522         info = framebuffer_alloc(256 * sizeof(u32) +
 523                         sizeof(struct fb_deferred_io) +
 524                         sizeof(struct picolcd_fb_data) +
 525                         PICOLCDFB_SIZE, dev);
 526         if (info == NULL) {
 527                 dev_err(dev, "failed to allocate a framebuffer\n");
 528                 goto err_nomem;
 529         }
 530
 531         info->fbdefio = info->par;
 532         *info->fbdefio = picolcd_fb_defio;
 533         info->par += sizeof(struct fb_deferred_io);
 534         palette = info->par;
 535         info->par += 256 * sizeof(u32);
 536         for (i = 0; i < 256; i++)
 537                 palette[i] = i > 0 && i < 16 ? 0xff : 0;
 538         info->pseudo_palette = palette;
 539         info->fbops = &picolcdfb_ops;
 540         info->var = picolcdfb_var;
 541         info->fix = picolcdfb_fix;
 542         info->fix.smem_len   = PICOLCDFB_SIZE*8;
 543         info->flags = FBINFO_FLAG_DEFAULT;
 544
 545         fbdata = info->par;
 546         spin_lock_init(&fbdata->lock);
 547         fbdata->picolcd = data;
 548         fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
 549         fbdata->bpp     = picolcdfb_var.bits_per_pixel;
 550         fbdata->force   = 1;
 551         fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data);
 552         fbdata->bitmap  = vmalloc(PICOLCDFB_SIZE*8);
 553         if (fbdata->bitmap == NULL) {
 554                 dev_err(dev, "can't get a free page for framebuffer\n");
 555                 goto err_nomem;
 556         }
 557         info->screen_base = (char __force __iomem *)fbdata->bitmap;
 558         info->fix.smem_start = (unsigned long)fbdata->bitmap;
 559         memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE);
 560         data->fb_info = info;
 561
 562         error = picolcd_fb_reset(data, 1);
 563         if (error) {
 564                 dev_err(dev, "failed to configure display\n");
 565                 goto err_cleanup;
 566         }
 567
 568         error = device_create_file(dev, &dev_attr_fb_update_rate);
 569         if (error) {
 570                 dev_err(dev, "failed to create sysfs attributes\n");
 571                 goto err_cleanup;
 572         }
 573
 574         fb_deferred_io_init(info);
 575         error = register_framebuffer(info);
 576         if (error) {
 577                 dev_err(dev, "failed to register framebuffer\n");
 578                 goto err_sysfs;
 579         }
 580         return 0;
 581
 582 err_sysfs:
 583         device_remove_file(dev, &dev_attr_fb_update_rate);
 584         fb_deferred_io_cleanup(info);
 585 err_cleanup:
 586         data->fb_info    = NULL;
 587
 588 err_nomem:
 589         if (fbdata)
 590                 vfree(fbdata->bitmap);
 591         framebuffer_release(info);
 592         return error;
 593 }
 594
 595 void picolcd_exit_framebuffer(struct picolcd_data *data)
 596 {
 597         struct fb_info *info = data->fb_info;
 598         struct picolcd_fb_data *fbdata = info->par;
 599         unsigned long flags;
 600
 601         device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate);
 602
 603         /* disconnect framebuffer from HID dev */
 604         spin_lock_irqsave(&fbdata->lock, flags);
 605         fbdata->picolcd = NULL;
 606         spin_unlock_irqrestore(&fbdata->lock, flags);
 607
 608         /* make sure there is no running update - thus that fbdata->picolcd
 609          * once obtained under lock is guaranteed not to get free() under
 610          * the feet of the deferred work */
 611         flush_delayed_work(&info->deferred_work);
 612
 613         data->fb_info = NULL;
 614         unregister_framebuffer(info);
 615 }