The patch titled
fbdev: eink_apollofb: new driver for Apollo eInk controller
has been removed from the -mm tree. Its filename was
eink_apollofb-new-driver-for-apollo-eink-controller.patch
This patch was dropped because it had testing failures
The current -mm tree may be found at http://userweb.kernel.org/~akpm/mmotm/
------------------------------------------------------
Subject: fbdev: eink_apollofb: new driver for Apollo eInk controller
From: Yauhen Kharuzhy <jekhor@xxxxxxxxx>
Add a new driver for eInk Apollo controller. This controller is used in
various bookreaders with eInk displays.
The eink_apollofb driver supports many features of Apollo chip, in
difference with the hecubafb driver: 2-bit color depth, partial picture
loading, flash read/write.
The driver uses platform_device framework for platform-specific functions
(set values of control lines, read/write data from/to bus etc.) and can be
used on any platform.
This driver has been developed for the OpenInkpot project
(http://openinkpot.org/).
[akpm@xxxxxxxxxxxxxxxxxxxx: cleanup]
[akpm@xxxxxxxxxxxxxxxxxxxx: kconfig uses tabs]
[akpm@xxxxxxxxxxxxxxxxxxxx: i386 build fix]
Signed-off-by: Yauhen Kharuzhy <jekhor@xxxxxxxxx>
Cc: Krzysztof Helt <krzysztof.h1@xxxxxxxxx>
Cc: "Antonino A. Daplas" <adaplas@xxxxxxx>
Signed-off-by: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>
---
drivers/video/Kconfig | 18
drivers/video/Makefile | 1
drivers/video/eink_apollofb.c | 969 ++++++++++++++++++++++++++++++++
include/linux/eink_apollofb.h | 60 +
4 files changed, 1048 insertions(+)
diff -puN drivers/video/Kconfig~eink_apollofb-new-driver-for-apollo-eink-controller drivers/video/Kconfig
--- a/drivers/video/Kconfig~eink_apollofb-new-driver-for-apollo-eink-controller
+++ a/drivers/video/Kconfig
@@ -712,6 +712,24 @@ config FB_N411
This enables support for the Apollo display controller in its
Hecuba form using the n411 devkit.
+config FB_EINK_APOLLO
+ tristate "Apollo eInk display controller support"
+ depends on EXPERIMENTAL && FB && MMU
+ depends on ARM
+ select FB_SYS_FILLRECT
+ select FB_SYS_COPYAREA
+ select FB_SYS_IMAGEBLIT
+ select FB_SYS_FOPS
+ select FB_DEFERRED_IO
+ help
+ This enables support for Apollo eInk display controller.
+ Includes support of deferred IO and 2-bit grayscale mode.
+
+ Hardware-specific functions have been moved to platform data.
+
+ To compile this driver as a module, choose M here: the
+ module will be called eink_apollofb.
+
config FB_HGA
tristate "Hercules mono graphics support"
depends on FB && X86
diff -puN drivers/video/Makefile~eink_apollofb-new-driver-for-apollo-eink-controller drivers/video/Makefile
--- a/drivers/video/Makefile~eink_apollofb-new-driver-for-apollo-eink-controller
+++ a/drivers/video/Makefile
@@ -76,6 +76,7 @@ obj-$(CONFIG_FB_ATARI) += ata
atafb_iplan2p2.o atafb_iplan2p4.o atafb_iplan2p8.o
obj-$(CONFIG_FB_MAC) += macfb.o
obj-$(CONFIG_FB_HECUBA) += hecubafb.o
+obj-$(CONFIG_FB_EINK_APOLLO) += eink_apollofb.o
obj-$(CONFIG_FB_HGA) += hgafb.o
obj-$(CONFIG_FB_XVR500) += sunxvr500.o
obj-$(CONFIG_FB_XVR2500) += sunxvr2500.o
diff -puN /dev/null drivers/video/eink_apollofb.c
--- /dev/null
+++ a/drivers/video/eink_apollofb.c
@@ -0,0 +1,969 @@
+/*
+ * linux/drivers/video/apollofb.c -- FB driver for lBook/Jinke eReader V3
+ *
+ * Copyright (C) 2007, Yauhen Kharuzhy
+ * This driver is part of openinkpot.org project
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ * This driver based on hecubafb driver code.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/fb.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/list.h>
+#include <linux/device.h>
+#include <linux/ctype.h>
+#include <linux/eink_apollofb.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+
+#include <asm/arch/regs-gpio.h>
+#include <asm/hardware.h>
+
+/* Display specific information */
+#define DPY_W 600
+#define DPY_H 800
+
+#define is_portrait(var) (!(var.rotate % 180))
+
+struct apollofb_options {
+ unsigned int manual_refresh:1;
+ unsigned int use_sleep_mode:1;
+};
+
+struct apollofb_par {
+ struct fb_info *info;
+ struct mutex lock;
+ struct delayed_work deferred_work;
+ struct cdev cdev;
+ struct apollofb_options options;
+ int current_mode;
+ struct eink_apollo_operations *ops;
+ int standby;
+};
+
+static struct fb_fix_screeninfo apollofb_fix __devinitdata = {
+ .id = "apollofb",
+ .type = FB_TYPE_PACKED_PIXELS,
+ .visual = FB_VISUAL_STATIC_PSEUDOCOLOR,
+ .xpanstep = 0,
+ .ypanstep = 0,
+ .ywrapstep = 0,
+ .line_length = DPY_W / (8 / 8),
+ .accel = FB_ACCEL_NONE,
+};
+
+static struct fb_var_screeninfo apollofb_var __devinitdata = {
+ .xres = DPY_W,
+ .yres = DPY_H,
+ .xres_virtual = DPY_W,
+ .yres_virtual = DPY_H,
+ .red = {0, 2, 0},
+ .blue = {0, 2, 0},
+ .green = {0, 2, 0},
+ .grayscale = 1,
+ .bits_per_pixel = 8,
+ .nonstd = 1,
+};
+
+static int apollo_wait_for_ack_value(struct apollofb_par *par,
+ unsigned int value)
+{
+ unsigned long timeout = jiffies + 2 * HZ;
+
+ while ((par->ops->get_ctl_pin(H_ACK) != value) &&
+ time_before(jiffies, timeout))
+ schedule();
+
+ if (par->ops->get_ctl_pin(H_ACK) != value) {
+ printk(KERN_ERR "%s: Wait for H_ACK == %u, timeout\n",
+ __func__, value);
+ return 1;
+ }
+
+ return 0;
+}
+
+#define apollo_wait_for_ack(par) apollo_wait_for_ack_value(par, 0)
+#define apollo_wait_for_ack_clear(par) apollo_wait_for_ack_value(par, 1)
+
+static int apollo_send_data(struct apollofb_par *par, unsigned char data)
+{
+ int res = 0;;
+
+ par->ops->write_value(data);
+ par->ops->set_ctl_pin(H_DS, 0);
+ res = apollo_wait_for_ack(par);
+ par->ops->set_ctl_pin(H_DS, 1);
+ if (!res)
+ apollo_wait_for_ack_clear(par);
+ return res;
+}
+
+
+static int apollo_send_command(struct apollofb_par *par, unsigned char cmd)
+{
+ int res;
+
+ par->ops->set_ctl_pin(H_CD, 1);
+ res = apollo_send_data(par, cmd);
+ par->ops->set_ctl_pin(H_CD, 0);
+ return res;
+}
+
+static unsigned char apollo_read_data(struct apollofb_par *par)
+{
+ unsigned char res;
+
+ par->ops->set_ctl_pin(H_RW, 1);
+ par->ops->set_ctl_pin(H_DS, 0);
+ apollo_wait_for_ack(par);
+ res = par->ops->read_value();
+ par->ops->set_ctl_pin(H_DS, 1);
+ apollo_wait_for_ack_clear(par);
+ par->ops->set_ctl_pin(H_RW, 0);
+
+ return res;
+}
+
+static void apollo_set_sleep_mode(struct apollofb_par *par)
+{
+ apollo_send_command(par, APOLLO_SLEEP_MODE);
+ par->current_mode = APOLLO_STATUS_MODE_SLEEP;
+}
+
+static void apollo_set_normal_mode(struct apollofb_par *par)
+{
+ par->ops->set_ctl_pin(H_CD, 0);
+ par->ops->set_ctl_pin(H_RW, 0);
+
+ apollo_send_command(par, APOLLO_NORMAL_MODE);
+ apollo_send_command(par, APOLLO_ORIENTATION);
+ apollo_send_data(par, ((par->info->var.rotate + 90) % 360) / 90);
+
+ par->current_mode = APOLLO_STATUS_MODE_NORMAL;
+}
+
+static void apollo_wakeup(struct apollofb_par *par)
+{
+ udelay(600); /* in case we were just powered off */
+ par->ops->set_ctl_pin(H_WUP, 1);
+ udelay(100);
+ par->ops->set_ctl_pin(H_DS, 0);
+ apollo_wait_for_ack(par);
+ par->ops->set_ctl_pin(H_WUP, 0);
+ par->ops->set_ctl_pin(H_DS, 1);
+ apollo_wait_for_ack_clear(par);
+}
+
+static void apollofb_apollo_update_part(struct apollofb_par *par,
+ unsigned int x1, unsigned int y1,
+ unsigned int x2, unsigned int y2)
+{
+ int i, j, k;
+ struct fb_info *info = par->info;
+ unsigned int width = is_portrait(info->var) ? info->var.xres :
+ info->var.yres;
+ unsigned int bpp = info->var.green.length;
+ unsigned int pixels_in_byte = 8 / bpp;
+ unsigned char *buf = (unsigned char __force *)info->screen_base;
+ unsigned char tmp, mask;
+
+ y1 -= y1 % 4;
+
+ if ((y2 + 1) % 4)
+ y2 += 4 - ((y2 + 1) % 4);
+
+ x1 -= x1 % 4;
+
+ if ((x2 + 1) % 4)
+ x2 += 4 - ((x2 + 1) % 4);
+
+ mask = 0;
+ for (i = 0; i < bpp; i++)
+ mask = (mask << 1) | 1;
+
+ mutex_lock(&par->lock);
+
+ if (par->current_mode == APOLLO_STATUS_MODE_SLEEP)
+ apollo_set_normal_mode(par);
+
+ if (par->options.manual_refresh)
+ apollo_send_command(par, APOLLO_MANUAL_REFRESH);
+
+ apollo_send_command(par, APOLLO_LOAD_PARTIAL_PICTURE);
+ apollo_send_data(par, (x1 >> 8) & 0xff);
+ apollo_send_data(par, x1 & 0xff);
+ apollo_send_data(par, (y1 >> 8) & 0xff);
+ apollo_send_data(par, y1 & 0xff);
+ apollo_send_data(par, (x2 >> 8) & 0xff);
+ apollo_send_data(par, x2 & 0xff);
+ apollo_send_data(par, (y2 >> 8) & 0xff);
+ apollo_send_data(par, y2 & 0xff);
+
+ k = 0;
+ tmp = 0;
+ for (i = y1; i <= y2; i++)
+ for (j = x1; j <= x2; j++) {
+ tmp = (tmp << bpp) | (buf[i * width + j] & mask);
+ k++;
+ if (k % pixels_in_byte == 0)
+ apollo_send_data(par, tmp);
+ }
+
+ apollo_send_command(par, APOLLO_STOP_LOADING);
+ apollo_send_command(par, APOLLO_DISPLAY_PARTIAL_PICTURE);
+
+ if (par->options.use_sleep_mode)
+ apollo_set_sleep_mode(par);
+
+ mutex_unlock(&par->lock);
+}
+
+/* this is called back from the deferred io workqueue */
+static void apollofb_dpy_deferred_io(struct fb_info *info,
+ struct list_head *pagelist)
+{
+
+ struct apollofb_par *par = info->par;
+ unsigned int width = is_portrait(info->var) ? info->var.xres :
+ info->var.yres;
+ unsigned int height = is_portrait(info->var) ? info->var.yres :
+ info->var.xres;
+ unsigned long int start_page = -1, end_page = -1;
+ unsigned int y1 = 0, y2 = 0;
+ struct page *cur;
+
+
+ list_for_each_entry(cur, pagelist, lru) {
+ if (start_page == -1) {
+ start_page = cur->index;
+ end_page = cur->index;
+ continue;
+ }
+
+ if (cur->index == end_page + 1) {
+ end_page++;
+ } else {
+ y1 = start_page * PAGE_SIZE / width;
+ y2 = ((end_page + 1) * PAGE_SIZE - 1) / width;
+ if (y2 >= height)
+ y2 = height - 1;
+
+ apollofb_apollo_update_part(par, 0, y1, width - 1, y2);
+
+ start_page = cur->index;
+ end_page = cur->index;
+ }
+ }
+
+ y1 = start_page * PAGE_SIZE / width;
+ y2 = ((end_page + 1) * PAGE_SIZE - 1) / width;
+ if (y2 >= height)
+ y2 = height - 1;
+
+ apollofb_apollo_update_part(par, 0, y1, width - 1, y2);
+}
+
+static void apollofb_deferred_work(struct work_struct *work)
+{
+ struct apollofb_par *par = container_of(work, struct apollofb_par,
+ deferred_work.work);
+ struct fb_info *info = par->info;
+ unsigned int width = is_portrait(info->var) ? info->var.xres :
+ info->var.yres;
+ unsigned int height = is_portrait(info->var) ? info->var.yres :
+ info->var.xres;
+
+ apollofb_apollo_update_part(par, 0, 0, width - 1, height - 1);
+}
+
+static void apollofb_fillrect(struct fb_info *info,
+ const struct fb_fillrect *rect)
+{
+ struct apollofb_par *par = info->par;
+
+ sys_fillrect(info, rect);
+
+ schedule_delayed_work(&par->deferred_work, info->fbdefio->delay);
+}
+
+static void apollofb_copyarea(struct fb_info *info,
+ const struct fb_copyarea *area)
+{
+ struct apollofb_par *par = info->par;
+
+ sys_copyarea(info, area);
+
+ schedule_delayed_work(&par->deferred_work, info->fbdefio->delay);
+}
+
+static void apollofb_imageblit(struct fb_info *info,
+ const struct fb_image *image)
+{
+ struct apollofb_par *par = info->par;
+
+ sys_imageblit(info, image);
+
+ schedule_delayed_work(&par->deferred_work, info->fbdefio->delay);
+}
+
+static int apollofb_cursor(struct fb_info *info, struct fb_cursor *cursor)
+{
+ return 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 apollofb_write(struct fb_info *info, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ unsigned long p;
+ int err = -EINVAL;
+ struct apollofb_par *par;
+ unsigned int xres;
+ unsigned int fbmemlength;
+
+ p = *ppos;
+ par = info->par;
+ xres = info->var.xres;
+ fbmemlength = (xres * info->var.yres)/8 * info->var.bits_per_pixel;
+
+ if (p > fbmemlength)
+ return -ENOSPC;
+
+ err = 0;
+ if ((count + p) > fbmemlength) {
+ count = fbmemlength - p;
+ err = -ENOSPC;
+ }
+
+ if (count) {
+ char *base_addr;
+
+ base_addr = (char __force *)info->screen_base;
+ count -= copy_from_user(base_addr + p, buf, count);
+ *ppos += count;
+ err = -EFAULT;
+ }
+
+ schedule_delayed_work(&par->deferred_work, info->fbdefio->delay);
+
+ if (count)
+ return count;
+
+ return err;
+}
+
+static int apollofb_sync(struct fb_info *info)
+{
+ return 0;
+}
+
+static int apollofb_check_var(struct fb_var_screeninfo *var,
+ struct fb_info *info)
+{
+ switch (var->bits_per_pixel) {
+ case 1:
+ var->red.length = 1;
+ var->red.offset = 0;
+ var->green.length = 1;
+ var->green.offset = 0;
+ var->blue.length = 1;
+ var->blue.offset = 0;
+ var->transp.length = 0;
+ var->transp.offset = 0;
+ break;
+ default:
+ var->bits_per_pixel = 8;
+ var->grayscale = 1;
+ var->red.length = 2;
+ var->red.offset = 0;
+ var->green.length = 2;
+ var->green.offset = 0;
+ var->blue.length = 2;
+ var->blue.offset = 0;
+ var->transp.length = 0;
+ var->transp.offset = 0;
+ break;
+ }
+
+ var->xres = DPY_W;
+ var->xres_virtual = DPY_W;
+ var->yres = DPY_H;
+ var->yres_virtual = DPY_H;
+
+ if (var->rotate % 90)
+ var->rotate -= var->rotate % 90;
+
+ return 0;
+}
+
+static int apollofb_set_par(struct fb_info *info)
+{
+ struct apollofb_par *par = info->par;
+
+ switch (info->var.bits_per_pixel) {
+ case 1:
+ info->fix.visual = FB_VISUAL_MONO01;
+ apollo_send_command(par, APOLLO_SET_DEPTH);
+ apollo_send_data(par, 0x00);
+ break;
+ default:
+ info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
+ apollo_send_command(par, APOLLO_SET_DEPTH);
+ apollo_send_data(par, 0x02);
+ break;
+ }
+
+ mutex_lock(&par->lock);
+ apollo_send_command(par, APOLLO_ORIENTATION);
+ apollo_send_data(par, ((info->var.rotate + 90) % 360) / 90);
+ mutex_unlock(&par->lock);
+
+ return 0;
+}
+
+static ssize_t apollofb_wf_read(struct file *f, char __user *buf,
+ size_t count, loff_t *f_pos)
+{
+ unsigned char data;
+ char __user *p = buf;
+ int i;
+ struct apollofb_par *par = f->private_data;
+
+ mutex_lock(&par->lock);
+ if (par->current_mode == APOLLO_STATUS_MODE_SLEEP)
+ apollo_set_normal_mode(par);
+
+ if (*f_pos > APOLLO_WAVEFORMS_FLASH_SIZE - 1)
+ return 0;
+
+ if (*f_pos + count > APOLLO_WAVEFORMS_FLASH_SIZE)
+ count = APOLLO_WAVEFORMS_FLASH_SIZE - *f_pos;
+
+ for (i = *f_pos; i < *f_pos + count; i++) {
+ apollo_send_command(par, APOLLO_READ_FROM_FLASH);
+
+ apollo_send_data(par, (i >> 16) & 0xff);
+ apollo_send_data(par, (i >> 8) & 0xff);
+ apollo_send_data(par, i & 0xff);
+
+ data = apollo_read_data(par);
+
+ if (copy_to_user(p, &data, 1))
+ return -EFAULT;
+
+ p++;
+ }
+
+ if (par->options.use_sleep_mode)
+ apollo_set_sleep_mode(par);
+ mutex_unlock(&par->lock);
+
+ *f_pos += count;
+ return count;
+}
+
+static ssize_t apollofb_wf_write(struct file *f, const char __user *buf,
+ size_t count, loff_t *f_pos)
+{
+ unsigned char data;
+ const char __user *p = buf;
+ int i;
+ struct apollofb_par *par = f->private_data;
+
+ mutex_lock(&par->lock);
+
+ if (par->current_mode == APOLLO_STATUS_MODE_SLEEP)
+ apollo_set_normal_mode(par);
+
+ if (*f_pos > APOLLO_WAVEFORMS_FLASH_SIZE - 1)
+ return 0;
+
+ if (*f_pos + count > APOLLO_WAVEFORMS_FLASH_SIZE)
+ count = APOLLO_WAVEFORMS_FLASH_SIZE - *f_pos;
+
+ for (i = *f_pos; i < *f_pos + count; i++) {
+ if (copy_to_user(&data, p, 1))
+ return -EFAULT;
+
+ apollo_send_command(par, APOLLO_WRITE_TO_FLASH);
+ apollo_send_data(par, (i >> 16) & 0xff);
+ apollo_send_data(par, (i >> 8) & 0xff);
+ apollo_send_data(par, i & 0xff);
+
+ apollo_send_data(par, data);
+
+ p++;
+ }
+
+ if (par->options.use_sleep_mode)
+ apollo_set_sleep_mode(par);
+ mutex_unlock(&par->lock);
+
+ *f_pos += count;
+ return count;
+}
+
+static int apollofb_wf_open(struct inode *i, struct file *f)
+{
+ struct apollofb_par *par;
+
+ par = container_of(i->i_cdev, struct apollofb_par, cdev);
+
+ f->private_data = par;
+
+ return 0;
+}
+
+static ssize_t apollofb_temperature_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+ char temp;
+
+ mutex_lock(&par->lock);
+
+ apollo_send_command(par, APOLLO_READ_TEMPERATURE);
+
+ temp = apollo_read_data(par);
+
+ mutex_unlock(&par->lock);
+
+ sprintf(buf, "%d\n", temp);
+ return strlen(buf) + 1;
+}
+
+static ssize_t apollofb_manual_refresh_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+
+ sprintf(buf, "%d\n", par->options.manual_refresh);
+ return strlen(buf) + 1;
+}
+
+static ssize_t apollofb_manual_refresh_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+ char *after;
+ unsigned long state = simple_strtoul(buf, &after, 10);
+ size_t count = after - buf;
+ ssize_t ret = -EINVAL;
+
+ if (*after && isspace(*after))
+ count++;
+
+ if ((count == size) && (state <= 1)) {
+ ret = count;
+ par->options.manual_refresh = state;
+ }
+
+ return ret;
+}
+
+static ssize_t apollofb_use_sleep_mode_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+
+ sprintf(buf, "%d\n", par->options.use_sleep_mode);
+ return strlen(buf) + 1;
+}
+
+static ssize_t apollofb_use_sleep_mode_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+ char *after;
+ unsigned long state = simple_strtoul(buf, &after, 10);
+ size_t count = after - buf;
+ ssize_t ret = -EINVAL;
+
+ if (*after && isspace(*after))
+ count++;
+
+ if ((count == size) && (state <= 1)) {
+ ret = count;
+ par->options.use_sleep_mode = state;
+
+ mutex_lock(&par->lock);
+
+ if (state)
+ apollo_set_sleep_mode(par);
+ else
+ apollo_set_normal_mode(par);
+
+ mutex_unlock(&par->lock);
+
+ }
+
+ return ret;
+}
+
+static ssize_t apollofb_defio_delay_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+
+ sprintf(buf, "%lu\n", info->fbdefio->delay * 1000 / HZ);
+ return strlen(buf) + 1;
+}
+
+static ssize_t apollofb_defio_delay_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct fb_info *info = dev_get_drvdata(dev);
+ char *after;
+ unsigned long state = simple_strtoul(buf, &after, 10);
+ size_t count = after - buf;
+ ssize_t ret = -EINVAL;
+
+ if (*after && isspace(*after))
+ count++;
+
+ state = state * HZ / 1000;
+
+ if (!state)
+ state = 1;
+
+ if (count == size) {
+ ret = count;
+ info->fbdefio->delay = state;
+ }
+
+ return ret;
+}
+
+DEVICE_ATTR(manual_refresh, 0666,
+ apollofb_manual_refresh_show, apollofb_manual_refresh_store);
+DEVICE_ATTR(defio_delay, 0666,
+ apollofb_defio_delay_show, apollofb_defio_delay_store);
+DEVICE_ATTR(use_sleep_mode, 0666,
+ apollofb_use_sleep_mode_show, apollofb_use_sleep_mode_store);
+
+static struct file_operations apollofb_wf_fops = {
+ .owner = THIS_MODULE,
+ .open = apollofb_wf_open,
+ .read = apollofb_wf_read,
+ .write = apollofb_wf_write,
+};
+
+
+static struct fb_ops apollofb_ops = {
+ .owner = THIS_MODULE,
+ .fb_read = fb_sys_read,
+ .fb_write = apollofb_write,
+ .fb_fillrect = apollofb_fillrect,
+ .fb_copyarea = apollofb_copyarea,
+ .fb_imageblit = apollofb_imageblit,
+ .fb_cursor = apollofb_cursor,
+ .fb_sync = apollofb_sync,
+ .fb_check_var = apollofb_check_var,
+ .fb_set_par = apollofb_set_par,
+};
+
+static struct fb_deferred_io apollofb_defio = {
+ .delay = HZ / 2,
+ .deferred_io = apollofb_dpy_deferred_io,
+};
+
+DEVICE_ATTR(temperature, 0444, apollofb_temperature_show, NULL);
+
+
+static int __devinit apollofb_setup_chrdev(struct apollofb_par *par)
+{
+ int res = 0;
+ struct cdev *cdev = &par->cdev;
+ dev_t devno;
+
+ res = alloc_chrdev_region(&devno, 0, 1, "apollo");
+ if (res)
+ goto err_alloc_chrdev_region;
+
+
+ cdev_init(cdev, &apollofb_wf_fops);
+
+ res = cdev_add(cdev, devno, 1);
+ if (res)
+ goto err_cdev_add;
+
+ return 0;
+
+err_cdev_add:
+ unregister_chrdev_region(devno, 1);
+err_alloc_chrdev_region:
+
+ return res;
+}
+
+static void apollofb_remove_chrdev(struct apollofb_par *par)
+{
+ cdev_del(&par->cdev);
+ unregister_chrdev_region(par->cdev.dev, 1);
+}
+
+static u16 red4[] __read_mostly = {
+ 0x0000, 0x5555, 0xaaaa, 0xffff
+};
+static u16 green4[] __read_mostly = {
+ 0x0000, 0x5555, 0xaaaa, 0xffff
+};
+static u16 blue4[] __read_mostly = {
+ 0x0000, 0x5555, 0xaaaa, 0xffff
+};
+
+static const struct fb_cmap eink_apollofb_4_colors = {
+ .len = 4, .red = red4, .green = green4, .blue = blue4
+};
+
+static int __devinit apollofb_probe(struct platform_device *dev)
+{
+ struct fb_info *info;
+ int retval = -ENOMEM;
+ int videomemorysize;
+ unsigned char *videomemory;
+ struct apollofb_par *par;
+ struct eink_apollofb_platdata *pdata = dev->dev.platform_data;
+ unsigned char apollo_display_size;
+
+ videomemorysize = (DPY_W * DPY_H)/8 * apollofb_var.bits_per_pixel;
+
+ videomemory = vmalloc(videomemorysize);
+ if (!videomemory)
+ return retval;
+
+ memset(videomemory, 0xFF, videomemorysize);
+
+ info = framebuffer_alloc(sizeof(struct apollofb_par), &dev->dev);
+ if (!info)
+ goto err;
+
+ if (!pdata->ops.set_ctl_pin ||
+ !pdata->ops.get_ctl_pin ||
+ !pdata->ops.read_value ||
+ !pdata->ops.write_value) {
+ retval = -EINVAL;
+ dev_err(&dev->dev,
+ "Invalid platform data: missing operations\n");
+ goto err1;
+ }
+
+ info->screen_base = (char __iomem *) videomemory;
+ info->fbops = &apollofb_ops;
+
+ info->var = apollofb_var;
+ info->fix = apollofb_fix;
+ info->fix.smem_len = videomemorysize;
+ par = info->par;
+ par->info = info;
+ mutex_init(&par->lock);
+ INIT_DELAYED_WORK(&par->deferred_work, apollofb_deferred_work);
+ par->options.manual_refresh = 0;
+ par->options.use_sleep_mode = 0;
+ par->ops = &pdata->ops;
+
+ info->flags = FBINFO_FLAG_DEFAULT;
+
+ if (pdata->defio_delay)
+ apollofb_defio.delay = pdata->defio_delay;
+ info->fbdefio = &apollofb_defio;
+ fb_deferred_io_init(info);
+
+ fb_alloc_cmap(&info->cmap, 4, 0);
+ fb_copy_cmap(&eink_apollofb_4_colors, &info->cmap);
+
+ if (par->ops->initialize)
+ par->ops->initialize();
+
+ par->ops->set_ctl_pin(H_CD, 0);
+ par->ops->set_ctl_pin(H_RW, 0);
+
+ mutex_lock(&par->lock);
+ if (apollo_send_command(par, APOLLO_DISPLAY_SIZE)) {
+ dev_err(&dev->dev, "Apollo controller is not detected.\n");
+ mutex_unlock(&par->lock);
+ goto err1;
+ }
+
+ apollo_display_size = apollo_read_data(par);
+ if (apollo_display_size != 0x22) {
+ dev_err(&dev->dev, "Unknown or missing eInk controller, "
+ "display size byte is 0x%02x\n",
+ apollo_display_size);
+ mutex_unlock(&par->lock);
+ goto err1;
+ }
+
+ apollo_set_normal_mode(par);
+ apollo_send_command(par, APOLLO_SET_DEPTH);
+ apollo_send_data(par, 0x02);
+ apollo_send_command(par, APOLLO_ERASE_DISPLAY);
+ apollo_send_data(par, 0x01);
+ if (par->options.use_sleep_mode)
+ apollo_set_sleep_mode(par);
+ mutex_unlock(&par->lock);
+
+ retval = register_framebuffer(info);
+ if (retval < 0)
+ goto err1;
+ platform_set_drvdata(dev, info);
+
+ printk(KERN_INFO
+ "fb%d: eInk Apollo frame buffer device,"
+ "using %dK of video memory (%p)\n",
+ info->node, videomemorysize >> 10, videomemory);
+
+
+ retval = apollofb_setup_chrdev(par);
+ if (retval)
+ goto err2;
+
+ retval = device_create_file(info->dev, &dev_attr_temperature);
+ if (retval)
+ goto err_devattr_temperature;
+
+ retval = device_create_file(info->dev, &dev_attr_manual_refresh);
+ if (retval)
+ goto err_devattr_manref;
+
+ retval = device_create_file(info->dev, &dev_attr_defio_delay);
+ if (retval)
+ goto err_devattr_defio_delay;
+
+ retval = device_create_file(info->dev, &dev_attr_use_sleep_mode);
+ if (retval)
+ goto err_devattr_use_sleep_mode;
+
+ return 0;
+
+
+ device_remove_file(info->dev, &dev_attr_use_sleep_mode);
+err_devattr_use_sleep_mode:
+ device_remove_file(info->dev, &dev_attr_defio_delay);
+err_devattr_defio_delay:
+ device_remove_file(info->dev, &dev_attr_manual_refresh);
+err_devattr_manref:
+ device_remove_file(info->dev, &dev_attr_temperature);
+err_devattr_temperature:
+ apollofb_remove_chrdev(par);
+err2:
+ unregister_framebuffer(info);
+err1:
+ framebuffer_release(info);
+err:
+ vfree(videomemory);
+ return retval;
+}
+
+static int __devexit apollofb_remove(struct platform_device *dev)
+{
+ struct fb_info *info = platform_get_drvdata(dev);
+ struct apollofb_par *par = info->par;
+
+ if (info) {
+ fb_deferred_io_cleanup(info);
+ cancel_delayed_work(&par->deferred_work);
+ flush_scheduled_work();
+
+ device_remove_file(info->dev, &dev_attr_use_sleep_mode);
+ device_remove_file(info->dev, &dev_attr_manual_refresh);
+ device_remove_file(info->dev, &dev_attr_defio_delay);
+ device_remove_file(info->dev, &dev_attr_temperature);
+ unregister_framebuffer(info);
+ vfree((void __force *)info->screen_base);
+ apollofb_remove_chrdev(info->par);
+ framebuffer_release(info);
+ }
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int apollofb_suspend(struct platform_device *pdev, pm_message_t message)
+{
+ struct fb_info *info = platform_get_drvdata(pdev);
+ struct apollofb_par *par = info->par;
+
+ mutex_lock(&par->lock);
+ apollo_send_command(par, APOLLO_STANDBY_MODE);
+ par->current_mode = APOLLO_STATUS_MODE_SLEEP;
+ mutex_unlock(&par->lock);
+
+ return 0;
+}
+
+static int apollofb_resume(struct platform_device *pdev)
+{
+ struct fb_info *info = platform_get_drvdata(pdev);
+ struct apollofb_par *par = info->par;
+
+ mutex_lock(&par->lock);
+ apollo_wakeup(par);
+ if (!par->options.use_sleep_mode)
+ apollo_set_normal_mode(par);
+ mutex_unlock(&par->lock);
+
+ return 0;
+}
+#endif
+
+
+static struct platform_driver apollofb_driver = {
+ .probe = apollofb_probe,
+ .remove = apollofb_remove,
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "eink-apollo",
+ },
+#ifdef CONFIG_PM
+ .suspend = apollofb_suspend,
+ .resume = apollofb_resume,
+#endif
+};
+
+static int __init apollofb_init(void)
+{
+ int ret = 0;
+
+ ret = platform_driver_register(&apollofb_driver);
+
+ return ret;
+}
+
+static void __exit apollofb_exit(void)
+{
+ platform_driver_unregister(&apollofb_driver);
+}
+
+
+module_init(apollofb_init);
+module_exit(apollofb_exit);
+
+MODULE_DESCRIPTION("fbdev driver for Apollo eInk display controller");
+MODULE_AUTHOR("Yauhen Kharuzhy");
+MODULE_LICENSE("GPL");
diff -puN /dev/null include/linux/eink_apollofb.h
--- /dev/null
+++ a/include/linux/eink_apollofb.h
@@ -0,0 +1,60 @@
+
+enum eink_apollo_controls {
+ H_CD = 0,
+ H_RW = 1,
+ H_DS = 2,
+ H_ACK = 3,
+ H_WUP = 4,
+ H_NRST = 5,
+};
+
+struct eink_apollo_operations {
+ int (*initialize)(void);
+ void (*set_ctl_pin)(unsigned int pin, unsigned char val);
+ int (*get_ctl_pin)(unsigned int pin);
+ void (*write_value)(unsigned char val);
+ unsigned char (*read_value)(void);
+};
+
+/* Apollo controller commands */
+#define APOLLO_WRITE_TO_FLASH 0x01
+#define APOLLO_READ_FROM_FLASH 0x02
+#define APOLLO_WRITE_REGISTER 0x10
+#define APOLLO_READ_REGISTER 0x11
+#define APOLLO_READ_TEMPERATURE 0x21
+#define APOLLO_LOAD_PICTURE 0xA0
+#define APOLLO_STOP_LOADING 0xA1
+#define APOLLO_DISPLAY_PICTURE 0xA2
+#define APOLLO_ERASE_DISPLAY 0xA3
+#define APOLLO_INIT_DISPLAY 0xA4
+#define APOLLO_RESTORE_IMAGE 0xA5
+#define APOLLO_GET_STATUS 0xAA
+#define APOLLO_LOAD_PARTIAL_PICTURE 0xB0
+#define APOLLO_DISPLAY_PARTIAL_PICTURE 0xB1
+#define APOLLO_VERSION_NUMBER 0xE0
+#define APOLLO_DISPLAY_SIZE 0xE2
+#define APOLLO_RESET 0xEE
+#define APOLLO_NORMAL_MODE 0xF0
+#define APOLLO_SLEEP_MODE 0xF1
+#define APOLLO_STANDBY_MODE 0xF2
+#define APOLLO_SET_DEPTH 0xF3
+#define APOLLO_ORIENTATION 0xF5
+#define APOLLO_POSITIVE_PICTURE 0xF7
+#define APOLLO_NEGATIVE_PICTURE 0xF8
+#define APOLLO_AUTO_REFRESH 0xF9
+#define APOLLO_CANCEL_AUTO_REFRESH 0xFA
+#define APOLLO_SET_REFRESH_TIMER 0xFB
+#define APOLLO_MANUAL_REFRESH 0xFC
+#define APOLLO_READ_REFRESH_TIMER 0xFD
+
+#define APOLLO_WAVEFORMS_FLASH_SIZE (1024 * 1024 * 2)
+
+#define APOLLO_STATUS_MODE_MASK (1 << 0)
+#define APOLLO_STATUS_MODE_SLEEP 0x01
+#define APOLLO_STATUS_MODE_NORMAL 0x00
+
+struct eink_apollofb_platdata {
+ struct eink_apollo_operations ops;
+ unsigned long defio_delay;
+};
+
_
Patches currently in -mm which might be from jekhor@xxxxxxxxx are
eink_apollofb-new-driver-for-apollo-eink-controller.patch
--
To unsubscribe from this list: send the line "unsubscribe mm-commits" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
