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