Quelle  hid-picolcd_fb.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/***************************************************************************
 *   Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org>  *
 *                                                                         *
 *   Based on Logitech G13 driver (v0.4)                                   *
 *     Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu>   *
 *                                                                         *
 ***************************************************************************/

#include <linux/hid.h>
#include <linux/vmalloc.h>

#include <linux/fb.h>
#include <linux/module.h>

#include "hid-picolcd.h"

/* Framebuffer
 *
 * The PicoLCD use a Topway LCD module of 256x64 pixel
 * This display area is tiled over 4 controllers with 8 tiles
 * each. Each tile has 8x64 pixel, each data byte representing
 * a 1-bit wide vertical line of the tile.
 *
 * The display can be updated at a tile granularity.
 *
 *       Chip 1           Chip 2           Chip 3           Chip 4
 * +----------------+----------------+----------------+----------------+
 * |     Tile 1     |     Tile 1     |     Tile 1     |     Tile 1     |
 * +----------------+----------------+----------------+----------------+
 * |     Tile 2     |     Tile 2     |     Tile 2     |     Tile 2     |
 * +----------------+----------------+----------------+----------------+
 *                                  ...
 * +----------------+----------------+----------------+----------------+
 * |     Tile 8     |     Tile 8     |     Tile 8     |     Tile 8     |
 * +----------------+----------------+----------------+----------------+
 */
#define PICOLCDFB_NAME "picolcdfb"
#define PICOLCDFB_WIDTH (256)
#define PICOLCDFB_HEIGHT (64)
#define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8)

#define PICOLCDFB_UPDATE_RATE_LIMIT   10
#define PICOLCDFB_UPDATE_RATE_DEFAULT  2

/* Framebuffer visual structures */
static const struct fb_fix_screeninfo picolcdfb_fix = {
 .id          = PICOLCDFB_NAME,
 .type        = FB_TYPE_PACKED_PIXELS,
 .visual      = FB_VISUAL_MONO01,
 .xpanstep    = 0,
 .ypanstep    = 0,
 .ywrapstep   = 0,
 .line_length = PICOLCDFB_WIDTH / 8,
 .accel       = FB_ACCEL_NONE,
};

static const struct fb_var_screeninfo picolcdfb_var = {
 .xres           = PICOLCDFB_WIDTH,
 .yres           = PICOLCDFB_HEIGHT,
 .xres_virtual   = PICOLCDFB_WIDTH,
 .yres_virtual   = PICOLCDFB_HEIGHT,
 .width          = 103,
 .height         = 26,
 .bits_per_pixel = 1,
 .grayscale      = 1,
 .red            = {
  .offset = 0,
  .length = 1,
  .msb_right = 0,
 },
 .green          = {
  .offset = 0,
  .length = 1,
  .msb_right = 0,
 },
 .blue           = {
  .offset = 0,
  .length = 1,
  .msb_right = 0,
 },
 .transp         = {
  .offset = 0,
  .length = 0,
  .msb_right = 0,
 },
};

/* Send a given tile to PicoLCD */
static int picolcd_fb_send_tile(struct picolcd_data *data, u8 *vbitmap,
  int chip, int tile)
{
 struct hid_report *report1, *report2;
 unsigned long flags;
 u8 *tdata;
 int i;

 report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev);
 if (!report1 || report1->maxfield != 1)
  return -ENODEV;
 report2 = picolcd_out_report(REPORT_LCD_DATA, data->hdev);
 if (!report2 || report2->maxfield != 1)
  return -ENODEV;

 spin_lock_irqsave(&data->lock, flags);
 if ((data->status & PICOLCD_FAILED)) {
  spin_unlock_irqrestore(&data->lock, flags);
  return -ENODEV;
 }
 hid_set_field(report1->field[0],  0, chip << 2);
 hid_set_field(report1->field[0],  1, 0x02);
 hid_set_field(report1->field[0],  2, 0x00);
 hid_set_field(report1->field[0],  3, 0x00);
 hid_set_field(report1->field[0],  4, 0xb8 | tile);
 hid_set_field(report1->field[0],  5, 0x00);
 hid_set_field(report1->field[0],  6, 0x00);
 hid_set_field(report1->field[0],  7, 0x40);
 hid_set_field(report1->field[0],  8, 0x00);
 hid_set_field(report1->field[0],  9, 0x00);
 hid_set_field(report1->field[0], 10,   32);

 hid_set_field(report2->field[0],  0, (chip << 2) | 0x01);
 hid_set_field(report2->field[0],  1, 0x00);
 hid_set_field(report2->field[0],  2, 0x00);
 hid_set_field(report2->field[0],  3,   32);

 tdata = vbitmap + (tile * 4 + chip) * 64;
 for (i = 0; i < 64; i++)
  if (i < 32)
   hid_set_field(report1->field[0], 11 + i, tdata[i]);
  else
   hid_set_field(report2->field[0], 4 + i - 32, tdata[i]);

 hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT);
 hid_hw_request(data->hdev, report2, HID_REQ_SET_REPORT);
 spin_unlock_irqrestore(&data->lock, flags);
 return 0;
}

/* Translate a single tile*/
static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp,
  int chip, int tile)
{
 int i, b, changed = 0;
 u8 tdata[64];
 u8 *vdata = vbitmap + (tile * 4 + chip) * 64;

 if (bpp == 1) {
  for (b = 7; b >= 0; b--) {
   const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32;
   for (i = 0; i < 64; i++) {
    tdata[i] <<= 1;
    tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01;
   }
  }
 } else if (bpp == 8) {
  for (b = 7; b >= 0; b--) {
   const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8;
   for (i = 0; i < 64; i++) {
    tdata[i] <<= 1;
    tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00;
   }
  }
 } else {
  /* Oops, we should never get here! */
  WARN_ON(1);
  return 0;
 }

 for (i = 0; i < 64; i++)
  if (tdata[i] != vdata[i]) {
   changed = 1;
   vdata[i] = tdata[i];
  }
 return changed;
}

void picolcd_fb_refresh(struct picolcd_data *data)
{
 if (data->fb_info)
  schedule_delayed_work(&data->fb_info->deferred_work, 0);
}

/* Reconfigure LCD display */
int picolcd_fb_reset(struct picolcd_data *data, int clear)
{
 struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev);
 struct picolcd_fb_data *fbdata = data->fb_info->par;
 int i, j;
 unsigned long flags;
 static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 };

 if (!report || report->maxfield != 1)
  return -ENODEV;

 spin_lock_irqsave(&data->lock, flags);
 for (i = 0; i < 4; i++) {
  for (j = 0; j < report->field[0]->maxusage; j++)
   if (j == 0)
    hid_set_field(report->field[0], j, i << 2);
   else if (j < sizeof(mapcmd))
    hid_set_field(report->field[0], j, mapcmd[j]);
   else
    hid_set_field(report->field[0], j, 0);
  hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 }
 spin_unlock_irqrestore(&data->lock, flags);

 if (clear) {
  memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE);
  memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp);
 }
 fbdata->force = 1;

 /* schedule first output of framebuffer */
 if (fbdata->ready)
  schedule_delayed_work(&data->fb_info->deferred_work, 0);
 else
  fbdata->ready = 1;

 return 0;
}

/* Update fb_vbitmap from the screen_buffer and send changed tiles to device */
static void picolcd_fb_update(struct fb_info *info)
{
 int chip, tile, n;
 unsigned long flags;
 struct picolcd_fb_data *fbdata = info->par;
 struct picolcd_data *data;

 mutex_lock(&info->lock);

 spin_lock_irqsave(&fbdata->lock, flags);
 if (!fbdata->ready && fbdata->picolcd)
  picolcd_fb_reset(fbdata->picolcd, 0);
 spin_unlock_irqrestore(&fbdata->lock, flags);

 /*
  * Translate the framebuffer into the format needed by the PicoLCD.
  * See display layout above.
  * Do this one tile after the other and push those tiles that changed.
  *
  * Wait for our IO to complete as otherwise we might flood the queue!
 */
 n = 0;
 for (chip = 0; chip < 4; chip++)
  for (tile = 0; tile < 8; tile++) {
   if (!fbdata->force && !picolcd_fb_update_tile(
     fbdata->vbitmap, fbdata->bitmap,
     fbdata->bpp, chip, tile))
    continue;
   n += 2;
   if (n >= HID_OUTPUT_FIFO_SIZE / 2) {
    spin_lock_irqsave(&fbdata->lock, flags);
    data = fbdata->picolcd;
    spin_unlock_irqrestore(&fbdata->lock, flags);
    mutex_unlock(&info->lock);
    if (!data)
     return;
    hid_hw_wait(data->hdev);
    mutex_lock(&info->lock);
    n = 0;
   }
   spin_lock_irqsave(&fbdata->lock, flags);
   data = fbdata->picolcd;
   spin_unlock_irqrestore(&fbdata->lock, flags);
   if (!data || picolcd_fb_send_tile(data,
     fbdata->vbitmap, chip, tile))
    goto out;
  }
 fbdata->force = false;
 if (n) {
  spin_lock_irqsave(&fbdata->lock, flags);
  data = fbdata->picolcd;
  spin_unlock_irqrestore(&fbdata->lock, flags);
  mutex_unlock(&info->lock);
  if (data)
   hid_hw_wait(data->hdev);
  return;
 }
out:
 mutex_unlock(&info->lock);
}

static int picolcd_fb_blank(int blank, struct fb_info *info)
{
 /* We let fb notification do this for us via lcd/backlight device */
 return 0;
}

static void picolcd_fb_destroy(struct fb_info *info)
{
 struct picolcd_fb_data *fbdata = info->par;

 /* make sure no work is deferred */
 fb_deferred_io_cleanup(info);

 /* No thirdparty should ever unregister our framebuffer! */
 WARN_ON(fbdata->picolcd != NULL);

 vfree((u8 *)info->fix.smem_start);
 framebuffer_release(info);
}

static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
{
 __u32 bpp      = var->bits_per_pixel;
 __u32 activate = var->activate;

 /* only allow 1/8 bit depth (8-bit is grayscale) */
 *var = picolcdfb_var;
 var->activate = activate;
 if (bpp >= 8) {
  var->bits_per_pixel = 8;
  var->red.length     = 8;
  var->green.length   = 8;
  var->blue.length    = 8;
 } else {
  var->bits_per_pixel = 1;
  var->red.length     = 1;
  var->green.length   = 1;
  var->blue.length    = 1;
 }
 return 0;
}

static int picolcd_set_par(struct fb_info *info)
{
 struct picolcd_fb_data *fbdata = info->par;
 u8 *tmp_fb, *o_fb;
 if (info->var.bits_per_pixel == fbdata->bpp)
  return 0;
 /* switch between 1/8 bit depths */
 if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8)
  return -EINVAL;

 o_fb   = fbdata->bitmap;
 tmp_fb = kmalloc_array(PICOLCDFB_SIZE, info->var.bits_per_pixel,
          GFP_KERNEL);
 if (!tmp_fb)
  return -ENOMEM;

 /* translate FB content to new bits-per-pixel */
 if (info->var.bits_per_pixel == 1) {
  int i, b;
  for (i = 0; i < PICOLCDFB_SIZE; i++) {
   u8 p = 0;
   for (b = 0; b < 8; b++) {
    p <<= 1;
    p |= o_fb[i*8+b] ? 0x01 : 0x00;
   }
   tmp_fb[i] = p;
  }
  memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
  info->fix.visual = FB_VISUAL_MONO01;
  info->fix.line_length = PICOLCDFB_WIDTH / 8;
 } else {
  int i;
  memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE);
  for (i = 0; i < PICOLCDFB_SIZE * 8; i++)
   o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00;
  info->fix.visual = FB_VISUAL_DIRECTCOLOR;
  info->fix.line_length = PICOLCDFB_WIDTH;
 }

 kfree(tmp_fb);
 fbdata->bpp = info->var.bits_per_pixel;
 return 0;
}

static void picolcdfb_ops_damage_range(struct fb_info *info, off_t off, size_t len)
{
 if (!info->par)
  return;
 schedule_delayed_work(&info->deferred_work, 0);
}

static void picolcdfb_ops_damage_area(struct fb_info *info, u32 x, u32 y, u32 width, u32 height)
{
 if (!info->par)
  return;
 schedule_delayed_work(&info->deferred_work, 0);
}

FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(picolcdfb_ops,
       picolcdfb_ops_damage_range,
       picolcdfb_ops_damage_area)

static const struct fb_ops picolcdfb_ops = {
 .owner        = THIS_MODULE,
 FB_DEFAULT_DEFERRED_OPS(picolcdfb_ops),
 .fb_destroy   = picolcd_fb_destroy,
 .fb_blank     = picolcd_fb_blank,
 .fb_check_var = picolcd_fb_check_var,
 .fb_set_par   = picolcd_set_par,
};


/* Callback from deferred IO workqueue */
static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagereflist)
{
 picolcd_fb_update(info);
}

static const struct fb_deferred_io picolcd_fb_defio = {
 .delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT,
 .deferred_io = picolcd_fb_deferred_io,
};


/*
 * The "fb_update_rate" sysfs attribute
 */
static ssize_t picolcd_fb_update_rate_show(struct device *dev,
  struct device_attribute *attr, char *buf)
{
 struct picolcd_data *data = dev_get_drvdata(dev);
 struct picolcd_fb_data *fbdata = data->fb_info->par;
 unsigned i, fb_update_rate = fbdata->update_rate;
 size_t ret = 0;

 for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++)
  if (i == fb_update_rate)
   ret += sysfs_emit_at(buf, ret, "[%u] ", i);
  else
   ret += sysfs_emit_at(buf, ret, "%u ", i);
 if (ret > 0)
  buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
 return ret;
}

static ssize_t picolcd_fb_update_rate_store(struct device *dev,
  struct device_attribute *attr, const char *buf, size_t count)
{
 struct picolcd_data *data = dev_get_drvdata(dev);
 struct picolcd_fb_data *fbdata = data->fb_info->par;
 int i;
 unsigned u;

 if (count < 1 || count > 10)
  return -EINVAL;

 i = sscanf(buf, "%u", &u);
 if (i != 1)
  return -EINVAL;

 if (u > PICOLCDFB_UPDATE_RATE_LIMIT)
  return -ERANGE;
 else if (u == 0)
  u = PICOLCDFB_UPDATE_RATE_DEFAULT;

 fbdata->update_rate = u;
 data->fb_info->fbdefio->delay = HZ / fbdata->update_rate;
 return count;
}

static DEVICE_ATTR(fb_update_rate, 0664, picolcd_fb_update_rate_show,
  picolcd_fb_update_rate_store);

/* initialize Framebuffer device */
int picolcd_init_framebuffer(struct picolcd_data *data)
{
 struct device *dev = &data->hdev->dev;
 struct fb_info *info = NULL;
 struct picolcd_fb_data *fbdata = NULL;
 int i, error = -ENOMEM;
 u32 *palette;

 /* The extra memory is:
  * - 256*u32 for pseudo_palette
  * - struct fb_deferred_io
 */
 info = framebuffer_alloc(256 * sizeof(u32) +
   sizeof(struct fb_deferred_io) +
   sizeof(struct picolcd_fb_data) +
   PICOLCDFB_SIZE, dev);
 if (!info)
  goto err_nomem;

 info->fbdefio = info->par;
 *info->fbdefio = picolcd_fb_defio;
 info->par += sizeof(struct fb_deferred_io);
 palette = info->par;
 info->par += 256 * sizeof(u32);
 for (i = 0; i < 256; i++)
  palette[i] = i > 0 && i < 16 ? 0xff : 0;
 info->pseudo_palette = palette;
 info->fbops = &picolcdfb_ops;
 info->var = picolcdfb_var;
 info->fix = picolcdfb_fix;
 info->fix.smem_len   = PICOLCDFB_SIZE*8;

#ifdef CONFIG_FB_BACKLIGHT
#ifdef CONFIG_HID_PICOLCD_BACKLIGHT
 info->bl_dev = data->backlight;
#endif
#endif

#ifdef CONFIG_HID_PICOLCD_LCD
 info->lcd_dev = data->lcd;
#endif

 fbdata = info->par;
 spin_lock_init(&fbdata->lock);
 fbdata->picolcd = data;
 fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
 fbdata->bpp     = picolcdfb_var.bits_per_pixel;
 fbdata->force   = 1;
 fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data);
 fbdata->bitmap  = vmalloc(PICOLCDFB_SIZE*8);
 if (fbdata->bitmap == NULL) {
  dev_err(dev, "can't get a free page for framebuffer\n");
  goto err_nomem;
 }
 info->flags |= FBINFO_VIRTFB;
 info->screen_buffer = fbdata->bitmap;
 info->fix.smem_start = (unsigned long)fbdata->bitmap;
 memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE);
 data->fb_info = info;

 error = picolcd_fb_reset(data, 1);
 if (error) {
  dev_err(dev, "failed to configure display\n");
  goto err_cleanup;
 }

 error = device_create_file(dev, &dev_attr_fb_update_rate);
 if (error) {
  dev_err(dev, "failed to create sysfs attributes\n");
  goto err_cleanup;
 }

 fb_deferred_io_init(info);
 error = register_framebuffer(info);
 if (error) {
  dev_err(dev, "failed to register framebuffer\n");
  goto err_sysfs;
 }
 return 0;

err_sysfs:
 device_remove_file(dev, &dev_attr_fb_update_rate);
 fb_deferred_io_cleanup(info);
err_cleanup:
 data->fb_info    = NULL;

err_nomem:
 if (fbdata)
  vfree(fbdata->bitmap);
 framebuffer_release(info);
 return error;
}

void picolcd_exit_framebuffer(struct picolcd_data *data)
{
 struct fb_info *info = data->fb_info;
 struct picolcd_fb_data *fbdata;
 unsigned long flags;

 if (!info)
  return;

 device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate);
 fbdata = info->par;

 /* disconnect framebuffer from HID dev */
 spin_lock_irqsave(&fbdata->lock, flags);
 fbdata->picolcd = NULL;
 spin_unlock_irqrestore(&fbdata->lock, flags);

 /* make sure there is no running update - thus that fbdata->picolcd
  * once obtained under lock is guaranteed not to get free() under
 * the feet of the deferred work */
 flush_delayed_work(&info->deferred_work);

 data->fb_info = NULL;
 unregister_framebuffer(info);
}