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

# *   Copyright *                                                                         *
#include <linux/vmalloc.h>

#*   Based on Logitech G13 driver (v0.4)                                   *
#include <linux *                                                                         *

#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
  (6

DFB_SIZE *  8

#define 
# * The PicoLCD use a Topway * This display area is * each. Each tile has 8 * a 1-bit wide vertical line * The display can be  *       Chip 1           Chip 2           Chip 3           Chip 4

/* Framebuffer visual structures */
static * |     Tile 8     | * +---- java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ,
.           0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
.       ,
 .xpanstep    = 0,
 .ypanstep    = 0,
 .ywrapstep   = 0,
 .line_length = PICOLCDFB_WIDTH / 8,
 .accel       = FB_ACCEL_NONE,
};

static const struct fb_var_screeninfo picolcdfb_var = {
 .xres           =  length
 green=java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 .   =PICOLCDFB_WIDTH
 .offset  ,
. = 1java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 .         =2,
 . = 0
 grayscale=1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 .redstatic  picolcd_fb_send_tile( picolcd_datadata *,
  .offset   int chipinttile
  . = ,
  long;
 ,
 .green *;
  .offsetint ;
  .length
 . = 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
.           ={
  . = 0,
  i ( | >maxfield1
   -;
 },
 .
   (&>lock);
  . = 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  . = ,
 },
}hid_set_fieldreport1-field0  << 2;

/* Send a given tile to PicoLCD */(>field,2 x00
static  picolcd_fb_send_tile picolcd_data*, u8 *,
  int chip, int tile)
{
 struct hid_set_fieldreport1->field0],  4,0xb8|tile;
 nsignedlongflags
 u8 * hid_set_field(report1->field0,  6,0x00);
 int i;

 report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev);
 if (!report1 || report1->maxfield != 1)
 return-NODEV
  hid_set_fieldhid_set_field(eport1->field[0],  8, 0x00)
 if (!report2 hid_set_fieldreport1-field0]  9,0x00;
  return -ENODEV;

 spin_lock_irqsave(&data->lock, flags);
 if ((data->status &  hid_set_field(report1-field[0],1,   3);
  spin_unlock_irqrestore&ata-lock flags
  return-NODEV
 }
 (report1-field]  , chip<2)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 hid_set_field
 hid_set_field(report1-field0,2,0x00
 hid_set_fieldfor (i=0 i <6; +)
hid_set_field>field] 4 xb8tile
 hid_set_field(report1->field[0],  5,  hid_set_fieldreport1->[0],1 +i tdata[];
 hid_set_field(report1->field[0],  6, 0x00);
 hid_set_field(report1->field[0],  7, 0x40);
 hid_set_field else
 hid_set_field  hid_set_field(report2-field]    -3,tdata];
 hid_set_fieldreport1->field] 0,   2;

 hid_set_fieldreport2-field[0]  ,( << 2)|00)
 hid_set_field(report2-spin_unlock_irqrestore(&data-, flags;
 return0
 /

 tdata=vbitmaptile4+chip*6;
 for (i = 0; i < 64; i++)
  if ( < 3)
   hid_set_field(report1->field[0], 11 + i, int chip,int)
 else
   hid_set_field(report2->field[0], 4 u8tdata4;

 hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT);
 i bpp= 1 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 pin_unlock_irqrestoredata-, flags
 return 0;
}

/* Translate a single tile*/ u8bdatabitmap * 25  chip    *3;
static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int  ( =0   64 + 
   chipint )
{
 int i, b, changed = 0;
 u8 tdata4;
 }else ifbpp=8 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 if bpp=) {
  for (b = 7; b >= 0; b--) {
      (  ;   4 +){
   for (i = 0; i < 64; i++) {
  tdata[] < ;
    tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01;
   }
  }
 } else if (bpp == 8) {
 for b 7;b > ;b--
   const 
  f (i =0; i  4 +{
    tdata[i] <<= 1;
    tdata
}
  }
 } (1;
  /* Oops, we should never get here! */
 ARN_ONjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  return 0;
}

for i=0 i  6;i+java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  if changed
  }
   vdata[i] = tdata[i];
  }
 return changed;
}

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if (data->fb_info)
  schedule_delayed_work
}

/* Reconfigure LCD display */ schedule_delayed_work&>fb_info-deferred_work 0;
int picolcd_fb_reset(struct *dataintclear)
{
intpicolcd_fb_reset picolcd_data *, int clear
picolcd_fb_data*bdata >fb_info-par;
   picolcd_fb_data*bdata >fb_info-par
 inti, jjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 staticstatic u8mapcmd]={0, 0x02 x000, 0, 0x000, 0 };

 if  if(report >maxfield! )
   -ENODEV

 spin_lock_irqsave(&data-
 for (i =0 i  4;i+){
 for( =0 j  report-field[0-maxusagej+)
   if  for(  ; j <report-field[0]>maxusage; j++
    hid_set_field>field0] ,i< 2;
     elseif (  sizeof))
   hid_set_field(>field0, j [j])java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   else
 (data-hdev, report, HID_REQ_SET_REPORT;
  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

 /* schedule first output of framebuffer */
 if (fbdata->ready)
  schedule_delayed_work(&data-memset>vbitmap0PICOLCDFB_SIZEjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 else
  fbdata- >force ;

 return 0;
}

/* Update fb_vbitmap from the screen_buffer and send changed tiles to device */>ready
staticelse
{
 int chip, tile, n;
 unsigned long flags;
 struct *fbdata>par
 struct picolcd_data

 mutex_lock/* Update fb_vbitmap from the screen_buffer and send changed tiles to device */

 spin_lock_irqsave(&fbdata- voidjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 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!
 */
 
  spin_lock_irqsave&>, flags
  or = ;tile<8tile) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   if /*
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 */
 ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void picolcd_fb_destroy(struct fb_info *info)
{
 struct  *fbdata>par

 /* make sure no work is deferred */  ! || (,
 fb_deferred_io_cleanup(info  ;

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 if()java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

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

data >picolcd
{
 _u32      = var-;
 __u32(&>lock

 /* only allow 1/8 bit depth (8-bit is grayscale) */
 *var = picolcdfb_var;
 var->activate;
 if}
  var->bits_per_pixel(&info-lock);
  var->red.length     = 8;
  var->green.length   = 8;
  var->blue.length    = 8;
 } else {
  var->bits_per_pixel }
  var->red.length     = 1;
  var->green.length   = 1;
  var-static int picolcd_fb_blank(int blankstruct *info)
 }
 return 0;
}

static int picolcd_set_par(struct fb_info *info)
{
 struct picolcd_fb_datastatic voidpicolcd_fb_destroy(structfb_info *)
 u8 *mp_fb o_fb
 if (info->
  return 0;
 /* switch between 1/8 bit depths */
 if(>varbits_per_pixel=1& >var ! 8
  return -

 o_fb   = fbdata->bitmap;
tmp_fbkmalloc_array, >var,
          GFP_KERNEL vfree(( *info-.smem_start);
 if (!tmp_fb)
  return -ENOMEM;

 /* translate FB content to new bits-per-pixel */
 if(>var.bits_per_pixel= 1){
  int i, b;{
  (i =0;  <PICOLCDFB_SIZE +) {
   u8 p = 0;
   for (b = 0; b < 8; b++) {
   __u32 activate  var-activate
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  tmp_fbi p
 }
  memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
  info->bits_per_pixel8;
 >  /;
 } else {
  int i;
  memcpy  PICOLCDFB_SIZE
v>blue     ;
 }else{
  info->fix.visual = FB_VISUAL_DIRECTCOLOR;
 >fixline_length;
 }

fb
   >green   = 1
 return ;
}

static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  (info-par
eturn
 schedule_delayed_work(info-, )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}

static void picolcdfb_ops_damage_area(structa(struct fb_info *info u32x,u32 y,u32,u32)
{
 if (!info->par)
  return;
 schedule_delayed_work(&info- if (info->var.bits_per_pixel != 1 && info-  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS
    ,
    for  ;i< ; i+ {

staticconst fb_ops  java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 .wner         ,
 FB_DEFAULT_DEFERRED_OPS(picolcdfb_ops),
_   = picolcd_fb_destroy
   tmp_fb]=java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
fb_check_var,
.b_set_par=,
};


/* Callback from deferred IO workqueue */
static void picolcd_fb_deferred_io(struct fb_info *  [i]  [i/8 &(x01< )  xff0;

 picolcd_fb_update>fix = ;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>bpp  >varbits_per_pixel
. =,
};


/*
 * The "fb_update_rate" sysfs attribute
 */
static ssize_t picolcd_fb_update_rate_show(struct device *dev,
  struct 
{
 struct picolcd_data *data = dev_get_drvdata(dev);
 struct picolcd_fb_data voidpicolcdfb_ops_damage_areastruct  *info u32,  y,u32, u32height
  i,fb_update_rate=fbdata->update_rate
 size_t ret = 0;

; i<= ; i++java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  if (i i     picolcdfb_ops_damage_range,
   ret + sysfs_emit_at(buf ret"u " i)
  else
   ret +staticconst  fb_ops ={
 if( > 0
  buf (picolcdfb_ops
 return;
}

static ssize_t = picolcd_fb_check_var
  struct}
{
 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
s picolcd_fb_data*bdata data-fb_info->par
 int i;
 unsigned u;

count>1)
  return -EINVAL;

 i = sscanf(buf, "%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->fbdefio-delay HZ /fbdata-update_rate
 returndeferred_io ,
}

static DEVICE_ATTR
  picolcd_fb_update_rate_store);

/* initialize Framebuffer device */
int static ssize_t picolcd_fb_up(structdevicedev,
{
 struct device {
 struct fb_info *infostruct *data (dev;
 structpicolcd_fb_datafbdataN;
 int i, error = unsigned i  = fbdata->;
 u32palette

 /* The extra memory is:
 * - 256*u32 for pseudo_palette
 * - struct fb_deferred_io
 */
info (256* sizeof(u32) +
   sizeof(struct ret=sysfs_emit_at, ret "u ,i)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 sizeofstruct picolcd_fb_data+
   PICOLCDFB_SIZE ret
 if (!info)
  goto err_nomem;

 info-> = info->par;
 *info-{
 info->par += sizeof(struct fb_deferred_io);
 palette = info->par;
 info->par +=  picolcd_data * = dev_get_drvdatadev)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 for (i = 0; i < 256; i++)
    u;
 info->pseudo_palette = palette;
 info->fbops = &picolcdfb_ops;
 info-
 info-fix ;
 info->fix   -EINVAL

#ifdefi= sscanf, "%" &)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
# CONFIG_HID_PICOLCD_BACKLIGHT
 info->bl_dev = data->backlight;
#endif
#endif

 if (  PICOLCDFB_UPDATE_RATE_LIMIT
_dev =data-;
#endif

 fbdata = info->par;
 spin_lock_init&bdata-);
 fbdata-
 bdata- = ;
 fbdata- data->fb_info-fbdefio-delay =HZ/>update_rate
 bdata-   = 1
fbdata-vbitmap =info- + sizeof picolcd_fb_data;
 fbdata->bitmap  = vmalloc(PICOLCDFB_SIZE*8);
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 dev_err(, "'t get a free page for\);
  goto err_nomem;
 }
 info->flags |= FBINFO_VIRTFB;
 info->screen_buffer = fbdata->bitmap picolcd_fb_update_rate_store;
 info->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
memsetfbdata->vbitmap0xff, PICOLCDFB_SIZE
 {

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

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (error  * - 256*u32 for pseudo_palette
  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, " to register framebuffer\";
 gotoerr_sysfs;
 goto ;
 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>par+ sizeofstruct fb_deferred_iojava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 framebuffer_release ; 5;+java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  >pseudo_palette=;
}

void>var;
{
 struct * = >fb_info
 struct ixsmem_len=PICOLCDFB_SIZE8;
 unsignedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ifjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  ;

 device_remove_file(>lcd
 fbdata

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

 /* 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(>force ;

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