[linux-block.git] / drivers / hid / hid-picolcd_fb.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_base 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);
}

/* Stub to call the system default and update the image on the picoLCD */
static void picolcd_fb_fillrect(struct fb_info *info,
		const struct fb_fillrect *rect)
{
	if (!info->par)
		return;
	sys_fillrect(info, rect);

	schedule_delayed_work(&info->deferred_work, 0);
}

/* Stub to call the system default and update the image on the picoLCD */
static void picolcd_fb_copyarea(struct fb_info *info,
		const struct fb_copyarea *area)
{
	if (!info->par)
		return;
	sys_copyarea(info, area);

	schedule_delayed_work(&info->deferred_work, 0);
}

/* Stub to call the system default and update the image on the picoLCD */
static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image)
{
	if (!info->par)
		return;
	sys_imageblit(info, image);

	schedule_delayed_work(&info->deferred_work, 0);
}

/*
 * this is the slow path from userspace. they can seek and write to
 * the fb. it's inefficient to do anything less than a full screen draw
 */
static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf,
		size_t count, loff_t *ppos)
{
	ssize_t ret;
	if (!info->par)
		return -ENODEV;
	ret = fb_sys_write(info, buf, count, ppos);
	if (ret >= 0)
		schedule_delayed_work(&info->deferred_work, 0);
	return ret;
}

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 thridparty 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 const struct fb_ops picolcdfb_ops = {
	.owner        = THIS_MODULE,
	.fb_destroy   = picolcd_fb_destroy,
	.fb_read      = fb_sys_read,
	.fb_write     = picolcd_fb_write,
	.fb_blank     = picolcd_fb_blank,
	.fb_fillrect  = picolcd_fb_fillrect,
	.fb_copyarea  = picolcd_fb_copyarea,
	.fb_imageblit = picolcd_fb_imageblit,
	.fb_check_var = picolcd_fb_check_var,
	.fb_set_par   = picolcd_set_par,
	.fb_mmap      = fb_deferred_io_mmap,
};


/* 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 (ret >= PAGE_SIZE)
			break;
		else if (i == fb_update_rate)
			ret += scnprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
		else
			ret += scnprintf(buf+ret, PAGE_SIZE-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;
	info->flags = FBINFO_FLAG_DEFAULT;

	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->screen_base = (char __force __iomem *)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);
}
Commit	Line	Data
24c9d96d	1	// SPDX-License-Identifier: GPL-2.0-only
fabdbf2f BP	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	* *
fabdbf2f BP	8	***************************************************************************/
	9
	10	#include <linux/hid.h>
d1c60a03	11	#include <linux/vmalloc.h>
fabdbf2f BP	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 */
16048709 BP	90	static int picolcd_fb_send_tile(struct picolcd_data data, u8 vbitmap,
16048709 BP	91	int chip, int tile)
fabdbf2f	92	{
16048709	93	struct hid_report report1, report2;
fabdbf2f BP	94	unsigned long flags;
	95	u8 *tdata;
	96	int i;
	97
16048709 BP	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)
fabdbf2f BP	103	return -ENODEV;
	104
	105	spin_lock_irqsave(&data->lock, flags);
16048709 BP	106	if ((data->status & PICOLCD_FAILED)) {
	107	spin_unlock_irqrestore(&data->lock, flags);
	108	return -ENODEV;
	109	}
fabdbf2f BP	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
16048709	127	tdata = vbitmap + (tile * 4 + chip) * 64;
fabdbf2f BP	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
d8814272 BT	134	hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT);
d8814272 BT	135	hid_hw_request(data->hdev, report2, HID_REQ_SET_REPORT);
fabdbf2f BP	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);
16048709	188	struct picolcd_fb_data *fbdata = data->fb_info->par;
fabdbf2f BP	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);
d8814272	205	hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
fabdbf2f	206	}
fabdbf2f BP	207	spin_unlock_irqrestore(&data->lock, flags);
fabdbf2f BP	208
16048709 BP	209	if (clear) {
	210	memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE);
	211	memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp);
fabdbf2f	212	}
16048709	213	fbdata->force = 1;
fabdbf2f BP	214
fabdbf2f BP	215	/* schedule first output of framebuffer */
16048709 BP	216	if (fbdata->ready)
	217	schedule_delayed_work(&data->fb_info->deferred_work, 0);
	218	else
	219	fbdata->ready = 1;
fabdbf2f BP	220
	221	return 0;
	222	}
	223
	224	/* Update fb_vbitmap from the screen_base and send changed tiles to device */
a93ab849	225	static void picolcd_fb_update(struct fb_info *info)
fabdbf2f BP	226	{
	227	int chip, tile, n;
	228	unsigned long flags;
16048709	229	struct picolcd_fb_data *fbdata = info->par;
a93ab849	230	struct picolcd_data *data;
fabdbf2f	231
a93ab849	232	mutex_lock(&info->lock);
fabdbf2f	233
16048709 BP	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);
fabdbf2f BP	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++)
16048709 BP	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;
b7966a4d	261	hid_hw_wait(data->hdev);
16048709 BP	262	mutex_lock(&info->lock);
16048709 BP	263	n = 0;
fabdbf2f	264	}
16048709 BP	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;
a93ab849	273	if (n) {
16048709 BP	274	spin_lock_irqsave(&fbdata->lock, flags);
	275	data = fbdata->picolcd;
	276	spin_unlock_irqrestore(&fbdata->lock, flags);
a93ab849	277	mutex_unlock(&info->lock);
16048709	278	if (data)
b7966a4d	279	hid_hw_wait(data->hdev);
a93ab849 BP	280	return;
	281	}
	282	out:
	283	mutex_unlock(&info->lock);
fabdbf2f BP	284	}
	285
	286	/* Stub to call the system default and update the image on the picoLCD */
	287	static void picolcd_fb_fillrect(struct fb_info *info,
	288	const struct fb_fillrect *rect)
	289	{
	290	if (!info->par)
	291	return;
	292	sys_fillrect(info, rect);
	293
	294	schedule_delayed_work(&info->deferred_work, 0);
	295	}
	296
	297	/* Stub to call the system default and update the image on the picoLCD */
	298	static void picolcd_fb_copyarea(struct fb_info *info,
	299	const struct fb_copyarea *area)
	300	{
	301	if (!info->par)
	302	return;
	303	sys_copyarea(info, area);
	304
	305	schedule_delayed_work(&info->deferred_work, 0);
	306	}
	307
	308	/* Stub to call the system default and update the image on the picoLCD */
	309	static void picolcd_fb_imageblit(struct fb_info info, const struct fb_image image)
	310	{
	311	if (!info->par)
	312	return;
	313	sys_imageblit(info, image);
	314
	315	schedule_delayed_work(&info->deferred_work, 0);
	316	}
	317
	318	/*
	319	* this is the slow path from userspace. they can seek and write to
	320	* the fb. it's inefficient to do anything less than a full screen draw
	321	*/
	322	static ssize_t picolcd_fb_write(struct fb_info info, const char __user buf,
	323	size_t count, loff_t *ppos)
	324	{
	325	ssize_t ret;
	326	if (!info->par)
	327	return -ENODEV;
	328	ret = fb_sys_write(info, buf, count, ppos);
	329	if (ret >= 0)
	330	schedule_delayed_work(&info->deferred_work, 0);
	331	return ret;
	332	}
	333
	334	static int picolcd_fb_blank(int blank, struct fb_info *info)
	335	{
fabdbf2f BP	336	/* We let fb notification do this for us via lcd/backlight device */
	337	return 0;
	338	}
	339
	340	static void picolcd_fb_destroy(struct fb_info *info)
	341	{
16048709 BP	342	struct picolcd_fb_data *fbdata = info->par;
16048709 BP	343
9966c37c	344	/* make sure no work is deferred */
a93ab849	345	fb_deferred_io_cleanup(info);
fabdbf2f	346
16048709 BP	347	/* No thridparty should ever unregister our framebuffer! */
	348	WARN_ON(fbdata->picolcd != NULL);
	349
9966c37c BP	350	vfree((u8 *)info->fix.smem_start);
9966c37c BP	351	framebuffer_release(info);
fabdbf2f BP	352	}
	353
	354	static int picolcd_fb_check_var(struct fb_var_screeninfo var, struct fb_info info)
	355	{
	356	__u32 bpp = var->bits_per_pixel;
	357	__u32 activate = var->activate;
	358
	359	/* only allow 1/8 bit depth (8-bit is grayscale) */
	360	*var = picolcdfb_var;
	361	var->activate = activate;
	362	if (bpp >= 8) {
	363	var->bits_per_pixel = 8;
	364	var->red.length = 8;
	365	var->green.length = 8;
	366	var->blue.length = 8;
	367	} else {
	368	var->bits_per_pixel = 1;
	369	var->red.length = 1;
	370	var->green.length = 1;
	371	var->blue.length = 1;
	372	}
	373	return 0;
	374	}
	375
	376	static int picolcd_set_par(struct fb_info *info)
	377	{
16048709	378	struct picolcd_fb_data *fbdata = info->par;
fabdbf2f	379	u8 tmp_fb, o_fb;
16048709	380	if (info->var.bits_per_pixel == fbdata->bpp)
fabdbf2f BP	381	return 0;
	382	/* switch between 1/8 bit depths */
	383	if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8)
	384	return -EINVAL;
	385
16048709	386	o_fb = fbdata->bitmap;
6da2ec56 KC	387	tmp_fb = kmalloc_array(PICOLCDFB_SIZE, info->var.bits_per_pixel,
6da2ec56 KC	388	GFP_KERNEL);
fabdbf2f BP	389	if (!tmp_fb)
	390	return -ENOMEM;
	391
	392	/* translate FB content to new bits-per-pixel */
	393	if (info->var.bits_per_pixel == 1) {
	394	int i, b;
	395	for (i = 0; i < PICOLCDFB_SIZE; i++) {
	396	u8 p = 0;
	397	for (b = 0; b < 8; b++) {
	398	p <<= 1;
	399	p \|= o_fb[i*8+b] ? 0x01 : 0x00;
	400	}
	401	tmp_fb[i] = p;
	402	}
	403	memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
	404	info->fix.visual = FB_VISUAL_MONO01;
	405	info->fix.line_length = PICOLCDFB_WIDTH / 8;
	406	} else {
	407	int i;
	408	memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE);
	409	for (i = 0; i < PICOLCDFB_SIZE * 8; i++)
	410	o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00;
	411	info->fix.visual = FB_VISUAL_DIRECTCOLOR;
	412	info->fix.line_length = PICOLCDFB_WIDTH;
	413	}
	414
	415	kfree(tmp_fb);
16048709	416	fbdata->bpp = info->var.bits_per_pixel;
fabdbf2f BP	417	return 0;
	418	}
	419
1b69e892	420	static const struct fb_ops picolcdfb_ops = {
fabdbf2f BP	421	.owner = THIS_MODULE,
fabdbf2f BP	422	.fb_destroy = picolcd_fb_destroy,
fabdbf2f BP	423	.fb_read = fb_sys_read,
	424	.fb_write = picolcd_fb_write,
	425	.fb_blank = picolcd_fb_blank,
	426	.fb_fillrect = picolcd_fb_fillrect,
	427	.fb_copyarea = picolcd_fb_copyarea,
	428	.fb_imageblit = picolcd_fb_imageblit,
	429	.fb_check_var = picolcd_fb_check_var,
	430	.fb_set_par = picolcd_set_par,
59055851	431	.fb_mmap = fb_deferred_io_mmap,
fabdbf2f BP	432	};
	433
	434
	435	/* Callback from deferred IO workqueue */
e80eec1b	436	static void picolcd_fb_deferred_io(struct fb_info info, struct list_head pagereflist)
fabdbf2f	437	{
a93ab849	438	picolcd_fb_update(info);
fabdbf2f BP	439	}
	440
	441	static const struct fb_deferred_io picolcd_fb_defio = {
	442	.delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT,
	443	.deferred_io = picolcd_fb_deferred_io,
	444	};
	445
	446
	447	/*
	448	* The "fb_update_rate" sysfs attribute
	449	*/
	450	static ssize_t picolcd_fb_update_rate_show(struct device *dev,
	451	struct device_attribute attr, char buf)
	452	{
	453	struct picolcd_data *data = dev_get_drvdata(dev);
16048709 BP	454	struct picolcd_fb_data *fbdata = data->fb_info->par;
16048709 BP	455	unsigned i, fb_update_rate = fbdata->update_rate;
fabdbf2f BP	456	size_t ret = 0;
	457
	458	for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++)
	459	if (ret >= PAGE_SIZE)
	460	break;
	461	else if (i == fb_update_rate)
42f502df	462	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
fabdbf2f	463	else
42f502df	464	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
fabdbf2f BP	465	if (ret > 0)
	466	buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
	467	return ret;
	468	}
	469
	470	static ssize_t picolcd_fb_update_rate_store(struct device *dev,
	471	struct device_attribute attr, const char buf, size_t count)
	472	{
	473	struct picolcd_data *data = dev_get_drvdata(dev);
16048709	474	struct picolcd_fb_data *fbdata = data->fb_info->par;
fabdbf2f BP	475	int i;
	476	unsigned u;
	477
	478	if (count < 1 \|\| count > 10)
	479	return -EINVAL;
	480
	481	i = sscanf(buf, "%u", &u);
	482	if (i != 1)
	483	return -EINVAL;
	484
	485	if (u > PICOLCDFB_UPDATE_RATE_LIMIT)
	486	return -ERANGE;
	487	else if (u == 0)
	488	u = PICOLCDFB_UPDATE_RATE_DEFAULT;
	489
16048709 BP	490	fbdata->update_rate = u;
16048709 BP	491	data->fb_info->fbdefio->delay = HZ / fbdata->update_rate;
fabdbf2f BP	492	return count;
	493	}
	494
f92201c3	495	static DEVICE_ATTR(fb_update_rate, 0664, picolcd_fb_update_rate_show,
fabdbf2f BP	496	picolcd_fb_update_rate_store);
	497
	498	/* initialize Framebuffer device */
	499	int picolcd_init_framebuffer(struct picolcd_data *data)
	500	{
	501	struct device *dev = &data->hdev->dev;
	502	struct fb_info *info = NULL;
16048709	503	struct picolcd_fb_data *fbdata = NULL;
fabdbf2f	504	int i, error = -ENOMEM;
fabdbf2f BP	505	u32 *palette;
fabdbf2f BP	506
fabdbf2f	507	/* The extra memory is:
fabdbf2f	508	* - 256*u32 for pseudo_palette
9966c37c	509	* - struct fb_deferred_io
fabdbf2f	510	*/
9966c37c	511	info = framebuffer_alloc(256 * sizeof(u32) +
16048709 BP	512	sizeof(struct fb_deferred_io) +
	513	sizeof(struct picolcd_fb_data) +
	514	PICOLCDFB_SIZE, dev);
0adcdbcb	515	if (!info)
fabdbf2f	516	goto err_nomem;
fabdbf2f	517
9966c37c BP	518	info->fbdefio = info->par;
9966c37c BP	519	*info->fbdefio = picolcd_fb_defio;
16048709 BP	520	info->par += sizeof(struct fb_deferred_io);
	521	palette = info->par;
	522	info->par += 256 * sizeof(u32);
fabdbf2f BP	523	for (i = 0; i < 256; i++)
	524	palette[i] = i > 0 && i < 16 ? 0xff : 0;
	525	info->pseudo_palette = palette;
fabdbf2f BP	526	info->fbops = &picolcdfb_ops;
	527	info->var = picolcdfb_var;
	528	info->fix = picolcdfb_fix;
	529	info->fix.smem_len = PICOLCDFB_SIZE*8;
fabdbf2f BP	530	info->flags = FBINFO_FLAG_DEFAULT;
fabdbf2f BP	531
16048709 BP	532	fbdata = info->par;
	533	spin_lock_init(&fbdata->lock);
	534	fbdata->picolcd = data;
	535	fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
	536	fbdata->bpp = picolcdfb_var.bits_per_pixel;
	537	fbdata->force = 1;
	538	fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data);
	539	fbdata->bitmap = vmalloc(PICOLCDFB_SIZE*8);
	540	if (fbdata->bitmap == NULL) {
	541	dev_err(dev, "can't get a free page for framebuffer\n");
	542	goto err_nomem;
	543	}
	544	info->screen_base = (char __force __iomem *)fbdata->bitmap;
	545	info->fix.smem_start = (unsigned long)fbdata->bitmap;
	546	memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE);
	547	data->fb_info = info;
	548
fabdbf2f BP	549	error = picolcd_fb_reset(data, 1);
	550	if (error) {
	551	dev_err(dev, "failed to configure display\n");
	552	goto err_cleanup;
	553	}
16048709	554
fabdbf2f BP	555	error = device_create_file(dev, &dev_attr_fb_update_rate);
	556	if (error) {
	557	dev_err(dev, "failed to create sysfs attributes\n");
	558	goto err_cleanup;
	559	}
16048709	560
fabdbf2f	561	fb_deferred_io_init(info);
fabdbf2f BP	562	error = register_framebuffer(info);
	563	if (error) {
	564	dev_err(dev, "failed to register framebuffer\n");
	565	goto err_sysfs;
	566	}
fabdbf2f BP	567	return 0;
	568
	569	err_sysfs:
fabdbf2f	570	device_remove_file(dev, &dev_attr_fb_update_rate);
16048709	571	fb_deferred_io_cleanup(info);
fabdbf2f	572	err_cleanup:
fabdbf2f BP	573	data->fb_info = NULL;
	574
	575	err_nomem:
16048709 BP	576	if (fbdata)
16048709 BP	577	vfree(fbdata->bitmap);
fabdbf2f	578	framebuffer_release(info);
fabdbf2f BP	579	return error;
	580	}
	581
	582	void picolcd_exit_framebuffer(struct picolcd_data *data)
	583	{
	584	struct fb_info *info = data->fb_info;
1cde501b	585	struct picolcd_fb_data *fbdata;
16048709	586	unsigned long flags;
fabdbf2f	587
1cde501b BP	588	if (!info)
	589	return;
	590
fabdbf2f	591	device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate);
1cde501b	592	fbdata = info->par;
16048709 BP	593
	594	/* disconnect framebuffer from HID dev */
	595	spin_lock_irqsave(&fbdata->lock, flags);
	596	fbdata->picolcd = NULL;
	597	spin_unlock_irqrestore(&fbdata->lock, flags);
	598
	599	/* make sure there is no running update - thus that fbdata->picolcd
	600	* once obtained under lock is guaranteed not to get free() under
	601	* the feet of the deferred work */
033d9959	602	flush_delayed_work(&info->deferred_work);
16048709 BP	603
16048709 BP	604	data->fb_info = NULL;
fabdbf2f	605	unregister_framebuffer(info);
fabdbf2f	606	}