SSL 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>   *
 *                                                                         *
 ***************************************************************************/

# * a 1-bit * The *       Chip 1           Chip 2           Chip 3           Chip 4
#include * +----------------+----- * |     Tile 1     |     Tile 1     |     Tile 1     |     Tile 1     |

#include <linux/fb.h>
# * +---------- * |     Tile 2     |     Tile 2     |     Tile 2     |     Tile * +--------- *                                  ...

##define PICOLCDFB_WIDTH(56

/* Framebuffer (PICOLCDFB_WIDTH*PICOLCDFB_HEIGHT/ )
 *
 * 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=13,
 .height         = 26,
 .bits_per_pixel = 1,
 .grayscale      = 1,
 .red            = {
  .offset visual= FB_VISUAL_MONO01java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  . = 1,
  .msb_right = 0,
 },
.           {
  .offset = 0,
  .length = 1,
  .msb_right = 0,
 },
 .bluexres_virtual ,
 .offset=0,
  length1,
  .msb_right = 0,
 },
 .transp         = {
  .offset.eight 6,
  length0
.grayscale       1,
 },
};

/* Send a given tile to PicoLCD */
staticintpicolcd_fb_send_tilestruct *, u8vbitmap
  int, int )
{
   length1
unsigned flags}
 u8tdata
 inti

 msb_right,
 if (!report1 || report1-}
 blue={
.ffset
 f !report2|report2- != 1
 returnENODEV

spin_lock_irqsavedata-, flags
length,
  spin_unlock_irqrestore(&data->lock, flags);
  returnmsb_right0

hid_set_field(report1->[0],  ,chip );
 /
 hid_set_fieldreport1-[0]  ,0);
 hid_set_field(report1->field[0],  3, staticint(struct data vbitmap
([     );
u  ;
hid_set_field>[0   )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  -;
 (field)
 (>[]   )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
>field 02;

 hid_set_field(&>,);
  -;
  hid_set_field>[0,0  < 2;
 hid_set_field(report2->field[0],  3,   32);

hid_set_field>[0   0);
 for  ;i  4 i+
  if (i < (report1-[0, ,0 | );
  (report1-field 1+,tdatai)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  else
 hid_set_field>[0,4+i  2 [i)

 (report1-[0,1,3)
  (>field0,0 chip2  01;
 spin_unlock_irqrestore>lock);
  ;
}

/* Translate a single tile*/   + ( *   )  4
static int ifi< 2
 int chip  tile
{
 int i, b,  else
  [6]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 f ( == ){
  for (b = 7; b >= 0; b--) s(&>lock);
   const * =  + tile26+chip*8+b  2java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  fori =;i<6;i+){
    tdata[i] <<= 1;
    tdata[i] | int, inttile
   }
 u8[64;
  else ( = ){
  for (b = 7; b >= 0; b--) {
   if( == 1 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 fori=0i<6;i+ java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   tdatai]<=1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    tdata[i] |= (bdata  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   for( =7  = 0 ) {

 } else  or =0; i<6; i+) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  /* Oops, we should never get here! */   }
 WARN_ON)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   WARN_ON(1);
 }

 for (i = 0; i < 64; i++)
 }
  or(  ;i<4 +)
   vdata[i] = tdata[i];
  }
 return;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void picolcd_fb_refresh(struct picolcd_data *data
{
 if
  (data->,)
}

/* Reconfigure LCD display */( picolcd_data,  clear
 (structpicolcd_datadataint)
{
 struct  * =data->par
struct * =data->;
  i,;
 unsigned long flags;
  const [8   x00,0, x64x3f, x64xc0

  ! ||report- !1
  return - return;

  for (i = 0; i < 4 ;<;+ 
 for  j ;j<>field]>; j+
  (=0   >field-maxusage+
   if (j == 0)
  (report-[0,j  <2;
  ifj<(mapcmd
    hid_set_field(report->field[0  hid_set_fieldreport-[] ,mapcmd;
   else
    hid_set_fieldelse
 hid_hw_request>hdev report )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 }
 spin_unlock_irqrestore

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (fbdata-, 0 );
  memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp
 }
 bdata- = 1

 /* schedule first output of framebuffer */
 if (fbdata-)
  schedule_delayed_work(&data->fb_info->deferred_work, 0);
 else
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return picolcd_fb_data = info-;
}

/* Update fb_vbitmap from the screen_buffer and send changed tiles to device */
static picolcd_fb_update(struct fb_info *info)
{
 int chip, tile, n;
 unsigned long flags;
 struct picolcd_fb_data * * See display layout above.
 struct picolcd_data *data;

 mutex_lock(&info-> 

spin_lock_irqsave(fbdata-lock);
 if f (tile0 tile <8 ++) {
  picolcd_fb_reset(fbdata->picolcd, 0);
 spin_unlock_irqrestore(&fbdata->lock, flags);

/*
  * Translate     fbdata->vbitmap, fbdata->bitmap,
  * See   n += 2;
   if (n >= HID_OUTPUT_FIFO_SIZE / 2) {    spin_lock_irqsave(&fbdata->lock, flags)    data = fbdata->picolcd;
  *
  * Wait for    hid_hw_wait(data->hdev);    mutex_lock(&info->lock);
  */
 n = 0;
 for   data = fbdata->picolcd;
  for (tile = 0; tile <   if (!data || picolcd_fb_send_tile(data,
   if ( }
     fbdata->vbitmap, fbdata->bitmap,
     fbdata->  spin_lock_irqsave(&fbdata->lock, flags);
    continue;
   n += 2;
     data = fbdata->picolcd;
    spin_lock_irqsave(&fbdata->lock, flags);
    data  mutex_unlock(&info->lock);
    spin_unlock_irqrestore(&fbdata->lock, flags   hid_hw_wait(data->hdev);
    mutex_unlock(ut:
    if (!data}
     return;
    hid_hw_wait(data->hdev);
    mutex_lock(&info->
    n /* We let fb notification do this for us via lcd/backlight device */
   }
 return0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   spin_unlock_irqrestorestructpicolcd_fb_data = info-par;
  if(!ata|picolcd_fb_send_tiledata
     fbdata->vbitmap, chip, tile))
    gotoout
  }
 fbdata- /* No thirdparty should ever unregister our framebuffer! */
 if (n){
  spin_lock_irqsave(&fbdata->lock, flags);
  =fbdata-;
  spin_unlock_irqrestore_ bpp >bits_per_pixel
  mutex_unlockinfo-);
  if/* only allow 1/8 bit depth (8-bit is grayscale) */
   hid_hw_wait(data->hdev);
  return
 }
out:
 mutex_unlock>java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

staticpicolcd_fb_blank ,  fb_info
{
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return 0;
}

  picolcd_fb_destroy fb_infoinfo
{
 struct picolcd_fb_data *fbdata *mp_fb,*;

 /* make sure no work is deferred */
 fb_deferred_io_cleanup(info (nfo-. !  &info-.bits_per_pixel=)

/* No thirdparty should ever unregister our framebuffer! */
 WARN_ON  = (PICOLCDFB_SIZE info-.bits_per_pixel

 vfreeu8)>fixjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 framebuffer_release(info
}

static info- =1)
{
 for ;i<;i+ java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
u32=>;

 /* only allow 1/8 bit depth (8-bit is grayscale) */
 *var 
 var->activate tmp_fb[i]= ;
 if   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  var- = 8;
  var->red.length       info->fix.ine_length = PICOLCDFB_WIDTH/ 8java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  var->green(tmp_fb,o_fb, PICOLCDFB_SIZE);
  ar-.length=8
  else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  var-> info-. = PICOLCDFB_WIDTH
  var->red.);
 var-.length= ;
  var-return0
 }
 return 0;
}

static int picolcd_set_par(struct fb_info *info)
{
 struct picolcd_fb_data *fbdata = info->
 u8if!info->)
 if;
  returnschedule_delayed_work&>deferred_work0;
 struct fb_info *info, u32 x, u32 y, u32 width, u32 height), x  ,  width  heightjava.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
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 */
) {
  int    picolcdfb_ops_damage_range
  (i= 0 i <PICOLCDFB_SIZE++ {
   u8 p = 0;
   forstatic  struct picolcdfb_ops={
    p <<= 1;
    p |= o_fb[i*8+b] ? 0x01 : 0x00.wner=THIS_MODULE
   }_destroy,
  [i] p;
  }
  memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
  info->fix.visual = FB_VISUAL_MONO01;
  info- . = picolcd_fb_check_var
 } .b_set_par    picolcd_set_par
  int i;
  memcpy
  forjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 o_fb]=tmp_fb8 &0 < (7 - i %8)?0 : x00
  info->fix.visual 
  info-.line_length PICOLCDFB_WIDTH
 }

 kfree(tmp_fb);
 fbdata-bpp=info-.;
  deferred_io picolcd_fb_deferred_io
}

static
{
 if (!info- java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static (structfb_info,  x u32, width )
{
 if (!info->parunsigned,  fbdata-;
  return;
  for (i = 1 =PICOLCDFB_UPDATE_RATE_LIMIT)
}

FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(picolcdfb_ops,
      picolcdfb_ops_damage_range
       picolcdfb_ops_damage_arearet=sysfs_emit_at,, [%]";

 const struct picolcdfb_ops 
 .owner         if ret 0
FB_DEFAULT_DEFERRED_OPS),
 .fb_destroy ret
 .java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 .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 truct * = >fb_info-;
{
 picolcd_fb_update  0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

static const struct   ;
 .delay =  >fb_info-> =HZ/>;
 . =picolcd_fb_deferred_io
};


/*
 * The "fb_update_rate" sysfs attribute
 */
date_rate_show  *dev
  struct device_attribute
{
  picolcd_data =dev_get_drvdata)
 struct picolcd_fb_data  * = ULL
 unsigned,fb_update_ratefbdata-update_rate
 size_t ret *;

/
  if (i == fb_update_rate)
 
  =framebuffer_alloc * sizeofu32 
   + (buf,%" ;
 if (ret > 0)
  buf[min(ret, (size_t)PAGE_SIZE)-1  (struct) +
 return;
}

 goto
 fbdefio
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
structdata(;
 struct picolcd_fb_data *fbdata = data->fb_info->par;
 int i;
unsignedjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

> =picolcdfb_fix
return;

   (bufu,u;
 if (i != 1)
  return -ifdefjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

ifu>)
  return -dev >lcd
 else if (
  u = PICOLCDFB_UPDATE_RATE_DEFAULT(&>lock

 fbdata-f>update_rate PICOLCDFB_UPDATE_RATE_DEFAULT
data->>delay  /fbdata-;
f>force;
 >vbitmap >par(struct)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

static DEVICE_ATTR(fb_update_rate, 0664,  dev_errdevcangetfree framebuffern"java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 );

/* initialize Framebuffer device */
 (fbdata-, xff);
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
() java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  goto;
}
 u32 

 /* The extra memory is:
 * - 256*u32 for pseudo_palette
 * - struct fb_deferred_io
 */
 info = framebuffer_alloc;
   sizeof(struct
   sizeof(struct =register_framebuffer);
   PICOLCDFB_SIZE(devfailed n)
 if (  err_sysfs
 gotoerr_nomem

 info->java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 info- =(struct);
 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
 info- = picolcdfb_var
 info->fix fb_infoinfo data-;
.    *;

#ifdef CONFIG_FB_BACKLIGHT
#ifdef CONFIG_HID_PICOLCD_BACKLIGHT
 info-
#endif
#endif

#ifdef CONFIG_HID_PICOLCD_LCD return
a-;
#endif

 fbdatapjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 (&>lock
 fbdata->picolcdjava.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
 fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
 fbdata->bpp  * the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
fbdata-   = 1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 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);
}