add gs os v0.6 kernel patches

v0.6/515_display.patch

@@ -0,0 +1,770 @@
+diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c
+index 1a9685eb8002..8bdb02aeaf0c 100644
+--- a/drivers/gpu/drm/panel/panel-simple.c
++++ b/drivers/gpu/drm/panel/panel-simple.c
+@@ -4466,6 +4466,44 @@ static const struct panel_desc arm_rtsm = {
+ 	.bus_format = MEDIA_BUS_FMT_RGB888_1X24,
+ };
+ 
++static const struct drm_display_mode clockwork_cpi3_lcd_mode = {
++	.clock = 5800,
++	.hdisplay = 320,
++	.hsync_start = 320 + 6,
++	.hsync_end = 320 + 6 + 2,
++	.htotal = 320 + 6 + 2 + 60,
++	.vdisplay = 240,
++	.vsync_start = 240 + 2,
++	.vsync_end = 240 + 2 + 2,
++	.vtotal = 240 + 2 + 2 + 6,
++	.flags = DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_PHSYNC,
++};
++
++static const struct panel_desc clockwork_cpi3_lcd = {
++	.modes = &clockwork_cpi3_lcd_mode,
++	.num_modes = 1,
++	.bpc = 8,
++};
++
++static const struct drm_display_mode clockwork_cpi3_hdmi_mode = {
++	.clock = 74250,
++	.hdisplay = 1280,
++	.hsync_start = 1280 + 110,
++	.hsync_end = 1280 + 110 + 40,
++	.htotal = 1280 + 110 + 40 + 220,
++	.vdisplay = 720,
++	.vsync_start = 720 + 5,
++	.vsync_end = 720 + 5 + 5,
++	.vtotal = 720 + 5 + 5 + 20,
++	.flags = DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_PHSYNC,
++};
++
++static const struct panel_desc clockwork_cpi3_hdmi = {
++	.modes = &clockwork_cpi3_hdmi_mode,
++	.num_modes = 1,
++	.bpc = 8,
++};
++
+ static const struct of_device_id platform_of_match[] = {
+ 	{
+ 		.compatible = "ampire,am-1280800n3tzqw-t00h",
+@@ -4906,6 +4944,12 @@ static const struct of_device_id platform_of_match[] = {
+ 		/* Must be the last entry */
+ 		.compatible = "panel-dpi",
+ 		.data = &panel_dpi,
++	}, {
++		.compatible = "clockwork,cpi3-lcd",
++		.data = &clockwork_cpi3_lcd,
++	}, {
++		.compatible = "clockwork,cpi3-hdmi",
++		.data = &clockwork_cpi3_hdmi,
+ 	}, {
+ 		/* sentinel */
+ 	}
+diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
+index e32694c13da5..9b606f172f80 100644
+--- a/drivers/video/backlight/Kconfig
++++ b/drivers/video/backlight/Kconfig
+@@ -135,6 +135,12 @@ config LCD_OTM3225A
+ 	  If you have a panel based on the OTM3225A controller
+ 	  chip then say y to include a driver for it.
+ 
++config LCD_KD027
++	tristate "STARTEK KD027 LCD Driver"
++	help
++	  If you have a KD027 LCD panel, say Y to enable its LCD control
++	  driver.
++
+ endif # LCD_CLASS_DEVICE
+ 
+ #
+@@ -464,6 +470,12 @@ config BACKLIGHT_LED
+ 	  If you have a LCD backlight adjustable by LED class driver, say Y
+ 	  to enable this driver.
+ 
++config BACKLIGHT_OCP8178
++	tristate "OCP8178 Backlight Driver"
++	depends on GPIOLIB
++	help
++	  If you have an OCP8178, say Y to enable the backlight driver.
++
+ endif # BACKLIGHT_CLASS_DEVICE
+ 
+ endmenu
+diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
+index cae2c83422ae..7eaf58dda80f 100644
+--- a/drivers/video/backlight/Makefile
++++ b/drivers/video/backlight/Makefile
+@@ -17,6 +17,7 @@ obj-$(CONFIG_LCD_PLATFORM)		+= platform_lcd.o
+ obj-$(CONFIG_LCD_TDO24M)		+= tdo24m.o
+ obj-$(CONFIG_LCD_TOSA)			+= tosa_lcd.o
+ obj-$(CONFIG_LCD_VGG2432A4)		+= vgg2432a4.o
++obj-$(CONFIG_LCD_KD027)			+= kd027_lcd.o
+ 
+ obj-$(CONFIG_BACKLIGHT_88PM860X)	+= 88pm860x_bl.o
+ obj-$(CONFIG_BACKLIGHT_AAT2870)		+= aat2870_bl.o
+@@ -58,3 +59,4 @@ obj-$(CONFIG_BACKLIGHT_WM831X)		+= wm831x_bl.o
+ obj-$(CONFIG_BACKLIGHT_ARCXCNN) 	+= arcxcnn_bl.o
+ obj-$(CONFIG_BACKLIGHT_RAVE_SP)		+= rave-sp-backlight.o
+ obj-$(CONFIG_BACKLIGHT_LED)		+= led_bl.o
++obj-$(CONFIG_BACKLIGHT_OCP8178)		+= ocp8178_bl.o
+diff --git a/drivers/video/backlight/kd027_lcd.c b/drivers/video/backlight/kd027_lcd.c
+new file mode 100644
+index 000000000000..24abec39d3bd
+--- /dev/null
++++ b/drivers/video/backlight/kd027_lcd.c
+@@ -0,0 +1,250 @@
++/*
++ * kd027_lcd.c
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ *
++ *
++ */
++
++#include <linux/gpio.h> /* Only for legacy support */
++#include <linux/gpio/consumer.h>
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/of_gpio.h>
++#include <linux/platform_data/gpio_backlight.h>
++#include <linux/platform_device.h>
++#include <linux/slab.h>
++#include <linux/delay.h>
++#include <linux/timer.h>
++#include <linux/poll.h>
++#include <linux/proc_fs.h>
++#include <linux/seq_file.h>
++#include <linux/sched.h>
++#include <linux/interrupt.h>
++#include <linux/irq.h>
++#include <linux/io.h>
++#include <linux/clk.h>
++
++struct kd027_lcd {
++	struct gpio_desc* rst_pin;
++	struct gpio_desc* cs_pin;
++	struct gpio_desc* sck_pin;
++	struct gpio_desc* sda_pin;
++	unsigned char init_seq[100];
++	unsigned char suspend_seq[20];
++	unsigned char resume_seq[20];
++	int init_seq_len;
++	int suspend_seq_len;
++	int resume_seq_len;
++};
++
++struct kd027_lcd * lcd_data;
++
++static void kd027_write_lcd(unsigned char data)
++{
++	unsigned char i;
++
++	for(i = 0; i < 8; i++) {
++		if (data & 0x80)
++			gpiod_set_value(lcd_data->sda_pin, 1);
++		else
++			gpiod_set_value(lcd_data->sda_pin, 0);
++		gpiod_set_value(lcd_data->sck_pin, 0);
++		gpiod_set_value(lcd_data->sck_pin, 1);
++		data <<= 1;
++	}
++}
++
++static void kd027_write_cmd_data(unsigned char c, unsigned char d)
++{
++	gpiod_set_value(lcd_data->cs_pin, 0);
++	kd027_write_lcd(c);
++	kd027_write_lcd(d);
++	gpiod_set_value(lcd_data->cs_pin, 1);
++}
++
++static void kd027_init(void)
++{
++	int i;
++	for(i = 0; i < lcd_data->init_seq_len/2; i++) {
++		kd027_write_cmd_data(lcd_data->init_seq[i * 2], lcd_data->init_seq[i * 2 + 1]);
++	}
++}
++
++#ifdef CONFIG_PROC_FS
++static char global_buffer[64]; 
++
++static int kd027_proc_show(struct seq_file *m, void *v)
++{
++	seq_printf(m, "kd027\n");
++	return 0;
++}
++
++static int kd027_proc_open(struct inode *inode, struct file *file)
++{
++	return single_open(file, kd027_proc_show, NULL);
++}
++
++static ssize_t kd027_proc_read(struct file * file, char __user * buf, size_t size, loff_t * loff)
++{
++	return 0;
++}
++
++static ssize_t kd027_proc_write(struct file * file, const char __user * buf, size_t size, loff_t * loff)
++{
++	int cmd, data;
++	char* tmp;
++
++	if(copy_from_user(global_buffer, buf, size))
++		return -EFAULT;
++
++	global_buffer[size] = 0;
++	cmd = simple_strtol(global_buffer, 0, 16);
++	tmp = strchr(global_buffer, ' ');
++	if(tmp) {
++		data = simple_strtol(tmp+1, 0, 16);
++		kd027_write_cmd_data(cmd, data);
++	}
++
++	return size;
++}
++
++static const struct proc_ops kd027_proc_fops = {
++	.proc_open		= kd027_proc_open,
++	.proc_read		= kd027_proc_read,
++	.proc_write		= kd027_proc_write,
++	.proc_lseek		= seq_lseek,
++	.proc_release	= single_release,
++};
++
++static int __init kd027_proc_init(void)
++{
++	struct proc_dir_entry *r;
++
++	r = proc_create("driver/lcd", S_IRWXUGO, NULL, &kd027_proc_fops);
++	if (!r)
++		return -ENOMEM;
++	return 0;
++}
++#else
++static inline int kd027_proc_init(void) { return 0; }
++#endif /* CONFIG_PROC_FS */
++
++static int kd027_probe(struct platform_device *pdev)
++{
++	int ret;
++	struct device_node *np = pdev->dev.of_node;
++	struct device *dev = &pdev->dev;
++
++	if ( !np) {
++		dev_err(&pdev->dev,
++			"failed to find platform data or device tree node.\n");
++		return -ENODEV;
++	}
++
++	lcd_data = devm_kzalloc(&pdev->dev, sizeof(*lcd_data), GFP_KERNEL);
++	if (lcd_data == NULL)
++		return -ENOMEM;
++
++	lcd_data->init_seq_len =  of_property_read_variable_u8_array(np, "init-seq", lcd_data->init_seq, 1, 100);
++	lcd_data->suspend_seq_len =  of_property_read_variable_u8_array(np, "suspend-seq", lcd_data->suspend_seq, 1, 20);
++	lcd_data->resume_seq_len =  of_property_read_variable_u8_array(np, "resume-seq", lcd_data->resume_seq, 1, 20);
++
++	lcd_data->rst_pin = devm_gpiod_get(dev, "lcd-rst", GPIOD_OUT_HIGH);
++	if (IS_ERR(lcd_data->rst_pin)) {
++		ret = PTR_ERR(lcd_data->rst_pin);
++
++		if (ret != -EPROBE_DEFER) {
++			dev_err(dev,
++				"Error: The gpios parameter is missing or invalid.\n");
++		}
++		return ret;
++	}
++
++	lcd_data->cs_pin = devm_gpiod_get(dev, "lcd-cs", GPIOD_OUT_HIGH);
++	if (IS_ERR(lcd_data->cs_pin)) {
++		ret = PTR_ERR(lcd_data->cs_pin);
++
++		if (ret != -EPROBE_DEFER) {
++			dev_err(dev,
++				"Error: The gpios parameter is missing or invalid.\n");
++		}
++		return ret;
++	}
++
++	lcd_data->sck_pin = devm_gpiod_get(dev, "lcd-sck", GPIOD_OUT_HIGH);
++	if (IS_ERR(lcd_data->sck_pin)) {
++		ret = PTR_ERR(lcd_data->sck_pin);
++
++		if (ret != -EPROBE_DEFER) {
++			dev_err(dev,
++				"Error: The gpios parameter is missing or invalid.\n");
++		}
++		return ret;
++	}
++
++	lcd_data->sda_pin = devm_gpiod_get(dev, "lcd-sda", GPIOD_OUT_HIGH);
++	if (IS_ERR(lcd_data->sda_pin)) {
++		ret = PTR_ERR(lcd_data->sda_pin);
++
++		if (ret != -EPROBE_DEFER) {
++			dev_err(dev,
++				"Error: The gpios parameter is missing or invalid.\n");
++		}
++		return ret;
++	}
++
++	kd027_init();
++	kd027_proc_init();
++
++	return 0;
++}
++
++static int kd027_suspend(struct platform_device * pdev, pm_message_t state)
++{
++	int i;
++	for(i = 0; i < lcd_data->suspend_seq_len/2; i++) {
++		kd027_write_cmd_data(lcd_data->suspend_seq[i * 2], lcd_data->suspend_seq[i * 2 + 1]);
++	}
++	return 0;
++}
++
++static int kd027_resume(struct platform_device * pdev)
++{
++	int i;
++	for(i = 0; i < lcd_data->resume_seq_len/2; i++) {
++		kd027_write_cmd_data(lcd_data->resume_seq[i * 2], lcd_data->resume_seq[i * 2 + 1]);
++	}
++	return 0;
++}
++
++#ifdef CONFIG_OF
++static struct of_device_id kd027_of_match[] = {
++	{ .compatible = "kd027-lcd" },
++	{ /* sentinel */ }
++};
++
++MODULE_DEVICE_TABLE(of, kd027_of_match);
++#endif
++
++static struct platform_driver kd027_device_driver = {
++	.probe		= kd027_probe,
++	.suspend 		= kd027_suspend,
++	.resume 		= kd027_resume,
++	.driver		= {
++		.name		= "kd027-lcd",
++		.of_match_table = of_match_ptr(kd027_of_match),
++	},
++};
++
++module_platform_driver(kd027_device_driver);
++
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("KD027 Driver");
++
+diff --git a/drivers/video/backlight/ocp8178_bl.c b/drivers/video/backlight/ocp8178_bl.c
+new file mode 100644
+index 000000000000..0ffb9e513e50
+--- /dev/null
++++ b/drivers/video/backlight/ocp8178_bl.c
+@@ -0,0 +1,349 @@
++/*
++ * ocp8178_bl.c - ocp8178 backlight driver
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++
++#include <linux/backlight.h>
++#include <linux/err.h>
++#include <linux/fb.h>
++#include <linux/gpio.h> /* Only for legacy support */
++#include <linux/gpio/consumer.h>
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/of_gpio.h>
++#include <linux/platform_data/gpio_backlight.h>
++#include <linux/platform_device.h>
++#include <linux/slab.h>
++#include <linux/delay.h>
++#include <linux/timer.h>
++#include <linux/poll.h>
++#include <linux/proc_fs.h>
++#include <linux/seq_file.h>
++#include <linux/sched.h>
++#include <linux/interrupt.h>
++#include <linux/irq.h>
++#include <linux/io.h>
++#include <linux/clk.h>
++
++struct ocp8178_backlight {
++	struct device *dev;
++	struct device *fbdev;
++
++	struct gpio_desc *gpiod;
++	int def_value;
++	int current_value;
++};
++
++#define DETECT_DELAY 200
++#define DETECT_TIME 500
++#define DETECT_WINDOW_TIME 1000
++#define START_TIME 10
++#define END_TIME 10
++#define SHUTDOWN_TIME 3000
++#define LOW_BIT_HIGH_TIME 10
++#define LOW_BIT_LOW_TIME 50
++#define HIGH_BIT_HIGH_TIME 50
++#define HIGH_BIT_LOW_TIME 10
++#define MAX_BRIGHTNESS_VALUE 9
++
++static void entry_1wire_mode(struct ocp8178_backlight *gbl)
++{
++	unsigned long flags = 0;
++	local_irq_save(flags);
++	gpiod_set_value(gbl->gpiod, 0);
++	mdelay(SHUTDOWN_TIME/1000);
++	gpiod_set_value(gbl->gpiod, 1);
++	udelay(DETECT_DELAY);
++	gpiod_set_value(gbl->gpiod, 0);
++	udelay(DETECT_TIME);
++	gpiod_set_value(gbl->gpiod, 1);
++	udelay(DETECT_WINDOW_TIME);
++	local_irq_restore(flags);
++}
++
++static inline void write_bit(struct ocp8178_backlight *gbl, int bit)
++{
++	if (bit) {
++		gpiod_set_value(gbl->gpiod, 0);
++		udelay(HIGH_BIT_LOW_TIME);
++		gpiod_set_value(gbl->gpiod, 1);
++		udelay(HIGH_BIT_HIGH_TIME);
++	} else {
++		gpiod_set_value(gbl->gpiod, 0);
++		udelay(LOW_BIT_LOW_TIME);
++		gpiod_set_value(gbl->gpiod, 1);
++		udelay(LOW_BIT_HIGH_TIME);
++	}
++}
++
++static void write_byte(struct ocp8178_backlight *gbl, int byte)
++{
++	unsigned long flags = 0;
++	unsigned char data = 0x72;
++	int i;
++
++	local_irq_save(flags);
++
++	gpiod_set_value(gbl->gpiod, 1);
++	udelay(START_TIME);
++	for(i = 0; i < 8; i++) {
++		if(data & 0x80) {
++			write_bit(gbl, 1);
++		} else {
++			write_bit(gbl, 0);
++		}
++		data <<= 1;
++	}
++	gpiod_set_value(gbl->gpiod, 0);
++	udelay(END_TIME);
++
++	data = byte & 0x1f;
++
++	gpiod_set_value(gbl->gpiod, 1);
++	udelay(START_TIME);
++	for(i = 0; i < 8; i++) {
++		if(data & 0x80) {
++			write_bit(gbl, 1);
++		} else {
++			write_bit(gbl, 0);
++		}
++		data <<= 1;
++	}
++	gpiod_set_value(gbl->gpiod, 0);
++	udelay(END_TIME);
++	gpiod_set_value(gbl->gpiod, 1);
++
++	local_irq_restore(flags);
++}
++
++unsigned char ocp8178_bl_table[MAX_BRIGHTNESS_VALUE+1] = {0, 1, 4, 8, 12, 16, 20, 24, 28, 31};
++
++static int ocp8178_update_status(struct backlight_device *bl)
++{
++	struct ocp8178_backlight *gbl = bl_get_data(bl);
++	int brightness = bl->props.brightness;
++
++	if (bl->props.power != FB_BLANK_UNBLANK ||
++	    bl->props.fb_blank != FB_BLANK_UNBLANK ||
++	    bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK))
++		brightness = 0;
++
++	if(brightness > MAX_BRIGHTNESS_VALUE) {
++		brightness = MAX_BRIGHTNESS_VALUE;
++	}
++
++	write_byte(gbl, ocp8178_bl_table[brightness]);
++	gbl->current_value = brightness;
++
++	return 0;
++}
++
++static int ocp8178_get_brightness(struct backlight_device *bl)
++{
++	struct ocp8178_backlight *gbl = bl_get_data(bl);
++	return gbl->current_value;
++}
++
++static int ocp8178_check_fb(struct backlight_device *bl,
++				   struct fb_info *info)
++{
++	struct ocp8178_backlight *gbl = bl_get_data(bl);
++	return gbl->fbdev == NULL || gbl->fbdev == info->dev;
++}
++
++static const struct backlight_ops ocp8178_backlight_ops = {
++	.options	= BL_CORE_SUSPENDRESUME,
++	.update_status	= ocp8178_update_status,
++	.get_brightness = ocp8178_get_brightness,
++	.check_fb	= ocp8178_check_fb,
++};
++
++static int ocp8178_probe_dt(struct platform_device *pdev,
++				   struct ocp8178_backlight *gbl)
++{
++	struct device *dev = &pdev->dev;
++	struct device_node *np = dev->of_node;
++	enum gpiod_flags flags;
++	int ret = 0;
++	u32 value32;
++
++	of_property_read_u32(np, "default-brightness", &value32);
++	if(value32 > MAX_BRIGHTNESS_VALUE)
++		gbl->def_value = MAX_BRIGHTNESS_VALUE;
++	else
++		gbl->def_value = value32;
++	flags = gbl->def_value ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
++
++	gbl->gpiod = devm_gpiod_get(dev, "backlight-control", flags);
++	if (IS_ERR(gbl->gpiod)) {
++		ret = PTR_ERR(gbl->gpiod);
++
++		if (ret != -EPROBE_DEFER) {
++			dev_err(dev,
++				"Error: The gpios parameter is missing or invalid.\n");
++		}
++	}
++
++	return ret;
++}
++
++static struct backlight_device *backlight;
++
++#ifdef CONFIG_PROC_FS
++static char global_buffer[64];
++
++static int ocp8178_proc_show(struct seq_file *m, void *v)
++{
++	seq_printf(m, "ocp8178\n");
++	return 0;
++}
++
++static int ocp8178_proc_open(struct inode *inode, struct file *file)
++{
++	return single_open(file, ocp8178_proc_show, NULL);
++}
++
++static int ocp8178_proc_read(struct file * file, char __user * buf, size_t size, loff_t * loff)
++{
++	int value, len;
++	struct backlight_device *bl = backlight;
++	value = ocp8178_get_brightness(bl);
++	len = snprintf(global_buffer, sizeof(global_buffer), "%d\n", value);
++	return simple_read_from_buffer(buf, size, loff, global_buffer, len);
++}
++
++static int ocp8178_proc_write(struct file * file, const char __user * buf, size_t size, loff_t * loff)
++{
++	int data;
++	struct backlight_device *bl = backlight;
++
++	if(copy_from_user(global_buffer, buf, size))
++		return -EFAULT;
++
++	global_buffer[size] = 0;
++	if(global_buffer[0] == '+') {
++		bl->props.brightness = (bl->props.brightness + 1) % (MAX_BRIGHTNESS_VALUE + 1);
++	} else if(global_buffer[0] == '-') {
++		bl->props.brightness = (bl->props.brightness + MAX_BRIGHTNESS_VALUE) % (MAX_BRIGHTNESS_VALUE + 1);
++	} else {
++		data = simple_strtol(global_buffer, 0, 10);
++		if(data < 0) {
++			bl->props.brightness = 0;
++		} else if(data > MAX_BRIGHTNESS_VALUE) {
++			bl->props.brightness = MAX_BRIGHTNESS_VALUE;
++		} else {
++			bl->props.brightness = data;
++		}
++	}
++	backlight_update_status(bl);
++
++	return size;
++}
++
++static const struct proc_ops ocp8178_proc_fops = {
++	.proc_open		= ocp8178_proc_open,
++	.proc_read		= ocp8178_proc_read,
++	.proc_write		= ocp8178_proc_write,
++	.proc_lseek		= seq_lseek,
++	.proc_release	= single_release,
++};
++
++static int __init ocp8178_proc_init(void)
++{
++	struct proc_dir_entry *r;
++
++	r = proc_create("driver/backlight", S_IRWXUGO, NULL, &ocp8178_proc_fops);
++	if (!r)
++		return -ENOMEM;
++	return 0;
++}
++#else
++static inline int ocp8178_proc_init(void) { return 0; }
++#endif /* CONFIG_PROC_FS */
++
++static int ocp8178_probe(struct platform_device *pdev)
++{
++	struct backlight_properties props;
++	struct backlight_device *bl;
++	struct ocp8178_backlight *gbl;
++	struct device_node *np = pdev->dev.of_node;
++	int ret;
++
++	if ( !np) {
++		dev_err(&pdev->dev,
++			"failed to find platform data or device tree node.\n");
++		return -ENODEV;
++	}
++
++	gbl = devm_kzalloc(&pdev->dev, sizeof(*gbl), GFP_KERNEL);
++	if (gbl == NULL)
++		return -ENOMEM;
++
++	gbl->dev = &pdev->dev;
++
++	ret = ocp8178_probe_dt(pdev, gbl);
++	if (ret)
++		return ret;
++
++	gbl->current_value = gbl->def_value;
++
++	memset(&props, 0, sizeof(props));
++	props.type = BACKLIGHT_RAW;
++	props.max_brightness = MAX_BRIGHTNESS_VALUE;
++	bl = devm_backlight_device_register(&pdev->dev, dev_name(&pdev->dev),
++					&pdev->dev, gbl, &ocp8178_backlight_ops,
++					&props);
++	if (IS_ERR(bl)) {
++		dev_err(&pdev->dev, "failed to register backlight\n");
++		return PTR_ERR(bl);
++	}
++
++	entry_1wire_mode(gbl);
++
++	bl->props.brightness = gbl->def_value;
++	backlight_update_status(bl);
++
++	platform_set_drvdata(pdev, bl);
++
++	backlight = bl;
++	ocp8178_proc_init();
++
++	return 0;
++}
++
++static int ocp8178_suspend(struct platform_device *pdev, pm_message_t state)
++{
++	return 0;
++}
++
++static int ocp8178_resume(struct platform_device *pdev)
++{
++	return 0;
++}
++
++static struct of_device_id ocp8178_of_match[] = {
++	{ .compatible = "ocp8178-backlight" },
++	{ /* sentinel */ }
++};
++
++MODULE_DEVICE_TABLE(of, ocp8178_of_match);
++
++static struct platform_driver ocp8178_driver = {
++	.driver		= {
++		.name		= "ocp8178-backlight",
++		.of_match_table = of_match_ptr(ocp8178_of_match),
++	},
++	.probe		= ocp8178_probe,
++	.suspend		= ocp8178_suspend,
++	.resume		= ocp8178_resume,
++};
++
++module_platform_driver(ocp8178_driver);
++
++MODULE_DESCRIPTION("OCP8178 Driver");
++MODULE_LICENSE("GPL");
+diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
+index e035a63bbe5b..b2eb9cf314fb 100644
+--- a/drivers/video/fbdev/core/fbcon.c
++++ b/drivers/video/fbdev/core/fbcon.c
+@@ -357,6 +357,7 @@ static int get_color(struct vc_data *vc, struct fb_info *info,
+ 
+ static void fb_flashcursor(struct work_struct *work)
+ {
++#if 0
+ 	struct fb_info *info = container_of(work, struct fb_info, queue);
+ 	struct fbcon_ops *ops = info->fbcon_par;
+ 	struct vc_data *vc = NULL;
+@@ -387,6 +388,7 @@ static void fb_flashcursor(struct work_struct *work)
+ 	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ 	console_unlock();
++#endif
+ }
+ 
+ static void cursor_timer_handler(struct timer_list *t)
+@@ -1319,6 +1321,7 @@ static void fbcon_clear_margins(struct vc_data *vc, int bottom_only)
+ 
+ static void fbcon_cursor(struct vc_data *vc, int mode)
+ {
++#if 0
+ 	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
+ 	struct fbcon_ops *ops = info->fbcon_par;
+  	int c = scr_readw((u16 *) vc->vc_pos);
+@@ -1340,6 +1343,7 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
+ 
+ 	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
++#endif
+ }
+ 
+ static int scrollback_phys_max = 0;
+diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
+index 528c87ff14d8..21ae9491051c 100644
+--- a/drivers/video/fbdev/core/fbmem.c
++++ b/drivers/video/fbdev/core/fbmem.c
+@@ -524,6 +524,9 @@ static int fb_show_logo_line(struct fb_info *info, int rotate,
+ 
+ 	image.width = logo->width;
+ 	image.height = logo->height;
++	image.dx = (info->var.xres/2) - (logo->width/2);
++	image.dy = (info->var.yres/2) - (logo->height/2);
++	n = 1;
+ 
+ 	if (rotate) {
+ 		logo_rotate = kmalloc_array(logo->width, logo->height,

v0.6/515_dts.patch

@@ -0,0 +1,804 @@
+diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
+index 7a72fc636a7a..fa7ad973969c 100644
+--- a/arch/arm/boot/dts/Makefile
++++ b/arch/arm/boot/dts/Makefile
+@@ -1267,6 +1267,8 @@ dtb-$(CONFIG_MACH_SUN8I) += \
+ 	sun8i-h3-zeropi.dtb \
+ 	sun8i-h3-emlid-neutis-n5h3-devboard.dtb \
+ 	sun8i-r16-bananapi-m2m.dtb \
++	sun8i-r16-clockworkpi-cpi3.dtb \
++	sun8i-r16-clockworkpi-cpi3-hdmi.dtb \
+ 	sun8i-r16-nintendo-nes-classic.dtb \
+ 	sun8i-r16-nintendo-super-nes-classic.dtb \
+ 	sun8i-r16-parrot.dtb \
+diff --git a/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3-hdmi.dts b/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3-hdmi.dts
+new file mode 100644
+index 000000000000..e2c15df25b30
+--- /dev/null
++++ b/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3-hdmi.dts
+@@ -0,0 +1,380 @@
++/*
++ * Copyright (c) 2018 Clockwork
++ *
++ * This file is dual-licensed: you can use it either under the terms
++ * of the GPL or the X11 license, at your option. Note that this dual
++ * licensing only applies to this file, and not this project as a
++ * whole.
++ *
++ *  a) This file is free software; you can redistribute it and/or
++ *     modify it under the terms of the GNU General Public License as
++ *     published by the Free Software Foundation; either version 2 of the
++ *     License, or (at your option) any later version.
++ *
++ *     This file is distributed in the hope that it will be useful,
++ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *     GNU General Public License for more details.
++ *
++ * Or, alternatively,
++ *
++ *  b) Permission is hereby granted, free of charge, to any person
++ *     obtaining a copy of this software and associated documentation
++ *     files (the "Software"), to deal in the Software without
++ *     restriction, including without limitation the rights to use,
++ *     copy, modify, merge, publish, distribute, sublicense, and/or
++ *     sell copies of the Software, and to permit persons to whom the
++ *     Software is furnished to do so, subject to the following
++ *     conditions:
++ *
++ *     The above copyright notice and this permission notice shall be
++ *     included in all copies or substantial portions of the Software.
++ *
++ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ *     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
++ *     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ *     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
++ *     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
++ *     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ *     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++ *     OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/dts-v1/;
++#include "sun8i-a33.dtsi"
++#include "sunxi-common-regulators.dtsi"
++
++#include <dt-bindings/gpio/gpio.h>
++#include <dt-bindings/input/input.h>
++
++/ {
++	model = "Clockwork CPI3";
++	compatible = "clockwork,clockworkpi-cpi3", "allwinner,sun8i-a33";
++
++	aliases {
++		serial0 = &uart0;
++		mmc0 = &mmc0;
++		mmc1 = &mmc1;
++	};
++
++	chosen {
++		stdout-path = "serial0:115200n8";
++	};
++
++	leds {
++		compatible = "gpio-leds";
++		pinctrl-names = "default";
++		pinctrl-0 = <&led_pins>;
++
++		led1 {
++			label = "led1";
++			gpios = <&pio 1 7 GPIO_ACTIVE_LOW>; /* PB7 */
++		};
++	};
++
++	wifi_pwrseq: wifi_pwrseq {
++		compatible = "mmc-pwrseq-simple";
++		reset-gpios = <&r_pio 0 6 GPIO_ACTIVE_LOW>; /* PL6 */
++	};
++
++	rfkill_gpio: rfkill_gpio {
++		compatible = "rfkill_gpio";
++		type = "bluetooth";
++		pinctrl-names = "default";
++		pinctrl-0 = <&bt_control_pin>;
++		reset-gpio = <&r_pio 0 8 GPIO_ACTIVE_HIGH>; /* PL8 */
++		shutdown-gpio = <&r_pio 0 10 GPIO_ACTIVE_LOW>; /* PL10 */
++	};
++
++	panel {
++		compatible = "clockwork,cpi3-hdmi";
++
++		ports {
++			#address-cells = <1>;
++			#size-cells = <0>;
++			port@0 {
++				#address-cells = <1>;
++				#size-cells = <0>;
++				reg = <0>;
++
++				rgb_input: endpoint@0 {
++					reg = <0>;
++					remote-endpoint = <&tcon0_out_rgb>;
++				};
++			};
++		};
++	};
++};
++
++&codec {
++	pinctrl-names = "default";
++	pinctrl-0 = <&hdmi_i2s_pins>;
++	status = "okay";
++};
++
++&dai {
++	status = "okay";
++};
++
++&sound {
++	simple-audio-card,routing =
++		"AIF2 ADCL Stereo Mux", "AIF2 ADCL",
++		"AIF1 DA0L", "AIF1 DA0L Stereo Mux",
++		"AIF2 ADCR Stereo Mux", "AIF2 ADCR",
++		"AIF1 DA0R", "AIF1 DA0R Stereo Mux";
++
++	status = "okay";
++};
++
++&link_codec {
++	sound-dai = <&codec 1>;
++};
++
++&de {
++	status = "okay";
++};
++
++&tcon0 {
++	status = "okay";
++};
++
++&tcon0_out {
++	tcon0_out_rgb: endpoint@0 {
++		reg = <0>;
++		remote-endpoint = <&rgb_input>;
++	};
++};
++
++&ehci0 {
++	status = "okay";
++};
++
++&mmc0 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&mmc0_pins>, <&mmc0_cd_pin>;
++	vmmc-supply = <&reg_dcdc1>;
++	cd-gpios = <&pio 1 3 GPIO_ACTIVE_LOW>; /* PB3 */
++	bus-width = <4>;
++	status = "okay";
++};
++
++&mmc1 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&mmc1_pg_pins>, <&wifi_reset_pin>;
++	vmmc-supply = <&reg_aldo1>;
++	mmc-pwrseq = <&wifi_pwrseq>;
++	bus-width = <4>;
++	non-removable;
++	keep-power-in-suspend;
++	status = "okay";
++};
++
++&ohci0 {
++	status = "okay";
++};
++
++&pio {
++	mmc0_cd_pin: mmc0_cd_pin@0 {
++		pins = "PB3";
++		function = "gpio_in";
++		bias-pull-up;
++	};
++
++	hdmi_i2s_pins: hdmi_i2s_pins@0 {
++		pins = "PB4", "PB5", "PB6";
++		function = "aif2";
++	};
++
++	led_pins: led_pins@0 {
++		pins = "PB7";
++		function = "gpio_out";
++	};
++};
++
++&r_pio {
++	usb1_vbus_pin: usb1_vbus_pin@0 {
++		pins = "PL2";
++		function = "gpio_out";
++	};
++
++	usb0_id_det: usb0_id_detect_pin@0 {
++		pins = "PL4";
++		function = "gpio_in";
++		bias-pull-up;
++	};
++
++	wifi_reset_pin: wifi_reset_pin@0 {
++		pins = "PL6";
++		function = "gpio_out";
++	};
++
++	bt_control_pin: bt_control_pin@0 {
++		pins = "PL8", "PL10";
++		function = "gpio_out";
++	};
++};
++
++&r_rsb {
++	status = "okay";
++
++	axp22x: pmic@3a3 {
++		compatible = "x-powers,axp223";
++		reg = <0x3a3>;
++		interrupt-parent = <&r_intc>;
++		interrupts = <GIC_SPI 32 IRQ_TYPE_LEVEL_LOW>;
++		drivevbus-supply = <&reg_vcc5v0>;
++		x-powers,drive-vbus-en;
++	};
++};
++
++#include "axp223.dtsi"
++
++&reg_aldo1 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-io";
++};
++
++&reg_aldo2 {
++	regulator-always-on;
++	regulator-min-microvolt = <2500000>;
++	regulator-max-microvolt = <2500000>;
++	regulator-name = "vdd-dll";
++};
++
++&reg_aldo3 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-pll-avcc";
++};
++
++&reg_dc5ldo {
++	regulator-always-on;
++	regulator-min-microvolt = <1100000>;
++	regulator-max-microvolt = <1100000>;
++	regulator-name = "vdd-cpus";
++};
++
++&reg_dcdc1 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-3v0";
++};
++
++&reg_dcdc2 {
++	regulator-always-on;
++	regulator-min-microvolt = <1100000>;
++	regulator-max-microvolt = <1100000>;
++	regulator-name = "vdd-sys";
++};
++
++&reg_dcdc3 {
++	regulator-always-on;
++	regulator-min-microvolt = <1200000>;
++	regulator-max-microvolt = <1200000>;
++	regulator-name = "vdd-cpu";
++};
++
++&reg_dcdc5 {
++	regulator-always-on;
++	regulator-min-microvolt = <1500000>;
++	regulator-max-microvolt = <1500000>;
++	regulator-name = "vcc-dram";
++};
++
++&reg_dldo1 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi0";
++};
++
++&reg_dldo2 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi1";
++};
++
++&reg_dldo3 {
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-amp";
++};
++
++&reg_dldo4 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 AND dldo4 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi2";
++};
++
++&reg_drivevbus {
++	regulator-name = "usb0-vbus";
++	status = "okay";
++};
++
++&reg_eldo1 {
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-hdmi";
++};
++
++&reg_usb1_vbus {
++	pinctrl-names = "default";
++	pinctrl-0 = <&usb1_vbus_pin>;
++	gpio = <&r_pio 0 2 GPIO_ACTIVE_HIGH>; /* PL2 */
++	status = "okay";
++};
++
++&battery_power_supply {
++	status = "okay";
++};
++
++&uart0 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&uart0_pb_pins>;
++	status = "okay";
++};
++
++&uart1 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&uart1_pg_pins>, <&uart1_cts_rts_pg_pins>;
++	status = "okay";
++};
++
++&usb_otg {
++	dr_mode = "otg";
++	status = "okay";
++};
++
++&usb_power_supply {
++	status = "okay";
++};
++
++&usbphy {
++	status = "okay";
++	pinctrl-names = "default";
++	pinctrl-0 = <&usb0_id_det>;
++	usb0_vbus-supply = <&reg_drivevbus>;
++	usb0_id_det-gpios = <&r_pio 0 4 GPIO_ACTIVE_HIGH>; /* PL4 */
++	usb0_vbus_power-supply = <&usb_power_supply>;
++	usb1_vbus-supply = <&reg_usb1_vbus>;
++};
+diff --git a/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3.dts b/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3.dts
+new file mode 100644
+index 000000000000..a3e04b8adf8d
+--- /dev/null
++++ b/arch/arm/boot/dts/sun8i-r16-clockworkpi-cpi3.dts
+@@ -0,0 +1,399 @@
++/*
++ * Copyright (c) 2018 Clockwork
++ *
++ * This file is dual-licensed: you can use it either under the terms
++ * of the GPL or the X11 license, at your option. Note that this dual
++ * licensing only applies to this file, and not this project as a
++ * whole.
++ *
++ *  a) This file is free software; you can redistribute it and/or
++ *     modify it under the terms of the GNU General Public License as
++ *     published by the Free Software Foundation; either version 2 of the
++ *     License, or (at your option) any later version.
++ *
++ *     This file is distributed in the hope that it will be useful,
++ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *     GNU General Public License for more details.
++ *
++ * Or, alternatively,
++ *
++ *  b) Permission is hereby granted, free of charge, to any person
++ *     obtaining a copy of this software and associated documentation
++ *     files (the "Software"), to deal in the Software without
++ *     restriction, including without limitation the rights to use,
++ *     copy, modify, merge, publish, distribute, sublicense, and/or
++ *     sell copies of the Software, and to permit persons to whom the
++ *     Software is furnished to do so, subject to the following
++ *     conditions:
++ *
++ *     The above copyright notice and this permission notice shall be
++ *     included in all copies or substantial portions of the Software.
++ *
++ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ *     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
++ *     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ *     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
++ *     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
++ *     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ *     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++ *     OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/dts-v1/;
++#include "sun8i-a33.dtsi"
++#include "sunxi-common-regulators.dtsi"
++
++#include <dt-bindings/gpio/gpio.h>
++#include <dt-bindings/input/input.h>
++
++/ {
++	model = "Clockwork CPI3";
++	compatible = "clockwork,clockworkpi-cpi3", "allwinner,sun8i-a33";
++
++	aliases {
++		serial0 = &uart0;
++		mmc0 = &mmc0;
++		mmc1 = &mmc1;
++	};
++
++	chosen {
++		stdout-path = "serial0:115200n8";
++	};
++
++	leds {
++		compatible = "gpio-leds";
++		pinctrl-names = "default";
++		pinctrl-0 = <&led_pins>;
++
++		led1 {
++			label = "led1";
++			gpios = <&pio 1 7 GPIO_ACTIVE_LOW>; /* PB7 */
++		};
++	};
++
++	wifi_pwrseq: wifi_pwrseq {
++		compatible = "mmc-pwrseq-simple";
++		reset-gpios = <&r_pio 0 6 GPIO_ACTIVE_LOW>; /* PL6 */
++	};
++
++	rfkill_gpio: rfkill_gpio {
++		compatible = "rfkill_gpio";
++		type = "bluetooth";
++		pinctrl-names = "default";
++		pinctrl-0 = <&bt_control_pin>;
++		reset-gpio = <&r_pio 0 8 GPIO_ACTIVE_HIGH>; /* PL8 */
++		shutdown-gpio = <&r_pio 0 10 GPIO_ACTIVE_LOW>; /* PL10 */
++	};
++
++	backlight {
++		compatible = "ocp8178-backlight";
++		pinctrl-names = "default";
++		pinctrl-0 = <&backlight_control_pin>;
++		backlight-control-gpios = <&pio 7 1 GPIO_ACTIVE_HIGH>; /* PH1 */
++		default-brightness = <5>;
++	};
++
++	lcd {
++		compatible = "kd027-lcd";
++		pinctrl-names = "default";
++		pinctrl-0 = <&lcd_control_pin>;
++		lcd-rst-gpios = <&pio 1 2 GPIO_ACTIVE_HIGH>; /* PB2 */
++		lcd-cs-gpios = <&pio 2 3 GPIO_ACTIVE_HIGH>; /* PC3 */
++		lcd-sck-gpios = <&pio 2 2 GPIO_ACTIVE_HIGH>; /* PC2 */
++		lcd-sda-gpios = <&pio 2 0 GPIO_ACTIVE_HIGH>; /* PC0 */
++		init-seq = /bits/ 8 <0x2b 0x01 0x00 0x07 0x0c 0x27 0x16 0x04>;
++		suspend-seq = /bits/ 8 <0x2b 0x00>;
++		resume-seq = /bits/ 8 <0x2b 0x01>;
++	};
++
++	panel {
++		compatible = "clockwork,cpi3-lcd";
++
++		ports {
++			#address-cells = <1>;
++			#size-cells = <0>;
++			port@0 {
++				#address-cells = <1>;
++				#size-cells = <0>;
++				reg = <0>;
++
++				rgb_input: endpoint@0 {
++					reg = <0>;
++					remote-endpoint = <&tcon0_out_rgb>;
++				};
++			};
++		};
++	};
++};
++
++&codec {
++	status = "okay";
++};
++
++&dai {
++	status = "okay";
++};
++
++&sound {
++	status = "okay";
++};
++
++&codec_analog {
++	pinctrl-names = "default";
++	pinctrl-0 = <&speaker_amplifier_pin>;
++	speaker-amplifier-gpios = <&r_pio 0 3 GPIO_ACTIVE_HIGH>; /* PL3 */
++	interrupts = <GIC_SPI 46 IRQ_TYPE_LEVEL_HIGH>;
++};
++
++&de {
++	status = "okay";
++};
++
++&tcon0 {
++	status = "okay";
++};
++
++&tcon0_out {
++	tcon0_out_rgb: endpoint@0 {
++		reg = <0>;
++		remote-endpoint = <&rgb_input>;
++	};
++};
++
++&ehci0 {
++	status = "okay";
++};
++
++&mmc0 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&mmc0_pins>, <&mmc0_cd_pin>;
++	vmmc-supply = <&reg_dcdc1>;
++	cd-gpios = <&pio 1 3 GPIO_ACTIVE_LOW>; /* PB3 */
++	bus-width = <4>;
++	status = "okay";
++};
++
++&mmc1 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&mmc1_pg_pins>, <&wifi_reset_pin>;
++	vmmc-supply = <&reg_aldo1>;
++	mmc-pwrseq = <&wifi_pwrseq>;
++	bus-width = <4>;
++	non-removable;
++	keep-power-in-suspend;
++	status = "okay";
++};
++
++&ohci0 {
++	status = "okay";
++};
++
++&pio {
++	mmc0_cd_pin: mmc0_cd_pin@0 {
++		pins = "PB3";
++		function = "gpio_in";
++		bias-pull-up;
++	};
++
++	led_pins: led_pins@0 {
++		pins = "PB7";
++		function = "gpio_out";
++	};
++
++	lcd_control_pin: lcd_control_pin@0 {
++		pins = "PB2", "PC0", "PC2", "PC3";
++		function = "gpio_out";
++	};
++
++	backlight_control_pin: backlight_control_pin@0 {
++		pins = "PH1";
++		function = "gpio_out";
++	};
++};
++
++&r_pio {
++	usb1_vbus_pin: usb1_vbus_pin@0 {
++		pins = "PL2";
++		function = "gpio_out";
++	};
++
++	speaker_amplifier_pin: speaker_amplifier_pin@0 {
++		pins = "PL3";
++		function = "gpio_out";
++	};
++
++	usb0_id_det: usb0_id_detect_pin@0 {
++		pins = "PL4";
++		function = "gpio_in";
++		bias-pull-up;
++	};
++
++	wifi_reset_pin: wifi_reset_pin@0 {
++		pins = "PL6";
++		function = "gpio_out";
++	};
++
++	bt_control_pin: bt_control_pin@0 {
++		pins = "PL8", "PL10";
++		function = "gpio_out";
++	};
++};
++
++&r_rsb {
++	status = "okay";
++
++	axp22x: pmic@3a3 {
++		compatible = "x-powers,axp223";
++		reg = <0x3a3>;
++		interrupt-parent = <&r_intc>;
++		interrupts = <GIC_SPI 32 IRQ_TYPE_LEVEL_LOW>;
++		drivevbus-supply = <&reg_vcc5v0>;
++		x-powers,drive-vbus-en;
++	};
++};
++
++#include "axp223.dtsi"
++
++&reg_aldo1 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-io";
++};
++
++&reg_aldo2 {
++	regulator-always-on;
++	regulator-min-microvolt = <2500000>;
++	regulator-max-microvolt = <2500000>;
++	regulator-name = "vdd-dll";
++};
++
++&reg_aldo3 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-pll-avcc";
++};
++
++&reg_dc5ldo {
++	regulator-always-on;
++	regulator-min-microvolt = <1100000>;
++	regulator-max-microvolt = <1100000>;
++	regulator-name = "vdd-cpus";
++};
++
++&reg_dcdc1 {
++	regulator-always-on;
++	regulator-min-microvolt = <3000000>;
++	regulator-max-microvolt = <3000000>;
++	regulator-name = "vcc-3v0";
++};
++
++&reg_dcdc2 {
++	regulator-always-on;
++	regulator-min-microvolt = <1100000>;
++	regulator-max-microvolt = <1100000>;
++	regulator-name = "vdd-sys";
++};
++
++&reg_dcdc3 {
++	regulator-always-on;
++	regulator-min-microvolt = <1200000>;
++	regulator-max-microvolt = <1200000>;
++	regulator-name = "vdd-cpu";
++};
++
++&reg_dcdc5 {
++	regulator-always-on;
++	regulator-min-microvolt = <1500000>;
++	regulator-max-microvolt = <1500000>;
++	regulator-name = "vcc-dram";
++};
++
++&reg_dldo1 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi0";
++};
++
++&reg_dldo2 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi1";
++};
++
++&reg_dldo3 {
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-amp";
++};
++
++&reg_dldo4 {
++	/*
++	 * TODO: WiFi chip needs dldo1 AND dldo2 AND dldo4 to be on to be powered.
++	 * Remove next line once it is possible to sync two regulators.
++	 */
++	regulator-always-on;
++	regulator-min-microvolt = <3300000>;
++	regulator-max-microvolt = <3300000>;
++	regulator-name = "vcc-wifi2";
++};
++
++&reg_drivevbus {
++	regulator-name = "usb0-vbus";
++	status = "okay";
++};
++
++&reg_usb1_vbus {
++	pinctrl-names = "default";
++	pinctrl-0 = <&usb1_vbus_pin>;
++	gpio = <&r_pio 0 2 GPIO_ACTIVE_HIGH>; /* PL2 */
++	status = "okay";
++};
++
++&battery_power_supply {
++	status = "okay";
++};
++
++&uart0 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&uart0_pb_pins>;
++	status = "okay";
++};
++
++&uart1 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&uart1_pg_pins>, <&uart1_cts_rts_pg_pins>;
++	status = "okay";
++};
++
++&usb_otg {
++	dr_mode = "otg";
++	status = "okay";
++};
++
++&usb_power_supply {
++	status = "okay";
++};
++
++&usbphy {
++	status = "okay";
++	pinctrl-names = "default";
++	pinctrl-0 = <&usb0_id_det>;
++	usb0_vbus-supply = <&reg_drivevbus>;
++	usb0_id_det-gpios = <&r_pio 0 4 GPIO_ACTIVE_HIGH>; /* PL4 */
++	usb0_vbus_power-supply = <&usb_power_supply>;
++	usb1_vbus-supply = <&reg_usb1_vbus>;
++};

v0.6/515_power.patch

@@ -0,0 +1,170 @@
+diff --git a/drivers/input/misc/axp20x-pek.c b/drivers/input/misc/axp20x-pek.c
+index 9c6386b2af33..6cf1ddda0788 100644
+--- a/drivers/input/misc/axp20x-pek.c
++++ b/drivers/input/misc/axp20x-pek.c
+@@ -215,10 +215,13 @@ static irqreturn_t axp20x_pek_irq(int irq, void *pwr)
+ 	 * The power-button is connected to ground so a falling edge (dbf)
+ 	 * means it is pressed.
+ 	 */
+-	if (irq == axp20x_pek->irq_dbf)
++	if (irq == axp20x_pek->irq_dbf) {
+ 		input_report_key(idev, KEY_POWER, true);
+-	else if (irq == axp20x_pek->irq_dbr)
++		msleep(100);
+ 		input_report_key(idev, KEY_POWER, false);
++	}
++	else if (irq == axp20x_pek->irq_dbr) {
++	}
+ 
+ 	input_sync(idev);
+ 
+diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
+index 092eb59a7d32..00ab1f315f6b 100644
+--- a/drivers/leds/leds-gpio.c
++++ b/drivers/leds/leds-gpio.c
+@@ -26,6 +26,8 @@ struct gpio_led_data {
+ 	gpio_blink_set_t platform_gpio_blink_set;
+ };
+ 
++static int leds_gpio_proc_init(const char *name);
++
+ static inline struct gpio_led_data *
+ 			cdev_to_gpio_led_data(struct led_classdev *led_cdev)
+ {
+@@ -119,6 +121,8 @@ static int create_gpio_led(const struct gpio_led *template,
+ 						     &init_data);
+ 	}
+ 
++	leds_gpio_proc_init(led_dat->cdev.name);
++
+ 	return ret;
+ }
+ 
+@@ -127,6 +131,8 @@ struct gpio_leds_priv {
+ 	struct gpio_led_data leds[];
+ };
+ 
++static struct gpio_leds_priv *leds_priv;
++
+ static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
+ {
+ 	struct device *dev = &pdev->dev;
+@@ -181,6 +187,7 @@ static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
+ 		priv->num_leds++;
+ 	}
+ 
++	leds_priv = priv;
+ 	return priv;
+ }
+ 
+@@ -307,6 +314,82 @@ static struct platform_driver gpio_led_driver = {
+ 
+ module_platform_driver(gpio_led_driver);
+ 
++#ifdef CONFIG_PROC_FS
++
++#include <linux/proc_fs.h>
++#include <linux/uaccess.h>
++
++static char global_buffer[64];
++
++static int leds_gpio_proc_show(struct seq_file *m, void *v)
++{
++	seq_printf(m, "leds_gpio\n");
++	return 0;
++}
++
++static int leds_gpio_proc_open(struct inode *inode, struct file *file)
++{
++	return single_open(file, leds_gpio_proc_show, NULL);
++}
++
++static int leds_gpio_proc_read(struct file * file, char __user * buf, size_t size, loff_t * loff)
++{
++	int value, len, i;
++
++	for(i = 0; i < leds_priv->num_leds; i++) {
++		if(strcmp(leds_priv->leds[i].cdev.name, file->f_path.dentry->d_iname) == 0) {
++			value = leds_priv->leds[i].cdev.brightness;
++			len = snprintf(global_buffer, sizeof(global_buffer), "%d\n", value);
++			return simple_read_from_buffer(buf, size, loff, global_buffer, len);
++		}
++	}
++
++	return 0;
++}
++
++static int leds_gpio_proc_write(struct file * file, const char __user * buf, size_t size, loff_t * loff)
++{
++	int value, i;
++
++	if(copy_from_user(global_buffer, buf, size))
++		return -EFAULT;
++
++	global_buffer[size] = 0;
++	for(i = 0; i < leds_priv->num_leds; i++) {
++		if(strcmp(leds_priv->leds[i].cdev.name, file->f_path.dentry->d_iname) == 0) {
++			value = simple_strtol(global_buffer, 0, 10);
++			gpio_led_set(&leds_priv->leds[i].cdev, value);
++			leds_priv->leds[i].cdev.brightness = value;
++			break;
++		}
++	}
++
++	return size;
++}
++
++static const struct proc_ops leds_gpio_proc_fops = {
++	.proc_open		= leds_gpio_proc_open,
++	.proc_read		= leds_gpio_proc_read,
++	.proc_write		= leds_gpio_proc_write,
++	.proc_lseek		= seq_lseek,
++	.proc_release	= single_release,
++};
++
++static int leds_gpio_proc_init(const char *name)
++{
++	struct proc_dir_entry *r;
++	char buf[50];
++
++	sprintf(buf, "driver/%s", name);
++	r = proc_create(buf, S_IRWXUGO, NULL, &leds_gpio_proc_fops);
++	if (!r)
++		return -ENOMEM;
++	return 0;
++}
++#else
++static inline int leds_gpio_proc_init(const char *name) { return 0; }
++#endif /* CONFIG_PROC_FS */
++
+ MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
+ MODULE_DESCRIPTION("GPIO LED driver");
+ MODULE_LICENSE("GPL");
+diff --git a/drivers/mfd/axp20x.c b/drivers/mfd/axp20x.c
+index 8161a5dc68e8..3b342db209dc 100644
+--- a/drivers/mfd/axp20x.c
++++ b/drivers/mfd/axp20x.c
+@@ -203,8 +203,8 @@ static const struct resource axp803_usb_power_supply_resources[] = {
+ };
+ 
+ static const struct resource axp22x_pek_resources[] = {
+-	DEFINE_RES_IRQ_NAMED(AXP22X_IRQ_PEK_RIS_EDGE, "PEK_DBR"),
+-	DEFINE_RES_IRQ_NAMED(AXP22X_IRQ_PEK_FAL_EDGE, "PEK_DBF"),
++	DEFINE_RES_IRQ_NAMED(AXP22X_IRQ_PEK_SHORT, "PEK_DBR"),
++	DEFINE_RES_IRQ_NAMED(AXP22X_IRQ_PEK_LONG, "PEK_DBF"),
+ };
+ 
+ static const struct resource axp288_power_button_resources[] = {
+diff --git a/drivers/mfd/sun6i-prcm.c b/drivers/mfd/sun6i-prcm.c
+index ee03db0b8485..a8c833df4f05 100644
+--- a/drivers/mfd/sun6i-prcm.c
++++ b/drivers/mfd/sun6i-prcm.c
+@@ -12,7 +12,7 @@
+ #include <linux/of.h>
+ 
+ #define SUN8I_CODEC_ANALOG_BASE	0x1c0
+-#define SUN8I_CODEC_ANALOG_SIZE	0x4
++#define SUN8I_CODEC_ANALOG_SIZE	0x10
+ 
+ struct prcm_data {
+ 	int nsubdevs;

v0.6/515_sound.patch

@@ -0,0 +1,383 @@
+diff --git a/sound/soc/sunxi/sun8i-codec-analog.c b/sound/soc/sunxi/sun8i-codec-analog.c
+index be872eefa61e..ca5f4e43476b 100644
+--- a/sound/soc/sunxi/sun8i-codec-analog.c
++++ b/sound/soc/sunxi/sun8i-codec-analog.c
+@@ -19,6 +19,8 @@
+ #include <sound/tlv.h>
+ 
+ #include "sun8i-adda-pr-regmap.h"
++#include <linux/gpio.h>
++#include <linux/gpio/consumer.h>
+ 
+ /* Codec analog control register offsets and bit fields */
+ #define SUN8I_ADDA_HP_VOLC		0x00
+@@ -113,6 +115,81 @@
+ #define SUN8I_ADDA_ADC_AP_EN_ADCLEN		6
+ #define SUN8I_ADDA_ADC_AP_EN_ADCG		0
+ 
++/* Analog control register access bits */
++#define ADDA_PR			0x0		/* PRCM base + 0x1c0 */
++#define ADDA_PR_RESET			BIT(28)
++#define ADDA_PR_WRITE			BIT(24)
++#define ADDA_PR_ADDR_SHIFT		16
++#define ADDA_PR_ADDR_MASK		GENMASK(4, 0)
++#define ADDA_PR_DATA_IN_SHIFT		8
++#define ADDA_PR_DATA_IN_MASK		GENMASK(7, 0)
++#define ADDA_PR_DATA_OUT_SHIFT		0
++#define ADDA_PR_DATA_OUT_MASK		GENMASK(7, 0)
++
++/* regmap access bits */
++static int adda_reg_read(void *context, unsigned int reg, unsigned int *val)
++{
++	void __iomem *base = (void __iomem *)context;
++	u32 tmp;
++
++	/* De-assert reset */
++	writel(readl(base) | ADDA_PR_RESET, base);
++
++	/* Clear write bit */
++	writel(readl(base) & ~ADDA_PR_WRITE, base);
++
++	/* Set register address */
++	tmp = readl(base);
++	tmp &= ~(ADDA_PR_ADDR_MASK << ADDA_PR_ADDR_SHIFT);
++	tmp |= (reg & ADDA_PR_ADDR_MASK) << ADDA_PR_ADDR_SHIFT;
++	writel(tmp, base);
++
++	/* Read back value */
++	*val = readl(base) & ADDA_PR_DATA_OUT_MASK;
++
++	return 0;
++}
++
++static int adda_reg_write(void *context, unsigned int reg, unsigned int val)
++{
++	void __iomem *base = (void __iomem *)context;
++	u32 tmp;
++
++	/* De-assert reset */
++	writel(readl(base) | ADDA_PR_RESET, base);
++
++	/* Set register address */
++	tmp = readl(base);
++	tmp &= ~(ADDA_PR_ADDR_MASK << ADDA_PR_ADDR_SHIFT);
++	tmp |= (reg & ADDA_PR_ADDR_MASK) << ADDA_PR_ADDR_SHIFT;
++	writel(tmp, base);
++
++	/* Set data to write */
++	tmp = readl(base);
++	tmp &= ~(ADDA_PR_DATA_IN_MASK << ADDA_PR_DATA_IN_SHIFT);
++	tmp |= (val & ADDA_PR_DATA_IN_MASK) << ADDA_PR_DATA_IN_SHIFT;
++	writel(tmp, base);
++
++	/* Set write bit to signal a write */
++	writel(readl(base) | ADDA_PR_WRITE, base);
++
++	/* Clear write bit */
++	writel(readl(base) & ~ADDA_PR_WRITE, base);
++
++	return 0;
++}
++
++static const struct regmap_config adda_pr_regmap_cfg = {
++	.name		= "adda-pr",
++	.reg_bits	= 5,
++	.reg_stride	= 1,
++	.val_bits	= 8,
++	.reg_read	= adda_reg_read,
++	.reg_write	= adda_reg_write,
++	.fast_io	= true,
++	.max_register	= 24,
++};
++
+ /* mixer controls */
+ static const struct snd_kcontrol_new sun8i_codec_mixer_controls[] = {
+ 	SOC_DAPM_DOUBLE_R("DAC Playback Switch",
+@@ -316,7 +393,7 @@ static const struct snd_soc_dapm_route sun8i_codec_mixer_routes[] = {
+ /* headphone specific controls, widgets, and routes */
+ static const DECLARE_TLV_DB_SCALE(sun8i_codec_hp_vol_scale, -6300, 100, 1);
+ static const struct snd_kcontrol_new sun8i_codec_headphone_controls[] = {
+-	SOC_SINGLE_TLV("Headphone Playback Volume",
++	SOC_SINGLE_TLV("Master Playback Volume",
+ 		       SUN8I_ADDA_HP_VOLC,
+ 		       SUN8I_ADDA_HP_VOLC_HP_VOL, 0x3f, 0,
+ 		       sun8i_codec_hp_vol_scale),
+@@ -673,7 +750,7 @@ struct sun8i_codec_analog_quirks {
+ 
+ static const struct sun8i_codec_analog_quirks sun8i_a23_quirks = {
+ 	.has_headphone	= true,
+-	.has_hmic	= true,
++//	.has_hmic	= true,
+ 	.has_linein	= true,
+ 	.has_mbias	= true,
+ 	.has_mic2	= true,
+@@ -817,10 +894,148 @@ static const struct of_device_id sun8i_codec_analog_of_match[] = {
+ };
+ MODULE_DEVICE_TABLE(of, sun8i_codec_analog_of_match);
+ 
++#define SUNXI_HMIC_ENABLE          (0x4)
++#define SUNXI_HMIC_CTL 	           (0x8)
++#define SUNXI_HMIC_DATA	           (0xc)
++
++/*
++*	SUNXI_HMIC_CTL
++*HMIC Control Register
++*CONFIG_ARCH_SUN8IW5:0x1c8
++*/
++#define HMIC_M					  (28)
++#define HMIC_N					  (24)
++#define HMIC_DIRQ				  (23)
++#define HMIC_TH1_HYS			  (21)
++#define HMIC_EARPHONE_OUT_IRQ_EN  (20)
++#define HMIC_EARPHONE_IN_IRQ_EN	  (19)
++#define HMIC_KEY_UP_IRQ_EN		  (18)
++#define HMIC_KEY_DOWN_IRQ_EN	  (17)
++#define HMIC_DATA_IRQ_EN		  (16)
++#define HMIC_DS_SAMP			  (14)
++#define HMIC_TH2_HYS			  (13)
++#define HMIC_TH2_KEY		      (8)
++#define HMIC_SF_SMOOTH_FIL		  (6)
++#define KEY_UP_IRQ_PEND			  (5)
++#define HMIC_TH1_EARPHONE		  (0)
++
++/*
++*	SUNXI_HMIC_DATA
++*HMIC Data Register
++*
++*CONFIG_ARCH_SUN8IW5:0x1cc
++*/
++#define HMIC_EARPHONE_OUT_IRQ_PEND  (20)
++#define HMIC_EARPHONE_IN_IRQ_PEND   (19)
++#define HMIC_KEY_UP_IRQ_PEND 	    (18)
++#define HMIC_KEY_DOWN_IRQ_PEND 		(17)
++#define HMIC_DATA_IRQ_PEND			(16)
++#define HMIC_ADC_DATA				(0)
++
++#define HP_VOLC					  (0x00)
++#define LOMIXSC					  (0x01)
++#define ROMIXSC					  (0x02)
++#define DAC_PA_SRC				  (0x03)
++#define PAEN_HP_CTRL			  (0x07)
++#define ADDA_APT2				  (0x12)
++#define MIC1G_MICBIAS_CTRL		  (0x0B)
++#define PA_ANTI_POP_REG_CTRL	  (0x0E)
++#define PA_SLOPE_SELECT	  (3)
++#define PA_ANTI_POP_EN		(0)
++
++static void __iomem *sun8i_codec_analog_base;
++static struct gpio_desc * speaker_amplifier_gpio;
++
++static int hmic_wrreg_prcm_bits(unsigned short reg, unsigned int mask, unsigned int value)
++{
++	unsigned int old, new;
++
++	adda_reg_read(sun8i_codec_analog_base, reg, &old);
++	new	=	(old & ~mask) | value;
++	adda_reg_write(sun8i_codec_analog_base, reg,new);
++
++	return 0;
++}
++
++static int hmic_wr_prcm_control(u32 reg, u32 mask, u32 shift, u32 val)
++{
++	u32 reg_val;
++	reg_val = val << shift;
++	mask = mask << shift;
++	hmic_wrreg_prcm_bits(reg, mask, reg_val);
++	return 0;
++}
++
++static int hmic_wrreg_bits(unsigned short reg, unsigned int	mask,	unsigned int value)
++{
++	unsigned int old, new;
++
++	old	=	readl(sun8i_codec_analog_base + reg);
++	new	=	(old & ~mask) | value;
++
++	writel(new, sun8i_codec_analog_base + reg);
++
++	return 0;
++}
++
++static int hmic_wr_control(u32 reg, u32 mask, u32 shift, u32 val)
++{
++	u32 reg_val;
++	reg_val = val << shift;
++	mask = mask << shift;
++	hmic_wrreg_bits(reg, mask, reg_val);
++	return 0;
++}
++
++static irqreturn_t sunxi_codec_analog_irq(int irq, void *dev_id)
++{
++	u32 tmp;
++
++	hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_KEY_DOWN_IRQ_PEND, 0x1);
++	hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_EARPHONE_IN_IRQ_PEND, 0x1);
++	hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_KEY_UP_IRQ_PEND, 0x1);
++	hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_EARPHONE_OUT_IRQ_PEND, 0x1);
++	hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_DATA_IRQ_PEND, 0x1);
++
++	tmp = readl(sun8i_codec_analog_base + SUNXI_HMIC_DATA);
++	if(tmp & 0x1f)
++		gpiod_set_value(speaker_amplifier_gpio, 0);
++	else
++		gpiod_set_value(speaker_amplifier_gpio, 1);
++
++	return IRQ_HANDLED;
++}
++
++static void sunxi_hppa_enable(void) {
++    /*fix the resume blaze blaze noise*/
++	hmic_wr_prcm_control(ADDA_APT2, 0x1, PA_SLOPE_SELECT, 0x0);
++	hmic_wr_prcm_control(SUN8I_ADDA_PAEN_HP_CTRL, 0x3, SUN8I_ADDA_PAEN_HP_CTRL_PA_ANTI_POP_CTRL, 0x1);
++	hmic_wr_prcm_control(PA_ANTI_POP_REG_CTRL, 0x7, PA_ANTI_POP_EN, 0x2);
++	usleep_range(100,200);
++	/*enable pa*/
++	hmic_wr_prcm_control(SUN8I_ADDA_PAEN_HP_CTRL, 0x1, SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN, 0x1);
++}
++
++static void sunxi_hbias_enable(void) {
++	/*audio codec hardware bug. the HBIASADCEN bit must be enable in init*/
++	hmic_wr_prcm_control(SUN8I_ADDA_MIC1G_MICBIAS_CTRL, 0x1, SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIAS_MODE, 0x1);
++	hmic_wr_prcm_control(SUN8I_ADDA_MIC1G_MICBIAS_CTRL, 0x1, SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIASEN, 0x1);
++}
++
++static void codec_init_events(void)
++{
++	/*fix the resume blaze blaze noise*/
++	sunxi_hppa_enable();
++	msleep(450);
++	/*audio codec hardware bug. the HBIASADCEN bit must be enable in init*/
++	sunxi_hbias_enable();
++}
++
+ static int sun8i_codec_analog_probe(struct platform_device *pdev)
+ {
+ 	struct regmap *regmap;
+ 	void __iomem *base;
++	int irq, ret;
+ 
+ 	base = devm_platform_ioremap_resource(pdev, 0);
+ 	if (IS_ERR(base)) {
+@@ -828,6 +1043,38 @@ static int sun8i_codec_analog_probe(struct platform_device *pdev)
+ 		return PTR_ERR(base);
+ 	}
+ 
++	sun8i_codec_analog_base = base;
++	speaker_amplifier_gpio = devm_gpiod_get_optional(&pdev->dev, "speaker-amplifier", GPIOD_OUT_HIGH);
++	if (!IS_ERR_OR_NULL(speaker_amplifier_gpio)) {
++
++		hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_M, 0x0);						/*0xf should be get from hw_debug 28*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_N, 0x0);						/*0xf should be get from hw_debug 24 0xf*/
++//		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_DIRQ, 0x1);					/*23*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_OUT_IRQ_EN, 0x1); 	/*20*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_IN_IRQ_EN, 0x1); 	/*19*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_KEY_UP_IRQ_EN, 0x1); 			/*18*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_KEY_DOWN_IRQ_EN, 0x1); 		/*17*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_DATA_IRQ_EN, 0x1); 			/*16*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x3, HMIC_DS_SAMP, 0x0); 				/*14 */
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH2_KEY, 0x0);				/*0xf should be get from hw_debug 8*/
++		hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH1_EARPHONE, 0x1);			/*0x1 should be get from hw_debug 0*/
++
++		irq = platform_get_irq(pdev, 0);
++		if (irq < 0) {
++			dev_err(&pdev->dev, "Can't retrieve our interrupt\n");
++			return irq;
++		}
++
++		ret = devm_request_irq(&pdev->dev, irq, sunxi_codec_analog_irq, 0, "audio_hmic_irq", NULL);
++		if (ret) {
++			dev_err(&pdev->dev, "can't register interrupt handler irq %d: %d\n",
++				irq, ret);
++			return ret;
++		}
++
++		codec_init_events();
++	}
++
+ 	regmap = sun8i_adda_pr_regmap_init(&pdev->dev, base);
+ 	if (IS_ERR(regmap)) {
+ 		dev_err(&pdev->dev, "Failed to create regmap\n");
+diff --git a/sound/soc/sunxi/sun8i-codec.c b/sound/soc/sunxi/sun8i-codec.c
+index 518bfb724a5b..b6a90e33f20a 100644
+--- a/sound/soc/sunxi/sun8i-codec.c
++++ b/sound/soc/sunxi/sun8i-codec.c
+@@ -257,6 +257,9 @@ static int sun8i_codec_update_sample_rate(struct sun8i_codec *scodec)
+ 	regmap_update_bits(scodec->regmap, SUN8I_SYS_SR_CTRL,
+ 			   SUN8I_SYS_SR_CTRL_AIF1_FS_MASK,
+ 			   hw_rate << SUN8I_SYS_SR_CTRL_AIF1_FS);
++	regmap_update_bits(scodec->regmap, SUN8I_SYS_SR_CTRL,
++			   SUN8I_SYS_SR_CTRL_AIF2_FS_MASK,
++			   hw_rate << SUN8I_SYS_SR_CTRL_AIF2_FS);
+ 
+ 	return 0;
+ }
+@@ -288,6 +291,9 @@ static int sun8i_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+ 				   SUN8I_AIF3_CLK_CTRL_AIF3_CLK_SRC_MASK,
+ 				   SUN8I_AIF3_CLK_CTRL_AIF3_CLK_SRC_AIF2);
+ 	} else {
++		regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++				   BIT(SUN8I_AIF_CLK_CTRL_MSTR_MOD),
++				   value << SUN8I_AIF_CLK_CTRL_MSTR_MOD);
+ 		regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(dai->id),
+ 				   BIT(SUN8I_AIF_CLK_CTRL_MSTR_MOD),
+ 				   value << SUN8I_AIF_CLK_CTRL_MSTR_MOD);
+@@ -321,6 +327,9 @@ static int sun8i_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+ 		if (format != 3)
+ 			return -EINVAL;
+ 	} else {
++		regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++				   SUN8I_AIF_CLK_CTRL_DATA_FMT_MASK,
++				   format << SUN8I_AIF_CLK_CTRL_DATA_FMT);
+ 		regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(dai->id),
+ 				   SUN8I_AIF_CLK_CTRL_DATA_FMT_MASK,
+ 				   format << SUN8I_AIF_CLK_CTRL_DATA_FMT);
+@@ -365,6 +374,9 @@ static int sun8i_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+ 		invert ^= scodec->quirks->lrck_inversion;
+ 	}
+ 
++	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++			   SUN8I_AIF_CLK_CTRL_CLK_INV_MASK,
++			   invert << SUN8I_AIF_CLK_CTRL_CLK_INV);
+ 	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(dai->id),
+ 			   SUN8I_AIF_CLK_CTRL_CLK_INV_MASK,
+ 			   invert << SUN8I_AIF_CLK_CTRL_CLK_INV);
+@@ -519,6 +531,9 @@ static int sun8i_codec_hw_params(struct snd_pcm_substream *substream,
+ 		return -EINVAL;
+ 	}
+ 
++	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++			   SUN8I_AIF_CLK_CTRL_WORD_SIZ_MASK,
++			   word_size << SUN8I_AIF_CLK_CTRL_WORD_SIZ);
+ 	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(dai->id),
+ 			   SUN8I_AIF_CLK_CTRL_WORD_SIZ_MASK,
+ 			   word_size << SUN8I_AIF_CLK_CTRL_WORD_SIZ);
+@@ -548,6 +563,9 @@ static int sun8i_codec_hw_params(struct snd_pcm_substream *substream,
+ 		clk_reg = SUN8I_AIF_CLK_CTRL(dai->id);
+ 	}
+ 
++	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++			   SUN8I_AIF_CLK_CTRL_LRCK_DIV_MASK,
++			   (lrck_div_order - 4) << SUN8I_AIF_CLK_CTRL_LRCK_DIV);
+ 	regmap_update_bits(scodec->regmap, clk_reg,
+ 			   SUN8I_AIF_CLK_CTRL_LRCK_DIV_MASK,
+ 			   (lrck_div_order - 4) << SUN8I_AIF_CLK_CTRL_LRCK_DIV);
+@@ -557,6 +575,9 @@ static int sun8i_codec_hw_params(struct snd_pcm_substream *substream,
+ 	if (bclk_div < 0)
+ 		return bclk_div;
+ 
++	regmap_update_bits(scodec->regmap, SUN8I_AIF_CLK_CTRL(SUN8I_CODEC_AIF1),
++			   SUN8I_AIF_CLK_CTRL_BCLK_DIV_MASK,
++			   bclk_div << SUN8I_AIF_CLK_CTRL_BCLK_DIV);
+ 	regmap_update_bits(scodec->regmap, clk_reg,
+ 			   SUN8I_AIF_CLK_CTRL_BCLK_DIV_MASK,
+ 			   bclk_div << SUN8I_AIF_CLK_CTRL_BCLK_DIV);
+@@ -1226,6 +1247,7 @@ static const struct snd_soc_component_driver sun8i_soc_component = {
+ };
+ 
+ static const struct regmap_config sun8i_codec_regmap_config = {
++	.name = "sun8i_codec",
+ 	.reg_bits	= 32,
+ 	.reg_stride	= 4,
+ 	.val_bits	= 32,

v0.6/515_wifi.patch

@@ -0,0 +1,78 @@
+diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
+index f7961b22e051..c3f51e123990 100644
+--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
+@@ -4431,6 +4431,55 @@ brcmf_sdio_prepare_fw_request(struct brcmf_sdio *bus)
+ 	return fwreq;
+ }
+ 
++static char brcmf_fw_name[BRCMF_FW_NAME_LEN];
++
++#ifdef CONFIG_PROC_FS
++#include <linux/proc_fs.h>
++
++static int brcmf_sdio_proc_show(struct seq_file *m, void *v)
++{
++	seq_printf(m, "brcmf_sdio\n");
++	return 0;
++}
++
++static int brcmf_sdio_proc_open(struct inode *inode, struct file *file)
++{
++	return single_open(file, brcmf_sdio_proc_show, NULL);
++}
++
++static ssize_t brcmf_sdio_proc_read(struct file * file, char __user * buf, size_t size, loff_t * loff)
++{
++	int len;
++	len = strlen(brcmf_fw_name);
++	return simple_read_from_buffer(buf, size, loff, brcmf_fw_name, len);
++}
++
++static ssize_t brcmf_sdio_proc_write(struct file * file, const char __user * buf, size_t size, loff_t * loff)
++{
++	return size;
++}
++
++static const struct proc_ops brcmf_sdio_proc_fops = {
++	.proc_open		= brcmf_sdio_proc_open,
++	.proc_read		= brcmf_sdio_proc_read,
++	.proc_write		= brcmf_sdio_proc_write,
++	.proc_lseek		= seq_lseek,
++	.proc_release	= single_release,
++};
++
++static int __init brcmf_sdio_proc_init(void)
++{
++	struct proc_dir_entry *r;
++
++	r = proc_create("driver/brcmf_fw", S_IRWXUGO, NULL, &brcmf_sdio_proc_fops);
++	if (!r)
++		return -ENOMEM;
++	return 0;
++}
++#else
++static inline int brcmf_sdio_proc_init(void) { return 0; }
++#endif /* CONFIG_PROC_FS */
++
+ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
+ {
+ 	int ret;
+@@ -4439,6 +4488,7 @@ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
+ 	struct brcmf_fw_request *fwreq;
+ 
+ 	brcmf_dbg(TRACE, "Enter\n");
++	msleep(1000);
+ 
+ 	/* Allocate private bus interface state */
+ 	bus = kzalloc(sizeof(struct brcmf_sdio), GFP_ATOMIC);
+@@ -4533,6 +4583,9 @@ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
+ 		goto fail;
+ 	}
+ 
++	sprintf(brcmf_fw_name, "%s\n", sdiodev->fw_name);
++	brcmf_sdio_proc_init();
++
+ 	return bus;
+ 
+ fail:

v0.6/README.md

@@ -0,0 +1,19 @@
+Linux kernel branch 5.15.y
+
+```
+git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
+```
+
+linux-5.15.y
+
+git commit hash `5827ddaf4534c52d31dd464679a186b41810ef76`
+
+
+After git apply all patches
+
+```
+make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- clockworkpi_cpi3_defconfig
+mkimage -A arm -O linux -T kernel -C none -a 0x40008000 -e 0x40008000 -n "Linux kernel" -d arch/arm/boot/zImage uImage
+```
+
+