diff options
Diffstat (limited to 'drivers/media')
186 files changed, 8374 insertions, 18732 deletions
diff --git a/drivers/media/isdbt/Kconfig b/drivers/media/isdbt/Kconfig index 59fb2fe..d4fb1a6 100644 --- a/drivers/media/isdbt/Kconfig +++ b/drivers/media/isdbt/Kconfig @@ -1,5 +1,14 @@ -config ISDBT_FC8100 - boolean "ISDBT - DRIVER FC8100" - default n - ---help--- - Isdbt driver for fci8100 +config ISDBT + bool "isdbt" + +choice + depends on ISDBT + prompt "isdbt one-seg driver" + default ISDBT_FC8150 + + config ISDBT_FC8150 + bool "ISDBT_FC8150" + + config ISDBT_FC8100 + bool "ISDBT_FC8100" +endchoice diff --git a/drivers/media/isdbt/Makefile b/drivers/media/isdbt/Makefile index 7cb1783..c328411 100644 --- a/drivers/media/isdbt/Makefile +++ b/drivers/media/isdbt/Makefile @@ -5,3 +5,4 @@ #obj-$(CONFIG_ISDBT_FC8100) += isdbt.o obj-$(CONFIG_ISDBT_FC8100) += fc8100/ +obj-$(CONFIG_ISDBT) += fc8150/ diff --git a/drivers/media/isdbt/fc8150/Makefile b/drivers/media/isdbt/fc8150/Makefile new file mode 100644 index 0000000..baf3d0e --- /dev/null +++ b/drivers/media/isdbt/fc8150/Makefile @@ -0,0 +1,18 @@ +obj-y += bbm.o +obj-y += fc8150.o +obj-y += fc8150_bb.o +obj-y += fc8150_hpi.o +obj-y += fc8150_i2c.o +obj-y += fc8150_isr.o +obj-y += fc8150_ppi.o +obj-y += fc8150_spi.o +obj-y += fc8150_spib.o +obj-y += fc8150_tun.o +obj-y += fci_bypass.o +obj-y += fci_hal.o +obj-y += fci_i2c.o +obj-y += fci_oal.o +obj-y += fci_ringbuffer.o +obj-y += fci_tun.o + +#ccflags-y += -Idrivers/media/isdbt diff --git a/drivers/media/isdbt/fc8150/bbm.c b/drivers/media/isdbt/fc8150/bbm.c new file mode 100644 index 0000000..c9ad7b0 --- /dev/null +++ b/drivers/media/isdbt/fc8150/bbm.c @@ -0,0 +1,287 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : bbm.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_tun.h" +#include "fci_hal.h" +#include "fc8150_bb.h" +#include "fc8150_isr.h" + +int BBM_RESET(HANDLE hDevice) +{ + int res; + + res = fc8150_reset(hDevice); + + return res; +} + +int BBM_PROBE(HANDLE hDevice) +{ + int res; + + res = fc8150_probe(hDevice); + + return res; +} + +int BBM_INIT(HANDLE hDevice) +{ + int res; + + res = fc8150_init(hDevice); + + return res; +} + +int BBM_DEINIT(HANDLE hDevice) +{ + int res; + + res = fc8150_deinit(hDevice); + + return res; +} + +int BBM_READ(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + + res = bbm_read(hDevice, addr, data); + + return res; +} + +int BBM_BYTE_READ(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + + res = bbm_byte_read(hDevice, addr, data); + + return res; +} + +int BBM_WORD_READ(HANDLE hDevice, u16 addr, u16 *data) +{ + int res; + + res = bbm_word_read(hDevice, addr, data); + + return res; +} + +int BBM_LONG_READ(HANDLE hDevice, u16 addr, u32 *data) +{ + int res; + + res = bbm_long_read(hDevice, addr, data); + + return BBM_OK; +} + +int BBM_BULK_READ(HANDLE hDevice, u16 addr, u8 *data, u16 size) +{ + int res; + + res = bbm_bulk_read(hDevice, addr, data, size); + + return res; +} + +int BBM_DATA(HANDLE hDevice, u16 addr, u8 *data, u32 size) +{ + int res; + + res = bbm_data(hDevice, addr, data, size); + + return res; +} + +int BBM_WRITE(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + + res = bbm_write(hDevice, addr, data); + + return res; +} + +int BBM_BYTE_WRITE(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + + res = bbm_byte_write(hDevice, addr, data); + + return res; +} + +int BBM_WORD_WRITE(HANDLE hDevice, u16 addr, u16 data) +{ + int res; + + res = bbm_word_write(hDevice, addr, data); + + return res; +} + +int BBM_LONG_WRITE(HANDLE hDevice, u16 addr, u32 data) +{ + int res; + + res = bbm_long_write(hDevice, addr, data); + + return res; +} + +int BBM_BULK_WRITE(HANDLE hDevice, u16 addr, u8 *data, u16 size) +{ + int res; + + res = bbm_bulk_write(hDevice, addr, data, size); + + return res; +} + +int BBM_I2C_INIT(HANDLE hDevice, u32 type) +{ + int res; + + res = tuner_ctrl_select(hDevice, type); + + return res; +} + +int BBM_I2C_DEINIT(HANDLE hDevice) +{ + int res; + + res = tuner_ctrl_deselect(hDevice); + + return res; +} + +int BBM_TUNER_READ(HANDLE hDevice, u8 addr, u8 alen, u8 *buffer, u8 len) +{ + int res; + + res = tuner_i2c_read(hDevice, addr, alen, buffer, len); + + return res; +} + +int BBM_TUNER_WRITE(HANDLE hDevice, u8 addr, u8 alen, u8 *buffer, u8 len) +{ + int res; + + res = tuner_i2c_write(hDevice, addr, alen, buffer, len); + + return res; +} + +int BBM_TUNER_SET_FREQ(HANDLE hDevice, u32 freq) +{ + int res; + + res = tuner_set_freq(hDevice, freq); + + return res; +} + +int BBM_TUNER_SELECT(HANDLE hDevice, u32 product, u32 band) +{ + int res; + + res = tuner_select(hDevice, product, band); + + return res; +} + +int BBM_TUNER_DESELECT(HANDLE hDevice) +{ + int res; + + res = tuner_deselect(hDevice); + + return res; +} + +int BBM_TUNER_GET_RSSI(HANDLE hDevice, s32 *rssi) +{ + int res; + + res = tuner_get_rssi(hDevice, rssi); + + return res; +} + +int BBM_SCAN_STATUS(HANDLE hDevice) +{ + int res; + + res = fc8150_scan_status(hDevice); + + return res; +} + +void BBM_ISR(HANDLE hDevice) +{ + fc8150_isr(hDevice); +} + +int BBM_HOSTIF_SELECT(HANDLE hDevice, u8 hostif) +{ + int res; + + res = bbm_hostif_select(hDevice, hostif); + + return res; +} + +int BBM_HOSTIF_DESELECT(HANDLE hDevice) +{ + int res; + + res = bbm_hostif_deselect(hDevice); + + return res; +} + +int BBM_TS_CALLBACK_REGISTER(u32 userdata + , int (*callback)(u32 userdata, u8 *data, int length)) +{ + gTSUserData = userdata; + pTSCallback = callback; + + return BBM_OK; +} + +int BBM_TS_CALLBACK_DEREGISTER(void) +{ + gTSUserData = 0; + pTSCallback = NULL; + + return BBM_OK; +} + +int BBM_AC_CALLBACK_REGISTER(u32 userData + , int (*callback)(u32 userdata, u8 *data, int length)) +{ + gACUserData = userData; + pACCallback = callback; + + return BBM_OK; +} + +int BBM_AC_CALLBACK_DEREGISTER(void) +{ + gACUserData = 0; + pACCallback = NULL; + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/bbm.h b/drivers/media/isdbt/fc8150/bbm.h new file mode 100644 index 0000000..2543681 --- /dev/null +++ b/drivers/media/isdbt/fc8150/bbm.h @@ -0,0 +1,60 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : bbm.h + + Description : API of 1-SEG baseband module + +*******************************************************************************/ +#ifndef __BBM_H__ +#define __BBM_H__ + +#include "fci_types.h" + +#define DRIVER_VER "VER 2.20.1" + +#ifdef __cplusplus +extern "C" { +#endif + +extern int BBM_RESET(HANDLE hDevice); +extern int BBM_PROBE(HANDLE hDevice); +extern int BBM_INIT(HANDLE hDevice); +extern int BBM_DEINIT(HANDLE hDevice); +extern int BBM_READ(HANDLE hDevice, u16 addr, u8 *data); +extern int BBM_BYTE_READ(HANDLE hDevice, u16 addr, u8 *data); +extern int BBM_WORD_READ(HANDLE hDevice, u16 addr, u16 *data); +extern int BBM_LONG_READ(HANDLE hDevice, u16 addr, u32 *data); +extern int BBM_BULK_READ(HANDLE hDevice, u16 addr, u8 *data, u16 size); +extern int BBM_DATA(HANDLE hDevice, u16 addr, u8 *data, u32 size); +extern int BBM_WRITE(HANDLE hDevice, u16 addr, u8 data); +extern int BBM_BYTE_WRITE(HANDLE hDevice, u16 addr, u8 data); +extern int BBM_WORD_WRITE(HANDLE hDevice, u16 addr, u16 data); +extern int BBM_LONG_WRITE(HANDLE hDevice, u16 addr, u32 data); +extern int BBM_BULK_WRITE(HANDLE hDevice, u16 addr, u8 *data, u16 size); +extern int BBM_I2C_INIT(HANDLE hDevice, u32 type); +extern int BBM_I2C_DEINIT(HANDLE hDevice); +extern int BBM_TUNER_SELECT(HANDLE hDevice, u32 product, u32 band); +extern int BBM_TUNER_DESELECT(HANDLE hDevice); +extern int BBM_TUNER_READ(HANDLE hDevice, u8 addr + , u8 alen, u8 *buffer, u8 len); +extern int BBM_TUNER_WRITE(HANDLE hDevice, u8 addr + , u8 alen, u8 *buffer, u8 len); +extern int BBM_TUNER_SET_FREQ(HANDLE hDevice, u32 freq); +extern int BBM_TUNER_GET_RSSI(HANDLE hDevice, s32 *rssi); +extern int BBM_SCAN_STATUS(HANDLE hDevice); +extern int BBM_HOSTIF_SELECT(HANDLE hDevice, u8 hostif); +extern int BBM_HOSTIF_DESELECT(HANDLE hDevice); +extern int BBM_TS_CALLBACK_REGISTER(u32 userdata + , int (*callback)(u32 userdata, u8 *data, int length)); +extern int BBM_TS_CALLBACK_DEREGISTER(void); +extern int BBM_AC_CALLBACK_REGISTER(u32 userData + , int (*callback)(u32 userdata, u8 *data, int length)); +extern int BBM_AC_CALLBACK_DEREGISTER(void); +extern void BBM_ISR(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif /* __BBM_H__ */ diff --git a/drivers/media/isdbt/fc8150/fc8150.c b/drivers/media/isdbt/fc8150/fc8150.c new file mode 100644 index 0000000..f6b829f --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150.c @@ -0,0 +1,525 @@ +#include <linux/miscdevice.h> +#include <linux/interrupt.h> +#include <linux/kthread.h> +#include <linux/poll.h> +#include <linux/vmalloc.h> +#include <linux/irq.h> +#include <linux/delay.h> +#include <linux/slab.h> +#include <linux/gpio.h> + +#include <linux/io.h> + +#include <mach/gpio.h> + +#include "fc8150.h" +#include "bbm.h" +#include "fci_oal.h" +#include "fci_tun.h" +#include "fc8150_regs.h" +#include "fc8150_isr.h" +#include "fci_hal.h" + +struct ISDBT_INIT_INFO_T *hInit; + +#define RING_BUFFER_SIZE (128 * 1024) /* kmalloc max 128k */ + +/* GPIO(RESET & INTRRUPT) Setting */ +#define FC8150_NAME "isdbt" + +/* +#define GPIO_ISDBT_IRQ 0x24 +#define GPIO_ISDBT_PWR_EN 1 +#define GPIO_ISDBT_RST 2 +*/ +#define GPIO_ISDBT_IRQ_FC8150 EXYNOS4_GPC0(4) +#define GPIO_ISDBT_PWR_EN_FC8150 EXYNOS4_GPC0(2) +#define GPIO_ISDBT_RST_FC8150 EXYNOS4_GPC0(0) + +static DECLARE_WAIT_QUEUE_HEAD(isdbt_isr_wait); + +static u8 isdbt_isr_sig; +static struct task_struct *isdbt_kthread; + +static irqreturn_t isdbt_irq(int irq, void *dev_id) +{ + isdbt_isr_sig = 1; + wake_up_interruptible(&isdbt_isr_wait); + + return IRQ_HANDLED; +} + +int isdbt_hw_setting(void) +{ + int err; + PRINTF(0, "isdbt_hw_setting\n"); + + err = gpio_request(GPIO_ISDBT_PWR_EN_FC8150, "isdbt_en"); + if (err) { + PRINTF(0, "isdbt_hw_setting: Couldn't request isdbt_en\n"); + goto gpio_isdbt_en; + } + gpio_direction_output(GPIO_ISDBT_PWR_EN_FC8150, 0); + + err = gpio_request(GPIO_ISDBT_RST_FC8150, "isdbt_rst"); + if (err) { + PRINTF(0, "isdbt_hw_setting: Couldn't request isdbt_rst\n"); + goto gpio_isdbt_rst; + } + gpio_direction_output(GPIO_ISDBT_RST_FC8150, 1); + + err = gpio_request(GPIO_ISDBT_IRQ_FC8150, "isdbt_irq"); + if (err) { + PRINTF(0, "isdbt_hw_setting: Couldn't request isdbt_irq\n"); + goto gpio_isdbt_rst; + } + gpio_direction_input(GPIO_ISDBT_IRQ_FC8150); + + err = request_irq(gpio_to_irq(GPIO_ISDBT_IRQ_FC8150), isdbt_irq + , IRQF_DISABLED | IRQF_TRIGGER_RISING, FC8150_NAME, NULL); + + if (err < 0) { + PRINTF(0, "isdbt_hw_setting: couldn't request gpio"); + PRINTF(0, "interrupt %d reason(%d)\n" + , gpio_to_irq(GPIO_ISDBT_IRQ_FC8150), err); + goto request_isdbt_irq; + } + return 0; +request_isdbt_irq: + gpio_free(GPIO_ISDBT_IRQ_FC8150); +gpio_isdbt_rst: + gpio_free(GPIO_ISDBT_PWR_EN_FC8150); +gpio_isdbt_en: + return err; +} + +/*POWER_ON & HW_RESET & INTERRUPT_CLEAR */ +void isdbt_hw_init(void) +{ + PRINTF(0, "isdbt_hw_init\n"); + gpio_set_value(GPIO_ISDBT_PWR_EN_FC8150, 1); + gpio_set_value(GPIO_ISDBT_RST_FC8150, 1); + mdelay(5); + gpio_set_value(GPIO_ISDBT_RST_FC8150, 0); + mdelay(1); + gpio_set_value(GPIO_ISDBT_RST_FC8150, 1); +} + +/*POWER_OFF */ +void isdbt_hw_deinit(void) +{ + PRINTF(0, "isdbt_hw_deinit\n"); + gpio_set_value(GPIO_ISDBT_PWR_EN_FC8150, 0); +} + +int data_callback(u32 hDevice, u8 *data, int len) +{ + struct ISDBT_INIT_INFO_T *hInit; + struct list_head *temp; + hInit = (struct ISDBT_INIT_INFO_T *)hDevice; + + list_for_each(temp, &(hInit->hHead)) + { + struct ISDBT_OPEN_INFO_T *hOpen; + + hOpen = list_entry(temp, struct ISDBT_OPEN_INFO_T, hList); + + if (hOpen->isdbttype == TS_TYPE) { + if (fci_ringbuffer_free(&hOpen->RingBuffer) < (len+2)) { + /*PRINTF(hDevice, "f"); */ + return 0; + } + + FCI_RINGBUFFER_WRITE_BYTE(&hOpen->RingBuffer, len >> 8); + FCI_RINGBUFFER_WRITE_BYTE(&hOpen->RingBuffer, + len & 0xff); + + fci_ringbuffer_write(&hOpen->RingBuffer, data, len); + + wake_up_interruptible(&(hOpen->RingBuffer.queue)); + } + } + + return 0; +} + +static int isdbt_thread(void *hDevice) +{ + static DEFINE_MUTEX(thread_lock); + + struct ISDBT_INIT_INFO_T *hInit = (struct ISDBT_INIT_INFO_T *)hDevice; + + set_user_nice(current, -20); + + PRINTF(hInit, "isdbt_kthread enter\n"); + + BBM_TS_CALLBACK_REGISTER((u32)hInit, data_callback); + + while (1) { + wait_event_interruptible(isdbt_isr_wait, + isdbt_isr_sig || kthread_should_stop()); + + isdbt_isr_sig = 0; + + BBM_ISR(hInit); + + if (kthread_should_stop()) + break; + } + + BBM_TS_CALLBACK_DEREGISTER(); + + PRINTF(hInit, "isdbt_kthread exit\n"); + + return 0; +} + +const struct file_operations isdbt_fops = { + .owner = THIS_MODULE, + .unlocked_ioctl = isdbt_ioctl, + .open = isdbt_open, + .read = isdbt_read, + .release = isdbt_release, +}; + +static struct miscdevice fc8150_misc_device = { + .minor = MISC_DYNAMIC_MINOR, + .name = FC8150_NAME, + .fops = &isdbt_fops, +}; + +int isdbt_open(struct inode *inode, struct file *filp) +{ + struct ISDBT_OPEN_INFO_T *hOpen; + + PRINTF(hInit, "isdbt open\n"); + + hOpen = kmalloc(sizeof(struct ISDBT_OPEN_INFO_T), GFP_KERNEL); + + hOpen->buf = kmalloc(RING_BUFFER_SIZE, GFP_KERNEL); + hOpen->isdbttype = 0; + + list_add(&(hOpen->hList), &(hInit->hHead)); + + hOpen->hInit = (HANDLE *)hInit; + + if (hOpen->buf == NULL) { + PRINTF(hInit, "ring buffer malloc error\n"); + return -ENOMEM; + } + + fci_ringbuffer_init(&hOpen->RingBuffer, hOpen->buf, RING_BUFFER_SIZE); + + filp->private_data = hOpen; + + return 0; +} + +ssize_t isdbt_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) +{ + s32 avail; + s32 non_blocking = filp->f_flags & O_NONBLOCK; + struct ISDBT_OPEN_INFO_T *hOpen + = (struct ISDBT_OPEN_INFO_T *)filp->private_data; + struct fci_ringbuffer *cibuf = &hOpen->RingBuffer; + ssize_t len; + + if (!cibuf->data || !count) { + /*PRINTF(hInit, " return 0\n"); */ + return 0; + } + + if (non_blocking && (fci_ringbuffer_empty(cibuf))) { + /*PRINTF(hInit, "return EWOULDBLOCK\n"); */ + return -EWOULDBLOCK; + } + + if (wait_event_interruptible(cibuf->queue, + !fci_ringbuffer_empty(cibuf))) { + PRINTF(hInit, "return ERESTARTSYS\n"); + return -ERESTARTSYS; + } + + avail = fci_ringbuffer_avail(cibuf); + + if (avail < 4) { + PRINTF(hInit, "return 00\n"); + return 0; + } + + len = FCI_RINGBUFFER_PEEK(cibuf, 0) << 8; + len |= FCI_RINGBUFFER_PEEK(cibuf, 1); + + if (avail < len + 2 || count < len) { + PRINTF(hInit, "return EINVAL\n"); + return -EINVAL; + } + + FCI_RINGBUFFER_SKIP(cibuf, 2); + + return fci_ringbuffer_read_user(cibuf, buf, len); +} + +int isdbt_release(struct inode *inode, struct file *filp) +{ + struct ISDBT_OPEN_INFO_T *hOpen; + + PRINTF(hInit, "isdbt_release\n"); + + hOpen = filp->private_data; + + hOpen->isdbttype = 0; + + list_del(&(hOpen->hList)); + kfree(hOpen->buf); + kfree(hOpen); + + return 0; +} + +int fc8150_if_test(void) +{ + int res = 0; + int i; + u16 wdata = 0; + u32 ldata = 0; + u8 data = 0; + u8 temp = 0; + + PRINTF(0, "fc8150_if_test Start!!!\n"); + for (i = 0 ; i < 100 ; i++) { + BBM_BYTE_WRITE(0, 0xa4, i & 0xff); + BBM_BYTE_READ(0, 0xa4, &data); + if ((i & 0xff) != data) { + PRINTF(0, "fc8150_if_btest! i=0x%x, data=0x%x\n" + , i & 0xff, data); + res = 1; + } + } + + for (i = 0 ; i < 100 ; i++) { + BBM_WORD_WRITE(0, 0xa4, i & 0xffff); + BBM_WORD_READ(0, 0xa4, &wdata); + if ((i & 0xffff) != wdata) { + PRINTF(0, "fc8150_if_wtest! i=0x%x, data=0x%x\n" + , i & 0xffff, wdata); + res = 1; + } + } + + for (i = 0 ; i < 100 ; i++) { + BBM_LONG_WRITE(0, 0xa4, i & 0xffffffff); + BBM_LONG_READ(0, 0xa4, &ldata); + if ((i & 0xffffffff) != ldata) { + PRINTF(0, "fc8150_if_ltest! i=0x%x, data=0x%x\n" + , i & 0xffffffff, ldata); + res = 1; + } + } + + for (i = 0 ; i < 100 ; i++) { + temp = i & 0xff; + BBM_TUNER_WRITE(NULL, 0x52, 0x01, &temp, 0x01); + BBM_TUNER_READ(NULL, 0x52, 0x01, &data, 0x01); + if ((i & 0xff) != data) + PRINTF(0, "FC8150 tuner test (0x%x,0x%x)\n" + , i & 0xff, data); + } + + PRINTF(0, "fc8150_if_test End!!!\n"); + + return res; +} + + +long isdbt_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +{ + s32 res = BBM_NOK; + s32 err = 0; + s32 size = 0; + struct ISDBT_OPEN_INFO_T *hOpen; + + struct ioctl_info info; + + if (_IOC_TYPE(cmd) != IOCTL_MAGIC) + return -EINVAL; + if (_IOC_NR(cmd) >= IOCTL_MAXNR) + return -EINVAL; + + hOpen = filp->private_data; + + size = _IOC_SIZE(cmd); + + switch (cmd) { + case IOCTL_ISDBT_RESET: + res = BBM_RESET(hInit); + break; + case IOCTL_ISDBT_INIT: + res = BBM_I2C_INIT(hInit, FCI_I2C_TYPE); + res |= BBM_PROBE(hInit); + if (res) { + PRINTF(hInit, "FC8150 Initialize Fail\n"); + break; + } + res |= BBM_INIT(hInit); + break; + case IOCTL_ISDBT_BYTE_READ: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_BYTE_READ(hInit, (u16)info.buff[0] + , (u8 *)(&info.buff[1])); + err |= copy_to_user((void *)arg, (void *)&info, size); + break; + case IOCTL_ISDBT_WORD_READ: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_WORD_READ(hInit, (u16)info.buff[0] + , (u16 *)(&info.buff[1])); + err |= copy_to_user((void *)arg, (void *)&info, size); + break; + case IOCTL_ISDBT_LONG_READ: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_LONG_READ(hInit, (u16)info.buff[0] + , (u32 *)(&info.buff[1])); + err |= copy_to_user((void *)arg, (void *)&info, size); + break; + case IOCTL_ISDBT_BULK_READ: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_BULK_READ(hInit, (u16)info.buff[0] + , (u8 *)(&info.buff[2]), info.buff[1]); + err |= copy_to_user((void *)arg, (void *)&info, size); + break; + case IOCTL_ISDBT_BYTE_WRITE: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_BYTE_WRITE(hInit, (u16)info.buff[0] + , (u8)info.buff[1]); + break; + case IOCTL_ISDBT_WORD_WRITE: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_WORD_WRITE(hInit, (u16)info.buff[0] + , (u16)info.buff[1]); + break; + case IOCTL_ISDBT_LONG_WRITE: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_LONG_WRITE(hInit, (u16)info.buff[0] + , (u32)info.buff[1]); + break; + case IOCTL_ISDBT_BULK_WRITE: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_BULK_WRITE(hInit, (u16)info.buff[0] + , (u8 *)(&info.buff[2]), info.buff[1]); + break; + case IOCTL_ISDBT_TUNER_READ: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_TUNER_READ(hInit, (u8)info.buff[0] + , (u8)info.buff[1], (u8 *)(&info.buff[3]) + , (u8)info.buff[2]); + err |= copy_to_user((void *)arg, (void *)&info, size); + break; + case IOCTL_ISDBT_TUNER_WRITE: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_TUNER_WRITE(hInit, (u8)info.buff[0] + , (u8)info.buff[1], (u8 *)(&info.buff[3]) + , (u8)info.buff[2]); + break; + case IOCTL_ISDBT_TUNER_SET_FREQ: + { + u32 f_rf; + err = copy_from_user((void *)&info, (void *)arg, size); + + f_rf = ((u32)info.buff[0] - 13) * 6000 + 473143; + res = BBM_TUNER_SET_FREQ(hInit, f_rf); + } + break; + case IOCTL_ISDBT_TUNER_SELECT: + err = copy_from_user((void *)&info, (void *)arg, size); + res = BBM_TUNER_SELECT(hInit, (u32)info.buff[0], 0); + break; + case IOCTL_ISDBT_TS_START: + hOpen->isdbttype = TS_TYPE; + break; + case IOCTL_ISDBT_TS_STOP: + hOpen->isdbttype = 0; + break; + case IOCTL_ISDBT_POWER_ON: + isdbt_hw_init(); + break; + case IOCTL_ISDBT_POWER_OFF: + isdbt_hw_deinit(); + break; + case IOCTL_ISDBT_SCAN_STATUS: + res = BBM_SCAN_STATUS(hInit); + break; + default: + PRINTF(hInit, "isdbt ioctl error!\n"); + res = BBM_NOK; + break; + } + + if (err < 0) { + PRINTF(hInit, "copy to/from user fail : %d", err); + res = BBM_NOK; + } + return res; +} + +int isdbt_init(void) +{ + s32 res; + + PRINTF(hInit, "isdbt_init\n"); + + res = misc_register(&fc8150_misc_device); + + if (res < 0) { + PRINTF(hInit, "isdbt init fail : %d\n", res); + return res; + } + + isdbt_hw_setting(); + + isdbt_hw_init(); + + hInit = kmalloc(sizeof(struct ISDBT_INIT_INFO_T), GFP_KERNEL); + + res = BBM_HOSTIF_SELECT(hInit, BBM_SPI); + + if (res) + PRINTF(hInit, "isdbt host interface select fail!\n"); + + isdbt_hw_deinit(); + + if (!isdbt_kthread) { + PRINTF(hInit, "kthread run\n"); + isdbt_kthread = kthread_run(isdbt_thread + , (void *)hInit, "isdbt_thread"); + } + + INIT_LIST_HEAD(&(hInit->hHead)); + + return 0; +} + +void isdbt_exit(void) +{ + PRINTF(hInit, "isdbt isdbt_exit\n"); + + free_irq(gpio_to_irq(GPIO_ISDBT_IRQ_FC8150), NULL); + gpio_free(GPIO_ISDBT_IRQ_FC8150); + gpio_free(GPIO_ISDBT_RST_FC8150); + gpio_free(GPIO_ISDBT_PWR_EN_FC8150); + + kthread_stop(isdbt_kthread); + isdbt_kthread = NULL; + + BBM_HOSTIF_DESELECT(hInit); + + isdbt_hw_deinit(); + + misc_deregister(&fc8150_misc_device); + + kfree(hInit); +} + +module_init(isdbt_init); +module_exit(isdbt_exit); + +MODULE_LICENSE("Dual BSD/GPL"); diff --git a/drivers/media/isdbt/fc8150/fc8150.h b/drivers/media/isdbt/fc8150/fc8150.h new file mode 100644 index 0000000..787cc0f --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150.h @@ -0,0 +1,120 @@ +/***************************************************************************** + Copyright(c) 2009 FCI Inc. All Rights Reserved + + File name : bbm.c + + Description : API of dmb baseband module + + History : + ---------------------------------------------------------------------- + 2009/08/29 jason initial +*******************************************************************************/ + +#ifndef __ISDBT_H__ +#define __ISDBT_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <linux/list.h> + +#include "fci_types.h" +#include "fci_ringbuffer.h" + +#define CTL_TYPE 0 +#define TS_TYPE 1 + +#define MAX_OPEN_NUM 8 + +#define IOCTL_MAGIC 't' + +struct ioctl_info { + unsigned long size; + unsigned long buff[128]; +}; + +#define IOCTL_MAXNR 25 + +#define IOCTL_ISDBT_RESET \ + _IO(IOCTL_MAGIC, 0) +#define IOCTL_ISDBT_PROBE \ + _IO(IOCTL_MAGIC, 1) +#define IOCTL_ISDBT_INIT \ + _IO(IOCTL_MAGIC, 2) +#define IOCTL_ISDBT_DEINIT \ + _IO(IOCTL_MAGIC, 3) + +#define IOCTL_ISDBT_BYTE_READ \ + _IOWR(IOCTL_MAGIC, 4, struct ioctl_info) +#define IOCTL_ISDBT_WORD_READ \ + _IOWR(IOCTL_MAGIC, 5, struct ioctl_info) +#define IOCTL_ISDBT_LONG_READ \ + _IOWR(IOCTL_MAGIC, 6, struct ioctl_info) +#define IOCTL_ISDBT_BULK_READ \ + _IOWR(IOCTL_MAGIC, 7, struct ioctl_info) + +#define IOCTL_ISDBT_BYTE_WRITE \ + _IOW(IOCTL_MAGIC, 8, struct ioctl_info) +#define IOCTL_ISDBT_WORD_WRITE \ + _IOW(IOCTL_MAGIC, 9, struct ioctl_info) +#define IOCTL_ISDBT_LONG_WRITE \ + _IOW(IOCTL_MAGIC, 10, struct ioctl_info) +#define IOCTL_ISDBT_BULK_WRITE \ + _IOW(IOCTL_MAGIC, 11, struct ioctl_info) + +#define IOCTL_ISDBT_TUNER_READ \ + _IOWR(IOCTL_MAGIC, 12, struct ioctl_info) +#define IOCTL_ISDBT_TUNER_WRITE \ + _IOW(IOCTL_MAGIC, 13, struct ioctl_info) + +#define IOCTL_ISDBT_TUNER_SET_FREQ \ + _IOW(IOCTL_MAGIC, 14, struct ioctl_info) +#define IOCTL_ISDBT_TUNER_SELECT \ + _IOW(IOCTL_MAGIC, 15, struct ioctl_info) +#define IOCTL_ISDBT_TUNER_DESELECT \ + _IO(IOCTL_MAGIC, 16) + +#define IOCTL_ISDBT_SCAN_STATUS \ + _IO(IOCTL_MAGIC, 17) +#define IOCTL_ISDBT_TS_START \ + _IO(IOCTL_MAGIC, 18) +#define IOCTL_ISDBT_TS_STOP \ + _IO(IOCTL_MAGIC, 19) + +#define IOCTL_ISDBT_TUNER_GET_RSSI \ + _IOWR(IOCTL_MAGIC, 20, struct ioctl_info) + +#define IOCTL_ISDBT_HOSTIF_SELECT \ + _IOW(IOCTL_MAGIC, 21, struct ioctl_info) +#define IOCTL_ISDBT_HOSTIF_DESELECT \ + _IO(IOCTL_MAGIC, 22) + +#define IOCTL_ISDBT_POWER_ON \ + _IO(IOCTL_MAGIC, 23) +#define IOCTL_ISDBT_POWER_OFF \ + _IO(IOCTL_MAGIC, 24) + +struct ISDBT_OPEN_INFO_T { + HANDLE *hInit; + struct list_head hList; + struct fci_ringbuffer RingBuffer; + u8 *buf; + u8 isdbttype; +}; + +struct ISDBT_INIT_INFO_T { + struct list_head hHead; +}; + +extern int isdbt_open(struct inode *inode, struct file *filp); +extern long isdbt_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); +extern int isdbt_release(struct inode *inode, struct file *filp); +extern ssize_t isdbt_read(struct file *filp + , char *buf, size_t count, loff_t *f_pos); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_bb.c b/drivers/media/isdbt/fc8150/fc8150_bb.c new file mode 100644 index 0000000..e696716 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_bb.c @@ -0,0 +1,789 @@ +/***************************************************************************** + + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_bb.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_oal.h" +#include "fci_hal.h" +#include "fci_tun.h" +#include "fc8150_regs.h" + +static u8 filter_coef_6M[7][16] = { + { 0x00, 0x00, 0x00, 0x07, 0x0f, 0x01, 0x03, 0x04 + , 0x01, 0x19, 0x14, 0x18, 0x0a, 0x26, 0x40, 0x4a}, + /*xtal_in : 24,16,32 (adc clk = 4.0000)*/ + { 0x00, 0x07, 0x07, 0x00, 0x01, 0x03, 0x03, 0x01 + , 0x1c, 0x17, 0x16, 0x1e, 0x10, 0x27, 0x3b, 0x43}, + /*xtal_in : 26 (adc clk = 4.3333)*/ + { 0x00, 0x07, 0x07, 0x00, 0x01, 0x03, 0x03, 0x00 + , 0x1b, 0x16, 0x16, 0x1f, 0x11, 0x27, 0x3a, 0x41}, + /*xtal_in : 27,18 (adc clk = 4.5000)*/ + { 0x00, 0x00, 0x07, 0x07, 0x00, 0x02, 0x03, 0x03 + , 0x1f, 0x18, 0x14, 0x1a, 0x0c, 0x26, 0x3e, 0x47}, + /*xtal_in : 16.384, 24.576 (adc clk = 4.0960)*/ + { 0x00, 0x07, 0x07, 0x00, 0x02, 0x03, 0x02, 0x0f + , 0x1a, 0x16, 0x18, 0x02, 0x13, 0x27, 0x38, 0x3e}, + /*xtal_in : 19.2, 38.4 (adc clk = 4.8000)*/ + { 0x00, 0x07, 0x07, 0x00, 0x01, 0x03, 0x03, 0x00 + , 0x1b, 0x16, 0x16, 0x1f, 0x11, 0x27, 0x3a, 0x41}, + /*xtal_in : 27.12 (adc clk = 4.5200)*/ + { 0x00, 0x07, 0x07, 0x00, 0x02, 0x03, 0x03, 0x00 + , 0x1a, 0x16, 0x17, 0x01, 0x12, 0x27, 0x39, 0x3f} + /*xtal_in : 37.4 (adc clk = 4.6750)*/ +}; + +#if 0 +static u8 filter_coef_7M[7][16] = { + { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0e, 0x00, 0x04, 0x05 + , 0x1f, 0x15, 0x12, 0x01, 0x22, 0x45, 0x55}, + /*xtal_in : 24,16,32 (adc clk = 4.0000)*/ + { 0x00, 0x00, 0x00, 0x07, 0x0e, 0x0f, 0x02, 0x05, 0x04 + , 0x1c, 0x14, 0x14, 0x05, 0x24, 0x43, 0x50}, + /*xtal_in : 26 (adc clk = 4.3333)*/ + { 0x00, 0x00, 0x00, 0x07, 0x0f, 0x00, 0x03, 0x05, 0x02 + , 0x1b, 0x14, 0x16, 0x07, 0x25, 0x42, 0x4d}, + /*xtal_in : 27,18 (adc clk = 4.5000)*/ + { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x01, 0x04, 0x05 + , 0x1e, 0x15, 0x13, 0x02, 0x23, 0x44, 0x53}, + /*xtal_in : 16.384, 24.576 (adc clk = 4.0960)*/ + { 0x00, 0x00, 0x07, 0x07, 0x00, 0x02, 0x04, 0x03, 0x1f + , 0x18, 0x14, 0x1a, 0x0c, 0x26, 0x3e, 0x47}, + /*xtal_in : 19.2, 38.4 (adc clk = 4.8000)*/ + { 0x00, 0x00, 0x00, 0x07, 0x0f, 0x00, 0x03, 0x05, 0x02 + , 0x1b, 0x14, 0x16, 0x07, 0x25, 0x41, 0x4d}, + /*xtal_in : 27.12 (adc clk = 4.5200)*/ + { 0x00, 0x00, 0x00, 0x07, 0x0f, 0x01, 0x03, 0x04, 0x00 + , 0x19, 0x14, 0x18, 0x0a, 0x26, 0x3f, 0x4a} + /*xtal_in : 37.4 (adc clk = 4.6750)*/ +}; + +static u8 filter_coef_8M[7][16] = { + { 0x00, 0x00, 0x00, 0x01, 0x01, 0x0f, 0x0d, 0x0f, 0x05 + , 0x06, 0x1d, 0x10, 0xf6, 0x1a, 0x4b, 0x62}, + /*xtal_in : 24,16,32 (adc clk = 4.0000)*/ + { 0x00, 0x00, 0x00, 0x01, 0x00, 0x0e, 0x0e, 0x02, 0x06 + , 0x04, 0x19, 0x10, 0xfb, 0x1e, 0x48, 0x5b}, + /*xtal_in : 26 (adc clk = 4.3333)*/ + { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0e, 0x00, 0x03, 0x05 + , 0x00, 0x16, 0x11, 0xff, 0x21, 0x46, 0x56}, + /*xtal_in : 27,18 (adc clk = 4.5000)*/ + { 0x00, 0x00, 0x00, 0x01, 0x00, 0x0f, 0x0d, 0x00, 0x05 + , 0x06, 0x1c, 0x10, 0xf7, 0x1b, 0x4a, 0x60}, + /*xtal_in : 16.384, 24.576 (adc clk = 4.0960)*/ + { 0x00, 0x00, 0x00, 0x07, 0x0e, 0x0f, 0x01, 0x05, 0x04 + , 0x1d, 0x14, 0x13, 0x04, 0x23, 0x44, 0x51}, + /*xtal_in : 19.2, 38.4 (adc clk = 4.8000)*/ + { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0e, 0x00, 0x04, 0x05 + , 0x00, 0x16, 0x12, 0x00, 0x21, 0x46, 0x56}, + /*xtal_in : 27.12 (adc clk = 4.5200)*/ + { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x01, 0x04, 0x05 + , 0x1e, 0x15, 0x13, 0x02, 0x23, 0x44, 0x53} + /*xtal_in : 37.4 (adc clk = 4.6750)*/ +}; +#endif + +static void fc8150_clock_mode(HANDLE hDevice) +{ + int i; + +#if (BBM_XTAL_FREQ == 16000) + bbm_write(hDevice, 0x0016, 0); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1f800000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x10); + bbm_write(hDevice, 0x2008, 0x41); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[0][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1b000000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xbd); + bbm_write(hDevice, 0x2008, 0xa1); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[0][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3ae1); + + bbm_long_write(hDevice, 0x103c, 0x17a00000); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x6b); + bbm_write(hDevice, 0x2008, 0x01); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[0][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 16384) + bbm_write(hDevice, 0x0016, 0); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2f80); + + bbm_long_write(hDevice, 0x103c, 0x20418937); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0xf7); + bbm_write(hDevice, 0x2008, 0xdf); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[3][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2f80); + + bbm_long_write(hDevice, 0x103c, 0x1ba5e354); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xa1); + bbm_write(hDevice, 0x2008, 0x2f); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[3][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3980); + + bbm_long_write(hDevice, 0x103c, 0x183126e9); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x4a); + bbm_write(hDevice, 0x2008, 0x7f); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[3][i]); +#endif + +#elif (BBM_XTAL_FREQ == 18000) + bbm_write(hDevice, 0x0016, 0); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2b3c); + + bbm_long_write(hDevice, 0x103c, 0x23700000); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x9c); + bbm_write(hDevice, 0x2008, 0xac); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[2][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2b3c); + + bbm_long_write(hDevice, 0x103c, 0x1e600000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x36); + bbm_write(hDevice, 0x2008, 0xc8); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[2][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3456); + + bbm_long_write(hDevice, 0x103c, 0x1a940000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xd0); + bbm_write(hDevice, 0x2008, 0xe5); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[2][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 19200) + bbm_write(hDevice, 0x0016, 0); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2889); + + bbm_long_write(hDevice, 0x103c, 0x25cccccd); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x62); + bbm_write(hDevice, 0x2008, 0xe1); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[4][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2889); + + bbm_long_write(hDevice, 0x103c, 0x20666666); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0xf3); + bbm_write(hDevice, 0x2008, 0x5c); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[4][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3111); + + bbm_long_write(hDevice, 0x103c, 0x1c59999a); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x83); + bbm_write(hDevice, 0x2008, 0xd6); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[4][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 24000) + bbm_write(hDevice, 0x0016, 2); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1f800000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x10); + bbm_write(hDevice, 0x2008, 0x41); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[0][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1b000000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xbd); + bbm_write(hDevice, 0x2008, 0xa1); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[0][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3ae1); + + bbm_long_write(hDevice, 0x103c, 0x17a00000); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x6b); + bbm_write(hDevice, 0x2008, 0x01); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[0][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 26000) + bbm_write(hDevice, 0x0016, 2); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2ce6); + + bbm_long_write(hDevice, 0x103c, 0x221fffd4); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0xc0); + bbm_write(hDevice, 0x2008, 0x3c); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[1][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2ce6); + + bbm_long_write(hDevice, 0x103c, 0x1d3fffda); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x60); + bbm_write(hDevice, 0x2008, 0x46); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[1][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x365a); + + bbm_long_write(hDevice, 0x103c, 0x1997ffdf); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x00); + bbm_write(hDevice, 0x2008, 0x50); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[1][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 27000) + bbm_write(hDevice, 0x0016, 2); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2b3c); + + bbm_long_write(hDevice, 0x103c, 0x23700000); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x9c); + bbm_write(hDevice, 0x2008, 0xac); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[2][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2b3c); + + bbm_long_write(hDevice, 0x103c, 0x1e600000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x36); + bbm_write(hDevice, 0x2008, 0xc8); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[2][i]); +#else + bbm_word_write(hDevice, 0x1032, 0x3456); + + bbm_long_write(hDevice, 0x103c, 0x1a940000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xd0); + bbm_write(hDevice, 0x2008, 0xe5); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[2][i]); +#endif + +#elif (BBM_XTAL_FREQ == 27120) + bbm_write(hDevice, 0x0016, 2); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2b0b); + + bbm_long_write(hDevice, 0x103c, 0x239851ec); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x98); + bbm_write(hDevice, 0x2008, 0x94); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[5][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2b0b); + + bbm_long_write(hDevice, 0x103c, 0x1e828f5c); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x32); + bbm_write(hDevice, 0x2008, 0x02); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[5][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x341b); + + bbm_long_write(hDevice, 0x103c, 0x1ab23d71); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xcb); + bbm_write(hDevice, 0x2008, 0x70); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[5][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 24576) + bbm_write(hDevice, 0x0016, 2); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2f80); + + bbm_long_write(hDevice, 0x103c, 0x20418937); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0xf7); + bbm_write(hDevice, 0x2008, 0xdf); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[3][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2f80); + + bbm_long_write(hDevice, 0x103c, 0x1ba5e354); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xa1); + bbm_write(hDevice, 0x2008, 0x2f); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[3][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3980); + + bbm_long_write(hDevice, 0x103c, 0x183126e9); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x4a); + bbm_write(hDevice, 0x2008, 0x7f); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[3][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 32000) + /* Default Clock */ + bbm_write(hDevice, 0x0016, 1); + +#if (BBM_BAND_WIDTH == 6) + /* Default Band-width */ + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1f800000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x10); + bbm_write(hDevice, 0x2008, 0x41); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[0][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x30a4); + + bbm_long_write(hDevice, 0x103c, 0x1b000000); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xbd); + bbm_write(hDevice, 0x2008, 0xa1); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[0][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3ae1); + + bbm_long_write(hDevice, 0x103c, 0x17a00000); + + bbm_write(hDevice, 0x200a, 0x05); + bbm_write(hDevice, 0x2009, 0x6b); + bbm_write(hDevice, 0x2008, 0x01); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[0][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 37400) + bbm_write(hDevice, 0x0016, 1); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x299e); + + bbm_long_write(hDevice, 0x103c, 0x24d0cccd); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x7a); + bbm_write(hDevice, 0x2008, 0x0f); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[6][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x299e); + + bbm_long_write(hDevice, 0x103c, 0x1f8e6666); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x0e); + bbm_write(hDevice, 0x2008, 0x66); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[6][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3261); + + bbm_long_write(hDevice, 0x103c, 0x1b9c999a); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0xa2); + bbm_write(hDevice, 0x2008, 0xbe); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[6][i]); + +#endif + +#elif (BBM_XTAL_FREQ == 38400) + bbm_write(hDevice, 0x0016, 1); + +#if (BBM_BAND_WIDTH == 6) + bbm_word_write(hDevice, 0x1032, 0x2889); + + bbm_long_write(hDevice, 0x103c, 0x25cccccd); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0x62); + bbm_write(hDevice, 0x2008, 0xe1); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_6M[4][i]); + +#elif (BBM_BAND_WIDTH == 7) + bbm_word_write(hDevice, 0x1032, 0x2889); + + bbm_long_write(hDevice, 0x103c, 0x20666666); + + bbm_write(hDevice, 0x200a, 0x03); + bbm_write(hDevice, 0x2009, 0xf3); + bbm_write(hDevice, 0x2008, 0x5c); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_7M[4][i]); + +#else + bbm_word_write(hDevice, 0x1032, 0x3111); + + bbm_long_write(hDevice, 0x103c, 0x1c59999a); + + bbm_write(hDevice, 0x200a, 0x04); + bbm_write(hDevice, 0x2009, 0x83); + bbm_write(hDevice, 0x2008, 0xd6); + + for (i = 0; i < 16; i++) + bbm_write(hDevice, 0x1040+i, filter_coef_8M[4][i]); + +#endif +#endif +} + +int fc8150_reset(HANDLE hDevice) +{ + bbm_write(hDevice, BBM_SW_RESET, 0x7f); + bbm_write(hDevice, BBM_SW_RESET, 0xff); + + return BBM_OK; +} + +int fc8150_probe(HANDLE hDevice) +{ + u16 ver; + bbm_word_read(hDevice, BBM_CHIP_ID_L, &ver); + + return (ver == 0x8150) ? BBM_OK : BBM_NOK; +} + +int fc8150_init(HANDLE hDevice) +{ + bbm_write(hDevice, 0x00b0, 0x03); + bbm_write(hDevice, 0x00b1, 0x00); + bbm_write(hDevice, 0x00b2, 0x14); + + fc8150_reset(hDevice); + fc8150_clock_mode(hDevice); + + bbm_write(hDevice, 0x1000, 0x27); + bbm_write(hDevice, 0x1004, 0x4d); + bbm_write(hDevice, 0x1069, 0x09); + bbm_write(hDevice, 0x1075, 0x00); + + bbm_word_write(hDevice, 0x00b4, 0x0000); + /*bbm_write(hDevice, 0x00b6, 0x03);*/ /* Default 0x03, 0x00, 0x07*/ + bbm_write(hDevice, 0x00b9, 0x00); + bbm_write(hDevice, 0x00ba, 0x01); + + bbm_write(hDevice, 0x2004, 0x41); + bbm_write(hDevice, 0x2106, 0x1f); + + bbm_write(hDevice, 0x5010, 0x00); + bbm_write(hDevice, BBM_RS_FAIL_TX, 0x00); /* RS FAILURE TX: 0x02*/ + + bbm_word_write(hDevice, BBM_BUF_TS_START, TS_BUF_START); + bbm_word_write(hDevice, BBM_BUF_TS_END, TS_BUF_END); + bbm_word_write(hDevice, BBM_BUF_TS_THR, TS_BUF_THR); + + /*bbm_word_write(hDevice, BBM_BUF_AC_START, AC_BUF_START);*/ + /*bbm_word_write(hDevice, BBM_BUF_AC_END, AC_BUF_END);*/ + /*bbm_word_write(hDevice, BBM_BUF_AC_THR, AC_BUF_THR);*/ + + /*bbm_write(hDevice, BBM_INT_POLAR_SEL, 0x00);*/ + /*bbm_write(hDevice, BBM_INT_AUTO_CLEAR, 0x01);*/ + /*bbm_write(hDevice, BBM_STATUS_AUTO_CLEAR_EN, 0x00);*/ + + bbm_write(hDevice, BBM_BUF_ENABLE, 0x01); + bbm_write(hDevice, BBM_BUF_INT, 0x01); + + bbm_write(hDevice, BBM_INT_MASK, 0x07); + bbm_write(hDevice, BBM_INT_STS_EN, 0x01); + + return BBM_OK; +} + +int fc8150_deinit(HANDLE hDevice) +{ + bbm_write(hDevice, BBM_SW_RESET, 0x00); + + return BBM_OK; +} + +int fc8150_scan_status(HANDLE hDevice) +{ + u32 ifagc_timeout = 7; + u32 ofdm_timeout = 16; + u32 ffs_lock_timeout = 10; + u32 dagc_timeout = 100; /* always done*/ + u32 cfs_timeout = 12; + u32 tmcc_timeout = 105; + u32 ts_err_free_timeout = 0; + int rssi; + u8 data, data1; + u8 lay0_mod, lay0_cr; + int i; + + for (i = 0; i < ifagc_timeout; i++) { + bbm_read(hDevice, 0x3025, &data); + + if (data & 0x01) + break; + + msWait(10); + } + + if (i == ifagc_timeout) + return BBM_NOK; + + tuner_get_rssi(hDevice, &rssi); + + if (rssi < -107) + return BBM_NOK; + + for (; i < ofdm_timeout; i++) { + bbm_read(hDevice, 0x3025, &data); + + if (data & 0x08) + break; + + msWait(10); + } + + if (i == ofdm_timeout) + return BBM_NOK; + + if (0 == (data & 0x04)) + return BBM_NOK; + + for (; i < ffs_lock_timeout; i++) { + bbm_read(hDevice, 0x3026, &data); + + if (data & 0x10) + break; + + msWait(10); + } + + if (i == ffs_lock_timeout) + return BBM_NOK; + + /* DAGC Lock*/ + for (i = 0; i < dagc_timeout; i++) { + bbm_read(hDevice, 0x3026, &data); + + if (data & 0x01) + break; + + msWait(10); + } + + if (i == dagc_timeout) + return BBM_NOK; + + for (i = 0; i < cfs_timeout; i++) { + bbm_read(hDevice, 0x3025, &data); + + if (data & 0x40) + break; + + msWait(10); + } + + if (i == cfs_timeout) + return BBM_NOK; + + bbm_read(hDevice, 0x2023, &data1); + if (data1 & 1) + return BBM_NOK; + + for (i = 0; i < tmcc_timeout; i++) { + bbm_read(hDevice, 0x3026, &data); + if (data & 0x02) + break; + + msWait(10); + } + + if (i == tmcc_timeout) + return BBM_NOK; + + bbm_read(hDevice, 0x4113, &data); + bbm_read(hDevice, 0x4114, &data1); + + if (((data >> 3) & 0x1) == 0) + return BBM_NOK; + + lay0_mod = ((data & 0x10) >> 2) | + ((data & 0x20) >> 4) | + ((data & 0x40) >> 6); + + lay0_cr = ((data & 0x80) >> 5) | + ((data1 & 0x01) << 1) | + ((data1 & 0x02) >> 1); + + if (!((lay0_mod == 1) || (lay0_mod == 2))) + return BBM_NOK; + + if (((0x70 & data) == 0x40) && ((0x1c & data1) == 0x18)) + ts_err_free_timeout = 400; + else + ts_err_free_timeout = 650; + + for (i = 0; i < ts_err_free_timeout; i++) { + bbm_read(hDevice, 0x5053, &data); + if (data & 0x01) + break; + + msWait(10); + } + + if (i == ts_err_free_timeout) + return BBM_NOK; + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_bb.h b/drivers/media/isdbt/fc8150/fc8150_bb.h new file mode 100644 index 0000000..696c621 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_bb.h @@ -0,0 +1,22 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_bb.h + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + + +#ifndef __FC8150_BB__ +#define __FC8150_BB__ + +#include "fci_types.h" + +extern int fc8150_reset(HANDLE hDevice); +extern int fc8150_probe(HANDLE hDevice); +extern int fc8150_init(HANDLE hDevice); +extern int fc8150_deinit(HANDLE hDevice); +extern int fc8150_scan_status(HANDLE hDevice); + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_hpi.c b/drivers/media/isdbt/fc8150/fc8150_hpi.c new file mode 100644 index 0000000..67d8484 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_hpi.c @@ -0,0 +1,197 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_hpi.c + + Description : fc8150 host interface + +*******************************************************************************/ +#include "linux/io.h" + +#include "fci_types.h" +#include "fc8150_regs.h" +#include "fci_oal.h" + +#define HPIC_READ 0x01 /* read command */ +#define HPIC_WRITE 0x02 /* write command */ +#define HPIC_AINC 0x04 /* address increment */ +#define HPIC_BMODE 0x00 /* byte mode */ +#define HPIC_WMODE 0x10 /* word mode */ +#define HPIC_LMODE 0x20 /* long mode */ +#define HPIC_ENDIAN 0x00 /* little endian */ +#define HPIC_CLEAR 0x80 /* currently not used */ + +#define BBM_BASE_ADDR 0 +#define BBM_BASE_OFFSET 0 + +#define FC8150_ADDR_REG(x) outb(x, (BBM_BASE_ADDR \ + + (BBM_ADDRESS_REG << BBM_BASE_OFFSET))) +#define FC8150_CMD_REG(x) outb(x, (BBM_BASE_ADDR \ + + (BBM_COMMAND_REG << BBM_BASE_OFFSET))) +#define FC8150_DATA_REG_OUT(x) outb(x, (BBM_BASE_ADDR \ + + (BBM_DATA_REG << BBM_BASE_OFFSET))) +#define FC8150_DATA_REG_IN inb(BBM_BASE_ADDR \ + + (BBM_DATA_REG << BBM_BASE_OFFSET)) + +int fc8150_hpi_init(HANDLE hDevice, u16 param1, u16 param2) +{ + OAL_CREATE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_byteread(HANDLE hDevice, u16 addr, u8 *data) +{ + u8 command = HPIC_READ | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + *data = FC8150_DATA_REG_IN; + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_wordread(HANDLE hDevice, u16 addr, u16 *data) +{ + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + *data = FC8150_DATA_REG_IN; + *data |= FC8150_DATA_REG_IN << 8; + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_longread(HANDLE hDevice, u16 addr, u32 *data) +{ + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + *data = FC8150_DATA_REG_IN; + *data |= FC8150_DATA_REG_IN << 8; + *data |= FC8150_DATA_REG_IN << 16; + *data |= FC8150_DATA_REG_IN << 24; + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + s32 i; + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + for (i = 0; i < length; i++) + data[i] = FC8150_DATA_REG_IN; + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_bytewrite(HANDLE hDevice, u16 addr, u8 data) +{ + u8 command = HPIC_WRITE | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + FC8150_DATA_REG_OUT(data); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_wordwrite(HANDLE hDevice, u16 addr, u16 data) +{ + u8 command = HPIC_WRITE | HPIC_BMODE | HPIC_ENDIAN | HPIC_AINC; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + FC8150_DATA_REG_OUT(data & 0xff); + FC8150_DATA_REG_OUT((data & 0xff00) >> 8); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_longwrite(HANDLE hDevice, u16 addr, u32 data) +{ + u8 command = HPIC_WRITE | HPIC_BMODE | HPIC_ENDIAN | HPIC_AINC; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + FC8150_DATA_REG_OUT(data & 0xff); + FC8150_DATA_REG_OUT((data & 0xff00) >> 8); + FC8150_DATA_REG_OUT((data & 0xff0000) >> 16); + FC8150_DATA_REG_OUT((data & 0xff000000) >> 24); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + s32 i; + u8 command = HPIC_WRITE | HPIC_BMODE | HPIC_ENDIAN | HPIC_AINC; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + for (i = 0; i < length; i++) + FC8150_DATA_REG_OUT(data[i]); + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + s32 i; + u8 command = HPIC_READ | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_ADDR_REG(addr & 0xff); + FC8150_ADDR_REG((addr & 0xff00) >> 8); + FC8150_CMD_REG(command); + + for (i = 0; i < length; i++) + data[i] = FC8150_DATA_REG_IN; + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_hpi_deinit(HANDLE hDevice) +{ + OAL_DELETE_SEMAPHORE(); + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_hpi.h b/drivers/media/isdbt/fc8150/fc8150_hpi.h new file mode 100644 index 0000000..b99921a --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_hpi.h @@ -0,0 +1,33 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_hpi.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#ifndef __FC8150_HPI_H__ +#define __FC8150_HPI_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_hpi_init(HANDLE hDevice, u16 param1, u16 param2); +extern int fc8150_hpi_byteread(HANDLE hDevice, u16 addr, u8 *data); +extern int fc8150_hpi_wordread(HANDLE hDevice, u16 addr, u16 *data); +extern int fc8150_hpi_longread(HANDLE hDevice, u16 addr, u32 *data); +extern int fc8150_hpi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_hpi_bytewrite(HANDLE hDevice, u16 addr, u8 data); +extern int fc8150_hpi_wordwrite(HANDLE hDevice, u16 addr, u16 data); +extern int fc8150_hpi_longwrite(HANDLE hDevice, u16 addr, u32 data); +extern int fc8150_hpi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_hpi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length); +extern int fc8150_hpi_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_i2c.c b/drivers/media/isdbt/fc8150/fc8150_i2c.c new file mode 100644 index 0000000..5d264c1 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_i2c.c @@ -0,0 +1,237 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_i2c.c + + Description : fc8150 host interface + +*******************************************************************************/ + +#include "fci_types.h" +#include "fc8150_regs.h" +#include "fci_oal.h" +#include "fci_hal.h" + +#define HPIC_READ 0x01 /* read command */ +#define HPIC_WRITE 0x02 /* write command */ +#define HPIC_AINC 0x04 /* address increment */ +#define HPIC_BMODE 0x00 /* byte mode */ +#define HPIC_WMODE 0x10 /* word mode */ +#define HPIC_LMODE 0x20 /* long mode */ +#define HPIC_ENDIAN 0x00 /* little endian */ +#define HPIC_CLEAR 0x80 /* currently not used */ + +#define CHIP_ADDR 0x58 + +static int i2c_bulkread(HANDLE hDevice, u8 chip, u8 addr, u8 *data, u16 length) +{ + /* Write your own i2c driver code here for read operation. */ + + return BBM_OK; +} + +static int i2c_bulkwrite(HANDLE hDevice, u8 chip, u8 addr, u8 *data, u16 length) +{ + /* Write your own i2c driver code here for Write operation. */ + + return BBM_OK; +} + +static int i2c_dataread(HANDLE hDevice, u8 chip, u8 addr, u8 *data, u32 length) +{ + return i2c_bulkread(hDevice, chip, addr, data, length); +} + +int fc8150_bypass_read(HANDLE hDevice, u8 chip, u8 addr, u8 *data, u16 length) +{ + int res; + u8 bypass_addr = 0x03; + u8 bypass_data = 1; + u8 bypass_len = 1; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, bypass_addr + , &bypass_data, bypass_len); + res |= i2c_bulkread(hDevice, chip, addr, data, length); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_bypass_write(HANDLE hDevice, u8 chip, u8 addr, u8 *data, u16 length) +{ + int res; + u8 bypass_addr = 0x03; + u8 bypass_data = 1; + u8 bypass_len = 1; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, bypass_addr + , &bypass_data, bypass_len); + res |= i2c_bulkwrite(hDevice, chip, addr, data, length); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_init(HANDLE hDevice, u16 param1, u16 param2) +{ + OAL_CREATE_SEMAPHORE(); + + /* for TSIF, you can call here your own TSIF initialization function. */ + /* tsif_initialize(); */ + + bbm_write(hDevice, BBM_TS_CLK_DIV, 0x04); + bbm_write(hDevice, BBM_TS_PAUSE, 0x80); + + bbm_write(hDevice, BBM_TS_CTRL, 0x02); + bbm_write(hDevice, BBM_TS_SEL, 0x84); + + return BBM_OK; +} + +int fc8150_i2c_byteread(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + u8 command = HPIC_READ | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkread(hDevice, CHIP_ADDR, BBM_DATA_REG, data, 1); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_wordread(HANDLE hDevice, u16 addr, u16 *data) +{ + int res; + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkread(hDevice, CHIP_ADDR, BBM_DATA_REG, (u8 *)data, 2); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_longread(HANDLE hDevice, u16 addr, u32 *data) +{ + int res; + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkread(hDevice, CHIP_ADDR, BBM_DATA_REG, (u8 *)data, 4); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = HPIC_READ | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkread(hDevice, CHIP_ADDR, BBM_DATA_REG, data, length); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_bytewrite(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + u8 command = HPIC_WRITE | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_DATA_REG, (u8 *)&data, 1); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_wordwrite(HANDLE hDevice, u16 addr, u16 data) +{ + int res; + u8 command = HPIC_WRITE | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_DATA_REG, (u8 *)&data, 2); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_longwrite(HANDLE hDevice, u16 addr, u32 data) +{ + int res; + u8 command = HPIC_WRITE | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_DATA_REG, (u8 *)&data, 4); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = HPIC_WRITE | HPIC_AINC | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_DATA_REG, data, length); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + int res; + u8 command = HPIC_READ | HPIC_BMODE | HPIC_ENDIAN; + + OAL_OBTAIN_SEMAPHORE(); + res = i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_ADDRESS_REG + , (u8 *)&addr, 2); + res |= i2c_bulkwrite(hDevice, CHIP_ADDR, BBM_COMMAND_REG, &command, 1); + res |= i2c_dataread(hDevice, CHIP_ADDR, BBM_DATA_REG, data, length); + OAL_RELEASE_SEMAPHORE(); + + return res; +} + +int fc8150_i2c_deinit(HANDLE hDevice) +{ + bbm_write(hDevice, BBM_TS_SEL, 0x00); + + /* tsif_disable(); */ + + OAL_DELETE_SEMAPHORE(); + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_i2c.h b/drivers/media/isdbt/fc8150/fc8150_i2c.h new file mode 100644 index 0000000..64d69de --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_i2c.h @@ -0,0 +1,33 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_i2c.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#ifndef __FC8150_I2C_H__ +#define __FC8150_I2C_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_i2c_init(HANDLE hDevice, u16 param1, u16 param2); +extern int fc8150_i2c_byteread(HANDLE hDevice, u16 addr, u8 *data); +extern int fc8150_i2c_wordread(HANDLE hDevice, u16 addr, u16 *data); +extern int fc8150_i2c_longread(HANDLE hDevice, u16 addr, u32 *data); +extern int fc8150_i2c_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_i2c_bytewrite(HANDLE hDevice, u16 addr, u8 data); +extern int fc8150_i2c_wordwrite(HANDLE hDevice, u16 addr, u16 data); +extern int fc8150_i2c_longwrite(HANDLE hDevice, u16 addr, u32 data); +extern int fc8150_i2c_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_i2c_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length); +extern int fc8150_i2c_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_isr.c b/drivers/media/isdbt/fc8150/fc8150_isr.c new file mode 100644 index 0000000..259576b --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_isr.c @@ -0,0 +1,47 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_isr.c + + Description : fc8150 interrupt service routine + +*******************************************************************************/ +#include "fci_types.h" +#include "fci_hal.h" +#include "fci_oal.h" +#include "fc8150_regs.h" + +int (*pTSCallback)(u32 userdata, u8 *data, int length) = NULL; +int (*pACCallback)(u32 userdata, u8 *data, int length) = NULL; + +u32 gTSUserData; +u32 gACUserData; + +/* static u8 acBuffer[AC_BUF_THR]; */ +static u8 tsBuffer[TS_BUF_SIZE]; + +static void fc8150_data(HANDLE hDevice, u8 bufIntStatus) +{ + if (bufIntStatus & 0x01) { /* TS */ + bbm_data(hDevice, BBM_TS_DATA, &tsBuffer[0], TS_BUF_SIZE/2); + + if (pTSCallback) + (*pTSCallback)(gTSUserData + , &tsBuffer[0], TS_BUF_SIZE/2); + } +} + +void fc8150_isr(HANDLE hDevice) +{ + u8 IntStatus = 0; + u8 bufIntStatus = 0; + + bbm_read(hDevice, BBM_INT_STATUS, &IntStatus); + bbm_write(hDevice, BBM_INT_STATUS, IntStatus); + + bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus); + if (bufIntStatus) { + bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus); + fc8150_data(hDevice, bufIntStatus); + } +} diff --git a/drivers/media/isdbt/fc8150/fc8150_isr.h b/drivers/media/isdbt/fc8150/fc8150_isr.h new file mode 100644 index 0000000..d7f1098 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_isr.h @@ -0,0 +1,22 @@ + +#ifndef __FC8150_ISR__ +#define __FC8150_ISR__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "fci_types.h" + +extern u32 gACUserData; +extern u32 gTSUserData; + +extern int (*pACCallback)(u32 userdata, u8 *data, int length); +extern int (*pTSCallback)(u32 userdata, u8 *data, int length); + +extern void fc8150_isr(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_ppi.c b/drivers/media/isdbt/fc8150/fc8150_ppi.c new file mode 100644 index 0000000..7c9fc07 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_ppi.c @@ -0,0 +1,212 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_ppi.c + + Description : fc8150 host interface + +*******************************************************************************/ +#include "linux/io.h" + +#include "fci_types.h" +#include "fc8150_regs.h" +#include "fci_oal.h" + +#define BBM_BASE_ADDR 0x00 + +#define PPI_BMODE 0x00 +#define PPI_WMODE 0x10 +#define PPI_LMODE 0x20 +#define PPI_READ 0x40 +#define PPI_WRITE 0x00 +#define PPI_AINC 0x80 + +#define FC8150_PPI_REG_OUT(x) outb(x, BBM_BASE_ADDR) +#define FC8150_PPI_REG_IN inb(BBM_BASE_ADDR) + +int fc8150_ppi_init(HANDLE hDevice, u16 param1, u16 param2) +{ + OAL_CREATE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_byteread(HANDLE hDevice, u16 addr, u8 *data) +{ + u32 length = 1; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(PPI_READ | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + *data = FC8150_PPI_REG_IN; + OAL_RELEASE_SEMAPHORE(); + return BBM_OK; +} + +int fc8150_ppi_wordread(HANDLE hDevice, u16 addr, u16 *data) +{ + u32 length = 2; + u8 command = PPI_AINC | PPI_READ | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + *data = FC8150_PPI_REG_IN; + *data |= FC8150_PPI_REG_IN << 8; + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_longread(HANDLE hDevice, u16 addr, u32 *data) +{ + u32 length = 4; + u8 command = PPI_AINC | PPI_READ | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + *data = FC8150_PPI_REG_IN; + *data |= FC8150_PPI_REG_IN << 8; + *data |= FC8150_PPI_REG_IN << 16; + *data |= FC8150_PPI_REG_IN << 24; + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int i; + u8 command = PPI_AINC | PPI_READ | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + for (i = 0; i < length; i++) + data[i] = FC8150_PPI_REG_IN; + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_bytewrite(HANDLE hDevice, u16 addr, u8 data) +{ + u32 length = 1; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(PPI_WRITE | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + FC8150_PPI_REG_OUT(data); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_wordwrite(HANDLE hDevice, u16 addr, u16 data) +{ + u32 length = 2; + u8 command = PPI_AINC | PPI_WRITE | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + FC8150_PPI_REG_OUT(data & 0xff); + FC8150_PPI_REG_OUT((data & 0xff00) >> 8); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_longwrite(HANDLE hDevice, u16 addr, u32 data) +{ + u32 length = 4; + u8 command = PPI_AINC | PPI_WRITE | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + FC8150_PPI_REG_OUT(data & 0x000000ff); + FC8150_PPI_REG_OUT((data & 0x0000ff00) >> 8); + FC8150_PPI_REG_OUT((data & 0x00ff0000) >> 16); + FC8150_PPI_REG_OUT((data & 0xff000000) >> 24); + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int i; + u8 command = PPI_AINC | PPI_WRITE | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + for (i = 0; i < length; i++) + FC8150_PPI_REG_OUT(data[i]); + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + int i; + u8 command = PPI_READ | PPI_BMODE; + + OAL_OBTAIN_SEMAPHORE(); + FC8150_PPI_REG_OUT(addr & 0xff); + FC8150_PPI_REG_OUT((addr & 0xff00) >> 8); + FC8150_PPI_REG_OUT(command | ((length & 0x0f0000) >> 16)); + FC8150_PPI_REG_OUT((length & 0xff00) >> 8); + FC8150_PPI_REG_OUT(length & 0xff); + + for (i = 0; i < length; i++) + data[i] = FC8150_PPI_REG_IN; + + OAL_RELEASE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_ppi_deinit(HANDLE hDevice) +{ + OAL_DELETE_SEMAPHORE(); + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_ppi.h b/drivers/media/isdbt/fc8150/fc8150_ppi.h new file mode 100644 index 0000000..b7d5322 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_ppi.h @@ -0,0 +1,33 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_ppi.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#ifndef __FC8150_PPI_H__ +#define __FC8150_PPI_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_ppi_init(HANDLE hDevice, u16 param1, u16 param2); +extern int fc8150_ppi_byteread(HANDLE hDevice, u16 addr, u8 *data); +extern int fc8150_ppi_wordread(HANDLE hDevice, u16 addr, u16 *data); +extern int fc8150_ppi_longread(HANDLE hDevice, u16 addr, u32 *data); +extern int fc8150_ppi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_ppi_bytewrite(HANDLE hDevice, u16 addr, u8 data); +extern int fc8150_ppi_wordwrite(HANDLE hDevice, u16 addr, u16 data); +extern int fc8150_ppi_longwrite(HANDLE hDevice, u16 addr, u32 data); +extern int fc8150_ppi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_ppi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length); +extern int fc8150_ppi_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_regs.h b/drivers/media/isdbt/fc8150/fc8150_regs.h new file mode 100644 index 0000000..235e703 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_regs.h @@ -0,0 +1,136 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_regs.h + + Description : Baseband register header + +*******************************************************************************/ + +#ifndef __FC8150_REGS_H__ +#define __FC8150_REGS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* #define BBM_XTAL_FREQ 16000 */ +/* #define BBM_XTAL_FREQ 16384 */ +/* #define BBM_XTAL_FREQ 18000 */ +/* #define BBM_XTAL_FREQ 19200 */ +#define BBM_XTAL_FREQ 24000 +/* #define BBM_XTAL_FREQ 26000 */ +/* #define BBM_XTAL_FREQ 27000 */ +/* #define BBM_XTAL_FREQ 27120 */ +/* #define BBM_XTAL_FREQ 24576 */ +/* #define BBM_XTAL_FREQ 32000 */ +/* #define BBM_XTAL_FREQ 37400 */ +/* #define BBM_XTAL_FREQ 38400 */ + +#define BBM_BAND_WIDTH 6 /* BW = 6M */ +/* #define BBM_BAND_WIDTH 7 */ /* BW = 7M */ +/* #define BBM_BAND_WIDTH 8 */ /* BW = 8M */ + + /* Host register */ +#define BBM_ADDRESS_REG 0x00 +#define BBM_COMMAND_REG 0x01 +#define BBM_DATA_REG 0x02 + + /* Common */ +#define BBM_AP2APB_LT 0x0000 +#define BBM_SW_RESET 0x0001 +#define BBM_INT_STATUS 0x0002 +#define BBM_INT_MASK 0x0003 +#define BBM_INT_STS_EN 0x0006 +#define BBM_AC_DATA 0x0007 +#define BBM_TS_DATA 0x0008 +#define BBM_TS_CLK_DIV 0x0010 +#define BBM_TS_CTRL 0x0011 +#define BBM_MD_MISO 0x0012 +#define BBM_TS_SEL 0x0013 +#define BBM_TS_PAUSE 0x0014 +#define BBM_RF_DEVID 0x0015 +#define BBM_INT_AUTO_CLEAR 0x0017 +#define BBM_INT_PERIOD 0x0018 +#define BBM_NON_AUTO_INT_PERIOD 0x0019 +#define BBM_STATUS_AUTO_CLEAR_EN 0x001a +#define BBM_INT_POLAR_SEL 0x0020 +#define BBM_PATTERN_MODE 0x0021 +#define BBM_CHIP_ID_L 0x0026 +#define BBM_CHIP_VERSION 0x0028 +#define BBM_TS_PAT_L 0x00a0 +#define BBM_AC_PAT_L 0x00a2 +#define BBM_VERIFY_TEST 0x00a4 + + /* I2C */ +#define BBM_I2C_PR_L 0x0030 +#define BBM_I2C_PR_H 0x0031 +#define BBM_I2C_CTR 0x0032 +#define BBM_I2C_RXR 0x0033 +#define BBM_I2C_SR 0x0034 +#define BBM_I2C_TXR 0x0035 +#define BBM_I2C_CR 0x0036 + + /* DM Control */ +#define BBM_DM_AUTO_ENABLE 0x0040 +#define BBM_DM_READ_SIZE 0x0041 +#define BBM_DM_START_ADDR 0x0042 +#define BBM_DM_TIMER_GAP 0x0043 +#define BBM_DM_BUSY 0x0044 + + /* RSSI */ +#define BBM_RSSI 0x0100 + + /* CE */ +#define BBM_WSCN_MSQ 0x4063 + + /* FEC */ +#define BBM_REQ_BER 0x5000 +#define BBM_MAIN_BER_RXD_RSPS 0x5020 +#define BBM_MAIN_BER_ERR_RSPS 0x5022 +#define BBM_MAIN_BER_ERR_BITS 0x5024 +#define BBM_BER_RXD_RSPS 0x5030 +#define BBM_BER_ERR_RSPS 0x5032 +#define BBM_BER_ERR_BITS 0x5034 +#define BBM_DMP_BER_RXD_BITS 0x5040 +#define BBM_DMP_BER_ERR_BITS 0x5044 + + /* Buffer */ +#define BBM_BUF_STATUS 0x8000 +#define BBM_BUF_OVERRUN 0x8001 +#define BBM_BUF_ENABLE 0x8002 +#define BBM_BUF_INT 0x8003 +#define BBM_RS_FAIL_TX 0x8004 + +#define BBM_SYNC_RELATED_INT_STATUS 0x8006 +#define BBM_SYNC_RELATED_INT_ENABLE 0x8007 +#define BBM_HANGING_TS 0x800A +#define BBM_HANGING_AC 0x800B +#define BBM_HANGING_ENABLE 0x800C + +#define BBM_BUF_TS_START 0x8010 +#define BBM_BUF_AC_START 0x8012 +#define BBM_BUF_TS_END 0x8020 +#define BBM_BUF_AC_END 0x8022 +#define BBM_BUF_TS_THR 0x8030 +#define BBM_BUF_AC_THR 0x8032 + + /* DM */ +#define BBM_DM_DATA 0xf001 + + /* Buffer Configuration */ +#define TS_BUF_SIZE (188*32*2) +#define TS_BUF_START (0) +#define TS_BUF_END (TS_BUF_START+TS_BUF_SIZE-1) +#define TS_BUF_THR ((TS_BUF_SIZE>>1)-1) + +#define AC_BUF_SIZE (204*2) +#define AC_BUF_START (TS_BUF_START+TS_BUF_SIZE) +#define AC_BUF_END (AC_BUF_START+AC_BUF_SIZE-1) +#define AC_BUF_THR ((AC_BUF_SIZE>>1)-1) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_spi.c b/drivers/media/isdbt/fc8150/fc8150_spi.c new file mode 100644 index 0000000..9903fc8 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_spi.c @@ -0,0 +1,293 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_spi.c + + Description : fc8150 host interface + +*******************************************************************************/ +#include <linux/spi/spi.h> +#include <linux/slab.h> + +#include "fci_types.h" +#include "fc8150_regs.h" +#include "fci_oal.h" + +#define SPI_BMODE 0x00 +#define SPI_WMODE 0x10 +#define SPI_LMODE 0x20 +#define SPI_READ 0x40 +#define SPI_WRITE 0x00 +#define SPI_AINC 0x80 +#define CHIPID (0 << 3) + +#define DRIVER_NAME "fc8150_spi" + +struct spi_device *fc8150_spi; + +static u8 tx_data[10]; +static u8 rdata_buf[8192]; +static u8 wdata_buf[8192]; + +static DEFINE_MUTEX(lock); + +static int __devinit fc8150_spi_probe(struct spi_device *spi) +{ + s32 ret; + + PRINTF(0, "fc8150_spi_probe\n"); + + spi->max_speed_hz = 24000000; + spi->bits_per_word = 8; + spi->mode = SPI_MODE_0; + + ret = spi_setup(spi); + + if (ret < 0) + return ret; + + fc8150_spi = spi; + + return ret; +} + +static int fc8150_spi_remove(struct spi_device *spi) +{ + + return 0; +} + +static struct spi_driver fc8150_spi_driver = { + .driver = { + .name = DRIVER_NAME, + .owner = THIS_MODULE, + }, + .probe = fc8150_spi_probe, + .remove = __devexit_p(fc8150_spi_remove), +}; + +static int fc8150_spi_write_then_read(struct spi_device *spi + , u8 *txbuf, u16 tx_length, u8 *rxbuf, u16 rx_length) +{ + int res = 0; + + struct spi_message message; + struct spi_transfer x; + + spi_message_init(&message); + memset(&x, 0, sizeof x); + + spi_message_add_tail(&x, &message); + + memcpy(&wdata_buf[0], txbuf, tx_length); + + x.tx_buf = &wdata_buf[0]; + x.rx_buf = &rdata_buf[0]; + x.len = tx_length + rx_length; + x.cs_change = 0; + x.bits_per_word = 8; + res = spi_sync(spi, &message); + + memcpy(rxbuf, x.rx_buf + tx_length, rx_length); + + return res; +} + +static int spi_bulkread(HANDLE hDevice, u16 addr + , u8 command, u8 *data, u16 length) +{ + int res; + + tx_data[0] = addr & 0xff; + tx_data[1] = (addr >> 8) & 0xff; + tx_data[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + tx_data[3] = (length >> 8) & 0xff; + tx_data[4] = length & 0xff; + + res = fc8150_spi_write_then_read(fc8150_spi, &tx_data[0] + , 5, data, length); + + if (res) { + PRINTF(0, "fc8150_spi_bulkread fail : %d\n", res); + return BBM_NOK; + } + + return BBM_OK; +} + +static int spi_bulkwrite(HANDLE hDevice, u16 addr + , u8 command, u8 *data, u16 length) +{ + int i; + int res; + + tx_data[0] = addr & 0xff; + tx_data[1] = (addr >> 8) & 0xff; + tx_data[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + tx_data[3] = (length >> 8) & 0xff; + tx_data[4] = length & 0xff; + + for (i = 0; i < length; i++) + tx_data[5+i] = data[i]; + + res = fc8150_spi_write_then_read(fc8150_spi + , &tx_data[0], length+5, NULL, 0); + + if (res) { + PRINTF(0, "fc8150_spi_bulkwrite fail : %d\n", res); + return BBM_NOK; + } + + return BBM_OK; +} + +static int spi_dataread(HANDLE hDevice, u16 addr + , u8 command, u8 *data, u32 length) +{ + int res; + + tx_data[0] = addr & 0xff; + tx_data[1] = (addr >> 8) & 0xff; + tx_data[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + tx_data[3] = (length >> 8) & 0xff; + tx_data[4] = length & 0xff; + + res = fc8150_spi_write_then_read(fc8150_spi + , &tx_data[0], 5, data, length); + + if (res) { + PRINTF(0, "fc8150_spi_dataread fail : %d\n", res); + return BBM_NOK; + } + + return BBM_OK; +} + +int fc8150_spi_init(HANDLE hDevice, u16 param1, u16 param2) +{ + int res = 0; + + PRINTF(0, "fc8150_spi_init : %d\n", res); + + res = spi_register_driver(&fc8150_spi_driver); + + if (res) { + PRINTF(0, "fc8150_spi register fail : %d\n", res); + return BBM_NOK; + } + + return res; +} + +int fc8150_spi_byteread(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + u8 command = SPI_READ; + + mutex_lock(&lock); + res = spi_bulkread(hDevice, addr, command, data, 1); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_wordread(HANDLE hDevice, u16 addr, u16 *data) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkread(hDevice, addr, command, (u8 *)data, 2); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_longread(HANDLE hDevice, u16 addr, u32 *data) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkread(hDevice, addr, command, (u8 *)data, 4); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkread(hDevice, addr, command, data, length); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_bytewrite(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + u8 command = SPI_WRITE; + + mutex_lock(&lock); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 1); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_wordwrite(HANDLE hDevice, u16 addr, u16 data) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 2); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_longwrite(HANDLE hDevice, u16 addr, u32 data) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 4); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + mutex_lock(&lock); + res = spi_bulkwrite(hDevice, addr, command, data, length); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + int res; + u8 command = SPI_READ; + + mutex_lock(&lock); + res = spi_dataread(hDevice, addr, command, data, length); + mutex_unlock(&lock); + + return res; +} + +int fc8150_spi_deinit(HANDLE hDevice) +{ + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_spi.h b/drivers/media/isdbt/fc8150/fc8150_spi.h new file mode 100644 index 0000000..6fd96d1 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_spi.h @@ -0,0 +1,33 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_spi.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#ifndef __FC8150_SPI__ +#define __FC8150_SPI__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_spi_init(HANDLE hDevice, u16 param1, u16 param2); +extern int fc8150_spi_byteread(HANDLE hDevice, u16 addr, u8 *data); +extern int fc8150_spi_wordread(HANDLE hDevice, u16 addr, u16 *data); +extern int fc8150_spi_longread(HANDLE hDevice, u16 addr, u32 *data); +extern int fc8150_spi_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_spi_bytewrite(HANDLE hDevice, u16 addr, u8 data); +extern int fc8150_spi_wordwrite(HANDLE hDevice, u16 addr, u16 data); +extern int fc8150_spi_longwrite(HANDLE hDevice, u16 addr, u32 data); +extern int fc8150_spi_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_spi_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length); +extern int fc8150_spi_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_spib.c b/drivers/media/isdbt/fc8150/fc8150_spib.c new file mode 100644 index 0000000..b2feccb --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_spib.c @@ -0,0 +1,210 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_spib.c + + Description : fc8150 host interface + +*******************************************************************************/ +#include "fci_types.h" +#include "fc8150_regs.h" +#include "fci_oal.h" + +#define SPI_BMODE 0x00 +#define SPI_WMODE 0x10 +#define SPI_LMODE 0x20 +#define SPI_READ 0x40 +#define SPI_WRITE 0x00 +#define SPI_AINC 0x80 +#define CHIPID (0 << 3) + +static int spi_bulkread(HANDLE hDevice, u16 addr +, u8 command, u8 *data, u16 length) +{ + /*unsigned char *cmd; + + cmd = g_SpiCmd; + + cmd[0] = addr & 0xff; + cmd[1] = (addr >> 8) & 0xff; + cmd[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + cmd[3] = (length >> 8) & 0xff; + cmd[4] = length & 0xff; + + spi_cmd.pCmd = cmd; + spi_cmd.cmdSize = 5; + spi_cmd.pData = g_SpiData; + spi_cmd.dataSize = length; + + // Send Command and data through the SPI + if (SPID_SendCommand_ByteRead(&spid, &spi_cmd)) + return BBM_NOK; + + memcpy(data, g_SpiData, length);*/ + + return BBM_OK; +} + +static int spi_bulkwrite(HANDLE hDevice, u16 addr + , u8 command, u8 *data, u16 length) +{ + /*unsigned char *cmd; + + cmd = g_SpiCmd; + + cmd[0] = addr & 0xff; + cmd[1] = (addr >> 8) & 0xff; + cmd[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + cmd[3] = (length >> 8) & 0xff; + cmd[4] = length & 0xff; + + spi_cmd.pCmd = cmd; + spi_cmd.cmdSize = 5; + spi_cmd.pData = g_SpiData; + memcpy(g_SpiData, data, length); + spi_cmd.dataSize = length; + + // Send Command and data through the SPI + if (SPID_SendCommand_ByteWrite(&spid, &spi_cmd)) + return BBM_NOK;*/ + + return BBM_OK; +} + +static int spi_dataread(HANDLE hDevice, u16 addr + , u8 command, u8 *data, u32 length) +{ + /*unsigned char *cmd; + + cmd = g_SpiCmd; + + cmd[0] = addr & 0xff; + cmd[1] = (addr >> 8) & 0xff; + cmd[2] = (command & 0xf0) | CHIPID | ((length >> 16) & 0x07); + cmd[3] = (length >> 8) & 0xff; + cmd[4] = length & 0xff; + + spi_cmd.pCmd = cmd; + spi_cmd.cmdSize = 5; + spi_cmd.pData = data; + spi_cmd.dataSize = length; + + // Send Command and data through the SPI + if (SPID_SendCommand_ByteRead(&spid, &spi_cmd)) + return BBM_NOK;*/ + + return BBM_OK; +} + +int fc8150_spib_init(HANDLE hDevice, u16 param1, u16 param2) +{ + OAL_CREATE_SEMAPHORE(); + + return BBM_OK; +} + +int fc8150_spib_byteread(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + u8 command = SPI_READ; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkread(hDevice, addr, command, data, 1); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_wordread(HANDLE hDevice, u16 addr, u16 *data) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkread(hDevice, addr, command, (u8 *)data, 2); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_longread(HANDLE hDevice, u16 addr, u32 *data) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkread(hDevice, addr, command, (u8 *)data, 4); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = SPI_READ | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkread(hDevice, addr, command, data, length); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_bytewrite(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + u8 command = SPI_WRITE; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 1); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_wordwrite(HANDLE hDevice, u16 addr, u32 data) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 2); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_longwrite(HANDLE hDevice, u16 addr, u32 data) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkwrite(hDevice, addr, command, (u8 *)&data, 4); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_bulkwrite(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + int res; + u8 command = SPI_WRITE | SPI_AINC; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_bulkwrite(hDevice, addr, command, data, length); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + int res; + u8 command = SPI_READ; + + OAL_OBTAIN_SEMAPHORE(); + res = spi_dataread(hDevice, addr, command, data, length); + OAL_RELEASE_SEMAPHORE(); + return res; +} + +int fc8150_spib_deinit(HANDLE hDevice) +{ + OAL_DELETE_SEMAPHORE(); + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_spib.h b/drivers/media/isdbt/fc8150/fc8150_spib.h new file mode 100644 index 0000000..86b28eb --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_spib.h @@ -0,0 +1,34 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_spib.c + + Description : API of 1-SEG baseband module + +*******************************************************************************/ + +#ifndef __FC8150_SPIB__ +#define __FC8150_SPIB__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_spib_init(HANDLE hDevice, u16 param1, u16 param2); +extern int fc8150_spib_byteread(HANDLE hDevice, u16 addr, u8 *data); +extern int fc8150_spib_wordread(HANDLE hDevice, u16 addr, u16 *data); +extern int fc8150_spib_longread(HANDLE hDevice, u16 addr, u32 *data); +extern int fc8150_spib_bulkread(HANDLE hDevice, u16 addr, u8 *data, u16 length); +extern int fc8150_spib_bytewrite(HANDLE hDevice, u16 addr, u8 data); +extern int fc8150_spib_wordwrite(HANDLE hDevice, u16 addr, u16 data); +extern int fc8150_spib_longwrite(HANDLE hDevice, u16 addr, u32 data); +extern int fc8150_spib_bulkwrite(HANDLE hDevice, u16 addr + , u8 *data, u16 length); +extern int fc8150_spib_dataread(HANDLE hDevice, u16 addr, u8 *data, u32 length); +extern int fc8150_spib_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8150_tun.c b/drivers/media/isdbt/fc8150/fc8150_tun.c new file mode 100644 index 0000000..644bf42 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_tun.c @@ -0,0 +1,393 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_tun.c (BGA & QFN) + + Description : fc8150 tuner driver + + History : + ---------------------------------------------------------------------- + 2012/01/20 initial 0.1 version + 2012/01/25 initial 0.3 version + 2012/01/27 initial 0.5 version + 2012/01/31 initial 1.0 version + 2012/01/31 initial 1.1 version + 2012/02/06 initial 1.2 version + 2012/02/09 initial 1.3 Version + 2012/02/15 initial 1.4 Version + 2012/02/15 initial 2.0 Version + 2012/02/24 initial 2.01 Version + 2012/03/30 initial 3.0 Version + 2012/06/07 pre SLR Version + 2012/06/11 pre SLR Version + 2012/06/15 + 2012/06/17 SLR 0.3 version + 2012/06/19 SLR 0.4 version + 2012/06/20 + 2012/07/04 + 2012/07/09 + 2012/07/10 + 2012/07/15 +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_oal.h" +#include "fci_tun.h" +#include "fc8150_regs.h" +#include "fci_hal.h" + +#define FC8150_FREQ_XTAL BBM_XTAL_FREQ /* 32MHZ */ + +static int fc8150_write(HANDLE hDevice, u8 addr, u8 data) +{ + int res; + u8 tmp; + + tmp = data; + res = tuner_i2c_write(hDevice, addr, 1, &tmp, 1); + + return res; +} + +static int fc8150_read(HANDLE hDevice, u8 addr, u8 *data) +{ + int res; + + res = tuner_i2c_read(hDevice, addr, 1, data, 1); + + return res; +} + +static int fc8150_bb_read(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + + res = bbm_read(hDevice, addr, data); + + return res; +} + +#if 0 +static int fc8150_bb_write(HANDLE hDevice, u16 addr, u8 data) +{ + int res; + + res = bbm_write(hDevice, addr, data); + + return res; +} +#endif + +static int fc8150_set_filter(HANDLE hDevice) +{ + int i; + u8 cal_mon = 0; + +#if (FC8150_FREQ_XTAL == 16000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x20); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 16384) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x21); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 18000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x24); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 19200) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x26); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 24000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x30); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 24576) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x31); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 26000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x34); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 27000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x36); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 27120) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x36); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 32000) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x40); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 37400) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x4B); + fc8150_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 38400) + fc8150_write(hDevice, 0x3B, 0x01); + fc8150_write(hDevice, 0x3D, 0x4D); + fc8150_write(hDevice, 0x3B, 0x00); +#else + return BBM_NOK; +#endif + + for (i = 0; i < 10; i++) { + msWait(5); + fc8150_read(hDevice, 0x33, &cal_mon); + if ((cal_mon & 0xC0) == 0xC0) + break; + fc8150_write(hDevice, 0x32, 0x01); + fc8150_write(hDevice, 0x32, 0x09); + } + + fc8150_write(hDevice, 0x32, 0x01); + + return BBM_OK; +} + +int fc8150_tuner_init(HANDLE hDevice, u32 band) +{ + int i; + int n_RFAGC_PD1_AVG, n_RFAGC_PD2_AVG; + u8 RFPD_REF; + u8 RFAGC_PD2[6], RFAGC_PD2_AVG, RFAGC_PD2_MAX, RFAGC_PD2_MIN; + u8 RFAGC_PD1[6], RFAGC_PD1_AVG, RFAGC_PD1_MAX, RFAGC_PD1_MIN; + + int res = BBM_OK; + + PRINTF(hDevice, "fc8150_init\n"); + + fc8150_write(hDevice, 0x00, 0x00); + fc8150_write(hDevice, 0x02, 0x81); + + fc8150_write(hDevice, 0x15, 0x02); + fc8150_write(hDevice, 0x20, 0x33); + fc8150_write(hDevice, 0x28, 0x62); + fc8150_write(hDevice, 0x35, 0xAA); + fc8150_write(hDevice, 0x38, 0x28); + + fc8150_write(hDevice, 0x3B, 0x01); + + fc8150_set_filter(hDevice); + + fc8150_write(hDevice, 0x3B, 0x00); + + fc8150_write(hDevice, 0x56, 0x01); + fc8150_write(hDevice, 0x57, 0x86); + fc8150_write(hDevice, 0x58, 0xA7); + fc8150_write(hDevice, 0x59, 0x4D); + + fc8150_write(hDevice, 0x80, 0x17); + fc8150_write(hDevice, 0xAB, 0x48); + + fc8150_write(hDevice, 0xA0, 0xC0); + fc8150_write(hDevice, 0xD0, 0x00); + + fc8150_write(hDevice, 0xA5, 0x65); + + RFAGC_PD1[0] = 0; + RFAGC_PD1[1] = 0; + RFAGC_PD1[2] = 0; + RFAGC_PD1[3] = 0; + RFAGC_PD1[4] = 0; + RFAGC_PD1[5] = 0; + RFAGC_PD1_MAX = 0; + RFAGC_PD1_MIN = 255; + + for (i = 0; i < 6 ; i++) { + fc8150_read(hDevice, 0xD8 , &RFAGC_PD1[i]); + + if (RFAGC_PD1[i] >= RFAGC_PD1_MAX) + RFAGC_PD1_MAX = RFAGC_PD1[i]; + if (RFAGC_PD1[i] <= RFAGC_PD1_MIN) + RFAGC_PD1_MIN = RFAGC_PD1[i]; + } + n_RFAGC_PD1_AVG = (RFAGC_PD1[0] + RFAGC_PD1[1] + RFAGC_PD1[2] + + RFAGC_PD1[3] + RFAGC_PD1[4] + RFAGC_PD1[5] + - RFAGC_PD1_MAX - RFAGC_PD1_MIN) / 4; + RFAGC_PD1_AVG = (unsigned char) n_RFAGC_PD1_AVG; + + fc8150_write(hDevice, 0x7F , RFAGC_PD1_AVG); + + RFAGC_PD2[0] = 0; + RFAGC_PD2[1] = 0; + RFAGC_PD2[2] = 0; + RFAGC_PD2[3] = 0; + RFAGC_PD2[4] = 0; + RFAGC_PD2[5] = 0; + + RFAGC_PD2_MAX = 0; + RFAGC_PD2_MIN = 255; + + for (i = 0; i < 6; i++) { + fc8150_read(hDevice, 0xD6, &RFAGC_PD2[i]); + + if (RFAGC_PD2[i] >= RFAGC_PD2_MAX) + RFAGC_PD2_MAX = RFAGC_PD2[i]; + if (RFAGC_PD2[i] <= RFAGC_PD2_MIN) + RFAGC_PD2_MIN = RFAGC_PD2[i]; + } + n_RFAGC_PD2_AVG = (RFAGC_PD2[0] + RFAGC_PD2[1] + RFAGC_PD2[2] + + RFAGC_PD2[3] + RFAGC_PD2[4] + RFAGC_PD2[5] + - RFAGC_PD2_MAX - RFAGC_PD2_MIN) / 4; + RFAGC_PD2_AVG = (unsigned char) n_RFAGC_PD2_AVG; + + fc8150_write(hDevice, 0x7E , RFAGC_PD2_AVG); + + res = fc8150_read(hDevice, 0xD6, &RFPD_REF); + + if (0x86 <= RFPD_REF) + fc8150_write(hDevice, 0x7B, 0x8F); + else if (RFPD_REF < 0x86) + fc8150_write(hDevice, 0x7B, 0x88); + + fc8150_write(hDevice, 0x79, 0x32); + fc8150_write(hDevice, 0x7A, 0x2C); + fc8150_write(hDevice, 0x7C, 0x10); + fc8150_write(hDevice, 0x7D, 0x0C); + fc8150_write(hDevice, 0x81, 0x0A); + fc8150_write(hDevice, 0x84, 0x00); + + fc8150_write(hDevice, 0x02, 0x81); + + return BBM_OK; +} + + +int fc8150_set_freq(HANDLE hDevice, enum band_type band, u32 rf_kHz) +{ + unsigned long f_diff, f_diff_shifted, n_val, k_val; + unsigned long f_vco, f_comp; + unsigned char r_val, data_0x56; + unsigned char pre_shift_bits = 4; + + f_vco = (rf_kHz) << 2; + if (f_vco < FC8150_FREQ_XTAL*40) + r_val = 2; + else + r_val = 1; + + f_comp = FC8150_FREQ_XTAL / r_val; + + n_val = f_vco / f_comp; + f_diff = f_vco - f_comp * n_val; + + f_diff_shifted = f_diff << (20 - pre_shift_bits); + + k_val = (f_diff_shifted) / (f_comp >> pre_shift_bits); + k_val = (k_val | 1); + + if (470000 < rf_kHz && rf_kHz <= 473143) { + fc8150_write(hDevice, 0x1E, 0x04); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } else if (473143 < rf_kHz && rf_kHz <= 485143) { + fc8150_write(hDevice, 0x1E, 0x03); + fc8150_write(hDevice, 0x1F, 0x3E); + fc8150_write(hDevice, 0x14, 0x84); + } else if (485143 < rf_kHz && rf_kHz <= 551143) { + fc8150_write(hDevice, 0x1E, 0x04); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } else if (551143 < rf_kHz && rf_kHz <= 563143) { + fc8150_write(hDevice, 0x1E, 0x03); + fc8150_write(hDevice, 0x1F, 0x3E); + fc8150_write(hDevice, 0x14, 0xC4); + } else if (563143 < rf_kHz && rf_kHz <= 593143) { + fc8150_write(hDevice, 0x1E, 0x02); + fc8150_write(hDevice, 0x1F, 0x3E); + fc8150_write(hDevice, 0x14, 0xC4); + } else if (593143 < rf_kHz && rf_kHz <= 659143) { + fc8150_write(hDevice, 0x1E, 0x02); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } else if (659143 < rf_kHz && rf_kHz <= 767143) { + fc8150_write(hDevice, 0x1E, 0x01); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } else if (767143 < rf_kHz) { + fc8150_write(hDevice, 0x1E, 0x00); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } else { + fc8150_write(hDevice, 0x1E, 0x05); + fc8150_write(hDevice, 0x1F, 0x36); + fc8150_write(hDevice, 0x14, 0x84); + } + + data_0x56 = ((r_val == 1) ? 0 : 0x10) + (unsigned char)(k_val>>16); + fc8150_write(hDevice, 0x56, data_0x56); + fc8150_write(hDevice, 0x57, (unsigned char)((k_val>>8)&0xFF)); + fc8150_write(hDevice, 0x58, (unsigned char)(((k_val)&0xFF))); + fc8150_write(hDevice, 0x59, (unsigned char) n_val); + + if (rf_kHz < 525000) + fc8150_write(hDevice, 0x55, 0x0E); + else if (525000 <= rf_kHz && rf_kHz < 600000) + fc8150_write(hDevice, 0x55, 0x0C); + else if (600000 <= rf_kHz && rf_kHz < 700000) + fc8150_write(hDevice, 0x55, 0x08); + else if (700000 < rf_kHz) + fc8150_write(hDevice, 0x55, 0x06); + + if (rf_kHz <= 491143) { + fc8150_write(hDevice, 0x79, 0x28); + fc8150_write(hDevice, 0x7A, 0x24); + } else if (491143 < rf_kHz && rf_kHz <= 659143) { + fc8150_write(hDevice, 0x79, 0x2A); + fc8150_write(hDevice, 0x7A, 0x26); + } else if (659143 < rf_kHz && rf_kHz <= 773143) { + fc8150_write(hDevice, 0x79, 0x2C); + fc8150_write(hDevice, 0x7A, 0x28); + } else if (773143 < rf_kHz) { + fc8150_write(hDevice, 0x79, 0x2F); + fc8150_write(hDevice, 0x7A, 0x2B); + } + + if (rf_kHz <= 707143) { + fc8150_write(hDevice, 0x54, 0x00); + fc8150_write(hDevice, 0x53, 0x5F); + } else if (707143 < rf_kHz) { + fc8150_write(hDevice, 0x54, 0x04); + fc8150_write(hDevice, 0x53, 0x9F); + } + + return BBM_OK; +} + +int fc8150_get_rssi(HANDLE hDevice, int *rssi) +{ + int res = BBM_OK; + u8 LNA, RFVGA, CSF, PREAMP_PGA = 0x00; + int K = -101.25; + int PGA = 0; + + res = fc8150_read(hDevice, 0xA3, &LNA); + res = fc8150_read(hDevice, 0xA4, &RFVGA); + res = fc8150_read(hDevice, 0xA8, &CSF); + res = fc8150_bb_read(hDevice, 0x106E, &PREAMP_PGA); + + if (res != BBM_OK) + return res; + + if (127 < PREAMP_PGA) + PGA = -1 * ((256 - PREAMP_PGA) + 1); + else if (PREAMP_PGA <= 127) + PGA = PREAMP_PGA; + + /* *rssi = (LNA & 0x07) * 6 + (RFVGA & 0x1F) + + ((CSF & 0x03)+((CSF & 0x70) >> 4) ) * 6 - PGA * 0.25f + K ; */ + *rssi = (LNA & 0x07) * 6 + (RFVGA & 0x1F) + + ((CSF & 0x03) + ((CSF & 0x70) >> 4)) * 6 - PGA / 4 + K; + + return BBM_OK; +} + +int fc8150_tuner_deinit(HANDLE hDevice) +{ + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8150_tun.h b/drivers/media/isdbt/fc8150/fc8150_tun.h new file mode 100644 index 0000000..64a715c --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8150_tun.h @@ -0,0 +1,26 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_tun.c + + Description : fc8150 tuner control driver + +*******************************************************************************/ + +#ifndef __FC8150_TUN__ +#define __FC8150_TUN__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8150_tuner_init(HANDLE hDevice, enum band_type band); +extern int fc8150_set_freq(HANDLE hDevice, enum band_type band, u32 f_lo); +extern int fc8150_get_rssi(HANDLE hDevice, int *rssi); +extern int fc8150_tuner_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fc8151_tun.c b/drivers/media/isdbt/fc8150/fc8151_tun.c new file mode 100644 index 0000000..e17b4b9 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8151_tun.c @@ -0,0 +1,413 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8151_tun.c (WLCSP) + + Description : fc8150 tuner driver + + History : + ---------------------------------------------------------------------- + 2012/01/20 initial 0.1 version + 2012/01/25 initial 0.3 version + 2012/01/27 initial 0.5 version + 2012/01/31 initial 1.0 version + 2012/01/31 initial 1.1 version + 2012/02/06 initial 1.2 version + 2012/02/09 initial 1.3 Version + 2012/02/15 initial 1.4 Version + 2012/02/15 initial 2.0 Version + 2012/02/24 initial 2.01 Version + 2012/03/30 initial 3.0 Version +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_oal.h" +#include "fci_tun.h" +#include "fc8150_regs.h" +#include "fci_hal.h" + +#define FC8150_FREQ_XTAL BBM_XTAL_FREQ /* 26MHZ */ + +static int high_crnt_mode = 1; + +static int fc8151_write(HANDLE hDevice, u8 addr, u8 data) +{ + int res; + u8 tmp; + + tmp = data; + res = tuner_i2c_write(hDevice, addr, 1, &tmp, 1); + + return res; +} + +static int fc8151_read(HANDLE hDevice, u8 addr, u8 *data) +{ + int res; + + res = tuner_i2c_read(hDevice, addr, 1, data, 1); + + return res; +} + +static int fc8151_bb_read(HANDLE hDevice, u16 addr, u8 *data) +{ + int res; + + res = bbm_read(hDevice, addr, data); + + return res; +} + +static int fc8151_bb_write(HANDLE hDevice, u16 addr, u8 data) +{ + return BBM_OK; +} + + +static int KbdFunc(HANDLE hDevice) +{ + int i = 0; + + u8 CSF = 0x00; + int res = BBM_OK; + int crnt_mode[5] = {0, 0, 0, 0, 0}; + int pre_crnt_mode = 0; + + high_crnt_mode = 2; + fc8151_write(hDevice, 0x13, 0xF4); + fc8151_write(hDevice, 0x1F, 0x06); + fc8151_write(hDevice, 0x33, 0x08); + fc8151_write(hDevice, 0x34, 0x68); + fc8151_write(hDevice, 0x35, 0x0A); + + while (1) { + while (1) { + for (i = 0; i < 5; i++) { + msWait(100); + res = fc8151_read(hDevice, 0xA6, &CSF); + if (CSF < 4) + crnt_mode[i] = 2; + if (CSF == 4) + crnt_mode[i] = 1; + if (4 < CSF) + crnt_mode[i] = 0; + } + + pre_crnt_mode = high_crnt_mode; + + if ((crnt_mode[0] + crnt_mode[1] + crnt_mode[2] + + crnt_mode[3] + crnt_mode[4]) == 10) + high_crnt_mode = 2; + else if ((crnt_mode[0] + crnt_mode[1] + crnt_mode[2] + + crnt_mode[3] + crnt_mode[4]) == 5) + high_crnt_mode = 1; + else if ((crnt_mode[0] + crnt_mode[1] + crnt_mode[2] + + crnt_mode[3] + crnt_mode[4]) == 0) + high_crnt_mode = 0; + else + high_crnt_mode = pre_crnt_mode; + + if (!(high_crnt_mode == pre_crnt_mode)) + break; + } + + if (high_crnt_mode == 2) { + fc8151_write(hDevice, 0x13, 0xF4); + fc8151_write(hDevice, 0x1F, 0x06); + fc8151_write(hDevice, 0x33, 0x08); + fc8151_write(hDevice, 0x34, 0x68); + fc8151_write(hDevice, 0x35, 0x0A); + } else if (high_crnt_mode == 1) { + fc8151_write(hDevice, 0x13, 0x44); + fc8151_write(hDevice, 0x1F, 0x06); + fc8151_write(hDevice, 0x33, 0x08); + fc8151_write(hDevice, 0x34, 0x68); + fc8151_write(hDevice, 0x35, 0x0A); + } else if (high_crnt_mode == 0) { + fc8151_write(hDevice, 0x13, 0x44); + fc8151_write(hDevice, 0x1F, 0x02); + fc8151_write(hDevice, 0x33, 0x04); + fc8151_write(hDevice, 0x34, 0x48); + fc8151_write(hDevice, 0x35, 0x0C); + } + } + + return res; + +} + +static int fc8151_set_filter(HANDLE hDevice) +{ + int i; + u8 cal_mon = 0; + +#if (FC8151_FREQ_XTAL == 16000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x20); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 16384) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x21); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 18000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x24); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 19200) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x26); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 24000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x30); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 24576) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x31); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 26000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x34); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 27000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x36); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 27120) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x36); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 32000) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x40); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 37400) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x4B); + fc8151_write(hDevice, 0x3B, 0x00); +#elif (FC8150_FREQ_XTAL == 38400) + fc8151_write(hDevice, 0x3B, 0x01); + fc8151_write(hDevice, 0x3D, 0x4D); + fc8151_write(hDevice, 0x3B, 0x00); +#else + return BBM_NOK; +#endif + + for (i = 0; i < 10; i++) { + msWait(5); + fc8151_read(hDevice, 0x33, &cal_mon); + if ((cal_mon & 0xC0) == 0xC0) + break; + fc8151_write(hDevice, 0x32, 0x01); + fc8151_write(hDevice, 0x32, 0x09); + } + + fc8151_write(hDevice, 0x32, 0x01); + + return BBM_OK; +} + +int fc8151_tuner_init(HANDLE hDevice, u32 band) +{ + u8 RFPD_REF, MIXPD_REF; + int res = BBM_OK; + + PRINTF(hDevice, "fc8151_init\n"); + + fc8151_write(hDevice, 0x00, 0x00); + fc8151_write(hDevice, 0x02, 0x81); + + fc8151_write(hDevice, 0x13, 0xF4); + fc8151_write(hDevice, 0x30, 0x0A); + fc8151_write(hDevice, 0x3B, 0x01); + + fc8151_set_filter(hDevice); + + fc8151_write(hDevice, 0x3B, 0x00); + + fc8151_write(hDevice, 0x34, 0x68); + fc8151_write(hDevice, 0x36, 0xFF); + fc8151_write(hDevice, 0x37, 0xFF); + fc8151_write(hDevice, 0x39, 0x11); + fc8151_write(hDevice, 0x3A, 0x00); + + fc8151_write(hDevice, 0x52, 0x20); + fc8151_write(hDevice, 0x53, 0x5F); + fc8151_write(hDevice, 0x54, 0x00); + fc8151_write(hDevice, 0x5E, 0x00); + fc8151_write(hDevice, 0x63, 0x30); + + fc8151_write(hDevice, 0x56, 0x0F); + fc8151_write(hDevice, 0x57, 0x1F); + fc8151_write(hDevice, 0x58, 0x09); + fc8151_write(hDevice, 0x59, 0x5E); + + fc8151_write(hDevice, 0x29, 0x00); + + fc8151_write(hDevice, 0x94, 0x00); + fc8151_write(hDevice, 0x95, 0x01); + fc8151_write(hDevice, 0x96, 0x11); + fc8151_write(hDevice, 0x97, 0x21); + fc8151_write(hDevice, 0x98, 0x31); + fc8151_write(hDevice, 0x99, 0x32); + fc8151_write(hDevice, 0x9A, 0x42); + fc8151_write(hDevice, 0x9B, 0x52); + fc8151_write(hDevice, 0x9C, 0x53); + fc8151_write(hDevice, 0x9D, 0x63); + fc8151_write(hDevice, 0x9E, 0x63); + fc8151_write(hDevice, 0x9F, 0x63); + + fc8151_write(hDevice, 0x79, 0x2A); + fc8151_write(hDevice, 0x7A, 0x24); + fc8151_write(hDevice, 0x7B, 0xFF); + fc8151_write(hDevice, 0x7C, 0x16); + fc8151_write(hDevice, 0x7D, 0x12); + fc8151_write(hDevice, 0x84, 0x00); + fc8151_write(hDevice, 0x85, 0x08); + fc8151_write(hDevice, 0x86, 0x00); + fc8151_write(hDevice, 0x87, 0x08); + fc8151_write(hDevice, 0x88, 0x00); + fc8151_write(hDevice, 0x89, 0x08); + fc8151_write(hDevice, 0x8A, 0x00); + fc8151_write(hDevice, 0x8B, 0x08); + fc8151_write(hDevice, 0x8C, 0x00); + fc8151_write(hDevice, 0x8D, 0x1D); + fc8151_write(hDevice, 0x8E, 0x13); + fc8151_write(hDevice, 0x8F, 0x1D); + fc8151_write(hDevice, 0x90, 0x13); + fc8151_write(hDevice, 0x91, 0x1D); + fc8151_write(hDevice, 0x92, 0x13); + fc8151_write(hDevice, 0x93, 0x1D); + fc8151_write(hDevice, 0x80, 0x1F); + fc8151_write(hDevice, 0x81, 0x0A); + fc8151_write(hDevice, 0x82, 0x40); + fc8151_write(hDevice, 0x83, 0x0A); + + fc8151_write(hDevice, 0xA0, 0xC0); + fc8151_write(hDevice, 0x7E, 0x7F); + fc8151_write(hDevice, 0x7F, 0x7F); + fc8151_write(hDevice, 0xD0, 0x0A); + fc8151_write(hDevice, 0xD2, 0x28); + fc8151_write(hDevice, 0xD4, 0x28); + + /* _beginthread(KbdFunc,0,&x); */ + + fc8151_write(hDevice, 0xA0, 0x17); + fc8151_write(hDevice, 0xD0, 0x00); + fc8151_write(hDevice, 0xA1, 0x1D); + + msWait(100); + + res = fc8151_read(hDevice, 0xD6, &RFPD_REF); + res = fc8151_read(hDevice, 0xD8, &MIXPD_REF); + + fc8151_write(hDevice, 0xA0, 0xD7); + fc8151_write(hDevice, 0xD0, 0x0A); + + fc8151_write(hDevice, 0x7E, RFPD_REF); + fc8151_write(hDevice, 0x7F, MIXPD_REF); + + fc8151_write(hDevice, 0xA0, 0xC0); + fc8151_write(hDevice, 0xA1, 0x00); + + return res; +} + + +int fc8151_set_freq(HANDLE hDevice, band_type band, u32 rf_kHz) +{ + int res = BBM_OK; + int n_captune = 0; + unsigned long f_diff, f_diff_shifted, n_val, k_val; + unsigned long f_vco, f_comp; + unsigned char r_val, data_0x56; + unsigned char pre_shift_bits = 4; + + f_vco = (rf_kHz) << 2; + if (f_vco < FC8150_FREQ_XTAL*40) + r_val = 2; + else + r_val = 1; + + f_comp = FC8150_FREQ_XTAL / r_val; + + n_val = f_vco / f_comp; + f_diff = f_vco - f_comp * n_val; + + f_diff_shifted = f_diff << (20 - pre_shift_bits); + + k_val = (f_diff_shifted + (f_comp >> (pre_shift_bits+1))) + / (f_comp >> pre_shift_bits); + k_val = (k_val | 1); + + if (470000 < rf_kHz && rf_kHz <= 505000) + n_captune = 4; + else if (505000 < rf_kHz && rf_kHz <= 545000) + n_captune = 3; + else if (545000 < rf_kHz && rf_kHz <= 610000) + n_captune = 2; + else if (610000 < rf_kHz && rf_kHz <= 695000) + n_captune = 1; + else if (695000 < rf_kHz) + n_captune = 0; + + fc8151_write(hDevice, 0x1E, (unsigned char)n_captune); + + data_0x56 = ((r_val == 1) ? 0 : 0x10) + (unsigned char)(k_val >> 16); + fc8151_write(hDevice, 0x56, data_0x56); + fc8151_write(hDevice, 0x57, (unsigned char)((k_val >> 8) & 0xFF)); + fc8151_write(hDevice, 0x58, (unsigned char)(((k_val) & 0xFF))); + fc8151_write(hDevice, 0x59, (unsigned char) n_val); + + if (rf_kHz <= 600000) + fc8151_write(hDevice, 0x55, 0x07); + else + fc8151_write(hDevice, 0x55, 0x05); + + if ((490000 < rf_kHz) && (560000 >= rf_kHz)) + fc8151_write(hDevice, 0x1F, 0x0E); + else + fc8151_write(hDevice, 0x1F, 0x06); + + return res; +} + +int fc8151_get_rssi(HANDLE hDevice, int *rssi) +{ + int res = BBM_OK; + u8 LNA, RFVGA, CSF, PREAMP_PGA = 0x00; + int K = -101.25; + float Gain_diff = 0; + int PGA = 0; + + res |= fc8151_read(hDevice, 0xA3, &LNA); + res |= fc8151_read(hDevice, 0xA4, &RFVGA); + res |= fc8151_read(hDevice, 0xA6, &CSF); + res |= fc8151_bb_read(hDevice, 0x106E, &PREAMP_PGA); + + if (res != BBM_OK) + return res; + + if (127 < PREAMP_PGA) + PGA = -1 * ((256 - PREAMP_PGA) + 1); + else if (PREAMP_PGA <= 127) + PGA = PREAMP_PGA; + + if (high_crnt_mode == 2) + Gain_diff = 0; + else if (high_crnt_mode == 1) + Gain_diff = 0; + else if (high_crnt_mode == 0) + Gain_diff = -3.5; + + *rssi = (LNA & 0x07) * 6 + (RFVGA) + + (CSF & 0x0F) * 6 - PGA * 0.25f + K - Gain_diff; + + return BBM_OK; +} + +int fc8151_tuner_deinit(HANDLE hDevice) +{ + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fc8151_tun.h b/drivers/media/isdbt/fc8150/fc8151_tun.h new file mode 100644 index 0000000..4147fa6 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fc8151_tun.h @@ -0,0 +1,26 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8151_tun.c + + Description : fc8151 tuner control driver + +*******************************************************************************/ + +#ifndef __FC8151_TUN__ +#define __FC8151_TUN__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fc8151_tuner_init(HANDLE hDevice, band_type band); +extern int fc8151_set_freq(HANDLE hDevice, band_type band, u32 f_lo); +extern int fc8151_get_rssi(HANDLE hDevice, int *rssi); +extern int fc8151_tuner_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_bypass.c b/drivers/media/isdbt/fc8150/fci_bypass.c new file mode 100644 index 0000000..f3104cb --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_bypass.c @@ -0,0 +1,39 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_bypass.c + + Description : fci i2c driver +*******************************************************************************/ +#include "fci_bypass.h" +#include "fci_types.h" + + +int fci_bypass_init(HANDLE hDevice, int speed, int slaveaddr) +{ + return BBM_OK; +} + +int fci_bypass_read(HANDLE hDevice, u8 chip, u8 addr, u8 alen, u8 *data, u8 len) +{ + int res; + + res = fc8150_bypass_read(hDevice, chip, addr, data, len); + + return res; +} + +int fci_bypass_write(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len) +{ + int res; + + res = fc8150_bypass_write(hDevice, chip, addr, data, len); + + return res; +} + +int fci_bypass_deinit(HANDLE hDevice) +{ + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fci_bypass.h b/drivers/media/isdbt/fc8150/fci_bypass.h new file mode 100644 index 0000000..dda0e64 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_bypass.h @@ -0,0 +1,34 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_bypass.h + + Description : fci i2c driver header +*******************************************************************************/ + +#ifndef __FCI_BYPASS_H__ +#define __FCI_BYPASS_H__ + +#include "fci_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fci_bypass_init(HANDLE hDevice, int speed, int slaveaddr); +extern int fci_bypass_read(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); +extern int fci_bypass_write(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); +extern int fci_bypass_deinit(HANDLE hDevice); + +extern int fc8150_bypass_read(HANDLE hDevice, u8 chip + , u8 addr, u8 *data, u16 length); +extern int fc8150_bypass_write(HANDLE hDevice, u8 chip + , u8 addr, u8 *data, u16 length); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_hal.c b/drivers/media/isdbt/fc8150/fci_hal.c new file mode 100644 index 0000000..b70f5eb --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_hal.c @@ -0,0 +1,245 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_hal.c + + Description : fc8150 host interface + +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_hal.h" +#include "fc8150_hpi.h" +#include "fc8150_spi.h" +#include "fc8150_ppi.h" +#include "fc8150_i2c.h" +#include "fc8150_spib.h" + +struct IF_PORT { + int (*init)(HANDLE hDevice, u16 param1, u16 param2); + + int (*byteread)(HANDLE hDevice, u16 addr, u8 *data); + int (*wordread)(HANDLE hDevice, u16 addr, u16 *data); + int (*longread)(HANDLE hDevice, u16 addr, u32 *data); + int (*bulkread)(HANDLE hDevice, u16 addr, u8 *data, u16 length); + + int (*bytewrite)(HANDLE hDevice, u16 addr, u8 data); + int (*wordwrite)(HANDLE hDevice, u16 addr, u16 data); + int (*longwrite)(HANDLE hDevice, u16 addr, u32 data); + int (*bulkwrite)(HANDLE hDevice, u16 addr, u8 *data, u16 length); + + int (*dataread)(HANDLE hDevice, u16 addr, u8 *data, u32 length); + + int (*deinit)(HANDLE hDevice); +}; + +static struct IF_PORT hpiif = { + &fc8150_hpi_init, + + &fc8150_hpi_byteread, + &fc8150_hpi_wordread, + &fc8150_hpi_longread, + &fc8150_hpi_bulkread, + + &fc8150_hpi_bytewrite, + &fc8150_hpi_wordwrite, + &fc8150_hpi_longwrite, + &fc8150_hpi_bulkwrite, + + &fc8150_hpi_dataread, + + &fc8150_hpi_deinit +}; + +static struct IF_PORT spiif = { + &fc8150_spi_init, + + &fc8150_spi_byteread, + &fc8150_spi_wordread, + &fc8150_spi_longread, + &fc8150_spi_bulkread, + + &fc8150_spi_bytewrite, + &fc8150_spi_wordwrite, + &fc8150_spi_longwrite, + &fc8150_spi_bulkwrite, + + &fc8150_spi_dataread, + + &fc8150_spi_deinit +}; + +static struct IF_PORT spibif = { + &fc8150_spib_init, + + &fc8150_spib_byteread, + &fc8150_spib_wordread, + &fc8150_spib_longread, + &fc8150_spib_bulkread, + + &fc8150_spib_bytewrite, + &fc8150_spib_wordwrite, + &fc8150_spib_longwrite, + &fc8150_spib_bulkwrite, + + &fc8150_spib_dataread, + + &fc8150_spib_deinit +}; + +static struct IF_PORT ppiif = { + &fc8150_ppi_init, + + &fc8150_ppi_byteread, + &fc8150_ppi_wordread, + &fc8150_ppi_longread, + &fc8150_ppi_bulkread, + + &fc8150_ppi_bytewrite, + &fc8150_ppi_wordwrite, + &fc8150_ppi_longwrite, + &fc8150_ppi_bulkwrite, + + &fc8150_ppi_dataread, + + &fc8150_ppi_deinit +}; + +static struct IF_PORT i2cif = { + &fc8150_i2c_init, + + &fc8150_i2c_byteread, + &fc8150_i2c_wordread, + &fc8150_i2c_longread, + &fc8150_i2c_bulkread, + + &fc8150_i2c_bytewrite, + &fc8150_i2c_wordwrite, + &fc8150_i2c_longwrite, + &fc8150_i2c_bulkwrite, + + &fc8150_i2c_dataread, + + &fc8150_i2c_deinit +}; + +static struct IF_PORT *ifport = &spiif; +u8 hostif_type = BBM_SPI; + +int bbm_hostif_select(HANDLE hDevice, u8 hostif) +{ + hostif_type = hostif; + + switch (hostif) { + case BBM_HPI: + ifport = &hpiif; + break; + case BBM_SPI: + ifport = &spiif; + break; + case BBM_I2C: + ifport = &i2cif; + break; + case BBM_PPI: + ifport = &ppiif; + break; + case BBM_SPIB: + ifport = &spibif; + break; + default: + return BBM_E_HOSTIF_SELECT; + } + + if (ifport->init(hDevice, 0, 0)) + return BBM_E_HOSTIF_INIT; + + return BBM_OK; +} + +int bbm_hostif_deselect(HANDLE hDevice) +{ + if (ifport->deinit(hDevice)) + return BBM_NOK; + + ifport = NULL; + hostif_type = BBM_SPI; + + return BBM_OK; +} + +int bbm_read(HANDLE hDevice, u16 addr, u8 *data) +{ + if (ifport->byteread(hDevice, addr, data)) + return BBM_E_BB_READ; + return BBM_OK; +} + +int bbm_byte_read(HANDLE hDevice, u16 addr, u8 *data) +{ + if (ifport->byteread(hDevice, addr, data)) + return BBM_E_BB_READ; + return BBM_OK; +} + +int bbm_word_read(HANDLE hDevice, u16 addr, u16 *data) +{ + if (ifport->wordread(hDevice, addr, data)) + return BBM_E_BB_READ; + return BBM_OK; +} + +int bbm_long_read(HANDLE hDevice, u16 addr, u32 *data) +{ + if (ifport->longread(hDevice, addr, data)) + return BBM_E_BB_READ; + return BBM_OK; +} + +int bbm_bulk_read(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + if (ifport->bulkread(hDevice, addr, data, length)) + return BBM_E_BB_READ; + return BBM_OK; +} + +int bbm_write(HANDLE hDevice, u16 addr, u8 data) +{ + if (ifport->bytewrite(hDevice, addr, data)) + return BBM_E_BB_WRITE; + return BBM_OK; +} + +int bbm_byte_write(HANDLE hDevice, u16 addr, u8 data) +{ + if (ifport->bytewrite(hDevice, addr, data)) + return BBM_E_BB_WRITE; + return BBM_OK; +} + +int bbm_word_write(HANDLE hDevice, u16 addr, u16 data) +{ + if (ifport->wordwrite(hDevice, addr, data)) + return BBM_E_BB_WRITE; + return BBM_OK; +} + +int bbm_long_write(HANDLE hDevice, u16 addr, u32 data) +{ + if (ifport->longwrite(hDevice, addr, data)) + return BBM_E_BB_WRITE; + return BBM_OK; +} + +int bbm_bulk_write(HANDLE hDevice, u16 addr, u8 *data, u16 length) +{ + if (ifport->bulkwrite(hDevice, addr, data, length)) + return BBM_E_BB_WRITE; + return BBM_OK; +} + +int bbm_data(HANDLE hDevice, u16 addr, u8 *data, u32 length) +{ + if (ifport->dataread(hDevice, addr, data, length)) + return BBM_E_BB_WRITE; + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fci_hal.h b/drivers/media/isdbt/fc8150/fci_hal.h new file mode 100644 index 0000000..e9d44c4 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_hal.h @@ -0,0 +1,37 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fc8150_hal.h + + Description : fc8150 host interface +*******************************************************************************/ + +#ifndef __FCI_HAL_H__ +#define __FCI_HAL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int bbm_hostif_select(HANDLE hDevice, u8 hostif); +extern int bbm_hostif_deselect(HANDLE hDevice); + +extern int bbm_read(HANDLE hDevice, u16 addr, u8 *data); +extern int bbm_byte_read(HANDLE hDevice, u16 addr, u8 *data); +extern int bbm_word_read(HANDLE hDevice, u16 addr, u16 *data); +extern int bbm_long_read(HANDLE hDevice, u16 addr, u32 *data); +extern int bbm_bulk_read(HANDLE hDevice, u16 addr, u8 *data, u16 length); + +extern int bbm_write(HANDLE hDevice, u16 addr, u8 data); +extern int bbm_byte_write(HANDLE hDevice, u16 addr, u8 data); +extern int bbm_word_write(HANDLE hDevice, u16 addr, u16 data); +extern int bbm_long_write(HANDLE hDevice, u16 addr, u32 data); +extern int bbm_bulk_write(HANDLE hDevice, u16 addr, u8 *data, u16 length); + +extern int bbm_data(HANDLE hDevice, u16 addr, u8 *data, u32 length); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_i2c.c b/drivers/media/isdbt/fc8150/fci_i2c.c new file mode 100644 index 0000000..1f011ca --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_i2c.c @@ -0,0 +1,226 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_i2c.c + + Description : fci i2c driver +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_oal.h" +#include "fc8150_regs.h" +#include "fci_hal.h" + +#define I2CSTAT_TIP 0x02 /* Tip bit */ +#define I2CSTAT_NACK 0x80 /* Nack bit */ + +#define I2C_TIMEOUT 100 + +#define I2C_CR_STA 0x80 +#define I2C_CR_STO 0x40 +#define I2C_CR_RD 0x20 +#define I2C_CR_WR 0x10 +#define I2C_CR_NACK 0x08 +#define I2C_CR_IACK 0x01 + +#define I2C_WRITE 0 +#define I2C_READ 1 + +#define I2C_OK 0 +#define I2C_NOK 1 +#define I2C_NACK 2 +#define I2C_NOK_LA 3 /* Lost arbitration */ +#define I2C_NOK_TOUT 4 /* time out */ + +#define FC8150_FREQ_XTAL BBM_XTAL_FREQ + +/* static OAL_SEMAPHORE hBbmMutex; */ + +static int WaitForXfer(HANDLE hDevice) +{ + int i; + int res = I2C_OK; + u8 status; + + i = I2C_TIMEOUT * 20000; + /* wait for transfer complete */ + do { + bbm_read(hDevice, BBM_I2C_SR, &status); + i--; + } while ((i > 0) && (status & I2CSTAT_TIP)); + + /* check time out or nack */ + if (status & I2CSTAT_TIP) { + res = I2C_NOK_TOUT; + } else { + bbm_read(hDevice, BBM_I2C_SR, &status); + if (status & I2CSTAT_NACK) + res = I2C_NACK; + else + res = I2C_OK; + } + + return res; +} + +static int fci_i2c_transfer(HANDLE hDevice, u8 cmd_type, u8 chip + , u8 addr[], u8 addr_len, u8 data[], u8 data_len) +{ + int i; + int result = I2C_OK; + + switch (cmd_type) { + case I2C_WRITE: + bbm_write(hDevice, BBM_I2C_TXR, chip | cmd_type); + bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + + if (addr && addr_len) { + i = 0; + while ((i < addr_len) && (result == I2C_OK)) { + bbm_write(hDevice, BBM_I2C_TXR, addr[i]); + bbm_write(hDevice, BBM_I2C_CR + , I2C_CR_WR /*0x10*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + i++; + } + } + + i = 0; + while ((i < data_len) && (result == I2C_OK)) { + bbm_write(hDevice, BBM_I2C_TXR, data[i]); + bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + i++; + } + + bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + break; + case I2C_READ: + if (addr && addr_len) { + bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_WRITE); + bbm_write(hDevice, BBM_I2C_CR + , I2C_CR_STA | I2C_CR_WR /*0x90*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + + i = 0; + while ((i < addr_len) && (result == I2C_OK)) { + bbm_write(hDevice, BBM_I2C_TXR, addr[i]); + bbm_write(hDevice, BBM_I2C_CR + , I2C_CR_WR /*0x10*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + i++; + } + } + + bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_READ); + bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) + return result; + + i = 0; + while ((i < data_len) && (result == I2C_OK)) { + if (i == data_len - 1) { + bbm_write(hDevice, BBM_I2C_CR + , I2C_CR_RD|I2C_CR_NACK/*0x28*/); + result = WaitForXfer(hDevice); + if ((result != I2C_NACK) + && (result != I2C_OK)) { + PRINTF(hDevice, "NACK4-0[%02x]\n" + , result); + return result; + } + } else { + bbm_write(hDevice, BBM_I2C_CR + , I2C_CR_RD /*0x20*/); + result = WaitForXfer(hDevice); + if (result != I2C_OK) { + PRINTF(hDevice, "NACK4-1[%02x]\n" + , result); + return result; + } + } + bbm_read(hDevice, BBM_I2C_RXR, &data[i]); + i++; + } + + bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/); + result = WaitForXfer(hDevice); + if ((result != I2C_NACK) && (result != I2C_OK)) { + PRINTF(hDevice, "NACK5[%02X]\n", result); + return result; + } + break; + default: + return I2C_NOK; + } + + return I2C_OK; +} + +int fci_i2c_init(HANDLE hDevice, int speed, int slaveaddr) +{ + u16 r = FC8150_FREQ_XTAL % (5 * speed); + u16 pr = (FC8150_FREQ_XTAL - r) / (5 * speed) - 1; + + if (((5 * speed) >> 1) <= r) + pr++; + + bbm_word_write(hDevice, BBM_I2C_PR_L, pr); + bbm_write(hDevice, BBM_I2C_CTR, 0xc0); + + PRINTF(hDevice, "Internal I2C Pre-scale: 0x%02x\n", pr); + + return BBM_OK; +} + +int fci_i2c_read(HANDLE hDevice, u8 chip, u8 addr, u8 alen, u8 *data, u8 len) +{ + int ret; + + ret = fci_i2c_transfer(hDevice, I2C_READ, chip << 1, &addr + , alen, data, len); + + if (ret != I2C_OK) { + PRINTF(hDevice, "fci_i2c_read() result=%d, addr = %x, data=%x\n" + , ret, addr, *data); + return ret; + } + + return ret; +} + +int fci_i2c_write(HANDLE hDevice, u8 chip, u8 addr, u8 alen, u8 *data, u8 len) +{ + int ret; + u8 *paddr = &addr; + + ret = fci_i2c_transfer(hDevice, I2C_WRITE, chip << 1 + , paddr, alen, data, len); + + if (ret != I2C_OK) + PRINTF(hDevice, "fci_i2c_write() result=%d, addr= %x, data=%x\n" + , ret, addr, *data); + + return ret; +} + +int fci_i2c_deinit(HANDLE hDevice) +{ + bbm_write(hDevice, BBM_I2C_CTR, 0x00); + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fci_i2c.h b/drivers/media/isdbt/fc8150/fci_i2c.h new file mode 100644 index 0000000..8c4ce07 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_i2c.h @@ -0,0 +1,29 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_i2c.h + + Description : fci i2c driver header +*******************************************************************************/ + +#ifndef __FCI_I2C_H__ +#define __FCI_I2C_H__ + +#include "fci_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +extern int fci_i2c_init(HANDLE hDevice, int speed, int slaveaddr); +extern int fci_i2c_read(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); +extern int fci_i2c_write(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); +extern int fci_i2c_deinit(HANDLE hDevice); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_oal.c b/drivers/media/isdbt/fc8150/fci_oal.c new file mode 100644 index 0000000..a7d7f77 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_oal.c @@ -0,0 +1,50 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_oal.c + + Description : OS adaptation layer +*******************************************************************************/ +#include <linux/kernel.h> +#include <linux/delay.h> + +#include "fc8150_regs.h" +#include "fci_types.h" + +void PRINTF(HANDLE hDevice, char *fmt, ...) +{ + va_list ap; + char str[256]; + + va_start(ap, fmt); + vsprintf(str, fmt, ap); + + printk(KERN_DEBUG"%s", str); + + va_end(ap); +} + +void msWait(int ms) +{ + msleep(ms); +} + +void OAL_CREATE_SEMAPHORE(void) +{ + +} + +void OAL_DELETE_SEMAPHORE(void) +{ + +} + +void OAL_OBTAIN_SEMAPHORE(void) +{ + +} + +void OAL_RELEASE_SEMAPHORE(void) +{ + +} diff --git a/drivers/media/isdbt/fc8150/fci_oal.h b/drivers/media/isdbt/fc8150/fci_oal.h new file mode 100644 index 0000000..88b3c35 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_oal.h @@ -0,0 +1,28 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_oal.h + + Description : OS adatation layer +*******************************************************************************/ + +#ifndef __FCI_OAL_H__ +#define __FCI_OAL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern void PRINTF(HANDLE hDevice, char *fmt, ...); +extern void msWait(int ms); + +extern void OAL_CREATE_SEMAPHORE(void); +extern void OAL_DELETE_SEMAPHORE(void); +extern void OAL_OBTAIN_SEMAPHORE(void); +extern void OAL_RELEASE_SEMAPHORE(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_ringbuffer.c b/drivers/media/isdbt/fc8150/fci_ringbuffer.c new file mode 100644 index 0000000..25fad51 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_ringbuffer.c @@ -0,0 +1,271 @@ +/***************************************************************************** + Copyright(c) 2010 FCI Inc. All Rights Reserved + + File name : fci_ringbuffer.c + + Description : fci ringbuffer + + History : + ---------------------------------------------------------------------- + 2010/11/25 aslan.cho initial +*******************************************************************************/ + +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/sched.h> +#include <linux/string.h> +#include <linux/uaccess.h> + +#include "fci_ringbuffer.h" + +#define PKT_READY 0 +#define PKT_DISPOSED 1 + +void fci_ringbuffer_init(struct fci_ringbuffer *rbuf, void *data, size_t len) +{ + rbuf->pread = rbuf->pwrite = 0; + rbuf->data = data; + rbuf->size = len; + rbuf->error = 0; + + init_waitqueue_head(&rbuf->queue); + + spin_lock_init(&(rbuf->lock)); +} + +int fci_ringbuffer_empty(struct fci_ringbuffer *rbuf) +{ + return (rbuf->pread == rbuf->pwrite); +} + +ssize_t fci_ringbuffer_free(struct fci_ringbuffer *rbuf) +{ + ssize_t free; + + free = rbuf->pread - rbuf->pwrite; + if (free <= 0) + free += rbuf->size; + return free-1; +} + +ssize_t fci_ringbuffer_avail(struct fci_ringbuffer *rbuf) +{ + ssize_t avail; + + avail = rbuf->pwrite - rbuf->pread; + if (avail < 0) + avail += rbuf->size; + return avail; +} + +void fci_ringbuffer_flush(struct fci_ringbuffer *rbuf) +{ + rbuf->pread = rbuf->pwrite; + rbuf->error = 0; +} + +void fci_ringbuffer_reset(struct fci_ringbuffer *rbuf) +{ + rbuf->pread = rbuf->pwrite = 0; + rbuf->error = 0; +} + +void fci_ringbuffer_flush_spinlock_wakeup(struct fci_ringbuffer *rbuf) +{ + unsigned long flags; + + spin_lock_irqsave(&rbuf->lock, flags); + fci_ringbuffer_flush(rbuf); + spin_unlock_irqrestore(&rbuf->lock, flags); + + wake_up(&rbuf->queue); +} + +ssize_t fci_ringbuffer_read_user(struct fci_ringbuffer *rbuf + , u8 __user *buf, size_t len) +{ + size_t todo = len; + size_t split; + + split = (rbuf->pread + len > rbuf->size) ? rbuf->size - rbuf->pread : 0; + if (split > 0) { + if (copy_to_user(buf, rbuf->data+rbuf->pread, split)) + return -EFAULT; + buf += split; + todo -= split; + rbuf->pread = 0; + } + if (copy_to_user(buf, rbuf->data+rbuf->pread, todo)) + return -EFAULT; + + rbuf->pread = (rbuf->pread + todo) % rbuf->size; + + return len; +} + +void fci_ringbuffer_read(struct fci_ringbuffer *rbuf, u8 *buf, size_t len) +{ + size_t todo = len; + size_t split; + + split = (rbuf->pread + len > rbuf->size) ? rbuf->size - rbuf->pread : 0; + if (split > 0) { + memcpy(buf, rbuf->data+rbuf->pread, split); + buf += split; + todo -= split; + rbuf->pread = 0; + } + memcpy(buf, rbuf->data+rbuf->pread, todo); + + rbuf->pread = (rbuf->pread + todo) % rbuf->size; +} + +ssize_t fci_ringbuffer_write(struct fci_ringbuffer *rbuf + , const u8 *buf, size_t len) +{ + size_t todo = len; + size_t split; + + split = (rbuf->pwrite + len > rbuf->size) + ? rbuf->size - rbuf->pwrite : 0; + + if (split > 0) { + memcpy(rbuf->data+rbuf->pwrite, buf, split); + buf += split; + todo -= split; + rbuf->pwrite = 0; + } + memcpy(rbuf->data+rbuf->pwrite, buf, todo); + rbuf->pwrite = (rbuf->pwrite + todo) % rbuf->size; + + return len; +} + +ssize_t fci_ringbuffer_pkt_write(struct fci_ringbuffer *rbuf + , u8 *buf, size_t len) +{ + int status; + ssize_t oldpwrite = rbuf->pwrite; + + FCI_RINGBUFFER_WRITE_BYTE(rbuf, len >> 8); + FCI_RINGBUFFER_WRITE_BYTE(rbuf, len & 0xff); + FCI_RINGBUFFER_WRITE_BYTE(rbuf, PKT_READY); + status = fci_ringbuffer_write(rbuf, buf, len); + + if (status < 0) + rbuf->pwrite = oldpwrite; + return status; +} + +ssize_t fci_ringbuffer_pkt_read_user(struct fci_ringbuffer *rbuf, size_t idx, + int offset, u8 __user *buf, size_t len) +{ + size_t todo; + size_t split; + size_t pktlen; + + pktlen = rbuf->data[idx] << 8; + pktlen |= rbuf->data[(idx + 1) % rbuf->size]; + if (offset > pktlen) + return -EINVAL; + if ((offset + len) > pktlen) + len = pktlen - offset; + + idx = (idx + FCI_RINGBUFFER_PKTHDRSIZE + offset) % rbuf->size; + todo = len; + split = ((idx + len) > rbuf->size) ? rbuf->size - idx : 0; + if (split > 0) { + if (copy_to_user(buf, rbuf->data+idx, split)) + return -EFAULT; + buf += split; + todo -= split; + idx = 0; + } + if (copy_to_user(buf, rbuf->data+idx, todo)) + return -EFAULT; + + return len; +} + +ssize_t fci_ringbuffer_pkt_read(struct fci_ringbuffer *rbuf, size_t idx, + int offset, u8 *buf, size_t len) +{ + size_t todo; + size_t split; + size_t pktlen; + + pktlen = rbuf->data[idx] << 8; + pktlen |= rbuf->data[(idx + 1) % rbuf->size]; + if (offset > pktlen) + return -EINVAL; + if ((offset + len) > pktlen) + len = pktlen - offset; + + idx = (idx + FCI_RINGBUFFER_PKTHDRSIZE + offset) % rbuf->size; + todo = len; + split = ((idx + len) > rbuf->size) ? rbuf->size - idx : 0; + if (split > 0) { + memcpy(buf, rbuf->data+idx, split); + buf += split; + todo -= split; + idx = 0; + } + memcpy(buf, rbuf->data+idx, todo); + return len; +} + +void fci_ringbuffer_pkt_dispose(struct fci_ringbuffer *rbuf, size_t idx) +{ + size_t pktlen; + + rbuf->data[(idx + 2) % rbuf->size] = PKT_DISPOSED; + + while (fci_ringbuffer_avail(rbuf) > FCI_RINGBUFFER_PKTHDRSIZE) { + if (FCI_RINGBUFFER_PEEK(rbuf, 2) == PKT_DISPOSED) { + pktlen = FCI_RINGBUFFER_PEEK(rbuf, 0) << 8; + pktlen |= FCI_RINGBUFFER_PEEK(rbuf, 1); + FCI_RINGBUFFER_SKIP(rbuf + , pktlen + FCI_RINGBUFFER_PKTHDRSIZE); + } else + break; + } +} + +ssize_t fci_ringbuffer_pkt_next(struct fci_ringbuffer *rbuf + , size_t idx, size_t *pktlen) +{ + int consumed; + int curpktlen; + int curpktstatus; + + if (idx == -1) + idx = rbuf->pread; + else { + curpktlen = rbuf->data[idx] << 8; + curpktlen |= rbuf->data[(idx + 1) % rbuf->size]; + idx = (idx + curpktlen + FCI_RINGBUFFER_PKTHDRSIZE) + % rbuf->size; + } + + consumed = (idx - rbuf->pread) % rbuf->size; + + while ((fci_ringbuffer_avail(rbuf) - consumed) + > FCI_RINGBUFFER_PKTHDRSIZE) { + + curpktlen = rbuf->data[idx] << 8; + curpktlen |= rbuf->data[(idx + 1) % rbuf->size]; + curpktstatus = rbuf->data[(idx + 2) % rbuf->size]; + + if (curpktstatus == PKT_READY) { + *pktlen = curpktlen; + return idx; + } + + consumed += curpktlen + FCI_RINGBUFFER_PKTHDRSIZE; + idx = (idx + curpktlen + FCI_RINGBUFFER_PKTHDRSIZE) + % rbuf->size; + } + + return -1; +} diff --git a/drivers/media/isdbt/fc8150/fci_ringbuffer.h b/drivers/media/isdbt/fc8150/fci_ringbuffer.h new file mode 100644 index 0000000..0d1a2cc --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_ringbuffer.h @@ -0,0 +1,89 @@ +/***************************************************************************** + Copyright(c) 2010 FCI Inc. All Rights Reserved + + File name : fci_ringbuffer.h + + Description : + + History : + ---------------------------------------------------------------------- + 2010/11/25 aslan.cho initial +*******************************************************************************/ + +#ifndef __FCI_RINGBUFFER_H__ +#define __FCI_RINGBUFFER_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <linux/spinlock.h> +#include <linux/wait.h> + +struct fci_ringbuffer { + u8 *data; + ssize_t size; + ssize_t pread; + ssize_t pwrite; + int error; + + wait_queue_head_t queue; + spinlock_t lock; +}; + +#define FCI_RINGBUFFER_PKTHDRSIZE 3 + +extern void fci_ringbuffer_init(struct fci_ringbuffer *rbuf + , void *data, size_t len); + +extern int fci_ringbuffer_empty(struct fci_ringbuffer *rbuf); + +extern ssize_t fci_ringbuffer_free(struct fci_ringbuffer *rbuf); + +extern ssize_t fci_ringbuffer_avail(struct fci_ringbuffer *rbuf); + +extern void fci_ringbuffer_reset(struct fci_ringbuffer *rbuf); + +extern void fci_ringbuffer_flush(struct fci_ringbuffer *rbuf); + +extern void fci_ringbuffer_flush_spinlock_wakeup(struct fci_ringbuffer *rbuf); + +#define FCI_RINGBUFFER_PEEK(rbuf, offs) \ + ((rbuf)->data[((rbuf)->pread+(offs)) % (rbuf)->size]) + +#define FCI_RINGBUFFER_SKIP(rbuf, num) \ + ((rbuf)->pread = ((rbuf)->pread+(num)) % (rbuf)->size) + +extern ssize_t fci_ringbuffer_read_user(struct fci_ringbuffer *rbuf +, u8 __user *buf, size_t len); + +extern void fci_ringbuffer_read(struct fci_ringbuffer *rbuf + , u8 *buf, size_t len); + + +#define FCI_RINGBUFFER_WRITE_BYTE(rbuf, byte) \ + { (rbuf)->data[(rbuf)->pwrite] = (byte); \ + (rbuf)->pwrite = ((rbuf)->pwrite + 1) % (rbuf)->size; } + +extern ssize_t fci_ringbuffer_write(struct fci_ringbuffer *rbuf + , const u8 *buf, size_t len); + +extern ssize_t fci_ringbuffer_pkt_write(struct fci_ringbuffer *rbuf + , u8 *buf, size_t len); + +extern ssize_t fci_ringbuffer_pkt_read_user(struct fci_ringbuffer *rbuf + , size_t idx, int offset, u8 __user *buf, size_t len); + +extern ssize_t fci_ringbuffer_pkt_read(struct fci_ringbuffer *rbuf + , size_t idx, int offset, u8 *buf, size_t len); + +extern void fci_ringbuffer_pkt_dispose(struct fci_ringbuffer *rbuf, size_t idx); + +extern ssize_t fci_ringbuffer_pkt_next(struct fci_ringbuffer *rbuf + , size_t idx, size_t *pktlen); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_tun.c b/drivers/media/isdbt/fc8150/fci_tun.c new file mode 100644 index 0000000..a369487 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_tun.c @@ -0,0 +1,204 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_tun.c + + Description : tuner control driver +*******************************************************************************/ + +#include "fci_types.h" +#include "fci_oal.h" +#include "fci_hal.h" +#include "fci_tun.h" +#include "fci_i2c.h" +#include "fci_bypass.h" +#include "fc8150_regs.h" +#include "fc8150_bb.h" +#include "fc8150_tun.h" + + +#define FC8150_TUNER_ADDR 0x5b + +static u8 tuner_addr = FC8150_TUNER_ADDR; +static enum band_type tuner_band = ISDBT_1_SEG_TYPE; +static enum i2c_type tuner_i2c = FCI_I2C_TYPE; + +struct I2C_DRV { + int (*init)(HANDLE hDevice, int speed, int slaveaddr); + int (*read)(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); + int (*write)(HANDLE hDevice, u8 chip, u8 addr + , u8 alen, u8 *data, u8 len); + int (*deinit)(HANDLE hDevice); +}; + +static struct I2C_DRV fcii2c = { + &fci_i2c_init, + &fci_i2c_read, + &fci_i2c_write, + &fci_i2c_deinit +}; + +static struct I2C_DRV fcibypass = { + &fci_bypass_init, + &fci_bypass_read, + &fci_bypass_write, + &fci_bypass_deinit +}; + +struct TUNER_DRV { + int (*init)(HANDLE hDevice, enum band_type band); + int (*set_freq)(HANDLE hDevice + , enum band_type band, u32 rf_Khz); + int (*get_rssi)(HANDLE hDevice, int *rssi); + int (*deinit)(HANDLE hDevice); +}; + +static struct TUNER_DRV fc8150_tuner = { + &fc8150_tuner_init, + &fc8150_set_freq, + &fc8150_get_rssi, + &fc8150_tuner_deinit +}; + +#if 0 +static TUNER_DRV fc8151_tuner = { + &fc8151_tuner_init, + &fc8151_set_freq, + &fc8151_get_rssi, + &fc8151_tuner_deinit +}; +#endif + +static struct I2C_DRV *tuner_ctrl = &fcii2c; +static struct TUNER_DRV *tuner = &fc8150_tuner; + +int tuner_ctrl_select(HANDLE hDevice, enum i2c_type type) +{ + switch (type) { + case FCI_I2C_TYPE: + tuner_ctrl = &fcii2c; + break; + case FCI_BYPASS_TYPE: + tuner_ctrl = &fcibypass; + break; + default: + return BBM_E_TN_CTRL_SELECT; + } + + if (tuner_ctrl->init(hDevice, 600, 0)) + return BBM_E_TN_CTRL_INIT; + + tuner_i2c = type; + + return BBM_OK; +} + +int tuner_ctrl_deselect(HANDLE hDevice) +{ + if (tuner_ctrl == NULL) + return BBM_E_TN_CTRL_SELECT; + + tuner_ctrl->deinit(hDevice); + + tuner_i2c = FCI_I2C_TYPE; + tuner_ctrl = &fcii2c; + + return BBM_OK; +} + +int tuner_i2c_read(HANDLE hDevice, u8 addr, u8 alen, u8 *data, u8 len) +{ + if (tuner_ctrl == NULL) + return BBM_E_TN_CTRL_SELECT; + + if (tuner_ctrl->read(hDevice, tuner_addr, addr, alen, data, len)) + return BBM_E_TN_READ; + + return BBM_OK; +} + +int tuner_i2c_write(HANDLE hDevice, u8 addr, u8 alen, u8 *data, u8 len) +{ + if (tuner_ctrl == NULL) + return BBM_E_TN_CTRL_SELECT; + + if (tuner_ctrl->write(hDevice, tuner_addr, addr, alen, data, len)) + return BBM_E_TN_WRITE; + + return BBM_OK; +} + +int tuner_set_freq(HANDLE hDevice, u32 freq) +{ + if (tuner == NULL) + return BBM_E_TN_SELECT; + +#if (BBM_BAND_WIDTH == 8) + freq -= 460; +#else + freq -= 380; +#endif + + if (tuner->set_freq(hDevice, tuner_band, freq)) + return BBM_E_TN_SET_FREQ; + + fc8150_reset(hDevice); + + return BBM_OK; +} + +int tuner_select(HANDLE hDevice, u32 product, u32 band) +{ + switch (product) { + case FC8150_TUNER: + tuner = &fc8150_tuner; + tuner_addr = FC8150_TUNER_ADDR; + tuner_band = band; + break; +#if 0 + case FC8151_TUNER: + tuner = &fc8151_tuner; + tuner_addr = FC8150_TUNER_ADDR; + tuner_band = band; + break; +#endif + default: + return BBM_E_TN_SELECT; + } + + if (tuner == NULL) + return BBM_E_TN_SELECT; + + if (tuner_i2c == FCI_BYPASS_TYPE) + bbm_write(hDevice, BBM_RF_DEVID, tuner_addr); + + if (tuner->init(hDevice, tuner_band)) + return BBM_E_TN_INIT; + + return BBM_OK; +} + +int tuner_deselect(HANDLE hDevice) +{ + if (tuner == NULL) + return BBM_E_TN_SELECT; + + if (tuner->deinit(hDevice)) + return BBM_NOK; + + tuner = NULL; + + return BBM_OK; +} + +int tuner_get_rssi(HANDLE hDevice, s32 *rssi) +{ + if (tuner == NULL) + return BBM_E_TN_SELECT; + + if (tuner->get_rssi(hDevice, rssi)) + return BBM_E_TN_RSSI; + + return BBM_OK; +} diff --git a/drivers/media/isdbt/fc8150/fci_tun.h b/drivers/media/isdbt/fc8150/fci_tun.h new file mode 100644 index 0000000..f81c522 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_tun.h @@ -0,0 +1,46 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_tun.h + + Description : tuner control driver +*******************************************************************************/ + +#ifndef __FCI_TUN_H__ +#define __FCI_TUN_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "fci_types.h" + +enum i2c_type { + FCI_I2C_TYPE = 0, + FCI_BYPASS_TYPE = 1 +}; + +enum band_type { + ISDBT_1_SEG_TYPE = 2 +}; + +enum product_type { + FC8150_TUNER = 8150, + FC8151_TUNER = 8151 +}; + +extern int tuner_ctrl_select(HANDLE hDevice, enum i2c_type type); +extern int tuner_ctrl_deselect(HANDLE hDevice); +extern int tuner_select(HANDLE hDevice, u32 product, u32 band); +extern int tuner_deselect(HANDLE hDevice); + +extern int tuner_i2c_read(HANDLE hDevice, u8 addr, u8 alen, u8 *data, u8 len); +extern int tuner_i2c_write(HANDLE hDevice, u8 addr, u8 alen, u8 *data, u8 len); +extern int tuner_set_freq(HANDLE hDevice, u32 freq); +extern int tuner_get_rssi(HANDLE hDevice, s32 *rssi); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/isdbt/fc8150/fci_types.h b/drivers/media/isdbt/fc8150/fci_types.h new file mode 100644 index 0000000..95b5ca8 --- /dev/null +++ b/drivers/media/isdbt/fc8150/fci_types.h @@ -0,0 +1,61 @@ +/***************************************************************************** + Copyright(c) 2012 FCI Inc. All Rights Reserved + + File name : fci_types.h + + Description : +*******************************************************************************/ + +#ifndef __FCI_TYPES_H__ +#define __FCI_TYPES_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef HANDLE +#define HANDLE void * +#endif + +#define BBM_HPI 0 +#define BBM_SPI 1 +#define BBM_USB 2 +#define BBM_I2C 3 +#define BBM_PPI 4 +#define BBM_SPIB 5 + +#define s8 signed char +#define s16 signed short int +#define s32 signed int +#define u8 unsigned char +#define u16 unsigned short +#define u32 unsigned int +#define TRUE 1 +#define FALSE 0 + +#ifndef NULL +#define NULL 0 +#endif + +#define BBM_OK 0 +#define BBM_NOK 1 + +#define BBM_E_FAIL 0x00000001 +#define BBM_E_HOSTIF_SELECT 0x00000002 +#define BBM_E_HOSTIF_INIT 0x00000003 +#define BBM_E_BB_WRITE 0x00000100 +#define BBM_E_BB_READ 0x00000101 +#define BBM_E_TN_WRITE 0x00000200 +#define BBM_E_TN_READ 0x00000201 +#define BBM_E_TN_CTRL_SELECT 0x00000202 +#define BBM_E_TN_CTRL_INIT 0x00000203 +#define BBM_E_TN_SELECT 0x00000204 +#define BBM_E_TN_INIT 0x00000205 +#define BBM_E_TN_RSSI 0x00000206 +#define BBM_E_TN_SET_FREQ 0x00000207 + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/drivers/media/tdmb/Kconfig b/drivers/media/tdmb/Kconfig index 05ac6ac..10a51b0 100644 --- a/drivers/media/tdmb/Kconfig +++ b/drivers/media/tdmb/Kconfig @@ -83,3 +83,7 @@ endchoice config TDMB_SIMUL depends on TDMB bool "Simulation" + +config TDMB_ANT_DET + depends on TDMB + bool "tdmb antenna detector" diff --git a/drivers/media/tdmb/fc8050/dmbdrv_wrap_fc8050.c b/drivers/media/tdmb/fc8050/dmbdrv_wrap_fc8050.c index a50b8ff..548e900 100644 --- a/drivers/media/tdmb/fc8050/dmbdrv_wrap_fc8050.c +++ b/drivers/media/tdmb/fc8050/dmbdrv_wrap_fc8050.c @@ -217,15 +217,14 @@ unsigned char dmb_drv_scan_ch(unsigned long frequency) if (!dmb_initialize) return TDMB_FAIL; - fic_decoder_subchannel_info_clean(); - - bbm_com_word_write(NULL, BBM_BUF_INT, 0x01ff); - if (bbm_com_tuner_set_freq(NULL, frequency)) { bbm_com_word_write(NULL, BBM_BUF_INT, 0x00ff); return TDMB_FAIL; } + fic_decoder_subchannel_info_clean(); + bbm_com_word_write(NULL, BBM_BUF_INT, 0x01ff); + if (bbm_com_scan_status(NULL)) { bbm_com_word_write(NULL, BBM_BUF_INT, 0x00ff); return TDMB_FAIL; diff --git a/drivers/media/tdmb/mtv318/raontv_tdmb.c b/drivers/media/tdmb/mtv318/raontv_tdmb.c index d488359..4b20f7e 100644 --- a/drivers/media/tdmb/mtv318/raontv_tdmb.c +++ b/drivers/media/tdmb/mtv318/raontv_tdmb.c @@ -321,6 +321,8 @@ static void tdmb_InitOFDM(void) RTV_REG_SET(0x16, 0x6C); + RTV_REG_SET(0x1a, 0xb4); + RTV_REG_SET(0x38, 0x01); RTV_REG_SET(0x20, 0x5B); @@ -1201,6 +1203,11 @@ INT rtvTDMB_OpenSubChannel( RTV_GUARD_LOCK; /* Max sub channel is 1. So, we close the previous sub ch. */ tdmb_CloseSubChannel(0); +#if defined(RTV_IF_SPI) || defined(RTV_IF_EBI2) + RTV_REG_MAP_SEL(OFDM_PAGE); + RTV_REG_SET(0x10, 0x48); + RTV_REG_SET(0x10, 0xC9); +#endif tdmb_OpenSubChannel(nSubChID, eServiceType, nThresholdSize); RTV_GUARD_FREE; #else diff --git a/drivers/media/tdmb/tcc3170/inc/tcbd_api_common.h b/drivers/media/tdmb/tcc3170/inc/tcbd_api_common.h index 3557809..f798610 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcbd_api_common.h +++ b/drivers/media/tdmb/tcc3170/inc/tcbd_api_common.h @@ -1,5 +1,5 @@ /* - * tcbd_api_common.c + * tcbd_api_common.h * * Author: <linux@telechips.com> * Description: Telechips broadcast driver diff --git a/drivers/media/tdmb/tcc3170/inc/tcbd_drv_io.h b/drivers/media/tdmb/tcc3170/inc/tcbd_drv_io.h index 7051b0f..b09d9ca 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcbd_drv_io.h +++ b/drivers/media/tdmb/tcc3170/inc/tcbd_drv_io.h @@ -81,13 +81,15 @@ TCBB_FUNC s32 tcbd_rf_reg_write( TCBB_FUNC s32 tcbd_rf_reg_read( struct tcbd_device *_handle, u32 _addr, u32 *_data); -TCBB_FUNC s32 tcbd_send_mail( - struct tcbd_device *_device, struct tcbd_mail_data *_mail); -TCBB_FUNC s32 tcbd_recv_mail( - struct tcbd_device *_device, struct tcbd_mail_data *_mail); -TCBB_FUNC s32 tcbd_read_mail_box( - struct tcbd_device *_device, u16 cmd, s32 len, u32 *data); - +TCBB_FUNC s32 tcbd_send_mail(struct tcbd_device *_device, + struct tcbd_mail_data *_mail); +TCBB_FUNC s32 tcbd_recv_mail(struct tcbd_device *_device, + struct tcbd_mail_data *_mail); +TCBB_FUNC s32 tcbd_read_mail_box(struct tcbd_device *_device, u16 cmd, + s32 len, u32 *data); +TCBB_FUNC s32 tcbd_write_mail_box(struct tcbd_device *_device, u16 _cmd, + s32 _cnt, u32 *_data); +TCBB_FUNC s32 tcbd_read_file(struct tcbd_device *_device, char *_path, + u8 *_buff, s32 _size); extern struct spi_device *spi_dmb; /* sukjoon_temp */ - #endif /*__TCBD_DRV_COMMON_H__*/ diff --git a/drivers/media/tdmb/tcc3170/inc/tcbd_drv_ip.h b/drivers/media/tdmb/tcc3170/inc/tcbd_drv_ip.h index fc181f8..7789d1c 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcbd_drv_ip.h +++ b/drivers/media/tdmb/tcc3170/inc/tcbd_drv_ip.h @@ -71,4 +71,8 @@ TCBB_FUNC s32 tcbd_init_dsp( struct tcbd_device *_device, u8 *_boot_code, s32 _size); TCBB_FUNC s32 tcbd_check_dsp_status(struct tcbd_device *_device); + +#define FILTER_ENABLE (1<<2) +#define FILTER_SYNCERR (1<<3) +TCBB_FUNC s32 tcbd_set_pid_filter(struct tcbd_device *_device, u32 _filter); #endif /*__TCBD_DRV_IP_H__*/ diff --git a/drivers/media/tdmb/tcc3170/inc/tcbd_feature.h b/drivers/media/tdmb/tcc3170/inc/tcbd_feature.h index a8bf7fc..53fb880 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcbd_feature.h +++ b/drivers/media/tdmb/tcc3170/inc/tcbd_feature.h @@ -25,19 +25,25 @@ #define __AGC_TABLE_IN_DSP__ - #define __CSPI_ONLY__ #undef __I2C_STS__ #undef __ALWAYS_FIC_ON__ #undef __CALLBACK_BUFFER_HEADER__ +#if defined(__I2C_STS__) +#define __STATUS_IN_REGISTER__ +#else /*__I2C_STS__*/ #undef __STATUS_IN_REGISTER__ #define __STATUS_IN_STREAM__ -#undef __CALC_INTRRUPT_THRESHOLD__ +#endif /*!__I2C_STS__*/ +#if defined(__CSPI_ONLY__) #define __READ_FIXED_LENGTH__ #undef __READ_VARIABLE_LENGTH__ +#endif /*__CSPI_ONLY__*/ + +#undef __DEBUG_DSP_ROM__ #define TCBD_MAX_NUM_SERVICE 6 @@ -50,24 +56,31 @@ #define TCBD_CHIPID_VALUE (0x37) #if defined(__STATUS_IN_REGISTER__) +#if defined(__CSPI_ONLY__) #define TCBD_THRESHOLD_FIC\ - (TCBD_FIC_SIZE + TCBD_OP_HEADER_SIZE) + (TCBD_FIC_SIZE + TCBD_STATUS_SIZE + TCBD_OP_HEADER_SIZE*2) +#elif defined(__I2C_STS__) +#define TCBD_THRESHOLD_FIC (TCBD_FIC_SIZE) +#else /*__I2C_STS__*/ +#error "you must define __I2C_STS__ or __CSPI_ONLY__" +#endif /*!__CSPI_ONLY__ && !__I2C_STS__*/ #else /* __STATUS_IN_REGISTER__ */ #define TCBD_THRESHOLD_FIC\ (TCBD_FIC_SIZE+TCBD_STATUS_SIZE+TCBD_OP_HEADER_SIZE*2) #endif /* !__STATUS_IN_REGISTER__ */ #if defined(__CSPI_ONLY__) -#define TCBD_BUFFER_A_SIZE (TCBD_THRESHOLD_FIC*5) -#define TCBD_BUFFER_B_SIZE (TCBD_MAX_FIFO_SIZE - TCBD_BUFFER_A_SIZE) +#define TCBD_BUFFER_A_SIZE (TCBD_MAX_FIFO_SIZE) +#define TCBD_BUFFER_B_SIZE (0x0) #define TCBD_BUFFER_C_SIZE (0x0) #define TCBD_BUFFER_D_SIZE (0x0) -#define TCBD_MAX_THRESHOLD (((TCBD_MAX_FIFO_SIZE>>1)>>2)<<2) +#define TCBD_MAX_THRESHOLD (((1024*7)>>2)<<2) #elif defined(__I2C_STS__) #define TCBD_BUFFER_A_SIZE (TCBD_THRESHOLD_FIC) -#define TCBD_BUFFER_B_SIZE (1024*6) +#define TCBD_BUFFER_B_SIZE \ + (((TCBD_MAX_FIFO_SIZE-TCBD_BUFFER_A_SIZE)>>2)<<2) #define TCBD_BUFFER_C_SIZE (0x0) #define TCBD_BUFFER_D_SIZE (0x0) @@ -92,19 +105,6 @@ #define PHY_MEM_ADDR_D_END\ (PHY_MEM_ADDR_D_START+TCBD_BUFFER_D_SIZE-1) -#define DP_CFG_OPSET1 (1144) -#define DP_CFG_OPSET2 (204) - -#define DP_CFG_1_DATA0 (PHY_BASE_ADDR + 0xd000) -#define DP_CFG_2_DATA0 (DP_CFG_1_DATA0 + DP_CFG_OPSET1) -#define DP_CFG_1_DATA1 (DP_CFG_2_DATA0 + DP_CFG_OPSET2) -#define DP_CFG_2_DATA1 (DP_CFG_1_DATA1 + DP_CFG_OPSET1) -#define DP_CFG_1_DATA2 (DP_CFG_2_DATA1 + DP_CFG_OPSET2) -#define DP_CFG_2_DATA2 (DP_CFG_1_DATA2 + DP_CFG_OPSET1) -#define DP_CFG_1_DATA3 (DP_CFG_2_DATA2 + DP_CFG_OPSET2) -#define DP_CFG_2_DATA3 (DP_CFG_1_DATA3 + DP_CFG_OPSET1) - - /* CODE Memory Setting */ #define START_PC (0x0000) #define START_PC_OFFSET (0x8000) diff --git a/drivers/media/tdmb/tcc3170/inc/tcbd_stream_parser/tcbd_stream_parser.h b/drivers/media/tdmb/tcc3170/inc/tcbd_stream_parser/tcbd_stream_parser.h index e50bf73..f9b0ab1 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcbd_stream_parser/tcbd_stream_parser.h +++ b/drivers/media/tdmb/tcc3170/inc/tcbd_stream_parser/tcbd_stream_parser.h @@ -24,7 +24,6 @@ #define __TCBD_STREAM_PARSER_H__ #undef __MERGE_EACH_TYPEOF_STREAM__ -#define __FIND_HEADER_MORE__ #define SIZE_BUFF_HEADER 4 /*[TYPE(1)][SUBCH(1)][SIZE(2)]*/ @@ -36,10 +35,11 @@ enum DATA_TYPE { DATA_TYPE_MAX }; -typedef s32 (*tcbd_stream_callback)( - u8 *_stream, s32 _size, u8 _subch_id, u8 _type); +typedef s32 (*tcbd_stream_callback)(s32 _dev_idx, u8 *_stream, s32 _size, + u8 _subch_id, u8 _type); -TCBB_FUNC void tcbd_init_parser(tcbd_stream_callback _streamCallback); -TCBB_FUNC s32 tcbd_split_stream(u8 *_stream, s32 _size); +TCBB_FUNC void tcbd_init_parser(s32 _dev_idx, + tcbd_stream_callback _streamCallback); +TCBB_FUNC s32 tcbd_split_stream(s32 _dev_idx, u8 *_stream, s32 _size); #endif /*__TCBD_STREAM_PARSER_H__*/ diff --git a/drivers/media/tdmb/tcc3170/inc/tcc317x_boot_tdmb.h b/drivers/media/tdmb/tcc3170/inc/tcc317x_boot_tdmb.h index daad3cf..b334fce 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcc317x_boot_tdmb.h +++ b/drivers/media/tdmb/tcc3170/inc/tcc317x_boot_tdmb.h @@ -1,36 +1,28 @@ #ifndef __TCC317X_BOOT_TDMB_H__ #define __TCC317X_BOOT_TDMB_H__ /* - asm file: E:\Works\ASM\TCC3500_ASM_BIN\TCC3170\LG\TCC317X_LG_v1_0_12.rom - Created : 2012-02-20 19:03:43 -*/ -#define TCC317X_BOOT_SIZE_TDMB 7412 + * asm file: E:\Works\ASM\TCC3500_ASM_BIN\TCC3170\LG\TCC317X_LG_v1_0_17.rom + * Created : 2012-05-04 09:54:27 + */ +#define TCC317X_BOOT_SIZE_TDMB 7996 unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { - 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1C, 0xCC, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1F, 0x14, 0xAB, 0x00, 0x04, 0x60, 0x17, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x0C, 0xA0, 0x17, 0x05, 0x00, 0x00, 0xAB, 0xB4, 0x00, 0xE0, 0x17, 0x05, 0x00, 0x00, 0xAB, 0xC2, 0x01, 0x20, 0x18, 0x05, 0x00, 0x00, 0xAB, 0x28, 0x00, 0x60, 0x18, 0x05, 0x00, 0x00, 0xAB, 0xB4, 0x00, 0xA0, 0x18, 0x05, 0x00, 0x00, - 0xAB, 0x1C, 0x00, 0x20, 0x19, 0x05, 0x00, 0x00, - 0xAB, 0x16, 0x00, 0x60, 0x19, 0x05, 0x00, 0x00, - 0xAB, 0x1A, 0x00, 0xA0, 0x19, 0x05, 0x00, 0x00, - 0xAB, 0x10, 0x00, 0xE0, 0x19, 0x05, 0x00, 0x00, - 0xAB, 0x16, 0x00, 0x20, 0x1A, 0x05, 0x00, 0x00, - 0xAB, 0x08, 0x00, 0x60, 0x1A, 0x05, 0x00, 0x00, + 0xAB, 0x20, 0x00, 0x20, 0x19, 0x05, 0x00, 0x00, + 0xAB, 0x1C, 0x00, 0x60, 0x19, 0x05, 0x00, 0x00, + 0xAB, 0x1C, 0x00, 0xA0, 0x19, 0x05, 0x00, 0x00, + 0xAB, 0x16, 0x00, 0xE0, 0x19, 0x05, 0x00, 0x00, + 0xAB, 0x1A, 0x00, 0x20, 0x1A, 0x05, 0x00, 0x00, + 0xAB, 0x10, 0x00, 0x60, 0x1A, 0x05, 0x00, 0x00, 0xAB, 0x84, 0x03, 0xA0, 0x1A, 0x05, 0x00, 0x00, 0xAB, 0xB8, 0x0B, 0xE0, 0x1A, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x20, 0x1B, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x60, 0x1B, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0xA0, 0x1B, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0xE0, 0x1B, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x20, 0x1C, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x60, 0x1C, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0xA0, 0x1C, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0xE0, 0x1C, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x20, 0x1D, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x60, 0x1D, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xA0, 0x1D, 0x05, 0x00, 0x00, 0xAB, 0x30, 0x00, 0xE0, 0x18, 0x05, 0x00, 0x00, @@ -41,20 +33,6 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0xCB, 0x3C, 0x0A, 0x00, 0x00, 0x26, 0x44, 0x00, 0xCB, 0x60, 0x20, 0x00, 0x00, 0x2A, 0x44, 0x00, 0xCB, 0x6E, 0x14, 0xA0, 0x28, 0x2E, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x32, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x36, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x3A, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x42, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x46, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x4A, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x4E, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x52, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x56, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x5A, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x5E, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x62, 0x44, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x66, 0x44, 0x00, 0xCB, 0xFE, 0x00, 0x00, 0x00, 0x6A, 0x44, 0x00, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x44, 0x00, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x72, 0x44, 0x00, @@ -79,7 +57,7 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0xCB, 0x00, 0x00, 0x00, 0x00, 0xAE, 0x44, 0x00, 0xCB, 0x58, 0x12, 0xAE, 0xE6, 0xB3, 0x44, 0x00, 0xCB, 0x06, 0x0A, 0x10, 0x10, 0xB6, 0x44, 0x00, - 0xCB, 0x1E, 0x94, 0x20, 0x00, 0xBA, 0x44, 0x00, + 0xCB, 0x1C, 0x92, 0x22, 0x00, 0xBA, 0x44, 0x00, 0xCB, 0x78, 0x82, 0x9E, 0x00, 0xBE, 0x44, 0x00, 0xCB, 0xF0, 0x04, 0x3D, 0x01, 0xC2, 0x44, 0x00, 0xCB, 0x3C, 0x8E, 0x4A, 0x00, 0xC6, 0x44, 0x00, @@ -88,7 +66,7 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x01, 0x00, 0xCB, 0xA2, 0xCA, 0x99, 0x35, 0x02, 0x44, 0x01, 0xCB, 0x40, 0x00, 0x00, 0x00, 0x06, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x14, 0x04, 0x2A, 0x3F, 0x5E, 0xA2, + 0x06, 0xA2, 0x0E, 0x04, 0x2A, 0x3F, 0x5E, 0xA2, 0x6A, 0x3F, 0x88, 0x23, 0xCB, 0x3E, 0xFE, 0xFF, 0xFF, 0x93, 0x44, 0x01, 0x0F, 0x31, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x31, 0x01, 0x00, @@ -116,8 +94,8 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0xE0, 0x14, 0x00, 0x00, 0x0F, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAE, 0xC7, 0x00, 0x00, 0x2E, 0x4F, 0x44, 0x01, 0x6E, 0x50, 0xD8, 0x05, - 0xAE, 0x50, 0x10, 0x4A, 0xEE, 0x50, 0xAC, 0x01, - 0x2E, 0x51, 0x8C, 0x06, 0x6E, 0x51, 0x4C, 0x48, + 0xAE, 0x50, 0x7C, 0x02, 0xEE, 0x50, 0xAC, 0x01, + 0x2E, 0x51, 0x8C, 0x06, 0x6E, 0x51, 0x60, 0x4A, 0x2E, 0x42, 0x00, 0x08, 0x0F, 0x25, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x37, 0xC3, 0x07, 0x00, 0x00, 0x01, 0x00, 0xCB, 0x20, 0x00, 0x00, @@ -163,7 +141,7 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x00, 0xD6, 0x46, 0x01, 0xCB, 0x3E, 0x00, 0x20, 0x00, 0xDA, 0x46, 0x01, 0xCB, 0xBE, 0x00, 0x40, 0x00, 0xDE, 0x46, 0x01, 0xCB, 0xDE, 0x00, 0xC0, - 0x00, 0xE2, 0x46, 0x01, 0x8B, 0x6D, 0x88, 0x82, + 0x00, 0xE2, 0x46, 0x01, 0x8B, 0x65, 0x88, 0x82, 0xB9, 0x51, 0x00, 0x00, 0xCB, 0x20, 0x02, 0xFE, 0x03, 0x9E, 0x47, 0x01, 0xCB, 0xFE, 0xFF, 0x43, 0x20, 0xFA, 0x46, 0x01, 0xCB, 0x22, 0x00, 0x00, @@ -174,43 +152,48 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x08, 0xE6, 0x47, 0x01, 0xCB, 0x00, 0x20, 0x00, 0x00, 0x16, 0x47, 0x01, 0x0E, 0x03, 0x00, 0x00, 0x06, 0x20, 0xBD, 0x00, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0xCA, 0x47, 0x00, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0xC6, 0x47, 0x00, 0x8B, 0xF4, 0xA3, 0xE0, - 0x7C, 0x04, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xE0, - 0x3B, 0x05, 0x00, 0x00, 0xCB, 0x80, 0x10, 0x60, - 0x15, 0x46, 0x47, 0x00, 0xCB, 0x40, 0x18, 0x20, - 0x1D, 0x4A, 0x47, 0x00, 0xCB, 0x00, 0x23, 0x82, - 0x18, 0x4E, 0x47, 0x00, 0xCB, 0x62, 0x1D, 0x42, - 0x23, 0x52, 0x47, 0x00, 0xCB, 0x22, 0x2A, 0x02, - 0x34, 0x56, 0x47, 0x00, 0xCB, 0x84, 0x1D, 0x64, - 0x23, 0x5A, 0x47, 0x00, 0xCB, 0x44, 0x2A, 0x24, - 0x34, 0x5E, 0x47, 0x00, 0xCB, 0x86, 0x20, 0x66, - 0x2A, 0x62, 0x47, 0x00, 0xCB, 0x46, 0x30, 0x26, - 0x3A, 0x66, 0x47, 0x00, 0xCB, 0x06, 0x46, 0x88, - 0x28, 0x6A, 0x47, 0x00, 0xCB, 0x68, 0x34, 0x48, - 0x3A, 0x6E, 0x47, 0x00, 0xCB, 0x28, 0x46, 0x08, - 0x54, 0x72, 0x47, 0x00, 0xCB, 0x8A, 0x30, 0x6A, - 0x3A, 0x76, 0x47, 0x00, 0xCB, 0x4A, 0x46, 0x2A, - 0x54, 0x7A, 0x47, 0x00, 0xCB, 0x0A, 0x68, 0x8C, - 0x3A, 0x7E, 0x47, 0x00, 0xCB, 0x6C, 0x46, 0x4C, - 0x54, 0x82, 0x47, 0x00, 0xCB, 0x2C, 0x68, 0x8E, - 0x40, 0x86, 0x47, 0x00, 0xCB, 0x6E, 0x54, 0x4E, - 0x60, 0x8A, 0x47, 0x00, 0xCB, 0x2E, 0x74, 0x0E, - 0x8C, 0x8E, 0x47, 0x00, 0xCB, 0x90, 0x50, 0x70, - 0x68, 0x92, 0x47, 0x00, 0xCB, 0x50, 0x74, 0x30, - 0x8C, 0x96, 0x47, 0x00, 0xCB, 0x10, 0xA8, 0x92, - 0x60, 0x9A, 0x47, 0x00, 0xCB, 0x72, 0x74, 0x52, - 0x8C, 0x9E, 0x47, 0x00, 0xCB, 0x32, 0xA8, 0x12, - 0xD0, 0xA2, 0x47, 0x00, 0xCB, 0x94, 0x74, 0x74, - 0x8C, 0xA6, 0x47, 0x00, 0xCB, 0x54, 0xA8, 0x34, - 0xD0, 0xAA, 0x47, 0x00, 0xCB, 0x14, 0xE8, 0x96, - 0x80, 0xAE, 0x47, 0x00, 0xCB, 0x76, 0xA8, 0x56, - 0xC0, 0xB2, 0x47, 0x00, 0xCB, 0x36, 0xE8, 0x16, - 0x18, 0xB7, 0x47, 0x00, 0xCB, 0x98, 0xA0, 0x78, - 0xD0, 0xBA, 0x47, 0x00, 0xCB, 0x38, 0x18, 0x9B, - 0xC0, 0xBE, 0x47, 0x00, 0xCB, 0x5A, 0x18, 0x1B, - 0xA0, 0xC3, 0x47, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0xCB, 0x06, 0x00, 0x00, + 0x00, 0xDA, 0x47, 0x00, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xCE, 0x47, 0x00, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xD2, 0x47, 0x00, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xD6, 0x47, 0x00, 0x0F, 0x99, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0F, 0xDD, 0x44, 0x2A, + 0x00, 0x00, 0x00, 0x00, 0x0F, 0x2B, 0x17, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x46, 0x04, 0x26, 0x04, + 0xAB, 0x00, 0x00, 0x00, 0x0B, 0x03, 0x00, 0x00, + 0xCB, 0x80, 0x10, 0x60, 0x15, 0x4E, 0x47, 0x00, + 0xCB, 0x40, 0x18, 0x20, 0x1D, 0x52, 0x47, 0x00, + 0xCB, 0x00, 0x23, 0x82, 0x18, 0x56, 0x47, 0x00, + 0xCB, 0x62, 0x1D, 0x42, 0x23, 0x5A, 0x47, 0x00, + 0xCB, 0x22, 0x2A, 0x02, 0x34, 0x5E, 0x47, 0x00, + 0xCB, 0x84, 0x1D, 0x64, 0x23, 0x62, 0x47, 0x00, + 0xCB, 0x44, 0x2A, 0x24, 0x34, 0x66, 0x47, 0x00, + 0xCB, 0x86, 0x20, 0x66, 0x2A, 0x6A, 0x47, 0x00, + 0xCB, 0x46, 0x30, 0x26, 0x3A, 0x6E, 0x47, 0x00, + 0xCB, 0x06, 0x46, 0x88, 0x28, 0x72, 0x47, 0x00, + 0xCB, 0x68, 0x34, 0x48, 0x3A, 0x76, 0x47, 0x00, + 0xCB, 0x28, 0x46, 0x08, 0x54, 0x7A, 0x47, 0x00, + 0xCB, 0x8A, 0x30, 0x6A, 0x3A, 0x7E, 0x47, 0x00, + 0xCB, 0x4A, 0x46, 0x2A, 0x54, 0x82, 0x47, 0x00, + 0xCB, 0x0A, 0x68, 0x8C, 0x3A, 0x86, 0x47, 0x00, + 0xCB, 0x6C, 0x46, 0x4C, 0x54, 0x8A, 0x47, 0x00, + 0xCB, 0x2C, 0x68, 0x8E, 0x40, 0x8E, 0x47, 0x00, + 0xCB, 0x6E, 0x54, 0x4E, 0x60, 0x92, 0x47, 0x00, + 0xCB, 0x2E, 0x74, 0x0E, 0x8C, 0x96, 0x47, 0x00, + 0xCB, 0x90, 0x50, 0x70, 0x68, 0x9A, 0x47, 0x00, + 0xCB, 0x50, 0x74, 0x30, 0x8C, 0x9E, 0x47, 0x00, + 0xCB, 0x10, 0xA8, 0x92, 0x60, 0xA2, 0x47, 0x00, + 0xCB, 0x72, 0x74, 0x52, 0x8C, 0xA6, 0x47, 0x00, + 0xCB, 0x32, 0xA8, 0x12, 0xD0, 0xAA, 0x47, 0x00, + 0xCB, 0x94, 0x74, 0x74, 0x8C, 0xAE, 0x47, 0x00, + 0xCB, 0x54, 0xA8, 0x34, 0xD0, 0xB2, 0x47, 0x00, + 0xCB, 0x14, 0xE8, 0x96, 0x80, 0xB6, 0x47, 0x00, + 0xCB, 0x76, 0xA8, 0x56, 0xC0, 0xBA, 0x47, 0x00, + 0xCB, 0x36, 0xE8, 0x16, 0x18, 0xBF, 0x47, 0x00, + 0xCB, 0x98, 0xA0, 0x78, 0xD0, 0xC2, 0x47, 0x00, + 0xCB, 0x38, 0x18, 0x9B, 0xC0, 0xC6, 0x47, 0x00, + 0xCB, 0x5A, 0x18, 0x1B, 0xA0, 0xCB, 0x47, 0x00, + 0x06, 0x02, 0x43, 0x04, 0xCB, 0x06, 0x00, 0x00, 0x00, 0x02, 0x46, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0xAB, 0x0E, 0x00, 0x20, @@ -225,20 +208,28 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x00, 0x02, 0x40, 0x01, 0x0E, 0x03, 0x01, 0x00, 0x06, 0x20, 0xBD, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0x90, 0x39, 0x03, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0xCA, 0x47, 0x00, 0xAB, 0x00, 0x00, 0x60, - 0x1F, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xE0, - 0x3B, 0x05, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x02, - 0x00, 0xAA, 0x46, 0x00, 0x0E, 0x1F, 0x00, 0x00, - 0x0A, 0x7A, 0x1C, 0xA3, 0x6A, 0x25, 0x31, 0xA2, - 0x6A, 0x0F, 0x32, 0xA2, 0x8B, 0xCD, 0x86, 0x80, - 0x1A, 0x51, 0x00, 0x00, 0x8B, 0x55, 0x8D, 0x80, - 0x1B, 0x51, 0x00, 0x00, 0x8B, 0x6D, 0x8F, 0x82, - 0x1C, 0x51, 0x00, 0x00, 0x8B, 0x65, 0x8F, 0x82, - 0x1D, 0x51, 0x00, 0x00, 0x8B, 0x55, 0x8F, 0x82, - 0x1E, 0x51, 0x00, 0x00, 0x8B, 0x5D, 0x8F, 0x82, - 0x1F, 0x51, 0x00, 0x00, 0x2A, 0x1D, 0x34, 0x22, + 0x00, 0xDA, 0x47, 0x00, 0xAB, 0x00, 0x00, 0x60, + 0x1F, 0x05, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x02, + 0x00, 0xAA, 0x46, 0x00, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xD6, 0x47, 0x00, 0x0F, 0x99, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0F, 0xDD, 0x44, 0x2A, + 0x00, 0x00, 0x00, 0x00, 0x0F, 0x2B, 0x17, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x46, 0x04, 0x34, 0x04, + 0xAB, 0x00, 0x00, 0x00, 0x0B, 0x03, 0x00, 0x00, + 0x0E, 0x1F, 0x00, 0x00, 0x0A, 0x7A, 0x1C, 0xA3, + 0x6A, 0x25, 0x31, 0xA2, 0x6A, 0x0F, 0x32, 0xA2, + 0x8B, 0xCD, 0x86, 0x80, 0x1A, 0x51, 0x00, 0x00, + 0x8B, 0x55, 0x8D, 0x80, 0x1B, 0x51, 0x00, 0x00, + 0x8B, 0x6D, 0x8F, 0x82, 0x1C, 0x51, 0x00, 0x00, + 0x8B, 0x65, 0x8F, 0x82, 0x1D, 0x51, 0x00, 0x00, + 0x8B, 0x55, 0x8F, 0x82, 0x1E, 0x51, 0x00, 0x00, + 0x8B, 0x5D, 0x8F, 0x82, 0x1F, 0x51, 0x00, 0x00, + 0x2A, 0x3F, 0xE8, 0x23, 0x97, 0x8F, 0x8F, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xC3, 0x3E, 0x04, 0x2A, 0x1D, 0x34, 0x22, 0x97, 0x0F, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x66, 0x82, 0x3F, 0x04, 0x0E, 0x17, 0x08, 0x00, + 0x66, 0x42, 0x3D, 0x04, 0x0E, 0x17, 0x08, 0x00, 0x0A, 0x0D, 0xF6, 0x28, 0x2A, 0x03, 0x18, 0xA2, 0xF6, 0x15, 0x04, 0x40, 0x96, 0x11, 0xFF, 0xFF, 0x9A, 0x08, 0x08, 0x00, 0x76, 0x1C, 0x00, 0x08, @@ -256,23 +247,24 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x14, 0x51, 0x00, 0x00, 0x8B, 0x5D, 0x8F, 0x82, 0x14, 0x51, 0x00, 0x00, 0x2A, 0x07, 0x26, 0xA2, 0x96, 0x33, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xA3, 0x3D, 0x04, 0x1A, 0x0C, 0x00, 0x14, + 0x46, 0x63, 0x3B, 0x04, 0x1A, 0x0C, 0x00, 0x14, 0x7A, 0x10, 0x0C, 0x08, 0x01, 0x00, 0x01, 0x00, - 0x26, 0xC3, 0x3E, 0x04, 0x3A, 0x0C, 0x10, 0x04, + 0x26, 0x83, 0x3C, 0x04, 0x3A, 0x0C, 0x10, 0x04, 0x4A, 0x1E, 0xF6, 0x28, 0x4A, 0x1E, 0xF8, 0x28, 0x4E, 0x14, 0x00, 0x00, 0x6A, 0x0B, 0x14, 0xA2, 0xCB, 0x02, 0x00, 0x00, 0x7E, 0x2F, 0x44, 0x01, 0x2A, 0x1D, 0x34, 0x22, 0x97, 0x0F, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x02, 0x41, 0x04, 0xF6, 0x75, 0x38, 0x04, + 0x66, 0xC2, 0x3E, 0x04, 0xF6, 0x75, 0x38, 0x04, 0x97, 0x0F, 0x07, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0xF6, 0xFD, 0x7C, 0x40, 0x6A, 0x3F, 0x14, 0xA2, 0xCB, 0x02, 0x00, 0x00, 0x88, 0x2E, 0x44, 0x01, - 0x2A, 0x0D, 0x32, 0x22, 0x7B, 0x0C, 0x0C, 0xC0, - 0x4F, 0x2C, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0xA6, 0x22, 0x42, 0x04, 0xCB, 0x04, 0x40, 0x00, + 0x2A, 0x3F, 0xE8, 0x23, 0x9A, 0x7C, 0x7C, 0x00, + 0x6A, 0x3F, 0xE8, 0x23, 0x2A, 0x0D, 0x32, 0x22, + 0x7B, 0x0C, 0x0C, 0xC0, 0x4F, 0x2C, 0x00, 0x00, + 0xA6, 0x22, 0x40, 0x04, 0xCB, 0x04, 0x40, 0x00, 0x00, 0x92, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0x42, 0x04, 0xCB, 0x02, 0x80, 0x00, + 0x06, 0x62, 0x40, 0x04, 0xCB, 0x02, 0x80, 0x00, 0x00, 0x92, 0x44, 0x01, 0xAB, 0x00, 0x02, 0x20, 0x60, 0x14, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, @@ -284,146 +276,168 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x36, 0x0E, 0x0E, 0x1F, 0x36, 0x92, 0x0E, 0x0D, 0x4F, 0x24, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x37, 0xC3, 0x07, 0x00, 0x00, 0x01, 0x00, - 0x8B, 0x8D, 0x8F, 0x80, 0xCA, 0x11, 0x00, 0x00, - 0x06, 0x10, 0xD5, 0x04, 0x6A, 0x25, 0x11, 0xA2, + 0x06, 0x10, 0x9A, 0x04, 0x6A, 0x25, 0x11, 0xA2, 0x2A, 0x3F, 0x0E, 0x22, 0xB7, 0x8F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x6A, 0x3F, 0x0E, 0x22, - 0xA6, 0x03, 0x13, 0x6C, 0xF6, 0x05, 0x48, 0x42, + 0xA6, 0x83, 0x0D, 0x6C, 0xF6, 0x05, 0x48, 0x42, 0x7A, 0x06, 0x09, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xE3, 0x50, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA0, 0x59, 0x04, 0x2A, 0x15, 0x54, 0x23, + 0x46, 0xA3, 0x51, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x60, 0x5A, 0x04, 0xCB, 0x02, 0x00, 0x00, + 0x00, 0xD2, 0x47, 0x00, 0x2A, 0x15, 0x54, 0x23, 0x5B, 0x3E, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0xA3, 0x47, 0x04, 0x8B, 0x4D, 0x8D, 0x80, + 0x46, 0xA3, 0x45, 0x04, 0x8B, 0x4D, 0x8D, 0x80, 0xAA, 0x11, 0x00, 0x00, 0x2A, 0x17, 0x90, 0x21, - 0x97, 0x85, 0x85, 0x1F, 0x00, 0x00, 0x00, 0x00, - 0x5B, 0x3E, 0x16, 0x7E, 0x00, 0x00, 0x00, 0x00, - 0x46, 0xE3, 0x48, 0x04, 0xCB, 0x7E, 0x14, 0xA0, + 0x97, 0x85, 0x85, 0x0F, 0x00, 0x00, 0x00, 0x00, + 0x5B, 0x3E, 0x16, 0x3E, 0x00, 0x00, 0x00, 0x00, + 0x46, 0xE3, 0x46, 0x04, 0xCB, 0x7E, 0x14, 0xA0, 0x28, 0x2E, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x49, 0x04, 0xCB, 0x6E, 0x14, 0xA0, + 0x06, 0x22, 0x47, 0x04, 0xCB, 0x6E, 0x14, 0xA0, 0x28, 0x2E, 0x44, 0x00, 0x0F, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0xCC, 0x00, 0x28, 0x0A, 0xDC, 0xD8, 0x28, 0x2A, 0x15, 0x18, 0x22, - 0x2A, 0x17, 0x1A, 0x22, 0x2A, 0x1D, 0x34, 0x22, - 0x97, 0x0F, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, - 0x66, 0x82, 0x50, 0x04, 0x5B, 0x3E, 0x18, 0x02, + 0x2A, 0x17, 0x1A, 0x22, 0x5B, 0x3E, 0x18, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0x83, 0x50, 0x04, 0x5B, 0x3E, 0x1A, 0x00, + 0x46, 0x43, 0x51, 0x04, 0x5B, 0x3E, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x82, 0x50, 0x04, 0xF6, 0x1D, 0x28, 0x50, + 0x66, 0x42, 0x51, 0x04, 0x2A, 0x3D, 0x54, 0x23, + 0x7B, 0x3E, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x66, 0xE2, 0x49, 0x04, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xD6, 0x47, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xA2, 0x4B, 0x04, 0x2A, 0x3D, 0xEA, 0x23, + 0x9A, 0x78, 0x78, 0x00, 0x6A, 0x3D, 0xEA, 0x23, + 0x7B, 0x3E, 0x3C, 0x3C, 0x00, 0x00, 0x00, 0x00, + 0xE6, 0xA2, 0x4B, 0x04, 0x2A, 0x3D, 0x14, 0x23, + 0x9A, 0x78, 0x78, 0x00, 0x6A, 0x3D, 0x14, 0x23, + 0xCB, 0x10, 0x00, 0x00, 0x00, 0x02, 0x40, 0x01, + 0x0F, 0x37, 0xC1, 0x05, 0x00, 0x00, 0x01, 0x00, + 0x06, 0x62, 0x2E, 0x04, 0x2A, 0x1D, 0x34, 0x22, + 0x97, 0x0F, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x66, 0x42, 0x51, 0x04, 0xF6, 0x1D, 0x28, 0x50, 0x96, 0x33, 0x3F, 0x00, 0x76, 0x34, 0x0C, 0x14, 0x1B, 0xAE, 0x06, 0x60, 0x29, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0A, 0x35, 0x00, 0x02, 0x5B, 0x3E, 0x06, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x26, 0x63, 0x4E, 0x04, 0xF6, 0x1D, 0x2C, 0x40, + 0x26, 0x23, 0x4F, 0x04, 0xF6, 0x1D, 0x2C, 0x40, 0x96, 0x33, 0x03, 0x00, 0x5B, 0x3E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0x63, 0x4F, 0x04, 0x97, 0x01, 0x49, 0x08, + 0x46, 0x23, 0x50, 0x04, 0x97, 0x01, 0x49, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0x63, 0x4F, 0x04, 0xF6, 0x75, 0x38, 0x04, + 0x46, 0x23, 0x50, 0x04, 0xF6, 0x75, 0x38, 0x04, 0x97, 0x0F, 0x07, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0xF6, 0xFD, 0x7C, 0x40, 0x6A, 0x3F, 0x14, 0xA2, - 0xCB, 0x04, 0x00, 0x00, 0x88, 0x2E, 0x44, 0x01, - 0x06, 0x82, 0x50, 0x04, 0xF6, 0x6D, 0x38, 0x44, - 0x2A, 0x07, 0xE4, 0x23, 0x7A, 0x7C, 0x34, 0x0C, - 0x26, 0x43, 0x50, 0x04, 0x6A, 0x3F, 0x14, 0xA2, - 0xCB, 0x04, 0x00, 0x00, 0x88, 0x2E, 0x44, 0x01, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0xCA, 0x47, 0x00, - 0xA6, 0xA3, 0x32, 0x34, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x02, 0x00, - 0x46, 0xA3, 0x51, 0x04, 0x01, 0x00, 0x01, 0x00, + 0xCB, 0x02, 0x00, 0x00, 0x88, 0x2E, 0x44, 0x01, + 0x06, 0x42, 0x51, 0x04, 0xF6, 0x6D, 0x38, 0x44, + 0x2A, 0x07, 0xEC, 0x23, 0x7A, 0x7C, 0x34, 0x0C, + 0x26, 0x03, 0x51, 0x04, 0x6A, 0x3F, 0x14, 0xA2, + 0xCB, 0x02, 0x00, 0x00, 0x88, 0x2E, 0x44, 0x01, + 0xCB, 0x00, 0x00, 0x00, 0x00, 0xDA, 0x47, 0x00, + 0xA6, 0x63, 0x2E, 0x34, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x02, 0x00, + 0x46, 0x63, 0x52, 0x04, 0x01, 0x00, 0x01, 0x00, 0x06, 0xD0, 0x38, 0x01, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x03, 0x00, - 0x46, 0xA3, 0x52, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x03, 0x00, + 0x46, 0x63, 0x53, 0x04, 0x01, 0x00, 0x01, 0x00, 0x06, 0x90, 0x7D, 0x03, 0x01, 0x00, 0x01, 0x00, - 0xA6, 0xA3, 0x32, 0x34, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x04, 0x00, - 0x46, 0xA3, 0x53, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0x88, 0x03, 0x01, 0x00, 0x01, 0x00, - 0xA6, 0xA3, 0x32, 0x34, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x05, 0x00, + 0xA6, 0x63, 0x2E, 0x34, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x04, 0x00, 0x46, 0x63, 0x54, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xD0, 0x94, 0x03, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x06, 0x00, + 0x06, 0xE0, 0xBD, 0x04, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0x63, 0x2E, 0x34, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x05, 0x00, 0x46, 0x23, 0x55, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x50, 0x98, 0x03, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x07, 0x00, + 0x06, 0xD0, 0x94, 0x03, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x06, 0x00, 0x46, 0xE3, 0x55, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x50, 0x98, 0x03, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x07, 0x00, + 0x46, 0xA3, 0x56, 0x04, 0x01, 0x00, 0x01, 0x00, 0x06, 0x50, 0x9A, 0x03, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x08, 0x00, - 0x46, 0xE3, 0x56, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xD0, 0x9B, 0x03, 0x01, 0x00, 0x01, 0x00, - 0xA6, 0xA3, 0x32, 0x34, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x00, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x08, 0x00, 0x46, 0xA3, 0x57, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE0, 0x61, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x7A, 0x06, 0x01, 0x00, - 0x46, 0x03, 0x45, 0x04, 0x2A, 0x0D, 0x32, 0x22, + 0x06, 0xD0, 0x9B, 0x03, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0x63, 0x2E, 0x34, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x00, 0x00, + 0x46, 0x63, 0x58, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x60, 0x63, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x43, 0x04, 0x7A, 0x06, 0x01, 0x00, + 0x46, 0x03, 0x43, 0x04, 0x2A, 0x0D, 0x32, 0x22, 0x7B, 0x0C, 0x0C, 0xC0, 0x4F, 0x2C, 0x00, 0x00, - 0xA6, 0xE2, 0x58, 0x04, 0xCB, 0x04, 0x40, 0x00, + 0xA6, 0xA2, 0x59, 0x04, 0xCB, 0x04, 0x40, 0x00, 0x00, 0x92, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x59, 0x04, 0xCB, 0x02, 0x80, 0x00, + 0x06, 0xE2, 0x59, 0x04, 0xCB, 0x02, 0x80, 0x00, 0x00, 0x92, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, 0x06, 0x90, 0x79, 0x03, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x02, 0x45, 0x04, 0x0A, 0x0A, 0x10, 0xA0, + 0x06, 0x02, 0x43, 0x04, 0x0A, 0x0A, 0x10, 0xA0, 0x4A, 0x04, 0x76, 0x28, 0xAB, 0x00, 0x00, 0xE0, 0x80, 0x14, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0x10, 0x85, 0x02, 0x0A, 0x0D, 0x08, 0x29, 0x0A, 0x1D, 0x06, 0x29, 0x5A, 0x0A, 0x00, 0x00, - 0x46, 0x63, 0x5B, 0x04, 0xCB, 0x00, 0x00, 0x00, + 0x46, 0x23, 0x5C, 0x04, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x16, 0x47, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xC2, 0x5B, 0x04, 0x2A, 0x05, 0x8A, 0x23, + 0x06, 0x82, 0x5C, 0x04, 0x2A, 0x05, 0x8A, 0x23, 0x9A, 0x08, 0x08, 0x00, 0x6A, 0x05, 0x8A, 0x23, 0x5A, 0x0A, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x5C, 0x04, 0xAB, 0x06, 0x00, 0x20, + 0x66, 0xA2, 0x5D, 0x04, 0xAB, 0x06, 0x00, 0x20, 0x60, 0x14, 0x00, 0x00, 0xCB, 0x3E, 0xFE, 0xFF, 0xFF, 0x93, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0xA5, 0x03, 0x2A, 0x0D, 0x32, 0x22, + 0x06, 0xE2, 0x5F, 0x04, 0x2A, 0x0D, 0x32, 0x22, 0x7B, 0x0C, 0x0C, 0xC0, 0x4F, 0x2C, 0x00, 0x00, - 0xA6, 0xE2, 0x5D, 0x04, 0xCB, 0x04, 0x40, 0x00, + 0xA6, 0xA2, 0x5E, 0x04, 0xCB, 0x04, 0x40, 0x00, 0x00, 0x92, 0x44, 0x01, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x5E, 0x04, 0xCB, 0x02, 0x80, 0x00, + 0x06, 0xE2, 0x5E, 0x04, 0xCB, 0x02, 0x80, 0x00, 0x00, 0x92, 0x44, 0x01, 0x2A, 0x3F, 0x8A, 0x23, - 0x0A, 0xED, 0x79, 0x28, 0x7B, 0x3A, 0x3C, 0x02, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x62, 0x60, 0x04, 0x7B, 0x3A, 0x3C, 0x08, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x62, 0x60, 0x04, 0x7B, 0x3A, 0x3C, 0x04, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x60, 0x04, 0x7B, 0x3A, 0x3C, 0x06, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x60, 0x04, 0x0F, 0x3B, 0x04, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x61, 0x04, 0x0F, 0x3B, 0x08, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x7A, 0x7C, 0x7C, 0x74, - 0x26, 0xE3, 0xA5, 0x03, 0xAB, 0x00, 0x02, 0x20, - 0x60, 0x14, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0xA5, 0x03, 0x2A, 0x01, 0x0E, 0x22, + 0x0F, 0x3B, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7A, 0x7C, 0x7C, 0x74, 0x01, 0x00, 0x01, 0x00, + 0x26, 0xE3, 0x5F, 0x04, 0xAB, 0x00, 0x02, 0x20, + 0x60, 0x14, 0x00, 0x00, 0x5A, 0x2A, 0x00, 0x00, + 0x46, 0x63, 0x60, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0xB1, 0x03, 0x0A, 0x0D, 0x00, 0x28, + 0x5A, 0x06, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0xBB, 0x03, 0x5A, 0x06, 0x01, 0x00, + 0x46, 0x23, 0xB0, 0x03, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x90, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, + 0xE6, 0x23, 0x62, 0x4C, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xD0, 0x76, 0x01, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0x62, 0x04, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0x91, 0x0B, 0x3B, 0x01, 0x00, 0x01, 0x00, + 0x66, 0xD1, 0x76, 0x39, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0xE1, 0xC1, 0x3C, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0xA3, 0xAA, 0x1B, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xA9, 0x03, 0x2A, 0x01, 0x0E, 0x22, 0x96, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x66, 0x72, 0x79, 0x03, 0x2A, 0x01, 0x58, 0x22, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x46, 0x23, 0x63, 0x04, 0xAB, 0x02, 0x00, 0x20, + 0x46, 0xA3, 0x64, 0x04, 0xAB, 0x02, 0x00, 0x20, 0x43, 0x05, 0x00, 0x00, 0x2A, 0x0D, 0x0E, 0x22, 0x17, 0x03, 0x03, 0x00, 0x00, 0x00, 0x78, 0x00, 0x7B, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x66, 0xE2, 0x64, 0x04, 0x7B, 0x3E, 0x0C, 0x00, + 0x66, 0x62, 0x66, 0x04, 0x7B, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x65, 0x04, 0x7B, 0x3E, 0x0C, 0x00, + 0x66, 0x62, 0x67, 0x04, 0x7B, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x40, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x66, 0x04, 0x0F, 0x2F, 0x03, 0x51, + 0x66, 0x62, 0x6A, 0x04, 0x0F, 0x2F, 0x03, 0x51, 0x04, 0x00, 0x00, 0x00, 0xCB, 0x4A, 0x00, 0x00, 0x00, 0x96, 0x44, 0x00, 0xCB, 0x7E, 0xB1, 0xE4, 0x17, 0x9B, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0x67, 0x04, 0x0F, 0x2F, 0x03, 0x71, + 0x06, 0x62, 0x6B, 0x04, 0x0F, 0x2F, 0x03, 0x71, 0x04, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x96, 0x44, 0x00, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0x9A, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0x67, 0x04, 0x0F, 0x2F, 0x03, 0x91, + 0x00, 0x9A, 0x44, 0x00, 0x2A, 0x0D, 0x32, 0x22, + 0x7B, 0x0E, 0x0C, 0xA0, 0xC4, 0x05, 0x00, 0x00, + 0x66, 0x62, 0x69, 0x04, 0x7B, 0x0E, 0x0C, 0xC0, + 0x43, 0x06, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0x69, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0x6B, 0x04, 0x0F, 0x2F, 0x03, 0x91, + 0x00, 0x00, 0x00, 0x00, 0xCB, 0x4A, 0x00, 0x00, + 0x00, 0x96, 0x44, 0x00, 0xCB, 0x7E, 0xB1, 0xE4, + 0x17, 0x9B, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0x6B, 0x04, 0x0F, 0x2F, 0x03, 0x91, 0x04, 0x00, 0x00, 0x00, 0xCB, 0x4A, 0x00, 0x00, 0x00, 0x96, 0x44, 0x00, 0xCB, 0x7E, 0xB1, 0xE4, 0x17, 0x9B, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0x67, 0x04, 0x0F, 0x31, 0x01, 0x00, + 0x06, 0x62, 0x6B, 0x04, 0x0F, 0x31, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x31, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x31, 0x1F, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x31, 0x1F, 0x00, @@ -488,274 +502,16 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0xC0, 0x9E, 0x45, 0x00, 0xCB, 0x86, 0xEC, 0x22, 0xC4, 0xA2, 0x45, 0x00, 0xCB, 0x86, 0xF4, 0x22, 0xCC, 0xA6, 0x45, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x77, 0x03, 0x0A, 0x0D, 0xE2, 0x29, - 0x0A, 0x1D, 0xE4, 0x29, 0x0A, 0x2D, 0xE6, 0x29, - 0x0F, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x5A, 0x4E, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x62, 0x7A, 0x04, 0x0A, 0x8D, 0xE8, 0x29, - 0x0A, 0x9D, 0x38, 0x2A, 0x76, 0x1C, 0x20, 0x04, - 0x1B, 0xAE, 0x06, 0x36, 0x23, 0x00, 0x00, 0x00, - 0x1B, 0xB0, 0x06, 0x36, 0x27, 0x00, 0x00, 0x00, - 0x1B, 0xB2, 0x10, 0x48, 0x29, 0x00, 0x00, 0x00, - 0x06, 0x82, 0x7B, 0x04, 0x0A, 0x8D, 0xEA, 0x29, - 0x0A, 0x9D, 0x42, 0x29, 0x76, 0x1C, 0x20, 0x04, - 0x1B, 0xAE, 0x06, 0x16, 0x23, 0x00, 0x00, 0x00, - 0x1B, 0xB0, 0x06, 0x16, 0x27, 0x00, 0x00, 0x00, - 0x1B, 0xB2, 0x10, 0x54, 0x29, 0x00, 0x00, 0x00, - 0x5A, 0x0C, 0x20, 0x24, 0x01, 0x00, 0x01, 0x00, - 0x86, 0xD2, 0xE7, 0x02, 0x2A, 0x14, 0x20, 0x03, - 0x2A, 0x16, 0x20, 0x03, 0x0A, 0xC5, 0x20, 0x06, - 0x96, 0xAD, 0xFF, 0x03, 0x7A, 0x0C, 0x34, 0x04, - 0x86, 0xD2, 0xE7, 0x02, 0xF6, 0x75, 0x28, 0x28, - 0x96, 0xEE, 0xFF, 0x03, 0x1A, 0x38, 0x34, 0x38, - 0x7A, 0x0C, 0x34, 0x00, 0x7A, 0x10, 0x04, 0x38, - 0xF6, 0x1D, 0x0C, 0x7C, 0xF6, 0x25, 0x10, 0x7C, - 0x76, 0x1C, 0x0C, 0x04, 0x36, 0x07, 0x03, 0x04, - 0xF6, 0x1D, 0x28, 0x50, 0x96, 0x33, 0x3F, 0x00, - 0x76, 0x34, 0x0C, 0x14, 0x1B, 0xAE, 0x06, 0x60, - 0x29, 0x00, 0x00, 0x00, 0x5A, 0x4E, 0x01, 0x00, - 0x66, 0xE2, 0x7F, 0x04, 0x0A, 0x35, 0x00, 0x02, - 0x5A, 0x72, 0x0F, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x86, 0xE2, 0x7F, 0x04, 0xB6, 0x66, 0x10, 0x00, - 0x96, 0x74, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xE3, 0x7F, 0x04, 0x9A, 0x0C, 0x0C, 0x00, - 0x4A, 0x1A, 0x00, 0x01, 0x5A, 0x52, 0x01, 0x00, - 0x66, 0xE2, 0xD6, 0x02, 0xF6, 0x1D, 0x2C, 0x38, - 0x96, 0x33, 0x0C, 0x00, 0x36, 0x06, 0x06, 0x03, - 0x5A, 0x72, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x22, 0x83, 0x04, 0x5A, 0x72, 0x04, 0x00, - 0x66, 0xA2, 0x81, 0x04, 0x5A, 0x72, 0x08, 0x00, - 0x66, 0xA2, 0xCB, 0x02, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xC8, 0x02, 0x0E, 0x17, 0x00, 0x00, - 0x0E, 0x3F, 0x02, 0x07, 0x0F, 0x21, 0x00, 0x00, - 0x5E, 0x00, 0x00, 0x00, 0xAE, 0x29, 0x3F, 0x0A, - 0x2E, 0xB7, 0xDD, 0x28, 0xCB, 0x00, 0x12, 0x20, - 0x00, 0xC2, 0x47, 0x01, 0xAB, 0x60, 0x09, 0x20, - 0x70, 0x14, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0xCE, 0x02, 0x0E, 0x17, 0x00, 0x00, - 0x0E, 0x3F, 0x00, 0x0D, 0x0F, 0x21, 0x00, 0x00, - 0x1E, 0x20, 0x00, 0x00, 0xAE, 0x29, 0x3F, 0x0A, - 0x2E, 0x37, 0xDE, 0x28, 0xAB, 0x68, 0x09, 0x20, - 0x70, 0x14, 0x00, 0x00, 0x8B, 0x6D, 0x88, 0x82, - 0xBA, 0x51, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x42, 0xD8, 0x02, 0x00, 0x00, 0x00, 0x00, - 0x6A, 0x00, 0x04, 0x03, 0x6A, 0x02, 0x04, 0x03, - 0x6A, 0x04, 0x04, 0x03, 0x6A, 0x06, 0x04, 0x03, - 0x6A, 0x08, 0x04, 0x03, 0x6A, 0x0A, 0x04, 0x03, - 0x6A, 0x0C, 0x04, 0x03, 0x6A, 0x0E, 0x04, 0x03, - 0x6A, 0x10, 0x04, 0x03, 0x6A, 0x12, 0x04, 0x03, - 0x6A, 0x14, 0x04, 0x03, 0x6A, 0x16, 0x04, 0x03, - 0x6A, 0x18, 0x04, 0x03, 0x6A, 0x1A, 0x04, 0x03, - 0x6A, 0x1C, 0x04, 0x03, 0x6A, 0x1E, 0x04, 0x03, - 0x6A, 0x20, 0x04, 0x03, 0x6A, 0x98, 0x04, 0x03, - 0x6A, 0xAE, 0x04, 0x03, 0x6A, 0xB0, 0x04, 0x03, - 0x6A, 0xB2, 0x04, 0x03, 0x6A, 0xB4, 0x04, 0x03, - 0x6A, 0xE4, 0x04, 0x03, 0x6A, 0xE6, 0x04, 0x03, - 0x6A, 0xE8, 0x04, 0x03, 0x6A, 0xEA, 0x04, 0x03, - 0x0A, 0x0C, 0x3E, 0x2A, 0x96, 0x01, 0x01, 0x00, - 0x66, 0x62, 0x9D, 0x04, 0x2A, 0x01, 0x5A, 0x23, - 0x96, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0x63, 0x9D, 0x04, 0x96, 0x01, 0x10, 0x00, - 0x46, 0x23, 0x9D, 0x04, 0x2A, 0x05, 0xD2, 0xA3, - 0x0A, 0x38, 0x88, 0xA3, 0x2A, 0x09, 0x46, 0x23, - 0x2A, 0x0B, 0x48, 0x23, 0x2A, 0x0D, 0x4A, 0x23, - 0x2A, 0x0F, 0x4C, 0x23, 0x2A, 0x11, 0x2E, 0x23, - 0x96, 0x22, 0xFF, 0xFF, 0x96, 0x09, 0xE0, 0x1F, - 0x76, 0x4C, 0x24, 0x4C, 0x96, 0x01, 0x00, 0x08, - 0x46, 0x63, 0x8B, 0x04, 0x1A, 0x18, 0x18, 0x08, - 0x1A, 0x1C, 0x1C, 0x0C, 0x6A, 0x0D, 0x4A, 0x23, - 0x6A, 0x0F, 0x4C, 0x23, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x8C, 0x04, 0x1A, 0x10, 0x10, 0x08, - 0x1A, 0x14, 0x14, 0x0C, 0x6A, 0x09, 0x46, 0x23, - 0x6A, 0x0B, 0x48, 0x23, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0x98, 0x04, 0x96, 0x02, 0x0C, 0x00, - 0x5A, 0x46, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x94, 0x04, 0x0A, 0xAD, 0xE6, 0x23, - 0x2A, 0x17, 0x4E, 0x23, 0x2A, 0x19, 0xDA, 0xA3, - 0x2A, 0x09, 0x50, 0x23, 0x2A, 0x0B, 0xD8, 0xA3, - 0x2A, 0x1B, 0x8C, 0xA3, 0xF6, 0x6D, 0x34, 0x34, - 0x96, 0xDD, 0x10, 0x00, 0x17, 0x07, 0xC9, 0xF7, - 0xFF, 0xFF, 0x7F, 0x00, 0x36, 0x92, 0x0E, 0x0D, - 0x7A, 0x08, 0x14, 0x10, 0x7A, 0x0C, 0x30, 0x2C, - 0x66, 0x22, 0x9D, 0x04, 0x8B, 0xDC, 0x9D, 0xA2, - 0x1F, 0x05, 0x00, 0x00, 0x0A, 0xDD, 0x04, 0x28, - 0x97, 0x86, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x23, 0x9D, 0x04, 0x8B, 0xDC, 0x9D, 0xE2, - 0x7C, 0x04, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0x1A, 0x47, 0x00, 0x2A, 0x03, 0x64, 0x22, - 0x2A, 0x09, 0x84, 0x23, 0x17, 0x80, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xE2, 0x91, 0x04, 0x7A, 0x00, 0x08, 0x0C, - 0x46, 0x23, 0x91, 0x04, 0xF6, 0x0D, 0x04, 0x60, - 0x96, 0x11, 0x7F, 0x00, 0x3A, 0x10, 0x10, 0x04, - 0x06, 0xC2, 0x91, 0x04, 0xBA, 0x10, 0x10, 0x00, - 0x17, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x66, 0xC2, 0x91, 0x04, 0x0E, 0x13, 0x00, 0x00, - 0x6A, 0x09, 0x84, 0x23, 0x6A, 0x0B, 0x50, 0x23, - 0x6A, 0x19, 0x4E, 0x23, 0x96, 0x81, 0x10, 0x00, - 0x66, 0x22, 0x9D, 0x04, 0x0A, 0x1C, 0xFE, 0xA3, - 0x96, 0x11, 0x04, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0x23, 0x93, 0x04, 0x0F, 0x05, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x7A, 0x0C, 0x0C, 0x08, - 0xBF, 0x0E, 0x0C, 0xBC, 0x00, 0x00, 0x00, 0x00, - 0x4E, 0x0C, 0x28, 0x00, 0xB6, 0x99, 0x02, 0x00, - 0x6A, 0x07, 0x14, 0xA2, 0x6A, 0x13, 0x16, 0xA2, - 0x2A, 0x13, 0xE4, 0x23, 0x97, 0x81, 0x81, 0xFF, - 0x7F, 0x00, 0x00, 0x00, 0x3A, 0x24, 0x24, 0x0C, - 0x6A, 0x13, 0xE4, 0x23, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x9D, 0x04, 0x0A, 0xAD, 0xE6, 0x23, - 0x0A, 0xCD, 0xDE, 0x29, 0x3A, 0x30, 0x30, 0x0C, - 0x4A, 0x64, 0xDE, 0x29, 0x8B, 0xE4, 0x9D, 0xA2, - 0x1F, 0x05, 0x00, 0x00, 0x0A, 0xDD, 0x04, 0x28, - 0x97, 0x86, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x23, 0x9D, 0x04, 0x8B, 0xE4, 0x9D, 0xE2, - 0x7C, 0x04, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xE0, - 0x3B, 0x05, 0x00, 0x00, 0x96, 0x81, 0x08, 0x00, - 0x66, 0x22, 0x9D, 0x04, 0xF6, 0x1D, 0x30, 0x08, - 0x4E, 0x0C, 0x28, 0x00, 0xB6, 0x99, 0x02, 0x00, - 0x6A, 0x07, 0x14, 0xA2, 0x6A, 0x13, 0x16, 0xA2, - 0x2A, 0x13, 0xE4, 0x23, 0x97, 0x81, 0x81, 0xFF, - 0x7F, 0x00, 0x00, 0x00, 0x3A, 0x24, 0x24, 0x0C, - 0x6A, 0x13, 0xE4, 0x23, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x9D, 0x04, 0x0A, 0xAD, 0xE8, 0x29, - 0x0A, 0xBD, 0x38, 0x2A, 0x0A, 0xCD, 0xF8, 0x28, - 0x0A, 0xDD, 0xFA, 0x28, 0x1A, 0x34, 0x34, 0x0C, - 0x4A, 0x6C, 0xFA, 0x28, 0x8B, 0xE4, 0x9D, 0xE2, - 0x1E, 0x05, 0x00, 0x00, 0x5A, 0x04, 0x28, 0x2C, - 0x46, 0x23, 0x9D, 0x04, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0xF6, 0x51, 0x00, 0x8B, 0xE4, 0x9D, 0x22, - 0x1F, 0x05, 0x00, 0x00, 0x2A, 0x01, 0xE2, 0x23, - 0x7A, 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x22, 0x9C, 0x04, 0x0A, 0x0D, 0xD8, 0x28, - 0x7A, 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xE3, 0x9B, 0x04, 0x37, 0x49, 0x49, 0x00, - 0x08, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00, - 0x00, 0xC6, 0x47, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0x9C, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x90, 0xB8, 0x04, 0x96, 0x81, 0x04, 0x00, - 0x66, 0x22, 0x9D, 0x04, 0xF6, 0x1D, 0x34, 0x08, - 0x9A, 0x0C, 0x0C, 0x00, 0x4E, 0x0C, 0x30, 0x00, - 0xB6, 0x99, 0x01, 0x00, 0x6A, 0x07, 0x14, 0xA2, - 0x6A, 0x13, 0x16, 0xA2, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x20, 0x78, 0x04, 0x2A, 0xEA, 0x04, 0xFF, - 0x2A, 0xE8, 0x04, 0xFF, 0x2A, 0xE6, 0x04, 0xFF, - 0x2A, 0xE4, 0x04, 0xFF, 0x2A, 0xB4, 0x04, 0xFF, - 0x2A, 0xB2, 0x04, 0xFF, 0x2A, 0xB0, 0x04, 0xFF, - 0x2A, 0xAE, 0x04, 0xFF, 0x2A, 0x98, 0x04, 0xFF, - 0x2A, 0x20, 0x04, 0xFF, 0x2A, 0x1E, 0x04, 0xFF, - 0x2A, 0x1C, 0x04, 0xFF, 0x2A, 0x1A, 0x04, 0xFF, - 0x2A, 0x18, 0x04, 0xFF, 0x2A, 0x16, 0x04, 0xFF, - 0x2A, 0x14, 0x04, 0xFF, 0x2A, 0x12, 0x04, 0xFF, - 0x2A, 0x10, 0x04, 0xFF, 0x2A, 0x0E, 0x04, 0xFF, - 0x2A, 0x0C, 0x04, 0xFF, 0x2A, 0x0A, 0x04, 0xFF, - 0x2A, 0x08, 0x04, 0xFF, 0x2A, 0x06, 0x04, 0xFF, - 0x2A, 0x04, 0x04, 0xFF, 0x2A, 0x02, 0x04, 0xFF, - 0x2A, 0x00, 0x04, 0xFF, 0x01, 0x00, 0x01, 0x00, - 0x25, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x6A, 0x00, 0x04, 0x03, 0x6A, 0x02, 0x04, 0x03, - 0x6A, 0x04, 0x04, 0x03, 0x6A, 0x06, 0x04, 0x03, - 0x6A, 0x08, 0x04, 0x03, 0x6A, 0x0A, 0x04, 0x03, - 0x6A, 0x0C, 0x04, 0x03, 0x6A, 0x0E, 0x04, 0x03, - 0x6A, 0x10, 0x04, 0x03, 0x6A, 0x12, 0x04, 0x03, - 0x6A, 0x14, 0x04, 0x03, 0x6A, 0x16, 0x04, 0x03, - 0x6A, 0x18, 0x04, 0x03, 0x6A, 0x1A, 0x04, 0x03, - 0x6A, 0x1C, 0x04, 0x03, 0x6A, 0x1E, 0x04, 0x03, - 0x6A, 0x20, 0x04, 0x03, 0x6A, 0x98, 0x04, 0x03, - 0x6A, 0xAE, 0x04, 0x03, 0x6A, 0xB0, 0x04, 0x03, - 0x6A, 0xB2, 0x04, 0x03, 0x6A, 0xB4, 0x04, 0x03, - 0x6A, 0xE4, 0x04, 0x03, 0x6A, 0xE6, 0x04, 0x03, - 0x6A, 0xE8, 0x04, 0x03, 0x6A, 0xEA, 0x04, 0x03, - 0x2A, 0x03, 0x0E, 0x22, 0x0A, 0x2C, 0x06, 0x29, - 0x2A, 0x07, 0x64, 0xA0, 0x96, 0x15, 0x02, 0x00, - 0x66, 0x42, 0xA5, 0x04, 0x96, 0x25, 0x02, 0x00, - 0x46, 0x43, 0xA5, 0x04, 0x2A, 0x07, 0x5C, 0xA0, - 0x96, 0x35, 0x07, 0x00, 0x96, 0x34, 0x00, 0xF8, - 0xF6, 0x25, 0x10, 0x20, 0x35, 0x94, 0x4A, 0x06, - 0x3A, 0x2A, 0x7A, 0x1E, 0x01, 0x00, 0x01, 0x00, - 0x66, 0xA2, 0xA9, 0x04, 0x2A, 0x0D, 0x68, 0xA0, - 0x2A, 0x09, 0x60, 0xA0, 0x2A, 0x0B, 0x5C, 0xA0, - 0x2A, 0x0F, 0x64, 0xA0, 0x17, 0x03, 0x03, 0x00, - 0x00, 0x00, 0x30, 0x00, 0xF6, 0x25, 0x10, 0x50, - 0xF6, 0x2D, 0x14, 0x50, 0xF6, 0x3D, 0x1C, 0x50, - 0x96, 0x44, 0xFF, 0x00, 0x96, 0x55, 0xFF, 0x00, - 0x96, 0x77, 0xFF, 0x00, 0x96, 0x18, 0x02, 0x00, - 0x66, 0x62, 0xA8, 0x04, 0x96, 0x28, 0x02, 0x00, - 0x46, 0x63, 0xA8, 0x04, 0x0E, 0x19, 0x14, 0x00, - 0x06, 0x62, 0xA9, 0x04, 0x7B, 0x10, 0x0C, 0x00, - 0x00, 0x00, 0xC0, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x22, 0xA9, 0x04, 0x0E, 0x19, 0x1C, 0x00, - 0x06, 0x62, 0xA9, 0x04, 0x3A, 0x18, 0x10, 0x14, - 0x76, 0x36, 0x18, 0x04, 0x4A, 0x36, 0x1A, 0x2A, - 0x06, 0xE2, 0xA9, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0x2C, 0x03, 0x0A, 0x0C, 0x3A, 0x2A, - 0x97, 0x83, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, - 0x46, 0x23, 0xAB, 0x04, 0x9A, 0x14, 0x00, 0x00, - 0x96, 0x55, 0x07, 0x00, 0xAB, 0x00, 0x00, 0xA0, - 0x1E, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x82, 0xAB, 0x04, 0x0E, 0x17, 0x01, 0x00, - 0xAB, 0x02, 0x00, 0xA0, 0x1E, 0x05, 0x00, 0x00, - 0x06, 0x10, 0x40, 0x03, 0x4A, 0x2C, 0x42, 0xA0, - 0x2A, 0x0D, 0x40, 0xA0, 0x97, 0x03, 0x03, 0x00, - 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x22, 0xB5, 0x04, 0x0A, 0x7D, 0x3A, 0x2A, - 0x0A, 0x1D, 0x26, 0x2A, 0x0A, 0x2D, 0x28, 0x2A, - 0x0A, 0x3D, 0x2A, 0x2A, 0x5A, 0x10, 0x1C, 0x04, - 0xE6, 0xE2, 0xB0, 0x04, 0x5A, 0x00, 0x1C, 0x04, - 0xBA, 0x00, 0x00, 0x00, 0x9A, 0x08, 0x08, 0x00, - 0x3F, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, - 0xBF, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, - 0x5A, 0x10, 0x00, 0x10, 0x5A, 0x86, 0x00, 0x00, - 0x46, 0x23, 0xB0, 0x04, 0x2A, 0x0B, 0x4A, 0x23, - 0x2A, 0x0D, 0x4C, 0x23, 0x76, 0x2C, 0x14, 0x34, - 0x3F, 0x14, 0x14, 0x18, 0x00, 0x00, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x60, 0x3D, 0x05, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x60, 0x6F, 0x14, 0x00, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x96, 0x46, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x9A, 0x46, 0x00, - 0x6A, 0x0B, 0x54, 0x23, 0xBF, 0x00, 0x10, 0x0C, - 0x00, 0x00, 0x00, 0x00, 0x1A, 0x04, 0x00, 0x0C, - 0x0E, 0x0B, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0xB3, 0x04, 0x5A, 0xE2, 0x02, 0x00, - 0x5A, 0x06, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xE3, 0xB2, 0x04, 0x2A, 0x0B, 0x46, 0x23, - 0x2A, 0x0D, 0x48, 0x23, 0x76, 0x2C, 0x14, 0x34, - 0x3F, 0x14, 0x14, 0x18, 0x00, 0x00, 0x00, 0x00, - 0xAB, 0x00, 0x00, 0x20, 0x3D, 0x05, 0x00, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x46, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0x92, 0x46, 0x00, - 0x6A, 0x0B, 0x52, 0x23, 0xBF, 0x00, 0x00, 0x0C, - 0x00, 0x00, 0x00, 0x00, 0x1A, 0x04, 0x00, 0x0C, - 0x0E, 0x0B, 0x01, 0x00, 0x4A, 0x06, 0xE2, 0x29, - 0x4A, 0x0E, 0xE4, 0x29, 0x4A, 0x16, 0xE6, 0x29, - 0x5B, 0x08, 0x0E, 0x02, 0x00, 0x00, 0x00, 0x00, - 0x46, 0xA3, 0xB4, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0x9A, 0x02, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x22, 0xB5, 0x04, 0xAB, 0x02, 0x00, 0xE0, - 0x47, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x20, 0x78, 0x04, 0x2A, 0xEA, 0x04, 0xFF, - 0x2A, 0xE8, 0x04, 0xFF, 0x2A, 0xE6, 0x04, 0xFF, - 0x2A, 0xE4, 0x04, 0xFF, 0x2A, 0xB4, 0x04, 0xFF, - 0x2A, 0xB2, 0x04, 0xFF, 0x2A, 0xB0, 0x04, 0xFF, - 0x2A, 0xAE, 0x04, 0xFF, 0x2A, 0x98, 0x04, 0xFF, - 0x2A, 0x20, 0x04, 0xFF, 0x2A, 0x1E, 0x04, 0xFF, - 0x2A, 0x1C, 0x04, 0xFF, 0x2A, 0x1A, 0x04, 0xFF, - 0x2A, 0x18, 0x04, 0xFF, 0x2A, 0x16, 0x04, 0xFF, - 0x2A, 0x14, 0x04, 0xFF, 0x2A, 0x12, 0x04, 0xFF, - 0x2A, 0x10, 0x04, 0xFF, 0x2A, 0x0E, 0x04, 0xFF, - 0x2A, 0x0C, 0x04, 0xFF, 0x2A, 0x0A, 0x04, 0xFF, - 0x2A, 0x08, 0x04, 0xFF, 0x2A, 0x06, 0x04, 0xFF, - 0x2A, 0x04, 0x04, 0xFF, 0x2A, 0x02, 0x04, 0xFF, - 0x2A, 0x00, 0x04, 0xFF, 0x01, 0x00, 0x01, 0x00, - 0x25, 0x04, 0x0A, 0x08, 0x7A, 0xA7, 0x17, 0x00, - 0x80, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x07, - 0x00, 0x00, 0x0A, 0xF8, 0x7E, 0xA3, 0x7A, 0x38, - 0x00, 0x04, 0x76, 0x78, 0x78, 0x70, 0x97, 0x87, - 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x01, 0x00, - 0x46, 0x53, 0xD2, 0x04, 0x2A, 0x15, 0x18, 0xA2, + 0x06, 0x22, 0x77, 0x03, 0x0A, 0x08, 0x7A, 0xA7, + 0x17, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x00, + 0x0E, 0x07, 0x00, 0x00, 0x0A, 0xF8, 0x7E, 0xA3, + 0x7A, 0x38, 0x00, 0x04, 0x76, 0x78, 0x78, 0x70, + 0x97, 0x87, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, + 0x46, 0x53, 0x97, 0x04, 0x2A, 0x15, 0x18, 0xA2, 0xF6, 0x5D, 0x28, 0x40, 0x9A, 0x2C, 0x2C, 0x00, 0x96, 0xAA, 0xFF, 0xFF, 0x76, 0x74, 0x04, 0x0C, 0x3A, 0x38, 0x30, 0x38, 0x7A, 0x3C, 0x38, 0x2C, - 0x26, 0x03, 0xBB, 0x04, 0x3A, 0x38, 0x3C, 0x28, + 0x26, 0x03, 0x7E, 0x04, 0x3A, 0x38, 0x3C, 0x28, 0x76, 0x74, 0x38, 0x08, 0x1B, 0x1C, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x01, 0xCB, 0x20, 0x01, 0x00, 0x00, 0x42, 0x44, 0x01, 0x6A, 0x1D, 0x22, 0xA2, @@ -768,74 +524,82 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x2A, 0x1F, 0x26, 0xA2, 0x96, 0xFF, 0x80, 0x00, 0x01, 0x00, - 0x46, 0xB3, 0xBD, 0x04, 0x8B, 0xA5, 0x88, 0x82, - 0xCA, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, + 0x46, 0xB3, 0x80, 0x04, 0x8B, 0xA5, 0x88, 0x82, 0xCB, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, 0xCC, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, 0xCD, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, 0xCE, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, 0xCF, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, 0xD0, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, - 0xD1, 0x11, 0x00, 0x00, 0x0F, 0x07, 0x00, 0x00, + 0xD1, 0x11, 0x00, 0x00, 0x8B, 0xA5, 0x88, 0x82, + 0xD2, 0x11, 0x00, 0x00, 0x0F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, 0x1E, 0x06, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x86, 0x52, 0xD2, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0xD3, 0x04, 0x7B, 0x1E, 0x08, 0xFE, + 0x86, 0x52, 0x97, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x10, 0x98, 0x04, 0x7B, 0x1E, 0x08, 0xFE, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x52, 0xD2, 0x04, 0x96, 0x45, 0xE0, 0x00, - 0x96, 0x46, 0x1F, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0xD3, 0x04, 0x96, 0x4F, 0x1F, 0x00, + 0x66, 0x52, 0x97, 0x04, 0x7B, 0x1E, 0x08, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x52, 0x97, 0x04, 0x96, 0x45, 0xE0, 0x00, + 0x96, 0x46, 0x1F, 0x00, 0x7B, 0x1E, 0x0C, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x52, 0x97, 0x04, 0x7B, 0x1E, 0x0C, 0x3A, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0x52, 0x97, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x10, 0x98, 0x04, 0x96, 0x4F, 0x1F, 0x00, 0x36, 0x05, 0x05, 0x0F, 0x7B, 0x1E, 0x0A, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x62, 0xC3, 0x04, 0x3A, 0x0C, 0x0C, 0x18, + 0x66, 0xE2, 0x87, 0x04, 0x3A, 0x0C, 0x0C, 0x18, 0xBA, 0x0C, 0x0C, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0xC0, 0x04, 0x3A, 0x18, 0x18, 0x0C, - 0x7A, 0xDA, 0x01, 0x00, 0x7A, 0x3C, 0x0C, 0x18, - 0xE6, 0x22, 0xC4, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x62, 0xC0, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0xD3, 0x04, 0x96, 0x4A, 0xFC, 0x00, + 0x06, 0x62, 0x83, 0x04, 0x3A, 0x18, 0x18, 0x0C, + 0x7A, 0xDA, 0x01, 0x00, 0x7B, 0x1E, 0x06, 0x40, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x86, 0x52, 0x97, 0x04, 0x7A, 0x3C, 0x0C, 0x18, + 0x26, 0x23, 0x89, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0x83, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x10, 0x98, 0x04, 0x96, 0x4A, 0xFC, 0x00, 0xF6, 0x55, 0x28, 0x08, 0x96, 0x4B, 0x03, 0x00, 0x76, 0x5C, 0x2C, 0x20, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0xD3, 0x04, 0x36, 0x0B, 0x0B, 0x04, - 0x06, 0x10, 0xD3, 0x04, 0x0E, 0x15, 0x10, 0x00, + 0x06, 0x10, 0x98, 0x04, 0x36, 0x0B, 0x0B, 0x04, + 0x06, 0x10, 0x98, 0x04, 0x0E, 0x15, 0x10, 0x00, 0x96, 0x5F, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x42, 0xC6, 0x04, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x10, 0xD3, 0x04, 0x0E, 0x25, 0x10, 0x00, + 0x66, 0x42, 0x8B, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x10, 0x98, 0x04, 0x0E, 0x25, 0x10, 0x00, 0x2A, 0x1F, 0x18, 0x22, 0x97, 0x87, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xF6, 0x7D, 0x3C, 0x50, 0x7A, 0x3C, 0x3C, 0x28, 0x01, 0x00, 0x01, 0x00, - 0x46, 0xA3, 0xC3, 0x04, 0x96, 0x5F, 0x80, 0x00, - 0x66, 0xE2, 0xCD, 0x04, 0x0E, 0x2B, 0x01, 0x00, + 0x46, 0x23, 0x88, 0x04, 0x96, 0x5F, 0x80, 0x00, + 0x66, 0xE2, 0x92, 0x04, 0x0E, 0x2B, 0x01, 0x00, 0x96, 0x51, 0x1C, 0x00, 0xF6, 0x0D, 0x04, 0x08, 0x96, 0x54, 0x03, 0x00, 0x76, 0x24, 0x10, 0x20, 0x36, 0x04, 0x04, 0x09, 0x7A, 0x2A, 0x00, 0x00, - 0x66, 0x62, 0xCA, 0x04, 0x7A, 0x2A, 0x01, 0x00, - 0x66, 0xE2, 0xCA, 0x04, 0x7A, 0x2A, 0x02, 0x00, - 0x66, 0x62, 0xCB, 0x04, 0x7A, 0x2A, 0x03, 0x00, - 0x66, 0x62, 0xCB, 0x04, 0x7A, 0x2A, 0x04, 0x00, - 0x66, 0x62, 0xCC, 0x04, 0x7A, 0x2A, 0x05, 0x00, - 0x66, 0xE2, 0xCC, 0x04, 0x7A, 0x2A, 0x06, 0x00, - 0x66, 0x62, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x3C, + 0x66, 0x62, 0x8F, 0x04, 0x7A, 0x2A, 0x01, 0x00, + 0x66, 0xE2, 0x8F, 0x04, 0x7A, 0x2A, 0x02, 0x00, + 0x66, 0x62, 0x90, 0x04, 0x7A, 0x2A, 0x03, 0x00, + 0x66, 0x62, 0x90, 0x04, 0x7A, 0x2A, 0x04, 0x00, + 0x66, 0x62, 0x91, 0x04, 0x7A, 0x2A, 0x05, 0x00, + 0x66, 0xE2, 0x91, 0x04, 0x7A, 0x2A, 0x06, 0x00, + 0x66, 0x62, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x30, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x30, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x20, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x18, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x18, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x10, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x6C, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x54, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x54, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xA2, 0xCD, 0x04, 0x3F, 0x0E, 0x10, 0x48, + 0x06, 0xA2, 0x92, 0x04, 0x3F, 0x0E, 0x10, 0x48, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x06, 0x42, 0xD0, 0x04, 0x0E, 0x2B, 0x00, 0x00, + 0x06, 0x42, 0x95, 0x04, 0x0E, 0x2B, 0x00, 0x00, 0x96, 0x50, 0x3E, 0x00, 0x96, 0x52, 0x01, 0x00, 0x76, 0x14, 0x08, 0x10, 0xF6, 0x05, 0x00, 0x04, - 0x1B, 0xAE, 0x00, 0xA2, 0x23, 0x00, 0x00, 0x00, - 0x1B, 0xB0, 0x00, 0xA2, 0x27, 0x00, 0x00, 0x00, + 0x1B, 0xAE, 0x00, 0xA6, 0x23, 0x00, 0x00, 0x00, + 0x1B, 0xB0, 0x00, 0xA6, 0x27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x2A, 0x1C, 0x20, 0x03, 0xF6, 0x71, 0x70, 0x10, 0x96, 0xE4, 0x80, 0xFF, @@ -848,13 +612,13 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x36, 0x0E, 0x0E, 0x00, 0x36, 0x0F, 0x0F, 0x02, 0x6A, 0x1D, 0x18, 0x22, 0x6A, 0x1F, 0x1A, 0x22, 0x37, 0x49, 0x49, 0x00, 0x08, 0x00, 0x00, 0x00, - 0xCB, 0x00, 0x00, 0x00, 0x00, 0xC6, 0x47, 0x00, + 0xCB, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x47, 0x00, 0x05, 0x04, 0x9A, 0x04, 0x04, 0x00, 0x7A, 0x40, 0x04, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x26, 0x13, 0xB9, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x26, 0x23, 0x7C, 0x04, 0x01, 0x00, 0x01, 0x00, 0x05, 0x04, 0xF6, 0x75, 0x0C, 0x08, 0x1B, 0xAE, - 0x1C, 0x94, 0x23, 0x00, 0x00, 0x00, 0x1B, 0xB0, - 0x1C, 0x94, 0x27, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x1C, 0x96, 0x23, 0x00, 0x00, 0x00, 0x1B, 0xB0, + 0x1C, 0x96, 0x27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x2A, 0x1C, 0x20, 0x03, 0x96, 0x3F, 0x03, 0x00, 0x76, 0x7C, 0x3C, 0x0C, 0xF6, 0x21, @@ -874,44 +638,17 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x80, 0x03, 0x00, 0x00, 0xF6, 0x1D, 0x0C, 0x50, 0xF6, 0x25, 0x10, 0x4C, 0xF6, 0x2D, 0x14, 0x40, 0x0F, 0x0D, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x7A, 0x22, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x66, 0x62, 0xDD, 0x04, 0x7A, 0x22, 0x00, 0x08, - 0x66, 0x22, 0x1D, 0x02, 0x7A, 0x22, 0x00, 0x10, - 0x66, 0xD2, 0x39, 0x02, 0x7A, 0x22, 0x00, 0x18, - 0x66, 0x12, 0x3D, 0x02, 0x7A, 0x22, 0x00, 0x20, - 0x66, 0x22, 0x44, 0x02, 0x7A, 0x22, 0x00, 0x30, - 0x66, 0xA2, 0x49, 0x02, 0x7A, 0x22, 0x00, 0x38, - 0x66, 0xA2, 0x4D, 0x02, 0x7A, 0x22, 0x00, 0x50, - 0x66, 0x22, 0x4F, 0x02, 0x7A, 0x22, 0x00, 0x58, - 0x66, 0x62, 0x51, 0x02, 0x7A, 0x22, 0x00, 0x60, - 0x66, 0x22, 0x58, 0x02, 0x7A, 0x22, 0x00, 0x70, - 0x66, 0x22, 0x5E, 0x02, 0x7A, 0x22, 0x00, 0x78, - 0x66, 0x62, 0x60, 0x02, 0x7A, 0x22, 0x00, 0x80, - 0x66, 0xE2, 0x66, 0x02, 0x7A, 0x22, 0x00, 0x98, - 0x66, 0x52, 0xE1, 0x04, 0x7A, 0x22, 0x00, 0xB0, - 0x66, 0x12, 0x75, 0x02, 0x7A, 0x22, 0x00, 0xB8, - 0x66, 0x22, 0x79, 0x02, 0x7A, 0x22, 0x00, 0xC0, - 0x66, 0x22, 0x7E, 0x02, 0x7A, 0x22, 0x00, 0xF8, - 0x66, 0xE2, 0x80, 0x02, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0x83, 0x02, 0x7A, 0x42, 0x00, 0x00, - 0x66, 0xA2, 0x0D, 0x02, 0x7A, 0x42, 0x01, 0x00, - 0x66, 0x52, 0x0E, 0x02, 0x7A, 0x42, 0x02, 0x00, - 0x66, 0xE2, 0x0F, 0x02, 0x7A, 0x42, 0x0C, 0x00, - 0x66, 0xA2, 0xE0, 0x04, 0x7A, 0x42, 0x0D, 0x00, - 0x66, 0x92, 0x11, 0x02, 0x7A, 0x42, 0x0F, 0x00, - 0x66, 0x12, 0x12, 0x02, 0x7A, 0x42, 0x10, 0x00, - 0x66, 0x92, 0x12, 0x02, 0x7A, 0x42, 0x11, 0x00, - 0x66, 0xE2, 0x14, 0x02, 0x7A, 0x42, 0x12, 0x00, - 0x66, 0x62, 0x17, 0x02, 0x7A, 0x42, 0x20, 0x00, - 0x66, 0x22, 0x1B, 0x02, 0x7A, 0x42, 0x21, 0x00, - 0x66, 0x92, 0x1B, 0x02, 0x7A, 0x42, 0xFF, 0x00, - 0x66, 0x12, 0x1C, 0x02, 0x01, 0x00, 0x01, 0x00, - 0x06, 0xE2, 0x83, 0x02, 0x2A, 0x0F, 0x00, 0xA2, + 0x7A, 0x3E, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0x9E, 0x04, 0x7A, 0x3E, 0x00, 0x98, + 0x66, 0x92, 0x9F, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0x03, 0x02, 0x7A, 0x5E, 0x0C, 0x00, + 0x66, 0xE2, 0x9E, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0x03, 0x02, 0x2A, 0x0F, 0x00, 0xA2, 0x4A, 0x3C, 0xD8, 0x28, 0x4A, 0x3D, 0xEA, 0x28, - 0xCB, 0x02, 0x00, 0x00, 0x00, 0xC6, 0x47, 0x00, - 0x05, 0x04, 0x7A, 0x42, 0x00, 0x00, 0x01, 0x00, - 0x66, 0x22, 0xE2, 0x04, 0x7A, 0x42, 0x01, 0x00, - 0x66, 0x52, 0xE4, 0x04, 0x01, 0x00, 0x01, 0x00, + 0xCB, 0x02, 0x00, 0x00, 0x00, 0xCE, 0x47, 0x00, + 0x05, 0x04, 0x7A, 0x5E, 0x00, 0x00, 0x01, 0x00, + 0x66, 0x62, 0xA0, 0x04, 0x7A, 0x5E, 0x01, 0x00, + 0x66, 0x92, 0xA2, 0x04, 0x01, 0x00, 0x01, 0x00, 0x06, 0xE2, 0x83, 0x02, 0x2A, 0x0F, 0x00, 0xA2, 0x2A, 0x11, 0x00, 0xA2, 0x97, 0x83, 0x03, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x17, 0x04, 0x04, 0x00, @@ -929,10 +666,346 @@ unsigned char TCC317X_BOOT_DATA_TDMB[TCC317X_BOOT_SIZE_TDMB] = { 0x00, 0x00, 0x8B, 0x05, 0x88, 0x82, 0x17, 0x11, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1F, 0x0C, 0x47, 0x33, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x6A, 0x00, 0x04, 0x03, 0x6A, 0x02, 0x04, 0x03, + 0x6A, 0x04, 0x04, 0x03, 0x6A, 0x06, 0x04, 0x03, + 0x6A, 0x08, 0x04, 0x03, 0x6A, 0x0A, 0x04, 0x03, + 0x6A, 0x0C, 0x04, 0x03, 0x6A, 0x0E, 0x04, 0x03, + 0x6A, 0x10, 0x04, 0x03, 0x6A, 0x12, 0x04, 0x03, + 0x6A, 0x14, 0x04, 0x03, 0x6A, 0x16, 0x04, 0x03, + 0x6A, 0x18, 0x04, 0x03, 0x6A, 0x1A, 0x04, 0x03, + 0x6A, 0x1C, 0x04, 0x03, 0x6A, 0x1E, 0x04, 0x03, + 0x6A, 0x20, 0x04, 0x03, 0x6A, 0x98, 0x04, 0x03, + 0x6A, 0xAE, 0x04, 0x03, 0x6A, 0xB0, 0x04, 0x03, + 0x6A, 0xB2, 0x04, 0x03, 0x6A, 0xB4, 0x04, 0x03, + 0x6A, 0xE4, 0x04, 0x03, 0x6A, 0xE6, 0x04, 0x03, + 0x6A, 0xE8, 0x04, 0x03, 0x6A, 0xEA, 0x04, 0x03, + 0x0A, 0x0C, 0x3E, 0x2A, 0x96, 0x01, 0x01, 0x00, + 0x66, 0xE2, 0x59, 0x00, 0x2A, 0x01, 0x5A, 0x23, + 0x96, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xE3, 0x59, 0x00, 0x96, 0x01, 0x10, 0x00, + 0x46, 0x63, 0xBD, 0x04, 0x2A, 0x05, 0xD2, 0xA3, + 0x0A, 0x38, 0x88, 0xA3, 0x2A, 0x09, 0x46, 0x23, + 0x2A, 0x0B, 0x48, 0x23, 0x2A, 0x0D, 0x4A, 0x23, + 0x2A, 0x0F, 0x4C, 0x23, 0x2A, 0x11, 0x2E, 0x23, + 0x96, 0x22, 0xFF, 0xFF, 0x96, 0x09, 0xE0, 0x1F, + 0x76, 0x4C, 0x24, 0x4C, 0x96, 0x01, 0x00, 0x08, + 0x46, 0xA3, 0xAC, 0x04, 0x1A, 0x18, 0x18, 0x08, + 0x1A, 0x1C, 0x1C, 0x0C, 0x6A, 0x0D, 0x4A, 0x23, + 0x6A, 0x0F, 0x4C, 0x23, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0xAD, 0x04, 0x1A, 0x10, 0x10, 0x08, + 0x1A, 0x14, 0x14, 0x0C, 0x6A, 0x09, 0x46, 0x23, + 0x6A, 0x0B, 0x48, 0x23, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xA2, 0xB8, 0x04, 0x96, 0x02, 0x0C, 0x00, + 0x5A, 0x46, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0xA2, 0xB5, 0x04, 0x0A, 0xAD, 0xF8, 0x28, + 0x2A, 0x17, 0x4E, 0x23, 0x2A, 0x19, 0xDA, 0xA3, + 0x2A, 0x09, 0x50, 0x23, 0x2A, 0x0B, 0xD8, 0xA3, + 0x2A, 0x1B, 0x8C, 0xA3, 0xF6, 0x6D, 0x34, 0x34, + 0x96, 0xDD, 0x10, 0x00, 0x17, 0x07, 0xC9, 0xF7, + 0xFF, 0xFF, 0x7F, 0x00, 0x36, 0x92, 0x0E, 0x0D, + 0x7A, 0x08, 0x14, 0x10, 0x7A, 0x0C, 0x30, 0x2C, + 0x66, 0x62, 0xBD, 0x04, 0x8B, 0xDC, 0x9D, 0xE2, + 0x1E, 0x05, 0x00, 0x00, 0x8B, 0xDC, 0x9D, 0x22, + 0x1F, 0x05, 0x00, 0x00, 0x2A, 0x03, 0x64, 0x22, + 0x2A, 0x09, 0x84, 0x23, 0x17, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x40, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0xB2, 0x04, 0x7A, 0x00, 0x08, 0x0C, + 0x46, 0xA3, 0xB1, 0x04, 0xF6, 0x0D, 0x04, 0x60, + 0x96, 0x11, 0x7F, 0x00, 0x3A, 0x10, 0x10, 0x04, + 0x06, 0x42, 0xB2, 0x04, 0xBA, 0x10, 0x10, 0x00, + 0x17, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x66, 0x42, 0xB2, 0x04, 0x0E, 0x13, 0x00, 0x00, + 0x6A, 0x09, 0x84, 0x23, 0x6A, 0x0B, 0x50, 0x23, + 0x6A, 0x19, 0x4E, 0x23, 0x96, 0x81, 0x10, 0x00, + 0x66, 0x62, 0xBD, 0x04, 0x0A, 0x1C, 0xFE, 0xA3, + 0x96, 0x11, 0x04, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xA3, 0xB3, 0x04, 0x0F, 0x05, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7A, 0x0C, 0x0C, 0x08, + 0xBF, 0x0E, 0x0C, 0xBC, 0x00, 0x00, 0x00, 0x00, + 0x4E, 0x0C, 0x28, 0x00, 0xB6, 0x99, 0x01, 0x00, + 0x97, 0x80, 0x81, 0xFF, 0x7F, 0x00, 0x00, 0x00, + 0x66, 0xE2, 0xB4, 0x04, 0x6A, 0x07, 0x14, 0xA2, + 0x6A, 0x13, 0x16, 0xA2, 0x2A, 0x13, 0xEC, 0x23, + 0x97, 0x81, 0x81, 0xFF, 0x7F, 0x00, 0x00, 0x00, + 0x3A, 0x24, 0x24, 0x0C, 0x6A, 0x13, 0xEC, 0x23, + 0x06, 0x62, 0xBD, 0x04, 0x0A, 0xAD, 0xF8, 0x28, + 0x0A, 0xCD, 0xFA, 0x28, 0x3A, 0x30, 0x30, 0x0C, + 0x4A, 0x64, 0xFA, 0x28, 0x8B, 0xE4, 0x9D, 0xE2, + 0x1E, 0x05, 0x00, 0x00, 0x8B, 0xE4, 0x9D, 0x22, + 0x1F, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x60, + 0x1F, 0x05, 0x00, 0x00, 0x96, 0x81, 0x08, 0x00, + 0x66, 0x62, 0xBD, 0x04, 0xF6, 0x1D, 0x30, 0x08, + 0x4E, 0x0C, 0x28, 0x00, 0xB6, 0x99, 0x01, 0x00, + 0x6A, 0x07, 0x14, 0xA2, 0x6A, 0x13, 0x16, 0xA2, + 0x2A, 0x13, 0xEC, 0x23, 0x97, 0x81, 0x81, 0xFF, + 0x7F, 0x00, 0x00, 0x00, 0x3A, 0x24, 0x24, 0x0C, + 0x6A, 0x13, 0xEC, 0x23, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0xBD, 0x04, 0x0A, 0xAD, 0xE8, 0x29, + 0x0A, 0xBD, 0x38, 0x2A, 0x0A, 0xCD, 0xF8, 0x28, + 0x0A, 0xDD, 0xFA, 0x28, 0x1A, 0x34, 0x34, 0x0C, + 0x4A, 0x6C, 0xFA, 0x28, 0x8B, 0xE4, 0x9D, 0xE2, + 0x1E, 0x05, 0x00, 0x00, 0x5A, 0x04, 0x28, 0x2C, + 0x46, 0x63, 0xBD, 0x04, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xF6, 0x51, 0x00, 0x8B, 0xE4, 0x9D, 0x22, + 0x1F, 0x05, 0x00, 0x00, 0x2A, 0x01, 0xE6, 0x23, + 0x7A, 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0xBC, 0x04, 0x0A, 0x0D, 0xD8, 0x28, + 0x7A, 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0x23, 0xBC, 0x04, 0x37, 0x49, 0x49, 0x00, + 0x08, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00, + 0x00, 0xCE, 0x47, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0xBC, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xA0, 0x7B, 0x04, 0x96, 0x81, 0x04, 0x00, + 0x66, 0x62, 0xBD, 0x04, 0xF6, 0x1D, 0x34, 0x08, + 0x9A, 0x0C, 0x0C, 0x00, 0x4E, 0x0C, 0x30, 0x00, + 0xB6, 0x99, 0x01, 0x00, 0x6A, 0x07, 0x14, 0xA2, + 0x6A, 0x13, 0x16, 0xA2, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x50, 0xBF, 0x02, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0x59, 0x00, 0x01, 0x00, 0x01, 0x00, + 0xE6, 0xE3, 0xBD, 0x7C, 0x17, 0x49, 0xC9, 0xFF, + 0xBF, 0xFF, 0x7F, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xD0, 0x52, 0x01, 0x01, 0x00, 0x01, 0x00, + 0xE6, 0x23, 0x89, 0x0B, 0x8B, 0x05, 0x89, 0x80, + 0x8C, 0x51, 0x00, 0x00, 0x2A, 0x01, 0x58, 0x22, + 0x17, 0x07, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, + 0x0A, 0x5C, 0x79, 0x28, 0x7B, 0x3E, 0x2A, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x66, 0x62, 0xC0, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0x89, 0x03, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xD0, 0xCA, 0x00, 0xAB, 0x18, 0x00, 0xE0, + 0x08, 0x05, 0x00, 0x00, 0x0A, 0x2D, 0x78, 0x28, + 0x0A, 0x8D, 0x76, 0x28, 0x0A, 0x9D, 0x22, 0x28, + 0x0F, 0x17, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x2A, 0x1D, 0x04, 0xA0, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0x91, 0x03, 0x0A, 0xAD, 0x0C, 0x28, + 0x0A, 0xBD, 0x10, 0x28, 0x0A, 0xCD, 0x16, 0x28, + 0x0A, 0xDD, 0x18, 0x28, 0x0A, 0xFD, 0x46, 0x28, + 0x0A, 0x0D, 0x1F, 0x28, 0x2A, 0x1D, 0x14, 0x22, + 0xB7, 0x26, 0x05, 0xD0, 0x04, 0x00, 0x00, 0x00, + 0xEE, 0x39, 0x00, 0x0D, 0x6E, 0x3A, 0x00, 0x0E, + 0x0F, 0xA4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0F, 0xDA, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1A, 0x04, 0x2C, 0x2C, 0x1A, 0x08, 0x04, 0x2C, + 0x76, 0x1C, 0x2C, 0x40, 0x37, 0xC4, 0x01, 0x00, + 0x08, 0x00, 0x08, 0x00, 0xB7, 0xC4, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0xB6, 0x22, 0x00, 0x10, + 0x4E, 0x24, 0x0A, 0x00, 0x0E, 0x28, 0x2A, 0x00, + 0x0F, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0E, 0x55, 0x36, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x46, 0xC4, 0xC5, 0x04, + 0xB3, 0xFF, 0x0A, 0x09, 0x41, 0x83, 0x2F, 0x00, + 0x0A, 0x2D, 0x40, 0x28, 0x2A, 0x4D, 0x96, 0x21, + 0xB6, 0xC0, 0x18, 0x0A, 0xB6, 0xC1, 0x08, 0x00, + 0x0E, 0x34, 0x01, 0x00, 0x0E, 0x28, 0x06, 0x00, + 0x0E, 0x0F, 0x00, 0x00, 0x0E, 0x55, 0x0A, 0x00, + 0x46, 0x04, 0xC8, 0x04, 0x4E, 0x34, 0x0D, 0x00, + 0x4E, 0x28, 0x0E, 0x00, 0x0E, 0x59, 0x36, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x66, 0xC4, 0xC7, 0x04, + 0x53, 0xFF, 0x2A, 0xE4, 0x4E, 0xEE, 0xE0, 0x03, + 0x9A, 0x0C, 0x0C, 0x00, 0xBA, 0x04, 0x34, 0x00, + 0x96, 0xA0, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0x63, 0xC9, 0x04, 0xB7, 0x26, 0x06, 0x10, + 0x04, 0x00, 0x00, 0x00, 0xB7, 0x84, 0x00, 0x00, + 0x00, 0x00, 0x13, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0xC9, 0x04, 0xB7, 0x26, 0x06, 0x0C, + 0x04, 0x00, 0x00, 0x00, 0xB7, 0x84, 0x00, 0x00, + 0x00, 0x00, 0x0F, 0x00, 0x0F, 0x47, 0x06, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xAE, 0xA1, 0x01, 0x00, + 0x0E, 0x55, 0x36, 0x00, 0x31, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x46, 0xC4, 0xCA, 0x04, + 0xB3, 0xFF, 0x0A, 0x04, 0x89, 0x03, 0x00, 0x00, + 0x0E, 0x5B, 0x00, 0x00, 0x0E, 0x5F, 0x00, 0x00, + 0x0E, 0x63, 0x00, 0x00, 0x0E, 0x67, 0x00, 0x00, + 0x0E, 0x58, 0x1C, 0x01, 0x8E, 0x5C, 0x1C, 0x01, + 0x0E, 0x60, 0x20, 0x01, 0x8E, 0x64, 0x20, 0x01, + 0x0E, 0x69, 0x58, 0x00, 0x7A, 0x00, 0x58, 0x5C, + 0xA6, 0x82, 0xCC, 0x04, 0x0E, 0x69, 0x5C, 0x00, + 0x0E, 0x6D, 0x60, 0x00, 0x7A, 0x00, 0x60, 0x64, + 0xA6, 0x02, 0xCD, 0x04, 0x0E, 0x6D, 0x64, 0x00, + 0x0E, 0x59, 0x68, 0x00, 0x7A, 0x00, 0x68, 0x6C, + 0xA6, 0x82, 0xCD, 0x04, 0x0E, 0x59, 0x6C, 0x00, + 0x2A, 0x01, 0xB2, 0x21, 0x7B, 0x3E, 0x00, 0x8C, + 0x3F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0xA2, 0xCE, 0x04, 0xBF, 0x5E, 0x58, 0xCC, + 0xCC, 0x00, 0x00, 0x00, 0x76, 0xBE, 0x5C, 0x44, + 0x06, 0x02, 0xCF, 0x04, 0xBF, 0x5E, 0x58, 0x78, + 0x14, 0x00, 0x00, 0x00, 0x76, 0xBE, 0x5C, 0x44, + 0xF6, 0x05, 0x34, 0x14, 0xAE, 0x27, 0x00, 0x00, + 0x0E, 0x63, 0x00, 0x00, 0x0E, 0x0B, 0x00, 0x00, + 0x0E, 0x0F, 0x00, 0x00, 0x0E, 0x13, 0x00, 0x00, + 0x0E, 0x17, 0x00, 0x00, 0x0E, 0x1B, 0x00, 0x00, + 0x0E, 0x1F, 0x00, 0x00, 0xAE, 0xA1, 0x03, 0x00, + 0x0E, 0x24, 0x5D, 0x00, 0x0E, 0x59, 0x02, 0x00, + 0x66, 0x04, 0xD4, 0x04, 0xAE, 0x4A, 0x10, 0x00, + 0x31, 0x00, 0x01, 0x00, 0x46, 0x04, 0xD1, 0x04, + 0xB3, 0xFF, 0x0A, 0x04, 0x89, 0x03, 0x00, 0x00, + 0x0E, 0x08, 0x1C, 0x01, 0x8E, 0x0C, 0x1C, 0x01, + 0x0E, 0x10, 0x20, 0x01, 0x8E, 0x14, 0x20, 0x01, + 0x79, 0x59, 0xF9, 0x79, 0x7A, 0x10, 0x18, 0x10, + 0x7A, 0x14, 0x18, 0x14, 0xF6, 0x15, 0x08, 0x7C, + 0xF6, 0x1D, 0x0C, 0x7C, 0xF6, 0x25, 0x10, 0x7C, + 0xF6, 0x2D, 0x14, 0x7C, 0x1A, 0x60, 0x60, 0x08, + 0x76, 0x3C, 0x1C, 0x04, 0x76, 0x44, 0x08, 0x60, + 0x36, 0x07, 0x07, 0x08, 0x1A, 0x60, 0x60, 0x0C, + 0x76, 0x44, 0x0C, 0x40, 0x36, 0x07, 0x07, 0x08, + 0x1A, 0x60, 0x60, 0x10, 0x76, 0x44, 0x10, 0x20, + 0x36, 0x07, 0x07, 0x08, 0x1A, 0x60, 0x60, 0x14, + 0x36, 0x07, 0x07, 0x05, 0xAE, 0x2B, 0x00, 0x00, + 0x0E, 0x61, 0x25, 0x00, 0x2E, 0xB1, 0xFF, 0x7F, + 0x76, 0x04, 0x34, 0x08, 0x76, 0x0C, 0x34, 0x04, + 0x0E, 0x55, 0x02, 0x00, 0x31, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x46, 0x44, 0xD5, 0x04, + 0xB3, 0x33, 0x16, 0x04, 0x89, 0x03, 0x00, 0x00, + 0x0E, 0x67, 0x00, 0x00, 0x0E, 0x6B, 0x00, 0x00, + 0x0E, 0x64, 0x14, 0x01, 0x8E, 0x68, 0x14, 0x01, + 0xBA, 0x64, 0x64, 0x00, 0x5A, 0x68, 0x00, 0x68, + 0x0E, 0x79, 0x68, 0x00, 0xF6, 0x75, 0x34, 0x10, + 0x9A, 0x38, 0x38, 0x00, 0x76, 0x74, 0x38, 0x14, + 0x7A, 0x08, 0x68, 0x38, 0x01, 0x00, 0x01, 0x00, + 0xE6, 0x42, 0xD7, 0x04, 0x7A, 0x78, 0x68, 0x00, + 0xF6, 0x8D, 0x68, 0x14, 0xF6, 0x95, 0x64, 0x14, + 0x0F, 0x17, 0xFE, 0xFF, 0xFF, 0xFF, 0x01, 0x00, + 0x0F, 0x19, 0xFE, 0xFF, 0xFF, 0xFF, 0x01, 0x00, + 0x0F, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0E, 0x21, 0x1C, 0x00, 0xF6, 0x75, 0x34, 0x10, + 0x97, 0x0F, 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x66, 0x02, 0xD9, 0x04, 0x0E, 0x2D, 0x54, 0x00, + 0x76, 0x44, 0x20, 0x04, 0x9A, 0x54, 0x54, 0x00, + 0x7A, 0x7C, 0x54, 0x38, 0x01, 0x00, 0x01, 0x00, + 0x26, 0x83, 0xD8, 0x04, 0xF6, 0x75, 0x34, 0x0C, + 0x97, 0x0F, 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x66, 0x62, 0xDA, 0x04, 0x0E, 0x31, 0x54, 0x00, + 0x06, 0xE2, 0xDA, 0x04, 0x76, 0x44, 0x20, 0x04, + 0x9A, 0x54, 0x54, 0x00, 0x7A, 0x7C, 0x54, 0x38, + 0x26, 0xC3, 0xD9, 0x04, 0x7A, 0x7C, 0x48, 0x2C, + 0x66, 0xC2, 0xDC, 0x04, 0x76, 0x04, 0x34, 0x08, + 0x7A, 0x7C, 0x2C, 0x30, 0x76, 0xFC, 0x7C, 0x14, + 0x3A, 0x7C, 0x00, 0x7C, 0xBF, 0x0A, 0x00, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x3F, 0x0A, 0x08, 0x28, + 0x00, 0x00, 0x00, 0x00, 0xBA, 0x08, 0x08, 0x00, + 0x7A, 0x7C, 0x7C, 0x08, 0x01, 0x00, 0x01, 0x00, + 0xE6, 0xC2, 0xDC, 0x04, 0x76, 0xCC, 0x2C, 0x14, + 0x7A, 0x6C, 0x64, 0x3C, 0x0E, 0x2D, 0x3C, 0x00, + 0x2A, 0x01, 0x90, 0x21, 0x7B, 0x3E, 0x00, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0xC2, 0xDD, 0x04, 0x4A, 0x8E, 0x4C, 0x2A, + 0x0A, 0x7D, 0x46, 0x2A, 0x0A, 0x8D, 0x4C, 0x2A, + 0x0A, 0x5D, 0x51, 0x2A, 0x0A, 0x0D, 0x4E, 0x2A, + 0x0A, 0x1D, 0x44, 0x2A, 0x0A, 0x2D, 0x48, 0x2A, + 0xF6, 0x1D, 0x34, 0x10, 0x9A, 0x0C, 0x0C, 0x00, + 0x76, 0x1C, 0x0C, 0x14, 0x7A, 0x7C, 0x64, 0x0C, + 0xE6, 0xA2, 0xDF, 0x04, 0x0E, 0x1F, 0x01, 0x00, + 0x9A, 0x08, 0x08, 0x00, 0x0E, 0x57, 0x00, 0x00, + 0x06, 0xE2, 0xE3, 0x04, 0x7B, 0x3E, 0x0E, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xE3, 0xE3, 0x04, 0x7A, 0x7C, 0x20, 0x44, + 0x46, 0x23, 0xE1, 0x04, 0x0E, 0x2D, 0x78, 0x00, + 0x0E, 0x57, 0x00, 0x00, 0x0E, 0x07, 0x00, 0x00, + 0x0E, 0x21, 0x44, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0xE3, 0x04, 0x7B, 0x3E, 0x2A, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0x63, 0xE3, 0x04, 0x7A, 0x7C, 0x44, 0x00, + 0xA6, 0x22, 0xE2, 0x04, 0x4A, 0xF6, 0x54, 0x2A, + 0x0E, 0x01, 0x44, 0x00, 0x9A, 0x04, 0x04, 0x00, + 0x7B, 0x3E, 0x02, 0x28, 0x00, 0x00, 0x00, 0x00, + 0x26, 0xE3, 0xE3, 0x04, 0x0A, 0xBD, 0x54, 0x2A, + 0x0E, 0x57, 0x00, 0x00, 0x0E, 0x07, 0x00, 0x00, + 0x0E, 0x23, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0xE2, 0xE3, 0x04, 0x0E, 0x57, 0x01, 0x00, + 0x0E, 0x07, 0x01, 0x00, 0x4A, 0xF6, 0x54, 0x2A, + 0x0E, 0x01, 0x44, 0x00, 0x0A, 0x3D, 0x4A, 0x2A, + 0x0A, 0x6D, 0x52, 0x2A, 0x0E, 0x13, 0x14, 0x00, + 0x0E, 0x17, 0x0A, 0x00, 0x2A, 0x3F, 0x90, 0x21, + 0x7B, 0x3E, 0x3E, 0x14, 0x00, 0x00, 0x00, 0x00, + 0xA6, 0x22, 0xE5, 0x04, 0x0E, 0x13, 0x05, 0x00, + 0x0E, 0x17, 0x02, 0x00, 0x7B, 0x3E, 0x0E, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xE3, 0xE7, 0x04, 0x9A, 0x0C, 0x0C, 0x00, + 0x7B, 0x3E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x63, 0xE6, 0x04, 0x0E, 0x19, 0x64, 0x00, + 0x06, 0x22, 0xE8, 0x04, 0x7A, 0x7C, 0x0C, 0x10, + 0x46, 0x23, 0xE8, 0x04, 0x7A, 0x7C, 0x08, 0x14, + 0x26, 0x23, 0xE7, 0x04, 0x76, 0xFC, 0x34, 0x08, + 0x7A, 0x2C, 0x18, 0x7C, 0x0E, 0x1F, 0x00, 0x00, + 0x0E, 0x0F, 0x00, 0x00, 0x0E, 0x0B, 0x00, 0x00, + 0x0E, 0x1B, 0x00, 0x00, 0x0E, 0x21, 0x44, 0x00, + 0x06, 0x22, 0xE8, 0x04, 0x0E, 0x0F, 0x00, 0x00, + 0x0E, 0x0B, 0x00, 0x00, 0x4A, 0x3E, 0x46, 0x2A, + 0x4A, 0x46, 0x4C, 0x2A, 0x4A, 0xAE, 0x50, 0x2A, + 0x4A, 0x06, 0x4E, 0x2A, 0x4A, 0x0E, 0x44, 0x2A, + 0x4A, 0x16, 0x48, 0x2A, 0x4A, 0x1E, 0x4A, 0x2A, + 0x4A, 0x36, 0x52, 0x2A, 0x36, 0x1F, 0x07, 0x15, + 0x7B, 0x3E, 0x3E, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x46, 0xC3, 0xEA, 0x04, 0x7B, 0x3E, 0x3C, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x26, 0xC3, 0xEA, 0x04, 0x7B, 0x3E, 0x3C, 0x40, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x86, 0xC2, 0xEA, 0x04, 0x0E, 0x2D, 0x78, 0x00, + 0x0A, 0x7D, 0x56, 0x2A, 0x0A, 0x8D, 0x5A, 0x2A, + 0x0A, 0x5D, 0x5D, 0x2A, 0x2A, 0x01, 0x90, 0x21, + 0x7B, 0x3E, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, + 0x26, 0x63, 0xF2, 0x04, 0x7A, 0x7C, 0x48, 0x1C, + 0xA6, 0x62, 0xEC, 0x04, 0x7A, 0x7C, 0x48, 0x1C, + 0x26, 0xE3, 0xEE, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x62, 0xF1, 0x04, 0x7B, 0x3E, 0x10, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0xA3, 0xED, 0x04, 0xAB, 0x02, 0x00, 0xA0, + 0x4B, 0x05, 0x00, 0x00, 0xAB, 0x02, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xF3, 0x04, 0x9A, 0x54, 0x54, 0x00, + 0x4A, 0xAE, 0x5C, 0x2A, 0x7B, 0x3E, 0x2A, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x86, 0x62, 0xF1, 0x04, 0xAB, 0x02, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xF3, 0x04, 0x7B, 0x3E, 0x10, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x46, 0x23, 0xF0, 0x04, 0xAB, 0x02, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0xAB, 0x04, 0x00, 0xA0, + 0x4B, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xF3, 0x04, 0x9A, 0x54, 0x54, 0x00, + 0x4A, 0xAE, 0x5C, 0x2A, 0x7B, 0x3E, 0x2A, 0x28, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x86, 0x62, 0xF1, 0x04, 0xAB, 0x04, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xF3, 0x04, 0x4A, 0x96, 0x56, 0x2A, + 0x4A, 0xDE, 0x58, 0x2A, 0xAB, 0x00, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xA0, + 0x4B, 0x05, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x22, 0xF3, 0x04, 0x4A, 0x96, 0x56, 0x2A, + 0x4A, 0x86, 0x58, 0x2A, 0xAB, 0x00, 0x00, 0x60, + 0x4B, 0x05, 0x00, 0x00, 0xAB, 0x00, 0x00, 0xA0, + 0x4B, 0x05, 0x00, 0x00, 0x0A, 0xFD, 0x59, 0x2A, + 0x7A, 0x70, 0x7C, 0x40, 0x3B, 0x38, 0x38, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x0F, 0x03, 0x9C, 0xFF, + 0xFF, 0xFF, 0x01, 0x00, 0x0F, 0x05, 0x18, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x70, 0x04, + 0xA6, 0xE2, 0xF4, 0x04, 0x7A, 0x00, 0x60, 0x08, + 0xA6, 0xE2, 0xF4, 0x04, 0x01, 0x00, 0x01, 0x00, + 0x06, 0x02, 0xF5, 0x04, 0x0E, 0x73, 0x00, 0x00, + 0x7A, 0x74, 0x2C, 0x3C, 0x6A, 0x2D, 0xA4, 0x28, + 0x6A, 0x2F, 0xA6, 0x28, 0x6A, 0x31, 0xA8, 0x28, + 0x6A, 0x33, 0xAA, 0x28, 0x6A, 0x35, 0xAC, 0x28, + 0x6A, 0x37, 0xAE, 0x28, 0x6A, 0x39, 0xB0, 0x28, + 0x6A, 0x3B, 0x94, 0x28, 0x0A, 0x1D, 0x77, 0x28, + 0x0A, 0x2D, 0x3B, 0x28, 0x3A, 0x00, 0x44, 0x74, + 0x16, 0x00, 0x00, 0x12, 0x4A, 0x06, 0x76, 0x28, + 0x4A, 0xEC, 0x06, 0xA4, 0x0A, 0x3D, 0x61, 0x28, + 0x5A, 0x00, 0x60, 0x4C, 0x01, 0x00, 0x01, 0x00, + 0xA6, 0xD2, 0xF7, 0x04, 0x37, 0x49, 0x49, 0x04, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x05, 0x04, 0x17, 0x49, 0xC9, 0xFB, 0xFF, 0xFF, + 0x7F, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDF, 0x01, 0x9A, 0xFF, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, }; -#endif /* __TCC317X_BOOT_TDMB_H__ */ +#endif /* __TCC317X_BOOT_TDMB_H__*/ diff --git a/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_debug.h b/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_debug.h index 6cdb393..cb115b0 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_debug.h +++ b/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_debug.h @@ -41,6 +41,10 @@ #define DEBUG_STREAM_READ 0x00008000 #define DEBUG_STREAM_STACK 0x00010000 #define DEBUG_STATUS 0x00020000 +#define DEBUG_PARSE_HEADER 0x00040000 + +#define MAX_SIZE_DSP_ROM (1024*10) +#define MAX_PATH 128 s32 printk(const char *fmt, ...); @@ -58,6 +62,14 @@ do {\ } \ } while (0) +s32 tcbd_debug_spur_dbg(void); +s32 tcbd_debug_rom_from_fs(void); +s32 *tcbd_debug_spur_clk_cfg(void); +char *tcbd_debug_rom_path(void); + +void tcbd_debug_mbox_rx(u16 *_cmd, s32 *_len, u32 **_data); +void tcbd_debug_mbox_tx(u16 *_cmd, s32 *_len, u32 **_data); + extern u32 tcbd_debug_class; #endif /*__TCPAL_DEBUG_H_*/ diff --git a/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_os.h b/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_os.h index b63efb4..85e4a3d 100644 --- a/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_os.h +++ b/drivers/media/tdmb/tcc3170/inc/tcpal/tcpal_os.h @@ -24,8 +24,11 @@ #define __TCPAL_OS_H__ #include "tcpal_types.h" #include <linux/init.h> -#include <linux/module.h> #include <linux/kernel.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/fs.h> +#include <linux/uaccess.h> /* For TimeCheck */ #define TCPAL_MAX_TIMECNT 0xFFFFFFFFFFFFFFFFULL diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c b/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c index 5b42026..986f3d9 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c @@ -31,12 +31,25 @@ #include "tcc317x_boot_tdmb.h" -s32 tcbd_device_start( - struct tcbd_device *_device, enum tcbd_clock_type _clock_type) +s32 tcbd_device_start(struct tcbd_device *_device, + enum tcbd_clock_type _clock_type) { s32 ret = 0, ver; u8 *dsp_rom = TCC317X_BOOT_DATA_TDMB; s32 size = TCC317X_BOOT_SIZE_TDMB; +#if defined(__DEBUG_DSP_ROM__) + static u8 dsp_rom_buff[MAX_SIZE_DSP_ROM]; + if (tcbd_debug_rom_from_fs() == 1) { + ret = tcbd_read_file(_device, tcbd_debug_rom_path(), + dsp_rom_buff, MAX_SIZE_DSP_ROM); + if (ret > 0) { + dsp_rom = dsp_rom_buff; + size = ret; + tcbd_debug(DEBUG_ERROR, "rom:%s, size:%d\n", + tcbd_debug_rom_path(), size); + } + } +#endif /*__DEBUG_DSP_ROM__*/ /* Initialize PLL */ tcbd_init_pll(_device, _clock_type); @@ -46,13 +59,13 @@ s32 tcbd_device_start( tcbd_enable_peri(_device); ret = tcbd_init_dsp(_device, dsp_rom, size); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to initialize dsp!! error:%d\n", ret); + tcbd_debug(DEBUG_ERROR, "failed to initialize dsp!! " + "error:%d\n", ret); return -TCERR_FATAL_ERROR; } else { tcbd_get_rom_version(_device, &ver); - tcbd_debug(DEBUG_API_COMMON, - "device start success!! version:0x%X\n", ver); + tcbd_debug(DEBUG_API_COMMON, "device start success!! " + "version:0x%X\n", ver); } return 0; } @@ -164,9 +177,9 @@ s32 tcbd_init_stream_data_config( return ret; } +#if defined(__CSPI_ONLY__) #if defined(__READ_FIXED_LENGTH__) -s32 tcbd_read_stream( - struct tcbd_device *_device, u8 *_buff, s32 *_size) +s32 tcbd_read_stream(struct tcbd_device *_device, u8 *_buff, s32 *_size) { u32 bytes_read = _device->intr_threshold; @@ -186,9 +199,8 @@ s32 tcbd_read_stream( return tcbd_reg_read_burst_fix( _device, TCBD_STREAM_CFG4, _buff, bytes_read); } -#else /* __READ_VARIABLE_LENGTH__ */ -s32 tcbd_read_stream( - struct tcbd_device *_device, u8 *_buff, s32 *_size) +#elif defined(__READ_VARIABLE_LENGTH__) +s32 tcbd_read_stream(struct tcbd_device *_device, u8 *_buff, s32 *_size) { u32 bytes_remain = 0; u32 bytes_read = _device->intr_threshold; @@ -217,7 +229,10 @@ s32 tcbd_read_stream( return tcbd_reg_read_burst_fix( _device, TCBD_STREAM_CFG4, _buff, bytes_read); } -#endif +#else +#error "you must define __READ_VARIABLE_LENGTH__ or __READ_FIXED_LENGTH__" +#endif /*!__READ_FIXED_LENGTH__ && !__READ_VARIABLE_LENGTH__*/ +#endif /*__CSPI_ONLY__*/ s32 tcbd_tune_frequency( struct tcbd_device *_device, u32 _freq_khz, s32 _bw_khz) @@ -233,32 +248,35 @@ s32 tcbd_tune_frequency( _device->curr_band = BAND_TYPE_BAND3; else _device->curr_band = BAND_TYPE_LBAND; - ret |= tcbd_reset_ip( - _device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_ALL); + ret |= tcbd_reset_ip(_device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_ALL); ret |= tcbd_rf_tune_frequency(_device, _freq_khz, _bw_khz); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to tune frequency to RF!! ret:%d\n", ret); + tcbd_debug(DEBUG_ERROR, "failed to tune frequency to RF!! " + "ret:%d\n", ret); return ret; } - if (_device->peri_type == PERI_TYPE_SPI_ONLY) { - /* enable fic buffer only*/ - ret |= tcbd_init_stream_data_config( - _device, - ENABLE_CMD_FIFO, - STREAM_DATA_ENABLE | - STREAM_HEADER_ON | - STREAM_MASK_BUFFERA, - TCBD_THRESHOLD_FIC); + switch (_device->peri_type) { + case PERI_TYPE_SPI_ONLY: + ret |= tcbd_init_stream_data_config(_device, ENABLE_CMD_FIFO, + STREAM_DATA_ENABLE | STREAM_HEADER_ON | + STREAM_MASK_BUFFERA, TCBD_THRESHOLD_FIC); + break; + case PERI_TYPE_STS: + ret |= tcbd_init_stream_data_config(_device, DISABLE_CMD_FIFO, + 0, 0); + break; + default: + tcbd_debug(DEBUG_ERROR, "%d not implemented!!\n", + _device->peri_type); + return -TCERR_FATAL_ERROR; } tcbd_init_status_manager(); ret |= tcbd_demod_tune_frequency(_device, _freq_khz, _bw_khz); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to tune frequency " + tcbd_debug(DEBUG_ERROR, "failed to tune frequency " "to demodulator!! ret:%d\n", ret); return ret; } @@ -268,8 +286,8 @@ s32 tcbd_tune_frequency( #if defined(__READ_VARIABLE_LENGTH__) _device->size_more_read = 0; #endif /*__READ_VARIABLE_LENGTH__*/ - tcbd_debug(DEBUG_API_COMMON, - " # Frequency set time :%lld\n", tcpal_diff_time(tick)); + tcbd_debug(DEBUG_API_COMMON, " # Frequency set time :%lld\n", + tcpal_diff_time(tick)); return ret; } @@ -318,8 +336,8 @@ s32 tcbd_wait_tune(struct tcbd_device *_device, u8 *_status) } while (tcpal_diff_time(time_tick) < time_tune_wait); if (cto && cfo) - tcbd_debug(DEBUG_API_COMMON, - "lock status : 0x%02X\n", *_status); + tcbd_debug(DEBUG_API_COMMON, "lock status : 0x%02X\n", + *_status); else ret = -TCERR_TUNE_FAILED; @@ -345,12 +363,11 @@ static inline s32 tcbd_calc_threshold(struct tcbd_service *_service) if (TCBD_MAX_THRESHOLD < threshold) threshold = TCBD_MAX_THRESHOLD; - tcbd_debug(DEBUG_API_COMMON, - "ptype:%s, bitrate :%d, interrupt threshold:%d\n", - (_service->ptype) ? "EEP" : "UEP", + tcbd_debug(DEBUG_API_COMMON, "ptype:%s, bitrate :%d, interrupt " + "threshold:%d\n", (_service->ptype) ? "EEP" : "UEP", _service->bitrate, threshold); - return threshold; + return threshold>>1; } static inline s32 tcbd_find_empty_slot( @@ -381,37 +398,37 @@ static inline s32 tcbd_find_used_slot( return -1; } -static inline s32 tcbd_set_service( - struct tcbd_device *_device, struct tcbd_service *_service) +#define FLAG_SHORT_PARAM 0 +#define FLAG_LONG_PARAM 1 +static inline s32 tcbd_set_service(struct tcbd_device *_device, + struct tcbd_service *_service, s32 _flag) { s32 ret = 0; - u32 threshold, sel_buff = 0, sel_stream = 0; + u32 threshold = 0, sel_buff = 0, sel_stream = 0; u8 en_cmd_fifo = 0; + sel_buff = STREAM_DATA_ENABLE | STREAM_HEADER_ON | + STREAM_MASK_BUFFERA; switch (_device->peri_type) { case PERI_TYPE_SPI_ONLY: -#if defined(__CALC_INTRRUPT_THRESHOLD__) - threshold = tcbd_calc_threshold(_service); - sel_stream = STREAM_SET_GARBAGE(threshold) | + if (_flag == FLAG_LONG_PARAM) { + threshold = tcbd_calc_threshold(_service); + sel_stream = STREAM_SET_GARBAGE(threshold) | STREAM_TYPE_ALL; -#else /* __CALC_INTRRUPT_THRESHOLD__ */ + } else { threshold = TCBD_MAX_THRESHOLD; sel_stream = STREAM_SET_GARBAGE(TCBD_MAX_THRESHOLD) | STREAM_TYPE_ALL; -#endif /* __CALC_INTRRUPT_THRESHOLD__ */ + } tcbd_debug(DEBUG_API_COMMON, "threshold : %d\n", threshold); en_cmd_fifo = ENABLE_CMD_FIFO; - sel_buff = STREAM_DATA_ENABLE | - STREAM_HEADER_ON | - STREAM_MASK_BUFFERA | - STREAM_MASK_BUFFERB; break; case PERI_TYPE_STS: en_cmd_fifo = DISABLE_CMD_FIFO; sel_stream = STREAM_TYPE_ALL; - sel_buff = STREAM_DATA_ENABLE | - STREAM_MASK_BUFFERA | - STREAM_MASK_BUFFERB; +#if !defined(__ALWAYS_FIC_ON__) + sel_buff &= ~(STREAM_HEADER_ON); +#endif /*__ALWAYS_FIC_ON__*/ break; default: tcbd_debug(DEBUG_ERROR, "not implemented!\n"); @@ -429,18 +446,20 @@ static inline s32 tcbd_set_service( #if defined(__READ_VARIABLE_LENGTH__) _device->size_more_read = 0; #endif /*__READ_VARIABLE_LENGTH__*/ + ret |= tcbd_disable_irq(_device, 0); ret |= tcbd_change_stream_type(_device, sel_stream); ret |= tcbd_init_stream_data_config( _device, en_cmd_fifo, sel_buff, threshold); ret |= tcbd_send_service_info(_device); - ret |= tcbd_enable_irq(_device, _device->enabled_irq); + if (_device->peri_type == PERI_TYPE_SPI_ONLY) + ret |= tcbd_enable_irq(_device, _device->enabled_irq); return ret; } -s32 tcbd_register_service( - struct tcbd_device *_device, u8 _subch_id, u8 _data_mode) +s32 tcbd_register_service(struct tcbd_device *_device, u8 _subch_id, + u8 _data_mode) { s32 empty_slot, empty_slot2x; struct tcbd_service service = {0, }; @@ -448,8 +467,7 @@ s32 tcbd_register_service( u32 *service_info = mult_service->service_info; if (tcbd_find_used_slot(mult_service, _subch_id) >= 0) { - tcbd_debug(DEBUG_ERROR, - "aready registerd service! " + tcbd_debug(DEBUG_ERROR, "aready registerd service! " "subch_id:%d\n", _subch_id); return -TCERR_AREADY_REGISTERED; } @@ -473,11 +491,11 @@ s32 tcbd_register_service( (empty_slot << 20) | (_data_mode << 16); - return tcbd_set_service(_device, &service); + return tcbd_set_service(_device, &service, FLAG_SHORT_PARAM); } -s32 tcbd_register_service_long( - struct tcbd_device *_device, struct tcbd_service *_service) +s32 tcbd_register_service_long(struct tcbd_device *_device, + struct tcbd_service *_service) { s32 empty_slot, empty_slot2x; u32 data_mode = 0; @@ -485,8 +503,7 @@ s32 tcbd_register_service_long( u32 *service_info = mult_service->service_info; if (tcbd_find_used_slot(mult_service, _service->subch_id) >= 0) { - tcbd_debug(DEBUG_ERROR, - "aready registerd service! " + tcbd_debug(DEBUG_ERROR, "aready registerd service! " "subch_id:%d\n", _service->subch_id); return -TCERR_AREADY_REGISTERED; } @@ -525,11 +542,10 @@ s32 tcbd_register_service_long( (_service->plevel << 8) | _service->bitrate; - return tcbd_set_service(_device, _service); + return tcbd_set_service(_device, _service, FLAG_LONG_PARAM); } -s32 tcbd_unregister_service( - struct tcbd_device *_device, u8 _subch_id) +s32 tcbd_unregister_service(struct tcbd_device *_device, u8 _subch_id) { s32 ret = 0; s32 service_idx; @@ -553,36 +569,57 @@ s32 tcbd_unregister_service( return ret; } -s32 tcbd_read_fic_data( - struct tcbd_device *_device, u8 *_buff, s32 _size) +s32 tcbd_read_fic_data(struct tcbd_device *_device, u8 *_buff, s32 _size) { s32 ret = 0; u32 addr_fic_buff; u8 status, err_status; - u64 tick; + tcbd_read_irq_status(_device, &status, &err_status); if (_size != TCBD_FIC_SIZE) { tcbd_debug(DEBUG_ERROR, "wrong fic size! %d\n", _size); - return -TCERR_INVALID_ARG; + ret = -TCERR_INVALID_ARG; + goto exit_read_fic; } - - ret = tcbd_read_irq_status(_device, &status, &err_status); if (status & TCBD_IRQ_STAT_FIFOAINIT) { addr_fic_buff = PHY_MEM_ADDR_A_START; - tick = tcpal_get_time(); - tcbd_debug(0, "status:0x%02X, err:0x%02X, %lld elapsed\n", - status, err_status, tcpal_diff_time(tick)); + tcbd_debug(DEBUG_INTRRUPT, "status:0x%02X, err:0x%02X\n", + status, err_status); ret = tcbd_mem_read(_device, addr_fic_buff, _buff, _size); - ret |= tcbd_clear_irq(_device, status); - } else { - ret |= -TCERR_NO_FIC_DATA; + } else + ret = -TCERR_NO_FIC_DATA; +exit_read_fic: + tcbd_clear_irq(_device, status); + return ret; } - ret |= tcbd_clear_irq(_device, status); +static s32 tcbd_disp_dsp_debug(struct tcbd_device *_device) +{ + s32 pos_buf = 0, ret, i; + u32 len = 0, *data = NULL; + u16 cmd; + s8 debug_buff[256]; + + tcbd_debug_mbox_rx(&cmd, &len, &data); + if (data == NULL) + return 0; + + ret = tcbd_read_mail_box(_device, cmd, len, data); + if (ret < 0) { + tcbd_debug(DEBUG_ERROR, "failed to read mail box, " + "err:%d\n", ret); return ret; } + for (i = 0; i < 6; i++) + pos_buf += sprintf(debug_buff + pos_buf, "[%d:%08X]", + i, data[i]); + tcbd_debug(DEBUG_INFO, "%s\n", debug_buff); + + return 0; +} + s32 tcbd_read_signal_info( struct tcbd_device *_device, struct tcbd_status_data *_status_data) @@ -595,6 +632,9 @@ s32 tcbd_read_signal_info( if (!_status_data) return -TCERR_INVALID_ARG; + if (tcbd_debug_spur_dbg() == 1) + tcbd_disp_dsp_debug(_device); + #if defined(__STATUS_IN_REGISTER__) ret = tcbd_reg_write(_device, TCBD_OP_STATUS0, 0x1); ret |= tcbd_reg_read_burst_fix(_device, diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c b/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c index ab5c1cb..e425df8 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c @@ -188,6 +188,9 @@ static inline void tcbd_calc_pcber(struct tcbd_status_data *_status_data) else if (_status_data->pcber > MAX_PCBER * ERROR_LIMIT) _status_data->pcber = MAX_PCBER * ERROR_LIMIT; + if (_status_data->pcber <= 20) + _status_data->pcber = 0; + _status_data->pcber_moving_avg = tcbd_get_moving_avg( &moving_average[0], diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c index 964e532..e2bcbea 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c @@ -42,7 +42,7 @@ s32 tcbd_io_open(struct tcbd_device *_device) if (tcbd_io_funcs.open == NULL) return -TCERR_IO_NOT_INITIALIZED; - tcpal_create_lock(&tcbd_io_funcs.sem, "tcbd_io_funcsSemaphore", 0); + tcpal_create_lock(&tcbd_io_funcs.sem, "tcbd_io_lock", 0); ret = tcbd_io_funcs.open(); if (ret < 0) @@ -80,7 +80,7 @@ s32 tcbd_reg_read( return -TCERR_IO_NOT_INITIALIZED; if (_device == NULL || _data == NULL) - return TCERR_INVALID_ARG; + return -TCERR_INVALID_ARG; tcpal_lock(&tcbd_io_funcs.sem); tcbd_io_funcs.chip_addr = _device->chip_addr; @@ -326,14 +326,14 @@ s32 tcbd_send_mail( sizeof(u32) + count * sizeof(u32)); ret |= tcbd_io_funcs.reg_write(TCBD_MAIL_CTRL, TCBD_MAIL_HOSTMAILPOST); if (ret < 0) - goto exittcbd_send_mail; + goto exit_send_mail; time_tick = tcpal_get_time(); do { elapsed = tcpal_diff_time(time_tick); if (elapsed > (u64)MAX_TIME_TO_WAIT_MAIL) { ret = -TCERR_WAIT_MAIL_TIMEOUT; - goto exittcbd_send_mail; + goto exit_send_mail; } /* latch mail status to register */ ret = tcbd_io_funcs.reg_write(TCBD_MAIL_FIFO_W, 0x5E); @@ -346,7 +346,7 @@ s32 tcbd_send_mail( tcbd_debug(DEBUG_DRV_IO, "cmd:0x%X, count:%d, elapsed time:%llu\n", _mail->cmd, count, elapsed); -exittcbd_send_mail: +exit_send_mail: tcpal_unlock(&tcbd_io_funcs.sem); return ret; } @@ -375,11 +375,10 @@ s32 tcbd_recv_mail( ret = -TCERR_WAIT_MAIL_TIMEOUT; if (ret < 0) - goto exittcbd_recv_mail; + goto exit_recv_mail; } while ((reg_data & 0xFC) < 3); /* check fifo status */ bytes_read = (reg_data >> 2) & 0x3F; - tcbd_debug(DEBUG_DRV_IO, - "cmd:0x%X, bytes_read:%d, elapsed time:%llu\n", + tcbd_debug(DEBUG_DRV_IO, "cmd:0x%X, bytes_read:%d, elapsed time:%llu\n", _mail->cmd, bytes_read, elapsed); ret = tcbd_io_funcs.reg_read_burst_fix( @@ -387,13 +386,12 @@ s32 tcbd_recv_mail( /*only warm boot cmd */ if (bytes_read == 4) { memcpy(_mail->data, mail_data, bytes_read); - goto exittcbd_recv_mail; + goto exit_recv_mail; } mail_hdr = *((u32 *)mail_data); if ((mail_hdr >> 24) != MB_SLAVEMAIL) { - tcbd_debug(DEBUG_ERROR, - "Error : cmd=0x%X bytes_read=%d\n", + tcbd_debug(DEBUG_ERROR, "Error : cmd=0x%X bytes_read=%d\n", _mail->cmd, bytes_read); tcbd_debug(DEBUG_ERROR, " [0x%02X][0x%02X][0x%02X][0x%02X]" "[0x%02X][0x%02X][0x%02X][0x%02X]\n", @@ -402,7 +400,7 @@ s32 tcbd_recv_mail( mail_data[6], mail_data[7]); ret = -TCERR_BROKEN_MAIL_HEADER; - goto exittcbd_recv_mail; + goto exit_recv_mail; } _mail->cmd = mail_hdr & 0xFFFF; _mail->status = (mail_hdr >> 16) & 0x7; @@ -410,18 +408,18 @@ s32 tcbd_recv_mail( tcbd_debug(DEBUG_ERROR, "Mail Error : status=0x%X, cmd=0x%X\n", _mail->status, _mail->cmd); ret = -TCERR_UNKNOWN_MAIL_STATUS; - goto exittcbd_recv_mail; + goto exit_recv_mail; } _mail->count = (bytes_read >> 2) - 1; memcpy(_mail->data, mail_data + 4, bytes_read - 4); -exittcbd_recv_mail: +exit_recv_mail: tcpal_unlock(&tcbd_io_funcs.sem); return ret; } -s32 tcbd_read_mail_box( - struct tcbd_device *_device, u16 _cmd, s32 _cnt, u32 *_data) +s32 tcbd_read_mail_box(struct tcbd_device *_device, u16 _cmd, s32 _cnt, + u32 *_data) { s32 ret = 0; struct tcbd_mail_data mail = {0, }; @@ -432,17 +430,87 @@ s32 tcbd_read_mail_box( ret = tcbd_send_mail(_device, &mail); if (ret < 0) { tcbd_debug(DEBUG_ERROR, "failed to send mail! %d\n", ret); - goto exti_read_mail_box; + goto exit_read_mail_box; } ret = tcbd_recv_mail(_device, &mail); if (ret < 0) { tcbd_debug(DEBUG_ERROR, "failed to recv mail! %d\n", ret); - goto exti_read_mail_box; + goto exit_read_mail_box; } memcpy((void *)_data, (void *)mail.data, _cnt * sizeof(u32)); -exti_read_mail_box: +exit_read_mail_box: + return ret; +} + +s32 tcbd_write_mail_box(struct tcbd_device *_device, u16 _cmd, s32 _cnt, + u32 *_data) +{ + u32 *data = NULL; + struct tcbd_mail_data mail = {0, }; + + if (_cnt > MAX_MAIL_COUNT || _data == NULL) { + tcbd_debug(DEBUG_ERROR, "invalid param, cnt:%d\n", _cnt); + return -TCERR_INVALID_ARG; + } + + mail.flag = MB_CMD_WRITE; + mail.cmd = _cmd; + mail.count = _cnt; + memcpy((void *)mail.data, (void *)_data, _cnt * sizeof(u32)); +#if defined(__DEBUG_DSP_ROM__) + tcbd_debug_mbox_tx(&_cmd, &_cnt, &data); + if (data != NULL) { + int i, sz = 0; + char print_buff[80]; + mail.cmd = _cmd; + mail.count = _cnt; + memcpy((void *)mail.data, (void *)data, _cnt * sizeof(u32)); + for (i = 0; i < _cnt; i++) + sz += sprintf(print_buff + sz, "[%08X]", data[i]); + + tcbd_debug(DEBUG_ERROR, "cmd 0x%X, cnt:%d, %s\n", + _cmd, _cnt, print_buff); + } +#endif /*__DEBUG_DSP_ROM__*/ + return tcbd_send_mail(_device, &mail); +} + +#if defined(__DEBUG_DSP_ROM__) +s32 tcbd_read_file(struct tcbd_device *_device, char *_path, u8 *_buff, + s32 _size) +{ + int ret; + struct file *flip = NULL; + mm_segment_t old_fs; + + if (_path == NULL) { + tcbd_debug(DEBUG_ERROR, "invalid filename! %s\n", _path); + return -1; + } + + if (_buff == NULL) { + tcbd_debug(DEBUG_ERROR, "Invaild pointer! 0x%X\n", (u32)_buff); + return -1; + } + + flip = filp_open(_path, O_RDWR, 0); + if (IS_ERR(flip)) { + tcbd_debug(DEBUG_ERROR, "%s open failed\n", _path); + return -1; + } + + old_fs = get_fs(); + set_fs(KERNEL_DS); + + flip->f_pos = 0; + ret = vfs_read(flip, _buff, _size, &flip->f_pos); + + filp_close(flip, NULL); + set_fs(old_fs); + return ret; } +#endif /*__DEBUG_DSP_ROM__*/ diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c index 96459ec..a5f81eb 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c @@ -50,7 +50,7 @@ struct tcbd_boot_bin { static u32 clock_config_table[3][5] = { { 0x60, 0x00, 0x0F, 0x03, 19200}, - { 0x60, 0x00, 0x0C, 0x03, 24576}, + { 0x60, 0x01, 0x18, 0x03, 24576}, { 0x60, 0x01, 0x0F, 0x03, 38400} }; @@ -70,14 +70,27 @@ static struct tcbd_spur_data spur_data_table_default[] = { }; static struct tcbd_spur_data spur_data_table_24576[] = { + { 180064, 2, {(0x03C3<<16)|(0x030D), (0x03C2<<16)|(0x0308)} }, { 184736, 2, {(0x0092<<16)|(0x033A), (0x0098<<16)|(0x0332)} }, + { 188928, 2, {(0x00B1<<16)|(0x034F), (0x00B5<<16)|(0x034B)} }, + { 189008, 2, {(0x00C6<<16)|(0x0366), (0x00CA<<16)|(0x0363)} }, + { 195936, 2, {(0x0328<<16)|(0x037F), (0x0324<<16)|(0x037C)} }, { 196736, 2, {(0x0030<<16)|(0x030F), (0x0032<<16)|(0x0305)} }, - { 199280, 2, {(0x0373<<16)|(0x0337), (0x036D<<16)|(0x032F)} }, - { 205280, 2, {(0x00A5<<16)|(0x0349), (0x00AC<<16)|(0x0342)} }, - { 213008, 2, {(0x0006<<16)|(0x030A), (0x0006<<16)|(0x0300)} }, + { 199280, 2, {(0x000B<<16)|(0x030A), (0x000B<<16)|(0x0300)} }, + { 204640, 2, {(0x03C3<<16)|(0x030D), (0x03C2<<16)|(0x0308)} }, + { 205280, 2, {(0x039F<<16)|(0x031E), (0x039B<<16)|(0x0315)} }, + { 208736, 2, {(0x03C4<<16)|(0x0312), (0x03C2<<16)|(0x0308)} }, + { 213008, 2, {(0x0006<<16)|(0x0305), (0x0006<<16)|(0x0300)} }, + { 213360, 2, {(0x0086<<16)|(0x032C), (0x0089<<16)|(0x0328)} }, + { 229072, 2, {(0x038F<<16)|(0x031F), (0x038D<<16)|(0x031B)} }, + { 237488, 2, {(0x03E2<<16)|(0x0307), (0x03E1<<16)|(0x0302)} }, + { 1458096, 2, {(0x03E2<<16)|(0x0307), (0x03E1<<16)|(0x0302)} }, + { 1466656, 2, {(0x006B<<16)|(0x031E), (0x006D<<16)|(0x0319)} }, + { 1475216, 2, {(0x00D4<<16)|(0x037A), (0x00D8<<16)|(0x0377)} }, + { 1482064, 2, {(0x0325<<16)|(0x0384), (0x0321<<16)|(0x0382)} }, + { 1490624, 2, {(0x0389<<16)|(0x0322), (0x0387<<16)|(0x031E)} }, }; - #if defined(__AGC_TABLE_IN_DSP__) static struct tcbd_agc_data agc_data_table_lband[] = { {MBCMD_AGC_DAB_JAM, 3, @@ -159,7 +172,6 @@ s32 tcbd_send_spur_data(struct tcbd_device *_device, s32 _freq_khz) { s32 ret = 0, i; s32 size_table; - struct tcbd_mail_data mail = {0, }; struct tcbd_spur_data *spur_table; switch (_device->clock_type) { @@ -174,31 +186,27 @@ s32 tcbd_send_spur_data(struct tcbd_device *_device, s32 _freq_khz) size_table = ARRAY_SIZE(spur_data_table_default); break; } - mail.flag = MB_CMD_WRITE; - mail.cmd = MBCMD_FP_DAB_IIR; for (i = 0; i < size_table; i++) { - if (spur_table[i].freq_khz == _freq_khz) { - mail.count = spur_table[i].num_data; - memcpy(mail.data, spur_table[i].data, - mail.count * sizeof(u32)); - tcbd_debug(DEBUG_DRV_COMP, - "freq:%d, num mail data:%d\n", - _freq_khz, mail.count); - ret = tcbd_send_mail(_device, &mail); + if (spur_table[i].freq_khz != _freq_khz) + continue; + + tcbd_debug(DEBUG_DRV_COMP, "freq:%d, num mail data:%d\n", + _freq_khz, spur_table[i].num_data); + ret = tcbd_write_mail_box(_device, MBCMD_FP_DAB_IIR, + spur_table[i].num_data, + spur_table[i].data); break; } - } return ret; } -s32 tcbd_send_agc_data( - struct tcbd_device *_device, enum tcbd_band_type _band_type) +s32 tcbd_send_agc_data(struct tcbd_device *_device, + enum tcbd_band_type _band_type) { s32 ret = 0, i; s32 size_table; struct tcbd_agc_data *agc_table; - struct tcbd_mail_data mail = {0, }; switch (_band_type) { case BAND_TYPE_LBAND: @@ -210,20 +218,16 @@ s32 tcbd_send_agc_data( agc_table = agc_table_data_vhf; break; default: - tcbd_debug(DEBUG_ERROR, - "Unknown band type:%d\n", _band_type); + tcbd_debug(DEBUG_ERROR, "Unknown band type:%d\n", _band_type); return -1; } - tcbd_debug(DEBUG_DRV_COMP, "agc table size:%d, band:%s\n", - size_table, + tcbd_debug(DEBUG_DRV_COMP, "agc table size:%d, band:%s\n", size_table, (_band_type == BAND_TYPE_LBAND) ? "Lband" : "Band3"); - mail.flag = MB_CMD_WRITE; for (i = 0; i < size_table; i++) { - mail.cmd = agc_table[i].cmd; - mail.count = agc_table[i].num_data; - memcpy(mail.data, agc_table[i].data, mail.count * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); + ret |= tcbd_write_mail_box(_device, agc_table[i].cmd, + agc_table[i].num_data, + agc_table[i].data); } return ret; @@ -231,26 +235,19 @@ s32 tcbd_send_agc_data( s32 tcbd_send_frequency(struct tcbd_device *_device, s32 _freq_khz) { - s32 ret = 0; - struct tcbd_mail_data mail; + s32 data, ret = 0; tcbd_debug(DEBUG_DRV_COMP, "freq:%d\n", _freq_khz); - mail.flag = MB_CMD_WRITE; - mail.cmd = MBPARA_SYS_NUM_FREQ; - mail.count = 1; - mail.data[0] = 1; - ret |= tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SYS_FREQ_0_6; - mail.data[0] = _freq_khz; - ret |= tcbd_send_mail(_device, &mail); + data = 1; + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_NUM_FREQ, 1, &data); + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_FREQ_0_6, 1, &_freq_khz); return ret; } -static inline void tcbd_sort_start_cu( - struct tcbd_multi_service *_multi_svc, u32 *_svc_info) +static inline void tcbd_sort_start_cu(struct tcbd_multi_service *_multi_svc, + u32 *_svc_info) { s32 i, j; s32 start_cu[TCBD_MAX_NUM_SERVICE]; @@ -283,36 +280,24 @@ static inline void tcbd_sort_start_cu( } } for (i = 0; i < TCBD_MAX_NUM_SERVICE * 2; i++) - tcbd_debug(DEBUG_DRV_COMP, - "%02d: 0x%08X\n", i, _svc_info[i]); + tcbd_debug(DEBUG_DRV_COMP, "%02d: 0x%08X\n", i, _svc_info[i]); } s32 tcbd_send_service_info(struct tcbd_device *_device) { s32 ret = 0; - struct tcbd_mail_data mail = {0, } ; struct tcbd_multi_service *mult_service = &_device->mult_service; u32 sorted_svc_info[TCBD_MAX_NUM_SERVICE * 2]; u8 num_svc = TCBD_MAX_NUM_SERVICE; tcbd_sort_start_cu(mult_service, sorted_svc_info); - mail.cmd = MBPARA_SEL_CH_INFO_PRAM; - mail.count = num_svc; - memcpy(mail.data, sorted_svc_info, - num_svc * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SEL_CH_INFO_PRAM + 1; - mail.count = num_svc; - memcpy(mail.data, sorted_svc_info + num_svc, - num_svc * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SYS_DAB_MCI_UPDATE; - mail.count = 1; - mail.data[0] = mult_service->service_count; - ret |= tcbd_send_mail(_device, &mail); + ret = tcbd_write_mail_box(_device, MBPARA_SEL_CH_INFO_PRAM, + num_svc, sorted_svc_info); + ret |= tcbd_write_mail_box(_device, MBPARA_SEL_CH_INFO_PRAM + 1, + num_svc, sorted_svc_info + num_svc); + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_DAB_MCI_UPDATE, 1, + &mult_service->service_count); tcbd_debug(DEBUG_DRV_COMP, "service count:%d\n", mult_service->service_count); return ret; @@ -355,7 +340,7 @@ s32 tcbd_enable_buffer(struct tcbd_device *_device) ret |= tcbd_reg_write(_device, TCBD_OBUFF_CONFIG, buff_en); return ret; } - +/*__DEBUG_TCBD__*/ s32 tcbd_init_buffer_region(struct tcbd_device *_device) { s32 i, ret = 0; @@ -410,8 +395,7 @@ s32 tcbd_init_buffer_region(struct tcbd_device *_device) return ret; } -s32 tcbd_change_memory_view( - struct tcbd_device *_device, +s32 tcbd_change_memory_view(struct tcbd_device *_device, enum tcbd_remap_type _remap) { return tcbd_reg_write(_device, TCBD_INIT_REMAP, (u8)_remap); @@ -432,8 +416,7 @@ u32 tcbd_get_osc_clock(struct tcbd_device *_device) return clock_config_table[(int)_device->clock_type][4]; } -s32 tcbd_init_pll( - struct tcbd_device *_device, enum tcbd_clock_type _ctype) +s32 tcbd_init_pll(struct tcbd_device *_device, enum tcbd_clock_type _ctype) { /* * _pll_data[0] = PLL_WAIT_TIME @@ -453,7 +436,11 @@ s32 tcbd_init_pll( _device->clock_type = _ctype; - clock_config = clock_config_table[(s32)_ctype]; + if (!tcbd_debug_spur_dbg()) + clock_config = clock_config_table[(s32)_ctype]; + else + clock_config = tcbd_debug_spur_clk_cfg(); + tcbd_debug(DEBUG_DRV_COMP, "osc clock:%d, P:%X, M:%X, S:%d\n", clock_config[1], clock_config[2], clock_config[3], clock_config[4]); @@ -497,18 +484,15 @@ static s32 tcbd_check_dsp(struct tcbd_device *_device) _device, TCBD_MAIL_FIFO_WIND, (u8 *)&status, 4); if (status != 0x1ACCE551) { - tcbd_debug(DEBUG_ERROR, - " # Error access mail [0x%X]\n", status); + tcbd_debug(DEBUG_ERROR, " # Error access mail [0x%X]\n", + status); return -TCERR_CANNOT_ACCESS_MAIL; } return ret; } -s32 tcbd_reset_ip( - struct tcbd_device *_device, - u8 _comp_en, - u8 _comp_rst) +s32 tcbd_reset_ip(struct tcbd_device *_device, u8 _comp_en, u8 _comp_rst) { s32 ret = 0; _device->processor = _comp_en; @@ -521,18 +505,13 @@ s32 tcbd_reset_ip( s32 tcbd_change_stream_type(struct tcbd_device *_device, u32 _format) { - struct tcbd_mail_data mail = {0, }; - - mail.flag = MB_CMD_WRITE; - mail.cmd = MBPARA_SYS_DAB_STREAM_SET; - mail.count = 1; - mail.data[0] = _format; _device->selected_stream = _format; - return tcbd_send_mail(_device, &mail); + return tcbd_write_mail_box(_device, MBPARA_SYS_DAB_STREAM_SET, + 1, &_format); } -s32 tcbd_demod_tune_frequency( - struct tcbd_device *_device, u32 _freq_khz, s32 _bw_khz) +s32 tcbd_demod_tune_frequency(struct tcbd_device *_device, u32 _freq_khz, + s32 _bw_khz) { s32 ret = 0; u32 sel_stream = 0; @@ -562,6 +541,7 @@ s32 tcbd_demod_tune_frequency( if (_device->curr_band != _device->prev_band) tcbd_send_agc_data(_device, _device->curr_band); + ret |= tcbd_set_pid_filter(_device, FILTER_ENABLE | FILTER_SYNCERR); ret |= tcbd_dsp_warm_start(_device); return ret; } @@ -626,15 +606,14 @@ s32 tcbd_dsp_warm_start(struct tcbd_device *_device) ret |= tcbd_recv_mail(_device, &mail); if (ret < 0 || mail.data[0] != 0x1ACCE551) { - tcbd_debug(DEBUG_ERROR, - " # Could not warm boot! [%08X]\n", mail.data[0]); + tcbd_debug(DEBUG_ERROR, " # Could not warm boot! [%08X]\n", + mail.data[0]); return -TCERR_WARMBOOT_FAIL; } ret = tcbd_start_demod(_device); if (ret >= 0) - tcbd_debug(DEBUG_DRV_COMP, - "Warm boot succeed! [0x%X] ret:%d\n", + tcbd_debug(DEBUG_DRV_COMP, "Warm boot succeed! [0x%X] ret:%d\n", mail.data[0], ret); return ret; } @@ -747,23 +726,17 @@ s32 tcbd_init_dsp(struct tcbd_device *_device, u8 *_boot_code, s32 _size) ret |= tcbd_change_memory_view(_device, EP_RAM0_RAM1); for (i = 0; i < num_table_entry && boot_bin[i].size; i++) { - tcbd_debug(DEBUG_API_COMMON, - "# download boot to 0x%X, size %d\n", - boot_bin[i].addr, boot_bin[i].size); - ret |= tcbd_mem_write( - _device, - boot_bin[i].addr, - boot_bin[i].data, + tcbd_debug(DEBUG_API_COMMON, "# download boot to 0x%X, " + "size %d\n", boot_bin[i].addr, boot_bin[i].size); - ret |= tcbd_reg_read_burst_cont(_device, - TCBD_CMDDMA_CRC32, - (u8 *)&dma_crc, - 4); - if (boot_bin[i].crc && - (SWAP32(dma_crc) != boot_bin[i].crc)) { - tcbd_debug(DEBUG_ERROR, - "# CRC Error DMA[0x%08X] != BIN[0x%08X]\n", - dma_crc, boot_bin[i].crc); + ret |= tcbd_mem_write(_device, boot_bin[i].addr, + boot_bin[i].data, boot_bin[i].size); + ret |= tcbd_reg_read_burst_cont(_device, TCBD_CMDDMA_CRC32, + (u8 *)&dma_crc, 4); + if (boot_bin[i].crc && (SWAP32(dma_crc) != boot_bin[i].crc)) { + tcbd_debug(DEBUG_ERROR, "# CRC Error DMA[0x%08X] !=" + " BIN[0x%08X]\n", dma_crc, + boot_bin[i].crc); return -TCERR_CRC_FAIL; } } @@ -828,3 +801,8 @@ s32 tcbd_check_dsp_status(struct tcbd_device *_device) } return 0; } + +s32 tcbd_set_pid_filter(struct tcbd_device *_device, u32 _filter) +{ + return tcbd_write_mail_box(_device, MBPARA_SYS_DAB_DP_FLT, 1, &_filter); +} diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c index 143b52d..8a162f7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c @@ -163,7 +163,7 @@ s32 tcbd_init_peri_gpio( break; } - tcbd_reg_write_burst_cont(_device, TCBD_GPIO_ALT, cfg_value, 10); + tcbd_reg_write_burst_cont(_device, TCBD_GPIO_ALT, cfg_value, 2); /*tcbd_reg_write_burst_cont(_device, TCBD_GPIO_DRV, drv_strength, 2);*/ return 0; } @@ -172,41 +172,41 @@ s32 tcbd_select_peri( struct tcbd_device *_device, enum tcbd_peri_type _peri_type) { s32 ret = 0; - u8 periMode[4] = {0, }; - u8 interface_speed = tcbd_calc_clock(_device, 3000, 10000); + u8 peri_mode[4] = {0, }; + u8 interface_speed = 4; /*tcbd_calc_clock(_device, 3000, 10000);*/ tcbd_debug(DEBUG_DRV_PERI, "peri type:%d, clock div:%d\n", (s32)(_peri_type), interface_speed); switch (_peri_type) { case PERI_TYPE_SPI_SLAVE: - tcbd_peri_spi_slave(periMode, interface_speed); + tcbd_peri_spi_slave(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 2); + _device, TCBD_PERI_MODE0, peri_mode, 2); ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x90); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_SPI_SLAVE); break; case PERI_TYPE_SPI_MASTER: - tcbd_peri_spi_master(periMode, interface_speed); + tcbd_peri_spi_master(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 2); + _device, TCBD_PERI_MODE0, peri_mode, 2); ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x90); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_SPI_MASTER); break; case PERI_TYPE_PTS: - tcbd_peri_pts(periMode, interface_speed); + tcbd_peri_pts(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 4); + _device, TCBD_PERI_MODE0, peri_mode, 4); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_PTS); break; case PERI_TYPE_STS: - tcbd_peri_sts(periMode, interface_speed); + tcbd_peri_sts(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 4); + _device, TCBD_PERI_MODE0, peri_mode, 4); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_STS); break; case PERI_TYPE_HPI: - tcbd_peri_hpi(periMode); - ret |= tcbd_reg_write(_device, TCBD_PERI_MODE0, periMode[0]); + tcbd_peri_hpi(peri_mode); + ret |= tcbd_reg_write(_device, TCBD_PERI_MODE0, peri_mode[0]); break; case PERI_TYPE_SPI_ONLY: ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x80); diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_hal.c b/drivers/media/tdmb/tcc3170/src/tcbd_hal.c index 43c2eb3..fba77e7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_hal.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_hal.c @@ -30,7 +30,10 @@ #include "tcpal_os.h" #include "tcpal_debug.h" #include "tcbd_hal.h" +#include "tcbd_feature.h" +#define __USE_DXB0_IRQ__ +/*#define __USE_DXB1_IRQ__*/ #ifdef __USE_TC_CPU__ static PGPIO RGPIO; @@ -51,22 +54,38 @@ void tchal_reset_device(void) { #ifdef __USE_TC_CPU__ tcbd_debug(DEBUG_TCHAL, "\n"); - +#if defined(__CSPI_ONLY__) /* select peripheral mode as SPI */ +#if defined(__USE_DXB1_IRQ__) BITCLR(RGPIO->GPAFN1, Hw16 - Hw12); /* DXB1_IRQ Set GPIO mode*/ BITSET(RGPIO->GPAEN, Hw11); /* DXB1_IRQ output mode*/ BITCLR(RGPIO->GPADAT, Hw11); /* DXB1_IRQ clear*/ +#elif defined(__USE_DXB0_IRQ__) + BITCLR(RGPIO->GPDFN1, Hw8 - Hw4); /* DXB0_IRQ Set GPIO mode*/ + BITSET(RGPIO->GPDEN, Hw9); /* DXB0_IRQ output mode*/ + BITCLR(RGPIO->GPDDAT, Hw9); /* DXB0_IRQ clear*/ +#endif /*__USE_DXB1_IRQ__*/ +#endif /*__CSPI_ONLY__*/ /* reset */ +#if defined(__CSPI_ONLY__) BITCLR(RGPIO->GPEFN1, Hw16 - Hw12); /* DXB1_RST# Set GPIO mode */ BITSET(RGPIO->GPEEN, Hw11);/* DXB1_RST# Set GPIO Output mode*/ BITCLR(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Clear */ tcpal_msleep(10); BITSET(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Set*/ +#elif defined(__I2C_STS__) + BITCLR(RGPIO->GPDFN1, Hw4 - Hw0); /* DXB0_RST# Set GPIO mode */ + BITSET(RGPIO->GPDEN, Hw8); /* DXB0_RST# Set GPIO Output mode*/ + BITCLR(RGPIO->GPDDAT, Hw8); /* DXB0_RST# Clear */ + tcpal_msleep(10); + BITSET(RGPIO->GPDDAT, Hw8); /* DXB0_RST# Set*/ +#else /*__CSPI_ONLY__ || __I2C_STS__*/ +#error "you must define __CSPI_ONLY__ or __I2C_STS__" +#endif /*!__CSPI_ONLY__ && !__I2C_STS__*/ #endif } - void tchal_power_on_device(void) { #ifdef __USE_TC_CPU__ @@ -92,21 +111,30 @@ void tchal_power_down_device(void) BITCLR(RGPIO->GPEFN0, Hw16 - Hw12); BITSET(RGPIO->GPEEN, Hw3);/* DXB1_PD Set GPIO Output mode*/ BITCLR(RGPIO->GPEDAT, Hw3);/* DXB1_PD Clear*/ +#if defined(__CSPI_ONLY__) BITCLR(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Clear*/ - - BITCLR(RGPIO->GPAFN1, Hw16 - Hw12);/* DXB1_RST# Set GPIO mode*/ - BITSET(RGPIO->GPAEN, Hw11);/* DXB1_RST# Set GPIO Output mode*/ - BITCLR(RGPIO->GPADAT, Hw11);/* DXB1_RST# Clear*/ +#elif defined(__I2C_STS__) + BITCLR(RGPIO->GPDDAT, Hw8);/* DXB0_RST# Clear */ +#else +#error "you must define __CSPI_ONLY__ or __I2C_STS__" +#endif #endif } void tchal_irq_setup(void) { #ifdef __USE_TC_CPU__ +#if defined(__USE_DXB1_IRQ__) BITCLR(RGPIO->GPAFN1, Hw16 - Hw12);/* DXB1_IRQ Set GPIO mode*/ BITCLR(RGPIO->GPAEN, Hw11);/* DXB1_IRQ input mode*/ - BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 11<<24); + BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 11<<24); /*GPIO_A11*/ +#elif defined(__USE_DXB0_IRQ__) + BITCLR(RGPIO->GPDFN1, Hw8 - Hw4); /* DXB0_IRQ Set GPIO mode*/ + BITCLR(RGPIO->GPDEN, Hw9); /* DXB0_IRQ input mode*/ + + BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 20<<24); /*GPIO_D9*/ +#endif /*__USE_DXB1_IRQ__*/ BITSET(RPIC->POL0, 1<<IRQ_TC317X); #endif } diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c index db55f3d..229bcc1 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c @@ -27,8 +27,8 @@ #include "tcbd_stream_parser.h" #define SIZE_MSC_CACHE_BUFF (188*20) -#define SIZE_FIC_CACHE_BUFF (388*4) -#define SIZE_STATUS_CACHE_BUFF (32*4) +#define SIZE_FIC_CACHE_BUFF (388*2) +#define SIZE_STATUS_CACHE_BUFF (32*2) #if defined(__MERGE_EACH_TYPEOF_STREAM__) #define SIZE_MSC_STACK_BUFF (1024*16) @@ -39,12 +39,12 @@ #define MAX_SUBCH_ID (0x1<<6) enum tcbd_split_stream_state { STATE_NO_SYNC = 0, - STATE_READ_NEXT, STATE_OTHER, STATE_STATUS, STATE_MSC, STATE_FIC, STATE_GARBAGE, + STATE_ERROR }; #define HEADER_SIZE 4 @@ -66,6 +66,8 @@ struct merged_stream_info { #endif /* __MERGE_EACH_TYPEOF_STREAM__ */ struct tcbd_split_stream_data { + s32 dev_idx; + s32 header_err[2]; enum tcbd_split_stream_state state; s32 header_cnt; s32 remain; @@ -82,7 +84,7 @@ struct tcbd_split_stream_data { tcbd_stream_callback stream_callback; }; -static struct tcbd_split_stream_data tcbd_stream_spliter; +static struct tcbd_split_stream_data tcbd_stream_spliter[2]; static inline u8 tcbd_parity_check(u8 *parity) { @@ -94,139 +96,106 @@ static inline u8 tcbd_parity_check(u8 *parity) p = (p + ((parity[i] >> k) & 1)) & 1; } - if (p == 0) - tcbd_debug(DEBUG_ERROR, "Odd parity error\n"); - return p; } -static s32 tcbd_find_sync(struct tcbd_split_stream_data *_parser) -{ - s32 i; - s32 next_hdr, size = _parser->remain; - u8 *stream = _parser->buffer; - -#if defined(__FIND_HEADER_MORE__) - s32 j, first = 0, num_found = 0, data_size; -#endif /*__FIND_HEADER_MORE__ */ - - /* 1. SYNC_BYTE must exist at stream[3] */ - if ((stream[3] == SYNC_BYTE) && - (tcbd_parity_check(stream) == 1)) - return 0; - - /* 2. if SYNC_BYTE doesn't exist at stream[3] - then search SYNC_BYTE at whole stream*/ - for (i = 0; i < size; i++) { - if ((i < 3) || (stream[i] != SYNC_BYTE)) - continue; - - if (tcbd_parity_check(&stream[i - 3]) != 1) { - next_hdr = SWAP32(*((u32 *)&stream[i-3])); - tcbd_debug(DEBUG_ERROR, - "parity error!! find next byte, " - "offset:%d, header:0x%08X\n", - i, next_hdr); - continue; - } -#if !defined(__FIND_HEADER_MORE__) - tcbd_debug(DEBUG_STREAM_PARSER, - "found header offset %d\n", i-3); - return i - 3; -#else /* __FIND_HEADER_MORE__ */ - num_found = 1; - first = j = i - 3; - do { - data_size = - (stream[j + 1] << 7 | (stream[j+0] >> 1)) << 2; - j += (data_size + 4); - if (j >= size) - break; - - if ((stream[j + 3] == SYNC_BYTE) && - (tcbd_parity_check(stream + j) == 1)) { - tcbd_debug(DEBUG_STREAM_PARSER, - "header ok pos:%d," - "remain:%d\n", j, size); - num_found++; - } else { - next_hdr = - SWAP32(*((u32 *)(stream + j))); - tcbd_debug(DEBUG_ERROR, - "Header ERR!! [%02X] j = %d," - " size=%d, data_size:%d\n", - next_hdr, j, size, data_size); - num_found--; - break; - } - } while (j < size); - - if (num_found > 1) { - next_hdr = SWAP32(*((u32 *)(stream+first))); - tcbd_debug(DEBUG_STREAM_PARSER, - "offset:%d, header ok count : %d, 0x%08X\n", - first, num_found, next_hdr); - return first; - } -#endif /*__FIND_HEADER_MORE__*/ - } - return -i; -} +#define FIC_ID 0x00 +#define STATUS_ID 0x3F +#define GARBAGE_ID 0x04 +#define OTHER_CHIP_ID 0x3D -static inline s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) +static inline void tcbd_change_parser_state(struct op_header *header, + struct tcbd_split_stream_data *_parser) { - u8 *stream = _parser->buffer; - struct op_header *header = &_parser->header; + s32 size_limit[] = { -1, 4096, 32, 4096, 388, 4096}; + s8 *type[] = {NULL, "other", "status", "msc", "fic", "garbage"}; - if ((stream[3] != SYNC_BYTE) || - (tcbd_parity_check(stream) != 1)) { - tcbd_debug(DEBUG_ERROR, "wrong header! header:0x%08X\n", - SWAP32(*(u32 *)stream)); - memset(header, 0, sizeof(struct op_header)); - return HEADER_SIZE; - } - _parser->header_cnt++; - - header->sync = stream[3]; - header->type = (stream[2] & 0xC0) >> 6; - header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; - header->subch = stream[2] & 0x3F; - - _parser->state = STATE_NO_SYNC; switch ((enum DATA_TYPE)header->type) { case DATA_TYPE_MSC: - if (header->data_size != TCBD_FIC_SIZE) + if (header->data_size == 388) { + _parser->state = STATE_FIC; + header->type = DATA_TYPE_FIC; + } else _parser->state = STATE_MSC; break; case DATA_TYPE_FIC: - if (header->subch) + if (header->subch == GARBAGE_ID) _parser->state = STATE_GARBAGE; - else + else if (header->subch == FIC_ID) _parser->state = STATE_FIC; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_STATUS: - _parser->state = STATE_STATUS; + if (header->subch == STATUS_ID) + _parser->state = STATE_STATUS; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_OTHER: - _parser->state = STATE_OTHER; + if (header->subch == OTHER_CHIP_ID) + _parser->state = STATE_OTHER; + else + _parser->state = STATE_ERROR; break; default: + tcbd_debug(DEBUG_ERROR, "unknown data type!!"); + _parser->state = STATE_ERROR; + break; + } + switch (_parser->state) { + case STATE_ERROR: + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + break; + default: + if (size_limit[_parser->state] < header->data_size) { + tcbd_debug(DEBUG_ERROR, "wrong data size %s:%d!\n", + type[_parser->state], header->data_size); + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + + } else + _parser->header_cnt++; break; } - return HEADER_SIZE; } -static inline void tcbd_stack_chunk( - struct tcbd_split_stream_data *_parser, u8 *_buffer) +static s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) { - u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; + u8 *stream = _parser->buffer; struct op_header *header = &_parser->header; + _parser->state = STATE_NO_SYNC; + if ((stream[3] != SYNC_BYTE) || (tcbd_parity_check(stream) != 1)) { + _parser->header_err[0]++; + return HEADER_SIZE; + } + + header->sync = stream[3]; + header->type = (stream[2] & 0xC0) >> 6; + header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; + header->subch = stream[2] & 0x3F; + + tcbd_debug(DEBUG_PARSE_HEADER, "sync:0x%02X, type:%d, size:%d\n", + header->sync, header->type, + header->data_size); + tcbd_change_parser_state(header, _parser); + + return HEADER_SIZE; +} + #if defined(__MERGE_EACH_TYPEOF_STREAM__) +static void tcbd_merge_each_stream(struct tcbd_split_stream_data *_parser, + u8 *chunk_buff) +{ static u8 msc_buff[TCBD_MAX_NUM_SERVICE][SIZE_MSC_STACK_BUFF]; static u8 fic_buff[SIZE_FIC_STACK_BUFF]; static u8 status_buff[SIZE_STATUS_STACK_BUFF]; + struct merged_stream_info *merged; + struct op_header *header = &_parser->header; + s32 sz_stack_buff[] = { SIZE_MSC_STACK_BUFF, SIZE_FIC_STACK_BUFF, @@ -236,7 +205,7 @@ static inline void tcbd_stack_chunk( switch (header->type) { case DATA_TYPE_MSC: if (_parser->num_subch >= TCBD_MAX_NUM_SERVICE) { - tcbd_debug(DEBUG_ERROR, "error!\n"); + tcbd_debug(DEBUG_ERROR, "exceeded max num service!\n"); return; } if (_parser->quick_msc_idx[header->subch] == 0xFF) @@ -245,10 +214,8 @@ static inline void tcbd_stack_chunk( quick_msc_idx = _parser->quick_msc_idx[header->subch]; if (quick_msc_idx >= TCBD_MAX_NUM_SERVICE) - tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, " - "header->subch:%d\n", - quick_msc_idx, - header->subch); + tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, header->" + "subch:%d\n", quick_msc_idx, header->subch); merged = &_parser->merged_msc[quick_msc_idx]; merged->buffer = msc_buff[quick_msc_idx]; @@ -267,114 +234,29 @@ static inline void tcbd_stack_chunk( return; } - if (merged->curr_pos + header->data_size > - sz_stack_buff[header->type]) { + if (merged->curr_pos+header->data_size > sz_stack_buff[header->type]) { tcbd_debug(DEBUG_ERROR, "overflow stack buffer!!\n"); return; } - tcbd_debug(DEBUG_STREAM_STACK, - "type:%d, subchid:%d, buffer:%p currpos:%d, size:%d\n", - header->type, - header->subch, - merged->buffer, - merged->curr_pos, + tcbd_debug(DEBUG_STREAM_STACK, "type:%d, subchid:%u, buffer:%p " + "currpos:%d, size:%d\n", header->type, header->subch, + merged->buffer, merged->curr_pos, header->data_size); + memcpy(merged->buffer + merged->curr_pos, chunk_buff, header->data_size); - memcpy(merged->buffer + merged->curr_pos, - chunk_buff, header->data_size); merged->curr_pos += header->data_size; - -#else /* __MERGE_EACH_TYPEOF_STREAM__ */ - if (_parser->stream_callback) { - _parser->stream_callback( - chunk_buff, - header->data_size, - header->subch, - header->type); - } -#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ } -static s32 tcbd_push_chunk( - struct tcbd_split_stream_data *_parser, u8 *_cached_buff) -{ - s32 move, pre_copied; - u8 *buffer = _parser->buffer; - s8 *type[] = {"msc", "fic", "status", "other"}; - s32 size_cache_buff[] = { - SIZE_MSC_CACHE_BUFF, - SIZE_FIC_CACHE_BUFF, - SIZE_STATUS_CACHE_BUFF}; - struct op_header *header = &_parser->header; - - if (_parser->next_read) { - if (_parser->state != STATE_GARBAGE) { - pre_copied = header->data_size - _parser->next_read; - - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes, pre:%d," - " curr:%d, buffer:%p\n", - type[header->type], - header->data_size, - pre_copied, - _parser->next_read, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff + pre_copied, buffer, - _parser->next_read); - tcbd_stack_chunk(_parser, _cached_buff); - } - move = _parser->next_read; - _parser->state = STATE_NO_SYNC; - _parser->next_read = 0; - } else if (_parser->remain >= header->data_size) { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes\n", - type[header->type], - header->data_size); - tcbd_stack_chunk(_parser, NULL); - } - _parser->state = STATE_NO_SYNC; - move = header->data_size; - } else { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "keep %s data %d bytes buff:%p\n", - type[header->type], - _parser->remain, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff, buffer, _parser->remain); - } - _parser->next_read = header->data_size - _parser->remain; - move = _parser->remain; - } - return move; -} - -#if defined(__MERGE_EACH_TYPEOF_STREAM__) -static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) +static s32 tcbd_push_merged_stream(struct tcbd_split_stream_data *_parser) { register s32 i; struct merged_stream_info *merged = NULL; struct merged_stream_info *list_stream[] = { - NULL, - &_parser->merged_fic, - &_parser->merged_status, - NULL + NULL, &_parser->merged_fic, &_parser->merged_status, NULL }; tcbd_debug(DEBUG_STREAM_STACK, "header num:%d, num subch :%d\n", - tcbd_stream_spliter.header_cnt, _parser->num_subch); + _parser->header_cnt, _parser->num_subch); for (i = 0; i < _parser->num_subch; i++) { merged = &_parser->merged_msc[i]; if (!merged->buffer || !merged->curr_pos) @@ -382,10 +264,9 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback(merged->buffer, - merged->curr_pos, - merged->subch_id, - DATA_TYPE_MSC); + _parser->stream_callback(_parser->dev_idx, + merged->buffer, merged->curr_pos, + merged->subch_id, DATA_TYPE_MSC); merged->buffer = NULL; merged->curr_pos = 0; } @@ -398,7 +279,7 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback( + _parser->stream_callback(_parser->dev_idx, merged->buffer, merged->curr_pos, merged->subch_id, i); merged->buffer = NULL; @@ -409,97 +290,236 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) } #endif /*__MERGE_EACH_TYPEOF_STREAM__ */ -s32 tcbd_split_stream(u8 *_stream, s32 _size) +static void tcbd_stack_chunk(struct tcbd_split_stream_data *_parser, + u8 *_buffer) +{ + u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; +#if defined(__MERGE_EACH_TYPEOF_STREAM__) + tcbd_merge_each_stream(_parser, chunk_buff); +#else /* __MERGE_EACH_TYPEOF_STREAM__ */ + struct op_header *header = &_parser->header; + if (_parser->stream_callback) { + _parser->stream_callback(_parser->dev_idx, chunk_buff, + header->data_size, header->subch, header->type); + } +#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ +} + +static inline s32 tcbd_push_concat(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + s32 pre_copied, ret; + u8 *buffer = _parser->buffer; + struct op_header *header = &_parser->header; + + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + ret = HEADER_SIZE; + goto exit_func; + } + + pre_copied = header->data_size - _parser->next_read; + if (_parser->next_read > _parser->remain) { + memcpy(_cache_buff + pre_copied, buffer, _parser->remain); + _parser->next_read -= _parser->remain; + ret = _parser->remain; + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes, pre:%d," + "next:%d, buffer:%p\n", type[header->type], + _parser->remain, pre_copied, _parser->next_read, + _cache_buff); + } else { + memcpy(_cache_buff + pre_copied, buffer, _parser->next_read); + tcbd_stack_chunk(_parser, _cache_buff); + ret = _parser->next_read; + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes, pre:%d," + "curr:%d, buffer:%p\n", type[header->type], + header->data_size, pre_copied, + _parser->next_read, _cache_buff); + _parser->state = STATE_NO_SYNC; + } + +exit_func: + return ret; +} + +static inline void tcbd_push_medium(struct tcbd_split_stream_data *_parser) +{ + struct op_header *header = &_parser->header; + s8 *type[] = {"msc", "fic", "status", "other"}; + + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes\n", + type[header->type], header->data_size); + tcbd_stack_chunk(_parser, NULL); +} + +static inline s32 tcbd_cache_ramnant(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + struct op_header *header = &_parser->header; + u8 *buffer = _parser->buffer; + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes buff:%p\n", + type[header->type], _parser->remain, _cache_buff); + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + return HEADER_SIZE; + } else { + memcpy(_cache_buff, buffer, _parser->remain); + return _parser->remain; + } +} + +static s32 tcbd_push_chunk(struct tcbd_split_stream_data *_parser, + u8 *_cached_buff) +{ + s32 move; + struct op_header *header = &_parser->header; + + if (_parser->next_read) { + if (_parser->state != STATE_GARBAGE) + move = tcbd_push_concat(_parser, _cached_buff); + else { + if (_parser->next_read > _parser->remain) { + _parser->next_read -= _parser->remain; + move = _parser->remain; + } else { + move = _parser->next_read; + _parser->state = STATE_NO_SYNC; + } + } + } else if (_parser->remain >= header->data_size) { + if (_parser->state != STATE_GARBAGE) + tcbd_push_medium(_parser); + + _parser->state = STATE_NO_SYNC; + move = header->data_size; + } else { + if (_parser->state != STATE_GARBAGE) + move = tcbd_cache_ramnant(_parser, _cached_buff); + else + move = _parser->remain; + + _parser->next_read = header->data_size - _parser->remain; + } + + switch (_parser->state) { + case STATE_NO_SYNC: +#if defined(__USING_TS_IF__) + if (_parser->next_read == 0) + move += 188 - ((move + SIZE_BUFF_HEADER) % 188); + else + move += 188 - (move % 188); +#endif /*__USING_TS_IF__*/ + case STATE_ERROR: + _parser->state = STATE_NO_SYNC; + _parser->next_read = 0; + default: + break; + } + + return move; +} + +s32 tcbd_split_stream(s32 _dev_idx, u8 *_stream, s32 _size) { s32 ret = 0; register s32 point, move; - /* buffer for un-handled spare data of each interrupt */ static u8 cache_buff_msc[SIZE_MSC_CACHE_BUFF]; static u8 cache_buff_fic[SIZE_FIC_CACHE_BUFF]; static u8 buff_cache_status[SIZE_STATUS_CACHE_BUFF]; - u64 time; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; + u64 time = 0; point = move = 0; - tcbd_stream_spliter.remain = _size; - tcbd_stream_spliter.header_cnt = 0; + spliter->remain = _size; + spliter->header_cnt = 0; + memset(spliter->header_err, 0, sizeof(spliter->header_err)); time = tcpal_get_time(); - while (tcbd_stream_spliter.remain > 0) { - tcbd_stream_spliter.buffer = _stream + point; - switch (tcbd_stream_spliter.state) { + while (spliter->remain > 0) { + spliter->buffer = _stream + point; + switch (spliter->state) { case STATE_NO_SYNC: - ret = tcbd_find_sync(&tcbd_stream_spliter); - if (ret < 0) { - tcbd_debug(DEBUG_STREAM_PARSER, - "could not find sync byte!! %d\n", ret); - tcbd_init_parser(NULL); - return ret; - } else if (ret > 0) { - point += ret; - tcbd_stream_spliter.buffer += ret; - tcbd_stream_spliter.remain -= ret; - } - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); break; case STATE_OTHER: - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); tcbd_debug(DEBUG_ERROR, "State Other!! size:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; case STATE_MSC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_msc); + move = tcbd_push_chunk(spliter, cache_buff_msc); break; case STATE_FIC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_fic); + move = tcbd_push_chunk(spliter, cache_buff_fic); break; case STATE_STATUS: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - buff_cache_status); + move = tcbd_push_chunk(spliter, buff_cache_status); break; + case STATE_GARBAGE: - move = tcbd_push_chunk(&tcbd_stream_spliter, NULL); + move = tcbd_push_chunk(spliter, NULL); tcbd_debug(DEBUG_STREAM_PARSER, "State Garbage!:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; default: move = 0; point = 0; + spliter->state = STATE_NO_SYNC; + spliter->next_read = 0; tcbd_debug(DEBUG_ERROR, "something wrong!\n"); - break; + goto exit_func; } - tcbd_stream_spliter.remain -= move; + spliter->remain -= move; point += move; tcbd_debug(0, "remain:%d, point:%d, move:%d\n", - tcbd_stream_spliter.remain, point, move); + spliter->remain, point, move); } +exit_func: #if defined(__MERGE_EACH_TYPEOF_STREAM__) - ret = tcbd_push_stream(&tcbd_stream_spliter); + ret = tcbd_push_merged_stream(spliter); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ - tcbd_debug(DEBUG_PARSING_TIME, - "%lldms elapsed!\n", tcpal_diff_time(time)); + tcbd_debug(DEBUG_PARSING_TIME, "%lldms elapsed to parse!\n", + tcpal_diff_time(time)); + + if (spliter->header_err[0] || spliter->header_err[1]) + tcbd_debug(DEBUG_ERROR, "header err, parity:%d, state:%d\n", + spliter->header_err[0], spliter->header_err[1]); return ret; } -void tcbd_init_parser(tcbd_stream_callback _stream_callback) +void tcbd_init_parser(s32 _dev_idx, tcbd_stream_callback _stream_callback) { tcbd_stream_callback bak = NULL; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; - if (tcbd_stream_spliter.stream_callback) - bak = tcbd_stream_spliter.stream_callback; + if (spliter->stream_callback) + bak = spliter->stream_callback; - memset(&tcbd_stream_spliter, 0, sizeof(tcbd_stream_spliter)); + memset(spliter, 0, sizeof(struct tcbd_split_stream_data)); + spliter->dev_idx = _dev_idx; #if defined(__MERGE_EACH_TYPEOF_STREAM__) - memset(tcbd_stream_spliter.quick_msc_idx, 0xFF, - sizeof(tcbd_stream_spliter.quick_msc_idx)); + memset(spliter->quick_msc_idx, 0xFF, sizeof(spliter->quick_msc_idx)); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ if (_stream_callback) - tcbd_stream_spliter.stream_callback = _stream_callback; + spliter->stream_callback = _stream_callback; else if (bak) - tcbd_stream_spliter.stream_callback = bak; + spliter->stream_callback = bak; } diff --git a/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c b/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c index 3764bc1..8997c44 100644 --- a/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c +++ b/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c @@ -471,8 +471,8 @@ s32 tcc_fic_run_decoder(u8 *buff, s32 size) s32 num_broken_fib = 0; u16 fib_crc; - if (size != MAX_FIC_SIZE) { - tcbd_debug(DEBUG_ERROR, "invalid fic size!\n"); + if ((size%TCC_FIB_SIZE) != 0) { + tcbd_debug(DEBUG_ERROR, "invalid fic size:%d!\n", size); return -1; } while (size > cnt * TCC_FIB_SIZE) { diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c index 80edd00..abe8ca7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c @@ -20,14 +20,70 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <linux/module.h> -#include <linux/kernel.h> -#include <linux/moduleparam.h> - #include "tcpal_os.h" #include "tcpal_debug.h" -module_param(tcbd_debug_class, int, 0644); +static s32 tcbd_spur_dbg; + +static s32 tcbd_spur_clock_config[5] = {0x60, 0x00, 0x0F, 0x02, 76800}; +static s32 clock_config_count = 5; + +static s32 tcbd_rom_from_fs; +static char *tcbd_rom_path = "/tmp/tcc3170.rom"; + +static u32 tcbd_mbox_rx[9] = {0, }; +static u32 tcbd_mbox_tx[9*10] = {0, }; + +static s32 mbox_rx_data_len = 9; +static s32 mbox_tx_data_len = 9*10; + +module_param(tcbd_rom_from_fs, int, 0664); +module_param(tcbd_rom_path, charp, 0664); +module_param(tcbd_spur_dbg, int, 0664); +module_param_array(tcbd_spur_clock_config, int, &clock_config_count, 0664); +module_param_array(tcbd_mbox_rx, int, &mbox_rx_data_len, 0664); +module_param_array(tcbd_mbox_tx, int, &mbox_tx_data_len, 0664); + +void tcbd_debug_mbox_rx(u16 *_cmd, s32 *_cnt, u32 **_data) +{ + *_cmd = tcbd_mbox_rx[0]; + *_cnt = tcbd_mbox_rx[1]; + *_data = &tcbd_mbox_rx[2]; +} + +void tcbd_debug_mbox_tx(u16 *_cmd, s32 *_cnt, u32 **_data) +{ + s32 i; + + for (i = 0; i < 10; i++) { + if (tcbd_mbox_tx[i * 9] != *_cmd) + continue; + *_cmd = tcbd_mbox_tx[i * 9 + 0]; + *_cnt = tcbd_mbox_tx[i * 9 + 1]; + *_data = &tcbd_mbox_tx[i * 9 + 2]; + break; + } +} + +s32 tcbd_debug_spur_dbg(void) +{ + return tcbd_spur_dbg; +} + +s32 tcbd_debug_rom_from_fs(void) +{ + return tcbd_rom_from_fs; +} + +s32 *tcbd_debug_spur_clk_cfg(void) +{ + return tcbd_spur_clock_config; +} + +char *tcbd_debug_rom_path(void) +{ + return tcbd_rom_path; +} u32 tcbd_debug_class = DEBUG_API_COMMON | @@ -45,3 +101,6 @@ u32 tcbd_debug_class = /*DEBUG_INTRRUPT | */ DEBUG_INFO | DEBUG_ERROR; + +module_param(tcbd_debug_class, int, 0664); + diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c index aab737d..679c157 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c @@ -56,8 +56,8 @@ static s32 tcpal_i2c_probe( struct i2c_client *i2c, const struct i2c_device_id *id) { s32 ret = 0; - tcpal_i2c_client = i2c; + tcbd_debug(DEBUG_TCPAL_I2C, "tcpal_i2c_client : %p\n", i2c); return ret; } @@ -107,7 +107,7 @@ static s32 tcpal_i2c_add_device(void) i2c_put_adapter(adapter); if (!client) { tcbd_debug(DEBUG_TCPAL_I2C, - "can't add i2c device at %p\n", info.addr); + "can't add i2c device at 0x%X\n", info.addr); goto err_driver; } @@ -122,8 +122,6 @@ static s32 tcpal_i2c_close(void) { i2c_unregister_device(tcpal_i2c_client); i2c_del_driver(&tcpal_i2c_driver); - - tcbd_debug(DEBUG_TCPAL_I2C, "\n"); return 0; } diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c index 5f159b3..b6cadaa 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c @@ -38,8 +38,6 @@ #include "tcc_fic_decoder.h" #include "tcbd_hal.h" -#define __WORKQUEUE__ - struct tcbd_irq_data { struct work_struct work; struct workqueue_struct *work_queue; @@ -51,6 +49,7 @@ struct tcbd_irq_data { static struct tcbd_irq_data tcbd_irq_handler_data; +#if defined(__CSPI_ONLY__) static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) { s32 size, ret = 0; @@ -60,10 +59,12 @@ static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) struct tcbd_device *device = irq_data->device; ret = tcbd_read_irq_status(device, &irq_status, &irq_error); + ret |= tcbd_clear_irq(device, irq_status); + ret |= tcbd_read_stream(device, buff_read, &size); - if (ret == 0 && !irq_error) { - tcbd_split_stream(buff_read, size); - } else { + if (ret == 0 && !irq_error) + tcbd_split_stream(0, buff_read, size); + else { tcbd_debug(DEBUG_ERROR, "### buffer is full, skip the data " "(ret:%d, status=0x%02X, error=0x%02X, %d) ###\n", ret, irq_status, irq_error, @@ -74,26 +75,11 @@ static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) device->selected_buff, device->intr_threshold); /*tcbd_reset_ip(device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); + tcbd_init_parser(0, NULL); } - ret = tcbd_read_irq_status(device, &irq_status, &irq_error); - if (ret != 0 || irq_error != 0) { - tcbd_debug(DEBUG_ERROR, "### buffer is full, skip the data " - "(ret:%d, status=0x%02X, error=0x%02X) ###\n", - ret, irq_status, irq_error); - tcbd_init_stream_data_config(device, - ENABLE_CMD_FIFO, - device->selected_buff, - device->intr_threshold); - /*tcbd_reset_ip(device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); - - } - tcbd_clear_irq(device, irq_status); } -#if defined(__WORKQUEUE__) -static void tcpal_stream_parsing_work(struct work_struct *_param) +static void tcpal_work_parse_stream(struct work_struct *_param) { u64 diff = tcpal_diff_time(tcbd_irq_handler_data.start_tick); struct tcbd_irq_data *irq_data = @@ -106,28 +92,11 @@ static void tcpal_stream_parsing_work(struct work_struct *_param) tcpal_split_stream(irq_data); enable_irq(irq_data->tcbd_irq); } -#endif /*__WORKQUEUE__*/ - -static irqreturn_t tcpal_irq_handler(s32 _irq, void *_param) -{ - struct tcbd_irq_data *irq_data = (struct tcbd_irq_data *)_param; - struct tcbd_device *device = irq_data->device; - disable_irq_nosync(irq_data->tcbd_irq); - if (device->is_pal_irq_en) { -#if defined(__WORKQUEUE__) - irq_data->start_tick = tcpal_get_time(); - queue_work(irq_data->work_queue, &irq_data->work); -#else /*__WORKQUEUE__*/ - tcpal_split_stream(irq_data); -#endif /*!__WORKQUEUE__*/ - tcbd_debug(DEBUG_INTRRUPT, "\n"); - } - return IRQ_HANDLED; -} s32 start_tune; static s32 tcpal_irq_stream_callback( + s32 _dev_idx, u8 *_stream, s32 _size, u8 _subch_id, @@ -175,27 +144,77 @@ skip_fic_parse: } return 0; } +#endif /*__CSPI_ONLY__*/ + +#if defined(__I2C_STS__) +static void tcpal_work_read_fic(struct work_struct *_param) +{ + s32 size = TCBD_FIC_SIZE, ret; + u8 buff[TCBD_FIC_SIZE]; + u64 diff; + struct tcbd_irq_data *irq_data = container_of(_param, + struct tcbd_irq_data, work); + struct tcbd_device *device = irq_data->device; + + diff = tcpal_diff_time(irq_data->start_tick); + tcbd_debug(DEBUG_INTRRUPT, "work delay :%d\n", (u32)diff); + + ret = tcbd_read_fic_data(device, buff, size); + if (ret < 0) { + tcbd_debug(DEBUG_ERROR, "failed to read fic! %d\n", ret); + goto exit_work; + } + + tcbd_enqueue_data(buff, size, 0, 1); + if (!start_tune) /* set by tune_frequency*/ + goto exit_work; + + ret = tcc_fic_run_decoder(buff, MAX_FIC_SIZE); + if (ret > 0) { + tcc_fic_get_ensbl_info(1); + start_tune = 0; + tcc_fic_parser_init(); + } +exit_work: + enable_irq(irq_data->tcbd_irq); +} +#endif /*__I2C_STS__*/ + +static irqreturn_t tcpal_irq_handler(s32 _irq, void *_param) +{ + struct tcbd_irq_data *irq_data = (struct tcbd_irq_data *)_param; + struct tcbd_device *device = irq_data->device; + + disable_irq_nosync(irq_data->tcbd_irq); + if (device->is_pal_irq_en) { + irq_data->start_tick = tcpal_get_time(); + queue_work(irq_data->work_queue, &irq_data->work); + tcbd_debug(DEBUG_INTRRUPT, "\n"); + } + return IRQ_HANDLED; +} s32 tcpal_irq_register_handler(void *_device) { s32 ret; -#if defined(__WORKQUEUE__) + tcbd_irq_handler_data.work_queue = create_singlethread_workqueue("tdmb_work"); tcbd_irq_handler_data.device = (struct tcbd_device *)_device; #if defined(__USE_TC_CPU__) tcbd_irq_handler_data.tcbd_irq = IRQ_TC317X; #endif /*__USE_TC_CPU__*/ - INIT_WORK(&tcbd_irq_handler_data.work, tcpal_stream_parsing_work); -#endif /*__WORKQUEUE__*/ - tcbd_init_parser(tcpal_irq_stream_callback); - ret = request_irq( - tcbd_irq_handler_data.tcbd_irq, - tcpal_irq_handler, +#if defined(__I2C_STS__) + INIT_WORK(&tcbd_irq_handler_data.work, tcpal_work_read_fic); +#elif defined(__CSPI_ONLY__) + INIT_WORK(&tcbd_irq_handler_data.work, tcpal_work_parse_stream); + tcbd_init_parser(0, tcpal_irq_stream_callback); +#endif /*__CSPI_ONLY__*/ + + ret = request_irq(tcbd_irq_handler_data.tcbd_irq, tcpal_irq_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED, - "tdmb_irq", - &tcbd_irq_handler_data); + "tdmb_irq", &tcbd_irq_handler_data); tcbd_debug(DEBUG_INTRRUPT, "request_irq : %d\n", (int)ret); return ret; } @@ -211,7 +230,9 @@ s32 tcpal_irq_unregister_handler(void) s32 tcpal_irq_enable(void) { - tcbd_init_parser(NULL); +#if defined(__CSPI_ONLY__) + tcbd_init_parser(0, NULL); +#endif /*__CSPI_ONLY__*/ tcbd_debug(DEBUG_INTRRUPT, "\n"); /* enable_irq(tcbd_irq_handler_data.tcbd_irq); */ return 0; diff --git a/drivers/media/tdmb/tdmb.c b/drivers/media/tdmb/tdmb.c index 10ab8d3..b8f215a 100644 --- a/drivers/media/tdmb/tdmb.c +++ b/drivers/media/tdmb/tdmb.c @@ -50,6 +50,14 @@ #include <linux/io.h> #include <mach/gpio.h> +#if defined(CONFIG_TDMB_ANT_DET) +#include <linux/input.h> +#endif + +#ifdef CONFIG_MACH_C1 +#include <linux/wakelock.h> +static struct wake_lock tdmb_wlock; +#endif #include "tdmb.h" #define TDMB_PRE_MALLOC 1 @@ -75,20 +83,34 @@ static struct tdmb_drv_func *tdmbdrv_func; static bool tdmb_pwr_on; static bool tdmb_power_on(void) { - bool ret; - if (tdmb_create_databuffer(tdmbdrv_func->get_int_size()) == false) { - DPRINTK("%s : tdmb_create_databuffer fail\n", __func__); - ret = false; - } else if (tdmb_create_workqueue() == true) { - DPRINTK("%s : tdmb_create_workqueue ok\n", __func__); - ret = tdmbdrv_func->power_on(); - } else { - ret = false; + DPRINTK("tdmb_create_databuffer fail\n"); + goto create_databuffer_fail; } - tdmb_pwr_on = ret; - DPRINTK("%s : ret(%d)\n", __func__, ret); - return ret; + if (tdmb_create_workqueue() == false) { + DPRINTK("tdmb_create_workqueue fail\n"); + goto create_workqueue_fail; + } + if (tdmbdrv_func->power_on() == false) { + DPRINTK("power_on fail\n"); + goto power_on_fail; + } + + DPRINTK("power_on success\n"); +#ifdef CONFIG_MACH_C1 + wake_lock(&tdmb_wlock); +#endif + tdmb_pwr_on = true; + return true; + +power_on_fail: + tdmb_destroy_workqueue(); +create_workqueue_fail: + tdmb_destroy_databuffer(); +create_databuffer_fail: + tdmb_pwr_on = false; + + return false; } static bool tdmb_power_off(void) { @@ -98,10 +120,12 @@ static bool tdmb_power_off(void) tdmbdrv_func->power_off(); tdmb_destroy_workqueue(); tdmb_destroy_databuffer(); +#ifdef CONFIG_MACH_C1 + wake_unlock(&tdmb_wlock); +#endif tdmb_pwr_on = false; } tdmb_last_ch = 0; - return true; } @@ -518,6 +542,182 @@ static struct tdmb_drv_func *tdmb_get_drv_func(void) return func(); } +#if defined(CONFIG_TDMB_ANT_DET) + +static struct input_dev *tdmb_ant_input; +static int tdmb_check_ant; +static int ant_prev_status; + +#define TDMB_ANT_CHECK_DURATION 500000 +#define TDMB_ANT_CHECK_COUNT 2 +static bool tdmb_ant_det_check_value(void) +{ + int loop = 0; + int cur_val = 0, prev_val = 0; + bool ret = false; + + tdmb_check_ant = 1; + + prev_val = ant_prev_status ? 0 : 1; + for (loop = 0; loop < TDMB_ANT_CHECK_COUNT; loop++) { + usleep_range(TDMB_ANT_CHECK_DURATION, TDMB_ANT_CHECK_DURATION); + cur_val = gpio_get_value_cansleep(gpio_cfg.gpio_ant_det); + if (prev_val != cur_val || ant_prev_status == cur_val) + break; + prev_val = cur_val; + } + + if (loop == TDMB_ANT_CHECK_COUNT) { + if (ant_prev_status == 0 && cur_val == 1) + ret = true; + + ant_prev_status = cur_val; + } + + tdmb_check_ant = 0; + + DPRINTK("%s cnt(%d) cur(%d) ret(%d)\n", __func__, loop, cur_val, ret); + + return ret; +} + +static int tdmb_ant_det_ignore_irq(void) +{ + DPRINTK("%s tdmb_check_ant=%d\n", __func__, tdmb_check_ant); + return tdmb_check_ant; +} + +static void tdmb_ant_det_work_func(struct work_struct *work) +{ + int val = 0; + + if (!tdmb_ant_input) { + DPRINTK("%s: input device is not registered\n", __func__); + return; + } + + if (tdmb_ant_det_check_value()) { + input_report_key(tdmb_ant_input, KEY_DMB_ANT_DET_UP, 1); + input_report_key(tdmb_ant_input, KEY_DMB_ANT_DET_UP, 0); + input_sync(tdmb_ant_input); + DPRINTK("%s: sys_rev:%d\n", __func__, system_rev); + } +} + +static struct workqueue_struct *tdmb_ant_det_wq; +static DECLARE_WORK(tdmb_ant_det_work, tdmb_ant_det_work_func); +static bool tdmb_ant_det_reg_input(struct platform_device *pdev) +{ + struct input_dev *input; + int err; + + DPRINTK("%s\n", __func__); + + input = input_allocate_device(); + if (!input) { + DPRINTK("Can't allocate input device\n"); + err = -ENOMEM; + } + set_bit(EV_KEY, input->evbit); + set_bit(KEY_DMB_ANT_DET_UP & KEY_MAX, input->keybit); + set_bit(KEY_DMB_ANT_DET_DOWN & KEY_MAX, input->keybit); + input->name = "sec_dmb_key"; + input->phys = "sec_dmb_key/input0"; + input->dev.parent = &pdev->dev; + + err = input_register_device(input); + if (err) { + DPRINTK("Can't register dmb_ant_det key: %d\n", err); + goto free_input_dev; + } + tdmb_ant_input = input; + ant_prev_status = gpio_get_value_cansleep(gpio_cfg.gpio_ant_det); + + return true; + +free_input_dev: + input_free_device(input); + return false; +} + +static void tdmb_ant_det_unreg_input(void) +{ + DPRINTK("%s\n", __func__); + if (tdmb_ant_input) { + input_unregister_device(tdmb_ant_input); + tdmb_ant_input = NULL; + } +} +static bool tdmb_ant_det_create_wq(void) +{ + DPRINTK("%s\n", __func__); + tdmb_ant_det_wq = create_singlethread_workqueue("tdmb_ant_det_wq"); + if (tdmb_ant_det_wq) + return true; + else + return false; +} + +static bool tdmb_ant_det_destroy_wq(void) +{ + DPRINTK("%s\n", __func__); + if (tdmb_ant_det_wq) { + flush_workqueue(tdmb_ant_det_wq); + destroy_workqueue(tdmb_ant_det_wq); + tdmb_ant_det_wq = NULL; + } + return true; +} + +static irqreturn_t tdmb_ant_det_irq_handler(int irq, void *dev_id) +{ + int ret = 0; + + if (tdmb_ant_det_ignore_irq()) + return IRQ_HANDLED; + + if (tdmb_ant_det_wq) { + ret = queue_work(tdmb_ant_det_wq, &tdmb_ant_det_work); + if (ret == 0) + DPRINTK("%s queue_work fail\n", __func__); + } + + return IRQ_HANDLED; +} + +static bool tdmb_ant_det_irq_set(bool set) +{ + bool ret = true; + int irq_ret; + DPRINTK("%s\n", __func__); + + if (set) { + if (system_rev >= 6) + irq_set_irq_type(gpio_cfg.irq_ant_det + , IRQ_TYPE_EDGE_BOTH); + else + irq_set_irq_type(gpio_cfg.irq_ant_det + , IRQ_TYPE_EDGE_RISING); + + irq_ret = request_irq(gpio_cfg.irq_ant_det + , tdmb_ant_det_irq_handler + , IRQF_DISABLED + , "tdmb_ant_det" + , NULL); + if (irq_ret < 0) { + DPRINTK("%s %d\r\n", __func__, irq_ret); + ret = false; + } + enable_irq_wake(gpio_cfg.irq_ant_det); + } else { + disable_irq_wake(gpio_cfg.irq_ant_det); + free_irq(gpio_cfg.irq_ant_det, NULL); + } + + return ret; +} +#endif + static int tdmb_probe(struct platform_device *pdev) { int ret; @@ -561,12 +761,40 @@ static int tdmb_probe(struct platform_device *pdev) #if TDMB_PRE_MALLOC tdmb_make_ring_buffer(); #endif +#ifdef CONFIG_MACH_C1 + wake_lock_init(&tdmb_wlock, WAKE_LOCK_SUSPEND, "tdmb_wlock"); +#endif + +#if defined(CONFIG_TDMB_ANT_DET) + if (!tdmb_ant_det_reg_input(pdev)) + goto err_reg_input; + if (!tdmb_ant_det_create_wq()) + goto free_reg_input; + if (!tdmb_ant_det_irq_set(true)) + goto free_ant_det_wq; return 0; + +free_ant_det_wq: + tdmb_ant_det_destroy_wq(); +free_reg_input: + tdmb_ant_det_unreg_input(); +err_reg_input: + return -EFAULT; +#else + return 0; +#endif + } static int tdmb_remove(struct platform_device *pdev) { + DPRINTK("tdmb_remove!\n"); +#if defined(CONFIG_TDMB_ANT_DET) + tdmb_ant_det_unreg_input(); + tdmb_ant_det_destroy_wq(); + tdmb_ant_det_irq_set(false); +#endif return 0; } @@ -626,6 +854,9 @@ static void __exit tdmb_exit(void) platform_driver_unregister(&tdmb_driver); tdmb_exit_bus(); +#ifdef CONFIG_MACH_C1 + wake_lock_destroy(&tdmb_wlock); +#endif } module_init(tdmb_init); diff --git a/drivers/media/tdmb/tdmb_port_tcc3170.c b/drivers/media/tdmb/tdmb_port_tcc3170.c index b4daafb..b6e6abe 100644 --- a/drivers/media/tdmb/tdmb_port_tcc3170.c +++ b/drivers/media/tdmb/tdmb_port_tcc3170.c @@ -51,6 +51,7 @@ #include "tcbd_stream_parser.h" #include "tcc_fic_decoder.h" #include "tcbd_drv_ip.h" +#include "tcc_fic_decoder.h" #include "tcbd_hal.h" @@ -279,6 +280,7 @@ static s32 __set_frequency(unsigned long freqKHz, bool scan_mode) u8 status; tcbd_disable_irq(&tcc3170_device, 0); + tcc_fic_parser_init(); ret = tcbd_tune_frequency(&tcc3170_device, freqKHz, 1500); if (ret < 0) { DPRINTK("tcbd_tune_frequency fail %d\n", ret); @@ -387,9 +389,10 @@ static void tcc3170_pull_data(void) mutex_lock(&tcc3170_mutex); ret = tcbd_read_irq_status(&tcc3170_device, &irq_status, &irq_error); + ret |= tcbd_clear_irq(&tcc3170_device, irq_status); ret |= tcbd_read_stream(&tcc3170_device, buff_read, &size); if (ret == 0 && !irq_error) { - tcbd_split_stream(buff_read, size); + tcbd_split_stream(0, buff_read, size); } else { DPRINTK("### buffer is full, skip the data " "(ret:%d, status=0x%02X, error=0x%02X) ###\n", @@ -400,28 +403,13 @@ static void tcc3170_pull_data(void) tcc3170_device.selected_buff, tcc3170_device.intr_threshold); /*tcbd_reset_ip(device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); - } - ret = tcbd_read_irq_status(&tcc3170_device, &irq_status, &irq_error); - if (ret != 0 || irq_error != 0) { - DPRINTK("### buffer is full, skip the data " - "(ret:%d, status=0x%02X, error=0x%02X) ###\n", - ret, irq_status, irq_error); - tcbd_init_stream_data_config(&tcc3170_device, - ENABLE_CMD_FIFO, - tcc3170_device.selected_buff, - tcc3170_device.intr_threshold); - /*tcbd_reset_ip( - device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); - + tcbd_init_parser(0, NULL); } - tcbd_clear_irq(&tcc3170_device, irq_status); - mutex_unlock(&tcc3170_mutex); } static s32 __stream_callback( + s32 _dev_idx, u8 *_stream, s32 _size, u8 _subch_id, @@ -467,7 +455,7 @@ static bool tcc3170_init(void) #else #error #endif - tcbd_init_parser(__stream_callback); + tcbd_init_parser(0, __stream_callback); return true; } diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-core.c b/drivers/media/video/exynos/fimc-is/fimc-is-core.c index 59da8d1..58b0fbc 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-core.c +++ b/drivers/media/video/exynos/fimc-is/fimc-is-core.c @@ -357,6 +357,10 @@ static int fimc_is_probe(struct platform_device *pdev) snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s.isp", dev_name(&dev->pdev->dev)); ret = v4l2_device_register(NULL, v4l2_dev); + if (ret) { + v4l2_err(v4l2_dev, "Failed to register v4l2 device\n"); + goto err_vd_reg; + } snprintf(dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.name, sizeof(dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.name), @@ -385,10 +389,8 @@ static int fimc_is_probe(struct platform_device *pdev) ret = video_register_device(&dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd, VFL_TYPE_GRABBER, 30); - if (ret) { - v4l2_err(v4l2_dev, "Failed to register video device\n"); - goto err_vd_reg; - } + if (ret) + goto p_err_device_register; printk(KERN_INFO "FIMC-IS Video node :: ISP %d minor : %d\n", dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.num, @@ -412,6 +414,7 @@ static int fimc_is_probe(struct platform_device *pdev) dev->pdata->clk_get(pdev); } else { err("#### failed to Get Clock####\n"); + ret = -EINVAL; goto p_err_init_mem; } /* Init v4l2 sub device */ @@ -464,11 +467,11 @@ static int fimc_is_probe(struct platform_device *pdev) return 0; p_err_init_mem: - free_irq(dev->irq1, dev); #if defined(CONFIG_VIDEO_EXYNOS_FIMC_IS_BAYER) err_vd_reg: - video_device_release(&dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd); +p_err_device_register: #endif + free_irq(dev->irq1, dev); p_err_req_irq: p_err_get_irq: iounmap(dev->regs); diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-core.h b/drivers/media/video/exynos/fimc-is/fimc-is-core.h index 1309e96..82be1a1 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-core.h +++ b/drivers/media/video/exynos/fimc-is/fimc-is-core.h @@ -63,7 +63,7 @@ #define FIMC_IS_A5_MEM_SIZE 0x00A00000 #define FIMC_IS_REGION_SIZE 0x5000 -#define FIMC_IS_DEBUG_REGION_ADDR 0x00840000 +#define FIMC_IS_DEBUG_REGION_ADDR 0x0084B000 #define FIMC_IS_SHARED_REGION_ADDR 0x008C0000 #define FIMC_IS_FW_INFO_LENGTH 32 #define FIMC_IS_FW_VERSION_LENGTH 7 @@ -77,13 +77,23 @@ #define GED_FD_RANGE 1000 -#define BUS_LOCK_FREQ_L0 400200 -#define BUS_LOCK_FREQ_L1 267200 -#define BUS_LOCK_FREQ_L2 267160 -#define BUS_LOCK_FREQ_L3 160160 -#define BUS_LOCK_FREQ_L4 133133 -#define BUS_LOCK_FREQ_L5 100100 - +#ifdef CONFIG_MACH_T0 +#define BUS_LOCK_FREQ_L0 440293 +#define BUS_LOCK_FREQ_L1 440220 +#define BUS_LOCK_FREQ_L2 293220 +#define BUS_LOCK_FREQ_L3 293176 +#define BUS_LOCK_FREQ_L4 176176 +#define BUS_LOCK_FREQ_L5 147147 +#define BUS_LOCK_FREQ_L6 110110 +#else +#define BUS_LOCK_FREQ_L0 400266 +#define BUS_LOCK_FREQ_L1 400200 +#define BUS_LOCK_FREQ_L2 267200 +#define BUS_LOCK_FREQ_L3 267160 +#define BUS_LOCK_FREQ_L4 160160 +#define BUS_LOCK_FREQ_L5 133133 +#define BUS_LOCK_FREQ_L6 100100 +#endif /* A5 debug message setting */ #define FIMC_IS_DEBUG_MSG 0x3F #define FIMC_IS_DEBUG_LEVEL 3 diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-helper.c b/drivers/media/video/exynos/fimc-is/fimc-is-helper.c index ef0d163..8cac853 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-helper.c +++ b/drivers/media/video/exynos/fimc-is/fimc-is-helper.c @@ -31,6 +31,7 @@ #include <linux/gpio.h> #include <linux/gpio_event.h> #include <plat/gpio-cfg.h> +#include <plat/cpu.h> #include "fimc-is-core.h" #include "fimc-is-regs.h" @@ -1039,18 +1040,46 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) writel(id, dev->regs + ISSR1); switch (sensor_index) { case SENSOR_S5K3H2_CSI_A: + sensor_ext = (struct sensor_open_extended *) + &dev->is_p_region->shared; + sensor_ext->actuator_type = 1; + sensor_ext->mclk = 0; + sensor_ext->mipi_lane_num = 0; + sensor_ext->mipi_speed = 0; + sensor_ext->fast_open_sensor = 0; + sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; + fimc_is_mem_cache_clean((void *)dev->is_p_region, + IS_PARAM_SIZE); dev->af.use_af = 1; dev->sensor.sensor_type = SENSOR_S5K3H2_CSI_A; writel(SENSOR_NAME_S5K3H2, dev->regs + ISSR2); writel(SENSOR_CONTROL_I2C0, dev->regs + ISSR3); - writel(0x0, dev->regs + ISSR4); + writel(virt_to_phys(sensor_ext), dev->regs + ISSR4); break; case SENSOR_S5K3H2_CSI_B: + sensor_ext = (struct sensor_open_extended *) + &dev->is_p_region->shared; + sensor_ext->actuator_type = 1; + sensor_ext->mclk = 0; + sensor_ext->mipi_lane_num = 0; + sensor_ext->mipi_speed = 0; + sensor_ext->fast_open_sensor = 0; + sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; + fimc_is_mem_cache_clean((void *)dev->is_p_region, + IS_PARAM_SIZE); dev->af.use_af = 1; dev->sensor.sensor_type = SENSOR_S5K3H2_CSI_B; writel(SENSOR_NAME_S5K3H2, dev->regs + ISSR2); writel(SENSOR_CONTROL_I2C1, dev->regs + ISSR3); - writel(0x0, dev->regs + ISSR4); + writel(virt_to_phys(sensor_ext), dev->regs + ISSR4); break; case SENSOR_S5K6A3_CSI_A: sensor_ext = (struct sensor_open_extended *) @@ -1061,6 +1090,10 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) sensor_ext->mipi_speed = 0; sensor_ext->fast_open_sensor = 0; sensor_ext->self_calibration_mode = 1; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; fimc_is_mem_cache_clean((void *)dev->is_p_region, IS_PARAM_SIZE); dev->af.use_af = 0; @@ -1078,6 +1111,10 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) sensor_ext->mipi_speed = 0; sensor_ext->fast_open_sensor = 0; sensor_ext->self_calibration_mode = 1; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; fimc_is_mem_cache_clean((void *)dev->is_p_region, IS_PARAM_SIZE); dev->af.use_af = 0; @@ -1095,6 +1132,10 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) sensor_ext->mipi_speed = 0; sensor_ext->fast_open_sensor = 0; sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; fimc_is_mem_cache_clean((void *)dev->is_p_region, IS_PARAM_SIZE); dev->af.use_af = 1; @@ -1112,6 +1153,10 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) sensor_ext->mipi_speed = 0; sensor_ext->fast_open_sensor = 0; sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; fimc_is_mem_cache_clean((void *)dev->is_p_region, IS_PARAM_SIZE); dev->af.use_af = 1; @@ -1121,18 +1166,46 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) writel(virt_to_phys(sensor_ext), dev->regs + ISSR4); break; case SENSOR_S5K4E5_CSI_A: + sensor_ext = (struct sensor_open_extended *) + &dev->is_p_region->shared; + sensor_ext->actuator_type = 1; + sensor_ext->mclk = 0; + sensor_ext->mipi_lane_num = 0; + sensor_ext->mipi_speed = 0; + sensor_ext->fast_open_sensor = 0; + sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; + fimc_is_mem_cache_clean((void *)dev->is_p_region, + IS_PARAM_SIZE); dev->af.use_af = 1; dev->sensor.sensor_type = SENSOR_S5K4E5_CSI_A; writel(SENSOR_NAME_S5K4E5, dev->regs + ISSR2); writel(SENSOR_CONTROL_I2C0, dev->regs + ISSR3); - writel(0x0, dev->regs + ISSR4); + writel(virt_to_phys(sensor_ext), dev->regs + ISSR4); break; case SENSOR_S5K4E5_CSI_B: + sensor_ext = (struct sensor_open_extended *) + &dev->is_p_region->shared; + sensor_ext->actuator_type = 1; + sensor_ext->mclk = 0; + sensor_ext->mipi_lane_num = 0; + sensor_ext->mipi_speed = 0; + sensor_ext->fast_open_sensor = 0; + sensor_ext->self_calibration_mode = 0; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; + fimc_is_mem_cache_clean((void *)dev->is_p_region, + IS_PARAM_SIZE); dev->af.use_af = 1; dev->sensor.sensor_type = SENSOR_S5K4E5_CSI_B; writel(SENSOR_NAME_S5K4E5, dev->regs + ISSR2); writel(SENSOR_CONTROL_I2C1, dev->regs + ISSR3); - writel(0x0, dev->regs + ISSR4); + writel(virt_to_phys(sensor_ext), dev->regs + ISSR4); break; case SENSOR_S5K6A3_CSI_B_CUSTOM: sensor_ext = (struct sensor_open_extended *) @@ -1143,6 +1216,10 @@ void fimc_is_hw_open_sensor(struct fimc_is_dev *dev, u32 id, u32 sensor_index) sensor_ext->mipi_speed = 0; sensor_ext->fast_open_sensor = 6; sensor_ext->self_calibration_mode = 1; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + sensor_ext->i2c_sclk = 88000000; + else + sensor_ext->i2c_sclk = 80000000; fimc_is_mem_cache_clean((void *)dev->is_p_region, IS_PARAM_SIZE); dev->af.use_af = 0; diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-param.h b/drivers/media/video/exynos/fimc-is/fimc-is-param.h index 9383c4a..b978e16 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-param.h +++ b/drivers/media/video/exynos/fimc-is/fimc-is-param.h @@ -14,7 +14,7 @@ #ifndef FIMC_IS_PARAMS_H_ #define FIMC_IS_PARAMS_H_ -#define IS_REGION_VER 122 /* IS REGION VERSION 1.22 */ +#define IS_REGION_VER 124 /* IS REGION VERSION 1.24 */ /* MACROs */ #define IS_SET_PARAM_BIT(dev, num) \ @@ -237,6 +237,8 @@ (dev->is_p_region->parameter.isp.dma1_output.buffer_address = x) #define IS_ISP_SET_PARAM_DMA_OUTPUT1_NODIFY_DMA_DONE(dev, x) \ (dev->is_p_region->parameter.isp.dma1_output.notify_dma_done = x) +#define IS_ISP_SET_PARAM_DMA_OUTPUT1_MASK(dev, x) \ + (dev->is_p_region->parameter.isp.dma1_output.dma_out_mask = x) #define IS_ISP_SET_PARAM_DMA_OUTPUT1_ERR(dev, x) \ (dev->is_p_region->parameter.isp.dma1_output.err = x) @@ -260,6 +262,8 @@ (dev->is_p_region->parameter.isp.dma2_output.buffer_address = x) #define IS_ISP_SET_PARAM_DMA_OUTPUT2_NODIFY_DMA_DONE(dev, x) \ (dev->is_p_region->parameter.isp.dma2_output.notify_dma_done = x) +#define IS_ISP_SET_PARAM_DMA_OUTPUT2_MASK(dev, x) \ + (dev->is_p_region->parameter.isp.dma2_output.dma_out_mask = x) #define IS_ISP_SET_PARAM_DMA_OUTPUT2_ERR(dev, x) \ (dev->is_p_region->parameter.isp.dma2_output.err = x) @@ -1228,7 +1232,8 @@ struct param_dma_output { u32 buffer_number; u32 buffer_address; u32 notify_dma_done; - u32 reserved[PARAMETER_MAX_MEMBER-11]; + u32 dma_out_mask; + u32 reserved[PARAMETER_MAX_MEMBER-12]; u32 err; }; @@ -1697,5 +1702,8 @@ struct sensor_open_extended { u32 fast_open_sensor; /* Activatiing sensor self calibration mode (6A3) */ u32 self_calibration_mode; + /* This field is to adjust I2c clock based on ACLK200 */ + /* This value is varied in case of rev 0.2 */ + u32 i2c_sclk; }; #endif diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-v4l2.c b/drivers/media/video/exynos/fimc-is/fimc-is-v4l2.c index aa60198..066885f 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-v4l2.c +++ b/drivers/media/video/exynos/fimc-is/fimc-is-v4l2.c @@ -373,7 +373,7 @@ int fimc_is_s_power(struct v4l2_subdev *sd, int on) } #if defined(CONFIG_BUSFREQ_OPP) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER) /* lock bus frequency */ - dev_lock(is_dev->bus_dev, dev, BUS_LOCK_FREQ_L0); + dev_lock(is_dev->bus_dev, dev, BUS_LOCK_FREQ_L1); #endif fimc_is_hw_set_low_poweroff(is_dev, false); ret = pm_runtime_get_sync(dev); @@ -618,7 +618,7 @@ static int fimc_is_reset(struct v4l2_subdev *sd, u32 val) /* Restart */ #if defined(CONFIG_BUSFREQ_OPP) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER) /* lock bus frequency */ - dev_lock(is_dev->bus_dev, dev, BUS_LOCK_FREQ_L0); + dev_lock(is_dev->bus_dev, dev, BUS_LOCK_FREQ_L1); #endif fimc_is_hw_set_low_poweroff(is_dev, false); ret = pm_runtime_get_sync(dev); @@ -816,6 +816,16 @@ static int fimc_is_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) case V4L2_CID_IS_FW_DEBUG_REGION_ADDR: ctrl->value = dev->mem.base + FIMC_IS_DEBUG_REGION_ADDR; break; +#if defined(CONFIG_SLP) +#define FRONT_CAM_STANDARD_REVISION 0x0b + case V4L2_CID_PHYSICAL_ROTATION: + if (system_rev > FRONT_CAM_STANDARD_REVISION || \ + system_rev == 0x04 || system_rev == 0x06) + ctrl->value = IS_ROTATION_270; + else + ctrl->value = IS_ROTATION_90; + break; +#endif default: return -EINVAL; } diff --git a/drivers/media/video/exynos/fimc-is/fimc-is-video.c b/drivers/media/video/exynos/fimc-is/fimc-is-video.c index 85080af..6b81bb9 100644 --- a/drivers/media/video/exynos/fimc-is/fimc-is-video.c +++ b/drivers/media/video/exynos/fimc-is/fimc-is-video.c @@ -45,6 +45,11 @@ static struct fimc_is_fmt fimc_is_formats[] = { { + .name = "Bayer8", + .fourcc = V4L2_PIX_FMT_SGRBG8, + .flags = 1, + }, + { .name = "Bayer10", .fourcc = V4L2_PIX_FMT_SGRBG10, .flags = 1, @@ -233,6 +238,21 @@ static int fimc_is_isp_video_s_fmt_mplane(struct file *file, void *priv, pix = &f->fmt.pix_mp; switch (f->fmt.pix.pixelformat) { + case V4L2_PIX_FMT_SGRBG8: + width = pix->width - is_dev->sensor.offset_x; + height = pix->height - is_dev->sensor.offset_y; + IS_ISP_SET_PARAM_DMA_OUTPUT2_CMD(is_dev, + DMA_OUTPUT_COMMAND_DISABLE); + IS_ISP_SET_PARAM_DMA_OUTPUT2_WIDTH(is_dev, width); + IS_ISP_SET_PARAM_DMA_OUTPUT2_HEIGHT(is_dev, height); + IS_ISP_SET_PARAM_DMA_OUTPUT2_FORMAT(is_dev, + DMA_OUTPUT_FORMAT_BAYER); + IS_ISP_SET_PARAM_DMA_OUTPUT2_BITWIDTH(is_dev, + DMA_OUTPUT_BIT_WIDTH_8BIT); + IS_ISP_SET_PARAM_DMA_OUTPUT2_PLANE(is_dev, DMA_OUTPUT_PLANE_1); + IS_ISP_SET_PARAM_DMA_OUTPUT2_ORDER(is_dev, + DMA_OUTPUT_ORDER_GB_BG); + break; case V4L2_PIX_FMT_SGRBG10: width = pix->width - is_dev->sensor.offset_x; height = pix->height - is_dev->sensor.offset_y; @@ -518,6 +538,8 @@ static int fimc_is_isp_start_streaming(struct vb2_queue *q) + 32 * sizeof(u32)); IS_ISP_SET_PARAM_DMA_OUTPUT2_NODIFY_DMA_DONE(is_dev, DMA_OUTPUT_NOTIFY_DMA_DONE_ENBABLE); + /* All buffers are available to write image data */ + IS_ISP_SET_PARAM_DMA_OUTPUT2_MASK(is_dev, 0xFFFFFFFF); IS_SET_PARAM_BIT(is_dev, PARAM_ISP_DMA2_OUTPUT); IS_INC_PARAM_NUM(is_dev); diff --git a/drivers/media/video/exynos/fimc-lite/fimc-lite-core.c b/drivers/media/video/exynos/fimc-lite/fimc-lite-core.c index eddbf1d..011787c 100644 --- a/drivers/media/video/exynos/fimc-lite/fimc-lite-core.c +++ b/drivers/media/video/exynos/fimc-lite/fimc-lite-core.c @@ -2021,7 +2021,7 @@ static int flite_probe(struct platform_device *pdev) pdev->name); if (!regs_res) { dev_err(&pdev->dev, "Failed to request io memory region\n"); - goto err_resource; + goto err_flite; } flite->regs_res = regs_res; @@ -2044,8 +2044,10 @@ static int flite_probe(struct platform_device *pdev) } sd = kzalloc(sizeof(*sd), GFP_KERNEL); - if (!sd) - goto err_irq; + if (!sd) { + ret = -ENOMEM; + goto err_irq; + } v4l2_subdev_init(sd, &flite_subdev_ops); snprintf(sd->name, sizeof(sd->name), "flite-subdev.%d", flite->id); @@ -2062,13 +2064,13 @@ static int flite_probe(struct platform_device *pdev) mutex_init(&flite->lock); flite->mdev = flite_get_capture_md(MDEV_CAPTURE); if (IS_ERR_OR_NULL(flite->mdev)) - goto err_irq; + goto err_device_register; flite_dbg("mdev = 0x%08x", (u32)flite->mdev); ret = flite_register_video_device(flite); if (ret) - goto err_irq; + goto err_device_register; /* Get mipi-csis subdev ptr using mdev */ flite->sd_csis = flite->mdev->csis_sd[flite->id]; @@ -2130,6 +2132,8 @@ err_vfd_alloc: media_entity_cleanup(&flite->vfd->entity); video_device_release(flite->vfd); #endif +err_device_register: + kfree(sd); err_irq: free_irq(flite->irq, flite); err_reg_unmap: diff --git a/drivers/media/video/mhl/Kconfig b/drivers/media/video/mhl/Kconfig index f4ff2873..2dac8dd 100644 --- a/drivers/media/video/mhl/Kconfig +++ b/drivers/media/video/mhl/Kconfig @@ -27,4 +27,8 @@ config SAMSUNG_WORKAROUND_HPD_GLANCE depends on (SAMSUNG_MHL || MHL_SII9234) && (CPU_EXYNOS4210 || CPU_EXYNOS4212 || CPU_EXYNOS4412) default y +config SAMSUNG_MHL_UNPOWERED + bool "Use source vbus for mhl dongle if no external power" + depends on (SAMSUNG_MHL || MHL_SII9234) + default n endmenu diff --git a/drivers/media/video/mhl/sii9234.c b/drivers/media/video/mhl/sii9234.c index 8ca25c6..c728ea3 100644 --- a/drivers/media/video/mhl/sii9234.c +++ b/drivers/media/video/mhl/sii9234.c @@ -49,11 +49,16 @@ /*///////////////////////// definition area //////////////////////*/ /*////////////////////////////////////////////////////////////////////////////*/ -#define __CONFIG_USE_TIMER__ +#define __CONFIG_USE_TIMER__ #define __CONFIG_RSEN_LOST_PATCH__ -/* #define __CONFIG_MHL_SWING_LEVEL__ */ +/* #define __CONFIG_MHL_SWING_LEVEL__ */ #define __CONFIG_SS_FACTORY__ #define __CONFIG_MHL_DEBUG__ +#if defined(CONFIG_MACH_T0) || defined(CONFIG_MACH_M3) +# define __CONFIG_MHL_VER_1_2__ +#else +# define __CONFIG_MHL_VER_1_1__ +#endif /* #define __SII9234_MUTEX_DEBUG__ */ /*////////////////////////////////////////////////////////////////////////////*/ /*////////////////// dependence hader file area //////////////////////*/ @@ -176,7 +181,7 @@ static struct workqueue_struct *sii9234_msc_wq; #endif static struct cbus_packet cbus_pkt_buf[CBUS_PKT_BUF_COUNT]; -#ifdef __CONFIG_USE_TIMER__ +#ifdef __CONFIG_USE_TIMER__ static int cbus_command_abort_state; #endif @@ -207,6 +212,11 @@ static void goto_d3(void); void sii9234_wake_lock(void) { struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); + if (!sii9234 || !sii9234->pdata) { + pr_err("[ERROR] %s() MHL driver has not initailized.\n", + __func__); + return; + } wake_lock(&sii9234->mhl_wake_lock); pr_debug("%s()\n", __func__); } @@ -215,6 +225,11 @@ EXPORT_SYMBOL(sii9234_wake_lock); void sii9234_wake_unlock(void) { struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); + if (!sii9234 || !sii9234->pdata) { + pr_err("[ERROR] %s() MHL driver has not initailized.\n", + __func__); + return; + } wake_unlock(&sii9234->mhl_wake_lock); pr_debug("%s()\n", __func__); } @@ -222,62 +237,71 @@ EXPORT_SYMBOL(sii9234_wake_unlock); #endif #ifdef __CONFIG_MHL_SWING_LEVEL__ -static ssize_t sii9234_swing_test_show(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t size) +static ssize_t sii9234_swing_test_show(struct class *class, + struct class_attribute *attr, + char *buf) { struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); - return sprintf(buf, "mhl_show_value : 0x%x\n", - sii9234->pdata->swing_level); + return sprintf(buf, "mhl_show_value : 0%o(0x%x)\n", + sii9234->pdata->swing_level, sii9234->pdata->swing_level); } -static ssize_t sii9234_swing_test_store(struct device *dev, - struct device_attribute *attr, +static ssize_t sii9234_swing_test_store(struct class *class, + struct class_attribute *attr, const char *buf, size_t size) { struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); - - char temp[4] = { 0, }; const char *p = buf; - int data, clk; - unsigned int value; - - while (*p != '\0') { - if (!isspace(*p)) - strncat(temp, p, 1); - p++; - } + int data, clk, ret; + unsigned int base, value; - if (strlen(temp) != 2) - return -EINVAL; + if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) + base = 16; + else + base = 8; - kstrtoul(temp, 10, &value); - data = value / 10; - clk = value % 10; - sii9234->pdata->swing_level = 0xc0; - sii9234->pdata->swing_level = sii9234->pdata->swing_level - | (data << 3) | clk; - sprintf(buf, "mhl_store_value : 0x%x\n", sii9234->pdata->swing_level); + ret = kstrtouint(p, base, &value); + printk(KERN_INFO "\n%s(): ret = %d, value = %d(=0%o=0x%x)\n", __func__, + ret, value, value, value); + if (ret != 0 || value < 0 || value > 0xff) { + printk(KERN_INFO "[ERROR] %s(): The value is invald!", + __func__); + return size; + } + data = value & 070; + clk = value & 07; + sii9234->pdata->swing_level = 0300 | data | clk; + printk(KERN_INFO "%s(): mhl_store_value : 0%o(0x%x)\n", __func__, + sii9234->pdata->swing_level, sii9234->pdata->swing_level); return size; } -static CLASS_ATTR(swing, 0664, - sii9234_swing_test_show, sii9234_swing_test_store); +static CLASS_ATTR(swing, 0666, + sii9234_swing_test_show, sii9234_swing_test_store); #endif -#ifdef CONFIG_SAMSUNG_USE_11PIN_CONNECTOR -# if !defined(CONFIG_MACH_P4NOTE) +#if defined(CONFIG_SAMSUNG_USE_11PIN_CONNECTOR) && !defined(CONFIG_MACH_P4NOTE) static int is_mhl_cable_connected(void) { # ifdef CONFIG_SAMSUNG_SMARTDOCK - if (max77693_muic_get_status1_adc_value() == ADC_SMARTDOCK) - return 1; - else -# endif + if (max77693_muic_get_status1_adc_value() == ADC_SMARTDOCK) + return 1; + else + return max77693_muic_get_status1_adc1k_value(); +# else return max77693_muic_get_status1_adc1k_value(); +# endif } #endif +#ifdef CONFIG_SAMSUNG_WORKAROUND_HPD_GLANCE +bool sii9234_is_mhl_power_state_on(void) +{ + struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); + pr_info("%s(): %s\n", __func__, + sii9234->pdata->power_state ? "Yes" : "No"); + return sii9234->pdata->power_state == 1; +} #endif u8 mhl_onoff_ex(bool onoff) @@ -318,10 +342,6 @@ u8 mhl_onoff_ex(bool onoff) if (sii9234->pdata->hw_onoff) sii9234->pdata->hw_onoff(0); -#ifdef CONFIG_SAMSUNG_WORKAROUND_HPD_GLANCE - mhl_hpd_handler(false); -#endif - #ifdef CONFIG_SAMSUNG_USE_11PIN_CONNECTOR #if !defined(CONFIG_MACH_P4NOTE) ret = is_mhl_cable_connected(); @@ -679,8 +699,13 @@ static int sii9234_cbus_init(struct sii9234_data *sii9234) /*To meet cts 6.3.10.1 spec */ if (ret < 0) goto i2c_error_exit; +#if defined(__CONFIG_MHL_VER_1_1__) ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_MHL_VERSION, 0x11); /*mhl version 1.1 */ +#elif defined(__CONFIG_MHL_VER_1_2__) + ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_MHL_VERSION, 0x12); + /*mhl version 1.2 */ +#endif if (ret < 0) goto i2c_error_exit; ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_DEV_CAT, 0x02); @@ -696,8 +721,13 @@ static int sii9234_cbus_init(struct sii9234_data *sii9234) /* YCbCr444, RGB444 */ if (ret < 0) goto i2c_error_exit; +#ifdef CONFIG_VIDEO_TVOUT_5_1CH_AUDIO ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_AUD_LINK_MODE, 0x03); /* 8ch, 2ch */ +#else + ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_AUD_LINK_MODE, 0x01); + /* 2ch */ +#endif if (ret < 0) goto i2c_error_exit; ret = cbus_write_reg(sii9234, 0x80 + DEVCAP_VIDEO_TYPE, 0); @@ -1434,11 +1464,6 @@ static void goto_d3(void) sii9234->rsen = false; -#if defined(CONFIG_SAMSUNG_WORKAROUND_HPD_GLANCE) &&\ - defined(CONFIG_HAS_EARLYSUSPEND) - if (!sii9234->suspend_state) - mhl_hpd_handler(false); -#endif memset(cbus_pkt_buf, 0x00, sizeof(cbus_pkt_buf)); ret = sii9234_power_init(sii9234); @@ -1610,6 +1635,7 @@ static void goto_d3(void) return; exit: pr_err("[ERROR] %s() error terminated!\n", __func__); + schedule_work(&sii9234->mhl_end_work); return; } @@ -2250,7 +2276,7 @@ static int sii9234_detection_callback(void) pr_info("sii9234: Detection failed"); if (sii9234->state == STATE_DISCONNECTED) { pr_cont(" (timeout)"); - sii9234->pdata->power_state = 0; + schedule_work(&sii9234->mhl_end_work); } else if (sii9234->state == STATE_DISCOVERY_FAILED) pr_cont(" (discovery failed)"); else if (sii9234->state == NO_MHL_STATUS) @@ -2260,8 +2286,12 @@ static int sii9234_detection_callback(void) pr_cont("\n"); /*mhl spec: 8.3.3, if discovery failed, must retry discovering */ +#ifdef CONFIG_SAMSUNG_USE_11PIN_CONNECTOR if ((sii9234->state == STATE_DISCOVERY_FAILED) && (sii9234->rgnd == RGND_1K)) { +#else + if ((sii9234->state == STATE_DISCOVERY_FAILED)) { +#endif pr_cont("Discovery failed but RGND_1K impedence" " restart detection_callback"); @@ -2276,7 +2306,7 @@ static int sii9234_detection_callback(void) pr_info("sii9234: Detection failed"); if (sii9234->state == STATE_DISCONNECTED) { pr_cont(" (timeout)"); - sii9234->pdata->power_state = 0; + schedule_work(&sii9234->mhl_end_work); } else if (sii9234->state == STATE_DISCOVERY_FAILED) pr_cont(" (discovery failed)"); else if (sii9234->state == NO_MHL_STATUS) @@ -2286,8 +2316,12 @@ static int sii9234_detection_callback(void) pr_cont("\n"); /*mhl spec: 8.3.3, if discovery failed, must retry discovering */ +#ifdef CONFIG_SAMSUNG_USE_11PIN_CONNECTOR if ((sii9234->state == STATE_DISCOVERY_FAILED) && (sii9234->rgnd == RGND_1K)) { +#else + if ((sii9234->state == STATE_DISCOVERY_FAILED)) { +#endif pr_cont("Discovery failed but RGND_1K impedence" " restart detection_callback"); @@ -3344,7 +3378,7 @@ static irqreturn_t sii9234_irq_thread(int irq, void *data) * as per Page 0,0x79 Register */ sii9234->mhl_status_value.sink_hpd = true; -#ifdef __CONFIG_USE_TIMER__ +#ifdef __CONFIG_USE_TIMER__ if (cbus_command_abort_state == 1) { pr_debug("cbus_command_mod_timer\n"); mod_timer(&sii9234->cbus_command_timer, @@ -3412,7 +3446,7 @@ static irqreturn_t sii9234_irq_thread(int irq, void *data) * or MHL cable disconnection * TODO: Define the below mhl_disconnection() */ -#ifdef __CONFIG_USE_TIMER__ +#ifdef __CONFIG_USE_TIMER__ del_timer(&sii9234->cbus_command_timer); #endif msleep(T_SRC_RXSENSE_DEGLITCH); @@ -3450,7 +3484,7 @@ static irqreturn_t sii9234_irq_thread(int irq, void *data) cbus_resp_abort_error(sii9234); if (cbus_intr1 & MSC_REQ_ABORT) { -#ifdef __CONFIG_USE_TIMER__ +#ifdef __CONFIG_USE_TIMER__ cbus_write_reg(sii9234, CBUS_INTR1_ENABLE_REG, 0); cbus_req_abort_error(sii9234); cbus_write_reg(sii9234, CBUS_INTR1_ENABLE_REG, 0xFF); @@ -3516,7 +3550,13 @@ static irqreturn_t sii9234_irq_thread(int irq, void *data) if (mhl_poweroff) { if (sii9234_callback_sched != 0) { sii9234_disable_irq(); - schedule_work(&sii9234->mhl_d3_work); + if (sii9234->pdata->factory_test == 0) { + schedule_work(&sii9234->mhl_d3_work); + pr_info("%s() normal goto_d3\n", __func__); + } else { + pr_info("%s() skip goto_d3\n", __func__); + mhl_onoff_ex(0); + } } } return IRQ_HANDLED; @@ -3561,7 +3601,31 @@ static ssize_t sysfs_check_mhl_command(struct class *class, return size; } -static CLASS_ATTR(test_result, 0664, sysfs_check_mhl_command, NULL); +static ssize_t sysfs_check_factory_store(struct class *class, + struct class_attribute *attr, const char *buf, size_t size) +{ + struct sii9234_data *sii9234 = dev_get_drvdata(sii9244_mhldev); + const char *p = buf; + u8 value = 0; + + if (p[0] == '1') + value = 1; + else + value = 0; + + sii9234->pdata->factory_test = value; + + if (sii9234->pdata->factory_test == 1) + pr_info("sii9234: in factory mode\n"); + else + pr_info("sii9234: not factory mode\n"); + + return size; + +} + +static CLASS_ATTR(test_result, 0664, sysfs_check_mhl_command, + sysfs_check_factory_store); #endif /*__CONFIG_SS_FACTORY__*/ static ssize_t sysfs_mhl_read_reg_show(struct device *dev, @@ -3715,6 +3779,9 @@ static void sii9234_extcon_work(struct work_struct *work) sii9234->extcon_attached ? "attached" : "detached"); if (sii9234->extcon_attached) { +#ifdef CONFIG_JACK_MON + jack_event_handler("hdmi", 1); +#endif #ifdef CONFIG_SAMSUNG_MHL #ifdef CONFIG_MACH_MIDAS sii9234_wake_lock(); @@ -3723,6 +3790,9 @@ static void sii9234_extcon_work(struct work_struct *work) #endif } else { +#ifdef CONFIG_JACK_MON + jack_event_handler("hdmi", 0); +#endif #ifdef CONFIG_SAMSUNG_MHL mhl_onoff_ex(false); #ifdef CONFIG_MACH_MIDAS @@ -3815,6 +3885,7 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, goto err_exit1; } sii9234->pdata->mhl_tx_client = client; + sii9234->pdata->factory_test = 0; init_waitqueue_head(&sii9234->wq); mutex_init(&sii9234->lock); @@ -3847,14 +3918,6 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, pr_debug("%s(): wake lock is initialized.\n", __func__); #endif - ret = request_threaded_irq(client->irq, NULL, sii9234_irq_thread, - IRQF_TRIGGER_HIGH | IRQF_ONESHOT, - "sii9234", sii9234); - if (ret < 0) - goto err_exit1; - - atomic_set(&sii9234->is_irq_enabled, false); - disable_irq(client->irq); #ifdef __SII9234_IRQ_DEBUG__ en_irq = 0; #endif @@ -3866,6 +3929,7 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, printk(KERN_ERR "[ERROR] %s() workqueue create fail\n", __func__); ret = -ENOMEM; + goto err_msc_wq; } INIT_WORK(&sii9234->msc_work, sii9234_process_msc_work); #endif @@ -3877,17 +3941,27 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, printk(KERN_ERR "[ERROR] %s() tmds_offon" " workqueue create fail\n", __func__); ret = -ENOMEM; + goto err_tmds_offon_wq; } INIT_WORK(&sii9234->tmds_offon_work, sii9234_tmds_offon_work); #endif + ret = request_threaded_irq(client->irq, NULL, sii9234_irq_thread, + IRQF_TRIGGER_HIGH | IRQF_ONESHOT, + "sii9234", sii9234); + if (ret < 0) + goto err_exit_after_irq; + + atomic_set(&sii9234->is_irq_enabled, false); + disable_irq(client->irq); + #if defined(__CONFIG_SS_FACTORY__) || defined(__CONFIG_MHL_SWING_LEVEL__) pr_info("sii9234 : create mhl sysfile\n"); sec_mhl = class_create(THIS_MODULE, "mhl"); if (IS_ERR(sec_mhl)) { pr_err("[ERROR] Failed to create class(sec_mhl)!\n"); - goto err_exit1; + goto err_exit_after_irq; } #endif @@ -3912,12 +3986,14 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, sii9234->cbus_pkt.command = CBUS_IDLE; sii9234->cbus_pkt.offset = DEVCAP_DEV_STATE; +#ifdef __CONFIG_USE_TIMER__ init_timer(&sii9234->cbus_command_timer); sii9234->cbus_command_timer.function = mhl_cbus_command_timer; sii9234->cbus_command_timer.data = (unsigned int)NULL; sii9234->cbus_command_timer.expires = 0xffffffffL; add_timer(&sii9234->cbus_command_timer); +#endif #ifdef CONFIG_SII9234_RCP /* indicate that we generate key events */ set_bit(EV_KEY, input->evbit); @@ -3965,6 +4041,11 @@ static int __devinit sii9234_mhl_tx_i2c_probe(struct i2c_client *client, #ifdef __CONFIG_TMDS_OFFON_WORKAROUND__ sii9234->tmds_state = 0; #endif +#if defined(CONFIG_SAMSUNG_WORKAROUND_HPD_GLANCE) &&\ + !defined(CONFIG_SAMSUNG_MHL_9290) + is_mhl_power_state_on = sii9234_is_mhl_power_state_on; +#endif + return 0; #ifdef CONFIG_EXTCON @@ -3972,6 +4053,9 @@ err_extcon: extcon_unregister_interest(&sii9234->extcon_dev); #endif err_exit2c: +#ifdef __CONFIG_USE_TIMER__ + del_timer(&sii9234->cbus_command_timer); +#endif #ifdef __CONFIG_MHL_SWING_LEVEL__ class_remove_file(sec_mhl, &class_attr_swing); #endif @@ -3983,12 +4067,25 @@ err_extcon: #if defined(__CONFIG_SS_FACTORY__) || defined(__CONFIG_MHL_SWING_LEVEL__) class_destroy(sec_mhl); #endif - err_exit1: +err_exit_after_irq: + free_irq(client->irq, sii9234); +#ifdef __CONFIG_TMDS_OFFON_WORKAROUND__ +err_tmds_offon_wq: + destroy_workqueue(sii9234_tmds_offon_wq); +#endif + +#ifdef __MHL_NEW_CBUS_MSC_CMD__ +err_msc_wq: + destroy_workqueue(sii9234_msc_wq); +#endif + +err_exit1: #ifdef CONFIG_SII9234_RCP input_free_device(input); #endif - err_exit0: +err_exit0: kfree(sii9234); + sii9234 = NULL; return ret; } diff --git a/drivers/media/video/mhl/sii9234_driver.h b/drivers/media/video/mhl/sii9234_driver.h index 081e5f6..437d053 100644 --- a/drivers/media/video/mhl/sii9234_driver.h +++ b/drivers/media/video/mhl/sii9234_driver.h @@ -34,6 +34,10 @@ #define __CONFIG_TMDS_OFFON_WORKAROUND__ #endif +#ifndef __CONFIG_USE_TIMER__ +#define __CONFIG_USE_TIMER__ +#endif + #ifndef CONFIG_SII9234_RCP #define CONFIG_SII9234_RCP 1 #include <linux/input.h> @@ -533,7 +537,9 @@ struct sii9234_data { #ifdef __CONFIG_TMDS_OFFON_WORKAROUND__ struct work_struct tmds_offon_work; #endif +#ifdef __CONFIG_USE_TIMER__ struct timer_list cbus_command_timer; +#endif #ifdef CONFIG_MACH_MIDAS struct wake_lock mhl_wake_lock; #endif diff --git a/drivers/media/video/s5c73m3_spi.c b/drivers/media/video/s5c73m3_spi.c index 0b537cb..0b537cb 100755..100644 --- a/drivers/media/video/s5c73m3_spi.c +++ b/drivers/media/video/s5c73m3_spi.c diff --git a/drivers/media/video/s5k5bafx.h b/drivers/media/video/s5k5bafx.h index 00f4c88..00f4c88 100644..100755 --- a/drivers/media/video/s5k5bafx.h +++ b/drivers/media/video/s5k5bafx.h diff --git a/drivers/media/video/samsung/Kconfig b/drivers/media/video/samsung/Kconfig index 8421224..7ae9e6a 100644 --- a/drivers/media/video/samsung/Kconfig +++ b/drivers/media/video/samsung/Kconfig @@ -17,11 +17,8 @@ if CPU_EXYNOS4210 || CPU_EXYNOS4212 || CPU_EXYNOS4412 source "drivers/media/video/samsung/fimc/Kconfig" source "drivers/media/video/samsung/tvout/Kconfig" source "drivers/media/video/samsung/mfc5x/Kconfig" - source "drivers/media/video/samsung/ump/Kconfig" - source "drivers/media/video/samsung/tsi/Kconfig" -endif -if (CPU_EXYNOS4210 || CPU_EXYNOS4212 || CPU_EXYNOS4412) && !SLP - source "drivers/media/video/samsung/mali/Kconfig" + source "drivers/media/video/samsung/mali/Kconfig" + source "drivers/media/video/samsung/ump/Kconfig" endif config VIDEO_FIMG2D diff --git a/drivers/media/video/samsung/Makefile b/drivers/media/video/samsung/Makefile index 639d3bc..e9905d2 100644 --- a/drivers/media/video/samsung/Makefile +++ b/drivers/media/video/samsung/Makefile @@ -12,26 +12,8 @@ obj-$(CONFIG_VIDEO_FIMG2D3X) += fimg2d3x/ obj-$(CONFIG_VIDEO_FIMG2D4X) += fimg2d4x/ endif -ifeq ($(CONFIG_MACH_U1), y) obj-$(CONFIG_VIDEO_UMP) += ump/ -else ifeq ($(CONFIG_MACH_SMDKC210), y) -obj-$(CONFIG_VIDEO_UMP) += ump/ -else ifeq ($(CONFIG_MACH_SMDKV310), y) -obj-$(CONFIG_VIDEO_UMP) += ump/ -else -obj-$(CONFIG_VIDEO_UMP) += ump/ -endif - obj-$(CONFIG_VIDEO_TSI) += tsi/ - -ifeq ($(CONFIG_MACH_U1), y) -obj-$(CONFIG_VIDEO_MALI400MP) += mali/ -else ifeq ($(CONFIG_MACH_SMDKC210), y) -obj-$(CONFIG_VIDEO_MALI400MP) += mali/ -else ifeq ($(CONFIG_MACH_SMDKV310), y) obj-$(CONFIG_VIDEO_MALI400MP) += mali/ -else -obj-$(CONFIG_VIDEO_MALI400MP) += mali/ -endif EXTRA_CFLAGS += -Idrivers/media/video diff --git a/drivers/media/video/samsung/jpeg_v2x/jpeg_dev.c b/drivers/media/video/samsung/jpeg_v2x/jpeg_dev.c index eb026ab..eb026ab 100644..100755 --- a/drivers/media/video/samsung/jpeg_v2x/jpeg_dev.c +++ b/drivers/media/video/samsung/jpeg_v2x/jpeg_dev.c diff --git a/drivers/media/video/samsung/mali/Kconfig b/drivers/media/video/samsung/mali/Kconfig index ae9bd7d..1736eed 100644 --- a/drivers/media/video/samsung/mali/Kconfig +++ b/drivers/media/video/samsung/mali/Kconfig @@ -38,6 +38,14 @@ int "Dedicated Memory Size" default "128" ---help--- This value is dedicated memory size of Mali GPU(unit is MByte). + +config MALI_R3P1_LSI + bool "Uses the R3P1 as a kernel module" + depends on VIDEO_MALI400MP + default n + ---help--- + This uses the r3p1 as a MALI kernel module + # For DEBUG config VIDEO_MALI400MP_DEBUG diff --git a/drivers/media/video/samsung/mali/Makefile_module b/drivers/media/video/samsung/mali/Makefile_module index 4fb0226..4fb0226 100644..100755 --- a/drivers/media/video/samsung/mali/Makefile_module +++ b/drivers/media/video/samsung/mali/Makefile_module diff --git a/drivers/media/video/samsung/mali/arch b/drivers/media/video/samsung/mali/arch new file mode 120000 index 0000000..58ffbe7 --- /dev/null +++ b/drivers/media/video/samsung/mali/arch @@ -0,0 +1 @@ +arch-release
\ No newline at end of file diff --git a/drivers/media/video/samsung/mali/arch-debug b/drivers/media/video/samsung/mali/arch-debug new file mode 120000 index 0000000..0ed0909 --- /dev/null +++ b/drivers/media/video/samsung/mali/arch-debug @@ -0,0 +1 @@ +arch-pegasus-m400/
\ No newline at end of file diff --git a/drivers/media/video/samsung/mali/arch-debug/config.h b/drivers/media/video/samsung/mali/arch-debug/config.h deleted file mode 100644 index d5196c3..0000000 --- a/drivers/media/video/samsung/mali/arch-debug/config.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_H__ -#define __ARCH_CONFIG_H__ - -/* Configuration for the EB platform with ZBT memory enabled */ -/*zepplin added 2010.08.17 for orion configuration*/ -#define MALI_BASE_ADDR 0x13000000 -#define GP_ADDR MALI_BASE_ADDR -#define L2_ADDR MALI_BASE_ADDR+0x1000 -#define PMU_ADDR MALI_BASE_ADDR+0x2000 -#define GP_MMU_ADDR MALI_BASE_ADDR+0x3000 -#define PP0_MMU_ADDR MALI_BASE_ADDR+0x4000 -#define PP1_MMU_ADDR MALI_BASE_ADDR+0x5000 -#define PP2_MMU_ADDR MALI_BASE_ADDR+0x6000 -#define PP3_MMU_ADDR MALI_BASE_ADDR+0x7000 -#define PP0_ADDR MALI_BASE_ADDR+0x8000 -#define PP1_ADDR MALI_BASE_ADDR+0xA000 -#define PP2_ADDR MALI_BASE_ADDR+0xC000 -#define PP3_ADDR MALI_BASE_ADDR+0xE000 - -/*for mmu and os memory*/ -#define MEM_BASE_ADDR 0x40000000 -#define MEM_TOTAL_SIZE 0x40000000 -#define MEM_MALI_OS_SIZE 0x40000000 - -/*for dedicated memory*/ -//#define MEM_MALI_BASE 0x58000000 -//#define MEM_MALI_SIZE 0x08000000 -#define MEM_MALI_SIZE CONFIG_MALI_MEM_SIZE*1024*1024 -#define MEM_MALI_BASE 0x80000000 - MEM_MALI_SIZE - -static _mali_osk_resource_t arch_configuration [] = -{ - { - .type = MALI400GP, - .description = "Mali-400 GP", - .base = GP_ADDR, - .irq = IRQ_GP_3D, - .mmu_id = 1 - }, - { - .type = MALI400PP, - .base = PP0_ADDR, - .irq = IRQ_PP0_3D, - .description = "Mali-400 PP 0", - .mmu_id = 2 - }, - { - .type = MALI400PP, - .base = PP1_ADDR, - .irq = IRQ_PP1_3D, - .description = "Mali-400 PP 1", - .mmu_id = 3 - }, - { - .type = MALI400PP, - .base = PP2_ADDR, - .irq = IRQ_PP2_3D, - .description = "Mali-400 PP 2", - .mmu_id = 4 - }, - { - .type = MALI400PP, - .base = PP3_ADDR, - .irq = IRQ_PP3_3D, - .description = "Mali-400 PP 3", - .mmu_id = 5 - }, -#if USING_MMU - { - .type = MMU, - .base = GP_MMU_ADDR, - .irq = IRQ_GPMMU_3D, - .description = "Mali-400 MMU for GP", - .mmu_id = 1 - }, - { - .type = MMU, - .base = PP0_MMU_ADDR, - .irq = IRQ_PPMMU0_3D, - .description = "Mali-400 MMU for PP 0", - .mmu_id = 2 - }, - { - .type = MMU, - .base = PP1_MMU_ADDR, - .irq = IRQ_PPMMU1_3D, - .description = "Mali-400 MMU for PP 1", - .mmu_id = 3 - }, - { - .type = MMU, - .base = PP2_MMU_ADDR, - .irq = IRQ_PPMMU2_3D, - .description = "Mali-400 MMU for PP 2", - .mmu_id = 4 - }, - { - .type = MMU, - .base = PP3_MMU_ADDR, - .irq = IRQ_PPMMU3_3D, - .description = "Mali-400 MMU for PP 3", - .mmu_id = 5 - }, -#if USING_OS_MEMORY - { - .type = OS_MEMORY, - .description = "System Memory", - .size = MEM_MALI_OS_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE - }, -#endif -#if USING_DED /* Dedicated Memory */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif/* if USING_OS_MEMORY*/ - { - .type = MEM_VALIDATION, - .description = "memory validation", - .base = MEM_BASE_ADDR, - .size = MEM_TOTAL_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#else /* Not using MMU */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif - { - .type = MALI400L2, - .base = L2_ADDR, - .description = "Mali-400 L2 cache" - }, -}; - -#endif /* __ARCH_CONFIG_H__ */ diff --git a/drivers/media/video/samsung/mali/arch-pb-virtex5-m300/config.h b/drivers/media/video/samsung/mali/arch-pb-virtex5-m300/config.h index e579526..e579526 100644..100755 --- a/drivers/media/video/samsung/mali/arch-pb-virtex5-m300/config.h +++ b/drivers/media/video/samsung/mali/arch-pb-virtex5-m300/config.h diff --git a/drivers/media/video/samsung/mali/arch-pegasus-m400/config.h b/drivers/media/video/samsung/mali/arch-pegasus-m400/config.h index d5196c3..d5196c3 100644..100755 --- a/drivers/media/video/samsung/mali/arch-pegasus-m400/config.h +++ b/drivers/media/video/samsung/mali/arch-pegasus-m400/config.h diff --git a/drivers/media/video/samsung/mali/arch-release b/drivers/media/video/samsung/mali/arch-release new file mode 120000 index 0000000..0ed0909 --- /dev/null +++ b/drivers/media/video/samsung/mali/arch-release @@ -0,0 +1 @@ +arch-pegasus-m400/
\ No newline at end of file diff --git a/drivers/media/video/samsung/mali/arch-release/config.h b/drivers/media/video/samsung/mali/arch-release/config.h deleted file mode 100644 index d5196c3..0000000 --- a/drivers/media/video/samsung/mali/arch-release/config.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_H__ -#define __ARCH_CONFIG_H__ - -/* Configuration for the EB platform with ZBT memory enabled */ -/*zepplin added 2010.08.17 for orion configuration*/ -#define MALI_BASE_ADDR 0x13000000 -#define GP_ADDR MALI_BASE_ADDR -#define L2_ADDR MALI_BASE_ADDR+0x1000 -#define PMU_ADDR MALI_BASE_ADDR+0x2000 -#define GP_MMU_ADDR MALI_BASE_ADDR+0x3000 -#define PP0_MMU_ADDR MALI_BASE_ADDR+0x4000 -#define PP1_MMU_ADDR MALI_BASE_ADDR+0x5000 -#define PP2_MMU_ADDR MALI_BASE_ADDR+0x6000 -#define PP3_MMU_ADDR MALI_BASE_ADDR+0x7000 -#define PP0_ADDR MALI_BASE_ADDR+0x8000 -#define PP1_ADDR MALI_BASE_ADDR+0xA000 -#define PP2_ADDR MALI_BASE_ADDR+0xC000 -#define PP3_ADDR MALI_BASE_ADDR+0xE000 - -/*for mmu and os memory*/ -#define MEM_BASE_ADDR 0x40000000 -#define MEM_TOTAL_SIZE 0x40000000 -#define MEM_MALI_OS_SIZE 0x40000000 - -/*for dedicated memory*/ -//#define MEM_MALI_BASE 0x58000000 -//#define MEM_MALI_SIZE 0x08000000 -#define MEM_MALI_SIZE CONFIG_MALI_MEM_SIZE*1024*1024 -#define MEM_MALI_BASE 0x80000000 - MEM_MALI_SIZE - -static _mali_osk_resource_t arch_configuration [] = -{ - { - .type = MALI400GP, - .description = "Mali-400 GP", - .base = GP_ADDR, - .irq = IRQ_GP_3D, - .mmu_id = 1 - }, - { - .type = MALI400PP, - .base = PP0_ADDR, - .irq = IRQ_PP0_3D, - .description = "Mali-400 PP 0", - .mmu_id = 2 - }, - { - .type = MALI400PP, - .base = PP1_ADDR, - .irq = IRQ_PP1_3D, - .description = "Mali-400 PP 1", - .mmu_id = 3 - }, - { - .type = MALI400PP, - .base = PP2_ADDR, - .irq = IRQ_PP2_3D, - .description = "Mali-400 PP 2", - .mmu_id = 4 - }, - { - .type = MALI400PP, - .base = PP3_ADDR, - .irq = IRQ_PP3_3D, - .description = "Mali-400 PP 3", - .mmu_id = 5 - }, -#if USING_MMU - { - .type = MMU, - .base = GP_MMU_ADDR, - .irq = IRQ_GPMMU_3D, - .description = "Mali-400 MMU for GP", - .mmu_id = 1 - }, - { - .type = MMU, - .base = PP0_MMU_ADDR, - .irq = IRQ_PPMMU0_3D, - .description = "Mali-400 MMU for PP 0", - .mmu_id = 2 - }, - { - .type = MMU, - .base = PP1_MMU_ADDR, - .irq = IRQ_PPMMU1_3D, - .description = "Mali-400 MMU for PP 1", - .mmu_id = 3 - }, - { - .type = MMU, - .base = PP2_MMU_ADDR, - .irq = IRQ_PPMMU2_3D, - .description = "Mali-400 MMU for PP 2", - .mmu_id = 4 - }, - { - .type = MMU, - .base = PP3_MMU_ADDR, - .irq = IRQ_PPMMU3_3D, - .description = "Mali-400 MMU for PP 3", - .mmu_id = 5 - }, -#if USING_OS_MEMORY - { - .type = OS_MEMORY, - .description = "System Memory", - .size = MEM_MALI_OS_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE - }, -#endif -#if USING_DED /* Dedicated Memory */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif/* if USING_OS_MEMORY*/ - { - .type = MEM_VALIDATION, - .description = "memory validation", - .base = MEM_BASE_ADDR, - .size = MEM_TOTAL_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#else /* Not using MMU */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif - { - .type = MALI400L2, - .base = L2_ADDR, - .description = "Mali-400 L2 cache" - }, -}; - -#endif /* __ARCH_CONFIG_H__ */ diff --git a/drivers/media/video/samsung/mali/arch/config.h b/drivers/media/video/samsung/mali/arch/config.h deleted file mode 100644 index d5196c3..0000000 --- a/drivers/media/video/samsung/mali/arch/config.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_H__ -#define __ARCH_CONFIG_H__ - -/* Configuration for the EB platform with ZBT memory enabled */ -/*zepplin added 2010.08.17 for orion configuration*/ -#define MALI_BASE_ADDR 0x13000000 -#define GP_ADDR MALI_BASE_ADDR -#define L2_ADDR MALI_BASE_ADDR+0x1000 -#define PMU_ADDR MALI_BASE_ADDR+0x2000 -#define GP_MMU_ADDR MALI_BASE_ADDR+0x3000 -#define PP0_MMU_ADDR MALI_BASE_ADDR+0x4000 -#define PP1_MMU_ADDR MALI_BASE_ADDR+0x5000 -#define PP2_MMU_ADDR MALI_BASE_ADDR+0x6000 -#define PP3_MMU_ADDR MALI_BASE_ADDR+0x7000 -#define PP0_ADDR MALI_BASE_ADDR+0x8000 -#define PP1_ADDR MALI_BASE_ADDR+0xA000 -#define PP2_ADDR MALI_BASE_ADDR+0xC000 -#define PP3_ADDR MALI_BASE_ADDR+0xE000 - -/*for mmu and os memory*/ -#define MEM_BASE_ADDR 0x40000000 -#define MEM_TOTAL_SIZE 0x40000000 -#define MEM_MALI_OS_SIZE 0x40000000 - -/*for dedicated memory*/ -//#define MEM_MALI_BASE 0x58000000 -//#define MEM_MALI_SIZE 0x08000000 -#define MEM_MALI_SIZE CONFIG_MALI_MEM_SIZE*1024*1024 -#define MEM_MALI_BASE 0x80000000 - MEM_MALI_SIZE - -static _mali_osk_resource_t arch_configuration [] = -{ - { - .type = MALI400GP, - .description = "Mali-400 GP", - .base = GP_ADDR, - .irq = IRQ_GP_3D, - .mmu_id = 1 - }, - { - .type = MALI400PP, - .base = PP0_ADDR, - .irq = IRQ_PP0_3D, - .description = "Mali-400 PP 0", - .mmu_id = 2 - }, - { - .type = MALI400PP, - .base = PP1_ADDR, - .irq = IRQ_PP1_3D, - .description = "Mali-400 PP 1", - .mmu_id = 3 - }, - { - .type = MALI400PP, - .base = PP2_ADDR, - .irq = IRQ_PP2_3D, - .description = "Mali-400 PP 2", - .mmu_id = 4 - }, - { - .type = MALI400PP, - .base = PP3_ADDR, - .irq = IRQ_PP3_3D, - .description = "Mali-400 PP 3", - .mmu_id = 5 - }, -#if USING_MMU - { - .type = MMU, - .base = GP_MMU_ADDR, - .irq = IRQ_GPMMU_3D, - .description = "Mali-400 MMU for GP", - .mmu_id = 1 - }, - { - .type = MMU, - .base = PP0_MMU_ADDR, - .irq = IRQ_PPMMU0_3D, - .description = "Mali-400 MMU for PP 0", - .mmu_id = 2 - }, - { - .type = MMU, - .base = PP1_MMU_ADDR, - .irq = IRQ_PPMMU1_3D, - .description = "Mali-400 MMU for PP 1", - .mmu_id = 3 - }, - { - .type = MMU, - .base = PP2_MMU_ADDR, - .irq = IRQ_PPMMU2_3D, - .description = "Mali-400 MMU for PP 2", - .mmu_id = 4 - }, - { - .type = MMU, - .base = PP3_MMU_ADDR, - .irq = IRQ_PPMMU3_3D, - .description = "Mali-400 MMU for PP 3", - .mmu_id = 5 - }, -#if USING_OS_MEMORY - { - .type = OS_MEMORY, - .description = "System Memory", - .size = MEM_MALI_OS_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE - }, -#endif -#if USING_DED /* Dedicated Memory */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif/* if USING_OS_MEMORY*/ - { - .type = MEM_VALIDATION, - .description = "memory validation", - .base = MEM_BASE_ADDR, - .size = MEM_TOTAL_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#else /* Not using MMU */ - { - .type = MEMORY, - .description = "Dedicated Memory", - .base = MEM_MALI_BASE, - .size = MEM_MALI_SIZE, - .flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE | _MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE - }, -#endif - { - .type = MALI400L2, - .base = L2_ADDR, - .description = "Mali-400 L2 cache" - }, -}; - -#endif /* __ARCH_CONFIG_H__ */ diff --git a/drivers/media/video/samsung/mali/common/mali_block_allocator.c b/drivers/media/video/samsung/mali/common/mali_block_allocator.c index 269e662..269e662 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_block_allocator.c +++ b/drivers/media/video/samsung/mali/common/mali_block_allocator.c diff --git a/drivers/media/video/samsung/mali/common/mali_block_allocator.h b/drivers/media/video/samsung/mali/common/mali_block_allocator.h index d3f0f9b..d3f0f9b 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_block_allocator.h +++ b/drivers/media/video/samsung/mali/common/mali_block_allocator.h diff --git a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c index 6af1279..6af1279 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c +++ b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c diff --git a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h index 6be75b0..6be75b0 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h +++ b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h diff --git a/drivers/media/video/samsung/mali/common/mali_gp.h b/drivers/media/video/samsung/mali/common/mali_gp.h index 3175b75..3175b75 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_gp.h +++ b/drivers/media/video/samsung/mali/common/mali_gp.h diff --git a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h index ef58509..ef58509 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h diff --git a/drivers/media/video/samsung/mali/common/mali_hw_core.c b/drivers/media/video/samsung/mali/common/mali_hw_core.c index 0b08622..0b08622 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_hw_core.c +++ b/drivers/media/video/samsung/mali/common/mali_hw_core.c diff --git a/drivers/media/video/samsung/mali/common/mali_hw_core.h b/drivers/media/video/samsung/mali/common/mali_hw_core.h index c797804..c797804 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_hw_core.h +++ b/drivers/media/video/samsung/mali/common/mali_hw_core.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_core.h b/drivers/media/video/samsung/mali/common/mali_kernel_core.h index d424c48..d424c48 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_core.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_core.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c index b9f05ca..b9f05ca 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h index 82ed94d..82ed94d 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h index 0946169..0946169 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c index 1377560..1377560 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h index cda74c3..cda74c3 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c index a374dbf..a374dbf 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h index 1f60517..1f60517 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h diff --git a/drivers/media/video/samsung/mali/common/mali_mem_validation.h b/drivers/media/video/samsung/mali/common/mali_mem_validation.h index 2043b44..2043b44 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_mem_validation.h +++ b/drivers/media/video/samsung/mali/common/mali_mem_validation.h diff --git a/drivers/media/video/samsung/mali/common/mali_osk_bitops.h b/drivers/media/video/samsung/mali/common/mali_osk_bitops.h index f262f7d..f262f7d 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_osk_bitops.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_bitops.h diff --git a/drivers/media/video/samsung/mali/common/mali_osk_list.h b/drivers/media/video/samsung/mali/common/mali_osk_list.h index a8d15f2..a8d15f2 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_osk_list.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_list.h diff --git a/drivers/media/video/samsung/mali/common/mali_osk_mali.h b/drivers/media/video/samsung/mali/common/mali_osk_mali.h index 427fcc8..427fcc8 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_osk_mali.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_mali.h diff --git a/drivers/media/video/samsung/mali/common/mali_pm.h b/drivers/media/video/samsung/mali/common/mali_pm.h index d4ccfde..d4ccfde 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_pm.h +++ b/drivers/media/video/samsung/mali/common/mali_pm.h diff --git a/drivers/media/video/samsung/mali/common/mali_pp.h b/drivers/media/video/samsung/mali/common/mali_pp.h index 9b425a0..9b425a0 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_pp.h +++ b/drivers/media/video/samsung/mali/common/mali_pp.h diff --git a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h index 48eb3bd..48eb3bd 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h diff --git a/drivers/media/video/samsung/mali/common/mali_scheduler.c b/drivers/media/video/samsung/mali/common/mali_scheduler.c index 52159a0..52159a0 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_scheduler.c +++ b/drivers/media/video/samsung/mali/common/mali_scheduler.c diff --git a/drivers/media/video/samsung/mali/common/mali_scheduler.h b/drivers/media/video/samsung/mali/common/mali_scheduler.h index 74f0947..74f0947 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_scheduler.h diff --git a/drivers/media/video/samsung/mali/common/mali_session.h b/drivers/media/video/samsung/mali/common/mali_session.h index b47c340..b47c340 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_session.h +++ b/drivers/media/video/samsung/mali/common/mali_session.h diff --git a/drivers/media/video/samsung/mali/common/mali_user_settings_db.c b/drivers/media/video/samsung/mali/common/mali_user_settings_db.c index 681c2b0..681c2b0 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_user_settings_db.c +++ b/drivers/media/video/samsung/mali/common/mali_user_settings_db.c diff --git a/drivers/media/video/samsung/mali/common/mali_user_settings_db.h b/drivers/media/video/samsung/mali/common/mali_user_settings_db.h index fbb9415..fbb9415 100644..100755 --- a/drivers/media/video/samsung/mali/common/mali_user_settings_db.h +++ b/drivers/media/video/samsung/mali/common/mali_user_settings_db.h diff --git a/drivers/media/video/samsung/mali/linux/license/gpl/mali_kernel_license.h b/drivers/media/video/samsung/mali/linux/license/gpl/mali_kernel_license.h index e9e5e55..e9e5e55 100644..100755 --- a/drivers/media/video/samsung/mali/linux/license/gpl/mali_kernel_license.h +++ b/drivers/media/video/samsung/mali/linux/license/gpl/mali_kernel_license.h diff --git a/drivers/media/video/samsung/mali/linux/mali_kernel_ioctl.h b/drivers/media/video/samsung/mali/linux/mali_kernel_ioctl.h index 6fc59a7..6fc59a7 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_kernel_ioctl.h +++ b/drivers/media/video/samsung/mali/linux/mali_kernel_ioctl.h diff --git a/drivers/media/video/samsung/mali/linux/mali_kernel_linux.h b/drivers/media/video/samsung/mali/linux/mali_kernel_linux.h index 22dc9a4..22dc9a4 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_kernel_linux.h +++ b/drivers/media/video/samsung/mali/linux/mali_kernel_linux.h diff --git a/drivers/media/video/samsung/mali/linux/mali_kernel_pm.h b/drivers/media/video/samsung/mali/linux/mali_kernel_pm.h index 6ef7270..6ef7270 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_kernel_pm.h +++ b/drivers/media/video/samsung/mali/linux/mali_kernel_pm.h diff --git a/drivers/media/video/samsung/mali/linux/mali_kernel_sysfs.h b/drivers/media/video/samsung/mali/linux/mali_kernel_sysfs.h index d79a886..d79a886 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_kernel_sysfs.h +++ b/drivers/media/video/samsung/mali/linux/mali_kernel_sysfs.h diff --git a/drivers/media/video/samsung/mali/linux/mali_linux_pm.h b/drivers/media/video/samsung/mali/linux/mali_linux_pm.h index 10f633e..10f633e 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_linux_pm.h +++ b/drivers/media/video/samsung/mali/linux/mali_linux_pm.h diff --git a/drivers/media/video/samsung/mali/linux/mali_linux_pm_testsuite.h b/drivers/media/video/samsung/mali/linux/mali_linux_pm_testsuite.h index 7d811bd..7d811bd 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_linux_pm_testsuite.h +++ b/drivers/media/video/samsung/mali/linux/mali_linux_pm_testsuite.h diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_atomics.c b/drivers/media/video/samsung/mali/linux/mali_osk_atomics.c index 05831c5..05831c5 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_atomics.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_atomics.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.c b/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.c index 7297218..7297218 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.h b/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.h index f87739b..f87739b 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.h +++ b/drivers/media/video/samsung/mali/linux/mali_osk_indir_mmap.h diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_math.c b/drivers/media/video/samsung/mali/linux/mali_osk_math.c index 3e62e51..3e62e51 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_math.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_math.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_memory.c b/drivers/media/video/samsung/mali/linux/mali_osk_memory.c index 7bb470f..7bb470f 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_memory.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_memory.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_misc.c b/drivers/media/video/samsung/mali/linux/mali_osk_misc.c index ad486db..ad486db 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_misc.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_misc.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_notification.c b/drivers/media/video/samsung/mali/linux/mali_osk_notification.c index c14c0d5..c14c0d5 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_notification.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_notification.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_specific.h b/drivers/media/video/samsung/mali/linux/mali_osk_specific.h index 83ee906..83ee906 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_specific.h +++ b/drivers/media/video/samsung/mali/linux/mali_osk_specific.h diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_time.c b/drivers/media/video/samsung/mali/linux/mali_osk_time.c index da9b865..da9b865 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_time.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_time.c diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_timers.c b/drivers/media/video/samsung/mali/linux/mali_osk_timers.c index e5829a3..e5829a3 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_osk_timers.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_timers.c diff --git a/drivers/media/video/samsung/mali/linux/mali_ukk_gp.c b/drivers/media/video/samsung/mali/linux/mali_ukk_gp.c index 7070016..7070016 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_ukk_gp.c +++ b/drivers/media/video/samsung/mali/linux/mali_ukk_gp.c diff --git a/drivers/media/video/samsung/mali/linux/mali_ukk_mem.c b/drivers/media/video/samsung/mali/linux/mali_ukk_mem.c index 260f257..260f257 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_ukk_mem.c +++ b/drivers/media/video/samsung/mali/linux/mali_ukk_mem.c diff --git a/drivers/media/video/samsung/mali/linux/mali_ukk_vsync.c b/drivers/media/video/samsung/mali/linux/mali_ukk_vsync.c index f9b5a3e..f9b5a3e 100644..100755 --- a/drivers/media/video/samsung/mali/linux/mali_ukk_vsync.c +++ b/drivers/media/video/samsung/mali/linux/mali_ukk_vsync.c diff --git a/drivers/media/video/samsung/mali/platform/default/mali_platform.c b/drivers/media/video/samsung/mali/platform/default/mali_platform.c index 9e64ce7..9e64ce7 100644..100755 --- a/drivers/media/video/samsung/mali/platform/default/mali_platform.c +++ b/drivers/media/video/samsung/mali/platform/default/mali_platform.c diff --git a/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform.c b/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform.c index 792b9a9..792b9a9 100644..100755 --- a/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform.c +++ b/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform.c diff --git a/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform_dvfs.c b/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform_dvfs.c index f8d76dc..f8d76dc 100644..100755 --- a/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform_dvfs.c +++ b/drivers/media/video/samsung/mali/platform/orion-m400/mali_platform_dvfs.c diff --git a/drivers/media/video/samsung/mali/readme.txt b/drivers/media/video/samsung/mali/readme.txt index 3acc51c..3acc51c 100644..100755 --- a/drivers/media/video/samsung/mali/readme.txt +++ b/drivers/media/video/samsung/mali/readme.txt diff --git a/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.c b/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.c index a6b1d76..a6b1d76 100644..100755 --- a/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.c +++ b/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.c diff --git a/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.h b/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.h index 3279dae..3279dae 100644..100755 --- a/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.h +++ b/drivers/media/video/samsung/mali/timestamp-arm11-cc/mali_timestamp.h diff --git a/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.c b/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.c index a6b1d76..a6b1d76 100644..100755 --- a/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.c +++ b/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.c diff --git a/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.h b/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.h index 94b842a..94b842a 100644..100755 --- a/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.h +++ b/drivers/media/video/samsung/mali/timestamp-default/mali_timestamp.h diff --git a/drivers/media/video/samsung/mfc5x/Kconfig b/drivers/media/video/samsung/mfc5x/Kconfig index 0ff8a60..57858ed 100644 --- a/drivers/media/video/samsung/mfc5x/Kconfig +++ b/drivers/media/video/samsung/mfc5x/Kconfig @@ -9,8 +9,8 @@ config VIDEO_MFC5X This is a Samsung Multi Format Codecs (MFC) FIMV V5.x config VIDEO_MFC_MAX_INSTANCE - int "Maximum size of MFC instance (1-4)" - range 1 4 + int "Maximum size of MFC instance (1-8)" + range 1 8 depends on VIDEO_MFC5X default 4 @@ -36,4 +36,10 @@ config VIDEO_MFC5X_DEC_CHROMA_LUMA_4K_ALIGN ---help--- To use physical address on the gem interface. - +config USE_MFC_CMA + bool "Use CMA for MFC_SECURE region (EXPERIMENTAL)" + depends on DMA_CMA + default n + help + This enables the Contiguous Memory Allocator for MFC SECURE region. + If unsure, say "n". diff --git a/drivers/media/video/samsung/mfc5x/SsbSipMfcApi.h b/drivers/media/video/samsung/mfc5x/SsbSipMfcApi.h index ba4b736..cbf6cab 100644 --- a/drivers/media/video/samsung/mfc5x/SsbSipMfcApi.h +++ b/drivers/media/video/samsung/mfc5x/SsbSipMfcApi.h @@ -41,11 +41,20 @@ #define SAMSUNG_MFC_DEV_NAME "/dev/s3c-mfc" #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) -#define SUPPORT_SLICE_ENCODING 0 // This is originally 1, but breaks video recording on AOSP :( +#define SUPPORT_SLICE_ENCODING 0 // originaly 1, but we're missing matching userspace #else #define SUPPORT_SLICE_ENCODING 0 #endif +/*---------------------------*/ +/* Memory Type */ +/*---------------------------*/ +typedef enum { + MEMORY_PHY_ADDR = 0, + MEMORY_USRPTR = 1, + MEMORY_DMABUF = 2, +} SSBSIP_MFC_MEMORY_TYPE; + /*--------------------------------------------------------------------------------*/ /* Structure and Type */ /*--------------------------------------------------------------------------------*/ @@ -127,6 +136,7 @@ typedef enum { /* C210 specific feature */ MFC_ENC_SETCONF_VUI_INFO, MFC_ENC_SETCONF_I_PERIOD, + MFC_ENC_SETCONF_SPS_PPS_GEN, MFC_ENC_SETCONF_HIER_P, MFC_ENC_SETCONF_SEI_GEN, @@ -139,7 +149,12 @@ typedef enum { MFC_GETOUTBUF_DISPLAY_DECODING, MFC_GETOUTBUF_DISPLAY_ONLY, MFC_GETOUTBUF_DISPLAY_END, - MFC_GETOUTBUF_CHANGE_RESOL +#ifndef CONFIG_SLP + MFC_GETOUTBUF_CHANGE_RESOL +#else + MFC_GETOUTBUF_CHANGING_RESOL, + MFC_GETOUTBUF_CHANGE_RESOL_DONE +#endif } SSBSIP_MFC_DEC_OUTBUF_STATUS; typedef enum { diff --git a/drivers/media/video/samsung/mfc5x/mfc.h b/drivers/media/video/samsung/mfc5x/mfc.h index de1849c..a8c5d72 100644 --- a/drivers/media/video/samsung/mfc5x/mfc.h +++ b/drivers/media/video/samsung/mfc5x/mfc.h @@ -98,4 +98,8 @@ #endif #endif +#ifdef CONFIG_SLP +#define MFC_NUM_PLANE 2 +#endif + #endif /* __MFC_H_ */ diff --git a/drivers/media/video/samsung/mfc5x/mfc_buf.c b/drivers/media/video/samsung/mfc5x/mfc_buf.c index e0e243d..d841a37 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_buf.c +++ b/drivers/media/video/samsung/mfc5x/mfc_buf.c @@ -16,6 +16,13 @@ #include <linux/mm.h> #include <linux/err.h> +#ifdef CONFIG_SLP +#include <linux/cma.h> +#ifdef CONFIG_SLP_DMABUF +#include <linux/dma-buf.h> +#endif +#endif + #include "mfc.h" #include "mfc_mem.h" #include "mfc_buf.h" @@ -30,6 +37,168 @@ #include "ump_kernel_interface_vcm.h" #endif +#ifdef CONFIG_SLP_DMABUF +struct mfc_dmabuf_buf { + dma_addr_t dma_addr; + unsigned long size; + /* fd exported from this buf object. */ + int export_fd; + /* dma buf exported from this buf object. */ + struct dma_buf *export_dma_buf; + struct dma_buf_attachment *db_attach; + atomic_t refcount; +}; + +static void _mfc_dmabuf_put(struct mfc_dmabuf_buf *buf) +{ + if (atomic_dec_and_test(&buf->refcount)) { + /* + * In legacy driver, dmabuf functions don't control + * cma memory allocation and free. + * so, currently we comment cma_free function. + * cma_free(buf->dma_addr); + */ + kfree(buf); + } +} + +static int mfc_attach_dmabuf(struct dma_buf *dmabuf, struct device *dev, + struct dma_buf_attachment *attach) +{ + mfc_dbg("mfc_attach_dmabuf: called !\n"); + return 0; +} + +static void mfc_detach_dmabuf(struct dma_buf *dmabuf, + struct dma_buf_attachment *attach) +{ + mfc_dbg("mfc_detach_dmabuf: called !\n"); + dma_buf_put(dmabuf); +} + +static struct sg_table * + mfc_map_dmabuf(struct dma_buf_attachment *attach, + enum dma_data_direction direction) +{ + struct mfc_dmabuf_buf *buf; + struct sg_table *sgt; + int ret; + int val; + + mfc_dbg("mfc_map_dmabuf: called !\n"); + if (!attach->dmabuf->priv) { + mfc_err("mfc_map_dmabuf: failed : attach->dmabuf->priv is NULL\n"); + return NULL; + } + buf = attach->dmabuf->priv; + sgt = kzalloc(sizeof(struct sg_table), GFP_KERNEL); + if (!sgt) { + mfc_err("mfc_map_dmabuf: failed to allocate sg table.\n"); + return ERR_PTR(-ENOMEM); + } + + ret = sg_alloc_table(sgt, 1, GFP_KERNEL); + if (ret < 0) { + mfc_err("mfc_map_dmabuf: failed to allocate scatter list.\n"); + kfree(sgt); + sgt = NULL; + return ERR_PTR(-ENOMEM); + } + + sg_init_table(sgt->sgl, 1); + sg_dma_len(sgt->sgl) = buf->size; + sg_set_page(sgt->sgl, pfn_to_page(PFN_DOWN(buf->dma_addr)), + buf->size, 0); + sg_dma_address(sgt->sgl) = buf->dma_addr; + + /* + * increase reference count of this buf object. + * + * Note: + * alloated physical memory region is being shared with others so + * this region shouldn't be released until all references of this + * region will be dropped by mfc_unmap_dmabuf(). + */ + val = atomic_inc_return(&buf->refcount); + mfc_dbg("mfc_map_dmabuf: refcount: %d\n", val); + + return sgt; +} + +static void mfc_unmap_dmabuf(struct dma_buf_attachment *attach, + struct sg_table *sgt, enum dma_data_direction direction) +{ + int val = 0; + struct mfc_dmabuf_buf *buf; + + mfc_dbg("mfc_unmap_dmabuf: called !\n"); + buf = attach->dmabuf->priv; + + sg_free_table(sgt); + kfree(sgt); + sgt = NULL; + + val = atomic_dec_return(&buf->refcount); + mfc_dbg("mfc_unmap_dmabuf: refcount: %d\n", val); +} + +static void mfc_release_dmabuf(struct dma_buf *dmabuf) +{ + struct mfc_dmabuf_buf *buf; + + mfc_dbg("mfc_release_dmabuf: called !\n"); + if (!dmabuf->priv) { + mfc_dbg("mfc_release_dmabuf: failed: dmabuf->priv is NULL\n"); + return; + } + buf = dmabuf->priv; + if (buf->export_dma_buf == dmabuf) { + mfc_dbg("mfc_release_dmabuf: called !\n"); + buf->export_fd = -1; + buf->export_dma_buf = NULL; + + _mfc_dmabuf_put(buf); + } +} + +static void *mfc_kmap_atomic_dmabuf(struct dma_buf *dma_buf, + unsigned long page_num) +{ + return NULL; +} + +static void mfc_kunmap_atomic_dmabuf(struct dma_buf *dma_buf, + unsigned long page_num, + void *addr) +{ + +} + +static void *mfc_kmap_dmabuf(struct dma_buf *dma_buf, + unsigned long page_num) +{ + return NULL; +} + +static void mfc_kunmap_dmabuf(struct dma_buf *dma_buf, + unsigned long page_num, void *addr) +{ + +} + +static struct dma_buf_ops mfc_dmabuf_ops = { + .attach = mfc_attach_dmabuf, + .detach = mfc_detach_dmabuf, + .map_dma_buf = mfc_map_dmabuf, + .unmap_dma_buf = mfc_unmap_dmabuf, + .release = mfc_release_dmabuf, + .kmap = mfc_kmap_dmabuf, + .kmap_atomic = mfc_kmap_atomic_dmabuf, + .kunmap = mfc_kunmap_dmabuf, + .kunmap_atomic = mfc_kunmap_atomic_dmabuf, +}; +#endif + #define PRINT_BUF #undef DEBUG_ALLOC_FREE @@ -122,7 +291,7 @@ static int mfc_put_free_buf(unsigned long addr, unsigned int size, int port) /* 0x00: not merged, 0x01: prev merged, 0x02: next merged */ int merged = 0x00; - if (!size) + if ((!size) || (port >= MFC_MAX_MEM_PORT_NUM)) return -EINVAL; mfc_dbg("addr: 0x%08lx, size: %d, port: %d\n", addr, size, port); @@ -376,6 +545,13 @@ void mfc_final_buf(void) kfree(alloc); } #else +#ifdef CONFIG_SLP + if (alloc->real) { + cma_free(alloc->real); + list_del(&alloc->list); + kfree(alloc); + } +#else if (mfc_put_free_buf(alloc->real, alloc->size, port) < 0) { @@ -385,6 +561,7 @@ void mfc_final_buf(void) kfree(alloc); } #endif +#endif } } @@ -466,6 +643,15 @@ struct mfc_alloc_buffer *_mfc_alloc_buf( #elif defined(CONFIG_S5P_VMEM) int align_size = 0; #endif +#ifdef CONFIG_SLP + struct mfc_dev *dev = ctx->dev; + size_t available_size; + struct cma_info cma_infos; +#ifdef CONFIG_SLP_DMABUF + struct mfc_dmabuf_buf *buf; + int flags = 0; +#endif +#endif /* unsigned long flags; */ @@ -486,8 +672,62 @@ struct mfc_alloc_buffer *_mfc_alloc_buf( /* spin_lock_irqsave(&lock, flags); */ +#ifdef CONFIG_SLP + if (cma_info(&cma_infos, dev->device, port ? "B" : "A")) { + mfc_info("failed to get CMA info of 'mfc'\n"); + kfree(alloc); + return NULL; + } + available_size = cma_infos.free_size; + if (available_size > MAX_MEM_OFFSET) { + mfc_warn("<Warning> too large 'mfc' reserved memory, " + "size will be shrink (%d:%d)\n", + size >> 10, MAX_MEM_OFFSET >> 10); + size = MAX_MEM_OFFSET; + } + addr = cma_alloc(dev->device, port ? "B" : "A", size, align); + if (IS_ERR_VALUE(addr)) { + mfc_err("failed to get rsv. memory from CMA"); + kfree(alloc); + return NULL; + } +#ifdef CONFIG_SLP_DMABUF + buf = kzalloc(sizeof(struct mfc_dmabuf_buf), GFP_KERNEL); + if (!buf) { + mfc_err("failed to alloc mfc_dmabuf_buf"); + kfree(alloc); + cma_free(addr); + return NULL; + } + buf->dma_addr = addr; + buf->size = size; + + buf->export_dma_buf = dma_buf_export(buf, &mfc_dmabuf_ops, + buf->size, 0600); + if (!buf->export_dma_buf) { + mfc_err("fail to export dma_buf\n"); + kfree(alloc); + cma_free(addr); + kfree(buf); + return NULL; + } + buf->export_fd = dma_buf_fd(buf->export_dma_buf, flags); + if (buf->export_fd < 0) { + mfc_err(" fail to get fd from dmabuf.\n"); + kfree(alloc); + cma_free(addr); + kfree(buf); + dma_buf_put(buf->export_dma_buf); + return NULL; + } + alloc->dmabuf_fd = buf->export_fd; + atomic_inc(&buf->refcount); + mfc_dbg(" buf->export_fd = %d\n", buf->export_fd); +#endif +#else addr = mfc_get_free_buf(size, align, port); +#endif mfc_dbg("mfc_get_free_buf: 0x%08lx\n", addr); @@ -783,15 +1023,22 @@ int _mfc_free_buf(unsigned long real) kfree(alloc); } #else +#ifdef CONFIG_SLP + if (alloc->real) { + cma_free(alloc->real); + list_del(&alloc->list); + kfree(alloc); + } +#else if (mfc_put_free_buf(alloc->real, alloc->size, port) < 0) { - mfc_err("failed to add free buffer\n"); } else { list_del(&alloc->list); kfree(alloc); } #endif +#endif break; } } @@ -839,6 +1086,13 @@ void mfc_free_buf_type(int owner, int type) alloc = list_entry(pos, struct mfc_alloc_buffer, list); if ((alloc->owner == owner) && (alloc->type == type)) { +#ifdef CONFIG_SLP + if (alloc->real) { + cma_free(alloc->real); + list_del(&alloc->list); + kfree(alloc); + } +#else if (mfc_put_free_buf(alloc->real, alloc->size, port) < 0) { @@ -847,6 +1101,7 @@ void mfc_free_buf_type(int owner, int type) list_del(&alloc->list); kfree(alloc); } +#endif } } } @@ -905,6 +1160,13 @@ void mfc_free_buf_inst(int owner) kfree(alloc); } #else +#ifdef CONFIG_SLP + if (alloc->real) { + cma_free(alloc->real); + list_del(&alloc->list); + kfree(alloc); + } +#else if (mfc_put_free_buf(alloc->real, alloc->size, port) < 0) { @@ -914,6 +1176,7 @@ void mfc_free_buf_inst(int owner) kfree(alloc); } #endif +#endif } } } @@ -1034,4 +1297,24 @@ void *mfc_get_buf_ump_handle(unsigned long real) return NULL; } #endif +#ifdef CONFIG_SLP_DMABUF +int mfc_get_buf_dmabuf(unsigned long real) +{ + struct list_head *pos, *nxt; + int port; + struct mfc_alloc_buffer *alloc; + + mfc_dbg("real: 0x%08lx\n", real); + for (port = 0; port < mfc_mem_count(); port++) { + list_for_each_safe(pos, nxt, &mfc_alloc_head[port]) { + alloc = list_entry(pos, struct mfc_alloc_buffer, list); + + if (alloc->real == real) + return alloc->dmabuf_fd; + } + } + + return -EINVAL; +} +#endif diff --git a/drivers/media/video/samsung/mfc5x/mfc_buf.h b/drivers/media/video/samsung/mfc5x/mfc_buf.h index 7fafb94..28ef0d6 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_buf.h +++ b/drivers/media/video/samsung/mfc5x/mfc_buf.h @@ -142,6 +142,10 @@ struct mfc_alloc_buffer { unsigned char *addr; /* kernel virtual address space */ unsigned int type; /* buffer type */ int owner; /* instance context id */ +#if defined(CONFIG_DMA_CMA) && defined(CONFIG_USE_MFC_CMA) + struct device *dev; + dma_addr_t dma_addr; +#endif #if defined(CONFIG_VIDEO_MFC_VCM_UMP) struct vcm_mmu_res *vcm_s; struct vcm_res *vcm_k; @@ -159,6 +163,9 @@ struct mfc_alloc_buffer { * when user use mmap, * user can access whole of memory by offset. */ +#ifdef CONFIG_SLP_DMABUF + int dmabuf_fd; +#endif #endif }; @@ -187,6 +194,9 @@ unsigned long mfc_get_buf_real(int owner, unsigned int key); unsigned char *mfc_get_buf_addr(int owner, unsigned char *user); unsigned char *_mfc_get_buf_addr(int owner, unsigned char *user); */ +#ifdef CONFIG_SLP_DMABUF +int mfc_get_buf_dmabuf(unsigned long real); +#endif #ifdef CONFIG_VIDEO_MFC_VCM_UMP unsigned int mfc_vcm_bind_from_others(struct mfc_inst_ctx *ctx, struct mfc_buf_alloc_arg *args, int flag); diff --git a/drivers/media/video/samsung/mfc5x/mfc_dec.c b/drivers/media/video/samsung/mfc5x/mfc_dec.c index fd78b7d..d3d336a 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_dec.c +++ b/drivers/media/video/samsung/mfc5x/mfc_dec.c @@ -1882,15 +1882,6 @@ int mfc_init_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) dec_ctx->numtotaldpb); #if defined(CONFIG_BUSFREQ) -#if defined(CONFIG_CPU_EXYNOS4210) - /* Fix MFC & Bus Frequency for better performance */ - if (atomic_read(&ctx->dev->busfreq_lock_cnt) == 0) { - exynos4_busfreq_lock(DVFS_LOCK_ID_MFC, BUS_L1); - mfc_dbg("Bus FREQ locked to L1\n"); - } - atomic_inc(&ctx->dev->busfreq_lock_cnt); - ctx->busfreq_flag = true; -#else /* Lock MFC & Bus FREQ for high resolution */ if (ctx->width >= MAX_HOR_RES || ctx->height >= MAX_VER_RES) { if (atomic_read(&ctx->dev->busfreq_lock_cnt) == 0) { @@ -1900,8 +1891,17 @@ int mfc_init_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) atomic_inc(&ctx->dev->busfreq_lock_cnt); ctx->busfreq_flag = true; - } + } else { +#if defined(CONFIG_CPU_EXYNOS4210) + /* Fix MFC & Bus Frequency for better performance */ + if (atomic_read(&ctx->dev->busfreq_lock_cnt) == 0) { + exynos4_busfreq_lock(DVFS_LOCK_ID_MFC, BUS_L1); + mfc_dbg("Bus FREQ locked to L1\n"); + } + atomic_inc(&ctx->dev->busfreq_lock_cnt); + ctx->busfreq_flag = true; #endif + } #endif #if defined(CONFIG_CPU_EXYNOS4210) && defined(CONFIG_EXYNOS4_CPUFREQ) @@ -1926,8 +1926,12 @@ int mfc_init_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) dmc_max_threshold = EXYNOS4212_DMC_MAX_THRESHOLD + 5; } else if (soc_is_exynos4412()) { - dmc_max_threshold = - EXYNOS4412_DMC_MAX_THRESHOLD + 5; + if (samsung_rev() >= EXYNOS4412_REV_2_0) + dmc_max_threshold = + PRIME_DMC_MAX_THRESHOLD + 5; + else + dmc_max_threshold = + EXYNOS4412_DMC_MAX_THRESHOLD + 5; } else { pr_err("Unsupported model.\n"); return -EINVAL; @@ -2093,6 +2097,25 @@ int mfc_change_resolution(struct mfc_inst_ctx *ctx, struct mfc_dec_exe_arg *exe_ } ret = mfc_cmd_init_buffers(ctx); + +#ifdef CONFIG_SLP + if (ctx->codecid == H264_DEC) { + exe_arg->out_crop_right_offset = + (read_shm(ctx, CROP_INFO1) >> 16) & 0xFFFF; + exe_arg->out_crop_left_offset = + read_shm(ctx, CROP_INFO1) & 0xFFFF; + exe_arg->out_crop_bottom_offset = + (read_shm(ctx, CROP_INFO2) >> 16) & 0xFFFF; + exe_arg->out_crop_top_offset = + read_shm(ctx, CROP_INFO2) & 0xFFFF; + + mfc_dbg("mfc_change_resolution: crop info t: %d, r: %d, b: %d, l: %d\n", + exe_arg->out_crop_top_offset, + exe_arg->out_crop_right_offset, + exe_arg->out_crop_bottom_offset, + exe_arg->out_crop_left_offset); + } +#endif if (ret < 0) return ret; @@ -2126,7 +2149,7 @@ static int mfc_decoding_frame(struct mfc_inst_ctx *ctx, struct mfc_dec_exe_arg * unsigned char *stream_vir; int ret; struct mfc_dec_ctx *dec_ctx = (struct mfc_dec_ctx *)ctx->c_priv; - unsigned long mem_ofs; + long mem_ofs; #ifdef CONFIG_VIDEO_MFC_VCM_UMP void *ump_handle; #endif @@ -2265,9 +2288,29 @@ static int mfc_decoding_frame(struct mfc_inst_ctx *ctx, struct mfc_dec_exe_arg * exe_arg->out_display_status = dec_ctx->dispstatus; - exe_arg->out_display_Y_addr = (display_luma_addr << 11); - exe_arg->out_display_C_addr = (display_chroma_addr << 11); - +#ifdef CONFIG_SLP_DMABUF + if (exe_arg->memory_type == MEMORY_DMABUF) { + exe_arg->out_display_Y_addr = + mfc_get_buf_dmabuf(display_luma_addr << 11); + if (exe_arg->out_display_Y_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get Y fd error %d\n", + exe_arg->out_display_Y_addr); + return MFC_DEC_EXE_ERR; + } + exe_arg->out_display_C_addr = + mfc_get_buf_dmabuf(display_chroma_addr << 11); + if (exe_arg->out_display_C_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get C fd error %d\n", + exe_arg->out_display_C_addr); + return MFC_DEC_EXE_ERR; + } + } else { +#endif + exe_arg->out_display_Y_addr = (display_luma_addr << 11); + exe_arg->out_display_C_addr = (display_chroma_addr << 11); +#ifdef CONFIG_SLP_DMABUF + } +#endif exe_arg->out_disp_pic_frame_type = display_frame_type; exe_arg->out_y_offset = mfc_mem_data_ofs(display_luma_addr << 11, 1); @@ -2361,6 +2404,7 @@ int mfc_exec_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) mfc_check_resolution_change(ctx, exe_arg); if (ctx->resolution_status == RES_SET_CHANGE) { ret = mfc_decoding_frame(ctx, exe_arg, &consumed); +#ifndef CONFIG_SLP } else if ((ctx->resolution_status == RES_WAIT_FRAME_DONE) && (exe_arg->out_display_status == DISP_S_FINISH)) { exe_arg->out_display_status = DISP_S_RES_CHANGE; @@ -2368,6 +2412,20 @@ int mfc_exec_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) if (ret != MFC_OK) return ret; ctx->resolution_status = RES_NO_CHANGE; +#else + } else if (ctx->resolution_status == RES_WAIT_FRAME_DONE) { + if (exe_arg->out_display_status == DISP_S_FINISH) { + exe_arg->out_display_status = + DISP_S_RES_CHANGE_DONE; + + ret = mfc_change_resolution(ctx, exe_arg); + if (ret != MFC_OK) + return ret; + ctx->resolution_status = RES_NO_CHANGE; + } else + exe_arg->out_display_status = + DISP_S_RES_CHANGING; +#endif } if ((dec_ctx->ispackedpb) && diff --git a/drivers/media/video/samsung/mfc5x/mfc_dec.h b/drivers/media/video/samsung/mfc5x/mfc_dec.h index f59795b..86b7a97 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_dec.h +++ b/drivers/media/video/samsung/mfc5x/mfc_dec.h @@ -44,7 +44,12 @@ enum disp_status { DISP_S_DD = 1, DISP_S_DISPLAY = 2, DISP_S_FINISH = 3, +#ifndef CONFIG_SLP DISP_S_RES_CHANGE = 4, /* not H/W bit */ +#else + DISP_S_RES_CHANGING = 4, /* not H/W bit */ + DISP_S_RES_CHANGE_DONE = 5, /* not H/W bit */ +#endif }; /* decoding status */ diff --git a/drivers/media/video/samsung/mfc5x/mfc_dev.c b/drivers/media/video/samsung/mfc5x/mfc_dev.c index e3a0b60..23bc10d 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_dev.c +++ b/drivers/media/video/samsung/mfc5x/mfc_dev.c @@ -66,6 +66,10 @@ #include <plat/sysmmu.h> #endif +#ifdef CONFIG_SLP_DMABUF +#include <media/videobuf2-core.h> +#endif + #define MFC_MINOR 252 #define MFC_FW_NAME "mfc_fw.bin" @@ -108,6 +112,79 @@ static inline void clear_magic(unsigned char *addr) } #endif +#ifdef CONFIG_SLP_DMABUF +/** + * _mfc_dmabuf_put() - release memory associated with + * a DMABUF shared buffer + */ +static void _mfc_dmabuf_put(struct vb2_plane *planes) +{ + unsigned int plane; + + for (plane = 0; plane < MFC_NUM_PLANE; ++plane) { + void *mem_priv = planes[plane].mem_priv; + + if (mem_priv) { + dma_buf_detach(planes[plane].dbuf, + planes[plane].mem_priv); + dma_buf_put(planes[plane].dbuf); + planes[plane].dbuf = NULL; + planes[plane].mem_priv = NULL; + } + } +} + +void mfc_queue_free(struct mfc_inst_ctx *mfc_ctx) +{ + struct vb2_plane *planes; + int buffer; + + for (buffer = 0; buffer < VIDEO_MAX_PLANES; ++buffer) { + planes = mfc_ctx->enc_planes[buffer]; + + if (!planes) + continue; + + _mfc_dmabuf_put(planes); + kfree(planes); + planes = NULL; + } +} + +int mfc_queue_alloc(struct mfc_inst_ctx *mfc_ctx) +{ + struct vb2_plane *planes; + int buffer; + int ret = 0; + + for (buffer = 0; buffer < MFC_NUM_PLANE; ++buffer) { + planes = kzalloc(sizeof(struct vb2_plane), GFP_KERNEL); + if (!planes) { + printk(KERN_INFO "MFC Queue memory alloc failed\n"); + ret = -ENOMEM; + goto err; + } + + planes->mem_priv = NULL; + mfc_ctx->enc_planes[buffer] = planes; + } + + for (buffer = MFC_NUM_PLANE; buffer < VIDEO_MAX_PLANES; ++buffer) + mfc_ctx->enc_planes[buffer] = NULL; + + return ret; + +err: + for (buffer = 0; buffer < VIDEO_MAX_PLANES; buffer++) { + if (mfc_ctx->enc_planes[buffer] != NULL) + kfree(mfc_ctx->enc_planes[buffer]); + mfc_ctx->enc_planes[buffer] = NULL; + } + + return ret; +} +#endif + static int get_free_inst_id(struct mfc_dev *dev) { int slot = 0; @@ -135,6 +212,25 @@ static int mfc_open(struct inode *inode, struct file *file) file->private_data = NULL; mutex_lock(&mfcdev->lock); + +#if defined(CONFIG_USE_MFC_CMA) && defined(CONFIG_MACH_M0) + if (atomic_read(&mfcdev->inst_cnt) == 0) { + size_t size = 0x02800000; + mfcdev->cma_vaddr = dma_alloc_coherent(mfcdev->device, size, + &mfcdev->cma_dma_addr, 0); + if (!mfcdev->cma_vaddr) { + printk(KERN_ERR "%s: dma_alloc_coherent returns " + "-ENOMEM\n", __func__); + mutex_unlock(&mfcdev->lock); + return -ENOMEM; + } + printk(KERN_INFO "%s[%d] size 0x%x, vaddr 0x%x, base 0x%x\n", + __func__, __LINE__, (int)size, + (int)mfcdev->cma_vaddr, + (int)mfcdev->cma_dma_addr); + } +#endif + #if SUPPORT_SLICE_ENCODING mfcdev->frame_working_flag = 1; mfcdev->frame_sys = 0; @@ -292,6 +388,13 @@ static int mfc_open(struct inode *inode, struct file *file) if (mfcdev->wait_frame_timeout == 1) wake_up(&mfcdev->wait_frame); #endif +#ifdef CONFIG_SLP_DMABUF + ret = mfc_queue_alloc(mfc_ctx); + if (ret < 0) { + mfc_err("mfc_queue_alloc failed\n"); + goto err_inst_ctx; + } +#endif mfc_info("MFC instance [%d:%d] opened", mfc_ctx->id, atomic_read(&mfcdev->inst_cnt)); @@ -456,10 +559,24 @@ static int mfc_release(struct inode *inode, struct file *file) if (mfcdev->wait_frame_timeout == 1) wake_up(&dev->wait_frame); #endif +#ifdef CONFIG_SLP_DMABUF + mfc_queue_free(mfc_ctx); +#endif err_pwr_disable: - mutex_unlock(&dev->lock); +#if defined(CONFIG_USE_MFC_CMA) && defined(CONFIG_MACH_M0) + if (atomic_read(&mfcdev->inst_cnt) == 0) { + size_t size = 0x02800000; + dma_free_coherent(mfcdev->device, size, mfcdev->cma_vaddr, + mfcdev->cma_dma_addr); + printk(KERN_INFO "%s[%d] size 0x%x, vaddr 0x%x, base 0x0%x\n", + __func__, __LINE__, (int)size, + (int) mfcdev->cma_vaddr, + (int)mfcdev->cma_dma_addr); + } +#endif + mutex_unlock(&dev->lock); return ret; } diff --git a/drivers/media/video/samsung/mfc5x/mfc_dev.h b/drivers/media/video/samsung/mfc5x/mfc_dev.h index c82c26c..bb2095c 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_dev.h +++ b/drivers/media/video/samsung/mfc5x/mfc_dev.h @@ -99,6 +99,12 @@ struct mfc_dev { struct mfc_fw fw; +#if defined(CONFIG_DMA_CMA) && defined(CONFIG_USE_MFC_CMA) + /* NEW CMA */ + void *cma_vaddr; + dma_addr_t cma_dma_addr; +#endif + struct s5p_vcm_mmu *_vcm_mmu; struct device *device; diff --git a/drivers/media/video/samsung/mfc5x/mfc_enc.c b/drivers/media/video/samsung/mfc5x/mfc_enc.c index 53f24c9..65d7b6b 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_enc.c +++ b/drivers/media/video/samsung/mfc5x/mfc_enc.c @@ -31,6 +31,11 @@ #include "mfc_buf.h" #include "mfc_interface.h" +#ifdef CONFIG_SLP_DMABUF +#include <linux/dma-buf.h> +#include <media/videobuf2-core.h> +#endif + static LIST_HEAD(mfc_encoders); /* @@ -507,7 +512,7 @@ static int pre_seq_start(struct mfc_inst_ctx *ctx) write_reg(mfc_mem_base_ofs(enc_ctx->streamaddr) >> 11, MFC_ENC_SI_CH1_SB_ADR); write_reg(enc_ctx->streamsize, MFC_ENC_SI_CH1_SB_SIZE); #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) - write_shm(ctx, 1, HW_VERSRION); + write_shm(ctx, 1, HW_VERSION); #endif return 0; @@ -579,6 +584,13 @@ static int h264_pre_seq_start(struct mfc_inst_ctx *ctx) h264->change &= ~(CHG_FRAME_PACKING); } + if (h264->sps_pps_gen == 1) { + write_shm(ctx, + ((h264->sps_pps_gen << 8) | + read_shm(ctx, EXT_ENC_CONTROL)), + EXT_ENC_CONTROL); + } + return 0; } @@ -1050,6 +1062,23 @@ static int h264_set_codec_cfg(struct mfc_inst_ctx *ctx, int type, void *arg) h264->change |= CHG_FRAME_PACKING; break; + + case MFC_ENC_SETCONF_SPS_PPS_GEN: + mfc_dbg("MFC_ENC_SETCONF_SPS_PPS_GEN : %d\n", ctx->state); + + if ((ctx->state < INST_STATE_CREATE) || + (ctx->state > INST_STATE_EXE)) { + mfc_err("MFC_ENC_SETCONF_SPS_PPS_GEN : " + " state is invalid\n"); + return MFC_STATE_INVALID; + } + + if (usercfg->basic.values[0] > 0) + h264->sps_pps_gen = 1; + else + h264->sps_pps_gen = 0; + + break; default: mfc_dbg("invalid set cfg type: 0x%08x\n", type); ret = -2; @@ -1590,6 +1619,65 @@ err_handling: return ret; } +#ifdef CONFIG_SLP_DMABUF +static int mfc_qbuf_dmabuf(struct mfc_inst_ctx *ctx, struct vb2_plane *planes, + int fd, dma_addr_t *dma_addr) +{ + struct sg_table *sg; + struct dma_buf *dbuf; + struct dma_buf_attachment *dba; + + dbuf = dma_buf_get(fd); + if (IS_ERR_OR_NULL(dbuf)) { + mfc_err("dmabuf get error!!!\n"); + dma_buf_put(dbuf); + return -EINVAL; + } + + /* Skip the plane if already verified */ + if (dbuf == planes->dbuf) { + dma_buf_put(dbuf); + return 0; + } + + dba = dma_buf_attach(dbuf, ctx->dev->device); + if (IS_ERR(dba)) { + mfc_err("failed to attach dmabuf\n"); + dma_buf_put(dbuf); + return -EINVAL; + } + + sg = dma_buf_map_attachment(dba, DMA_BIDIRECTIONAL); + if (IS_ERR(sg)) { + dma_buf_detach(dbuf, dba); + dma_buf_put(dbuf); + return PTR_ERR(sg); + } + dba->priv = sg; + + planes->dbuf = dbuf; + planes->mem_priv = dba; + + *dma_addr = sg_dma_address(sg->sgl); + + return 0; +} + +static int mfc_dqbuf_dmabuf(struct mfc_inst_ctx *ctx, struct vb2_plane *plane) +{ + + struct sg_table *sg; + struct dma_buf_attachment *dba; + + dba = plane->mem_priv; + sg = dba->priv; + + dma_buf_unmap_attachment(dba, sg, DMA_FROM_DEVICE); + + return 0; +} +#endif + static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg *exe_arg) { int ret; @@ -1597,6 +1685,9 @@ static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg * void *ump_handle; #endif struct mfc_enc_ctx *enc_ctx = (struct mfc_enc_ctx *)ctx->c_priv; +#ifdef CONFIG_SLP_DMABUF + dma_addr_t dma_addr[MFC_NUM_PLANE]; +#endif /* Set Frame Tag */ write_shm(ctx, exe_arg->in_frametag, SET_FRAME_TAG); @@ -1648,6 +1739,39 @@ static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg * #endif /* Set current frame buffer addr */ +#ifdef CONFIG_SLP_DMABUF + if (exe_arg->memory_type == MEMORY_DMABUF) { + ret = mfc_qbuf_dmabuf(ctx, ctx->enc_planes[0], + exe_arg->in_Y_addr, &dma_addr[0]); + if (ret) { + mfc_err("mfc_qbuf_dmabuf Y error!!! ret = %d\n", ret); + return -EINVAL; + } + ret = mfc_qbuf_dmabuf(ctx, ctx->enc_planes[1], + exe_arg->in_CbCr_addr, &dma_addr[1]); + if (ret) { + mfc_err("mfc_qbuf_dmabuf CbCr error!!! ret = %d\n", + ret); + ret = mfc_dqbuf_dmabuf(ctx, ctx->enc_planes[0]); + if (ret) + mfc_err("mfc_dqbuf_dmabuf Y error!! ret = %d\n", + ret); + return -EINVAL; + } + } + +#if (MFC_MAX_MEM_PORT_NUM == 2) + write_reg((dma_addr[0] - mfc_mem_base(1)) >> 11, + MFC_ENC_SI_CH1_CUR_Y_ADR); + write_reg((dma_addr[1] - mfc_mem_base(1)) >> 11, + MFC_ENC_SI_CH1_CUR_C_ADR); +#else + write_reg((dma_addr[0] - mfc_mem_base(0)) >> 11, + MFC_ENC_SI_CH1_CUR_Y_ADR); + write_reg((dma_addr[1] - mfc_mem_base(0)) >> 11, + MFC_ENC_SI_CH1_CUR_C_ADR); +#endif +#else #if (MFC_MAX_MEM_PORT_NUM == 2) write_reg((exe_arg->in_Y_addr - mfc_mem_base(1)) >> 11, MFC_ENC_SI_CH1_CUR_Y_ADR); write_reg((exe_arg->in_CbCr_addr - mfc_mem_base(1)) >> 11, MFC_ENC_SI_CH1_CUR_C_ADR); @@ -1655,6 +1779,7 @@ static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg * write_reg((exe_arg->in_Y_addr - mfc_mem_base(0)) >> 11, MFC_ENC_SI_CH1_CUR_Y_ADR); write_reg((exe_arg->in_CbCr_addr - mfc_mem_base(0)) >> 11, MFC_ENC_SI_CH1_CUR_C_ADR); #endif +#endif #if 0 write_reg(1, MFC_ENC_STR_BF_U_EMPTY); @@ -1680,8 +1805,33 @@ static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg * exe_arg->out_encoded_size = read_reg(MFC_ENC_SI_STRM_SIZE); /* FIXME: port must be checked */ - exe_arg->out_Y_addr = mfc_mem_addr_ofs(read_reg(MFC_ENCODED_Y_ADDR) << 11, 1); - exe_arg->out_CbCr_addr = mfc_mem_addr_ofs(read_reg(MFC_ENCODED_C_ADDR) << 11, 1); +#ifdef CONFIG_SLP_DMABUF + if (exe_arg->memory_type == MEMORY_DMABUF) { + exe_arg->out_Y_addr = + mfc_get_buf_dmabuf(mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_Y_ADDR) << 11, 1)); + if (exe_arg->out_Y_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get Y fd error %d\n", + exe_arg->out_Y_addr); + return MFC_ENC_EXE_ERR; + } + exe_arg->out_CbCr_addr = + mfc_get_buf_dmabuf(mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_C_ADDR) << 11, 1)); + if (exe_arg->out_CbCr_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get CbCr fd error %d\n", + exe_arg->out_CbCr_addr); + return MFC_ENC_EXE_ERR; + } + } else { +#endif + exe_arg->out_Y_addr = mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_Y_ADDR) << 11, 1); + exe_arg->out_CbCr_addr = mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_C_ADDR) << 11, 1); +#ifdef CONFIG_SLP_DMABUF + } +#endif #if SUPPORT_SLICE_ENCODING } else { /* slice */ ret = mfc_cmd_slice_start(ctx); @@ -1699,8 +1849,35 @@ static int mfc_encoding_frame(struct mfc_inst_ctx *ctx, struct mfc_enc_exe_arg * exe_arg->out_encoded_size = enc_ctx->slicesize; /* FIXME: port must be checked */ - exe_arg->out_Y_addr = mfc_mem_addr_ofs(read_reg(MFC_ENCODED_Y_ADDR) << 11, 1); - exe_arg->out_CbCr_addr = mfc_mem_addr_ofs(read_reg(MFC_ENCODED_C_ADDR) << 11, 1); +#ifdef CONFIG_SLP_DMABUF + if (exe_arg->memory_type == MEMORY_DMABUF) { + exe_arg->out_Y_addr = + mfc_get_buf_dmabuf(mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_Y_ADDR) + << 11, 1)); + if (exe_arg->out_Y_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get Y fd error %d\n", + exe_arg->out_Y_addr); + return MFC_ENC_EXE_ERR; + } + exe_arg->out_CbCr_addr = + mfc_get_buf_dmabuf(mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_C_ADDR) + << 11, 1)); + if (exe_arg->out_CbCr_addr < 0) { + mfc_err("mfc_get_buf_dmabuf : Get CbCr fd error %d\n", + exe_arg->out_CbCr_addr); + return MFC_ENC_EXE_ERR; + } + } else { +#endif + exe_arg->out_Y_addr = mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_Y_ADDR) << 11, 1); + exe_arg->out_CbCr_addr = mfc_mem_addr_ofs + (read_reg(MFC_ENCODED_C_ADDR) << 11, 1); +#ifdef CONFIG_SLP_DMABUF + } +#endif } } @@ -1765,6 +1942,9 @@ int mfc_exec_encoding(struct mfc_inst_ctx *ctx, union mfc_args *args) { struct mfc_enc_exe_arg *exe_arg; int ret; +#ifdef CONFIG_SLP_DMABUF + int err; +#endif /* struct mfc_enc_ctx *enc_ctx = (struct mfc_enc_ctx *)ctx->c_priv; */ @@ -1787,6 +1967,21 @@ int mfc_exec_encoding(struct mfc_inst_ctx *ctx, union mfc_args *args) mfc_set_inst_state(ctx, INST_STATE_EXE_DONE); +#ifdef CONFIG_SLP_DMABUF + if (exe_arg->memory_type == MEMORY_DMABUF) { + err = mfc_dqbuf_dmabuf(ctx, ctx->enc_planes[0]); + if (err) { + mfc_err("mfc_dqbuf_dmabuf error!!! ret = %d\n", err); + return -EINVAL; + } + err = mfc_dqbuf_dmabuf(ctx, ctx->enc_planes[1]); + if (err) { + mfc_err("mfc_dqbuf_dmabuf error!!! ret = %d\n", err); + return -EINVAL; + } + } +#endif + return ret; } diff --git a/drivers/media/video/samsung/mfc5x/mfc_enc.h b/drivers/media/video/samsung/mfc5x/mfc_enc.h index 4bca251..21a9ba6 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_enc.h +++ b/drivers/media/video/samsung/mfc5x/mfc_enc.h @@ -87,6 +87,7 @@ struct mfc_enc_h264 { unsigned int sei_gen; /* H */ struct mfc_frame_packing fp; /* H */ + unsigned int sps_pps_gen; }; int mfc_init_encoding(struct mfc_inst_ctx *ctx, union mfc_args *args); diff --git a/drivers/media/video/samsung/mfc5x/mfc_inst.c b/drivers/media/video/samsung/mfc5x/mfc_inst.c index 518fbfc..ef0d0e0 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_inst.c +++ b/drivers/media/video/samsung/mfc5x/mfc_inst.c @@ -215,6 +215,7 @@ int mfc_set_inst_cfg(struct mfc_inst_ctx *ctx, int type, void *arg) case MFC_ENC_SETCONF_HIER_P: case MFC_ENC_SETCONF_SEI_GEN: case MFC_ENC_SETCONF_FRAME_PACKING: + case MFC_ENC_SETCONF_SPS_PPS_GEN: if (ctx->c_ops->set_codec_cfg) { if ((ctx->c_ops->set_codec_cfg(ctx, type, arg)) < 0) return MFC_SET_CONF_FAIL; diff --git a/drivers/media/video/samsung/mfc5x/mfc_inst.h b/drivers/media/video/samsung/mfc5x/mfc_inst.h index e297c55..b78dd91 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_inst.h +++ b/drivers/media/video/samsung/mfc5x/mfc_inst.h @@ -15,6 +15,9 @@ #define __MFC_INST_H __FILE__ #include <linux/list.h> +#ifdef CONFIG_SLP +#include <linux/videodev2.h> +#endif #include "mfc.h" #include "mfc_interface.h" @@ -130,7 +133,7 @@ struct mfc_inst_ctx { unsigned int width; unsigned int height; volatile unsigned char *shm; - unsigned int shmofs; + long shmofs; unsigned int ctxbufofs; unsigned int ctxbufsize; unsigned int descbufofs; /* FIXME: move to decoder context */ @@ -170,6 +173,10 @@ struct mfc_inst_ctx { #if SUPPORT_SLICE_ENCODING int slice_flag; #endif +#ifdef CONFIG_SLP + struct vb2_plane *enc_planes[VIDEO_MAX_PLANES]; + struct vb2_plane *dec_planes[VIDEO_MAX_PLANES]; +#endif }; struct mfc_inst_ctx *mfc_create_inst(void); diff --git a/drivers/media/video/samsung/mfc5x/mfc_interface.h b/drivers/media/video/samsung/mfc5x/mfc_interface.h index 61116e5..6845b8a 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_interface.h +++ b/drivers/media/video/samsung/mfc5x/mfc_interface.h @@ -242,6 +242,9 @@ struct mfc_enc_exe_arg { unsigned int out_y_cookie; unsigned int out_c_cookie; #endif +#ifdef CONFIG_SLP_DMABUF + SSBSIP_MFC_MEMORY_TYPE memory_type; /* [OUT] memory type */ +#endif }; struct mfc_dec_init_arg { @@ -312,6 +315,9 @@ struct mfc_dec_exe_arg { unsigned int out_y_cookie; unsigned int out_c_cookie; #endif +#ifdef CONFIG_SLP_DMABUF + SSBSIP_MFC_MEMORY_TYPE memory_type; /* [OUT] memory type */ +#endif int out_img_width; /* [OUT] width of YUV420 frame */ int out_img_height; /* [OUT] height of YUV420 frame */ int out_buf_width; /* [OUT] width of YUV420 frame */ diff --git a/drivers/media/video/samsung/mfc5x/mfc_mem.c b/drivers/media/video/samsung/mfc5x/mfc_mem.c index bdf7148..051e4c0 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_mem.c +++ b/drivers/media/video/samsung/mfc5x/mfc_mem.c @@ -551,10 +551,23 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) /* early allocator */ #if defined(CONFIG_S5P_MEM_CMA) #ifdef CONFIG_EXYNOS_CONTENT_PATH_PROTECTION +#if defined(CONFIG_USE_MFC_CMA) && defined(CONFIG_MACH_M0) + cma_infos[0].lower_bound = 0x5C100000; + cma_infos[0].upper_bound = 0x5F200000; + cma_infos[0].total_size = 0x03100000; + cma_infos[0].free_size = 0x03100000; + cma_infos[0].count = 1; +#else if (cma_info(&cma_infos[0], dev->device, "A")) { mfc_info("failed to get CMA info of 'mfc-secure'\n"); return -ENOMEM; } +#endif + printk(KERN_INFO "%s[%d] cma 0x%x 0x%x 0x%x 0x%x %u\n", + __func__, __LINE__, + (int)cma_infos[0].lower_bound, (int)cma_infos[0].upper_bound, + (int)cma_infos[0].total_size, (int)cma_infos[0].free_size, + cma_infos[0].count); if (cma_info(&cma_infos[1], dev->device, "B")) { mfc_info("failed to get CMA info of 'mfc-normal'\n"); @@ -598,6 +611,15 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) return -ENOMEM; } +#if defined(CONFIG_USE_MFC_CMA) && defined(CONFIG_MACH_M0) + base[0] = 0x5c100000; + dev->mem_infos[0].base = base[0]; + dev->mem_infos[0].size = size; + dev->mem_infos[0].addr = phys_to_virt(base[0]); + mfc_info("%s[%d]: base 0x%x, size 0x%x, addr 0x%x\n", + __func__, __LINE__, (int)base[0], (int)size, + (int)dev->mem_infos[0].addr); +#else base[0] = cma_alloc(dev->device, "A", size, ALIGN_128KB); if (IS_ERR_VALUE(base[0])) { mfc_err("failed to get rsv. memory from CMA on mfc-secure"); @@ -607,7 +629,7 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) dev->mem_infos[0].base = base[0]; dev->mem_infos[0].size = size; dev->mem_infos[0].addr = cma_get_virt(base[0], size, 0); - +#endif available_size -= dev->mem_infos[0].size; mfc_dbg("avail: 0x%08x\n", available_size); @@ -670,7 +692,12 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) size = MAX_MEM_OFFSET; } +#ifdef CONFIG_SLP + base[0] = cma_alloc(dev->device, "AB", MFC_FW_SYSTEM_SIZE, + ALIGN_128KB); +#else base[0] = cma_alloc(dev->device, "AB", size, ALIGN_128KB); +#endif if (IS_ERR_VALUE(base[0])) { mfc_err("failed to get rsv. memory from CMA"); return -ENOMEM; @@ -702,7 +729,12 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) size = MAX_MEM_OFFSET; } +#ifdef CONFIG_SLP + base[0] = cma_alloc(dev->device, cma_index ? "B" : "A", + MFC_FW_SYSTEM_SIZE, ALIGN_128KB); +#else base[0] = cma_alloc(dev->device, cma_index ? "B" : "A", size, ALIGN_128KB); +#endif if (IS_ERR_VALUE(base[0])) { mfc_err("failed to get rsv. memory from CMA on port #0"); return -ENOMEM; @@ -724,7 +756,12 @@ int mfc_init_mem_mgr(struct mfc_dev *dev) size = MAX_MEM_OFFSET; } +#ifdef CONFIG_SLP + base[1] = cma_index ? cma_infos[1].lower_bound : + cma_infos[0].lower_bound; +#else base[1] = cma_alloc(dev->device, cma_index ? "B" : "A", size, ALIGN_128KB); +#endif if (IS_ERR_VALUE(base[1])) { mfc_err("failed to get rsv. memory from CMA on port #1"); cma_free(base[0]); diff --git a/drivers/media/video/samsung/mfc5x/mfc_shm.h b/drivers/media/video/samsung/mfc5x/mfc_shm.h index e5d7ba7..3da6573 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_shm.h +++ b/drivers/media/video/samsung/mfc5x/mfc_shm.h @@ -66,7 +66,7 @@ enum MFC_SHM_OFS DBG_HISTORY_INPUT1 = 0x00D4, /* C */ DBG_HISTORY_OUTPUT = 0x00D8, /* C */ HIERARCHICAL_P_QP = 0x00E0, /* E, H.264 */ - HW_VERSRION = 0x010C, /* C */ + HW_VERSION = 0x010C, /* C */ SEI_ENABLE = 0x0168, /* C, H.264 */ FRAME_PACK_SEI_AVAIL = 0x016C, /* D, H.264 */ FRAME_PACK_ARRGMENT_ID = 0x0170, /* D, H.264 */ diff --git a/drivers/media/video/samsung/ump/Kconfig b/drivers/media/video/samsung/ump/Kconfig index 6304825..9d8e5e6 100644 --- a/drivers/media/video/samsung/ump/Kconfig +++ b/drivers/media/video/samsung/ump/Kconfig @@ -17,6 +17,14 @@ config UMP_VCM_ALLOC help Use VCM(virtual-contiguous-memory) to allocate physical memory. + +config UMP_R3P1_LSI + bool "Uses the R3P1 as a ump module" + depends on VIDEO_UMP + default n + ---help--- + This uses the r3p1 as a UMP kernel module + choice depends on VIDEO_UMP prompt "UMP MEMEMORY OPTION" diff --git a/drivers/media/video/samsung/ump/Makefile.common b/drivers/media/video/samsung/ump/Makefile.common index 35527a2..35527a2 100644..100755 --- a/drivers/media/video/samsung/ump/Makefile.common +++ b/drivers/media/video/samsung/ump/Makefile.common diff --git a/drivers/media/video/samsung/ump/Makefile_module b/drivers/media/video/samsung/ump/Makefile_module index f0c3829..f0c3829 100644..100755 --- a/drivers/media/video/samsung/ump/Makefile_module +++ b/drivers/media/video/samsung/ump/Makefile_module diff --git a/drivers/media/video/samsung/ump/arch b/drivers/media/video/samsung/ump/arch new file mode 120000 index 0000000..58ffbe7 --- /dev/null +++ b/drivers/media/video/samsung/ump/arch @@ -0,0 +1 @@ +arch-release
\ No newline at end of file diff --git a/drivers/media/video/samsung/ump/arch-debug b/drivers/media/video/samsung/ump/arch-debug new file mode 120000 index 0000000..0ed0909 --- /dev/null +++ b/drivers/media/video/samsung/ump/arch-debug @@ -0,0 +1 @@ +arch-pegasus-m400/
\ No newline at end of file diff --git a/drivers/media/video/samsung/ump/arch-debug/config.h b/drivers/media/video/samsung/ump/arch-debug/config.h deleted file mode 100644 index 688edc9..0000000 --- a/drivers/media/video/samsung/ump/arch-debug/config.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_UMP_H__ -#define __ARCH_CONFIG_UMP_H__ - -#define ARCH_UMP_BACKEND_DEFAULT USING_MEMORY -#if (USING_MEMORY == 0) /* Dedicated Memory */ -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0x2C000000 -#else -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0 -#endif - -#define ARCH_UMP_MEMORY_SIZE_DEFAULT UMP_MEM_SIZE*1024*1024 -#endif /* __ARCH_CONFIG_UMP_H__ */ diff --git a/drivers/media/video/samsung/ump/arch-pb-virtex5/config.h b/drivers/media/video/samsung/ump/arch-pb-virtex5/config.h index 38ae1ee..38ae1ee 100644..100755 --- a/drivers/media/video/samsung/ump/arch-pb-virtex5/config.h +++ b/drivers/media/video/samsung/ump/arch-pb-virtex5/config.h diff --git a/drivers/media/video/samsung/ump/arch-pegasus-m400/config.h b/drivers/media/video/samsung/ump/arch-pegasus-m400/config.h index 688edc9..688edc9 100644..100755 --- a/drivers/media/video/samsung/ump/arch-pegasus-m400/config.h +++ b/drivers/media/video/samsung/ump/arch-pegasus-m400/config.h diff --git a/drivers/media/video/samsung/ump/arch-release b/drivers/media/video/samsung/ump/arch-release new file mode 120000 index 0000000..0ed0909 --- /dev/null +++ b/drivers/media/video/samsung/ump/arch-release @@ -0,0 +1 @@ +arch-pegasus-m400/
\ No newline at end of file diff --git a/drivers/media/video/samsung/ump/arch-release/config.h b/drivers/media/video/samsung/ump/arch-release/config.h deleted file mode 100644 index 688edc9..0000000 --- a/drivers/media/video/samsung/ump/arch-release/config.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_UMP_H__ -#define __ARCH_CONFIG_UMP_H__ - -#define ARCH_UMP_BACKEND_DEFAULT USING_MEMORY -#if (USING_MEMORY == 0) /* Dedicated Memory */ -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0x2C000000 -#else -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0 -#endif - -#define ARCH_UMP_MEMORY_SIZE_DEFAULT UMP_MEM_SIZE*1024*1024 -#endif /* __ARCH_CONFIG_UMP_H__ */ diff --git a/drivers/media/video/samsung/ump/arch/config.h b/drivers/media/video/samsung/ump/arch/config.h deleted file mode 100644 index 688edc9..0000000 --- a/drivers/media/video/samsung/ump/arch/config.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2010-2012 ARM Limited. All rights reserved. - * - * This program is free software and is provided to you under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. - * - * A copy of the licence is included with the program, and can also be obtained from Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef __ARCH_CONFIG_UMP_H__ -#define __ARCH_CONFIG_UMP_H__ - -#define ARCH_UMP_BACKEND_DEFAULT USING_MEMORY -#if (USING_MEMORY == 0) /* Dedicated Memory */ -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0x2C000000 -#else -#define ARCH_UMP_MEMORY_ADDRESS_DEFAULT 0 -#endif - -#define ARCH_UMP_MEMORY_SIZE_DEFAULT UMP_MEM_SIZE*1024*1024 -#endif /* __ARCH_CONFIG_UMP_H__ */ diff --git a/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.c b/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.c index cc7b8be..cc7b8be 100644..100755 --- a/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.c +++ b/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.c diff --git a/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.h b/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.h index 881d3d8..881d3d8 100644..100755 --- a/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.h +++ b/drivers/media/video/samsung/ump/common/ump_kernel_descriptor_mapping.h diff --git a/drivers/media/video/samsung/ump/linux/license/gpl/ump_kernel_license.h b/drivers/media/video/samsung/ump/linux/license/gpl/ump_kernel_license.h index 50a021c..50a021c 100644..100755 --- a/drivers/media/video/samsung/ump/linux/license/gpl/ump_kernel_license.h +++ b/drivers/media/video/samsung/ump/linux/license/gpl/ump_kernel_license.h diff --git a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_dedicated.h b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_dedicated.h index 4f7180e..4f7180e 100644..100755 --- a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_dedicated.h +++ b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_dedicated.h diff --git a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.h b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.h index b638562d..b638562d 100644..100755 --- a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.h +++ b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.h diff --git a/drivers/media/video/samsung/ump/linux/ump_osk_atomics.c b/drivers/media/video/samsung/ump/linux/ump_osk_atomics.c index 77be0c9..77be0c9 100644..100755 --- a/drivers/media/video/samsung/ump/linux/ump_osk_atomics.c +++ b/drivers/media/video/samsung/ump/linux/ump_osk_atomics.c diff --git a/drivers/media/video/samsung/ump/linux/ump_osk_misc.c b/drivers/media/video/samsung/ump/linux/ump_osk_misc.c index 1f1118e..1f1118e 100644..100755 --- a/drivers/media/video/samsung/ump/linux/ump_osk_misc.c +++ b/drivers/media/video/samsung/ump/linux/ump_osk_misc.c diff --git a/drivers/media/video/slp_db8131m.c b/drivers/media/video/slp_db8131m.c deleted file mode 100644 index a42bfd4c..0000000 --- a/drivers/media/video/slp_db8131m.c +++ /dev/null @@ -1,796 +0,0 @@ -/* - * linux/drivers/media/video/slp_db8131m.c - * - * Copyright (c) 2012 Samsung Electronics Co., Ltd. - * - * 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/i2c.h> -#include <linux/init.h> -#include <media/v4l2-device.h> -#include <linux/delay.h> -#include <linux/version.h> -#include <media/v4l2-device.h> -#include <media/v4l2-subdev.h> -#ifdef CONFIG_VIDEO_SAMSUNG_V4L2 -#include <linux/videodev2_exynos_camera.h> -#endif -#include <media/db8131m_platform.h> - -#include "slp_db8131m.h" - -#ifdef DB8131M_USLEEP -#include <linux/hrtimer.h> -#endif - -#define CHECK_ERR(x) if (unlikely((x) < 0)) { \ - cam_err("i2c failed, err %d\n", x); \ - return x; \ - } - -#define NELEMS(array) (sizeof(array) / sizeof(array[0])) - -static inline int db8131m_read(struct i2c_client *client, - u16 subaddr, u16 *data) -{ - u8 buf[2]; - int err = 0; - struct i2c_msg msg = { - .addr = client->addr, - .flags = 0, - .len = 2, - .buf = buf, - }; - - *(u16 *)buf = cpu_to_be16(subaddr); - - err = i2c_transfer(client->adapter, &msg, 1); - if (unlikely(err < 0)) - cam_err("ERR: %d register read fail\n", __LINE__); - - msg.flags = I2C_M_RD; - - err = i2c_transfer(client->adapter, &msg, 1); - if (unlikely(err < 0)) - cam_err("ERR: %d register read fail\n", __LINE__); - - *data = ((buf[0] << 8) | buf[1]); - - return err; -} - -/* - * s5k6aafx sensor i2c write routine - * <start>--<Device address><2Byte Subaddr><2Byte Value>--<stop> - */ -static inline int db8131m_write(struct i2c_client *client, - u32 packet) -{ - u8 buf[4]; - int err = 0, retry_count = 5; - - struct i2c_msg msg = { - .addr = client->addr, - .flags = 0, - .buf = buf, - .len = 4, - }; - - if (!client->adapter) { - cam_err("ERR - can't search i2c client adapter\n"); - return -EIO; - } - - while (retry_count--) { - *(u32 *)buf = cpu_to_be32(packet); - err = i2c_transfer(client->adapter, &msg, 1); - if (likely(err == 1)) - break; - mdelay(10); - } - - if (unlikely(err < 0)) { - cam_err("ERR - 0x%08x write failed err=%d\n", - (u32)packet, err); - return err; - } - - return (err != 1) ? -1 : 0; -} - -/* program multiple registers */ -static int db8131m_write_regs(struct v4l2_subdev *sd, - const u8 *packet, u32 num) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - int ret = -EAGAIN; - int retry_count = 5; - - u8 buf[2] = {0,}; - - struct i2c_msg msg = { - msg.addr = client->addr, - msg.flags = 0, - msg.len = 2, - msg.buf = buf, - }; - - while (num) { - buf[0] = *packet++; - buf[1] = *packet++; - - num -= 2; - - retry_count = 5; - - while (retry_count--) { - ret = i2c_transfer(client->adapter, &msg, 1); - if (likely(ret == 1)) - break; - mdelay(10); - } - - if (unlikely(ret < 0)) { - cam_err("ERR - 0x%08x write failed err=%d\n", - (u32)packet, ret); - break; - } - } - - if (unlikely(ret < 0)) { - cam_err("fail to write registers!!\n"); - return -EIO; - } - - return 0; -} - -static int db8131m_check_dataline(struct v4l2_subdev *sd, s32 val) -{ - return 0; -} - -static int db8131m_debug_sensor_status(struct v4l2_subdev *sd) -{ - return 0; -} - -static int db8131m_check_sensor_status(struct v4l2_subdev *sd) -{ - return 0; -} - -static inline int db8131m_check_esd(struct v4l2_subdev *sd) -{ - return 0; -} - -static int db8131m_set_preview_start(struct v4l2_subdev *sd) -{ - struct db8131m_state *state = to_state(sd); - int err = -EINVAL; - - cam_info("reset preview\n"); - -#ifdef CONFIG_LOAD_FILE - err = db8131m_write_regs_from_sd(sd, "db8131m_preview"); -#else - err = db8131m_write_regs(sd, db8131m_preview, - sizeof(db8131m_preview) / sizeof(db8131m_preview[0])); -#endif - if (state->check_dataline) - err = db8131m_check_dataline(sd, 1); - if (unlikely(err)) { - cam_err("fail to make preview\n"); - return err; - } - - return 0; -} - -static int db8131m_set_preview_stop(struct v4l2_subdev *sd) -{ - return 0; -} - -static int db8131m_set_capture_start(struct v4l2_subdev *sd) -{ - return 0; -} - -static int db8131m_set_sensor_mode(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct db8131m_state *state = to_state(sd); - - if ((ctrl->value != SENSOR_CAMERA) && - (ctrl->value != SENSOR_MOVIE)) { - cam_err("ERR: Not support.(%d)\n", ctrl->value); - return -EINVAL; - } - - state->sensor_mode = ctrl->value; - - return 0; -} - -static int db8131m_enum_framesizes(struct v4l2_subdev *sd, \ - struct v4l2_frmsizeenum *fsize) -{ - return 0; -} - -static int db8131m_s_fmt(struct v4l2_subdev *sd, - struct v4l2_mbus_framefmt *ffmt) -{ - struct db8131m_state *state = to_state(sd); - u32 *width = NULL, *height = NULL; - - cam_dbg("E\n"); - /* - * Just copying the requested format as of now. - * We need to check here what are the formats the camera support, and - * set the most appropriate one according to the request from FIMC - */ - - state->req_fmt.width = ffmt->width; - state->req_fmt.height = ffmt->height; - state->req_fmt.priv = ffmt->field; - - switch (state->req_fmt.priv) { - case V4L2_PIX_FMT_MODE_PREVIEW: - cam_dbg("V4L2_PIX_FMT_MODE_PREVIEW\n"); - width = &state->preview_frmsizes.width; - height = &state->preview_frmsizes.height; - break; - - case V4L2_PIX_FMT_MODE_CAPTURE: - cam_dbg("V4L2_PIX_FMT_MODE_CAPTURE\n"); - width = &state->capture_frmsizes.width; - height = &state->capture_frmsizes.height; - break; - - default: - cam_err("ERR(EINVAL)\n"); - return -EINVAL; - } - - if ((*width != state->req_fmt.width) || - (*height != state->req_fmt.height)) { - cam_err("ERR: Invalid size. width= %d, height= %d\n", - state->req_fmt.width, state->req_fmt.height); - } - - return 0; -} - -static int db8131m_set_frame_rate(struct v4l2_subdev *sd, u32 fps) -{ - int err = 0; - - cam_info("frame rate %d\n\n", fps); - - switch (fps) { - case 7: - err = db8131m_write_regs(sd, db8131m_vt_7fps, - sizeof(db8131m_vt_7fps) / \ - sizeof(db8131m_vt_7fps[0])); - break; - case 10: - err = db8131m_write_regs(sd, db8131m_vt_10fps, - sizeof(db8131m_vt_10fps) / \ - sizeof(db8131m_vt_10fps[0])); - - break; - case 12: - err = db8131m_write_regs(sd, db8131m_vt_12fps, - sizeof(db8131m_vt_12fps) / \ - sizeof(db8131m_vt_12fps[0])); - - break; - case 15: - err = db8131m_write_regs(sd, db8131m_vt_15fps, - sizeof(db8131m_vt_15fps) / \ - sizeof(db8131m_vt_15fps[0])); - break; - default: - cam_err("ERR: Invalid framerate\n"); - break; - } - - if (unlikely(err < 0)) { - cam_err("i2c_write for set framerate\n"); - return -EIO; - } - - return err; -} - -static int db8131m_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms) -{ - int err = 0; - - cam_dbg("E\n"); - - return err; -} - -static int db8131m_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms) -{ - int err = 0; - u32 fps = 0; - struct db8131m_state *state = to_state(sd); - - if (!state->vt_mode) - return 0; - - cam_dbg("E\n"); - - fps = parms->parm.capture.timeperframe.denominator / - parms->parm.capture.timeperframe.numerator; - - if (fps != state->set_fps) { - if (fps < 0 && fps > 30) { - cam_err("invalid frame rate %d\n", fps); - fps = 30; - } - state->req_fps = fps; - - if (state->initialized) { - err = db8131m_set_frame_rate(sd, state->req_fps); - if (err >= 0) - state->set_fps = state->req_fps; - } - - } - - return err; -} - -static int db8131m_control_stream(struct v4l2_subdev *sd, u32 cmd) -{ - int err = 0; - - switch (cmd) { - case 0: /* STREAM_STOP */ - cam_dbg("stream stop!!!\n"); - break; - - case 1: /* STREAM_START */ - cam_warn("WARN: do nothing\n"); - break; - - default: - cam_err("ERR: Invalid cmd\n"); - break; - } - - if (unlikely(err)) - cam_err("failed to stream start(stop)\n"); - - return err; -} - -static int db8131m_init(struct v4l2_subdev *sd, u32 val) -{ - /* struct i2c_client *client = v4l2_get_subdevdata(sd); */ - struct db8131m_state *state = to_state(sd); - int err = -EINVAL; - - cam_dbg("E\n"); - - /* set initial regster value */ - if (state->sensor_mode == SENSOR_CAMERA) { - cam_info("load camera common setting\n"); - err = db8131m_write_regs(sd, db8131m_common_1, - sizeof(db8131m_common_1) / \ - sizeof(db8131m_common_1[0])); - - msleep(150); - - err |= db8131m_write_regs(sd, db8131m_common_2, - sizeof(db8131m_common_2) / \ - sizeof(db8131m_common_2[0])); - } else { - cam_info("load recording setting\n"); - err = db8131m_write_regs(sd, db8131m_common_1, - sizeof(db8131m_common_1) / \ - sizeof(db8131m_common_1[0])); - - msleep(150); - - err = db8131m_write_regs(sd, db8131m_common_2, - sizeof(db8131m_common_2) / \ - sizeof(db8131m_common_2[0])); - } - if (unlikely(err)) { - cam_err("failed to init\n"); - return err; - } - - /* We stop stream-output from sensor when starting camera. */ - err = db8131m_control_stream(sd, 0); - if (unlikely(err < 0)) - return err; - msleep(150); - - state->initialized = 1; - - return 0; -} - -static int db8131m_s_stream(struct v4l2_subdev *sd, int enable) -{ - struct db8131m_state *state = to_state(sd); - /* struct i2c_client *client = v4l2_get_subdevdata(sd); */ - int err = 0; - - cam_info("stream mode = %d\n", enable); - - switch (enable) { - case STREAM_MODE_CAM_OFF: - if (state->sensor_mode == SENSOR_CAMERA) { - if (state->check_dataline) - err = db8131m_check_dataline(sd, 0); - else - err = db8131m_control_stream(sd, 0); - } - break; - - case STREAM_MODE_CAM_ON: - /* The position of this code need to be adjusted later */ - if ((state->sensor_mode == SENSOR_CAMERA) - && (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE)) - err = db8131m_set_capture_start(sd); - else - err = db8131m_set_preview_start(sd); - break; - - case STREAM_MODE_MOVIE_ON: - cam_dbg("do nothing(movie on)!!\n"); - break; - - case STREAM_MODE_MOVIE_OFF: - cam_dbg("do nothing(movie off)!!\n"); - break; - - default: - cam_err("ERR: Invalid stream mode\n"); - break; - } - - if (unlikely(err < 0)) { - cam_err("ERR: faild\n"); - return err; - } - - return 0; -} - -static int db8131m_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - struct db8131m_state *state = to_state(sd); - int err = 0; - - cam_dbg("ctrl->id : %d\n", ctrl->id - V4L2_CID_PRIVATE_BASE); - - switch (ctrl->id) { - case V4L2_CID_CAMERA_EXIF_TV: - ctrl->value = state->exif.shutter_speed; - break; - case V4L2_CID_CAMERA_EXIF_ISO: - ctrl->value = state->exif.iso; - break; - default: - cam_err("no such control id %d\n", - ctrl->id - V4L2_CID_PRIVATE_BASE); - break; - } - - return err; -} - -static int db8131m_set_brightness(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct db8131m_state *state = to_state(sd); - int err = -EINVAL; - - cam_dbg("E\n"); - - if (state->check_dataline) - return 0; - - switch (ctrl->value) { - case EV_MINUS_4: - err = db8131m_write_regs(sd, db8131m_bright_m4, \ - sizeof(db8131m_bright_m4) / \ - sizeof(db8131m_bright_m4[0])); - break; - case EV_MINUS_3: - err = db8131m_write_regs(sd, db8131m_bright_m3, \ - sizeof(db8131m_bright_m3) / \ - sizeof(db8131m_bright_m3[0])); - - break; - case EV_MINUS_2: - err = db8131m_write_regs(sd, db8131m_bright_m2, \ - sizeof(db8131m_bright_m2) / \ - sizeof(db8131m_bright_m2[0])); - break; - case EV_MINUS_1: - err = db8131m_write_regs(sd, db8131m_bright_m1, \ - sizeof(db8131m_bright_m1) / \ - sizeof(db8131m_bright_m1[0])); - break; - case EV_DEFAULT: - err = db8131m_write_regs(sd, db8131m_bright_default, \ - sizeof(db8131m_bright_default) / \ - sizeof(db8131m_bright_default[0])); - break; - case EV_PLUS_1: - err = db8131m_write_regs(sd, db8131m_bright_p1, \ - sizeof(db8131m_bright_p1) / \ - sizeof(db8131m_bright_p1[0])); - break; - case EV_PLUS_2: - err = db8131m_write_regs(sd, db8131m_bright_p2, \ - sizeof(db8131m_bright_p2) / \ - sizeof(db8131m_bright_p2[0])); - break; - case EV_PLUS_3: - err = db8131m_write_regs(sd, db8131m_bright_p3, \ - sizeof(db8131m_bright_p3) / \ - sizeof(db8131m_bright_p3[0])); - break; - case EV_PLUS_4: - err = db8131m_write_regs(sd, db8131m_bright_p4, \ - sizeof(db8131m_bright_p4) / \ - sizeof(db8131m_bright_p4[0])); - break; - default: - cam_err("ERR: invalid brightness(%d)\n", ctrl->value); - return err; - break; - } - - if (unlikely(err < 0)) { - cam_err("ERR: i2c_write for set brightness\n"); - return -EIO; - } - - return 0; -} - -static int db8131m_set_blur(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - return 0; -} - -static int db8131m_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - /* struct i2c_client *client = v4l2_get_subdevdata(sd); */ - struct db8131m_state *state = to_state(sd); - int err = 0; - - cam_info("ctrl->id : %d, value=%d\n", ctrl->id - V4L2_CID_PRIVATE_BASE, - ctrl->value); - - if ((ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE) - && (ctrl->id != V4L2_CID_CAMERA_SENSOR_MODE) - && ((ctrl->id != V4L2_CID_CAMERA_VT_MODE)) - && (!state->initialized)) { - cam_warn("camera isn't initialized\n"); - return 0; - } - - switch (ctrl->id) { - case V4L2_CID_CAM_PREVIEW_ONOFF: - if (ctrl->value) - err = db8131m_set_preview_start(sd); - else - err = db8131m_set_preview_stop(sd); - cam_dbg("V4L2_CID_CAM_PREVIEW_ONOFF [%d]\n", ctrl->value); - break; - - case V4L2_CID_CAM_CAPTURE: - err = db8131m_set_capture_start(sd); - cam_dbg("V4L2_CID_CAM_CAPTURE\n"); - break; - - case V4L2_CID_CAMERA_BRIGHTNESS: - err = db8131m_set_brightness(sd, ctrl); - cam_dbg("V4L2_CID_CAMERA_BRIGHTNESS [%d]\n", ctrl->value); - break; - - case V4L2_CID_CAMERA_VGA_BLUR: - err = db8131m_set_blur(sd, ctrl); - cam_dbg("V4L2_CID_CAMERA_VGA_BLUR [%d]\n", ctrl->value); - break; - - case V4L2_CID_CAMERA_VT_MODE: - state->vt_mode = ctrl->value; - break; - - case V4L2_CID_CAMERA_CHECK_DATALINE: - state->check_dataline = ctrl->value; - cam_dbg("check_dataline = %d\n", state->check_dataline); - err = 0; - break; - - case V4L2_CID_CAMERA_SENSOR_MODE: - err = db8131m_set_sensor_mode(sd, ctrl); - cam_dbg("sensor_mode = %d\n", ctrl->value); - break; - - case V4L2_CID_CAMERA_CHECK_DATALINE_STOP: - cam_dbg("do nothing\n"); - /*err = db8131m_check_dataline_stop(sd);*/ - break; - - case V4L2_CID_CAMERA_CHECK_ESD: - err = db8131m_check_esd(sd); - break; - - case V4L2_CID_CAMERA_FRAME_RATE: - cam_dbg("do nothing\n"); - break; - - case V4L2_CID_CAMERA_CHECK_SENSOR_STATUS: - db8131m_debug_sensor_status(sd); - err = db8131m_check_sensor_status(sd); - break; - - default: - cam_err("ERR(ENOIOCTLCMD)\n"); - /* no errors return.*/ - break; - } - - cam_dbg("X\n"); - return err; -} - -static const struct v4l2_subdev_core_ops db8131m_core_ops = { - .init = db8131m_init, /* initializing API */ -#if 0 - .queryctrl = db8131m_queryctrl, - .querymenu = db8131m_querymenu, -#endif - .g_ctrl = db8131m_g_ctrl, - .s_ctrl = db8131m_s_ctrl, -}; - -static const struct v4l2_subdev_video_ops db8131m_video_ops = { - /*.s_crystal_freq = db8131m_s_crystal_freq,*/ - .s_mbus_fmt = db8131m_s_fmt, - .s_stream = db8131m_s_stream, - .enum_framesizes = db8131m_enum_framesizes, - /*.enum_frameintervals = db8131m_enum_frameintervals,*/ - /*.enum_fmt = db8131m_enum_fmt,*/ - .g_parm = db8131m_g_parm, - .s_parm = db8131m_s_parm, -}; - -static const struct v4l2_subdev_ops db8131m_ops = { - .core = &db8131m_core_ops, - .video = &db8131m_video_ops, -}; - -/* - * db8131m_probe - * Fetching platform data is being done with s_config subdev call. - * In probe routine, we just register subdev device - */ -static int db8131m_probe(struct i2c_client *client, - const struct i2c_device_id *id) -{ - struct db8131m_state *state = NULL; - struct v4l2_subdev *sd = NULL; - struct db8131m_platform_data *pdata = NULL; - cam_dbg("E\n"); - - state = kzalloc(sizeof(struct db8131m_state), GFP_KERNEL); - if (state == NULL) - return -ENOMEM; - - sd = &state->sd; - strcpy(sd->name, DB8131M_DRIVER_NAME); - - state->initialized = 0; - state->req_fps = state->set_fps = 8; - state->sensor_mode = SENSOR_CAMERA; - - pdata = client->dev.platform_data; - - if (!pdata) { - cam_err("no platform data\n"); - return -ENODEV; - } - - /* Registering subdev */ - v4l2_i2c_subdev_init(sd, client, &db8131m_ops); - - /* - * Assign default format and resolution - * Use configured default information in platform data - * or without them, use default information in driver - */ - if (!(pdata->default_width && pdata->default_height)) { - state->preview_frmsizes.width = DEFAULT_PREVIEW_WIDTH; - state->preview_frmsizes.height = DEFAULT_PREVIEW_HEIGHT; - } else { - state->preview_frmsizes.width = pdata->default_width; - state->preview_frmsizes.height = pdata->default_height; - } - state->capture_frmsizes.width = DEFAULT_CAPTURE_WIDTH; - state->capture_frmsizes.height = DEFAULT_CAPTURE_HEIGHT; - - cam_dbg("preview_width: %d , preview_height: %d, " - "capture_width: %d, capture_height: %d", - state->preview_frmsizes.width, state->preview_frmsizes.height, - state->capture_frmsizes.width, state->capture_frmsizes.height); - - state->req_fmt.width = state->preview_frmsizes.width; - state->req_fmt.height = state->preview_frmsizes.height; - - if (!pdata->pixelformat) - state->req_fmt.pixelformat = VT_DEFAULT_FMT; - else - state->req_fmt.pixelformat = pdata->pixelformat; - - cam_dbg("probed!!\n"); - - return 0; -} - -static int db8131m_remove(struct i2c_client *client) -{ - struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct db8131m_state *state = to_state(sd); - - cam_dbg("E\n"); - - state->initialized = 0; - - v4l2_device_unregister_subdev(sd); - kfree(to_state(sd)); - - return 0; -} - -static const struct i2c_device_id db8131m_id[] = { - { DB8131M_DRIVER_NAME, 0 }, - { }, -}; -MODULE_DEVICE_TABLE(i2c, db8131m_id); - -static struct i2c_driver db8131m_i2c_driver = { - .driver = { - .name = DB8131M_DRIVER_NAME, - }, - .probe = db8131m_probe, - .remove = db8131m_remove, - .id_table = db8131m_id, -}; - -static int __init db8131m_mod_init(void) -{ - cam_dbg("E\n"); - return i2c_add_driver(&db8131m_i2c_driver); -} - -static void __exit db8131m_mod_exit(void) -{ - cam_dbg("E\n"); - i2c_del_driver(&db8131m_i2c_driver); -} -module_init(db8131m_mod_init); -module_exit(db8131m_mod_exit); - -MODULE_DESCRIPTION("DB8131M CAM driver"); -MODULE_AUTHOR(" "); -MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/slp_db8131m.h b/drivers/media/video/slp_db8131m.h deleted file mode 100644 index 3c594a2..0000000 --- a/drivers/media/video/slp_db8131m.h +++ /dev/null @@ -1,100 +0,0 @@ -/* - * linux/drivers/media/video/slp_db8131m.c - * - * Copyright (c) 2012 Samsung Electronics Co., Ltd. - * - * 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. - */ - -#ifndef __DB8131M_H -#define __DB8131M_H - -#include <linux/types.h> - -extern struct class *camera_class; - -#define DB8131M_DRIVER_NAME "DB8131M" - -struct db8131m_framesize { - u32 width; - u32 height; -}; - -struct db8131m_exif { - u32 shutter_speed; - u16 iso; -}; - - -/* - * Driver information - */ -struct db8131m_state { - struct v4l2_subdev sd; - struct device *db8131m_dev; - /* - * req_fmt is the requested format from the application. - * set_fmt is the output format of the camera. Finally FIMC - * converts the camera output(set_fmt) to the requested format - * with hardware scaler. - */ - struct v4l2_pix_format req_fmt; - struct db8131m_framesize preview_frmsizes; - struct db8131m_framesize capture_frmsizes; - struct db8131m_exif exif; - - enum v4l2_sensor_mode sensor_mode; - s32 vt_mode; - s32 check_dataline; - u32 req_fps; - u32 set_fps; - u32 initialized; -}; - -static inline struct db8131m_state *to_state(struct v4l2_subdev *sd) -{ - return container_of(sd, struct db8131m_state, sd); -} - -/*#define CONFIG_CAM_DEBUG */ -#define cam_warn(fmt, ...) \ - do { \ - printk(KERN_WARNING "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_err(fmt, ...) \ - do { \ - printk(KERN_ERR "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_info(fmt, ...) \ - do { \ - printk(KERN_INFO "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#ifdef CONFIG_CAM_DEBUG -#define cam_dbg(fmt, ...) \ - do { \ - printk(KERN_DEBUG "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) -#else -#define cam_dbg(fmt, ...) -#endif /* CONFIG_CAM_DEBUG */ - - - -/*********** Sensor specific ************/ -#define DB8131M_DELAY 0xFFFF0000 -#define DB8131M_DEF_APEX_DEN 100 - -/* Register address */ -#define REG_PAGE_SHUTTER 0x7000 -#define REG_ADDR_SHUTTER 0x14D0 -#define REG_PAGE_ISO 0x7000 -#define REG_ADDR_ISO 0x14C8 - -#include "slp_db8131m_setfile.h" - -#endif /* __DB8131M_H */ diff --git a/drivers/media/video/slp_db8131m_setfile.h b/drivers/media/video/slp_db8131m_setfile.h deleted file mode 100644 index ebbdbb0..0000000 --- a/drivers/media/video/slp_db8131m_setfile.h +++ /dev/null @@ -1,2264 +0,0 @@ -/* - * linux/drivers/media/video/slp_db8131m_setfile.h - * - * Copyright (c) 2012 Samsung Electronics Co., Ltd. - * - * 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. - */ -#ifndef __DB8131M_SETFILE_H -#define __DB8131M_SETFILE_H - -#include <linux/types.h> - -/* 1.3M mipi setting-common from PARTRON */ -/*******************************************************************/ -/* Name : DB8131M Initial Setfile*/ -/* PLL mode : MCLK=24MHz / PCLK=48MHz*/ -/* FPS : Preview 7.5~15fps / Capture 7.5fps / recording 25fps*/ -/* Date : 2011.12.06*/ -/*******************************************************************/ - - -static const u8 db8131m_common_1[] = { -/***************************************************/ -/* Command Preview 7.5~15fps*/ -/***************************************************/ -0xFF, 0xC0, /*Page mode*/ -0x10, 0x01, -}; -/*Wait 150*/ - -static const u8 db8131m_common_2[] = { -/***************************************************/ -/* Format*/ -/***************************************************/ -0xFF, 0xA1, /*Page mode*/ -0x70, 0x01, -0x71, 0x0D, - -/***************************************************/ -/* SensorCon*/ -/***************************************************/ -0xFF, 0xD0, /*Page mode*/ -0x0F, 0x0B, /*ABLK_Ctrl_1_Addr*/ -0x13, 0x00, /*Gain_Addr*/ -0x15, 0x01, /*IVREFT_REFB_Addr*/ -0x20, 0x0E, /*ABLK_Rsrv_Addr*/ -0x23, 0x01, /*IVREFT2_REFB2_Addr*/ -0x24, 0x01, /*IPPG_IVCM2_Addr*/ -0x39, 0x70, /*RiseSx_CDS_1_L_Addr*/ -0x51, 0x19, /*Fallcreset_1_L_Addr*/ -0x83, 0x2D, /*RiseTran_Sig_Even_L_Addr*/ -0x85, 0x2F, /*FallTran_Sig_Even_L_Addr*/ -0x87, 0x2D, /*RiseTran_Sig_Odd_L_Addr*/ -0x89, 0x2F, /*FallTran_Sig_Odd_L_Addr*/ -0x8B, 0x27, /*RiseCNT_EN_1_L_Addr*/ -0x8D, 0x6c, /*FallCNT_EN_1_L_Addr*/ -0xD7, 0x80, /*ABLK_Ctrl_12_Addr*/ -0xDB, 0xA2, /*FallScanTx15_1_L_Addr*/ -0xED, 0x01, /*PLL_P_Addr*/ -0xEE, 0x0F, /*PLL_M_Addr*/ -0xEF, 0x00, /*PLL_S_Addr*/ -0xF9, 0x00, /*ABLK_Ctrl_8*/ -0xF8, 0x00, /*Vblank Sleep Mode enable*/ -0xFB, 0x90, /*PostADC_Gain_Addr*/ - -/***************************************************/ -/* Analog ADF*/ -/***************************************************/ -0xFF, 0x85, /*Page mode*/ -0x89, 0x93, /*gAdf_u8APThreshold*/ -0x8A, 0x0C, /*u8APClmpThreshold*/ -0x8C, 0x07, /*gAdf_u8APMinVal_ThrClampH*/ -0x8D, 0x40, /*gAdf_u8APMinVal_ThrClampL*/ -0x8E, 0x03, /*gAdf_u8APMinVal_DOFFSET*/ -0x8F, 0x14, /*gAdf_u8APMinVal_AMP2_1_SDM*/ -0x91, 0x1A, /*gAdf_u8APMinVal_AMP4_3_SDM*/ -0x92, 0x0F, /*gAdf_u8APMinVal_FallIntTx15*/ -0x93, 0x47, /*gAdf_u8APMinVal_CDSxRange_CtrlPre*/ -0x95, 0x18, /*gAdf_u8APMinVal_REFB_IVCM*/ -0x96, 0x38, /*gAdf_u8APMinVal_ref_os_PB*/ -0x97, 0x0D, /*gAdf_u8APMinVal_NTx_Range*/ -0x98, 0x0D, /*gAdf_u8APMaxVal_Clmp_rst*/ -0x99, 0x06, /*gAdf_u8APMaxVal_ThrClampH*/ -0x9A, 0x9F, /*gAdf_u8APMaxVal_ThrClampL*/ -0x9B, 0x02, /*gAdf_u8APMaxVal_DOFFSET*/ -0x9C, 0x1C, /*gAdf_u8APMaxVal_AMP2_1_SDM*/ -0x9E, 0x11, /*gAdf_u8APMaxVal_AMP4_3_SDM*/ -0x9F, 0x5D, /*gAdf_u8APMaxVal_FallIntTx15*/ -0xA0, 0x78, /*gAdf_u8APMaxVal_CDSxRange_CtrlPre*/ -0xA2, 0x18, /*gAdf_u8APMaxVal_REFB_IVCM*/ -0xA3, 0x40, /*gAdf_u8APMaxVal_ref_os_PB*/ -0xA4, 0x0B, /*gAdf_u8APMaxVal_NTx_Range*/ - -0xFF, 0x86, /*Page mode*/ -0x15, 0x00, /*gPT_u8Adf_APThrHys*/ -0x16, 0xF7, /*gPT_u8Adf_APFallIntTxThrLevel*/ -0x17, 0x13, /*gPT_u8Adf_APMinVal_BP2_1_SDM*/ -0x18, 0x13, /*gPT_u8Adf_APMidVal_BP2_1_SDM*/ -0x19, 0x1C, /*gPT_u8Adf_APMaxVal_BP2_1_SDM*/ -0x1A, 0x06, /*gPT_u8Adf_APMidVal_ThrClampH*/ -0x1B, 0xF0, /*gPT_u8Adf_APMidVal_ThrClampL*/ -0x1C, 0x01, /*gPT_u8Adf_APMidVal_DOFFSET*/ -0x1D, 0x14, /*gPT_u8Adf_APMidVal_AMP2_1_SDM*/ -0x1F, 0x31, /*gPT_u8Adf_APMidVal_AMP4_3_SDM*/ -0x20, 0x68, /*gPT_u8Adf_APMidVal_CDSxRange_CtrlPre*/ -0x22, 0x18, /*gPT_u8Adf_APMidVal_REFB_IVCM*/ -0x23, 0x38, /*gPT_u8Adf_APMidVal_ref_os_PB*/ -0x24, 0x0F, /*gPT_u8Adf_APMidVal_NTx_Range*/ -0x25, 0x77, /*gPT_u8Adf_APVal_EnSiSoSht_EnSm*/ - -0xFF, 0x87, /*Page mode*/ -0xEA, 0x41, - -0xFF, 0xD0, /*Page mode*/ -0x20, 0x0D, /*ABLK_Rsrv_Addr*/ - -0xFF, 0x83, /*Page mode*/ -0x63, 0x28, /*Again Table*/ -0x64, 0x10, /*Again Table*/ -0x65, 0xA8, /*Again Table*/ -0x66, 0x50, /*Again Table*/ -0x67, 0x28, /*Again Table*/ -0x68, 0x14, /*Again Table*/ - - -/***************************************************/ -/* AE*/ -/***************************************************/ -0xFF, 0x82, /*Page mode*/ -0x95, 0x88, /* AE weight*/ -0x96, 0x88, -0x97, 0xF8, -0x98, 0x8F, -0x99, 0xF8, -0x9A, 0x8F, -0x9B, 0x88, -0x9C, 0x88, -0xA9, 0x40, /* OTarget*/ -0xAA, 0x40, /* ITarget*/ -0x9D, 0x66, /* AE Speed*/ -0x9F, 0x06, /* AE HoldBnd*/ -0xA8, 0x40, /* STarget*/ -0xB9, 0x04, /* RGain*/ -0xBB, 0x04, /* GGain*/ -0xBD, 0x04, /* BGain*/ -0xC5, 0x02, /* PeakMvStep*/ -0xC6, 0x38, /* PeakTgMin*/ -0xC7, 0x24, /* PeakRatioTh1*/ -0xC8, 0x10, /* PeakRatioTh0*/ -0xC9, 0x05, /* PeakLuTh*/ -0xD5, 0x60, /* LuxGainTB_2*/ -0xFF, 0x83, /*Page mode */ -0x2F, 0x04, /* TimeNum0*/ -0x30, 0x05, /* TimeNum1*/ -0x4F, 0x05, /* FrameOffset*/ -0xFF, 0x82, /*Page mode */ -0xA1, 0x0A, /* AnalogGainMax*/ -0xF3, 0x09, /* SCLK*/ -0xF4, 0x60, -0xF9, 0x00, /* GainMax*/ -0xFA, 0xC8, /* GainMax*/ -0xFB, 0x62, /* Gain3Lut*/ -0xFC, 0x39, /* Gain2Lut*/ -0xFD, 0x28, /* Gain1Lut*/ -0xFE, 0x12, /* GainMin*/ -0xFF, 0x83, /*Page mode */ -0x03, 0x0F, /* TimeMax60Hz : 8fps*/ -0x04, 0x0A, /* Time3Lux60Hz : 12fps*/ -0x05, 0x04, /* Time2Lut60Hz : 24fps*/ -0x06, 0x04, /* Time1Lut60Hz : 24fps*/ -0xFF, 0x82, /*Page mode */ -0xD3, 0x12, /* LuxTBGainStep0 */ -0xD4, 0x36, /* LuxTBGainStep1 */ -0xD5, 0x60, /* LuxTBGainStep2*/ -0xD6, 0x01, /* LuxTBTimeStep0H*/ -0xD7, 0x00, /* LuxTBTimeStep0L*/ -0xD8, 0x01, /* LuxTBTimeStep1H*/ -0xD9, 0xC0, /* LuxTBTimeStep1L*/ -0xDA, 0x06, /* LuxTBTimeStep2H*/ -0xDB, 0x00, /* LuxTBTimeStep2L*/ -0xFF, 0x83, /*Page mode */ -0x0B, 0x04, -0x0C, 0x4C, /* Frame Rate*/ -0xFF, 0x82, /*Page mode */ -0x92, 0x5D, - -/***************************************************/ -/* AWB*/ -/***************************************************/ -0xFF, 0x83, /*Page mode */ -0x79, 0x83, /* AWB SKIN ON*/ -0x86, 0x07, /* gAWB_u16MinGrayCnt_rw_0*/ -0x87, 0x00, /* gAWB_u16MinGrayCnt_rw_1*/ -0x90, 0x05, /* gAWB_u16FinalRGain_ro_0*/ -0x94, 0x05, /* gAWB_u16FinalBGain_ro_0*/ -0x98, 0xD4, /* SkinWinCntTh*/ -0xA2, 0x28, /* SkinYTh*/ -0xA3, 0x00, /* SkinHoldHitCnt*/ -0xA4, 0x0F, /* SkinHoldHitCnt*/ -0xAD, 0x65, /* u8SkinTop2*/ -0xAE, 0x80, /* gAwb_u8SkinTop2LS1Ratio_rw 5zone*/ -0xAF, 0x20, /* gAwb_u8SkinTop2LS2Ratio_rw 6zone */ -0xB4, 0x10, /* u8SkinTop2LSHys_rw*/ -0xB5, 0x54, /* gAwb_u8SkinLTx*/ -0xB6, 0xbd, /* gAwb_u8SkinLTy*/ -0xB7, 0x74, /* gAwb_u8SkinRBx*/ -0xB8, 0x9d, /* gAwb_u8SkinRBy*/ -0xBA, 0x4F, /* UniCThrY_rw*/ -0xBF, 0x0C, /* u16UniCGrayCntThr_rw_0*/ -0xC0, 0x80, /* u16UniCGrayCntThr_rw_1*/ -0xFF, 0x87, /*Page mode */ -0xC9, 0x22, /* gUR_u8AWBTrim_Addr*/ -0xFF, 0x84, /*Page mode */ -0x49, 0x02, /* Threshold_indoor*/ -0x4A, 0x00, -0x4B, 0x03, /* Threshold_outdoor*/ -0x4C, 0x80, -0xFF, 0x83, /*Page mode */ -0xCB, 0x03, /* R MinGain [Default 0X20] A Spec Pass */ -0xCC, 0xC0, /* R MinGain [Default 0X20] A Spec Pass */ -0x82, 0x00, /* lockratio*/ -0xFF, 0x84, /*Page mode */ -0x3D, 0x00, /* gAwb_u32LuxConst1_rw_0*/ -0x3E, 0x00, /* gAwb_u32LuxConst1_rw_1*/ -0x3F, 0x06, /* gAwb_u32LuxConst1_rw_2*/ -0x40, 0x20, /* gAwb_u32LuxConst1_rw_3*/ -0x41, 0x07, /* gAwb_u32LuxConst2_rw_0*/ -0x42, 0x53, /* gAwb_u32LuxConst2_rw_1*/ -0x43, 0x00, /* gAwb_u32LuxConst2_rw_2*/ -0x44, 0x00, /* gAwb_u32LuxConst2_rw_3*/ -0x55, 0x03, /* gAwb_u8Weight_Gen_rw_0 */ -0x56, 0x10, /* gAwb_u8Weight_Gen_rw_1 */ -0x57, 0x14, /* gAwb_u8Weight_Gen_rw_2 */ -0x58, 0x07, /* gAwb_u8Weight_Gen_rw_3 */ -0x59, 0x04, /* gAwb_u8Weight_Gen_rw_4 */ -0x5A, 0x03, /* gAwb_u8Weight_Gen_rw_5 */ -0x5B, 0x03, /* gAwb_u8Weight_Gen_rw_6 */ -0x5C, 0x15, /* gAwb_u8Weight_Gen_rw_7 */ -0x5D, 0x01, /* gAwb_u8Weight_Ind_rw_0 */ -0x5E, 0x0F, /* gAwb_u8Weight_Ind_rw_1 */ -0x5F, 0x07, /* gAwb_u8Weight_Ind_rw_2 */ -0x60, 0x14, /* gAwb_u8Weight_Ind_rw_3 */ -0x61, 0x14, /* gAwb_u8Weight_Ind_rw_4 */ -0x62, 0x12, /* gAwb_u8Weight_Ind_rw_5 */ -0x63, 0x11, /* gAwb_u8Weight_Ind_rw_6 */ -0x64, 0x14, /* gAwb_u8Weight_Ind_rw_7 */ -0x65, 0x03, /* gAwb_u8Weight_Outd_rw_0*/ -0x66, 0x05, /* gAwb_u8Weight_Outd_rw_1*/ -0x67, 0x15, /* gAwb_u8Weight_Outd_rw_2*/ -0x68, 0x04, /* gAwb_u8Weight_Outd_rw_3*/ -0x69, 0x01, /* gAwb_u8Weight_Outd_rw_4*/ -0x6A, 0x02, /* gAwb_u8Weight_Outd_rw_5*/ -0x6B, 0x03, /* gAwb_u8Weight_Outd_rw_6*/ -0x6C, 0x15, /* gAwb_u8Weight_Outd_rw_6*/ -0xFF, 0x85, /*Page mode */ -0xE2, 0x0C, /* gPT_u8Awb_UnicolorZone_rw */ -0xFF, 0x83, /*Page mode */ -0xCD, 0x06, /*Max Rgain*/ -0xCE, 0x80, -0xD1, 0x06, /*Max BGain*/ -0xd2, 0x80, - -/***************************************************/ -/* AWB STE*/ -/***************************************************/ -0xFF, 0xA1, /*Page mode */ -/*Flash*/ -0xA0, 0x5c, /*AWBZone0LTx*/ -0xA1, 0x7a, /*AWBZone0LTy*/ -0xA2, 0x69, /*AWBZone0RBx*/ -0xA3, 0x6f, /*AWBZone0RBy*/ -/*cloudy*/ -0xA4, 0x73, /*AWBZone1LTx*/ -0xA5, 0x55, /*AWBZone1LTy*/ -0xA6, 0x8C, /*AWBZone1RBx*/ -0xA7, 0x30, /*AWBZone1RBy */ -/*Daylight */ -0xA8, 0x69, /*AWBZone2LTx*/ -0xA9, 0x69, /*AWBZone2LTy*/ -0xAA, 0x83, /*AWBZone2RBx*/ -0xAB, 0x52, /*AWBZone2RBy */ -/*Fluorescent */ -0xAC, 0x57, /*AWBZone3LTx*/ -0xAD, 0x6e, /*AWBZone3LTy*/ -0xAE, 0x6f, /*AWBZone3RBx*/ -0xAF, 0x59, /*AWBZone3RBy*/ - -/*CWF */ -0xB0, 0x50, /*AWBZone4LTx*/ -0xB1, 0x74, /*AWBZone4LTy*/ -0xB2, 0x65, /*AWBZone4RBx*/ -0xB3, 0x5d, /*AWBZone4RBy*/ -/*TL84 */ -0xB4, 0x53, /*AWBZone5LTx*/ -0xB5, 0x7f, /*AWBZone5LTy*/ -0xB6, 0x62, /*AWBZone5RBx*/ -0xB7, 0x75, /*AWBZone5RBy */ -/*A */ -0xB8, 0x4a, /*AWBZone6LTx*/ -0xB9, 0x87, /*AWBZone6LTy*/ -0xBA, 0x59, /*AWBZone6RBx*/ -0xBB, 0x78, /*AWBZone6RBy*/ -/*Horizon */ -0xBC, 0x41, /*AWBZone7LTx*/ -0xBD, 0x91, /*AWBZone7LTy*/ -0xBE, 0x4b, /*AWBZone7RBx*/ -0xBF, 0x89, /*AWBZone7RBy*/ -/*Skin */ -0xC0, 0x5b, /*AWBZone8LTx*/ -0xC1, 0x85, /*AWBZone8LTy*/ -0xC2, 0x60, /*AWBZone8RBx*/ -0xC3, 0x7b, /*AWBZone8RBy*/ - -/***************************************************/ -/* UR*/ -/***************************************************/ -0xFF, 0x85, /*Page mode */ -0x06, 0x05, -0xFF, 0x86, /*Page mode */ -0x14, 0x1E, /* CCM sum 1*/ -0xFF, 0x85, /*Page mode */ -0x86, 0x42, /* 42 saturation level*/ -0x07, 0x00, /* sup hysteresis*/ - -/*DAY light */ -0xFF, 0x83, /*Page mode */ -0xEA, 0x00, /*gAwb_s16AdapCCMTbl_0*/ -0xEB, 0x53, /*gAwb_s16AdapCCMTbl_1*/ -0xEC, 0xFF, /*gAwb_s16AdapCCMTbl_2*/ -0xED, 0xE1, /*gAwb_s16AdapCCMTbl_3*/ -0xEE, 0x00, /*gAwb_s16AdapCCMTbl_4*/ -0xEF, 0x05, /*gAwb_s16AdapCCMTbl_5*/ -0xF0, 0xFF, /*gAwb_s16AdapCCMTbl_6*/ -0xF1, 0xF3, /*gAwb_s16AdapCCMTbl_7*/ -0xF2, 0x00, /*gAwb_s16AdapCCMTbl_8*/ -0xF3, 0x4B, /*gAwb_s16AdapCCMTbl_9*/ -0xF4, 0xFF, /*gAwb_s16AdapCCMTbl_10*/ -0xF5, 0xFA, /*gAwb_s16AdapCCMTbl_11*/ -0xF6, 0xFF, /*gAwb_s16AdapCCMTbl_12*/ -0xF7, 0xFa, /*gAwb_s16AdapCCMTbl_13*/ -0xF8, 0xFF, /*gAwb_s16AdapCCMTbl_14*/ -0xF9, 0xC3, /*gAwb_s16AdapCCMTbl_15*/ -0xFA, 0x00, /*gAwb_s16AdapCCMTbl_16*/ -0xFB, 0x80, /*gAwb_s16AdapCCMTbl_17*/ - -/*CWF lgiht */ -0xFF, 0x83, /*Page mode*/ -0xFC, 0x00, /* gAwb_s16AdapCCMTbl_18 */ -0xFD, 0x68, /* gAwb_s16AdapCCMTbl_19 */ -0xFF, 0x85, /*Page mode */ -0xE0, 0xFF, /* gAwb_s16AdapCCMTbl_20 */ -0xE1, 0xde, /* gAwb_s16AdapCCMTbl_21 */ -0xFF, 0x84, /*Page mode */ -0x00, 0xff, /* gAwb_s16AdapCCMTbl_22 */ -0x01, 0xfa, /* gAwb_s16AdapCCMTbl_23 */ -0x02, 0xFF, /* gAwb_s16AdapCCMTbl_24 */ -0x03, 0xf0, /* gAwb_s16AdapCCMTbl_25 */ -0x04, 0x00, /* gAwb_s16AdapCCMTbl_26 */ -0x05, 0x52, /* gAwb_s16AdapCCMTbl_27 */ -0x06, 0xFF, /* gAwb_s16AdapCCMTbl_28 */ -0x07, 0xFa, /* gAwb_s16AdapCCMTbl_29 */ -0x08, 0x00, /* gAwb_s16AdapCCMTbl_30 */ -0x09, 0x00, /* gAwb_s16AdapCCMTbl_31 */ -0x0A, 0xFF, /* gAwb_s16AdapCCMTbl_32 */ -0x0B, 0xdb, /* gAwb_s16AdapCCMTbl_33 */ -0x0C, 0x00, /* gAwb_s16AdapCCMTbl_34 */ -0x0D, 0x68, /* gAwb_s16AdapCCMTbl_35 */ - -/*A light */ - -0x0E, 0x00, /* gAwb_s16AdapCCMTbl_36 */ -0x0F, 0x6d, /* gAwb_s16AdapCCMTbl_37 */ -0x10, 0xFF, /* gAwb_s16AdapCCMTbl_38 */ -0x11, 0xd5, /* gAwb_s16AdapCCMTbl_39 */ -0x12, 0xff, /* gAwb_s16AdapCCMTbl_40 */ -0x13, 0xfe, /* gAwb_s16AdapCCMTbl_41 */ -0x14, 0xFF, /* gAwb_s16AdapCCMTbl_42 */ -0x15, 0xf4, /* gAwb_s16AdapCCMTbl_43 */ -0x16, 0x00, /* gAwb_s16AdapCCMTbl_44 */ -0x17, 0x5a, /* gAwb_s16AdapCCMTbl_45 */ -0x18, 0xff, /* gAwb_s16AdapCCMTbl_46 */ -0x19, 0xef, /* gAwb_s16AdapCCMTbl_47 */ -0x1A, 0xff, /* gAwb_s16AdapCCMTbl_48 */ -0x1B, 0xfa, /* gAwb_s16AdapCCMTbl_49 */ -0x1C, 0xFF, /* gAwb_s16AdapCCMTbl_50 */ -0x1D, 0xbe, /* gAwb_s16AdapCCMTbl_51 */ -0x1E, 0x00, /* gAwb_s16AdapCCMTbl_52 */ -0x1F, 0x86, /* gAwb_s16AdapCCMTbl_53 */ - - -/***************************************************/ -/* ADF*/ -/***************************************************/ - -/* ISP setting*/ -0xFF, 0xA0, /*Page mode */ -0x10, 0x80, /* BLC: ABLC db*/ -0x60, 0x73, /* CDC: Dark CDC ON */ -0x61, 0x1F, /* Six CDC_Edge En, Slash EN*/ -0x69, 0x0C, /* Slash direction Line threshold*/ -0x6A, 0x60, /* Slash direction Pixel threshold*/ -0xC2, 0x04, /* NSF: directional smoothing*/ -0xD0, 0x51, /* DEM: pattern detection*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /* EDE: Luminane adaptation on*/ -0x32, 0x50, /* EDE: Adaptation slope */ -0x34, 0x00, /* EDE: x1 point */ -0x35, 0x0B, /* EDE: x1 point */ -0x36, 0x01, /* EDE: x2 point */ -0x37, 0x80, /* EDE: x2 point */ -0x3A, 0x00, /* EDE: Adaptation left margin*/ -0x3B, 0x30, /* EDE: Adaptation right margin*/ -0x3C, 0x08, /* EDE: rgb edge threshol*/ - -/* Adaptive Setting*/ -0xFF, 0x85, /*Page mode */ -/* LSC*/ -0x0F, 0x43, /* LVLSC lux level threshold*/ -0x10, 0x43, /* LSLSC Light source , threshold lux*/ - -/* BGT*/ -0x17, 0x30, /* BGT lux level threshold*/ -0x26, 0x20, /* MinVal */ -0x3c, 0x00, /* MaxVal */ - -/* CNT*/ -0x18, 0x43, /* CNT lux level threshold*/ -0x27, 0x00, /* MinVal */ -0x3d, 0x00, /* MaxVal */ - -/* NSF */ -0x12, 0xA5, /* NSF lux level threshold */ -0x22, 0x38, /* u8MinVal_NSF1*/ -0x23, 0x70, /* u8MinVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x12, 0x00, /* u8MinVal_NSF3*/ -0xFF, 0x85, /*Page mode */ -0x38, 0x12, /* u8MaxVal_NSF1*/ -0x39, 0x30, /* u8MaxVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x13, 0x08, /* u8MaxVal_NSF3*/ - -/* GDC*/ -0xFF, 0x85, /*Page mode */ -0x15, 0xF4, /* GDC lux level threshold */ -0x2D, 0x20, /* u8MinVal_GDC1*/ -0x2E, 0x30, /* u8MinVal_GDC2*/ -0x43, 0x40, /* u8MaxVal_GDC1*/ -0x44, 0x80, /* u8MaxVal_GDC2*/ - -/* ISP Edge*/ -0x04, 0xFB, /* EnEDE*/ -0x14, 0x54, /* u8ThrLevel_EDE*/ -0x28, 0x00, /* u8MinVal_EDE_CP*/ -0x29, 0x03, /* u8MinVal_EDE1*/ -0x2A, 0x20, /* u8MinVal_EDE2*/ -0x2B, 0x00, /* u8MinVal_EDE_OFS*/ -0x2C, 0x22, /* u8MinVal_SG*/ -0x3E, 0x00, /* u8MaxVal_EDE_CP*/ -0x3F, 0x09, /* u8MaxVal_EDE1*/ -0x40, 0x22, /* u8MaxVal_EDE2*/ -0x41, 0x02, /* u8MaxVal_EDE_OFS*/ -0x42, 0x33, /* u8MaxVal_SG*/ - -/* Gamma Adaptive*/ - -0x16, 0xA0, /* Gamma Threshold*/ -0x47, 0x00, /* Min_Gamma_0*/ -0x48, 0x03, /* Min_Gamma_1*/ -0x49, 0x10, /* Min_Gamma_2*/ -0x4A, 0x25, /* Min_Gamma_3*/ -0x4B, 0x3B, /* Min_Gamma_4*/ -0x4C, 0x4F, /* Min_Gamma_5*/ -0x4D, 0x6D, /* Min_Gamma_6*/ -0x4E, 0x86, /* Min_Gamma_7*/ -0x4F, 0x9B, /* Min_Gamma_8*/ -0x50, 0xAD, /* Min_Gamma_9*/ -0x51, 0xC2, /* Min_Gamma_10*/ -0x52, 0xD3, /* Min_Gamma_11*/ -0x53, 0xE1, /* Min_Gamma_12*/ -0x54, 0xE9, /* Min_Gamma_13*/ -0x55, 0xF2, /* Min_Gamma_14*/ -0x56, 0xFA, /* Min_Gamma_15*/ -0x57, 0xFF, /* Min_Gamma_16*/ -0x58, 0x00, /* Max_Gamma_0 */ -0x59, 0x06, /* Max_Gamma_1 */ -0x5a, 0x14, /* Max_Gamma_2 */ -0x5b, 0x30, /* Max_Gamma_3 */ -0x5c, 0x4A, /* Max_Gamma_4 */ -0x5d, 0x5D, /* Max_Gamma_5 */ -0x5e, 0x75, /* Max_Gamma_6 */ -0x5f, 0x89, /* Max_Gamma_7 */ -0x60, 0x9A, /* Max_Gamma_8 */ -0x61, 0xA7, /* Max_Gamma_9 */ -0x62, 0xBC, /* Max_Gamma_10 */ -0x63, 0xD0, /* Max_Gamma_11 */ -0x64, 0xE0, /* Max_Gamma_12 */ -0x65, 0xE7, /* Max_Gamma_13 */ -0x66, 0xEE, /* Max_Gamma_14 */ -0x67, 0xF7, /* Max_Gamma_15 */ -0x68, 0xFF, /* Max_Gamma_16 */ - -/* Initial edge, noise filter setting*/ -0xFF, 0xA0, /*Page mode */ -0xC0, 0x12, /*NSFTh1_Addr*/ -0xC1, 0x30, /*NSFTh2_Addr*/ -0xC2, 0x08, /*NSFTh3_Addr*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /*EDEOption_Addr*/ -0x31, 0x33, /*EDESlopeGain_Addr*/ -0x32, 0x50, /*EDELuAdpCtrl_Addr*/ -0x33, 0x00, /*EDEPreCoringPt_Addr*/ -0x34, 0x00, /*EDETransFuncXp1_Addr1*/ -0x35, 0x0B, /*EDETransFuncXp1_Addr0*/ -0x36, 0x01, /*EDETransFuncXp2_Addr1*/ -0x37, 0x80, /*EDETransFuncXp2_Addr0*/ -0x38, 0x09, /*EDETransFuncSl1_Addr*/ -0x39, 0x22, /*EDETransFuncSl2_Addr*/ -0x3A, 0x00, /*EDELuAdpLOffset_Addr*/ -0x3B, 0x30, /*EDELuAdpROffset_Addr*/ -0x3C, 0x08, /*EDERBThrd_Addr*/ -0x3D, 0x02, /*EDESmallOffset_Addr*/ - - -/* CCM Saturation Level*/ -0xFF, 0x85, /*Page mode */ -0x1A, 0x64, /* SUP Threshold */ -0x30, 0x40, /* MinSUP */ - -0xFF, 0xA0, /*Page mode */ -/* Lens Shading*/ -0x43, 0x80, /* RH7 rrhrhh*/ -0x44, 0x80, /* RV*/ -0x45, 0x80, /* RH */ -0x46, 0x80, /* RV*/ -0x47, 0x80, /* GH*/ -0x48, 0x80, /* GV*/ -0x49, 0x80, /* GH*/ -0x4A, 0x80, /* GV */ -0x4B, 0x80, /* BH*/ -0x4C, 0x80, /* BV*/ -0x4D, 0x80, /* BH*/ -0x4E, 0x80, /* BV */ -0x52, 0x90, /* GGain*/ -0x53, 0x20, /* GGain*/ -0x54, 0x00, /* GGain*/ - -/*Max Shading*/ -0xFF, 0x85, /*Page mode */ -0x32, 0xC0, -0x33, 0x30, -0x34, 0x00, -0x35, 0x90, -0x36, 0x20, -0x37, 0x00, - -/*Min Shading*/ -0x1c, 0xC0, -0x1d, 0x30, -0x1e, 0x00, -0x1f, 0x90, -0x20, 0x18, -0x21, 0x00, - -/* LineLength */ -0xFF, 0x87, /*Page mode */ -0xDC, 0x05, /* by Yong In Han 091511*/ -0xDD, 0xB0, /* by Yong In Han 091511*/ -0xd5, 0x00, /* Flip*/ -/***************************************************/ -/* SensorCon */ -/***************************************************/ -0xFF, 0xD0, /*Page mode */ -0x20, 0x0E, /* ABLK_Rsrv_Addr*/ -0x20, 0x0D, /* ABLK_Rsrv_Addr*/ - -/***************************************************/ -/* MIPI */ -/***************************************************/ -0xFF, 0xB0, /*Page mode */ -0x54, 0x02, /* MIPI PHY_HS_TX_CTRL*/ -0x38, 0x05, /* MIPI DPHY_CTRL_SET*/ - - -/* SXGA PR*/ -0xFF, 0x85, /*Page mode */ -0xB8, 0x0A, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr0*/ -0xB9, 0x00, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr1*/ -0xBC, 0x04, /* gPT_u8PR_Active_SXGA_DPHY_CLK_TIME_Addr3*/ -0xFF, 0x87, /*Page mode */ -0x0C, 0x00, /* start Y*/ -0x0D, 0x20, /* start Y */ -0x10, 0x03, /* end Y*/ -0x11, 0xE0, /* end Y */ - -/* Recoding */ -0xFF, 0x86, /*Page mode */ -0x38, 0x05, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr0*/ -0x39, 0x00, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr1*/ -0x3C, 0x04, /* gPT_u8PR_Active_720P_DPHY_CLK_TIME_Addr3*/ - -0xFF, 0x87, -0x23, 0x02, /*gPR_Active_720P_u8SensorCtrl_Addr */ -0x25, 0x01, /*gPR_Active_720P_u8PLL_P_Addr */ -0x26, 0x0F, /*gPR_Active_720P_u8PLL_M_Addr */ -0x27, 0x00, /*gPR_Active_720P_u8PLL_S_Addr */ -0x28, 0x00, /*gPR_Active_720P_u8PLL_Ctrl_Addr */ -0x29, 0x01, /*gPR_Active_720P_u8src_clk_sel_Addr */ -0x2A, 0x00, /*gPR_Active_720P_u8output_pad_status_Addr */ -0x2B, 0x3F, /*gPR_Active_720P_u8ablk_ctrl_10_Addr */ -0x2C, 0xFF, /*gPR_Active_720P_u8BayerFunc_Addr */ -0x2D, 0xFF, /*gPR_Active_720P_u8RgbYcFunc_Addr */ -0x2E, 0x00, /*gPR_Active_720P_u8ISPMode_Addr */ -0x2F, 0x02, /*gPR_Active_720P_u8SCLCtrl_Addr */ -0x30, 0x01, /*gPR_Active_720P_u8SCLHorScale_Addr0 */ -0x31, 0xFF, /*gPR_Active_720P_u8SCLHorScale_Addr1 */ -0x32, 0x03, /*gPR_Active_720P_u8SCLVerScale_Addr0 */ -0x33, 0xFF, /*gPR_Active_720P_u8SCLVerScale_Addr1 */ -0x34, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr0 */ -0x35, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr1 */ -0x36, 0x00, /*gPR_Active_720P_u8SCLCropStartY_Addr0 */ -0x37, 0x10, /*gPR_Active_720P_u8SCLCropStartY_Addr1 */ -0x38, 0x02, /*gPR_Active_720P_u8SCLCropEndX_Addr0 */ -0x39, 0x80, /*gPR_Active_720P_u8SCLCropEndX_Addr1 */ -0x3A, 0x01, /*gPR_Active_720P_u8SCLCropEndY_Addr0 */ -0x3B, 0xF0, /*gPR_Active_720P_u8SCLCropEndY_Addr1 */ -0x3C, 0x01, /*gPR_Active_720P_u8OutForm_Addr */ -0x3D, 0x0C, /*gPR_Active_720P_u8OutCtrl_Addr */ -0x3E, 0x04, /*gPR_Active_720P_u8AEWinStartX_Addr */ -0x3F, 0x04, /*gPR_Active_720P_u8AEWinStartY_Addr */ -0x40, 0x66, /*gPR_Active_720P_u8MergedWinWidth_Addr */ -0x41, 0x5E, /*gPR_Active_720P_u8MergedWinHeight_Addr */ -0x42, 0x04, /*gPR_Active_720P_u8AEHistWinAx_Addr */ -0x43, 0x04, /*gPR_Active_720P_u8AEHistWinAy_Addr */ -0x44, 0x98, /*gPR_Active_720P_u8AEHistWinBx_Addr */ -0x45, 0x78, /*gPR_Active_720P_u8AEHistWinBy_Addr */ -0x46, 0x22, /*gPR_Active_720P_u8AWBTrim_Addr */ -0x47, 0x28, /*gPR_Active_720P_u8AWBCTWinAx_Addr */ -0x48, 0x20, /*gPR_Active_720P_u8AWBCTWinAy_Addr */ -0x49, 0x78, /*gPR_Active_720P_u8AWBCTWinBx_Addr */ -0x4A, 0x60, /*gPR_Active_720P_u8AWBCTWinBy_Addr */ -0x4B, 0x03, /*gPR_Active_720P_u16AFCFrameLength_0 */ -0x4C, 0x00, /*gPR_Active_720P_u16AFCFrameLength_1 */ - -/* VGA PR */ -0xFF, 0x86, /*Page mode */ -0x2F, 0x05, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr0*/ -0x30, 0x00, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr1*/ -0x33, 0x04, /* gPT_u8PR_Active_VGA_DPHY_CLK_TIME_Addr3*/ - -0xFF, 0x87, /*Page mode */ -0x4D, 0x00, /*gPR_Active_VGA_u8SensorCtrl_Addr*/ -0x4E, 0x72, /*gPR_Active_VGA_u8SensorMode_Addr*/ -0x4F, 0x01, /*gPR_Active_VGA_u8PLL_P_Addr*/ -0x50, 0x0F, /*gPR_Active_VGA_u8PLL_M_Addr*/ -0x51, 0x00, /*gPR_Active_VGA_u8PLL_S_Addr*/ -0x52, 0x00, /*gPR_Active_VGA_u8PLL_Ctrl_Addr*/ -0x53, 0x01, /*gPR_Active_VGA_u8src_clk_sel_Addr*/ -0x54, 0x00, /*gPR_Active_VGA_u8output_pad_status_Addr*/ -0x55, 0x3F, /*gPR_Active_VGA_u8ablk_ctrl_10_Addr*/ -0x56, 0xFF, /*gPR_Active_VGA_u8BayerFunc_Addr*/ -0x57, 0xFF, /*gPR_Active_VGA_u8RgbYcFunc_Addr*/ -0x58, 0x00, /*gPR_Active_VGA_u8ISPMode_Addr*/ -0x59, 0x02, /*gPR_Active_VGA_u8SCLCtrl_Addr*/ -0x5A, 0x01, /*gPR_Active_VGA_u8SCLHorScale_Addr0*/ -0x5B, 0xFF, /*gPR_Active_VGA_u8SCLHorScale_Addr1*/ -0x5C, 0x01, /*gPR_Active_VGA_u8SCLVerScale_Addr0*/ -0x5D, 0xFF, /*gPR_Active_VGA_u8SCLVerScale_Addr1*/ -0x5E, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr0*/ -0x5F, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr1*/ -0x60, 0x00, /*gPR_Active_VGA_u8SCLCropStartY_Addr0*/ -0x61, 0x20, /*gPR_Active_VGA_u8SCLCropStartY_Addr1*/ -0x62, 0x05, /*gPR_Active_VGA_u8SCLCropEndX_Addr0*/ -0x63, 0x00, /*gPR_Active_VGA_u8SCLCropEndX_Addr1*/ -0x64, 0x03, /*gPR_Active_VGA_u8SCLCropEndY_Addr0*/ -0x65, 0xE0, /*gPR_Active_VGA_u8SCLCropEndY_Addr1*/ - -0xFF, 0xd1, /*Page mode */ -0x07, 0x00, /* power off mask clear*/ -0x0b, 0x00, /* clock off mask clear*/ -0xFF, 0xC0, /*Page mode */ -0x10, 0x41, - -/* Self-Cam END of Initial */ -}; - -/* Set-data based on SKT VT standard ,when using 3G network*/ -/* VGA 8fps -*/ -static const u8 db8131m_vt_common_1[] = { -/***************************************************/ -/* Device : DB8131M fixed 8Fps */ -/* MIPI Interface for Noncontious Clock */ -/***************************************************/ -/***************************************************/ -/* Command */ -/***************************************************/ -0xFF, 0xC0, /*Page mode*/ -0x10, 0x01, -}; -/*wait 150*/ - -static const u8 db8131m_vt_common_2[] = { -/***************************************************/ -/* Format */ -/***************************************************/ -0xFF, 0xA1, /*Page mode */ -0x70, 0x01, -0x71, 0x0D, - -/***************************************************/ -/* SensorCon */ -/***************************************************/ -0xFF, 0xD0, /*Page mode */ -0x0F, 0x0B, /*ABLK_Ctrl_1_Addr*/ -0x13, 0x00, /*Gain_Addr*/ -0x15, 0x01, /*IVREFT_REFB_Addr*/ -0x20, 0x0E, /*ABLK_Rsrv_Addr*/ -0x23, 0x01, /*IVREFT2_REFB2_Addr*/ -0x24, 0x01, /*IPPG_IVCM2_Addr*/ -0x39, 0x70, /*RiseSx_CDS_1_L_Addr*/ -0x51, 0x19, /*Fallcreset_1_L_Addr*/ -0x83, 0x2D, /*RiseTran_Sig_Even_L_Addr*/ -0x85, 0x2F, /*FallTran_Sig_Even_L_Addr*/ -0x87, 0x2D, /*RiseTran_Sig_Odd_L_Addr*/ -0x89, 0x2F, /*FallTran_Sig_Odd_L_Addr*/ -0x8B, 0x27, /*RiseCNT_EN_1_L_Addr*/ -0x8D, 0x6c, /*FallCNT_EN_1_L_Addr*/ -0xD7, 0x80, /*ABLK_Ctrl_12_Addr*/ -0xDB, 0xA2, /*FallScanTx15_1_L_Addr*/ -0xED, 0x01, /*PLL_P_Addr*/ -0xEE, 0x0F, /*PLL_M_Addr*/ -0xEF, 0x00, /*PLL_S_Addr*/ -0xF9, 0x00, /*ABLK_Ctrl_8*/ -0xF8, 0x00, /*Vblank Sleep Mode enable*/ -0xFB, 0x90, /*PostADC_Gain_Addr*/ - -/***************************************************/ -/* Analog ADF */ -/***************************************************/ -0xFF, 0x85, /*Page mode */ -0x89, 0x93, /*gAdf_u8APThreshold*/ -0x8A, 0x0C, /*u8APClmpThreshold*/ -0x8C, 0x07, /*gAdf_u8APMinVal_ThrClampH*/ -0x8D, 0x40, /*gAdf_u8APMinVal_ThrClampL*/ -0x8E, 0x03, /*gAdf_u8APMinVal_DOFFSET*/ -0x8F, 0x14, /*gAdf_u8APMinVal_AMP2_1_SDM*/ -0x91, 0x1A, /*gAdf_u8APMinVal_AMP4_3_SDM*/ -0x92, 0x0F, /*gAdf_u8APMinVal_FallIntTx15*/ -0x93, 0x47, /*gAdf_u8APMinVal_CDSxRange_CtrlPre*/ -0x95, 0x18, /*gAdf_u8APMinVal_REFB_IVCM*/ -0x96, 0x38, /*gAdf_u8APMinVal_ref_os_PB*/ -0x97, 0x0D, /*gAdf_u8APMinVal_NTx_Range*/ -0x98, 0x0D, /*gAdf_u8APMaxVal_Clmp_rst*/ -0x99, 0x06, /*gAdf_u8APMaxVal_ThrClampH*/ -0x9A, 0x9F, /*gAdf_u8APMaxVal_ThrClampL*/ -0x9B, 0x02, /*gAdf_u8APMaxVal_DOFFSET*/ -0x9C, 0x1C, /*gAdf_u8APMaxVal_AMP2_1_SDM*/ -0x9E, 0x11, /*gAdf_u8APMaxVal_AMP4_3_SDM*/ -0x9F, 0x5D, /*gAdf_u8APMaxVal_FallIntTx15*/ -0xA0, 0x78, /*gAdf_u8APMaxVal_CDSxRange_CtrlPre*/ -0xA2, 0x18, /*gAdf_u8APMaxVal_REFB_IVCM*/ -0xA3, 0x40, /*gAdf_u8APMaxVal_ref_os_PB*/ -0xA4, 0x0B, /*gAdf_u8APMaxVal_NTx_Range*/ - -0xFF, 0x86, /*Page mode */ -0x15, 0x00, /*gPT_u8Adf_APThrHys*/ -0x16, 0xF7, /*gPT_u8Adf_APFallIntTxThrLevel*/ -0x17, 0x13, /*gPT_u8Adf_APMinVal_BP2_1_SDM*/ -0x18, 0x13, /*gPT_u8Adf_APMidVal_BP2_1_SDM*/ -0x19, 0x1C, /*gPT_u8Adf_APMaxVal_BP2_1_SDM*/ -0x1A, 0x06, /*gPT_u8Adf_APMidVal_ThrClampH*/ -0x1B, 0xF0, /*gPT_u8Adf_APMidVal_ThrClampL*/ -0x1C, 0x01, /*gPT_u8Adf_APMidVal_DOFFSET*/ -0x1D, 0x14, /*gPT_u8Adf_APMidVal_AMP2_1_SDM*/ -0x1F, 0x31, /*gPT_u8Adf_APMidVal_AMP4_3_SDM*/ -0x20, 0x68, /*gPT_u8Adf_APMidVal_CDSxRange_CtrlPre*/ -0x22, 0x18, /*gPT_u8Adf_APMidVal_REFB_IVCM*/ -0x23, 0x38, /*gPT_u8Adf_APMidVal_ref_os_PB*/ -0x24, 0x0F, /*gPT_u8Adf_APMidVal_NTx_Range*/ -0x25, 0x77, /*gPT_u8Adf_APVal_EnSiSoSht_EnSm*/ - -0xFF, 0x87, /*Page mode */ -0xEA, 0x41, - -0xFF, 0xD0, /*Page mode */ -0x20, 0x0D, /*ABLK_Rsrv_Addr*/ - -0xFF, 0x83, /*Page mode */ -0x63, 0x28, /*Again Table*/ -0x64, 0x10, /*Again Table*/ -0x65, 0xA8, /*Again Table*/ -0x66, 0x50, /*Again Table*/ -0x67, 0x28, /*Again Table*/ -0x68, 0x14, /*Again Table*/ - - -/***************************************************/ -/* AE */ -/***************************************************/ -0xFF, 0x82, /*Page mode */ -0x91, 0x02, /* AeMode*/ -0x95, 0x88, /* AE weight*/ -0x96, 0x88, -0x97, 0xF8, -0x98, 0x8F, -0x99, 0xF8, -0x9A, 0x8F, -0x9B, 0x88, -0x9C, 0x88, -0xA9, 0x40, /* OTarget*/ -0xAA, 0x40, /* ITarget*/ -0x9D, 0x66, /* AE Speed*/ -0x9F, 0x06, /* AE HoldBnd*/ -0xA8, 0x40, /* STarget*/ -0xB9, 0x04, /* RGain*/ -0xBB, 0x04, /* GGain*/ -0xBD, 0x04, /* BGain*/ -0xC5, 0x02, /* PeakMvStep*/ -0xC6, 0x38, /* PeakTgMin*/ -0xC7, 0x24, /* PeakRatioTh1*/ -0xC8, 0x10, /* PeakRatioTh0*/ -0xC9, 0x05, /* PeakLuTh*/ -0xD5, 0x60, /* LuxGainTB_2*/ -0xFF, 0x83, /*Page mode */ -0x2F, 0x04, /* TimeNum0*/ -0x30, 0x05, /* TimeNum1*/ -0x4F, 0x05, /* FrameOffset*/ -0xFF, 0x82, /*Page mode */ -0xA1, 0x0A, /* AnalogGainMax*/ -0xF3, 0x09, /* SCLK*/ -0xF4, 0x60, -0xF9, 0x00, /* GainMax*/ -0xFA, 0xC8, /* GainMax*/ -0xFB, 0x62, /* Gain3Lut*/ -0xFC, 0x39, /* Gain2Lut*/ -0xFD, 0x28, /* Gain1Lut*/ -0xFE, 0x12, /* GainMin*/ -0xFF, 0x83, /*Page mode */ -0x03, 0x0F, /* TimeMax60Hz : 8fps*/ -0x04, 0x0A, /* Time3Lux60Hz : 12fps*/ -0x05, 0x04, /* Time2Lut60Hz : 24fps*/ -0x06, 0x04, /* Time1Lut60Hz : 24fps*/ -0xFF, 0x82, /*Page mode */ -0xD3, 0x12, /* LuxTBGainStep0 */ -0xD4, 0x36, /* LuxTBGainStep1 */ -0xD5, 0x60, /* LuxTBGainStep2*/ -0xD6, 0x01, /* LuxTBTimeStep0H*/ -0xD7, 0x00, /* LuxTBTimeStep0L*/ -0xD8, 0x01, /* LuxTBTimeStep1H*/ -0xD9, 0xC0, /* LuxTBTimeStep1L*/ -0xDA, 0x06, /* LuxTBTimeStep2H*/ -0xDB, 0x00, /* LuxTBTimeStep2L*/ -0xFF, 0x83, /*Page mode */ -0x0B, 0x08, -0x0C, 0x0C, /* Frame Rate*/ -0xFF, 0x82, /*Page mode */ -0x92, 0x5D, - -/***************************************************/ -/* AWB */ -/***************************************************/ -0xFF, 0x83, /*Page mode */ -0x79, 0x83, /* AWB SKIN ON*/ -0x86, 0x07, /* gAWB_u16MinGrayCnt_rw_0*/ -0x87, 0x00, /* gAWB_u16MinGrayCnt_rw_1*/ -0x90, 0x05, /* gAWB_u16FinalRGain_ro_0*/ -0x94, 0x05, /* gAWB_u16FinalBGain_ro_0*/ -0x98, 0xD4, /* SkinWinCntTh*/ -0xA2, 0x28, /* SkinYTh*/ -0xA3, 0x00, /* SkinHoldHitCnt*/ -0xA4, 0x0F, /* SkinHoldHitCnt*/ -0xAD, 0x65, /* u8SkinTop2*/ -0xAE, 0x80, /* gAwb_u8SkinTop2LS1Ratio_rw 5zone */ -0xAF, 0x20, /* gAwb_u8SkinTop2LS2Ratio_rw 6zone */ -0xB4, 0x10, /* u8SkinTop2LSHys_rw */ -0xB5, 0x54, /* gAwb_u8SkinLTx */ -0xB6, 0xbd, /* gAwb_u8SkinLTy */ -0xB7, 0x74, /* gAwb_u8SkinRBx */ -0xB8, 0x9d, /* gAwb_u8SkinRBy */ -0xBA, 0x4F, /* UniCThrY_rw */ -0xBF, 0x0C, /* u16UniCGrayCntThr_rw_0 */ -0xC0, 0x80, /* u16UniCGrayCntThr_rw_1 */ -0xFF, 0x87, /*Page mode */ -0xC9, 0x22, /* gUR_u8AWBTrim_Addr */ -0xFF, 0x84, /*Page mode */ -0x49, 0x02, /* Threshold_indoor */ -0x4A, 0x00, -0x4B, 0x03, /* Threshold_outdoor */ -0x4C, 0x80, -0xFF, 0x83, /*Page mode */ -0xCB, 0x03, /* R MinGain [Default 0X20] A Spec Pass */ -0xCC, 0xC0, /* R MinGain [Default 0X20] A Spec Pass */ -0x82, 0x00, /* lockratio*/ -0xFF, 0x84, /*Page mode */ -0x3D, 0x00, /* gAwb_u32LuxConst1_rw_0*/ -0x3E, 0x00, /* gAwb_u32LuxConst1_rw_1*/ -0x3F, 0x06, /* gAwb_u32LuxConst1_rw_2*/ -0x40, 0x20, /* gAwb_u32LuxConst1_rw_3*/ -0x41, 0x07, /* gAwb_u32LuxConst2_rw_0*/ -0x42, 0x53, /* gAwb_u32LuxConst2_rw_1*/ -0x43, 0x00, /* gAwb_u32LuxConst2_rw_2*/ -0x44, 0x00, /* gAwb_u32LuxConst2_rw_3*/ -0x55, 0x03, /* gAwb_u8Weight_Gen_rw_0 */ -0x56, 0x10, /* gAwb_u8Weight_Gen_rw_1 */ -0x57, 0x14, /* gAwb_u8Weight_Gen_rw_2 */ -0x58, 0x07, /* gAwb_u8Weight_Gen_rw_3 */ -0x59, 0x04, /* gAwb_u8Weight_Gen_rw_4 */ -0x5A, 0x03, /* gAwb_u8Weight_Gen_rw_5 */ -0x5B, 0x03, /* gAwb_u8Weight_Gen_rw_6 */ -0x5C, 0x15, /* gAwb_u8Weight_Gen_rw_7 */ -0x5D, 0x01, /* gAwb_u8Weight_Ind_rw_0 */ -0x5E, 0x0F, /* gAwb_u8Weight_Ind_rw_1 */ -0x5F, 0x07, /* gAwb_u8Weight_Ind_rw_2 */ -0x60, 0x14, /* gAwb_u8Weight_Ind_rw_3 */ -0x61, 0x14, /* gAwb_u8Weight_Ind_rw_4 */ -0x62, 0x12, /* gAwb_u8Weight_Ind_rw_5 */ -0x63, 0x11, /* gAwb_u8Weight_Ind_rw_6 */ -0x64, 0x14, /* gAwb_u8Weight_Ind_rw_7 */ -0x65, 0x03, /* gAwb_u8Weight_Outd_rw_0*/ -0x66, 0x05, /* gAwb_u8Weight_Outd_rw_1*/ -0x67, 0x15, /* gAwb_u8Weight_Outd_rw_2*/ -0x68, 0x04, /* gAwb_u8Weight_Outd_rw_3*/ -0x69, 0x01, /* gAwb_u8Weight_Outd_rw_4*/ -0x6A, 0x02, /* gAwb_u8Weight_Outd_rw_5*/ -0x6B, 0x03, /* gAwb_u8Weight_Outd_rw_6*/ -0x6C, 0x15, /* gAwb_u8Weight_Outd_rw_6*/ -0xFF, 0x85, /*Page mode */ -0xE2, 0x0C, /* gPT_u8Awb_UnicolorZone_rw */ -0xFF, 0x83, /*Page mode */ -0xCD, 0x06, /*Max Rgain*/ -0xCE, 0x80, -0xD1, 0x06, /*Max BGain*/ -0xd2, 0x80, - -/***************************************************/ -/* AWB STE */ -/***************************************************/ -0xFF, 0xA1, /*Page mode */ -/* Flash */ -0xA0, 0x5c, /*AWBZone0LTx*/ -0xA1, 0x7a, /*AWBZone0LTy*/ -0xA2, 0x69, /*AWBZone0RBx*/ -0xA3, 0x6f, /*AWBZone0RBy*/ -/* cloudy */ -0xA4, 0x73, /*AWBZone1LTx*/ -0xA5, 0x55, /*AWBZone1LTy*/ -0xA6, 0x8C, /*AWBZone1RBx*/ -0xA7, 0x30, /*AWBZone1RBy */ -/* Daylight */ -0xA8, 0x69, /*AWBZone2LTx*/ -0xA9, 0x69, /*AWBZone2LTy*/ -0xAA, 0x83, /*AWBZone2RBx*/ -0xAB, 0x52, /*AWBZone2RBy */ -/* Fluorescent */ -0xAC, 0x57, /*AWBZone3LTx*/ -0xAD, 0x6e, /*AWBZone3LTy*/ -0xAE, 0x6f, /*AWBZone3RBx*/ -0xAF, 0x59, /*AWBZone3RBy*/ - -/*CWF */ -0xB0, 0x50, /*AWBZone4LTx*/ -0xB1, 0x74, /*AWBZone4LTy*/ -0xB2, 0x65, /*AWBZone4RBx*/ -0xB3, 0x5d, /*AWBZone4RBy*/ -/*TL84 */ -0xB4, 0x53, /*AWBZone5LTx*/ -0xB5, 0x7f, /*AWBZone5LTy*/ -0xB6, 0x62, /*AWBZone5RBx*/ -0xB7, 0x75, /*AWBZone5RBy */ -/*A */ -0xB8, 0x4a, /*AWBZone6LTx*/ -0xB9, 0x87, /*AWBZone6LTy*/ -0xBA, 0x59, /*AWBZone6RBx*/ -0xBB, 0x78, /*AWBZone6RBy*/ -/*Horizon */ -0xBC, 0x41, /*AWBZone7LTx*/ -0xBD, 0x91, /*AWBZone7LTy*/ -0xBE, 0x4b, /*AWBZone7RBx*/ -0xBF, 0x89, /*AWBZone7RBy*/ -/*Skin */ -0xC0, 0x5b, /*AWBZone8LTx*/ -0xC1, 0x85, /*AWBZone8LTy*/ -0xC2, 0x60, /*AWBZone8RBx*/ -0xC3, 0x7b, /*AWBZone8RBy*/ - -/***************************************************/ -/* UR */ -/***************************************************/ -0xFF, 0x85, /*Page mode */ -0x06, 0x05, -0xFF, 0x86, /*Page mode */ -0x14, 0x1E, /* CCM sum 1*/ -0xFF, 0x85, /*Page mode */ -0x86, 0x42, /* 42 saturation level*/ -0x07, 0x00, /* sup hysteresis*/ - -/*DAY light */ -0xFF, 0x83, /*Page mode */ -0xEA, 0x00, /*gAwb_s16AdapCCMTbl_0*/ -0xEB, 0x53, /*gAwb_s16AdapCCMTbl_1*/ -0xEC, 0xFF, /*gAwb_s16AdapCCMTbl_2*/ -0xED, 0xE1, /*gAwb_s16AdapCCMTbl_3*/ -0xEE, 0x00, /*gAwb_s16AdapCCMTbl_4*/ -0xEF, 0x05, /*gAwb_s16AdapCCMTbl_5*/ -0xF0, 0xFF, /*gAwb_s16AdapCCMTbl_6*/ -0xF1, 0xF3, /*gAwb_s16AdapCCMTbl_7*/ -0xF2, 0x00, /*gAwb_s16AdapCCMTbl_8*/ -0xF3, 0x4B, /*gAwb_s16AdapCCMTbl_9*/ -0xF4, 0xFF, /*gAwb_s16AdapCCMTbl_10*/ -0xF5, 0xFA, /*gAwb_s16AdapCCMTbl_11*/ -0xF6, 0xFF, /*gAwb_s16AdapCCMTbl_12*/ -0xF7, 0xFa, /*gAwb_s16AdapCCMTbl_13*/ -0xF8, 0xFF, /*gAwb_s16AdapCCMTbl_14*/ -0xF9, 0xC3, /*gAwb_s16AdapCCMTbl_15*/ -0xFA, 0x00, /*gAwb_s16AdapCCMTbl_16*/ -0xFB, 0x80, /*gAwb_s16AdapCCMTbl_17*/ - -/*CWF lgiht */ -0xFF, 0x83, /*Page mode */ -0xFC, 0x00, /* gAwb_s16AdapCCMTbl_18 */ -0xFD, 0x68, /* gAwb_s16AdapCCMTbl_19 */ -0xFF, 0x85, /*Page mode */ -0xE0, 0xFF, /* gAwb_s16AdapCCMTbl_20 */ -0xE1, 0xde, /* gAwb_s16AdapCCMTbl_21 */ -0xFF, 0x84, /*Page mode */ -0x00, 0xff, /* gAwb_s16AdapCCMTbl_22 */ -0x01, 0xfa, /* gAwb_s16AdapCCMTbl_23 */ -0x02, 0xFF, /* gAwb_s16AdapCCMTbl_24 */ -0x03, 0xf0, /* gAwb_s16AdapCCMTbl_25 */ -0x04, 0x00, /* gAwb_s16AdapCCMTbl_26 */ -0x05, 0x52, /* gAwb_s16AdapCCMTbl_27 */ -0x06, 0xFF, /* gAwb_s16AdapCCMTbl_28 */ -0x07, 0xFa, /* gAwb_s16AdapCCMTbl_29 */ -0x08, 0x00, /* gAwb_s16AdapCCMTbl_30 */ -0x09, 0x00, /* gAwb_s16AdapCCMTbl_31 */ -0x0A, 0xFF, /* gAwb_s16AdapCCMTbl_32 */ -0x0B, 0xdb, /* gAwb_s16AdapCCMTbl_33 */ -0x0C, 0x00, /* gAwb_s16AdapCCMTbl_34 */ -0x0D, 0x68, /* gAwb_s16AdapCCMTbl_35 */ - -/*A light */ - -0x0E, 0x00, /* gAwb_s16AdapCCMTbl_36 */ -0x0F, 0x6d, /* gAwb_s16AdapCCMTbl_37 */ -0x10, 0xFF, /* gAwb_s16AdapCCMTbl_38 */ -0x11, 0xd5, /* gAwb_s16AdapCCMTbl_39 */ -0x12, 0xff, /* gAwb_s16AdapCCMTbl_40 */ -0x13, 0xfe, /* gAwb_s16AdapCCMTbl_41 */ -0x14, 0xFF, /* gAwb_s16AdapCCMTbl_42 */ -0x15, 0xf4, /* gAwb_s16AdapCCMTbl_43 */ -0x16, 0x00, /* gAwb_s16AdapCCMTbl_44 */ -0x17, 0x5a, /* gAwb_s16AdapCCMTbl_45 */ -0x18, 0xff, /* gAwb_s16AdapCCMTbl_46 */ -0x19, 0xef, /* gAwb_s16AdapCCMTbl_47 */ -0x1A, 0xff, /* gAwb_s16AdapCCMTbl_48 */ -0x1B, 0xfa, /* gAwb_s16AdapCCMTbl_49 */ -0x1C, 0xFF, /* gAwb_s16AdapCCMTbl_50 */ -0x1D, 0xbe, /* gAwb_s16AdapCCMTbl_51 */ -0x1E, 0x00, /* gAwb_s16AdapCCMTbl_52 */ -0x1F, 0x86, /* gAwb_s16AdapCCMTbl_53 */ - - -/***************************************************/ -/* ADF */ -/***************************************************/ - -/* ISP setting*/ -0xFF, 0xA0, /*Page mode */ -0x10, 0x80, /* BLC: ABLC db*/ -0x60, 0x73, /* CDC: Dark CDC ON */ -0x61, 0x1F, /* Six CDC_Edge En, Slash EN*/ -0x69, 0x0C, /* Slash direction Line threshold*/ -0x6A, 0x60, /* Slash direction Pixel threshold*/ -0xC2, 0x04, /* NSF: directional smoothing*/ -0xD0, 0x51, /* DEM: pattern detection*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /* EDE: Luminane adaptation on*/ -0x32, 0x50, /* EDE: Adaptation slope */ -0x34, 0x00, /* EDE: x1 point */ -0x35, 0x0B, /* EDE: x1 point */ -0x36, 0x01, /* EDE: x2 point */ -0x37, 0x80, /* EDE: x2 point */ -0x3A, 0x00, /* EDE: Adaptation left margin*/ -0x3B, 0x30, /* EDE: Adaptation right margin*/ -0x3C, 0x08, /* EDE: rgb edge threshol*/ - -/* Adaptive Setting*/ -0xFF, 0x85, /*Page mode */ -/* LSC*/ -0x0F, 0x43, /* LVLSC lux level threshold*/ -0x10, 0x43, /* LSLSC Light source , threshold lux*/ - -/* BGT*/ -0x17, 0x30, /* BGT lux level threshold*/ -0x26, 0x20, /* MinVal */ -0x3c, 0x00, /* MaxVal */ - -/* CNT*/ -0x18, 0x43, /* CNT lux level threshold*/ -0x27, 0x00, /* MinVal */ -0x3d, 0x00, /* MaxVal */ - -/* NSF */ -0x12, 0xA5, /* NSF lux level threshold */ -0x22, 0x38, /* u8MinVal_NSF1*/ -0x23, 0x70, /* u8MinVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x12, 0x00, /* u8MinVal_NSF3*/ -0xFF, 0x85, /*Page mode */ -0x38, 0x12, /* u8MaxVal_NSF1*/ -0x39, 0x30, /* u8MaxVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x13, 0x08, /* u8MaxVal_NSF3*/ - -/* GDC*/ -0xFF, 0x85, /*Page mode */ -0x15, 0xF4, /* GDC lux level threshold */ -0x2D, 0x20, /* u8MinVal_GDC1*/ -0x2E, 0x30, /* u8MinVal_GDC2*/ -0x43, 0x40, /* u8MaxVal_GDC1*/ -0x44, 0x80, /* u8MaxVal_GDC2*/ - -/* ISP Edge*/ -0x04, 0xFB, /* EnEDE*/ -0x14, 0x54, /* u8ThrLevel_EDE*/ -0x28, 0x00, /* u8MinVal_EDE_CP*/ -0x29, 0x03, /* u8MinVal_EDE1*/ -0x2A, 0x20, /* u8MinVal_EDE2*/ -0x2B, 0x00, /* u8MinVal_EDE_OFS*/ -0x2C, 0x22, /* u8MinVal_SG*/ -0x3E, 0x00, /* u8MaxVal_EDE_CP*/ -0x3F, 0x09, /* u8MaxVal_EDE1*/ -0x40, 0x22, /* u8MaxVal_EDE2*/ -0x41, 0x02, /* u8MaxVal_EDE_OFS*/ -0x42, 0x33, /* u8MaxVal_SG*/ - -/* Gamma Adaptive*/ - -0x16, 0xA0, /* Gamma Threshold*/ -0x47, 0x00, /* Min_Gamma_0*/ -0x48, 0x03, /* Min_Gamma_1*/ -0x49, 0x10, /* Min_Gamma_2*/ -0x4A, 0x25, /* Min_Gamma_3*/ -0x4B, 0x3B, /* Min_Gamma_4*/ -0x4C, 0x4F, /* Min_Gamma_5*/ -0x4D, 0x6D, /* Min_Gamma_6*/ -0x4E, 0x86, /* Min_Gamma_7*/ -0x4F, 0x9B, /* Min_Gamma_8*/ -0x50, 0xAD, /* Min_Gamma_9*/ -0x51, 0xC2, /* Min_Gamma_10*/ -0x52, 0xD3, /* Min_Gamma_11*/ -0x53, 0xE1, /* Min_Gamma_12*/ -0x54, 0xE9, /* Min_Gamma_13*/ -0x55, 0xF2, /* Min_Gamma_14*/ -0x56, 0xFA, /* Min_Gamma_15*/ -0x57, 0xFF, /* Min_Gamma_16*/ -0x58, 0x00, /* Max_Gamma_0 */ -0x59, 0x06, /* Max_Gamma_1 */ -0x5a, 0x14, /* Max_Gamma_2 */ -0x5b, 0x30, /* Max_Gamma_3 */ -0x5c, 0x4A, /* Max_Gamma_4 */ -0x5d, 0x5D, /* Max_Gamma_5 */ -0x5e, 0x75, /* Max_Gamma_6 */ -0x5f, 0x89, /* Max_Gamma_7 */ -0x60, 0x9A, /* Max_Gamma_8 */ -0x61, 0xA7, /* Max_Gamma_9 */ -0x62, 0xBC, /* Max_Gamma_10 */ -0x63, 0xD0, /* Max_Gamma_11 */ -0x64, 0xE0, /* Max_Gamma_12 */ -0x65, 0xE7, /* Max_Gamma_13 */ -0x66, 0xEE, /* Max_Gamma_14 */ -0x67, 0xF7, /* Max_Gamma_15 */ -0x68, 0xFF, /* Max_Gamma_16 */ - -/* Initial edge, noise filter setting*/ -0xFF, 0xA0, /*Page mode */ -0xC0, 0x12, /*NSFTh1_Addr*/ -0xC1, 0x30, /*NSFTh2_Addr*/ -0xC2, 0x08, /*NSFTh3_Addr*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /*EDEOption_Addr*/ -0x31, 0x33, /*EDESlopeGain_Addr*/ -0x32, 0x50, /*EDELuAdpCtrl_Addr*/ -0x33, 0x00, /*EDEPreCoringPt_Addr*/ -0x34, 0x00, /*EDETransFuncXp1_Addr1*/ -0x35, 0x0B, /*EDETransFuncXp1_Addr0*/ -0x36, 0x01, /*EDETransFuncXp2_Addr1*/ -0x37, 0x80, /*EDETransFuncXp2_Addr0*/ -0x38, 0x09, /*EDETransFuncSl1_Addr*/ -0x39, 0x22, /*EDETransFuncSl2_Addr*/ -0x3A, 0x00, /*EDELuAdpLOffset_Addr*/ -0x3B, 0x30, /*EDELuAdpROffset_Addr*/ -0x3C, 0x08, /*EDERBThrd_Addr*/ -0x3D, 0x02, /*EDESmallOffset_Addr*/ - -/* CCM Saturation Level*/ -0xFF, 0x85, /*Page mode */ -0x1A, 0x64, /* SUP Threshold */ -0x30, 0x40, /* MinSUP */ - -0xFF, 0xA0, /*Page mode */ -/* Lens Shading*/ -0x43, 0x80, /* RH7 rrhrhh*/ -0x44, 0x80, /* RV*/ -0x45, 0x80, /* RH */ -0x46, 0x80, /* RV*/ -0x47, 0x80, /* GH*/ -0x48, 0x80, /* GV*/ -0x49, 0x80, /* GH*/ -0x4A, 0x80, /* GV */ -0x4B, 0x80, /* BH*/ -0x4C, 0x80, /* BV*/ -0x4D, 0x80, /* BH*/ -0x4E, 0x80, /* BV */ -0x52, 0x90, /* GGain*/ -0x53, 0x20, /* GGain*/ -0x54, 0x00, /* GGain*/ - -/*Max Shading*/ -0xFF, 0x85, /*Page mode */ -0x32, 0xC0, -0x33, 0x30, -0x34, 0x00, -0x35, 0x90, -0x36, 0x20, -0x37, 0x00, - -/*Min Shading*/ -0x1c, 0xC0, -0x1d, 0x30, -0x1e, 0x00, -0x1f, 0x90, -0x20, 0x18, -0x21, 0x00, - -/* LineLength */ -0xFF, 0x87, /*Page mode */ -0xDC, 0x05, /* by Yong In Han 091511*/ -0xDD, 0xB0, /* by Yong In Han 091511*/ -0xd5, 0x00, /* Flip*/ -/***************************************************/ -/* SensorCon */ -/***************************************************/ -0xFF, 0xD0, /*Page mode */ -0x20, 0x0E, /* ABLK_Rsrv_Addr*/ -0x20, 0x0D, /* ABLK_Rsrv_Addr*/ - -/***************************************************/ -/* MIPI */ -/***************************************************/ -0xFF, 0xB0, /*Page mode */ -0x54, 0x02, /* MIPI PHY_HS_TX_CTRL*/ -0x38, 0x05, /* MIPI DPHY_CTRL_SET*/ - - -/* SXGA PR*/ -0xFF, 0x85, /*Page mode */ -0xB8, 0x0A, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr0*/ -0xB9, 0x00, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr1*/ -0xBC, 0x04, /* gPT_u8PR_Active_SXGA_DPHY_CLK_TIME_Addr3*/ -0xFF, 0x87, /*Page mode */ -0x0C, 0x00, /* start Y*/ -0x0D, 0x20, /* start Y */ -0x10, 0x03, /* end Y*/ -0x11, 0xE0, /* end Y */ - -/* Recoding */ -0xFF, 0x86, /*Page mode */ -0x38, 0x05, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr0*/ -0x39, 0x00, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr1*/ -0x3C, 0x04, /* gPT_u8PR_Active_720P_DPHY_CLK_TIME_Addr3*/ - -0xFF, 0x87, -0x23, 0x02, /*gPR_Active_720P_u8SensorCtrl_Addr */ -0x25, 0x01, /*gPR_Active_720P_u8PLL_P_Addr */ -0x26, 0x0F, /*gPR_Active_720P_u8PLL_M_Addr */ -0x27, 0x00, /*gPR_Active_720P_u8PLL_S_Addr */ -0x28, 0x00, /*gPR_Active_720P_u8PLL_Ctrl_Addr */ -0x29, 0x01, /*gPR_Active_720P_u8src_clk_sel_Addr */ -0x2A, 0x00, /*gPR_Active_720P_u8output_pad_status_Addr */ -0x2B, 0x3F, /*gPR_Active_720P_u8ablk_ctrl_10_Addr */ -0x2C, 0xFF, /*gPR_Active_720P_u8BayerFunc_Addr */ -0x2D, 0xFF, /*gPR_Active_720P_u8RgbYcFunc_Addr */ -0x2E, 0x00, /*gPR_Active_720P_u8ISPMode_Addr */ -0x2F, 0x02, /*gPR_Active_720P_u8SCLCtrl_Addr */ -0x30, 0x01, /*gPR_Active_720P_u8SCLHorScale_Addr0 */ -0x31, 0xFF, /*gPR_Active_720P_u8SCLHorScale_Addr1 */ -0x32, 0x03, /*gPR_Active_720P_u8SCLVerScale_Addr0 */ -0x33, 0xFF, /*gPR_Active_720P_u8SCLVerScale_Addr1 */ -0x34, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr0 */ -0x35, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr1 */ -0x36, 0x00, /*gPR_Active_720P_u8SCLCropStartY_Addr0 */ -0x37, 0x10, /*gPR_Active_720P_u8SCLCropStartY_Addr1 */ -0x38, 0x02, /*gPR_Active_720P_u8SCLCropEndX_Addr0 */ -0x39, 0x80, /*gPR_Active_720P_u8SCLCropEndX_Addr1 */ -0x3A, 0x01, /*gPR_Active_720P_u8SCLCropEndY_Addr0 */ -0x3B, 0xF0, /*gPR_Active_720P_u8SCLCropEndY_Addr1 */ -0x3C, 0x01, /*gPR_Active_720P_u8OutForm_Addr */ -0x3D, 0x0C, /*gPR_Active_720P_u8OutCtrl_Addr */ -0x3E, 0x04, /*gPR_Active_720P_u8AEWinStartX_Addr */ -0x3F, 0x04, /*gPR_Active_720P_u8AEWinStartY_Addr */ -0x40, 0x66, /*gPR_Active_720P_u8MergedWinWidth_Addr */ -0x41, 0x5E, /*gPR_Active_720P_u8MergedWinHeight_Addr */ -0x42, 0x04, /*gPR_Active_720P_u8AEHistWinAx_Addr */ -0x43, 0x04, /*gPR_Active_720P_u8AEHistWinAy_Addr */ -0x44, 0x98, /*gPR_Active_720P_u8AEHistWinBx_Addr */ -0x45, 0x78, /*gPR_Active_720P_u8AEHistWinBy_Addr */ -0x46, 0x22, /*gPR_Active_720P_u8AWBTrim_Addr */ -0x47, 0x28, /*gPR_Active_720P_u8AWBCTWinAx_Addr */ -0x48, 0x20, /*gPR_Active_720P_u8AWBCTWinAy_Addr */ -0x49, 0x78, /*gPR_Active_720P_u8AWBCTWinBx_Addr */ -0x4A, 0x60, /*gPR_Active_720P_u8AWBCTWinBy_Addr */ -0x4B, 0x03, /*gPR_Active_720P_u16AFCFrameLength_0 */ -0x4C, 0x00, /*gPR_Active_720P_u16AFCFrameLength_1 */ - - -/* VGA PR */ -0xFF, 0x86, /*Page mode */ -0x2F, 0x05, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr0*/ -0x30, 0x00, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr1*/ -0x33, 0x04, /* gPT_u8PR_Active_VGA_DPHY_CLK_TIME_Addr3 */ - -0xFF, 0x87, /*Page mode */ -0x4D, 0x00, /*gPR_Active_VGA_u8SensorCtrl_Addr*/ -0x4E, 0x72, /*gPR_Active_VGA_u8SensorMode_Addr*/ -0x4F, 0x01, /*gPR_Active_VGA_u8PLL_P_Addr*/ -0x50, 0x0F, /*gPR_Active_VGA_u8PLL_M_Addr*/ -0x51, 0x00, /*gPR_Active_VGA_u8PLL_S_Addr*/ -0x52, 0x00, /*gPR_Active_VGA_u8PLL_Ctrl_Addr*/ -0x53, 0x01, /*gPR_Active_VGA_u8src_clk_sel_Addr*/ -0x54, 0x00, /*gPR_Active_VGA_u8output_pad_status_Addr*/ -0x55, 0x3F, /*gPR_Active_VGA_u8ablk_ctrl_10_Addr*/ -0x56, 0xFF, /*gPR_Active_VGA_u8BayerFunc_Addr*/ -0x57, 0xFF, /*gPR_Active_VGA_u8RgbYcFunc_Addr*/ -0x58, 0x00, /*gPR_Active_VGA_u8ISPMode_Addr*/ -0x59, 0x02, /*gPR_Active_VGA_u8SCLCtrl_Addr*/ -0x5A, 0x01, /*gPR_Active_VGA_u8SCLHorScale_Addr0*/ -0x5B, 0xFF, /*gPR_Active_VGA_u8SCLHorScale_Addr1*/ -0x5C, 0x01, /*gPR_Active_VGA_u8SCLVerScale_Addr0*/ -0x5D, 0xFF, /*gPR_Active_VGA_u8SCLVerScale_Addr1*/ -0x5E, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr0*/ -0x5F, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr1*/ -0x60, 0x00, /*gPR_Active_VGA_u8SCLCropStartY_Addr0*/ -0x61, 0x20, /*gPR_Active_VGA_u8SCLCropStartY_Addr1*/ -0x62, 0x05, /*gPR_Active_VGA_u8SCLCropEndX_Addr0*/ -0x63, 0x00, /*gPR_Active_VGA_u8SCLCropEndX_Addr1*/ -0x64, 0x03, /*gPR_Active_VGA_u8SCLCropEndY_Addr0*/ -0x65, 0xE0, /*gPR_Active_VGA_u8SCLCropEndY_Addr1*/ - -0xFF, 0xd1, /*Page mode */ -0x07, 0x00, /* power off mask clear*/ -0x0b, 0x00, /* clock off mask clear*/ -0xFF, 0xC0, /*Page mode */ -0x10, 0x41, - - -/* VT-Call END of Initial*/ -}; - - -/* Set-data based on Samsung Reliabilty Group standard -* ,when using WIFI. 15fps -*/ -static const u8 db8131m_vt_wifi_common_1[] = { -/***************************************************/ -/* Device : DB8131M Fixed 8fps */ -/* MIPI Interface for Noncontious Clock */ -/***************************************************/ -/***************************************************/ -/* Command */ -/***************************************************/ -0xFF, 0xC0, /*Page mode*/ -0x10, 0x01, -}; -/*wait 150*/ - -static const u8 db8131m_vt_wifi_common_2[] = { -/***************************************************/ -/* Format */ -/***************************************************/ -0xFF, 0xA1, /*Page mode */ -0x70, 0x01, -0x71, 0x0D, - -/***************************************************/ -/* SensorCon */ -/***************************************************/ -0xFF, 0xD0, /*Page mode */ -0x0F, 0x0B, /*ABLK_Ctrl_1_Addr*/ -0x13, 0x00, /*Gain_Addr*/ -0x15, 0x01, /*IVREFT_REFB_Addr*/ -0x20, 0x0E, /*ABLK_Rsrv_Addr*/ -0x23, 0x01, /*IVREFT2_REFB2_Addr*/ -0x24, 0x01, /*IPPG_IVCM2_Addr*/ -0x39, 0x70, /*RiseSx_CDS_1_L_Addr*/ -0x51, 0x19, /*Fallcreset_1_L_Addr*/ -0x83, 0x2D, /*RiseTran_Sig_Even_L_Addr*/ -0x85, 0x2F, /*FallTran_Sig_Even_L_Addr*/ -0x87, 0x2D, /*RiseTran_Sig_Odd_L_Addr*/ -0x89, 0x2F, /*FallTran_Sig_Odd_L_Addr*/ -0x8B, 0x27, /*RiseCNT_EN_1_L_Addr*/ -0x8D, 0x6c, /*FallCNT_EN_1_L_Addr*/ -0xD7, 0x80, /*ABLK_Ctrl_12_Addr*/ -0xDB, 0xA2, /*FallScanTx15_1_L_Addr*/ -0xED, 0x01, /*PLL_P_Addr*/ -0xEE, 0x0F, /*PLL_M_Addr*/ -0xEF, 0x00, /*PLL_S_Addr*/ -0xF9, 0x00, /*ABLK_Ctrl_8*/ -0xF8, 0x00, /*Vblank Sleep Mode enable*/ -0xFB, 0x90, /*PostADC_Gain_Addr*/ - -/***************************************************/ -/* Analog ADF */ -/***************************************************/ -0xFF, 0x85, /*Page mode */ -0x89, 0x93, /*gAdf_u8APThreshold*/ -0x8A, 0x0C, /*u8APClmpThreshold*/ -0x8C, 0x07, /*gAdf_u8APMinVal_ThrClampH*/ -0x8D, 0x40, /*gAdf_u8APMinVal_ThrClampL*/ -0x8E, 0x03, /*gAdf_u8APMinVal_DOFFSET*/ -0x8F, 0x14, /*gAdf_u8APMinVal_AMP2_1_SDM*/ -0x91, 0x1A, /*gAdf_u8APMinVal_AMP4_3_SDM*/ -0x92, 0x0F, /*gAdf_u8APMinVal_FallIntTx15*/ -0x93, 0x47, /*gAdf_u8APMinVal_CDSxRange_CtrlPre*/ -0x95, 0x18, /*gAdf_u8APMinVal_REFB_IVCM*/ -0x96, 0x38, /*gAdf_u8APMinVal_ref_os_PB*/ -0x97, 0x0D, /*gAdf_u8APMinVal_NTx_Range*/ -0x98, 0x0D, /*gAdf_u8APMaxVal_Clmp_rst*/ -0x99, 0x06, /*gAdf_u8APMaxVal_ThrClampH*/ -0x9A, 0x9F, /*gAdf_u8APMaxVal_ThrClampL*/ -0x9B, 0x02, /*gAdf_u8APMaxVal_DOFFSET*/ -0x9C, 0x1C, /*gAdf_u8APMaxVal_AMP2_1_SDM*/ -0x9E, 0x11, /*gAdf_u8APMaxVal_AMP4_3_SDM*/ -0x9F, 0x5D, /*gAdf_u8APMaxVal_FallIntTx15*/ -0xA0, 0x78, /*gAdf_u8APMaxVal_CDSxRange_CtrlPre*/ -0xA2, 0x18, /*gAdf_u8APMaxVal_REFB_IVCM*/ -0xA3, 0x40, /*gAdf_u8APMaxVal_ref_os_PB*/ -0xA4, 0x0B, /*gAdf_u8APMaxVal_NTx_Range*/ - -0xFF, 0x86, /*Page mode */ -0x15, 0x00, /*gPT_u8Adf_APThrHys*/ -0x16, 0xF7, /*gPT_u8Adf_APFallIntTxThrLevel*/ -0x17, 0x13, /*gPT_u8Adf_APMinVal_BP2_1_SDM*/ -0x18, 0x13, /*gPT_u8Adf_APMidVal_BP2_1_SDM*/ -0x19, 0x1C, /*gPT_u8Adf_APMaxVal_BP2_1_SDM*/ -0x1A, 0x06, /*gPT_u8Adf_APMidVal_ThrClampH*/ -0x1B, 0xF0, /*gPT_u8Adf_APMidVal_ThrClampL*/ -0x1C, 0x01, /*gPT_u8Adf_APMidVal_DOFFSET*/ -0x1D, 0x14, /*gPT_u8Adf_APMidVal_AMP2_1_SDM*/ -0x1F, 0x31, /*gPT_u8Adf_APMidVal_AMP4_3_SDM*/ -0x20, 0x68, /*gPT_u8Adf_APMidVal_CDSxRange_CtrlPre*/ -0x22, 0x18, /*gPT_u8Adf_APMidVal_REFB_IVCM*/ -0x23, 0x38, /*gPT_u8Adf_APMidVal_ref_os_PB*/ -0x24, 0x0F, /*gPT_u8Adf_APMidVal_NTx_Range*/ -0x25, 0x77, /*gPT_u8Adf_APVal_EnSiSoSht_EnSm*/ - -0xFF, 0x87, /*Page mode */ -0xEA, 0x41, - -0xFF, 0xD0, /*Page mode */ -0x20, 0x0D, /*ABLK_Rsrv_Addr*/ - -0xFF, 0x83, /*Page mode */ -0x63, 0x28, /*Again Table*/ -0x64, 0x10, /*Again Table*/ -0x65, 0xA8, /*Again Table*/ -0x66, 0x50, /*Again Table*/ -0x67, 0x28, /*Again Table*/ -0x68, 0x14, /*Again Table*/ - - -/***************************************************/ -/* AE */ -/***************************************************/ -0xFF, 0x82, /*Page mode */ -0x91, 0x02, /* AeMode*/ -0x95, 0x88, /* AE weight*/ -0x96, 0x88, -0x97, 0xF8, -0x98, 0x8F, -0x99, 0xF8, -0x9A, 0x8F, -0x9B, 0x88, -0x9C, 0x88, -0xA9, 0x40, /* OTarget*/ -0xAA, 0x40, /* ITarget*/ -0x9D, 0x66, /* AE Speed*/ -0x9F, 0x06, /* AE HoldBnd*/ -0xA8, 0x40, /* STarget*/ -0xB9, 0x04, /* RGain*/ -0xBB, 0x04, /* GGain*/ -0xBD, 0x04, /* BGain*/ -0xC5, 0x02, /* PeakMvStep*/ -0xC6, 0x38, /* PeakTgMin*/ -0xC7, 0x24, /* PeakRatioTh1*/ -0xC8, 0x10, /* PeakRatioTh0*/ -0xC9, 0x05, /* PeakLuTh*/ -0xD5, 0x60, /* LuxGainTB_2*/ -0xFF, 0x83, /*Page mode */ -0x2F, 0x04, /* TimeNum0*/ -0x30, 0x05, /* TimeNum1*/ -0x4F, 0x05, /* FrameOffset*/ -0xFF, 0x82, /*Page mode */ -0xA1, 0x0A, /* AnalogGainMax*/ -0xF3, 0x09, /* SCLK*/ -0xF4, 0x60, -0xF9, 0x00, /* GainMax*/ -0xFA, 0xC8, /* GainMax*/ -0xFB, 0x62, /* Gain3Lut*/ -0xFC, 0x39, /* Gain2Lut*/ -0xFD, 0x28, /* Gain1Lut*/ -0xFE, 0x12, /* GainMin*/ -0xFF, 0x83, /*Page mode */ -0x03, 0x0F, /* TimeMax60Hz : 8fps*/ -0x04, 0x0A, /* Time3Lux60Hz : 12fps*/ -0x05, 0x04, /* Time2Lut60Hz : 24fps*/ -0x06, 0x04, /* Time1Lut60Hz : 24fps*/ -0xFF, 0x82, /*Page mode */ -0xD3, 0x12, /* LuxTBGainStep0 */ -0xD4, 0x36, /* LuxTBGainStep1 */ -0xD5, 0x60, /* LuxTBGainStep2*/ -0xD6, 0x01, /* LuxTBTimeStep0H*/ -0xD7, 0x00, /* LuxTBTimeStep0L*/ -0xD8, 0x01, /* LuxTBTimeStep1H*/ -0xD9, 0xC0, /* LuxTBTimeStep1L*/ -0xDA, 0x06, /* LuxTBTimeStep2H*/ -0xDB, 0x00, /* LuxTBTimeStep2L*/ -0xFF, 0x83, /*Page mode */ -0x0B, 0x08, -0x0C, 0x0C, /* Frame Rate*/ -0xFF, 0x82, /*Page mode */ -0x92, 0x5D, - -/***************************************************/ -/* AWB */ -/***************************************************/ -0xFF, 0x83, /*Page mode */ -0x79, 0x83, /* AWB SKIN ON*/ -0x86, 0x07, /* gAWB_u16MinGrayCnt_rw_0*/ -0x87, 0x00, /* gAWB_u16MinGrayCnt_rw_1*/ -0x90, 0x05, /* gAWB_u16FinalRGain_ro_0*/ -0x94, 0x05, /* gAWB_u16FinalBGain_ro_0*/ -0x98, 0xD4, /* SkinWinCntTh*/ -0xA2, 0x28, /* SkinYTh*/ -0xA3, 0x00, /* SkinHoldHitCnt*/ -0xA4, 0x0F, /* SkinHoldHitCnt*/ -0xAD, 0x65, /* u8SkinTop2*/ -0xAE, 0x80, /* gAwb_u8SkinTop2LS1Ratio_rw 5zone */ -0xAF, 0x20, /* gAwb_u8SkinTop2LS2Ratio_rw 6zone */ -0xB4, 0x10, /* u8SkinTop2LSHys_rw */ -0xB5, 0x54, /* gAwb_u8SkinLTx */ -0xB6, 0xbd, /* gAwb_u8SkinLTy */ -0xB7, 0x74, /* gAwb_u8SkinRBx */ -0xB8, 0x9d, /* gAwb_u8SkinRBy */ -0xBA, 0x4F, /* UniCThrY_rw */ -0xBF, 0x0C, /* u16UniCGrayCntThr_rw_0*/ -0xC0, 0x80, /* u16UniCGrayCntThr_rw_1 */ -0xFF, 0x87, /*Page mode */ -0xC9, 0x22, /* gUR_u8AWBTrim_Addr */ -0xFF, 0x84, /*Page mode */ -0x49, 0x02, /* Threshold_indoor */ -0x4A, 0x00, -0x4B, 0x03, /* Threshold_outdoor */ -0x4C, 0x80, -0xFF, 0x83, /*Page mode */ -0xCB, 0x03, /* R MinGain [Default 0X20] A Spec Pass */ -0xCC, 0xC0, /* R MinGain [Default 0X20] A Spec Pass */ -0x82, 0x00, /* lockratio*/ -0xFF, 0x84, /*Page mode */ -0x3D, 0x00, /* gAwb_u32LuxConst1_rw_0*/ -0x3E, 0x00, /* gAwb_u32LuxConst1_rw_1*/ -0x3F, 0x06, /* gAwb_u32LuxConst1_rw_2*/ -0x40, 0x20, /* gAwb_u32LuxConst1_rw_3*/ -0x41, 0x07, /* gAwb_u32LuxConst2_rw_0*/ -0x42, 0x53, /* gAwb_u32LuxConst2_rw_1*/ -0x43, 0x00, /* gAwb_u32LuxConst2_rw_2*/ -0x44, 0x00, /* gAwb_u32LuxConst2_rw_3*/ -0x55, 0x03, /* gAwb_u8Weight_Gen_rw_0 */ -0x56, 0x10, /* gAwb_u8Weight_Gen_rw_1 */ -0x57, 0x14, /* gAwb_u8Weight_Gen_rw_2 */ -0x58, 0x07, /* gAwb_u8Weight_Gen_rw_3 */ -0x59, 0x04, /* gAwb_u8Weight_Gen_rw_4 */ -0x5A, 0x03, /* gAwb_u8Weight_Gen_rw_5 */ -0x5B, 0x03, /* gAwb_u8Weight_Gen_rw_6 */ -0x5C, 0x15, /* gAwb_u8Weight_Gen_rw_7 */ -0x5D, 0x01, /* gAwb_u8Weight_Ind_rw_0 */ -0x5E, 0x0F, /* gAwb_u8Weight_Ind_rw_1 */ -0x5F, 0x07, /* gAwb_u8Weight_Ind_rw_2 */ -0x60, 0x14, /* gAwb_u8Weight_Ind_rw_3 */ -0x61, 0x14, /* gAwb_u8Weight_Ind_rw_4 */ -0x62, 0x12, /* gAwb_u8Weight_Ind_rw_5 */ -0x63, 0x11, /* gAwb_u8Weight_Ind_rw_6 */ -0x64, 0x14, /* gAwb_u8Weight_Ind_rw_7 */ -0x65, 0x03, /* gAwb_u8Weight_Outd_rw_0*/ -0x66, 0x05, /* gAwb_u8Weight_Outd_rw_1*/ -0x67, 0x15, /* gAwb_u8Weight_Outd_rw_2*/ -0x68, 0x04, /* gAwb_u8Weight_Outd_rw_3*/ -0x69, 0x01, /* gAwb_u8Weight_Outd_rw_4*/ -0x6A, 0x02, /* gAwb_u8Weight_Outd_rw_5*/ -0x6B, 0x03, /* gAwb_u8Weight_Outd_rw_6*/ -0x6C, 0x15, /* gAwb_u8Weight_Outd_rw_6*/ -0xFF, 0x85, /*Page mode */ -0xE2, 0x0C, /* gPT_u8Awb_UnicolorZone_rw */ -0xFF, 0x83, /*Page mode */ -0xCD, 0x06, /*Max Rgain*/ -0xCE, 0x80, -0xD1, 0x06, /*Max BGain*/ -0xd2, 0x80, - -/***************************************************/ -/* AWB STE */ -/***************************************************/ -0xFF, 0xA1, /*Page mode */ -/*Flash*/ -0xA0, 0x5c, /*AWBZone0LTx*/ -0xA1, 0x7a, /*AWBZone0LTy*/ -0xA2, 0x69, /*AWBZone0RBx*/ -0xA3, 0x6f, /*AWBZone0RBy*/ -/*cloudy*/ -0xA4, 0x73, /*AWBZone1LTx*/ -0xA5, 0x55, /*AWBZone1LTy*/ -0xA6, 0x8C, /*AWBZone1RBx*/ -0xA7, 0x30, /*AWBZone1RBy */ -/*Daylight */ -0xA8, 0x69, /*AWBZone2LTx*/ -0xA9, 0x69, /*AWBZone2LTy*/ -0xAA, 0x83, /*AWBZone2RBx*/ -0xAB, 0x52, /*AWBZone2RBy */ -/*Fluorescent */ -0xAC, 0x57, /*AWBZone3LTx*/ -0xAD, 0x6e, /*AWBZone3LTy*/ -0xAE, 0x6f, /*AWBZone3RBx*/ -0xAF, 0x59, /*AWBZone3RBy*/ - -/*CWF */ -0xB0, 0x50, /*AWBZone4LTx*/ -0xB1, 0x74, /*AWBZone4LTy*/ -0xB2, 0x65, /*AWBZone4RBx*/ -0xB3, 0x5d, /*AWBZone4RBy*/ -/*TL84 */ -0xB4, 0x53, /*AWBZone5LTx*/ -0xB5, 0x7f, /*AWBZone5LTy*/ -0xB6, 0x62, /*AWBZone5RBx*/ -0xB7, 0x75, /*AWBZone5RBy */ -/*A */ -0xB8, 0x4a, /*AWBZone6LTx*/ -0xB9, 0x87, /*AWBZone6LTy*/ -0xBA, 0x59, /*AWBZone6RBx*/ -0xBB, 0x78, /*AWBZone6RBy*/ -/*Horizon */ -0xBC, 0x41, /*AWBZone7LTx*/ -0xBD, 0x91, /*AWBZone7LTy*/ -0xBE, 0x4b, /*AWBZone7RBx*/ -0xBF, 0x89, /*AWBZone7RBy*/ -/*Skin */ -0xC0, 0x5b, /*AWBZone8LTx*/ -0xC1, 0x85, /*AWBZone8LTy*/ -0xC2, 0x60, /*AWBZone8RBx*/ -0xC3, 0x7b, /*AWBZone8RBy*/ - -/***************************************************/ -/* UR */ -/***************************************************/ -0xFF, 0x85, /*Page mode */ -0x06, 0x05, -0xFF, 0x86, /*Page mode */ -0x14, 0x1E, /* CCM sum 1*/ -0xFF, 0x85, /*Page mode */ -0x86, 0x42, /* 42 saturation level*/ -0x07, 0x00, /* sup hysteresis*/ - -/*DAY light */ -0xFF, 0x83, /*Page mode */ -0xEA, 0x00, /*gAwb_s16AdapCCMTbl_0*/ -0xEB, 0x53, /*gAwb_s16AdapCCMTbl_1*/ -0xEC, 0xFF, /*gAwb_s16AdapCCMTbl_2*/ -0xED, 0xE1, /*gAwb_s16AdapCCMTbl_3*/ -0xEE, 0x00, /*gAwb_s16AdapCCMTbl_4*/ -0xEF, 0x05, /*gAwb_s16AdapCCMTbl_5*/ -0xF0, 0xFF, /*gAwb_s16AdapCCMTbl_6*/ -0xF1, 0xF3, /*gAwb_s16AdapCCMTbl_7*/ -0xF2, 0x00, /*gAwb_s16AdapCCMTbl_8*/ -0xF3, 0x4B, /*gAwb_s16AdapCCMTbl_9*/ -0xF4, 0xFF, /*gAwb_s16AdapCCMTbl_10*/ -0xF5, 0xFA, /*gAwb_s16AdapCCMTbl_11*/ -0xF6, 0xFF, /*gAwb_s16AdapCCMTbl_12*/ -0xF7, 0xFa, /*gAwb_s16AdapCCMTbl_13*/ -0xF8, 0xFF, /*gAwb_s16AdapCCMTbl_14*/ -0xF9, 0xC3, /*gAwb_s16AdapCCMTbl_15*/ -0xFA, 0x00, /*gAwb_s16AdapCCMTbl_16*/ -0xFB, 0x80, /*gAwb_s16AdapCCMTbl_17*/ - -/*CWF lgiht */ -0xFF, 0x83, /*Page mode */ -0xFC, 0x00, /* gAwb_s16AdapCCMTbl_18 */ -0xFD, 0x68, /* gAwb_s16AdapCCMTbl_19 */ -0xFF, 0x85, /*Page mode */ -0xE0, 0xFF, /* gAwb_s16AdapCCMTbl_20 */ -0xE1, 0xde, /* gAwb_s16AdapCCMTbl_21 */ -0xFF, 0x84, /*Page mode */ -0x00, 0xff, /* gAwb_s16AdapCCMTbl_22 */ -0x01, 0xfa, /* gAwb_s16AdapCCMTbl_23 */ -0x02, 0xFF, /* gAwb_s16AdapCCMTbl_24 */ -0x03, 0xf0, /* gAwb_s16AdapCCMTbl_25 */ -0x04, 0x00, /* gAwb_s16AdapCCMTbl_26 */ -0x05, 0x52, /* gAwb_s16AdapCCMTbl_27 */ -0x06, 0xFF, /* gAwb_s16AdapCCMTbl_28 */ -0x07, 0xFa, /* gAwb_s16AdapCCMTbl_29 */ -0x08, 0x00, /* gAwb_s16AdapCCMTbl_30 */ -0x09, 0x00, /* gAwb_s16AdapCCMTbl_31 */ -0x0A, 0xFF, /* gAwb_s16AdapCCMTbl_32 */ -0x0B, 0xdb, /* gAwb_s16AdapCCMTbl_33 */ -0x0C, 0x00, /* gAwb_s16AdapCCMTbl_34 */ -0x0D, 0x68, /* gAwb_s16AdapCCMTbl_35 */ - -/*A light */ - -0x0E, 0x00, /* gAwb_s16AdapCCMTbl_36 */ -0x0F, 0x6d, /* gAwb_s16AdapCCMTbl_37 */ -0x10, 0xFF, /* gAwb_s16AdapCCMTbl_38 */ -0x11, 0xd5, /* gAwb_s16AdapCCMTbl_39 */ -0x12, 0xff, /* gAwb_s16AdapCCMTbl_40 */ -0x13, 0xfe, /* gAwb_s16AdapCCMTbl_41 */ -0x14, 0xFF, /* gAwb_s16AdapCCMTbl_42 */ -0x15, 0xf4, /* gAwb_s16AdapCCMTbl_43 */ -0x16, 0x00, /* gAwb_s16AdapCCMTbl_44 */ -0x17, 0x5a, /* gAwb_s16AdapCCMTbl_45 */ -0x18, 0xff, /* gAwb_s16AdapCCMTbl_46 */ -0x19, 0xef, /* gAwb_s16AdapCCMTbl_47 */ -0x1A, 0xff, /* gAwb_s16AdapCCMTbl_48 */ -0x1B, 0xfa, /* gAwb_s16AdapCCMTbl_49 */ -0x1C, 0xFF, /* gAwb_s16AdapCCMTbl_50 */ -0x1D, 0xbe, /* gAwb_s16AdapCCMTbl_51 */ -0x1E, 0x00, /* gAwb_s16AdapCCMTbl_52 */ -0x1F, 0x86, /* gAwb_s16AdapCCMTbl_53 */ - - -/***************************************************/ -/* ADF */ -/***************************************************/ - -/* ISP setting*/ -0xFF, 0xA0, /*Page mode */ -0x10, 0x80, /* BLC: ABLC db*/ -0x60, 0x73, /* CDC: Dark CDC ON */ -0x61, 0x1F, /* Six CDC_Edge En, Slash EN*/ -0x69, 0x0C, /* Slash direction Line threshold*/ -0x6A, 0x60, /* Slash direction Pixel threshold*/ -0xC2, 0x04, /* NSF: directional smoothing*/ -0xD0, 0x51, /* DEM: pattern detection*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /* EDE: Luminane adaptation on*/ -0x32, 0x50, /* EDE: Adaptation slope */ -0x34, 0x00, /* EDE: x1 point */ -0x35, 0x0B, /* EDE: x1 point */ -0x36, 0x01, /* EDE: x2 point */ -0x37, 0x80, /* EDE: x2 point */ -0x3A, 0x00, /* EDE: Adaptation left margin*/ -0x3B, 0x30, /* EDE: Adaptation right margin*/ -0x3C, 0x08, /* EDE: rgb edge threshol*/ - -/* Adaptive Setting*/ -0xFF, 0x85, /*Page mode */ -/* LSC*/ -0x0F, 0x43, /* LVLSC lux level threshold*/ -0x10, 0x43, /* LSLSC Light source , threshold lux*/ - -/* BGT*/ -0x17, 0x30, /* BGT lux level threshold*/ -0x26, 0x20, /* MinVal */ -0x3c, 0x00, /* MaxVal */ - -/* CNT*/ -0x18, 0x43, /* CNT lux level threshold*/ -0x27, 0x00, /* MinVal */ -0x3d, 0x00, /* MaxVal */ - -/* NSF */ -0x12, 0xA5, /* NSF lux level threshold */ -0x22, 0x38, /* u8MinVal_NSF1*/ -0x23, 0x70, /* u8MinVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x12, 0x00, /* u8MinVal_NSF3*/ -0xFF, 0x85, /*Page mode */ -0x38, 0x12, /* u8MaxVal_NSF1*/ -0x39, 0x30, /* u8MaxVal_NSF2*/ -0xFF, 0x86, /*Page mode */ -0x13, 0x08, /* u8MaxVal_NSF3*/ - -/* GDC*/ -0xFF, 0x85, /*Page mode */ -0x15, 0xF4, /* GDC lux level threshold */ -0x2D, 0x20, /* u8MinVal_GDC1*/ -0x2E, 0x30, /* u8MinVal_GDC2*/ -0x43, 0x40, /* u8MaxVal_GDC1*/ -0x44, 0x80, /* u8MaxVal_GDC2*/ - -/* ISP Edge*/ -0x04, 0xFB, /* EnEDE*/ -0x14, 0x54, /* u8ThrLevel_EDE*/ -0x28, 0x00, /* u8MinVal_EDE_CP*/ -0x29, 0x03, /* u8MinVal_EDE1*/ -0x2A, 0x20, /* u8MinVal_EDE2*/ -0x2B, 0x00, /* u8MinVal_EDE_OFS*/ -0x2C, 0x22, /* u8MinVal_SG*/ -0x3E, 0x00, /* u8MaxVal_EDE_CP*/ -0x3F, 0x09, /* u8MaxVal_EDE1*/ -0x40, 0x22, /* u8MaxVal_EDE2*/ -0x41, 0x02, /* u8MaxVal_EDE_OFS*/ -0x42, 0x33, /* u8MaxVal_SG*/ - -/* Gamma Adaptive*/ - -0x16, 0xA0, /* Gamma Threshold*/ -0x47, 0x00, /* Min_Gamma_0*/ -0x48, 0x03, /* Min_Gamma_1*/ -0x49, 0x10, /* Min_Gamma_2*/ -0x4A, 0x25, /* Min_Gamma_3*/ -0x4B, 0x3B, /* Min_Gamma_4*/ -0x4C, 0x4F, /* Min_Gamma_5*/ -0x4D, 0x6D, /* Min_Gamma_6*/ -0x4E, 0x86, /* Min_Gamma_7*/ -0x4F, 0x9B, /* Min_Gamma_8*/ -0x50, 0xAD, /* Min_Gamma_9*/ -0x51, 0xC2, /* Min_Gamma_10*/ -0x52, 0xD3, /* Min_Gamma_11*/ -0x53, 0xE1, /* Min_Gamma_12*/ -0x54, 0xE9, /* Min_Gamma_13*/ -0x55, 0xF2, /* Min_Gamma_14*/ -0x56, 0xFA, /* Min_Gamma_15*/ -0x57, 0xFF, /* Min_Gamma_16*/ -0x58, 0x00, /* Max_Gamma_0 */ -0x59, 0x06, /* Max_Gamma_1 */ -0x5a, 0x14, /* Max_Gamma_2 */ -0x5b, 0x30, /* Max_Gamma_3 */ -0x5c, 0x4A, /* Max_Gamma_4 */ -0x5d, 0x5D, /* Max_Gamma_5 */ -0x5e, 0x75, /* Max_Gamma_6 */ -0x5f, 0x89, /* Max_Gamma_7 */ -0x60, 0x9A, /* Max_Gamma_8 */ -0x61, 0xA7, /* Max_Gamma_9 */ -0x62, 0xBC, /* Max_Gamma_10 */ -0x63, 0xD0, /* Max_Gamma_11 */ -0x64, 0xE0, /* Max_Gamma_12 */ -0x65, 0xE7, /* Max_Gamma_13 */ -0x66, 0xEE, /* Max_Gamma_14 */ -0x67, 0xF7, /* Max_Gamma_15 */ -0x68, 0xFF, /* Max_Gamma_16 */ - -/* Initial edge, noise filter setting*/ -0xFF, 0xA0, /*Page mode */ -0xC0, 0x12, /*NSFTh1_Addr*/ -0xC1, 0x30, /*NSFTh2_Addr*/ -0xC2, 0x08, /*NSFTh3_Addr*/ -0xFF, 0xA1, /*Page mode */ -0x30, 0x01, /*EDEOption_Addr*/ -0x31, 0x33, /*EDESlopeGain_Addr*/ -0x32, 0x50, /*EDELuAdpCtrl_Addr*/ -0x33, 0x00, /*EDEPreCoringPt_Addr*/ -0x34, 0x00, /*EDETransFuncXp1_Addr1*/ -0x35, 0x0B, /*EDETransFuncXp1_Addr0*/ -0x36, 0x01, /*EDETransFuncXp2_Addr1*/ -0x37, 0x80, /*EDETransFuncXp2_Addr0*/ -0x38, 0x09, /*EDETransFuncSl1_Addr*/ -0x39, 0x22, /*EDETransFuncSl2_Addr*/ -0x3A, 0x00, /*EDELuAdpLOffset_Addr*/ -0x3B, 0x30, /*EDELuAdpROffset_Addr*/ -0x3C, 0x08, /*EDERBThrd_Addr*/ -0x3D, 0x02, /*EDESmallOffset_Addr*/ - - -/* CCM Saturation Level*/ -0xFF, 0x85, /*Page mode */ -0x1A, 0x64, /* SUP Threshold */ -0x30, 0x40, /* MinSUP */ - -0xFF, 0xA0, /*Page mode */ -/* Lens Shading*/ -0x43, 0x80, /* RH7 rrhrhh*/ -0x44, 0x80, /* RV*/ -0x45, 0x80, /* RH */ -0x46, 0x80, /* RV*/ -0x47, 0x80, /* GH*/ -0x48, 0x80, /* GV*/ -0x49, 0x80, /* GH*/ -0x4A, 0x80, /* GV */ -0x4B, 0x80, /* BH*/ -0x4C, 0x80, /* BV*/ -0x4D, 0x80, /* BH*/ -0x4E, 0x80, /* BV */ -0x52, 0x90, /* GGain*/ -0x53, 0x20, /* GGain*/ -0x54, 0x00, /* GGain*/ - -/*Max Shading*/ -0xFF, 0x85, /*Page mode */ -0x32, 0xC0, -0x33, 0x30, -0x34, 0x00, -0x35, 0x90, -0x36, 0x20, -0x37, 0x00, - -/*Min Shading*/ -0x1c, 0xC0, -0x1d, 0x30, -0x1e, 0x00, -0x1f, 0x90, -0x20, 0x18, -0x21, 0x00, - -/* LineLength */ -0xFF, 0x87, /*Page mode */ -0xDC, 0x05, /* by Yong In Han 091511*/ -0xDD, 0xB0, /* by Yong In Han 091511*/ -0xd5, 0x00, /* Flip*/ -/***************************************************/ -/* SensorCon */ -/***************************************************/ -0xFF, 0xD0, /*Page mode */ -0x20, 0x0E, /* ABLK_Rsrv_Addr*/ -0x20, 0x0D, /* ABLK_Rsrv_Addr*/ - -/***************************************************/ -/* MIPI */ -/***************************************************/ -0xFF, 0xB0, /*Page mode */ -0x54, 0x02, /* MIPI PHY_HS_TX_CTRL*/ -0x38, 0x05, /* MIPI DPHY_CTRL_SET*/ - - -/* SXGA PR*/ -0xFF, 0x85, /*Page mode */ -0xB8, 0x0A, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr0*/ -0xB9, 0x00, /* gPT_u8PR_Active_SXGA_WORD_COUNT_Addr1*/ -0xBC, 0x04, /* gPT_u8PR_Active_SXGA_DPHY_CLK_TIME_Addr3*/ -0xFF, 0x87, /*Page mode */ -0x0C, 0x00, /* start Y*/ -0x0D, 0x20, /* start Y */ -0x10, 0x03, /* end Y*/ -0x11, 0xE0, /* end Y */ - -/* Recoding */ -0xFF, 0x86, /*Page mode */ -0x38, 0x05, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr0*/ -0x39, 0x00, /* gPT_u8PR_Active_720P_WORD_COUNT_Addr1*/ -0x3C, 0x04, /* gPT_u8PR_Active_720P_DPHY_CLK_TIME_Addr3*/ - -0xFF, 0x87, -0x23, 0x02, /*gPR_Active_720P_u8SensorCtrl_Addr */ -0x25, 0x01, /*gPR_Active_720P_u8PLL_P_Addr */ -0x26, 0x0F, /*gPR_Active_720P_u8PLL_M_Addr */ -0x27, 0x00, /*gPR_Active_720P_u8PLL_S_Addr */ -0x28, 0x00, /*gPR_Active_720P_u8PLL_Ctrl_Addr */ -0x29, 0x01, /*gPR_Active_720P_u8src_clk_sel_Addr */ -0x2A, 0x00, /*gPR_Active_720P_u8output_pad_status_Addr */ -0x2B, 0x3F, /*gPR_Active_720P_u8ablk_ctrl_10_Addr */ -0x2C, 0xFF, /*gPR_Active_720P_u8BayerFunc_Addr */ -0x2D, 0xFF, /*gPR_Active_720P_u8RgbYcFunc_Addr */ -0x2E, 0x00, /*gPR_Active_720P_u8ISPMode_Addr */ -0x2F, 0x02, /*gPR_Active_720P_u8SCLCtrl_Addr */ -0x30, 0x01, /*gPR_Active_720P_u8SCLHorScale_Addr0 */ -0x31, 0xFF, /*gPR_Active_720P_u8SCLHorScale_Addr1 */ -0x32, 0x03, /*gPR_Active_720P_u8SCLVerScale_Addr0 */ -0x33, 0xFF, /*gPR_Active_720P_u8SCLVerScale_Addr1 */ -0x34, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr0 */ -0x35, 0x00, /*gPR_Active_720P_u8SCLCropStartX_Addr1 */ -0x36, 0x00, /*gPR_Active_720P_u8SCLCropStartY_Addr0 */ -0x37, 0x10, /*gPR_Active_720P_u8SCLCropStartY_Addr1 */ -0x38, 0x02, /*gPR_Active_720P_u8SCLCropEndX_Addr0 */ -0x39, 0x80, /*gPR_Active_720P_u8SCLCropEndX_Addr1 */ -0x3A, 0x01, /*gPR_Active_720P_u8SCLCropEndY_Addr0 */ -0x3B, 0xF0, /*gPR_Active_720P_u8SCLCropEndY_Addr1 */ -0x3C, 0x01, /*gPR_Active_720P_u8OutForm_Addr */ -0x3D, 0x0C, /*gPR_Active_720P_u8OutCtrl_Addr */ -0x3E, 0x04, /*gPR_Active_720P_u8AEWinStartX_Addr */ -0x3F, 0x04, /*gPR_Active_720P_u8AEWinStartY_Addr */ -0x40, 0x66, /*gPR_Active_720P_u8MergedWinWidth_Addr */ -0x41, 0x5E, /*gPR_Active_720P_u8MergedWinHeight_Addr */ -0x42, 0x04, /*gPR_Active_720P_u8AEHistWinAx_Addr */ -0x43, 0x04, /*gPR_Active_720P_u8AEHistWinAy_Addr */ -0x44, 0x98, /*gPR_Active_720P_u8AEHistWinBx_Addr */ -0x45, 0x78, /*gPR_Active_720P_u8AEHistWinBy_Addr */ -0x46, 0x22, /*gPR_Active_720P_u8AWBTrim_Addr */ -0x47, 0x28, /*gPR_Active_720P_u8AWBCTWinAx_Addr */ -0x48, 0x20, /*gPR_Active_720P_u8AWBCTWinAy_Addr */ -0x49, 0x78, /*gPR_Active_720P_u8AWBCTWinBx_Addr */ -0x4A, 0x60, /*gPR_Active_720P_u8AWBCTWinBy_Addr */ -0x4B, 0x03, /*gPR_Active_720P_u16AFCFrameLength_0 */ -0x4C, 0x00, /*gPR_Active_720P_u16AFCFrameLength_1 */ - - -/* VGA PR */ -0xFF, 0x86, /*Page mode */ -0x2F, 0x05, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr0*/ -0x30, 0x00, /* gPT_u8PR_Active_VGA_WORD_COUNT_Addr1*/ -0x33, 0x04, /* gPT_u8PR_Active_VGA_DPHY_CLK_TIME_Addr3*/ - -0xFF, 0x87, /*Page mode */ -0x4D, 0x00, /*gPR_Active_VGA_u8SensorCtrl_Addr*/ -0x4E, 0x72, /*gPR_Active_VGA_u8SensorMode_Addr*/ -0x4F, 0x01, /*gPR_Active_VGA_u8PLL_P_Addr*/ -0x50, 0x0F, /*gPR_Active_VGA_u8PLL_M_Addr*/ -0x51, 0x00, /*gPR_Active_VGA_u8PLL_S_Addr*/ -0x52, 0x00, /*gPR_Active_VGA_u8PLL_Ctrl_Addr*/ -0x53, 0x01, /*gPR_Active_VGA_u8src_clk_sel_Addr*/ -0x54, 0x00, /*gPR_Active_VGA_u8output_pad_status_Addr*/ -0x55, 0x3F, /*gPR_Active_VGA_u8ablk_ctrl_10_Addr*/ -0x56, 0xFF, /*gPR_Active_VGA_u8BayerFunc_Addr*/ -0x57, 0xFF, /*gPR_Active_VGA_u8RgbYcFunc_Addr*/ -0x58, 0x00, /*gPR_Active_VGA_u8ISPMode_Addr*/ -0x59, 0x02, /*gPR_Active_VGA_u8SCLCtrl_Addr*/ -0x5A, 0x01, /*gPR_Active_VGA_u8SCLHorScale_Addr0*/ -0x5B, 0xFF, /*gPR_Active_VGA_u8SCLHorScale_Addr1*/ -0x5C, 0x01, /*gPR_Active_VGA_u8SCLVerScale_Addr0*/ -0x5D, 0xFF, /*gPR_Active_VGA_u8SCLVerScale_Addr1*/ -0x5E, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr0*/ -0x5F, 0x00, /*gPR_Active_VGA_u8SCLCropStartX_Addr1*/ -0x60, 0x00, /*gPR_Active_VGA_u8SCLCropStartY_Addr0*/ -0x61, 0x20, /*gPR_Active_VGA_u8SCLCropStartY_Addr1*/ -0x62, 0x05, /*gPR_Active_VGA_u8SCLCropEndX_Addr0*/ -0x63, 0x00, /*gPR_Active_VGA_u8SCLCropEndX_Addr1*/ -0x64, 0x03, /*gPR_Active_VGA_u8SCLCropEndY_Addr0*/ -0x65, 0xE0, /*gPR_Active_VGA_u8SCLCropEndY_Addr1*/ - -0xFF, 0xd1, /*Page mode */ -0x07, 0x00, /* power off mask clear*/ -0x0b, 0x00, /* clock off mask clear*/ -0xFF, 0xC0, /*Page mode */ -0x10, 0x41, - -/* Wifi VT-Call END of Initial*/ -}; - -/***************************************************/ -/* CAMERA_PREVIEW - ÃÔ¿µ ÈÄ ÇÁ¸®ºä º¹±Í½Ã ¼ÂÆà */ -/***************************************************/ - -static const u8 db8131m_preview[] = { -0xff, 0x82, -0x7F, 0x35, -}; - -/***************************************************/ -/* CAMERA_SNAPSHOT - ÃÔ¿µ */ -/***************************************************/ -static const u8 db8131m_capture[] = { -0xff, 0x82, -0x7F, 0x34, -0xff, 0xC0, -0x10, 0x03, -}; -/*Wait 150ms*/ -/* capture ½ÇÇà*/ - -/***************************************************/ -/* CAMERA_RECORDING WITH 25fps */ -/***************************************************/ - -static const u8 db8131m_recording_60Hz_common[] = { -/***************************************************/ -/* Device : DB8131M */ -/* MIPI Interface for Noncontious Clock */ -/***************************************************/ - -/* Recording Anti-Flicker 60Hz END of Initial */ -0xFF, 0x87, -0xDE, 0x7A, /*gPR_Active_720P_u8SensorMode_Addr */ -0xFF, 0xC0, /* Page mode*/ -0x10, 0x42, /* Preview Command*/ - -/* Fixed 25fps Mode*/ -0xFF, 0x82, /* Page mode*/ -0x91, 0x02, /* AeMode*/ -0xFF, 0x83, /* Page mode*/ -0x0B, 0x02, /* Frame Rate*/ -0x0C, 0x94, /* Frame Rate*/ -0x03, 0x04, /* TimeMax60Hz*/ -0x04, 0x03, /* Time3Lux60Hz*/ -0x05, 0x02, /* Time2Lut60Hz*/ -0x06, 0x01, /* Time1Lut60Hz*/ -0xFF, 0x82, /* Page mode*/ -0x92, 0x5D, -}; - - -static const u8 db8131m_stream_stop[] = { - -}; - - -/***************************************************/ -/* CAMERA_BRIGHTNESS_1 (1/9) M4 */ -/***************************************************/ -static const u8 db8131m_bright_m4[] = { -/* Brightness -4 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0xE0, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_2 (2/9) M3 */ -/***************************************************/ - -static const u8 db8131m_bright_m3[] = { -/* Brightness -3 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0xE8, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_3 (3/9) M2 */ -/***************************************************/ -static const u8 db8131m_bright_m2[] = { -/* Brightness -2 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0xF0, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_4 (4/9) M1 */ -/***************************************************/ - -static const u8 db8131m_bright_m1[] = { -/* Brightness -1 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0xF8, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_5 (5/9) Default */ -/***************************************************/ -static const u8 db8131m_bright_default[] = { -/* Brightness 0 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0x00, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_6 (6/9) P1 */ -/***************************************************/ -static const u8 db8131m_bright_p1[] = { -/* Brightness +1 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0x08, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_7 (7/9) P2 */ -/***************************************************/ -static const u8 db8131m_bright_p2[] = { -/* Brightness +2 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0x10, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_8 (8/9) P3 */ -/***************************************************/ -static const u8 db8131m_bright_p3[] = { -/* Brightness +3 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0x18, /* Brightness*/ -}; - -/***************************************************/ -/* CAMERA_BRIGHTNESS_9 (9/9) P4 */ -/***************************************************/ -static const u8 db8131m_bright_p4[] = { -/* Brightness +4 */ -0xFF, 0x87, /* Page mode*/ -0xAE, 0x20, /* Brightness*/ -}; - - -static const u8 db8131m_vt_7fps[] = { -/* Fixed 7fps Mode*/ -0xFF, 0x82, /* Page mode*/ -0x91, 0x02, /* AeMode*/ -0xFF, 0x83, /* Page mode*/ -0x0B, 0x09, /* Frame Rate*/ -0x0C, 0x33, /* Frame Rate*/ -0x03, 0x0F, /* TimeMax60Hz*/ -0x04, 0x0A, /* Time3Lux60Hz*/ -0x05, 0x06, /* Time2Lut60Hz*/ -0x06, 0x04, /* Time1Lut60Hz*/ -0xFF, 0x82, /* Page mode*/ -0x92, 0x5D, -}; - -static const u8 db8131m_vt_10fps[] = { -/* Fixed 10fps Mode */ -0xFF, 0x82, /* Page mode*/ -0x91, 0x02, /* AeMode*/ -0xFF, 0x83, /* Page mode*/ -0x0B, 0x06, /* Frame Rate*/ -0x0C, 0x70, /* Frame Rate*/ -0x03, 0x0A, /* TimeMax60Hz*/ -0x04, 0x08, /* Time3Lux60Hz*/ -0x05, 0x06, /* Time2Lut60Hz*/ -0x06, 0x04, /* Time1Lut60Hz*/ -0xFF, 0x82, /* Page mode*/ -0x92, 0x5D, - -}; - -static const u8 db8131m_vt_12fps[] = { -/* Fixed 12fps Mode */ -0xFF, 0x82, /* Page mode*/ -0x91, 0x02, /* AeMode*/ -0xFF, 0x83, /* Page mode*/ -0x0B, 0x05, /* Frame Rate*/ -0x0C, 0x5E, /* Frame Rate*/ -0x03, 0x0C, /* TimeMax60Hz*/ -0x04, 0x0A, /* Time3Lux60Hz*/ -0x05, 0x06, /* Time2Lut60Hz*/ -0x06, 0x04, /* Time1Lut60Hz*/ -0xFF, 0x82, /* Page mode*/ -0x92, 0x5D, -}; - -static const u8 db8131m_vt_15fps[] = { -/* Fixed 15fps Mode */ -0xFF, 0x82, /* Page mode*/ -0x91, 0x02, /* AeMode*/ -0xFF, 0x83, /* Page mode*/ -0x0B, 0x04, /* Frame Rate*/ -0x0C, 0x4C, /* Frame Rate*/ -0x03, 0x08, /* TimeMax60Hz*/ -0x04, 0x06, /* Time3Lux60Hz*/ -0x05, 0x04, /* Time2Lut60Hz*/ -0x06, 0x04, /* Time1Lut60Hz*/ -0xFF, 0x82, /* Page mode*/ -0x92, 0x5D, - -}; - -/***************************************************/ -/* CAMERA_DTP_ON */ -/***************************************************/ -static const u8 db8131m_pattern_on[] = { -0xFF, 0x87, /* Page mode*/ -0xAB, 0x00, /* BayerFunc*/ -0xAC, 0x28, /* RGBYcFunc*/ -0xFF, 0xA0, /* Page mode*/ -0x02, 0x05, /* TPG ? Gamma*/ - -}; - -/***************************************************/ -/* CAMERA_DTP_OFF */ -/***************************************************/ -static const u8 db8131m_pattern_off[] = { -0xFF, 0x87, /* Page mode*/ -0xAB, 0xFF, /* BayerFunc*/ -0xAC, 0xFF, /* RGBYcFunc*/ -0xFF, 0xA0, /* Page mode*/ -0x02, 0x00, /* TPG Disable*/ - -}; -#endif /* __DB8131M_SETFILE_H */ diff --git a/drivers/media/video/slp_s5c73m3.c b/drivers/media/video/slp_s5c73m3.c deleted file mode 100644 index 08726d2..0000000 --- a/drivers/media/video/slp_s5c73m3.c +++ /dev/null @@ -1,3415 +0,0 @@ -/* - * driver for LSI S5C73M3 (ISP for 8MP Camera) - * - * Copyright (c) 2011, Samsung Electronics. All rights reserved - * - * 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. - * - * This program 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. - */ - -#include <linux/i2c.h> -#include <linux/init.h> -#include <media/v4l2-device.h> -#include <linux/delay.h> -#include <linux/vmalloc.h> -#include <linux/firmware.h> -#include <linux/videodev2.h> - -#include <plat/gpio-cfg.h> -#include <linux/gpio.h> - -#ifdef CONFIG_BUSFREQ_OPP -#include <mach/dev.h> -#else -#include <linux/pm_qos_params.h> -#endif - -#ifdef CONFIG_VIDEO_SAMSUNG_V4L2 -#include <linux/videodev2_exynos_media.h> -#include <linux/videodev2_exynos_camera.h> -#endif - -#include <linux/regulator/machine.h> - -#include <media/s5c73m3_platform.h> -#ifdef CONFIG_VIDEO_SLP_S5C73M3 -#include "slp_s5c73m3.h" -#else -#include "s5c73m3.h" -#endif - -#define S5C73M3_DRIVER_NAME "S5C73M3" - -extern struct class *camera_class; /*sys/class/camera*/ -struct device *s5c73m3_dev; /*sys/class/camera/rear*/ -struct v4l2_subdev *sd_internal; - -#ifdef CONFIG_BUSFREQ_OPP -struct device *bus_dev; -#else -static struct pm_qos_request_list entry = {}; -#endif - -/*#define S5C73M3_FROM_BOOTING*/ - -#ifdef CONFIG_VIDEO_SLP_S5C73M3 - -#define S5C73M3_FW_PATH "/lib/firmware/SlimISP.bin" -#define S5C73M3_FW_GC_PATH "/lib/firmware/SlimISP_GC.bin" -#define S5C73M3_FW_GD_PATH "/lib/firmware/SlimISP_GD.bin" -#define S5C73M3_FW_GE_PATH "/lib/firmware/SlimISP_GE.bin" -#define S5C73M3_FW_GF_PATH "/lib/firmware/SlimISP_GF.bin" -#define S5C73M3_FW_ZC_PATH "/lib/firmware/SlimISP_ZC.bin" -#define S5C73M3_FW_ZD_PATH "/lib/firmware/SlimISP_ZD.bin" -#define S5C73M3_FW_ZE_PATH "/lib/firmware/SlimISP_ZE.bin" -#define S5C73M3_FW_ZF_PATH "/lib/firmware/SlimISP_ZF.bin" -#define S5C73M3_FW_ZG_PATH "/lib/firmware/SlimISP_ZG.bin" - -#else /* CONFIG_VIDEO_SLP_S5C73M3 */ - -/* For Android */ -#define S5C73M3_FW_PATH "/sdcard/SlimISP.bin" - -#endif /* CONFIG_VIDEO_SLP_S5C73M3 */ - -#define S5C73M3_FW_VER_LEN 6 -#define S5C73M3_FW_VER_FILE_CUR 0x60 - -#define S5C73M3_FLASH_BASE_ADDR 0x10000000 -#define S5C73M3_INT_RAM_BASE_ADDR 0x68000000 - -#define S5C73M3_I2C_RETRY 5 -#define S5C73M3_I2C_VERIFY 100 -#define S5C73M3_ISP_TIMEOUT 3000 -#define S5C73M3_ISP_AFB_TIMEOUT 15000 /* FIXME */ -#define S5C73M3_ISP_ESD_TIMEOUT 1000 - -#define S5C73M3_JPEG_MAXSIZE 0x800000 -#define S5C73M3_YUV_MAXSIZE 0x3F4800 /*FHD*/ -#define S5C73M3_POINTER_MAXSIZE 0x10E0 /*FHD*/ - -#define S5C73M3_DEF_APEX_DEN 100 - -#define CHECK_ERR(x) if ((x) < 0) { \ - cam_err("i2c failed, err %d\n", x); \ - return x; \ - } -static const struct s5c73m3_frmsizeenum preview_frmsizes[] = { - { S5C73M3_PREVIEW_QVGA, 320, 240, 0x01 }, - { S5C73M3_PREVIEW_CIF, 352, 288, 0x0E }, - { S5C73M3_PREVIEW_VGA, 640, 480, 0x02 }, - { S5C73M3_PREVIEW_880X720, 880, 720, 0x03 }, - { S5C73M3_PREVIEW_960X720, 960, 720, 0x04 }, - { S5C73M3_PREVIEW_1008X672, 1008, 672, 0x0F }, - { S5C73M3_PREVIEW_1184X666, 1184, 666, 0x05 }, - { S5C73M3_PREVIEW_720P, 1280, 720, 0x06 }, - { S5C73M3_VDIS_720P, 1536, 864, 0x07 }, - { S5C73M3_PREVIEW_1080P, 1920, 1080, 0x0A}, - { S5C73M3_VDIS_1080P, 2304, 1296, 0x0C}, -}; - -static const struct s5c73m3_frmsizeenum capture_frmsizes[] = { - { S5C73M3_CAPTURE_VGA, 640, 480, 0x10 }, - { S5C73M3_CAPTURE_1024X768, 1024, 768, 0xD0 }, - { S5C73M3_CAPTURE_HD, 1280, 720, 0x40 }, - { S5C73M3_CAPTURE_2MP, 1600, 1200, 0x70 }, - { S5C73M3_CAPTURE_W2MP, 2048, 1152, 0x80 }, - { S5C73M3_CAPTURE_3MP, 2048, 1536, 0x90 }, - { S5C73M3_CAPTURE_W4MP, 2560, 1440, 0xA0 }, - { S5C73M3_CAPTURE_5MP, 2560, 1920, 0xB0 }, - { S5C73M3_CAPTURE_W6MP, 3264, 1836, 0xE0 }, - { S5C73M3_CAPTURE_3264X2176, 3264, 2176, 0xC0 }, - { S5C73M3_CAPTURE_8MP, 3264, 2448, 0xF0 }, -}; - -static struct s5c73m3_control s5c73m3_ctrls[] = { - /* Exposure & Scenemode stuff(ISO, Metering, Saturation, etc) */ - { - .id = V4L2_CID_CAMERA_ISO, - .minimum = ISO_AUTO, - .maximum = ISO_800, - .step = 1, - .value = ISO_AUTO, - .default_value = ISO_AUTO, - }, { - /* Capture */ - .id = V4L2_CID_CAM_JPEG_QUALITY, - .minimum = 1, - .maximum = 100, - .step = 1, - .value = 100, - .default_value = 100, - }, -#ifdef CONFIG_VIDEO_SLP_S5C73M3 - { - /* Flash */ - .id = V4L2_CID_CAMERA_FLASH_MODE, - .minimum = FLASH_MODE_OFF, - .maximum = FLASH_MODE_MAX - 1, - .step = 1, - .value = FLASH_MODE_OFF, - .default_value = FLASH_MODE_OFF, - }, { - .id = V4L2_CID_EXPOSURE, - .minimum = EV_MINUS_4, - .maximum = EV_MAX - 1, - .step = 1, - .value = EV_DEFAULT, - .default_value = EV_DEFAULT, - }, { - .id = V4L2_CID_SATURATION, - .minimum = SATURATION_MINUS_2, - .maximum = SATURATION_MAX - 1, - .step = 1, - .value = SATURATION_DEFAULT, - .default_value = SATURATION_DEFAULT, - }, { - .id = V4L2_CID_SHARPNESS, - .minimum = SHARPNESS_MINUS_2, - .maximum = SHARPNESS_MAX - 1, - .step = 1, - .value = SHARPNESS_DEFAULT, - .default_value = SHARPNESS_DEFAULT, - }, { - .id = V4L2_CID_CAMERA_METERING, - .minimum = METERING_MATRIX, - .maximum = METERING_MAX - 1, - .step = 1, - .value = METERING_MATRIX, - .default_value = METERING_MATRIX, - }, { - .id = V4L2_CID_WHITE_BALANCE_PRESET, - .minimum = WHITE_BALANCE_AUTO, - .maximum = WHITE_BALANCE_MAX - 1, - .step = 1, - .value = WHITE_BALANCE_AUTO, - .default_value = WHITE_BALANCE_AUTO, - }, { - .id = V4L2_CID_COLORFX, - .minimum = V4L2_COLORFX_NONE, - .maximum = V4L2_COLORFX_VIVID, - .step = 1, - .value = V4L2_COLORFX_NONE, - .default_value = V4L2_COLORFX_NONE, - }, { - .id = V4L2_CID_CAMERA_SCENE_MODE, - .minimum = SCENE_MODE_NONE, - .maximum = SCENE_MODE_MAX - 1, - .step = 1, - .value = SCENE_MODE_NONE, - .default_value = SCENE_MODE_MAX, - }, { - /* Zoom */ - .id = V4L2_CID_ZOOM_ABSOLUTE, - .minimum = ZOOM_LEVEL_0, - .maximum = ZOOM_LEVEL_MAX - 1, - .step = 1, - .value = ZOOM_LEVEL_0, - .default_value = ZOOM_LEVEL_0, - }, { - /* Focus */ - .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT, - .minimum = 0, - .maximum = 4000, /* FIXME */ - .step = 1, - .value = 0, - .default_value = 0, - }, { - .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP, - .minimum = 0, - .maximum = 3000, /* FIXME */ - .step = 1, - .value = 0, - .default_value = 0, - }, { - .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH, - .minimum = 0, - .maximum = 4000, /* FIXME */ - .step = 1, - .value = 0, - .default_value = 0, - }, { - .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT, - .minimum = 0, - .maximum = 3000, /* FIXME */ - .step = 1, - .value = 0, - .default_value = 0, - }, { - .id = V4L2_CID_CAMERA_FOCUS_MODE, - .minimum = FOCUS_MODE_AUTO, - .maximum = FOCUS_MODE_MAX, - .step = 1, - .value = FOCUS_MODE_AUTO, - .default_value = FOCUS_MODE_AUTO, - }, { - .id = V4L2_CID_CAMERA_SET_AUTO_FOCUS, - .minimum = 0, - .maximum = 1, - .step = 1, - .value = 0, - .default_value = 0, - }, { - .id = V4L2_CID_PHYSICAL_ROTATION, - .minimum = IS_ROTATION_0, - .maximum = IS_ROTATION_MAX - 1, - .step = 1, - .value = IS_ROTATION_90, - .default_value = IS_ROTATION_90, - }, -#else - { - .id = V4L2_CID_CAMERA_BRIGHTNESS, - .minimum = EV_MINUS_4, - .maximum = EV_MAX - 1, - .step = 1, - .value = EV_DEFAULT, - .default_value = EV_DEFAULT, - }, { - .id = V4L2_CID_CAMERA_SATURATION, - .minimum = SATURATION_MINUS_2, - .maximum = SATURATION_MAX - 1, - .step = 1, - .value = SATURATION_DEFAULT, - .default_value = SATURATION_DEFAULT, - }, { - .id = V4L2_CID_CAMERA_SHARPNESS, - .minimum = SHARPNESS_MINUS_2, - .maximum = SHARPNESS_MAX - 1, - .step = 1, - .value = SHARPNESS_DEFAULT, - .default_value = SHARPNESS_DEFAULT, - }, { - /* Zoom */ - .id = V4L2_CID_CAMERA_ZOOM, - .minimum = ZOOM_LEVEL_0, - .maximum = ZOOM_LEVEL_MAX - 1, - .step = 1, - .value = ZOOM_LEVEL_0, - .default_value = ZOOM_LEVEL_0, - }, -#endif - -}; - -static u8 sysfs_sensor_fw[10] = {0,}; -static u8 sysfs_phone_fw[10] = {0,}; -static u8 sysfs_sensor_type[15] = {0,}; -static u8 sysfs_isp_core[10] = {0,}; - -static int s5c73m3_s_stream_sensor(struct v4l2_subdev *sd, int onoff); -static int s5c73m3_set_touch_auto_focus(struct v4l2_subdev *sd); -static int s5c73m3_SPI_booting(struct v4l2_subdev *sd); -static int s5c73m3_get_af_cal_version(struct v4l2_subdev *sd); - -static inline struct s5c73m3_state *to_state(struct v4l2_subdev *sd) -{ - return container_of(sd, struct s5c73m3_state, sd); -} - -static int s5c73m3_i2c_write(struct v4l2_subdev *sd, - unsigned short addr, unsigned short data) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - struct i2c_msg msg; - unsigned char buf[4]; - int i, err; - - if (!client->adapter) - return -ENODEV; - - msg.addr = client->addr; - msg.flags = 0; - msg.len = sizeof(buf); - msg.buf = buf; - - buf[0] = addr >> 8; - buf[1] = addr & 0xff; - buf[2] = data >> 8; - buf[3] = data & 0xff; - - cam_i2c_dbg("addr %#x, data %#x\n", addr, data); - - for (i = S5C73M3_I2C_RETRY; i; i--) { - err = i2c_transfer(client->adapter, &msg, 1); - if (err == 1) - break; - msleep(20); - } - - return err; -} - -static int s5c73m3_i2c_write_block(struct v4l2_subdev *sd, - const u32 regs[], int size) -{ - int i, err = 0; - - for (i = 0; i < size; i++) { - err = s5c73m3_i2c_write(sd, (regs[i]>>16), regs[i]); - CHECK_ERR(err); - } - - return err; -} - -static int s5c73m3_i2c_read(struct v4l2_subdev *sd, - unsigned short addr, unsigned short *data) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - struct i2c_msg msg; - unsigned char buf[2]; - int i, err; - - if (!client->adapter) - return -ENODEV; - - msg.addr = client->addr; - msg.flags = 0; - msg.len = sizeof(buf); - msg.buf = buf; - - buf[0] = addr >> 8; - buf[1] = addr & 0xff; - - for (i = S5C73M3_I2C_RETRY; i; i--) { - err = i2c_transfer(client->adapter, &msg, 1); - if (err == 1) - break; - msleep(20); - } - - if (err != 1) { - cam_err("addr %#x\n", addr); - return err; - } - - msg.flags = I2C_M_RD; - - for (i = S5C73M3_I2C_RETRY; i; i--) { - err = i2c_transfer(client->adapter, &msg, 1); - if (err == 1) - break; - msleep(20); - } - - if (err != 1) { - cam_err("addr %#x\n", addr); - return err; - } - - *data = ((buf[0] << 8) | buf[1]); - - return err; -} - -static int s5c73m3_write(struct v4l2_subdev *sd, - unsigned short addr1, unsigned short addr2, unsigned short data) -{ - int err; - - err = s5c73m3_i2c_write(sd, 0x0050, addr1); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, addr2); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, data); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_read(struct v4l2_subdev *sd, - unsigned short addr1, unsigned short addr2, unsigned short *data) -{ - int err; - - err = s5c73m3_i2c_write(sd, 0xfcfc, 0x3310); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0058, addr1); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x005C, addr2); - CHECK_ERR(err); - - err = s5c73m3_i2c_read(sd, 0x0F14, data); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_i2c_check_status(struct v4l2_subdev *sd) -{ - int err = 0; - int index = 0; - u16 status = 0; - u16 i2c_status = 0; - - do { - err = s5c73m3_read(sd, 0x0009, 0x5080, &status); - if (status == 0xffff) - break; - err = s5c73m3_read(sd, 0x0009, 0x599E, &i2c_status); - if (i2c_status != 0) - cam_dbg("i2c_status = %#x\n", i2c_status); - - index++; - udelay(500); - } while (index < 2000); /* 1 sec */ - - cam_dbg("index : %d, status : %#x, i2c_stauts : %#x\n", - index, status, i2c_status); - - if (index >= 2000) - err = -1; - - return err; -} - -static int s5c73m3_writeb_no_check_status(struct v4l2_subdev *sd, - unsigned short addr, unsigned short data) -{ - int err; - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, addr); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, data); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5080); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0001); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_writeb(struct v4l2_subdev *sd, - unsigned short addr, unsigned short data) -{ - int err; - err = s5c73m3_i2c_check_status(sd); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, addr); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, data); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5080); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0001); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_set_mode(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_trace("E\n"); - - if (state->format_mode != V4L2_PIX_FMT_MODE_CAPTURE) { - if (state->hdr_mode) { - err = s5c73m3_writeb(sd, S5C73M3_IMG_OUTPUT, - S5C73M3_HDR_OUTPUT); - CHECK_ERR(err); - cam_dbg("hdr ouput mode\n"); - } else { - err = s5c73m3_writeb(sd, S5C73M3_IMG_OUTPUT, - S5C73M3_YUV_OUTPUT); - CHECK_ERR(err); - cam_dbg("yuv ouput mode\n"); - } - } else { - if (state->hybrid_mode) { - err = s5c73m3_writeb(sd, S5C73M3_IMG_OUTPUT, - S5C73M3_HYBRID_OUTPUT); - CHECK_ERR(err); - cam_dbg("hybrid ouput mode\n"); - } else { - err = s5c73m3_writeb(sd, S5C73M3_IMG_OUTPUT, - S5C73M3_INTERLEAVED_OUTPUT); - CHECK_ERR(err); - cam_dbg("interleaved ouput mode\n"); - } - } - - cam_trace("X\n"); - return 0; -} - -/* - * v4l2_subdev_core_ops - */ -static int s5c73m3_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(s5c73m3_ctrls); i++) { - if (qc->id == s5c73m3_ctrls[i].id) { - qc->maximum = s5c73m3_ctrls[i].maximum; - qc->minimum = s5c73m3_ctrls[i].minimum; - qc->step = s5c73m3_ctrls[i].step; - qc->default_value = s5c73m3_ctrls[i].default_value; - return 0; - } - } - - return -EINVAL; -} - -#ifdef CONFIG_TARGET_LOCALE_KOR -static int s5c73m3_set_antibanding(struct v4l2_subdev *sd, int val) -{ - return 0; -} -#endif - -static int s5c73m3_set_af_softlanding(struct v4l2_subdev *sd) -{ - int err = 0; - - cam_trace("E\n"); - - err = s5c73m3_writeb(sd, S5C73M3_AF_SOFTLANDING, - S5C73M3_AF_SOFTLANDING_ON); - CHECK_ERR(err); - cam_trace("X\n"); - - return 0; -} - -static int s5c73m3_dump_fw(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5c73m3_get_sensor_fw_version(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - u16 read_val; - u16 sensor_fw; - u16 sensor_type; - int i; - int err = 0; - - /*ARM go*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - udelay(400); - - /*Check boot done*/ - for (i = 0; i < 3; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x0C) - break; - - udelay(100); - } - - if (read_val != 0x0C) { - cam_err("boot fail, read_val %#x\n", read_val); - return -1; - } - - /*P,M,S and Boot Mode*/ - err = s5c73m3_write(sd, 0x3010, 0x0014, 0x2146); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3010, 0x0010, 0x230C); - CHECK_ERR(err); - - udelay(200); - - /*Check SPI ready*/ - for (i = 0; i < 300; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x230E) - break; - - udelay(100); - } - - if (read_val != 0x230E) { - cam_err("SPI not ready, read_val %#x\n", read_val); - return -1; - } - - /*ARM reset*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFD); - CHECK_ERR(err); - - /*remap*/ - err = s5c73m3_write(sd, 0x3010, 0x00A4, 0x0183); - CHECK_ERR(err); - - /*ARM go again*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - for (i = 0; i < 3; i++) { - err = s5c73m3_read(sd, 0x0000, 0x0060+i*2, &sensor_fw); - CHECK_ERR(err); - state->sensor_fw[i*2] = sensor_fw&0x00ff; - state->sensor_fw[i*2+1] = (sensor_fw&0xff00)>>8; - } - state->sensor_fw[i*2+2] = ' '; - - for (i = 0; i < 6; i++) { - err = s5c73m3_read(sd, 0x0000, 0x0066+i*2, &sensor_type); - CHECK_ERR(err); - state->sensor_type[i*2] = sensor_type&0x00ff; - state->sensor_type[i*2+1] = (sensor_type&0xff00)>>8; - } - state->sensor_type[i*2+2] = ' '; - - memcpy(sysfs_sensor_fw, state->sensor_fw, - sizeof(state->sensor_fw)); - memcpy(sysfs_sensor_type, state->sensor_type, - sizeof(state->sensor_type)); - - cam_dbg("Sensor_version = %s, Sensor_Type = %s\n", - state->sensor_fw, state->sensor_type); - - if ((state->sensor_fw[0] < 'A') || state->sensor_fw[0] > 'Z') { - cam_dbg("Sensor Version is invalid data\n"); - err = -1; - } - return err; -} - - -static int s5c73m3_get_phone_fw_version(struct v4l2_subdev *sd) -{ - struct device *dev = sd->v4l2_dev->dev; - struct s5c73m3_state *state = to_state(sd); - const struct firmware *fw = {0, }; - char fw_path[20] = {0,}; - u8 *buf = NULL; - int err = 0; - - struct file *fp; - mm_segment_t old_fs; - long nread; - int fw_requested = 1; - - buf = vmalloc(S5C73M3_FW_VER_LEN+1); - if (!buf) { - cam_err("failed to allocate memory\n"); - err = -ENOMEM; - goto out; - } - - old_fs = get_fs(); - set_fs(KERNEL_DS); - - fp = filp_open(S5C73M3_FW_PATH, O_RDONLY, 0); - if (IS_ERR(fp)) { - cam_trace("failed to open %s, err %ld\n", - S5C73M3_FW_PATH, PTR_ERR(fp)); - goto request_fw; - } - - fw_requested = 0; - err = vfs_llseek(fp, S5C73M3_FW_VER_FILE_CUR, SEEK_SET); - if (err < 0) { - cam_warn("failed to fseek, %d\n", err); - goto out; - } - - nread = vfs_read(fp, (char __user *)buf, - S5C73M3_FW_VER_LEN, - &fp->f_pos); - - if (nread != S5C73M3_FW_VER_LEN) { - cam_err("failed to read firmware file, %ld Bytes\n", nread); - err = -EIO; - goto out; - } - -request_fw: - if (fw_requested) { - set_fs(old_fs); - - if (state->sensor_fw[0] == 'O') { - sprintf(fw_path, "SlimISP_G%c.bin", - state->sensor_fw[1]); - } else if (state->sensor_fw[0] == 'S') { - sprintf(fw_path, "SlimISP_Z%c.bin", - state->sensor_fw[1]); - } else { - sprintf(fw_path, "SlimISP_%c%c.bin", - state->sensor_fw[0], - state->sensor_fw[1]); - } - cam_dbg("file_name = %s\n", fw_path); - - err = request_firmware(&fw, fw_path, dev); - if (err != 0) { - cam_err("request_firmware falied\n"); - err = -EINVAL; - goto out; - } - - memcpy(buf, (u8 *)&fw->data[S5C73M3_FW_VER_FILE_CUR], - S5C73M3_FW_VER_LEN); - - } - - memcpy(state->phone_fw, buf, S5C73M3_FW_VER_LEN); - state->phone_fw[S5C73M3_FW_VER_LEN+1] = ' '; - - memcpy(sysfs_phone_fw, state->phone_fw, sizeof(state->phone_fw)); - cam_dbg("Phone_version = %s\n", state->phone_fw); - - cam_dbg("end\n"); - -out: - if (!fw_requested) { - vfree(buf); - - filp_close(fp, current->files); - set_fs(old_fs); - } else { - release_firmware(fw); - } - - return err; -} - -static int s5c73m3_update_camerafw_to_FROM(struct v4l2_subdev *sd) -{ - int err; - int index = 0; - u16 status = 0; - - do { - /* stauts 0 : not ready ISP */ - if (status == 0) { - err = s5c73m3_writeb(sd, 0x0906, 0x0000); - CHECK_ERR(err); - } - - err = s5c73m3_read(sd, 0x0009, 0x5906, &status); - /* Success : 0x05, Fail : 0x07 , Progressing : 0xFFFF*/ - if (status == 0x0005 || - status == 0x0007) - break; - - index++; - msleep(20); - } while (index < 500); /* 10 sec */ - - - if (status == 0x0007) - return -1; - else - return 0; -} - -static int s5c73m3_check_fw(struct v4l2_subdev *sd, int download) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - - if (download) { - err = state->pdata->is_isp_reset(); - CHECK_ERR(err); - } - - err = s5c73m3_get_sensor_fw_version(sd); - err = s5c73m3_get_phone_fw_version(sd); - - if (state->phone_fw[0] == 'Z' || state->phone_fw[0] == 'G' || - state->phone_fw[0] == 'S' || state->phone_fw[0] == 'O') { - err = state->pdata->is_isp_reset(); - CHECK_ERR(err); - - err = s5c73m3_SPI_booting(sd); - CHECK_ERR(err); - - if (download) { - err = s5c73m3_update_camerafw_to_FROM(sd); - CHECK_ERR(err); - } - } - s5c73m3_get_af_cal_version(sd); - return 0; -} - -static int s5c73m3_set_sensor_mode(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case SENSOR_CAMERA: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_AUTO_MODE_AE_SET); - CHECK_ERR(err); - break; - - case SENSOR_MOVIE: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_FIXED_30FPS); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = SENSOR_CAMERA; - goto retry; - } - state->sensor_mode = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_flash(struct v4l2_subdev *sd, int val, int recording) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case FLASH_MODE_OFF: - err = s5c73m3_writeb(sd, S5C73M3_FLASH_MODE, - S5C73M3_FLASH_MODE_OFF); - CHECK_ERR(err); - err = s5c73m3_writeb(sd, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_OFF); - CHECK_ERR(err); - break; - - case FLASH_MODE_AUTO: - err = s5c73m3_writeb(sd, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_OFF); - CHECK_ERR(err); - err = s5c73m3_writeb(sd, S5C73M3_FLASH_MODE, - S5C73M3_FLASH_MODE_AUTO); - CHECK_ERR(err); - break; - - case FLASH_MODE_ON: - err = s5c73m3_writeb(sd, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_OFF); - CHECK_ERR(err); - err = s5c73m3_writeb(sd, S5C73M3_FLASH_MODE, - S5C73M3_FLASH_MODE_ON); - CHECK_ERR(err); - break; - - case FLASH_MODE_TORCH: - err = s5c73m3_writeb(sd, S5C73M3_FLASH_MODE, - S5C73M3_FLASH_MODE_OFF); - CHECK_ERR(err); - err = s5c73m3_writeb(sd, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_ON); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = FLASH_MODE_OFF; - goto retry; - } - state->flash_mode = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_iso(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - int err; - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", ctrl->value); - -retry: - switch (ctrl->value) { - case ISO_AUTO: - err = s5c73m3_writeb(sd, S5C73M3_ISO, - S5C73M3_ISO_AUTO); - CHECK_ERR(err); - break; - - case ISO_50: - case ISO_100: - err = s5c73m3_writeb(sd, S5C73M3_ISO, - S5C73M3_ISO_100); - CHECK_ERR(err); - break; - - case ISO_200: - err = s5c73m3_writeb(sd, S5C73M3_ISO, - S5C73M3_ISO_200); - CHECK_ERR(err); - break; - - case ISO_400: - err = s5c73m3_writeb(sd, S5C73M3_ISO, - S5C73M3_ISO_400); - CHECK_ERR(err); - break; - - case ISO_800: - err = s5c73m3_writeb(sd, S5C73M3_ISO, - S5C73M3_ISO_800); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", ctrl->value); - ctrl->value = ISO_AUTO; - goto retry; - } - - state->exif.iso = ctrl->value; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_metering(struct v4l2_subdev *sd, int val) -{ - int err; - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case METERING_CENTER: - err = s5c73m3_writeb(sd, S5C73M3_METER, - S5C73M3_METER_CENTER); - CHECK_ERR(err); - break; - - case METERING_SPOT: - err = s5c73m3_writeb(sd, S5C73M3_METER, - S5C73M3_METER_SPOT); - CHECK_ERR(err); - break; - - case METERING_MATRIX: - err = s5c73m3_writeb(sd, S5C73M3_METER, - S5C73M3_METER_AVERAGE); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = METERING_CENTER; - goto retry; - } - - state->exif.metering = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_exposure(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - int err; - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", ctrl->value); - - if (ctrl->value < -4 || ctrl->value > 4) { - cam_warn("invalid value, %d\n", ctrl->value); - ctrl->value = 0; - } - err = s5c73m3_writeb(sd, S5C73M3_EV, - ctrl->value + 4); - CHECK_ERR(err); - - state->exif.bv = ctrl->value; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_contrast(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - int err; - int contrast = 0; - cam_dbg("E, value %d\n", ctrl->value); - - if (ctrl->value < -2 || ctrl->value > 2) { - cam_warn("invalid value, %d\n", ctrl->value); - ctrl->value = 0; - } - if (ctrl->value < 0) - contrast = (ctrl->value * (-1)) + 2; - else - contrast = ctrl->value; - err = s5c73m3_writeb(sd, S5C73M3_CONTRAST, - contrast); - CHECK_ERR(err); - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_whitebalance(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case WHITE_BALANCE_AUTO: - err = s5c73m3_writeb(sd, S5C73M3_AWB_MODE, - S5C73M3_AWB_MODE_AUTO); - CHECK_ERR(err); - break; - - case WHITE_BALANCE_SUNNY: - err = s5c73m3_writeb(sd, S5C73M3_AWB_MODE, - S5C73M3_AWB_MODE_DAYLIGHT); - CHECK_ERR(err); - break; - - case WHITE_BALANCE_CLOUDY: - err = s5c73m3_writeb(sd, S5C73M3_AWB_MODE, - S5C73M3_AWB_MODE_CLOUDY); - CHECK_ERR(err); - break; - - case WHITE_BALANCE_TUNGSTEN: - err = s5c73m3_writeb(sd, S5C73M3_AWB_MODE, - S5C73M3_AWB_MODE_INCANDESCENT); - CHECK_ERR(err); - break; - - case WHITE_BALANCE_FLUORESCENT: - err = s5c73m3_writeb(sd, S5C73M3_AWB_MODE, - S5C73M3_AWB_MODE_FLUORESCENT1); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = WHITE_BALANCE_AUTO; - goto retry; - } - - state->wb_mode = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_sharpness(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", ctrl->value); - - cam_err("Sharpness control is not supported\n"); - - state->exif.sharpness = ctrl->value; - - return 0; -} - -static int s5c73m3_set_saturation(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", ctrl->value); - - cam_err("Saturation control is not supported\n"); - - state->exif.saturation = ctrl->value; - - return 0; -} - -static int s5c73m3_set_scene_mode(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case SCENE_MODE_NONE: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_NONE); - CHECK_ERR(err); - break; - - case SCENE_MODE_PORTRAIT: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_PORTRAIT); - CHECK_ERR(err); - break; - - case SCENE_MODE_LANDSCAPE: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_LANDSCAPE); - CHECK_ERR(err); - break; - - case SCENE_MODE_SPORTS: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_SPORTS); - CHECK_ERR(err); - break; - - case SCENE_MODE_PARTY_INDOOR: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_INDOOR); - CHECK_ERR(err); - break; - - case SCENE_MODE_BEACH_SNOW: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_BEACH); - CHECK_ERR(err); - break; - - case SCENE_MODE_SUNSET: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_SUNSET); - CHECK_ERR(err); - break; - - case SCENE_MODE_DUSK_DAWN: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_DAWN); - CHECK_ERR(err); - break; - - case SCENE_MODE_FALL_COLOR: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_FALL); - CHECK_ERR(err); - break; - - case SCENE_MODE_NIGHTSHOT: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_NIGHT); - CHECK_ERR(err); - break; - - case SCENE_MODE_BACK_LIGHT: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_AGAINSTLIGHT); - CHECK_ERR(err); - break; - - case SCENE_MODE_FIREWORKS: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_FIRE); - CHECK_ERR(err); - break; - - case SCENE_MODE_TEXT: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_TEXT); - CHECK_ERR(err); - break; - - case SCENE_MODE_CANDLE_LIGHT: - err = s5c73m3_writeb(sd, S5C73M3_SCENE_MODE, - S5C73M3_SCENE_MODE_CANDLE); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = SCENE_MODE_NONE; - goto retry; - } - - state->scene_mode = val; - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_capture_firework(struct v4l2_subdev *sd) -{ - int err = 0; - - cam_dbg("E, capture_firework\n"); - - err = s5c73m3_writeb(sd, S5C73M3_FIREWORK_CAPTURE, 0x0001); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_set_effect(struct v4l2_subdev *sd, int val) -{ - int err; - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case IMAGE_EFFECT_NONE: - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_EFFECT, - S5C73M3_IMAGE_EFFECT_NONE); - CHECK_ERR(err); - break; - - case IMAGE_EFFECT_SEPIA: - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_EFFECT, - S5C73M3_IMAGE_EFFECT_SEPIA); - CHECK_ERR(err); - break; - - case IMAGE_EFFECT_BNW: - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_EFFECT, - S5C73M3_IMAGE_EFFECT_MONO); - CHECK_ERR(err); - break; - - case IMAGE_EFFECT_NEGATIVE: - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_EFFECT, - S5C73M3_IMAGE_EFFECT_NEGATIVE); - CHECK_ERR(err); - break; - - case IMAGE_EFFECT_AQUA: - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_EFFECT, - S5C73M3_IMAGE_EFFECT_AQUA); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = IMAGE_EFFECT_NONE; - goto retry; - } - - state->exif.effect = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_wdr(struct v4l2_subdev *sd, int val) -{ - int err; - struct s5c73m3_state *state = to_state(sd); - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case WDR_OFF: - err = s5c73m3_writeb(sd, S5C73M3_WDR, - S5C73M3_WDR_OFF); - CHECK_ERR(err); - break; - - case WDR_ON: - err = s5c73m3_writeb(sd, S5C73M3_WDR, - S5C73M3_WDR_ON); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = WDR_OFF; - goto retry; - } - state->exif.wdr = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_antishake(struct v4l2_subdev *sd, int val) -{ - int err = 0; - if (val) { - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_ANTI_SHAKE); - CHECK_ERR(err); - } else { - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_AUTO_MODE_AE_SET); - CHECK_ERR(err); - } - return err; -} - -static int s5c73m3_set_face_beauty(struct v4l2_subdev *sd, int val) -{ - return 0; -} - -static int s5c73m3_set_ae_lock(struct v4l2_subdev *sd, int val) -{ - int err; - - if (val) - err = s5c73m3_writeb(sd, S5C73M3_AE_CON, S5C73M3_AE_STOP); - else - err = s5c73m3_writeb(sd, S5C73M3_AE_CON, S5C73M3_AE_START); - - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_set_awb_lock(struct v4l2_subdev *sd, int val) -{ - int err; - - if (val) - err = s5c73m3_writeb(sd, S5C73M3_AWB_CON, S5C73M3_AWB_STOP); - else - err = s5c73m3_writeb(sd, S5C73M3_AWB_CON, S5C73M3_AWB_START); - - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_set_ae_awb_lock(struct v4l2_subdev *sd, int val) -{ - return 0; -} - -static int s5c73m3_get_af_cal_version(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - u16 status = 0; - int err = 0; - - /* Calibration Device */ - err = s5c73m3_read(sd, 0x0009, 0x300C, &status); - CHECK_ERR(err); - state->cal_device = status; - - /* Calibration DLL Version */ - status = 0; - err = s5c73m3_read(sd, 0x0009, 0x4FF8, &status); - CHECK_ERR(err); - state->cal_dll = status; - - cam_dbg("Cal_Device = 0x%x, Cal_DLL = 0x%x\n", - state->cal_device, state->cal_dll); - - return 0; -} - -static int s5c73m3_stop_af_lens(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value\n"); - - if (val == CAF_START) { - if (state->focus.mode == FOCUS_MODE_CONTINOUS_VIDEO) { - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_MOVIE_CAF_START); - - } else { - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_PREVIEW_CAF_START); - } - } else { - err = s5c73m3_writeb(sd, S5C73M3_AF_CON, - S5C73M3_AF_CON_STOP); - } - CHECK_ERR(err); - - cam_dbg("X\n"); - - return err; -} - -static int s5c73m3_set_af(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - - cam_info("%s, mode %#x\n", val ? "start" : "stop", state->focus.mode); - - state->focus.status = 0; - - if (val) { - state->isflash = S5C73M3_ISNEED_FLASH_ON; - - if (state->focus.mode == FOCUS_MODE_TOUCH) - err = s5c73m3_set_touch_auto_focus(sd); - else - err = s5c73m3_writeb(sd, S5C73M3_AF_CON, - S5C73M3_AF_CON_START); - } else { - err = s5c73m3_writeb(sd, S5C73M3_STILL_MAIN_FLASH - , S5C73M3_STILL_MAIN_FLASH_CANCEL); - err = s5c73m3_writeb(sd, S5C73M3_AF_CON, - S5C73M3_AF_CON_STOP); - state->isflash = S5C73M3_ISNEED_FLASH_UNDEFINED; - } - - CHECK_ERR(err); - - cam_info("X\n"); - return err; -} - -static int s5c73m3_get_pre_flash(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - int err = 0; - u16 pre_flash = false; - - s5c73m3_read(sd, 0x0009, S5C73M3_STILL_PRE_FLASH | 0x5000, &pre_flash); - ctrl->value = pre_flash; - return err; -} - -static int s5c73m3_get_af_result(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - u16 af_status = S5C73M3_AF_STATUS_UNFOCUSED; - /*u16 temp_status = 0;*/ - - err = s5c73m3_read(sd, 0x0009, S5C73M3_AF_STATUS, &af_status); - - /*err = s5c73m3_read(sd, 0x0009, 0x5840, &temp_status);*/ - - switch (af_status) { - case S5C73M3_AF_STATUS_FOCUSING: - case S5C73M3_CAF_STATUS_FOCUSING: - case S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR: - case S5C73M3_AF_STATUS_INVALID: - ctrl->value = CAMERA_AF_STATUS_IN_PROGRESS; - break; - - case S5C73M3_AF_STATUS_FOCUSED: - case S5C73M3_CAF_STATUS_FOCUSED: - ctrl->value = CAMERA_AF_STATUS_SUCCESS; - break; - - case S5C73M3_CAF_STATUS_UNFOCUSED: - case S5C73M3_AF_STATUS_UNFOCUSED: - default: - ctrl->value = CAMERA_AF_STATUS_FAIL; - break; - } - state->focus.status = af_status; - - /*cam_dbg("af_status = %d, frame_cnt = %d\n", - state->focus.status, temp_status);*/ - return err; -} - -static int s5c73m3_set_af_mode(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case FOCUS_MODE_AUTO: - case FOCUS_MODE_INFINITY: - if (state->focus.mode != FOCUS_MODE_CONTINOUS_PICTURE) { - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_NORMAL); - CHECK_ERR(err); - } else { - err = s5c73m3_writeb(sd, S5C73M3_AF_CON, - S5C73M3_AF_CON_STOP); - CHECK_ERR(err); - } - - state->focus.mode = val; - state->caf_mode = S5C73M3_AF_MODE_NORMAL; - break; - - case FOCUS_MODE_MACRO: - if (state->focus.mode != FOCUS_MODE_CONTINOUS_PICTURE_MACRO) { - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_MACRO); - CHECK_ERR(err); - } else { - err = s5c73m3_writeb(sd, S5C73M3_AF_CON, - S5C73M3_AF_CON_STOP); - CHECK_ERR(err); - } - - state->focus.mode = val; - state->caf_mode = S5C73M3_AF_MODE_MACRO; - break; - - case FOCUS_MODE_CONTINOUS_PICTURE: - state->isflash = S5C73M3_ISNEED_FLASH_UNDEFINED; - - if (val != state->focus.mode && - state->caf_mode != S5C73M3_AF_MODE_NORMAL) { - state->focus.mode = val; - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_NORMAL); - CHECK_ERR(err); - state->caf_mode = S5C73M3_AF_MODE_NORMAL; - } - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_PREVIEW_CAF_START); - CHECK_ERR(err); - break; - - case FOCUS_MODE_CONTINOUS_PICTURE_MACRO: - state->isflash = S5C73M3_ISNEED_FLASH_UNDEFINED; - if (val != state->focus.mode && - state->caf_mode != S5C73M3_AF_MODE_MACRO) { - state->focus.mode = val; - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_MACRO); - state->caf_mode = S5C73M3_AF_MODE_MACRO; - CHECK_ERR(err); - } - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_PREVIEW_CAF_START); - CHECK_ERR(err); - break; - - case FOCUS_MODE_CONTINOUS_VIDEO: - state->focus.mode = val; - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_MOVIE_CAF_START); - CHECK_ERR(err); - break; - - case FOCUS_MODE_FACEDETECT: - state->focus.mode = val; - break; - - case FOCUS_MODE_TOUCH: - state->focus.mode = val; - break; - - default: - cam_warn("invalid value, %d\n", val); - val = FOCUS_MODE_AUTO; - goto retry; - } - - state->focus.mode = val; - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_touch_auto_focus(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - - cam_dbg("s5c73m3_set_touch_auto_focus\n"); - -#ifdef CONFIG_VIDEO_SLP_S5C73M3 - cam_dbg("Rectangle Position(%d,%d,%d,%d)\n", - state->focus.top, state->focus.left, - state->focus.width, state->focus.height); - state->focus.pos_x = state->focus.left + state->focus.width / 2; - state->focus.pos_y = state->focus.top + state->focus.height / 2; -#endif - cam_dbg("Touch Position(%d,%d)\n", - state->focus.pos_x, state->focus.pos_y); - cam_dbg("Preview Size(%d,%d)\n", - state->preview->width, state->preview->height); - - err = s5c73m3_i2c_write(sd, 0xfcfc, 0x3310); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, S5C73M3_AF_TOUCH_POSITION); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->focus.pos_x); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->focus.pos_y); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->preview->width); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->preview->height); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0E0A); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5080); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0001); - CHECK_ERR(err); - - return 0; -} - -static int s5c73m3_set_zoom(struct v4l2_subdev *sd, int value) -{ - int err; - cam_dbg("E, value %d\n", value); - -retry: - if (value < 0 || value > 30) { - cam_warn("invalid value, %d\n", value); - value = 0; - goto retry; - } - err = s5c73m3_writeb_no_check_status(sd, S5C73M3_ZOOM_STEP, - value); - CHECK_ERR(err); - mdelay(10); - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_set_jpeg_quality(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - int val = ctrl->value, err; - cam_dbg("E, value %d\n", val); - - if (val <= 65) /* Normal */ - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_QUALITY, - S5C73M3_IMAGE_QUALITY_NORMAL); - else if (val <= 75) /* Fine */ - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_QUALITY, - S5C73M3_IMAGE_QUALITY_FINE); - else /* Superfine */ - err = s5c73m3_writeb(sd, S5C73M3_IMAGE_QUALITY, - S5C73M3_IMAGE_QUALITY_SUPERFINE); - - CHECK_ERR(err); - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_get_exif(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5c73m3_aeawb_lock_unlock(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - int ae_lock = val & 0x1; - int awb_lock = (val & 0x2) >> 1; - int ae_lock_changed = - ~(ae_lock & state->ae_lock) & (ae_lock | state->ae_lock); - int awb_lock_changed = - ~(awb_lock & state->awb_lock) & (awb_lock | state->awb_lock); - - if (ae_lock_changed) { - cam_dbg("ae lock - %s\n", ae_lock ? "true" : "false"); - err = s5c73m3_writeb(sd, S5C73M3_AE_CON, - ae_lock ? S5C73M3_AE_STOP : S5C73M3_AE_START); - CHECK_ERR(err); - state->ae_lock = ae_lock; - } - if (awb_lock_changed && - state->wb_mode == WHITE_BALANCE_AUTO) { - cam_dbg("awb lock - %s\n", awb_lock ? "true" : "false"); - err = s5c73m3_writeb(sd, S5C73M3_AWB_CON, - awb_lock ? S5C73M3_AWB_STOP : S5C73M3_AWB_START); - CHECK_ERR(err); - state->awb_lock = awb_lock; - } - - return 0; -} - -static int s5c73m3_start_capture(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - u16 isneed_flash = false; - u16 pre_flash = false; - - s5c73m3_read(sd, 0x0009, S5C73M3_STILL_PRE_FLASH | 0x5000, &pre_flash); - - if (state->flash_mode == FLASH_MODE_ON) { - if (!pre_flash) { - err = s5c73m3_writeb(sd, S5C73M3_STILL_PRE_FLASH - , S5C73M3_STILL_PRE_FLASH_FIRE); - msleep(100); - } - err = s5c73m3_writeb(sd, S5C73M3_STILL_MAIN_FLASH - , S5C73M3_STILL_MAIN_FLASH_FIRE); - } else if (state->flash_mode == FLASH_MODE_AUTO) { - if (pre_flash) { - err = s5c73m3_writeb(sd, S5C73M3_STILL_MAIN_FLASH - , S5C73M3_STILL_MAIN_FLASH_FIRE); - } else if (state->isflash != S5C73M3_ISNEED_FLASH_ON) { - err = s5c73m3_read(sd, 0x0009, - S5C73M3_AE_ISNEEDFLASH | 0x5000, &isneed_flash); - if (isneed_flash) { - err = s5c73m3_writeb(sd, S5C73M3_STILL_PRE_FLASH - , S5C73M3_STILL_PRE_FLASH_FIRE); - msleep(100); - err = s5c73m3_writeb(sd, - S5C73M3_STILL_MAIN_FLASH, - S5C73M3_STILL_MAIN_FLASH_FIRE); - } - } - } - - state->isflash = S5C73M3_ISNEED_FLASH_UNDEFINED; - - return 0; -} - -static int s5c73m3_set_auto_bracket_mode(struct v4l2_subdev *sd) -{ - int err = 0; - - err = s5c73m3_writeb(sd, S5C73M3_AE_AUTO_BRAKET, - S5C73M3_AE_AUTO_BRAKET_EV20); - CHECK_ERR(err); - - return err; -} - -static int s5c73m3_check_dataline(struct v4l2_subdev *sd, int val) -{ - return 0; -} - -static int s5c73m3_check_esd(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5c73m3_set_frame_rate(struct v4l2_subdev *sd, int fps) -{ - int err = 0; - struct s5c73m3_state *state = to_state(sd); - - if (!state->stream_enable) { - state->fps = fps; - return 0; - } - - switch (fps) { - case 30: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_FIXED_30FPS); /* 30fps */ - break; - case 20: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_FIXED_20FPS); /* 20fps */ - break; - case 15: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_FIXED_15FPS); /* 15fps */ - break; - default: - err = s5c73m3_writeb(sd, S5C73M3_AE_MODE, - S5C73M3_AUTO_MODE_AE_SET); /* auto */ - break; - } - return err; -} - -static int s5c73m3_set_face_zoom(struct v4l2_subdev *sd, int val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - - cam_dbg("s5c73m3_set_face_zoom\n"); -#ifdef CONFIG_VIDEO_SLP_S5C73M3 - cam_dbg("Rectangle Position(%d,%d,%d,%d)\n", - state->focus.top, state->focus.left, - state->focus.width, state->focus.height); - state->focus.pos_x = state->focus.left + state->focus.width / 2; - state->focus.pos_y = state->focus.top + state->focus.height / 2; -#endif - cam_dbg("Touch Position(%d,%d)\n", - state->focus.pos_x, state->focus.pos_y); - cam_dbg("Preview Size(%d,%d)\n", - state->preview->width, state->preview->height); - - err = s5c73m3_i2c_write(sd, 0xfcfc, 0x3310); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, S5C73M3_AF_TOUCH_POSITION); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->focus.pos_x); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->focus.pos_y); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->preview->width); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, state->preview->height); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, S5C73M3_AF_FACE_ZOOM); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, val); /*0:reset, 1:Start*/ - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5080); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0001); - CHECK_ERR(err); - - return 0; -} - - -static int s5c73m3_set_face_detection(struct v4l2_subdev *sd, int val) -{ - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case FACE_DETECTION_ON: - err = s5c73m3_writeb(sd, S5C73M3_FACE_DET, - S5C73M3_FACE_DET_ON); - CHECK_ERR(err); - - err = s5c73m3_writeb(sd, S5C73M3_AF_MODE, - S5C73M3_AF_MODE_PREVIEW_CAF_START); - CHECK_ERR(err); - - break; - - case FACE_DETECTION_OFF: - err = s5c73m3_writeb(sd, S5C73M3_FACE_DET, - S5C73M3_FACE_DET_OFF); - CHECK_ERR(err); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = FACE_DETECTION_OFF; - goto retry; - } - - cam_trace("X\n"); - return 0; - -} - -static int s5c73m3_set_hybrid_capture(struct v4l2_subdev *sd) -{ - int err; - cam_trace("E\n"); - - err = s5c73m3_writeb(sd, S5C73M3_HYBRID_CAPTURE, 1); - - CHECK_ERR(err); - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - - if (unlikely(state->isp.bad_fw && ctrl->id != V4L2_CID_CAM_UPDATE_FW)) { - cam_err("\"Unknown\" state, please update F/W"); - return -ENOSYS; - } - - switch (ctrl->id) { - case V4L2_CID_CAMERA_FRAME_RATE: - err = s5c73m3_set_frame_rate(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_FACE_DETECTION: - err = s5c73m3_set_face_detection(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_FACE_ZOOM: - err = s5c73m3_set_face_zoom(sd, ctrl->value); - break; - - case V4L2_CID_CAM_UPDATE_FW: - if (ctrl->value == FW_MODE_DUMP) - err = s5c73m3_dump_fw(sd); - else if (ctrl->value == FW_MODE_UPDATE) - err = s5c73m3_check_fw(sd, 1); - else - err = 0; - break; - - case V4L2_CID_CAMERA_SENSOR_MODE: - err = s5c73m3_set_sensor_mode(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_FLASH_MODE: - err = s5c73m3_set_flash(sd, ctrl->value, 0); - break; - - case V4L2_CID_CAMERA_ISO: - err = s5c73m3_set_iso(sd, ctrl); - break; - - case V4L2_CID_CAMERA_METERING: - if (state->sensor_mode == SENSOR_CAMERA) - err = s5c73m3_set_metering(sd, ctrl->value); - break; - - case V4L2_CID_EXPOSURE: - ctrl->value -= 4; - err = s5c73m3_set_exposure(sd, ctrl); - break; - - case V4L2_CID_CAMERA_BRIGHTNESS: - err = s5c73m3_set_exposure(sd, ctrl); - break; - - case V4L2_CID_CAMERA_CONTRAST: - err = s5c73m3_set_contrast(sd, ctrl); - break; - - case V4L2_CID_WHITE_BALANCE_PRESET: - err = s5c73m3_set_whitebalance(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_WHITE_BALANCE: - err = s5c73m3_set_whitebalance(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_SCENE_MODE: - err = s5c73m3_set_scene_mode(sd, ctrl->value); - break; - - case V4L2_CID_COLORFX: - err = s5c73m3_set_effect(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_EFFECT: - err = s5c73m3_set_effect(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_WDR: - err = s5c73m3_set_wdr(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_ANTI_SHAKE: - err = s5c73m3_set_antishake(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_BEAUTY_SHOT: - err = s5c73m3_set_face_beauty(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_DEFAULT_FOCUS_POSITION: - /*err = s5c73m3_set_af_mode(sd, state->focus.mode);*/ - err = 0; - break; - - case V4L2_CID_FOCUS_AUTO_MODE: - err = s5c73m3_set_af_mode(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_FOCUS_MODE: - err = s5c73m3_set_af_mode(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_SET_AUTO_FOCUS: - err = s5c73m3_set_af(sd, ctrl->value); - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT: - state->focus.left = ctrl->value; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP: - state->focus.top = ctrl->value; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH: - state->focus.width = ctrl->value; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT: - state->focus.height = ctrl->value; - break; - - case V4L2_CID_CAMERA_OBJECT_POSITION_X: - state->focus.pos_x = ctrl->value; - break; - - case V4L2_CID_CAMERA_OBJECT_POSITION_Y: - state->focus.pos_y = ctrl->value; - break; - - case V4L2_CID_CAMERA_ZOOM: - err = s5c73m3_set_zoom(sd, ctrl->value); - break; - - case V4L2_CID_CAM_JPEG_QUALITY: - err = s5c73m3_set_jpeg_quality(sd, ctrl); - break; - - case V4L2_CID_CAMERA_CAPTURE: - err = s5c73m3_start_capture(sd, ctrl->value); - - if (state->scene_mode == SCENE_MODE_FIREWORKS) - err = s5c73m3_capture_firework(sd); - break; - - case V4L2_CID_CAMERA_HDR: - state->hdr_mode = ctrl->value; - err = 0; - break; - - case V4L2_CID_CAMERA_HYBRID: - state->hybrid_mode = ctrl->value; - err = 0; - break; - - case V4L2_CID_CAMERA_HYBRID_CAPTURE: - err = s5c73m3_set_hybrid_capture(sd); - break; - - case V4L2_CID_CAMERA_VT_MODE: - state->vt_mode = ctrl->value; - break; - - case V4L2_CID_CAMERA_CHECK_DATALINE: - state->check_dataline = ctrl->value; - break; - - case V4L2_CID_CAMERA_CHECK_ESD: - err = s5c73m3_check_esd(sd); - break; - - case V4L2_CID_CAMERA_JPEG_RESOLUTION: - state->jpeg_width = (u32)ctrl->value >> 16; - state->jpeg_height = (u32)ctrl->value & 0x0FFFF; - break; - - case V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK: - err = s5c73m3_aeawb_lock_unlock(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_CAF_START_STOP: - err = s5c73m3_stop_af_lens(sd, ctrl->value); - break; - - case V4L2_CID_SATURATION: - err = s5c73m3_set_saturation(sd, ctrl); - break; - - case V4L2_CID_SHARPNESS: - err = s5c73m3_set_sharpness(sd, ctrl); - break; - - default: - if ((ctrl->id & 0xFFFF) <= 2000) { - cam_err("no such control id(PRIVATE_BASE) %d, value %d\n", - ctrl->id & 0xFFFF, ctrl->value); - /*err = -ENOIOCTLCMD;*/ - } else if ((ctrl->id - V4L2_CID_BASE) <= 10000) { - cam_err("no such control id(BASE_CID) %d\n", - ctrl->id - V4L2_CID_BASE); - } else { - cam_err("no such control id(CAMERA_CLASS_BASE CID) %d\n", - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE); - } - err = 0; - break; - } - - if (err < 0 && err != -ENOIOCTLCMD) - cam_err("failed, id %d, value %d\n", - ctrl->id - V4L2_CID_PRIVATE_BASE, ctrl->value); - return err; -} - -static int s5c73m3_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - - switch (ctrl->id) { - case V4L2_CID_CAMERA_CAPTURE: - err = s5c73m3_get_pre_flash(sd, ctrl); - break; - case V4L2_CID_CAMERA_AUTO_FOCUS_RESULT: - err = s5c73m3_get_af_result(sd, ctrl); - break; - - case V4L2_CID_CAM_JPEG_MEMSIZE: - ctrl->value = 0xA00000; - break; - - case V4L2_CID_CAM_JPEG_MAIN_SIZE: - ctrl->value = state->jpeg.main_size; - break; - - case V4L2_CID_CAM_JPEG_MAIN_OFFSET: - ctrl->value = state->jpeg.main_offset; - break; - - case V4L2_CID_CAM_JPEG_THUMB_SIZE: - ctrl->value = state->jpeg.thumb_size; - break; - - case V4L2_CID_CAM_JPEG_THUMB_OFFSET: - ctrl->value = state->jpeg.thumb_offset; - break; - - case V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET: - ctrl->value = state->jpeg.postview_offset; - break; - - case V4L2_CID_CAMERA_EXIF_FLASH: - ctrl->value = state->exif.flash; - break; - - case V4L2_CID_CAMERA_ISO: - ctrl->value = state->exif.iso; - break; - - case V4L2_CID_CAMERA_EXIF_ISO: - ctrl->value = state->exif.iso; - break; - - case V4L2_CID_CAMERA_EXIF_TV: - ctrl->value = state->exif.tv; - break; - - case V4L2_CID_CAMERA_EXIF_BV: - ctrl->value = state->exif.bv; - break; - - case V4L2_CID_CAMERA_EXIF_EBV: - ctrl->value = state->exif.ebv; - break; - - case V4L2_CID_WHITE_BALANCE_PRESET: - ctrl->value = state->wb_mode; - break; - - case V4L2_CID_EXPOSURE: - ctrl->value = state->exif.bv; - break; - - case V4L2_CID_COLORFX: - ctrl->value = state->exif.effect; - break; - - case V4L2_CID_SATURATION: - ctrl->value = state->exif.saturation; - break; - - case V4L2_CID_SHARPNESS: - ctrl->value = state->exif.sharpness; - break; - - case V4L2_CID_CAMERA_METERING: - ctrl->value = state->exif.metering; - break; - - case V4L2_CID_CAMERA_WDR: - ctrl->value = state->exif.wdr; - break; - - case V4L2_CID_CAMERA_FLASH_MODE: - ctrl->value = state->flash_mode; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT: - ctrl->value = state->focus.left; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP: - ctrl->value = state->focus.top; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH: - ctrl->value = state->focus.width; - break; - - case V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT: - ctrl->value = state->focus.height; - break; - - case V4L2_CID_CAM_STABILIZE: - cam_err("V4L2_CID_CAM_STABILIZE is not supported\n"); - break; - - case V4L2_CID_PHYSICAL_ROTATION: - ctrl->value = IS_ROTATION_90; - break; - - default: - if ((ctrl->id & 0xFFFF) <= 2000) { - cam_err("no such control id(PRIVATE_BASE) %d, value %d\n", - ctrl->id & 0xFFFF, ctrl->value); - /*err = -ENOIOCTLCMD;*/ - } else if ((ctrl->id - V4L2_CID_BASE) <= 10000) { - cam_err("no such control id(BASE_CID) %d\n", - ctrl->id - V4L2_CID_BASE); - } else { - cam_err("no such control id(CAMERA_CLASS_BASE CID) %d\n", - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE); - } - err = 0; - break; - } - - if (err < 0 && err != -ENOIOCTLCMD) - cam_err("failed, id %d\n", ctrl->id - V4L2_CID_PRIVATE_BASE); - - return err; -} - - -static int s5c73m3_g_ext_ctrl(struct v4l2_subdev *sd, - struct v4l2_ext_control *ctrl) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - - switch (ctrl->id) { - case V4L2_CID_CAM_SENSOR_FW_VER: - strcpy(ctrl->string, state->phone_fw); - break; - - default: - cam_err("no such control id %d\n", - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE); - /*err = -ENOIOCTLCMD*/ - err = 0; - break; - } - - if (err < 0 && err != -ENOIOCTLCMD) - cam_err("failed, id %d\n", - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE); - - return err; -} - -static int s5c73m3_g_ext_ctrls(struct v4l2_subdev *sd, - struct v4l2_ext_controls *ctrls) -{ - struct v4l2_ext_control *ctrl = ctrls->controls; - int i, err = 0; - - for (i = 0; i < ctrls->count; i++, ctrl++) { - err = s5c73m3_g_ext_ctrl(sd, ctrl); - if (err) { - ctrls->error_idx = i; - break; - } - } - return err; -} - - -static int s5c73m3_program_fw(struct v4l2_subdev *sd, - u8 *buf, u32 addr, u32 unit, u32 count, u8 id) -{ - return 0; -} - -#ifndef CONFIG_VIDEO_S5C73M3_SPI -int s5c73m3_spi_write(const u8 *addr, const int len, const int txSize) -{ return 0; } -#endif - -static int s5c73m3_load_fw(struct v4l2_subdev *sd) -{ - struct device *dev = sd->v4l2_dev->dev; - struct s5c73m3_state *state = to_state(sd); - const struct firmware *fw; - char fw_path[20] = {0,}; - u8 *buf = NULL; - int err, txSize; - - struct file *fp; - mm_segment_t old_fs; - long fsize, nread; - int fw_requested = 1; - - old_fs = get_fs(); - set_fs(KERNEL_DS); - - if ((state->sensor_fw[0] == 'G') && (state->sensor_fw[1] == 'C')) - fp = filp_open(S5C73M3_FW_GC_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'G') && (state->sensor_fw[1] == 'D')) - fp = filp_open(S5C73M3_FW_GD_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'G') && (state->sensor_fw[1] == 'E')) - fp = filp_open(S5C73M3_FW_GE_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'G') && (state->sensor_fw[1] == 'F')) - fp = filp_open(S5C73M3_FW_GF_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'Z') && (state->sensor_fw[1] == 'C')) - fp = filp_open(S5C73M3_FW_ZC_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'Z') && (state->sensor_fw[1] == 'D')) - fp = filp_open(S5C73M3_FW_ZD_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'Z') && (state->sensor_fw[1] == 'E')) - fp = filp_open(S5C73M3_FW_ZE_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'Z') && (state->sensor_fw[1] == 'F')) - fp = filp_open(S5C73M3_FW_ZF_PATH, O_RDONLY, 0); - else if ((state->sensor_fw[0] == 'Z') && (state->sensor_fw[1] == 'G')) - fp = filp_open(S5C73M3_FW_ZG_PATH, O_RDONLY, 0); - else - fp = filp_open(S5C73M3_FW_PATH, O_RDONLY, 0); - - if (IS_ERR(fp)) { - cam_trace("failed to open %s, err %ld\n", - S5C73M3_FW_PATH, PTR_ERR(fp)); - goto request_fw; - } - - fw_requested = 0; - fsize = fp->f_path.dentry->d_inode->i_size; - - buf = vmalloc(fsize); - if (!buf) { - cam_err("failed to allocate memory\n"); - err = -ENOMEM; - goto out; - } - - nread = vfs_read(fp, (char __user *)buf, fsize, &fp->f_pos); - if (nread != fsize) { - cam_err("failed to read firmware file, %ld Bytes\n", nread); - err = -EIO; - goto out; - } - -request_fw: - if (fw_requested) { - set_fs(old_fs); - - if (state->sensor_fw[0] == 'O') { - sprintf(fw_path, "SlimISP_G%c.bin", - state->sensor_fw[1]); - } else if (state->sensor_fw[0] == 'S') { - sprintf(fw_path, "SlimISP_Z%c.bin", - state->sensor_fw[1]); - } else { - sprintf(fw_path, "SlimISP_%c%c.bin", - state->sensor_fw[0], - state->sensor_fw[1]); - } - cam_dbg("file_name = %s\n", fw_path); - - err = request_firmware(&fw, fw_path, dev); - if (err != 0) { - cam_err("request_firmware falied\n"); - err = -EINVAL; - goto out; - } - - cam_dbg("start, size %d Bytes\n", fw->size); - buf = (u8 *)fw->data; - fsize = fw->size; - } - - if (fw_requested) - txSize = 60*1024; /*60KB*/ - else - txSize = 64; /*64 byte for non-DMA mode*/ - - err = s5c73m3_spi_write(buf, fsize, txSize); - if (err < 0) { - cam_err("s5c73m3_spi_write falied\n"); - goto out; - } - - cam_dbg("end\n"); - -out: - if (!fw_requested) { - vfree(buf); - - filp_close(fp, current->files); - set_fs(old_fs); - } else { - release_firmware(fw); - } - - return err; -} - -/* - * v4l2_subdev_video_ops - */ -static const struct s5c73m3_frmsizeenum *s5c73m3_get_frmsize - (const struct s5c73m3_frmsizeenum *frmsizes, int num_entries, int index) -{ - int i; - - for (i = 0; i < num_entries; i++) { - if (frmsizes[i].index == index) - return &frmsizes[i]; - } - - return NULL; -} - -static int s5c73m3_set_frmsize(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - int err ; - cam_trace("E\n"); - - if (state->format_mode != V4L2_PIX_FMT_MODE_CAPTURE) { - err = s5c73m3_writeb(sd, S5C73M3_CHG_MODE, - S5C73M3_YUV_MODE | state->preview->reg_val | - (state->sensor_mode<<8)); - CHECK_ERR(err); - - cam_dbg("yuv frame size %dx%d\n", - state->preview->width, state->preview->height); - } else { - err = s5c73m3_writeb(sd, S5C73M3_CHG_MODE, - S5C73M3_INTERLEAVED_MODE - | state->capture->reg_val | state->preview->reg_val - |(state->sensor_mode<<8)); - CHECK_ERR(err); - - cam_dbg("interleaved yuv size %dx%d\n", - state->preview->width, state->preview->height); - - cam_dbg("interleaved jpeg size %dx%d\n", - state->capture->width, state->capture->height); - } - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_s_fmt(struct v4l2_subdev *sd, - struct v4l2_mbus_framefmt *ffmt) -{ - struct s5c73m3_state *state = to_state(sd); - const struct s5c73m3_frmsizeenum **frmsize; - const struct s5c73m3_frmsizeenum **capfrmsize; - - u32 width = ffmt->width; - u32 height = ffmt->height; - u32 tmp_width; - u32 old_index, old_index_cap; - int i, num_entries; - cam_trace("E\n"); - - if (unlikely(state->isp.bad_fw)) { - cam_err("\"Unknown\" state, please update F/W"); - return -ENOSYS; - } - if (ffmt->width < ffmt->height) { - tmp_width = ffmt->height; - height = ffmt->width; - width = tmp_width; - } - - if (ffmt->colorspace == V4L2_COLORSPACE_JPEG) - state->format_mode = V4L2_PIX_FMT_MODE_CAPTURE; - else - state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW; - - s5c73m3_set_mode(sd); - - /*set frame size for preview(yuv)*/ - frmsize = &state->preview; - old_index = *frmsize ? (*frmsize)->index : -1; - *frmsize = NULL; - - num_entries = ARRAY_SIZE(preview_frmsizes); - for (i = 0; i < num_entries; i++) { - if (width == preview_frmsizes[i].width && - height == preview_frmsizes[i].height) { - *frmsize = &preview_frmsizes[i]; - break; - } - } - - if (*frmsize == NULL) { - cam_warn("invalid yuv frame size %dx%d\n", width, height); - *frmsize = s5c73m3_get_frmsize(preview_frmsizes, - num_entries, - S5C73M3_PREVIEW_960X720); - } - - /*set frame size for capture(jpeg)*/ - /*it's meaningful for interleaved mode*/ - capfrmsize = &state->capture; - old_index_cap = *capfrmsize ? (*capfrmsize)->index : -1; - *capfrmsize = NULL; - - width = state->jpeg_width; - height = state->jpeg_height; - - num_entries = ARRAY_SIZE(capture_frmsizes); - for (i = 0; i < num_entries; i++) { - if (width == capture_frmsizes[i].width && - height == capture_frmsizes[i].height) { - *capfrmsize = &capture_frmsizes[i]; - break; - } - } - - if (*capfrmsize == NULL) { - cam_warn("invalid jpeg frame size %dx%d\n", width, height); - *capfrmsize = s5c73m3_get_frmsize(capture_frmsizes, num_entries, - S5C73M3_CAPTURE_VGA); - } - - cam_dbg("yuv %dx%d\n", (*frmsize)->width, (*frmsize)->height); - cam_dbg("jpeg %dx%d\n", (*capfrmsize)->width, (*capfrmsize)->height); - if (state->stream_enable) { - if (ffmt->colorspace == V4L2_COLORSPACE_JPEG) { - if ((old_index != (*frmsize)->index) - || (old_index_cap != (*capfrmsize)->index)) - s5c73m3_set_frmsize(sd); - } else { - if (old_index != (*frmsize)->index) - s5c73m3_set_frmsize(sd); - } - } else - s5c73m3_set_frmsize(sd); - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a) -{ - struct s5c73m3_state *state = to_state(sd); - - cam_info("g_parm: FPS %d\n", state->fps); - if (state->fps == 0) { - a->parm.capture.timeperframe.numerator = state->fps; - a->parm.capture.timeperframe.denominator = 1; - } else { - a->parm.capture.timeperframe.numerator = 1; - a->parm.capture.timeperframe.denominator = state->fps; - } - - return 0; -} - -static int s5c73m3_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a) -{ - struct s5c73m3_state *state = to_state(sd); - u32 denom = a->parm.capture.timeperframe.denominator; - u32 numer = a->parm.capture.timeperframe.numerator; - u32 err = 0; - u32 fps; - - if (unlikely(state->isp.bad_fw)) { - cam_err("\"Unknown\" state, please update F/W"); - return -ENOSYS; - } - - if (numer == 0) { - fps = 0; - } else { - fps = denom / numer; - if (fps != state->fps) { - if (fps < 0 || fps > 30) { - cam_err("invalid frame rate %d\n", fps); - fps = 30; - } - } - } - - state->fps = fps; - - cam_err("Frame rate = %d(%d)\n", fps, state->fps); - - err = s5c73m3_set_frame_rate(sd, state->fps); - CHECK_ERR(err); - - return 0; -} - -static int s5c73m3_enum_framesizes(struct v4l2_subdev *sd, - struct v4l2_frmsizeenum *fsize) -{ - struct s5c73m3_state *state = to_state(sd); - unsigned int i; - int index = fsize->index; - - /* - * Compatible with current fimc code, we have added this condition. - * Fimc use this subdev call for getting width and height of current - * state. - */ - if (index != -1) { - if (index < ARRAY_SIZE(preview_frmsizes)) { - for (i = 0; i < ARRAY_SIZE(preview_frmsizes); ++i) { - /* - * If we need to check pixelformat, please add - * condition at this line. - */ - if (index == i) { - fsize->type = - V4L2_FRMSIZE_TYPE_DISCRETE; - fsize->discrete.width = - preview_frmsizes[i].width; - fsize->discrete.height = - preview_frmsizes[i].height; - return 0; - } - } - } - return -EINVAL; - } - - /* - * The camera interface should read this value, this is the resolution - * at which the sensor would provide framedata to the camera i/f - * In case of image capture, - * this returns the default camera resolution (VGA) - */ - if (state->preview == NULL) - return -EINVAL; - - fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; - if (state->hdr_mode) { - fsize->discrete.width = state->capture->width; - fsize->discrete.height = state->capture->height; - } else { - fsize->discrete.width = state->preview->width; - fsize->discrete.height = state->preview->height; - } - return 0; -} - -static int s5c73m3_s_stream_sensor(struct v4l2_subdev *sd, int onoff) -{ - int err = 0; - int index = 0; - u16 stream_status = 0; - - cam_info("%s::::onoff=%d\n", __func__, onoff); - err = s5c73m3_writeb(sd, S5C73M3_SENSOR_STREAMING, - onoff ? S5C73M3_SENSOR_STREAMING_ON : - S5C73M3_SENSOR_STREAMING_OFF); - CHECK_ERR(err); - - do { - err = s5c73m3_read(sd, 0x0009, 0x5080, &stream_status); - if (stream_status == 0xffff) - break; - - index++; - msleep(20); - } while (index < 30); - - if (index >= 30) { - cam_info("%s::::TimeOut!! index = %d, status = 0x%x", - __func__, index, stream_status); - err = -1; - } - - return err; -} - -static int s5c73m3_s_stream_hdr(struct v4l2_subdev *sd, int enable) -{ - struct s5c73m3_state *state = to_state(sd); - int err = 0; - cam_info("s_stream_hdr\n"); - - if (enable) { - err = s5c73m3_i2c_write(sd, 0x0050, 0x0009); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5000); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0902); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0008); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x091A); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0002); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0B10); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x8000 | - state->capture->reg_val | - state->preview->reg_val); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0054, 0x5080); - CHECK_ERR(err); - - err = s5c73m3_i2c_write(sd, 0x0F14, 0x0003); - CHECK_ERR(err); - - err = s5c73m3_s_stream_sensor(sd, enable); - err = s5c73m3_set_auto_bracket_mode(sd); - } else { - err = s5c73m3_s_stream_sensor(sd, enable); - } - - return 0; -} - -static int s5c73m3_s_stream(struct v4l2_subdev *sd, int enable) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - - cam_trace("E\n"); - - if (unlikely(state->isp.bad_fw)) { - cam_err("\"Unknown\" state, please update F/W"); - return -ENOSYS; - } - - switch (enable) { - case STREAM_MODE_CAM_ON: - case STREAM_MODE_CAM_OFF: - switch (state->format_mode) { - case V4L2_PIX_FMT_MODE_CAPTURE: - cam_info("capture %s", - enable == STREAM_MODE_CAM_ON ? "on" : "off"); - - s5c73m3_s_stream_sensor(sd, enable); - if (enable == STREAM_MODE_CAM_ON && - state->focus.mode == - FOCUS_MODE_CONTINOUS_VIDEO) { - s5c73m3_set_af_mode(sd, - FOCUS_MODE_CONTINOUS_VIDEO); - } - break; - - default: - cam_info("preview %s", - enable == STREAM_MODE_CAM_ON ? "on" : "off"); - - if (state->hdr_mode) { - err = s5c73m3_set_flash(sd, FLASH_MODE_OFF, 0); - err = s5c73m3_s_stream_hdr(sd, enable); - } else { - err = s5c73m3_s_stream_sensor(sd, enable); - if (enable == STREAM_MODE_CAM_ON && - state->focus.mode == - FOCUS_MODE_CONTINOUS_VIDEO) { - s5c73m3_set_af_mode(sd, - FOCUS_MODE_CONTINOUS_VIDEO); - } - } - break; - } - break; - - case STREAM_MODE_MOVIE_ON: - if (state->flash_mode != FLASH_MODE_OFF) - err = s5c73m3_set_flash(sd, state->flash_mode, 1); - - if (state->preview->index == S5C73M3_PREVIEW_720P || - state->preview->index == S5C73M3_PREVIEW_1080P) - err = s5c73m3_set_af(sd, 1); - break; - - case STREAM_MODE_MOVIE_OFF: - if (state->preview->index == S5C73M3_PREVIEW_720P || - state->preview->index == S5C73M3_PREVIEW_1080P) - err = s5c73m3_set_af(sd, 0); - - s5c73m3_set_flash(sd, FLASH_MODE_OFF, 1); - break; - - default: - cam_err("invalid stream option, %d\n", enable); - break; - } - -#if 0 - err = s5c73m3_writeb(sd, S5C73M3_AF_CAL, 0); - CHECK_ERR(err); -#endif - state->stream_enable = enable; - if (state->stream_enable && state->hdr_mode == 0) { - if (state->fps) - s5c73m3_set_frame_rate(sd, state->fps); - } - - cam_trace("X\n"); - return 0; -} - -static int s5c73m3_check_version(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5c73m3_init_param(struct v4l2_subdev *sd) -{ - s5c73m3_set_flash(sd, FLASH_MODE_OFF, 0); - return 0; -} - -static int s5c73m3_FROM_booting(struct v4l2_subdev *sd) -{ - u16 read_val; - int i, err; - - cam_trace("E\n"); - - /*ARM go*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - udelay(400); - - /*Check boot done*/ - for (i = 0; i < 4; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x0C) - break; - - udelay(100); - } - - if (read_val != 0x0C) { - cam_err("boot fail, read_val %#x\n", read_val); - return -1; - } - - /*P,M,S and Boot Mode*/ - err = s5c73m3_write(sd, 0x3100, 0x010C, 0x0044); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3100, 0x0108, 0x000D); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3100, 0x0304, 0x0001); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x0001, 0x0000, 0x5800); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x0001, 0x0002, 0x0002); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3100, 0x0000, 0x0001); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3010, 0x0014, 0x1B85); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3010, 0x0010, 0x230C); - CHECK_ERR(err); - - mdelay(300); - - /*Check binary read done*/ - for (i = 0; i < 3; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x230E) - break; - - udelay(100); - } - - if (read_val != 0x230E) { - cam_err("binary read fail, read_val %#x\n", read_val); - return -1; - } - - /*ARM reset*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFD); - CHECK_ERR(err); - - /*remap*/ - err = s5c73m3_write(sd, 0x3010, 0x00A4, 0x0183); - CHECK_ERR(err); - - /*ARM go again*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - cam_trace("X\n"); - - return 0; -} - -static int s5c73m3_SPI_booting(struct v4l2_subdev *sd) -{ - u16 read_val; - int i, err; - - cam_trace("E\n"); - - /*ARM go*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - udelay(400); - - /*Check boot done*/ - for (i = 0; i < 3; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x0C) - break; - - udelay(100); - } - - if (read_val != 0x0C) { - cam_err("boot fail, read_val %#x\n", read_val); - return -1; - } - - /*P,M,S and Boot Mode*/ - err = s5c73m3_write(sd, 0x3010, 0x0014, 0x2146); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3010, 0x0010, 0x210C); - CHECK_ERR(err); - - udelay(200); - - /*Check SPI ready*/ - for (i = 0; i < 3; i++) { - err = s5c73m3_read(sd, 0x3010, 0x0010, &read_val); - CHECK_ERR(err); - - if (read_val == 0x210D) - break; - - udelay(100); - } - - if (read_val != 0x210D) { - cam_err("SPI not ready, read_val %#x\n", read_val); - return -1; - } - - /*download fw by SPI*/ - s5c73m3_load_fw(sd); - - /*ARM reset*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFD); - CHECK_ERR(err); - - /*remap*/ - err = s5c73m3_write(sd, 0x3010, 0x00A4, 0x0183); - CHECK_ERR(err); - - /*ARM go again*/ - err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); - CHECK_ERR(err); - - cam_trace("X\n"); - - return 0; -} - -static int s5c73m3_read_vdd_core(struct v4l2_subdev *sd) -{ - struct s5c73m3_state *state = to_state(sd); - u16 read_val; - int err; - - cam_trace("E\n"); - - /*Initialize OTP Controller*/ - err = s5c73m3_write(sd, 0x3800, 0xA004, 0x0000); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA000, 0x0004); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0D8, 0x0000); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0DC, 0x0004); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0C4, 0x4000); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0D4, 0x0015); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA000, 0x0001); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0B4, 0x9F90); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA09C, 0x9A95); - CHECK_ERR(err); - - /*Page Select*/ - err = s5c73m3_write(sd, 0x3800, 0xA0C4, 0x4800); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0C4, 0x4400); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA0C4, 0x4200); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA004, 0x00C0); - CHECK_ERR(err); - err = s5c73m3_write(sd, 0x3800, 0xA000, 0x0001); - CHECK_ERR(err); - -#if 0 /*read_val should be 0x7383*/ - err = s5c73m3_read(sd, 0x0000, 0x131C, &read_val); - CHECK_ERR(err); - - cam_dbg("read_val %#x\n", read_val); -#endif - - /*Read Data*/ - err = s5c73m3_read(sd, 0x3800, 0xA034, &read_val); - CHECK_ERR(err); - - cam_dbg("read_val %#x\n", read_val); - - /*Read Data End*/ - err = s5c73m3_write(sd, 0x3800, 0xA000, 0x0000); - CHECK_ERR(err); - - if (read_val & 0x200) { - state->pdata->set_vdd_core(1150000); - strcpy(sysfs_isp_core, "1.15V"); - } else if (read_val & 0x800) { - state->pdata->set_vdd_core(1100000); - strcpy(sysfs_isp_core, "1.10V"); - } else if (read_val & 0x2000) { - state->pdata->set_vdd_core(1050000); - strcpy(sysfs_isp_core, "1.05V"); - } else if (read_val & 0x8000) { - state->pdata->set_vdd_core(1000000); - strcpy(sysfs_isp_core, "1.00V"); - } else { - state->pdata->set_vdd_core(1150000); - strcpy(sysfs_isp_core, "1.15V"); - } - - cam_trace("X\n"); - - return 0; -} - - -static int s5c73m3_init(struct v4l2_subdev *sd, u32 val) -{ - struct s5c73m3_state *state = to_state(sd); - int err; - - sd_internal = sd; - - /* Default state values */ - state->isp.bad_fw = 0; - - state->preview = NULL; - state->capture = NULL; - - state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW; - state->sensor_mode = SENSOR_CAMERA; - state->flash_mode = FLASH_MODE_OFF; - state->beauty_mode = 0; - state->focus.mode = FOCUS_MODE_CONTINOUS_PICTURE; - state->focus.touch = 0; - - state->fps = 0; /* auto */ - - memset(&state->focus, 0, sizeof(state->focus)); - - if (!state->pdata->is_vdd_core_set()) - s5c73m3_read_vdd_core(sd); - -#ifdef S5C73M3_FROM_BOOTING - err = s5c73m3_FROM_booting(sd); -#else - err = s5c73m3_check_fw(sd, 0); - if (err < 0) { - cam_dbg("isp.bad_fw is true\n"); - state->isp.bad_fw = 1; - } -#endif - CHECK_ERR(err); - - s5c73m3_init_param(sd); - - return 0; -} - -static const struct v4l2_subdev_core_ops s5c73m3_core_ops = { - .init = s5c73m3_init, /* initializing API */ - .load_fw = s5c73m3_load_fw, - .queryctrl = s5c73m3_queryctrl, - .g_ctrl = s5c73m3_g_ctrl, - .s_ctrl = s5c73m3_s_ctrl, - .g_ext_ctrls = s5c73m3_g_ext_ctrls, -}; - -static const struct v4l2_subdev_video_ops s5c73m3_video_ops = { - .s_mbus_fmt = s5c73m3_s_fmt, - .g_parm = s5c73m3_g_parm, - .s_parm = s5c73m3_s_parm, - .enum_framesizes = s5c73m3_enum_framesizes, - .s_stream = s5c73m3_s_stream, -}; - -static const struct v4l2_subdev_ops s5c73m3_ops = { - .core = &s5c73m3_core_ops, - .video = &s5c73m3_video_ops, -}; - -static ssize_t s5c73m3_camera_rear_camtype_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - char type[25]; - - strcpy(type, sysfs_sensor_type); - return sprintf(buf, "%s\n", type); -} - -static ssize_t s5c73m3_camera_rear_camfw_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - return sprintf(buf, "%s %s\n", sysfs_sensor_fw, sysfs_phone_fw); -} - -static ssize_t s5c73m3_camera_rear_flash(struct device *dev, - struct device_attribute *attr, const char *buf, - size_t count) -{ - int err; - - if (buf[0] == '0') - err = s5c73m3_writeb(sd_internal, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_OFF); - else - err = s5c73m3_writeb(sd_internal, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_ON); - - CHECK_ERR(err); - - return count; -} - -static ssize_t s5c73m3_camera_isp_core_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - char core[10]; - - strcpy(core, sysfs_isp_core); - return sprintf(buf, "%s\n", core); -} - -static DEVICE_ATTR(rear_camtype, S_IRUGO, - s5c73m3_camera_rear_camtype_show, NULL); -static DEVICE_ATTR(rear_camfw, S_IRUGO, s5c73m3_camera_rear_camfw_show, NULL); -static DEVICE_ATTR(rear_flash, S_IWUSR | S_IWGRP, NULL, - s5c73m3_camera_rear_flash); -static DEVICE_ATTR(isp_core, S_IRUGO, s5c73m3_camera_isp_core_show, NULL); - -/* - * s5c73m3_probe - * Fetching platform data is being done with s_config subdev call. - * In probe routine, we just register subdev device - */ -static int __devinit s5c73m3_probe(struct i2c_client *client, - const struct i2c_device_id *id) -{ - struct s5c73m3_state *state; - struct v4l2_subdev *sd; - - state = kzalloc(sizeof(struct s5c73m3_state), GFP_KERNEL); - if (state == NULL) - return -ENOMEM; - - sd = &state->sd; - strcpy(sd->name, S5C73M3_DRIVER_NAME); - - state->pdata = client->dev.platform_data; - - /* Registering subdev */ - v4l2_i2c_subdev_init(sd, client, &s5c73m3_ops); - -#ifdef CAM_DEBUG - state->dbg_level = CAM_DEBUG; -#endif - -#ifdef CONFIG_BUSFREQ_OPP - /* lock bus frequency */ - dev_lock(bus_dev, s5c73m3_dev, 400200); -#else - pm_qos_update_request(&entry, 400200); -#endif - - if (s5c73m3_dev) - dev_set_drvdata(s5c73m3_dev, state); - - printk(KERN_DEBUG "%s\n", __func__); - - return 0; -} - -static int __devexit s5c73m3_remove(struct i2c_client *client) -{ - struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct s5c73m3_state *state = to_state(sd); - - if (unlikely(state->isp.bad_fw)) { - cam_err("camera is not ready!!\n"); - } else { - if (s5c73m3_set_af_softlanding(sd) < 0) - cam_err("failed to set soft landing\n"); - } - v4l2_device_unregister_subdev(sd); - -#ifdef CONFIG_BUSFREQ_OPP - /* Unlock bus frequency */ - dev_unlock(bus_dev, s5c73m3_dev); -#else - pm_qos_update_request(&entry, 0); -#endif - - kfree(state->fw_version); - kfree(state); - - return 0; -} - -static const struct i2c_device_id s5c73m3_id[] = { - { S5C73M3_DRIVER_NAME, 0 }, - { } -}; -MODULE_DEVICE_TABLE(i2c, s5c73m3_id); - -static struct i2c_driver s5c73m3_i2c_driver = { - .driver = { - .name = S5C73M3_DRIVER_NAME, - }, - .probe = s5c73m3_probe, - .remove = __devexit_p(s5c73m3_remove), - .id_table = s5c73m3_id, -}; - -static int __init s5c73m3_mod_init(void) -{ -#ifdef CONFIG_BUSFREQ_OPP - /* To lock bus frequency in OPP mode */ - bus_dev = dev_get("exynos-busfreq"); -#else - pm_qos_add_request(&entry, PM_QOS_BUS_DMA_THROUGHPUT, 0); -#endif - - if (!s5c73m3_dev) { - s5c73m3_dev = device_create(camera_class, - NULL, 0, NULL, "rear"); - if (IS_ERR(s5c73m3_dev)) { - cam_warn("failed to create device!\n"); - return 0; - } - - if (device_create_file(s5c73m3_dev, &dev_attr_rear_camtype) - < 0) { - cam_warn("failed to create device file, %s\n", - dev_attr_rear_camtype.attr.name); - } - - if (device_create_file(s5c73m3_dev, &dev_attr_rear_camfw) < 0) { - cam_warn("failed to create device file, %s\n", - dev_attr_rear_camfw.attr.name); - } - - if (device_create_file(s5c73m3_dev, &dev_attr_rear_flash) < 0) { - cam_warn("failed to create device file, %s\n", - dev_attr_rear_flash.attr.name); - } - - if (device_create_file(s5c73m3_dev, &dev_attr_isp_core) < 0) { - cam_warn("failed to create device file, %s\n", - dev_attr_isp_core.attr.name); - } - } - - return i2c_add_driver(&s5c73m3_i2c_driver); -} - -static void __exit s5c73m3_mod_exit(void) -{ - i2c_del_driver(&s5c73m3_i2c_driver); -} -module_init(s5c73m3_mod_init); -module_exit(s5c73m3_mod_exit); - - -MODULE_DESCRIPTION("driver for LSI S5C73M3"); -MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/slp_s5c73m3.h b/drivers/media/video/slp_s5c73m3.h deleted file mode 100644 index 314c65f..0000000 --- a/drivers/media/video/slp_s5c73m3.h +++ /dev/null @@ -1,516 +0,0 @@ -/* - * Driver for LSI S5C73M3 (ISP for 8MP Camera) - * - * 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. - */ - -#ifndef __SLP_S5C73M3_H -#define __SLP_S5C73M3_H - -#define CONFIG_CAM_DEBUG 1 - -#define cam_warn(fmt, ...) \ - do { \ - printk(KERN_WARNING "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_err(fmt, ...) \ - do { \ - printk(KERN_ERR "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_info(fmt, ...) \ - do { \ - printk(KERN_INFO "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#ifdef CONFIG_CAM_DEBUG -#define CAM_DEBUG (1 << 0) -#define CAM_TRACE (1 << 1) -#define CAM_I2C (1 << 2) - -#define cam_dbg(fmt, ...) \ - do { \ - if (to_state(sd)->dbg_level & CAM_DEBUG) \ - printk(KERN_DEBUG "%s: " fmt, \ - __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_trace(fmt, ...) \ - do { \ - if (to_state(sd)->dbg_level & CAM_TRACE) \ - printk(KERN_DEBUG "%s: " fmt, \ - __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_i2c_dbg(fmt, ...) \ - do { \ - if (to_state(sd)->dbg_level & CAM_I2C) \ - printk(KERN_DEBUG "%s: " fmt, \ - __func__, ##__VA_ARGS__); \ - } while (0) -#else -#define cam_dbg(fmt, ...) -#define cam_trace(fmt, ...) -#define cam_i2c_dbg(fmt, ...) -#endif - -enum s5c73m3_prev_frmsize { - S5C73M3_PREVIEW_QCIF, - S5C73M3_PREVIEW_QCIF2, - S5C73M3_PREVIEW_QVGA, - S5C73M3_PREVIEW_CIF, - S5C73M3_PREVIEW_VGA, - S5C73M3_PREVIEW_D1, - S5C73M3_PREVIEW_WVGA, - S5C73M3_PREVIEW_880X720, - S5C73M3_PREVIEW_960X720, - S5C73M3_PREVIEW_1008X672, - S5C73M3_PREVIEW_1056X704, - S5C73M3_PREVIEW_1184X666, - S5C73M3_PREVIEW_720P, - S5C73M3_VDIS_720P, - S5C73M3_PREVIEW_1080P, - S5C73M3_VDIS_1080P, - S5C73M3_PREVIEW_HDR, -}; - -enum s5c73m3_cap_frmsize { - S5C73M3_CAPTURE_VGA, /* 640 x 480 */ - S5C73M3_CAPTURE_WVGA, /* 800 x 480 */ - S5C73M3_CAPTURE_1024X768, /* 1024 x 768 */ - S5C73M3_CAPTURE_HD, /* 1280 x 720 */ - S5C73M3_CAPTURE_W1MP, /* 1600 x 960 */ - S5C73M3_CAPTURE_2MP, /* UXGA - 1600 x 1200 */ - S5C73M3_CAPTURE_W2MP, /* 2048 x 1232 */ - S5C73M3_CAPTURE_3MP, /* QXGA - 2048 x 1536 */ - S5C73M3_CAPTURE_W4MP, /* WQXGA - 2560 x 1440 */ - S5C73M3_CAPTURE_5MP, /* 2560 x 1920 */ - S5C73M3_CAPTURE_W6MP, /* 3072 x 1856 */ - S5C73M3_CAPTURE_7MP, /* 3072 x 2304 */ - S5C73M3_CAPTURE_W7MP, /* WQXGA - 2560 x 1536 */ - S5C73M3_CAPTURE_3264X2176, /* 3264 x 2176 */ - S5C73M3_CAPTURE_8MP, /* 3264 x 2448 */ -}; - -enum s5c73m3_isneed_flash_tristate { - S5C73M3_ISNEED_FLASH_OFF = 0x00, - S5C73M3_ISNEED_FLASH_ON = 0x01, - S5C73M3_ISNEED_FLASH_UNDEFINED = 0x02, -}; - -struct s5c73m3_control { - u32 id; - s32 value; - s32 minimum; /* Note signedness */ - s32 maximum; - s32 step; - s32 default_value; -}; - -struct s5c73m3_frmsizeenum { - unsigned int index; - unsigned int width; - unsigned int height; - u8 reg_val; /* a value for category parameter */ -}; - -struct s5c73m3_isp { - wait_queue_head_t wait; - unsigned int irq; /* irq issued by ISP */ - unsigned int issued; - unsigned int int_factor; - unsigned int bad_fw:1; -}; - -struct s5c73m3_jpeg { - int quality; - unsigned int main_size; /* Main JPEG file size */ - unsigned int thumb_size; /* Thumbnail file size */ - unsigned int main_offset; - unsigned int thumb_offset; - unsigned int postview_offset; -}; - -struct s5c73m3_focus { - unsigned int mode; - unsigned int lock; - unsigned int status; - unsigned int touch; - unsigned int pos_x; - unsigned int pos_y; - - /* rectangle type values */ - unsigned int left; - unsigned int top; - unsigned int width; - unsigned int height; -}; - -struct s5c73m3_exif { - char unique_id[7]; - u32 exptime; /* us */ - u16 flash; - u16 iso; - int tv; /* shutter speed */ - int bv; /* brightness */ - int ebv; /* exposure bias */ - int effect; /* effect(colorfx) */ - int saturation; - int sharpness; - int metering; - int wdr; -}; - -struct s5c73m3_state { - struct s5c73m3_platform_data *pdata; - struct v4l2_subdev sd; - - struct s5c73m3_isp isp; - - const struct s5c73m3_frmsizeenum *preview; - const struct s5c73m3_frmsizeenum *capture; - - enum v4l2_pix_format_mode format_mode; - enum v4l2_sensor_mode sensor_mode; - enum v4l2_flash_mode flash_mode; - enum v4l2_wb_mode wb_mode; - enum v4l2_scene_mode scene_mode; - int vt_mode; - int beauty_mode; - int hdr_mode; - int hybrid_mode; - int zoom; - int stream_enable; - int ae_lock; - int awb_lock; - - int cal_device; - int cal_dll; - - unsigned int fps; - struct s5c73m3_focus focus; - int caf_mode; - char isflash; - - struct s5c73m3_jpeg jpeg; - struct s5c73m3_exif exif; - - int check_dataline; - char *fw_version; - - u32 jpeg_width; - u32 jpeg_height; - - u8 sensor_fw[10]; - u8 phone_fw[10]; - - u8 sensor_type[15]; - -#ifdef CONFIG_CAM_DEBUG - u8 dbg_level; -#endif -}; - -#define S5C73M3_IMG_OUTPUT 0x0902 -#define S5C73M3_HDR_OUTPUT 0x0008 -#define S5C73M3_YUV_OUTPUT 0x0009 -#define S5C73M3_INTERLEAVED_OUTPUT 0x000D -#define S5C73M3_HYBRID_OUTPUT 0x0016 - -#define S5C73M3_STILL_PRE_FLASH 0x0A00 -#define S5C73M3_STILL_PRE_FLASH_FIRE 0x0000 -#define S5C73M3_STILL_PRE_FLASH_NON_FIRED 0x0000 -#define S5C73M3_STILL_PRE_FLASH_FIRED 0x0001 - -#define S5C73M3_STILL_MAIN_FLASH 0x0A02 -#define S5C73M3_STILL_MAIN_FLASH_CANCEL 0x0001 -#define S5C73M3_STILL_MAIN_FLASH_FIRE 0x0002 - - -#define S5C73M3_ZOOM_STEP 0x0B00 - - -#define S5C73M3_IMAGE_EFFECT 0x0B0A -#define S5C73M3_IMAGE_EFFECT_NONE 0x0001 -#define S5C73M3_IMAGE_EFFECT_NEGATIVE 0x0002 -#define S5C73M3_IMAGE_EFFECT_AQUA 0x0003 -#define S5C73M3_IMAGE_EFFECT_SEPIA 0x0004 -#define S5C73M3_IMAGE_EFFECT_MONO 0x0005 - -#define S5C73M3_IMAGE_QUALITY 0x0B0C -#define S5C73M3_IMAGE_QUALITY_SUPERFINE 0x0000 -#define S5C73M3_IMAGE_QUALITY_FINE 0x0001 -#define S5C73M3_IMAGE_QUALITY_NORMAL 0x0002 - - -#define S5C73M3_FLASH_MODE 0x0B0E -#define S5C73M3_FLASH_MODE_OFF 0x0000 -#define S5C73M3_FLASH_MODE_ON 0x0001 -#define S5C73M3_FLASH_MODE_AUTO 0x0002 - -#define S5C73M3_FLASH_TORCH 0x0B12 -#define S5C73M3_FLASH_TORCH_OFF 0x0000 -#define S5C73M3_FLASH_TORCH_ON 0x0001 - -#define S5C73M3_AE_ISNEEDFLASH 0x0CBA -#define S5C73M3_AE_ISNEEDFLASH_OFF 0x0000 -#define S5C73M3_AE_ISNEEDFLASH_ON 0x0001 - - -#define S5C73M3_CHG_MODE 0x0B10 -#define S5C73M3_YUV_MODE 0x8000 -#define S5C73M3_INTERLEAVED_MODE 0x8000 -#define S5C73M3_CHG_MODE_YUV_320_240 0x8001 -#define S5C73M3_CHG_MODE_YUV_400_300 0x8002 -#define S5C73M3_CHG_MODE_YUV_640_480 0x8003 -#define S5C73M3_CHG_MODE_YUV_800_600 0x8004 -#define S5C73M3_CHG_MODE_YUV_960_720 0x8005 -#define S5C73M3_CHG_MODE_YUV_1280_720 0x8006 -#define S5C73M3_CHG_MODE_YUV_1280_960 0x8007 -#define S5C73M3_CHG_MODE_YUV_1600_1200 0x8008 -#define S5C73M3_CHG_MODE_YUV_1632_1224 0x8009 -#define S5C73M3_CHG_MODE_YUV_1920_1080 0x800A -#define S5C73M3_CHG_MODE_YUV_1920_1440 0x800B -#define S5C73M3_CHG_MODE_YUV_2304_1296 0x800C -#define S5C73M3_CHG_MODE_YUV_2304_1728 0x800D -#define S5C73M3_CHG_MODE_JPEG_640_480 0x0010 -#define S5C73M3_CHG_MODE_JPEG_800_450 0x0020 -#define S5C73M3_CHG_MODE_JPEG_800_600 0x0030 -#define S5C73M3_CHG_MODE_JPEG_1600_960 0x0040 -#define S5C73M3_CHG_MODE_JPEG_1600_1200 0x0050 -#define S5C73M3_CHG_MODE_JPEG_2048_1152 0x0060 -#define S5C73M3_CHG_MODE_JPEG_2048_1536 0x0070 -#define S5C73M3_CHG_MODE_JPEG_2560_1440 0x0080 -#define S5C73M3_CHG_MODE_JPEG_2560_1920 0x0090 -#define S5C73M3_CHG_MODE_JPEG_3072_1728 0x00A0 -#define S5C73M3_CHG_MODE_JPEG_3264_2304 0x00B0 -#define S5C73M3_CHG_MODE_JPEG_3264_1836 0x00C0 -#define S5C73M3_CHG_MODE_JPEG_3264_2448 0x00D0 - - -#define S5C73M3_AF_CON 0x0E00 -#define S5C73M3_AF_CON_STOP 0x0000 -#define S5C73M3_AF_CON_SCAN 0x0001/*AF_SCAN:Full Search*/ -#define S5C73M3_AF_CON_START 0x0002/*AF_START:Fast Search*/ - -#define S5C73M3_AF_STATUS 0x5E80 - -#define S5C73M3_AF_TOUCH_AF 0x0E0A - -#define S5C73M3_AF_CAL 0x0E06 - -#define S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR 0x0001 -#define S5C73M3_CAF_STATUS_FOCUSING 0x0002 -#define S5C73M3_CAF_STATUS_FOCUSED 0x0003 -#define S5C73M3_CAF_STATUS_UNFOCUSED 0x0004 - -#define S5C73M3_AF_STATUS_INVALID 0x0010 -#define S5C73M3_AF_STATUS_FOCUSING 0x0020 -#define S5C73M3_AF_STATUS_FOCUSED 0x0030/*SUCCESS*/ -#define S5C73M3_AF_STATUS_UNFOCUSED 0x0040/*FAIL*/ - -#define S5C73M3_AF_TOUCH_POSITION 0x5E8E - -#define S5C73M3_AF_FACE_ZOOM 0x0E10 - -#define S5C73M3_AF_MODE 0x0E02 -#define S5C73M3_AF_MODE_NORMAL 0x0000 -#define S5C73M3_AF_MODE_MACRO 0x0001 -#define S5C73M3_AF_MODE_MOVIE_CAF_START 0x0002 -#define S5C73M3_AF_MODE_MOVIE_CAF_STOP 0x0003 -#define S5C73M3_AF_MODE_PREVIEW_CAF_START 0x0004 -#define S5C73M3_AF_MODE_PREVIEW_CAF_STOP 0x0005 - -#define S5C73M3_AF_SOFTLANDING 0x0E16 -#define S5C73M3_AF_SOFTLANDING_ON 0x0000 - -#define S5C73M3_FACE_DET 0x0E0C -#define S5C73M3_FACE_DET_OFF 0x0000 -#define S5C73M3_FACE_DET_ON 0x0001 - -#define S5C73M3_FACE_DET_OSD 0x0E0E -#define S5C73M3_FACE_DET_OSD_OFF 0x0000 -#define S5C73M3_FACE_DET_OSD_ON 0x0001 - -#define S5C73M3_AE_CON 0x0C00 -#define S5C73M3_AE_STOP 0x0000/*LOCK*/ -#define S5C73M3_AE_START 0x0001/*UNLOCK*/ - -#define S5C73M3_ISO 0x0C02 -#define S5C73M3_ISO_AUTO 0x0000 -#define S5C73M3_ISO_100 0x0001 -#define S5C73M3_ISO_200 0x0002 -#define S5C73M3_ISO_400 0x0003 -#define S5C73M3_ISO_800 0x0004 -#define S5C73M3_ISO_SPORTS 0x0005 -#define S5C73M3_ISO_NIGHT 0x0006 -#define S5C73M3_ISO_INDOOR 0x0007 - -#define S5C73M3_EV 0x0C04 -#define S5C73M3_EV_M20 0x0000 -#define S5C73M3_EV_M15 0x0001 -#define S5C73M3_EV_M10 0x0002 -#define S5C73M3_EV_M05 0x0003 -#define S5C73M3_EV_ZERO 0x0004 -#define S5C73M3_EV_P05 0x0005 -#define S5C73M3_EV_P10 0x0006 -#define S5C73M3_EV_P15 0x0007 -#define S5C73M3_EV_P20 0x0008 - -#define S5C73M3_METER 0x0C06 -#define S5C73M3_METER_CENTER 0x0000 -#define S5C73M3_METER_SPOT 0x0001 -#define S5C73M3_METER_AVERAGE 0x0002 -#define S5C73M3_METER_SMART 0x0003 - -#define S5C73M3_WDR 0x0C08 -#define S5C73M3_WDR_OFF 0x0000 -#define S5C73M3_WDR_ON 0x0001 - -#define S5C73M3_AE_MODE 0x0C1E -#define S5C73M3_AUTO_MODE_AE_SET 0x0000 -#define S5C73M3_FIXED_30FPS 0x0002 -#define S5C73M3_FIXED_20FPS 0x0003 -#define S5C73M3_FIXED_15FPS 0x0004 -#define S5C73M3_FIXED_120FPS 0x0008 -#define S5C73M3_FIXED_7FPS 0x0009 -#define S5C73M3_ANTI_SHAKE 0x0013 - -#define S5C73M3_SHARPNESS 0x0C14 -#define S5C73M3_SHARPNESS_0 0x0000 -#define S5C73M3_SHARPNESS_1 0x0001 -#define S5C73M3_SHARPNESS_2 0x0002 -#define S5C73M3_SHARPNESS_M1 0x0003 -#define S5C73M3_SHARPNESS_M2 0x0004 - -#define S5C73M3_SATURATION 0x0C16 -#define S5C73M3_SATURATION_0 0x0000 -#define S5C73M3_SATURATION_1 0x0001 -#define S5C73M3_SATURATION_2 0x0002 -#define S5C73M3_SATURATION_M1 0x0003 -#define S5C73M3_SATURATION_M2 0x0004 - -#define S5C73M3_CONTRAST 0x0C18 -#define S5C73M3_CONTRAST_0 0x0000 -#define S5C73M3_CONTRAST_1 0x0001 -#define S5C73M3_CONTRAST_2 0x0002 -#define S5C73M3_CONTRAST_M1 0x0003 -#define S5C73M3_CONTRAST_M2 0x0004 - -#define S5C73M3_SCENE_MODE 0x0C1A -#define S5C73M3_SCENE_MODE_NONE 0x0000 -#define S5C73M3_SCENE_MODE_PORTRAIT 0x0001 -#define S5C73M3_SCENE_MODE_LANDSCAPE 0x0002 -#define S5C73M3_SCENE_MODE_SPORTS 0x0003 -#define S5C73M3_SCENE_MODE_INDOOR 0x0004 -#define S5C73M3_SCENE_MODE_BEACH 0x0005 -#define S5C73M3_SCENE_MODE_SUNSET 0x0006 -#define S5C73M3_SCENE_MODE_DAWN 0x0007 -#define S5C73M3_SCENE_MODE_FALL 0x0008 -#define S5C73M3_SCENE_MODE_NIGHT 0x0009 -#define S5C73M3_SCENE_MODE_AGAINSTLIGHT 0x000A -#define S5C73M3_SCENE_MODE_FIRE 0x000B -#define S5C73M3_SCENE_MODE_TEXT 0x000C -#define S5C73M3_SCENE_MODE_CANDLE 0x000D - -#define S5C73M3_FIREWORK_CAPTURE 0x0C20 - -#define S5C73M3_AE_AUTO_BRAKET 0x0B14 -#define S5C73M3_AE_AUTO_BRAKET_EV05 0x0080 -#define S5C73M3_AE_AUTO_BRAKET_EV10 0x0100 -#define S5C73M3_AE_AUTO_BRAKET_EV15 0x0180 -#define S5C73M3_AE_AUTO_BRAKET_EV20 0x0200 - -#define S5C73M3_SENSOR_STREAMING 0x090A -#define S5C73M3_SENSOR_STREAMING_OFF 0x0000 -#define S5C73M3_SENSOR_STREAMING_ON 0x0001 - -#define S5C73M3_AWB_MODE 0x0D02 -#define S5C73M3_AWB_MODE_INCANDESCENT 0x0000 -#define S5C73M3_AWB_MODE_FLUORESCENT1 0x0001 -#define S5C73M3_AWB_MODE_FLUORESCENT2 0x0002 -#define S5C73M3_AWB_MODE_DAYLIGHT 0x0003 -#define S5C73M3_AWB_MODE_CLOUDY 0x0004 -#define S5C73M3_AWB_MODE_AUTO 0x0005 - -#define S5C73M3_AWB_CON 0x0D00 -#define S5C73M3_AWB_STOP 0x0000/*LOCK*/ -#define S5C73M3_AWB_START 0x0001/*UNLOCK*/ - -#define S5C73M3_HYBRID_CAPTURE 0x0996 - -/* S5C73M3 Sensor Mode */ -#define S5C73M3_SYSINIT_MODE 0x0 -#define S5C73M3_PARMSET_MODE 0x1 -#define S5C73M3_MONITOR_MODE 0x2 -#define S5C73M3_STILLCAP_MODE 0x3 - -/* Interrupt Factor */ -#define S5C73M3_INT_SOUND (1 << 7) -#define S5C73M3_INT_LENS_INIT (1 << 6) -#define S5C73M3_INT_FD (1 << 5) -#define S5C73M3_INT_FRAME_SYNC (1 << 4) -#define S5C73M3_INT_CAPTURE (1 << 3) -#define S5C73M3_INT_ZOOM (1 << 2) -#define S5C73M3_INT_AF (1 << 1) -#define S5C73M3_INT_MODE (1 << 0) - -/* ESD Interrupt */ -#define S5C73M3_INT_ESD (1 << 0) - -static const u32 S5C73M3_INIT[] = { -0x00500009, -0x00545000, -0x0F140B08, -0x0F140000, -0x0F140900, -0x0F140403, /*640MHz*/ -0x00545080, -0x0F140002 -}; - -static u32 S5C73M3_OTP_CONTROL[] = { -0xFCFC3310, -0x00503800, -0x0054A004, -0x0F140000, -0x0054A000, -0x0F140004, -0x0054A0D8, -0x0F140000, -0x0054A0DC, -0x0F140004, -0x0054A0C4, -0x0F144000, -0x0054A0D4, -0x0F140015, -0x0054A000, -0x0F140001, -0x0054A0B4, -0x0F149F90, -0x0054A09C, -0x0F149A95, -}; - -static u32 S5C73M3_OTP_PAGE[] = { -0x0054A0C4, -0x0F144800, -0x0054A0C4, -0x0F144400, -0x0054A0C4, -0x0F144200, -0x0054A004, -0x0F1400C0, -0x0054A000, -0x0F140001, -}; - -#ifdef CONFIG_VIDEO_S5C73M3_SPI -extern int s5c73m3_spi_write(const u8 *addr, const int len, const int txSize); -#endif - -#endif /* __SLP_S5C73M3_H */ diff --git a/drivers/media/video/slp_s5k4ecgx.c b/drivers/media/video/slp_s5k4ecgx.c deleted file mode 100644 index c78ca71..0000000 --- a/drivers/media/video/slp_s5k4ecgx.c +++ /dev/null @@ -1,2335 +0,0 @@ -/* - * Driver for S5K4ECGX from Samsung Electronics - * - * 5Mp CMOS Image Sensor SoC with an Embedded Image Processor - * - * Copyright (c) 2012 Samsung Electronics Co., Ltd. - * - * 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/i2c.h> -#include <linux/init.h> -#include <media/v4l2-device.h> -#include <linux/delay.h> -#include <linux/version.h> -#include <media/v4l2-device.h> -#include <media/v4l2-subdev.h> -#include <linux/workqueue.h> -#ifdef CONFIG_VIDEO_SAMSUNG_V4L2 -#include <linux/videodev2_exynos_media.h> -#include <linux/videodev2_exynos_camera.h> -#endif -#include <media/s5k4ecgx_platform.h> - -#include "slp_s5k4ecgx.h" - -#ifdef S5K4ECGX_USLEEP -#include <linux/hrtimer.h> -#endif - -#define S5K4ECGX_BURST_MODE -#ifdef S5K4ECGX_BURST_MODE - static u16 addr, value; - - static int len; - static u8 buf[SZ_4K] = {0,}; -#else - static u8 buf[4] = {0,}; -#endif - -/* 5M mem size */ -#define S5K4ECGX_INTLV_DATA_MAXSIZE (5 << 20) - -static const struct s5k4ecgx_framesize preview_frmsizes[] = { - { S5K4ECGX_PREVIEW_640, 640, 480 }, - { S5K4ECGX_PREVIEW_176, 640, 480 }, - { S5K4ECGX_PREVIEW_320, 320, 240 }, - { S5K4ECGX_PREVIEW_720, 720, 480 }, - { S5K4ECGX_PREVIEW_800, 800, 480 }, - { S5K4ECGX_PREVIEW_1280, 1280, 720 }, -}; - -static const struct s5k4ecgx_framesize capture_frmsizes[] = { - { S5K4ECGX_CAPTURE_5MP, 2560, 1920 }, - { S5K4ECGX_CAPTURE_3MP, 2048, 1536 }, - { S5K4ECGX_CAPTURE_2MP, 1600, 1200 }, - { S5K4ECGX_CAPTURE_1MP, 1280, 960 }, - { S5K4ECGX_CAPTURE_XGA, 1024, 768 }, - { S5K4ECGX_CAPTURE_VGA, 640, 480 }, -}; - -#define CHECK_ERR(x) if (unlikely((x) < 0)) { \ - cam_err("i2c failed, err %d\n", x); \ - return x; \ - } - -#define NELEMS(array) (sizeof(array) / sizeof(array[0])) - -#ifdef S5K4ECGX_USLEEP -/* - * Use msleep() if the sleep time is over 1000 us. -*/ -static void s5k4ecgx_usleep(u32 usecs) -{ - ktime_t expires; - u64 add_time = (u64)usecs * 1000; - - if (unlikely(!usecs)) - return; - - expires = ktime_add_ns(ktime_get(), add_time); - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_hrtimeout(&expires, HRTIMER_MODE_ABS); -} -#endif - -static void s5k4ecgx_cam_delay(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - - if (state->scene_mode == SCENE_MODE_NIGHTSHOT || - state->scene_mode == SCENE_MODE_FIREWORKS) - msleep(250); - else - msleep(200); -} - -static inline int s5k4ecgx_read(struct i2c_client *client, - u16 subaddr, u16 *data) -{ - u8 buf[2]; - int err = 0; - struct i2c_msg msg = { - .addr = client->addr, - .flags = 0, - .len = 2, - .buf = buf, - }; - - *(u16 *)buf = cpu_to_be16(subaddr); - - err = i2c_transfer(client->adapter, &msg, 1); - if (unlikely(err < 0)) - cam_err("ERR: %d register read fail\n", __LINE__); - - msg.flags = I2C_M_RD; - - err = i2c_transfer(client->adapter, &msg, 1); - if (unlikely(err < 0)) - cam_err("ERR: %d register read fail\n", __LINE__); - - *data = ((buf[0] << 8) | buf[1]); - - return err; -} - -static inline int s5k4ecgx_write(struct i2c_client *client, - u32 packet) -{ - u8 buf[4]; - int err = 0, retry_count = 5; - - struct i2c_msg msg = { - .addr = client->addr, - .flags = 0, - .buf = buf, - .len = 4, - }; - - if (!client->adapter) { - cam_err("ERR - can't search i2c client adapter\n"); - return -EIO; - } - - while (retry_count--) { - *(u32 *)buf = cpu_to_be32(packet); - err = i2c_transfer(client->adapter, &msg, 1); - if (likely(err == 1)) - break; - mdelay(10); - } - - if (unlikely(err < 0)) { - cam_err("ERR - 0x%08x write failed err=%d\n", - (u32)packet, err); - return err; - } - - return (err != 1) ? -1 : 0; -} - -/* -* Read a register. -*/ -static int s5k4ecgx_read_reg(struct v4l2_subdev *sd, - u16 page, u16 addr, u16 *val) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - u32 page_cmd = (0x002C << 16) | page; - u32 addr_cmd = (0x002E << 16) | addr; - int err = 0; - - cam_dbg("page_cmd=0x%X, addr_cmd=0x%X\n", page_cmd, addr_cmd); - - err = s5k4ecgx_write(client, page_cmd); - CHECK_ERR(err); - err = s5k4ecgx_write(client, addr_cmd); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, val); - CHECK_ERR(err); - - return 0; -} - -/* program multiple registers */ -static int s5k4ecgx_write_regs(struct v4l2_subdev *sd, - const u32 *packet, u32 num) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - int ret = -EAGAIN; - u32 temp = 0; - u16 delay = 0; - int retry_count = 5; - - struct i2c_msg msg = { - msg.addr = client->addr, - msg.flags = 0, - msg.len = 4, - msg.buf = buf, - }; - - while (num--) { - temp = *packet++; - - if ((temp & S5K4ECGX_DELAY) == S5K4ECGX_DELAY) { - delay = temp & 0xFFFF; - cam_dbg("line(%d):delay(0x%x):delay(%d)\n", - __LINE__, delay, delay); - msleep(delay); - continue; - } - -#ifdef S5K4ECGX_BURST_MODE - addr = temp >> 16; - value = temp & 0xFFFF; - - switch (addr) { - case 0x0F12: - if (len == 0) { - buf[len++] = addr >> 8; - buf[len++] = addr & 0xFF; - } - buf[len++] = value >> 8; - buf[len++] = value & 0xFF; - - if ((*packet >> 16) != addr) { - msg.len = len; - goto s5k4ecgx_burst_write; - } - break; - - case 0xFFFF: - break; - - default: - msg.len = 4; - *(u32 *)buf = cpu_to_be32(temp); - goto s5k4ecgx_burst_write; - } - - continue; -#else - *(u32 *)buf = cpu_to_be32(temp); -#endif - -#ifdef S5K4ECGX_BURST_MODE -s5k4ecgx_burst_write: - len = 0; -#endif - retry_count = 5; - - while (retry_count--) { - ret = i2c_transfer(client->adapter, &msg, 1); - if (likely(ret == 1)) - break; - mdelay(10); - } - - if (unlikely(ret < 0)) { - cam_err("ERR - 0x%08x write failed err=%d\n", \ - (u32)packet, ret); - break; - } - } - - if (unlikely(ret < 0)) { - cam_err("fail to write registers!!\n"); - return -EIO; - } - - return 0; -} - -static int camera_flash_manual_ctrl(struct v4l2_subdev *sd, int mode) -{ - struct s5k4ecgx_state *state = to_state(sd); - int ret = 0; - cam_dbg(" E\n"); - if (mode == CAM_FLASH_ON) { - /* FLASH mode */ - ret = state->pdata->flash_ctrl(CAM_FLASH_ON); - state->preflash = PREFLASH_ON; - } else if (mode == CAM_FLASH_TORCH) { - /* TORCH mode */ - ret = state->pdata->flash_ctrl(CAM_FLASH_TORCH); - state->preflash = PREFLASH_ON; - } else { - ret = state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - } - return ret; -} - -static int s5k4ecgx_get_exif(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5k4ecgx_get_lux(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - struct i2c_client *client = v4l2_get_subdevdata(sd); - int msb = 0; - int lsb = 0; - int cur_lux = 0; - bool lowlight = false; - int err = 0; - cam_dbg(" E\n"); - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2C18); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *)&lsb); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *)&msb); - CHECK_ERR(err); - - cur_lux = (msb << 16) | lsb; - - if (cur_lux >= 0x32) - lowlight = false; - else - lowlight = true; - - state->lowlight = lowlight; - - cam_info("%s, s5k4ecgx_status.lowlight is %d\n", __func__, - state->lowlight); - /*this value is under 0x0032 in low light condition */ - return err; -} - -static int s5k4ecgx_ae_stable(struct v4l2_subdev *sd) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - struct s5k4ecgx_state *state = to_state(sd); - int val = 0; - int err = 0; - int cnt; - do { - if (state->focus.start == AUTO_FOCUS_OFF) { - cam_info("af_start_preflash: AF is cancelled!\n"); - state->focus.status = CAMERA_AF_STATUS_MAX; - break; - } - - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2C74); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *)&val); - CHECK_ERR(err); - - if (val == 0x1) - break; - - s5k4ecgx_usleep(10*1000); - - } while (cnt < 40); - cam_info("%s, ret value is %d\n", __func__, - val); - - return err; -} - -static int s5k4ecgx_set_awb_lock(struct v4l2_subdev *sd, int val) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - cam_info(" E\n"); - - if (val == state->awb_lock) - return 0; - - if (val) - err = s5k4ecgx_write_regs(sd, s5k4ecgx_awb_lock_EVT1,\ - sizeof(s5k4ecgx_awb_lock_EVT1) / \ - sizeof(s5k4ecgx_awb_lock_EVT1[0])); - else - err = s5k4ecgx_write_regs(sd, s5k4ecgx_awb_unlock_EVT1,\ - sizeof(s5k4ecgx_awb_unlock_EVT1) / \ - sizeof(s5k4ecgx_awb_unlock_EVT1[0])); - - CHECK_ERR(err); - state->awb_lock = val; - cam_info("awb %s\n", val ? "lock" : "unlock"); - return err; -} - -static int s5k4ecgx_set_ae_lock(struct v4l2_subdev *sd, int val) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - cam_info(" E\n"); - - if (val == state->ae_lock) - return 0; - - if (val) - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ae_lock_EVT1,\ - sizeof(s5k4ecgx_ae_lock_EVT1) / \ - sizeof(s5k4ecgx_ae_lock_EVT1[0])); - else - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ae_unlock_EVT1,\ - sizeof(s5k4ecgx_ae_unlock_EVT1) / \ - sizeof(s5k4ecgx_ae_unlock_EVT1[0])); - - CHECK_ERR(err); - state->ae_lock = val; - cam_info("ae %s\n", val ? "lock" : "unlock"); - return err; -} - -static int s5k4ecgx_check_dataline(struct v4l2_subdev *sd, s32 val) -{ - cam_info("DTP %s\n", val ? "ON" : "OFF"); - return 0; -} - -static int s5k4ecgx_debug_sensor_status(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5k4ecgx_check_sensor_status(struct v4l2_subdev *sd) -{ - return 0; -} - -static inline int s5k4ecgx_check_esd(struct v4l2_subdev *sd) -{ - return 0; -} - -static int s5k4ecgx_set_preview_start(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -EINVAL; - - cam_info(" E\n"); - - if ((state->runmode == RUNMODE_NOTREADY) || - (state->runmode == RUNMODE_CAPTURING)) { - cam_err("%s: ERROR - Invalid runmode\n", __func__); - return -EPERM; - } - - state->focus.status = CAMERA_AF_STATUS_MAX; - - if (state->runmode == RUNMODE_CAPTURE_STOP) { - if (state->preflash != PREFLASH_OFF) { - err = state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - } - /* AE/AWB unlock */ - err = s5k4ecgx_set_ae_lock(sd, false); - err = s5k4ecgx_set_awb_lock(sd, false); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Preview_Return_EVT1,\ - sizeof(s5k4ecgx_Preview_Return_EVT1) / \ - sizeof(s5k4ecgx_Preview_Return_EVT1[0])); - } else { - switch (state->preview_frmsizes->index) { - case S5K4ECGX_PREVIEW_1280: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_1280_Preview_EVT1,\ - sizeof(s5k4ecgx_1280_Preview_EVT1) / \ - sizeof(s5k4ecgx_1280_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_1280\n"); - break; - case S5K4ECGX_PREVIEW_800: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_800_Preview_EVT1,\ - sizeof(s5k4ecgx_800_Preview_EVT1) / \ - sizeof(s5k4ecgx_800_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_800\n"); - break; - case S5K4ECGX_PREVIEW_720: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_720_Preview_EVT1,\ - sizeof(s5k4ecgx_720_Preview_EVT1) / \ - sizeof(s5k4ecgx_720_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_720\n"); - break; - case S5K4ECGX_PREVIEW_320: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_320_Preview_EVT1,\ - sizeof(s5k4ecgx_320_Preview_EVT1) / \ - sizeof(s5k4ecgx_320_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_320\n"); - break; - case S5K4ECGX_PREVIEW_176: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_176_Preview_EVT1,\ - sizeof(s5k4ecgx_176_Preview_EVT1) / \ - sizeof(s5k4ecgx_176_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_640\n"); - break; - case S5K4ECGX_PREVIEW_640: - default: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_640_Preview_EVT1,\ - sizeof(s5k4ecgx_640_Preview_EVT1) / \ - sizeof(s5k4ecgx_640_Preview_EVT1[0])); - cam_info("S5K4ECGX_PREVIEW_640\n"); - break; - } - - if (state->check_dataline) - err = s5k4ecgx_check_dataline(sd, 1); - } - - if (unlikely(err)) { - cam_err("fail to make preview\n"); - return err; - } - - state->runmode = RUNMODE_RUNNING; - - return 0; -} - -static int s5k4ecgx_set_preview_stop(struct v4l2_subdev *sd) -{ - int err = 0; - cam_info("do nothing.\n"); - - return err; -} - -static int s5k4ecgx_check_capture_status(struct v4l2_subdev *sd) -{ - int cnt = 0; - int status = 0; - int err = 0; - struct i2c_client *client = v4l2_get_subdevdata(sd); - - msleep(20); - while (cnt < 150) { - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E0244); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *) - &status); - CHECK_ERR(err); - - if (!status) - break; - msleep(20); - cnt++; - } - if (cnt) - pr_info("[s5k4ecgx] wait time for capture frame : %dms\n", - cnt * 10); - if (status) - pr_info("[s5k4ecgx] take picture failed.\n"); - - return 0; -} - -static int s5k4ecgx_set_capture_start(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -EINVAL; - cam_info(" E\n"); - /* check lowlight */ - if (state->lowlight) { - /* check scene mode */ - if (state->scene_mode != SCENE_MODE_NIGHTSHOT && - state->scene_mode != SCENE_MODE_FIREWORKS) { - /*low light capture start */ - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_Low_Cap_On_EVT1, \ - sizeof(s5k4ecgx_Low_Cap_On_EVT1) / \ - sizeof(s5k4ecgx_Low_Cap_On_EVT1[0])); - cam_info("s5k4ecgx_set_capture_start : s5k4ecgx_Low_Cap_On_EVT1\n"); - - /* check flash on */ - if (state->flash_mode == FLASH_MODE_AUTO || - state->flash_mode == FLASH_MODE_ON) { - /* AE/AWB unlock */ - err = s5k4ecgx_set_ae_lock(sd, false); - CHECK_ERR(err); - err = s5k4ecgx_set_awb_lock(sd, false); - CHECK_ERR(err); - /* Main flash on */ - state->pdata->flash_ctrl(CAM_FLASH_ON); - state->preflash = PREFLASH_ON; - /* 200ms AE delay */ - msleep(200); - } else - s5k4ecgx_cam_delay(sd); - } - } else { - /* check flash on */ - if (state->flash_mode == FLASH_MODE_ON) { - /* AE/AWB unlock */ - err = s5k4ecgx_set_ae_lock(sd, false); - CHECK_ERR(err); - err = s5k4ecgx_set_awb_lock(sd, false); - CHECK_ERR(err); - /* Main flash on */ - state->pdata->flash_ctrl(CAM_FLASH_ON); - state->preflash = PREFLASH_ON; - /* 200ms AE delay */ - msleep(200); - } - } - - /*capture start*/ - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Capture_Start_EVT1, \ - sizeof(s5k4ecgx_Capture_Start_EVT1) / \ - sizeof(s5k4ecgx_Capture_Start_EVT1[0])); - cam_info("s5k4ecgx_set_capture_start : s5k4ecgx_Capture_Start_EVT1\n"); - - state->runmode = RUNMODE_CAPTURING; - - /*capture delay*/ - err = s5k4ecgx_check_capture_status(sd); - - /* FIX later - temp code*/ - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - - if (unlikely(err)) { - cam_err("failed to make capture\n"); - return err; - } - - s5k4ecgx_get_exif(sd); - - return err; -} - -static int s5k4ecgx_set_sensor_mode(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct s5k4ecgx_state *state = to_state(sd); - - if ((ctrl->value != SENSOR_CAMERA) && - (ctrl->value != SENSOR_MOVIE)) { - cam_err("ERR: Not support.(%d)\n", ctrl->value); - return -EINVAL; - } - - state->sensor_mode = ctrl->value; - - return 0; -} - -static int s5k4ecgx_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt) -{ - cam_dbg("E\n"); - return 0; -} - -static int s5k4ecgx_enum_framesizes(struct v4l2_subdev *sd, \ - struct v4l2_frmsizeenum *fsize) -{ - struct s5k4ecgx_state *state = to_state(sd); - - cam_dbg("s5k4ecgx_enum_framesizes E\n"); - - /* - * Return the actual output settings programmed to the camera - * - * The camera interface should read this value, this is the resolution - * at which the sensor would provide framedata to the camera i/f - * In case of image capture, - * this returns the default camera resolution (VGA) - */ - if (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE) { - fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; - fsize->discrete.width = state->capture_frmsizes->width; - fsize->discrete.height = state->capture_frmsizes->height; - } else { - fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; - fsize->discrete.width = state->preview_frmsizes->width; - fsize->discrete.height = state->preview_frmsizes->height; - } - - cam_info("width - %d , height - %d\n", - fsize->discrete.width, fsize->discrete.height); - - return 0; -} - -static int s5k4ecgx_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt) -{ - int err = 0; - - cam_dbg("E\n"); - - return err; -} - -static int s5k4ecgx_set_fmt_size(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - cam_info("s5k4ecgx_set_fmt_size E\n"); - - if (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE) { - switch (state->capture_frmsizes->index) { - case S5K4ECGX_CAPTURE_5MP: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_5M_Capture_EVT1,\ - sizeof(s5k4ecgx_5M_Capture_EVT1) / - sizeof(s5k4ecgx_5M_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_5MP\n"); - break; - case S5K4ECGX_CAPTURE_3MP: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_3M_Capture_EVT1, - sizeof(s5k4ecgx_3M_Capture_EVT1) / - sizeof(s5k4ecgx_3M_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_3MP\n"); - break; - case S5K4ECGX_CAPTURE_2MP: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_2M_Capture_EVT1, - sizeof(s5k4ecgx_2M_Capture_EVT1) / - sizeof(s5k4ecgx_2M_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_2MP\n"); - break; - case S5K4ECGX_CAPTURE_1MP: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_1M_Capture_EVT1, - sizeof(s5k4ecgx_1M_Capture_EVT1) / - sizeof(s5k4ecgx_1M_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_1MP\n"); - break; - case S5K4ECGX_CAPTURE_XGA: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_XGA_Capture_EVT1, - sizeof(s5k4ecgx_XGA_Capture_EVT1) / - sizeof(s5k4ecgx_XGA_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_XGA\n"); - break; - case S5K4ECGX_CAPTURE_VGA: - err = s5k4ecgx_write_regs(sd, - s5k4ecgx_VGA_Capture_EVT1, - sizeof(s5k4ecgx_VGA_Capture_EVT1) / - sizeof(s5k4ecgx_VGA_Capture_EVT1[0])); - cam_info("s5k4ecgx_set_fmt_size : S5K4ECGX_CAPTURE_VGA\n"); - break; - default: - cam_err("ERR: Invalid capture size\n"); - break; - } - } - - if (unlikely(err < 0)) { - cam_err("i2c_write for set framerate\n"); - return -EIO; - } - - return err; -} - -static int s5k4ecgx_s_fmt(struct v4l2_subdev *sd, \ - struct v4l2_mbus_framefmt *ffmt) -{ - struct s5k4ecgx_state *state = to_state(sd); - u32 num_entries = 0; - u32 i; - u32 err = 0; - u32 width, height = 0; - - cam_info("s5k4ecgx_s_fmt E\n"); - /* - * Just copying the requested format as of now. - * We need to check here what are the formats the camera support, and - * set the most appropriate one according to the request from FIMC - */ - - width = state->req_fmt.width = ffmt->width; - height = state->req_fmt.height = ffmt->height; - - if (ffmt->colorspace == V4L2_COLORSPACE_JPEG) - state->req_fmt.priv = V4L2_PIX_FMT_MODE_CAPTURE; - else - state->req_fmt.priv = V4L2_PIX_FMT_MODE_PREVIEW; - - switch (state->req_fmt.priv) { - case V4L2_PIX_FMT_MODE_PREVIEW: - cam_info("V4L2_PIX_FMT_MODE_PREVIEW\n"); - num_entries = ARRAY_SIZE(preview_frmsizes); - for (i = 0; i < num_entries; i++) { - if (width == preview_frmsizes[i].width && - height == preview_frmsizes[i].height) { - state->preview_frmsizes = &preview_frmsizes[i]; - break; - } - if (i == (num_entries - 1)) - state->preview_frmsizes = &preview_frmsizes[0]; - } - break; - - case V4L2_PIX_FMT_MODE_CAPTURE: - cam_info("V4L2_PIX_FMT_MODE_CAPTURE\n"); - num_entries = ARRAY_SIZE(capture_frmsizes); - for (i = 0; i < num_entries; i++) { - if (width == capture_frmsizes[i].width && \ - height == capture_frmsizes[i].height) { - state->capture_frmsizes = &capture_frmsizes[i]; - break; - } - } - break; - - default: - cam_err - ("ERR(EINVAL) : Invalid capture size width(%d), height(%d)\n",\ - ffmt->width, ffmt->height); - return -EINVAL; - } - - /*set frame size of preview or capture*/ - err = s5k4ecgx_set_fmt_size(sd); - - return err; -} - -static int s5k4ecgx_set_frame_rate(struct v4l2_subdev *sd, u32 fps) -{ - int err = 0; - - cam_info("frame rate %d\n\n", fps); - - switch (fps) { - case 7: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_FPS_7_EVT1, - sizeof(s5k4ecgx_FPS_7_EVT1) / \ - sizeof(s5k4ecgx_FPS_7_EVT1[0])); - break; - case 15: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_FPS_15_EVT1, - sizeof(s5k4ecgx_FPS_15_EVT1) / \ - sizeof(s5k4ecgx_FPS_15_EVT1[0])); - - break; - case 20: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_FPS_20_EVT1, - sizeof(s5k4ecgx_FPS_20_EVT1) / \ - sizeof(s5k4ecgx_FPS_20_EVT1[0])); - - break; - case 24: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_FPS_24_EVT1, - sizeof(s5k4ecgx_FPS_24_EVT1) / \ - sizeof(s5k4ecgx_FPS_24_EVT1[0])); - break; - case 30: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_FPS_30_EVT1, - sizeof(s5k4ecgx_FPS_30_EVT1) / \ - sizeof(s5k4ecgx_FPS_30_EVT1[0])); - break; - default: - cam_err("ERR: Invalid framerate\n"); - break; - } - - if (unlikely(err < 0)) { - cam_err("i2c_write for set framerate\n"); - return -EIO; - } - - return err; -} - -static int s5k4ecgx_g_parm(struct v4l2_subdev *sd,\ - struct v4l2_streamparm *parms) -{ - int err = 0; - - cam_dbg("E\n"); - - return err; -} - -static int s5k4ecgx_s_parm(struct v4l2_subdev *sd, \ - struct v4l2_streamparm *parms) -{ - int err = 0; - u32 fps = 0; - u32 denom = parms->parm.capture.timeperframe.denominator; - u32 numer = parms->parm.capture.timeperframe.numerator; - struct s5k4ecgx_state *state = to_state(sd); - - cam_dbg("E\n"); - - if (denom >= 1 && numer == 1) - fps = denom / numer; - else if (denom == 1 && numer == 0) - fps = 0; - - if (fps != state->set_fps) { - if (fps < 0 && fps > 30) { - cam_err("invalid frame rate %d\n", fps); - fps = 30; - } - state->req_fps = fps; - - if (state->initialized) { - err = s5k4ecgx_set_frame_rate(sd, state->req_fps); - if (err >= 0) - state->set_fps = state->req_fps; - } - - } - - return err; -} - -static int s5k4ecgx_control_stream(struct v4l2_subdev *sd, int cmd) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - switch (cmd) { - case STREAM_START: - cam_warn("WARN: do nothing\n"); - break; - - case STREAM_STOP: - cam_dbg("stream stop!!!\n"); - if (state->runmode == RUNMODE_CAPTURING) - state->runmode = RUNMODE_CAPTURE_STOP; - - break; - - default: - cam_err("ERR: Invalid cmd\n"); - break; - } - - if (unlikely(err)) - cam_err("failed to stream start(stop)\n"); - - return err; -} - -static int s5k4ecgx_init(struct v4l2_subdev *sd, u32 val) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -EINVAL; - - cam_dbg("E\n"); - - /* set initial regster value */ - if (state->sensor_mode == SENSOR_CAMERA) { - cam_info("load camera common setting\n"); - err = s5k4ecgx_write_regs(sd, s5k4ecgx_init_reg1_EVT1, - sizeof(s5k4ecgx_init_reg1_EVT1) / \ - sizeof(s5k4ecgx_init_reg1_EVT1[0])); - - msleep(20); - - err |= s5k4ecgx_write_regs(sd, s5k4ecgx_init_reg2_EVT1, - sizeof(s5k4ecgx_init_reg2_EVT1) / \ - sizeof(s5k4ecgx_init_reg2_EVT1[0])); - } else { - cam_info("load recording setting\n"); - err = s5k4ecgx_write_regs(sd, s5k4ecgx_init_reg1_EVT1, - sizeof(s5k4ecgx_init_reg1_EVT1) / \ - sizeof(s5k4ecgx_init_reg1_EVT1[0])); - - msleep(20); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_init_reg2_EVT1, - sizeof(s5k4ecgx_init_reg2_EVT1) / \ - sizeof(s5k4ecgx_init_reg2_EVT1[0])); - } - - if (unlikely(err)) { - cam_err("failed to init\n"); - return err; - } - - state->runmode = RUNMODE_INIT; - - /* We stop stream-output from sensor when starting camera. */ - err = s5k4ecgx_control_stream(sd, STREAM_STOP); - if (unlikely(err < 0)) - return err; - msleep(150); - - state->initialized = 1; - - return 0; -} - -static int s5k4ecgx_s_stream(struct v4l2_subdev *sd, int enable) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - cam_info("stream mode = %d\n", enable); - - switch (enable) { - case STREAM_MODE_CAM_OFF: - if (state->sensor_mode == SENSOR_CAMERA) { - if (state->check_dataline) - err = s5k4ecgx_check_dataline(sd, 0); - else - err = s5k4ecgx_control_stream(sd, STREAM_STOP); - } - break; - - case STREAM_MODE_CAM_ON: - /* The position of this code need to be adjusted later */ - if ((state->sensor_mode == SENSOR_CAMERA) - && (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE)) - err = s5k4ecgx_set_capture_start(sd); - else - err = s5k4ecgx_set_preview_start(sd); - break; - - case STREAM_MODE_MOVIE_ON: - cam_dbg("do nothing(movie on)!!\n"); - break; - - case STREAM_MODE_MOVIE_OFF: - cam_dbg("do nothing(movie off)!!\n"); - break; - - default: - cam_err("ERR: Invalid stream mode\n"); - break; - } - - if (unlikely(err < 0)) { - cam_err("ERR: faild\n"); - return err; - } - - return 0; -} - -static int s5k4ecgx_get_af_1stsearch(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - int af_status = -1; - int err = 0; - int ret = 0; - cam_info("- Start\n"); - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2EEE); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *)&af_status); - CHECK_ERR(err); - - switch (af_status & 0xff) { - case AF_PROGRESS_1ST: - ret = CAMERA_AF_STATUS_IN_PROGRESS; - break; - - case AF_SUCCESS_1ST: - ret = CAMERA_AF_STATUS_SUCCESS; - break; - - case AF_FAIL_1ST: - default: - ret = CAMERA_AF_STATUS_FAIL; - break; - } - - ctrl->value = ret; - cam_info("- END%d\n", ret); - return ret; -} - -static int s5k4ecgx_get_af_2ndsearch(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - int af_status = -1; - int err = 0; - int ret = 0; - cam_info(" E\n"); - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2207); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, (unsigned short *)&af_status); - CHECK_ERR(err); - - switch (af_status & 0xff) { - case AF_SUCCESS_2ND: - ret = CAMERA_AF_STATUS_SUCCESS; - break; - - case AF_PROGRESS_2ND: - default: - ret = CAMERA_AF_STATUS_IN_PROGRESS; - break; - } - - ctrl->value = ret; - cam_info(" - END%d\n", ret); - return ret; -} - -static int s5k4ecgx_get_af_result(struct v4l2_subdev *sd, - struct v4l2_control *ctrl) -{ - struct s5k4ecgx_state *state = to_state(sd); - int status = 0; - cam_info(" - START\n"); - if (state->focus.first == true) { - state->focus.first = false; - s5k4ecgx_cam_delay(sd); - } - - /* 1st search af */ - s5k4ecgx_cam_delay(sd); - - status = s5k4ecgx_get_af_1stsearch(sd, ctrl); - - if (status != CAMERA_AF_STATUS_SUCCESS) { - state->focus.status = status; - if (status == CAMERA_AF_STATUS_FAIL) - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - return status; - } - - /* 2nd search af */ - s5k4ecgx_cam_delay(sd); - - status = s5k4ecgx_get_af_2ndsearch(sd, ctrl); - - state->focus.status = status; - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - - cam_info("af_status = %d\n", status); - cam_info(" - END\n"); - return 0; -} - - -static int s5k4ecgx_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - /* V4L2_CID_PRIVATE_BASE==0x08000000 */ - /* V4L2_CID_CAMERA_CLASS_BASE==0x009a0900 */ - /* V4L2_CID_BASE==0x00980900 */ - - if (ctrl->id > V4L2_CID_PRIVATE_BASE) - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_PRIVATE_BASE\n",\ - ctrl->id - V4L2_CID_PRIVATE_BASE, ctrl->value); - else if (ctrl->id > V4L2_CID_CAMERA_CLASS_BASE) - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_CAMERA_CLASS_BASE\n",\ - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE, ctrl->value); - else - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_BASE\n", \ - ctrl->id - V4L2_CID_BASE, ctrl->value); - - mutex_lock(&state->ctrl_lock); - - switch (ctrl->id) { - case V4L2_CID_CAMERA_AUTO_FOCUS_RESULT: - ctrl->value = state->focus.status; - break; - - case V4L2_CID_CAM_JPEG_MEMSIZE: - ctrl->value = S5K4ECGX_INTLV_DATA_MAXSIZE; - break; - - case V4L2_CID_CAM_JPEG_MAIN_SIZE: - ctrl->value = S5K4ECGX_INTLV_DATA_MAXSIZE; - break; - - case V4L2_CID_CAM_JPEG_MAIN_OFFSET: - ctrl->value = 0; - break; - - case V4L2_CID_CAM_JPEG_THUMB_SIZE: - ctrl->value = 0; - break; - - case V4L2_CID_CAM_JPEG_THUMB_OFFSET: - ctrl->value = 0; - break; - - case V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET: - ctrl->value = 0; - break; - - case V4L2_CID_CAMERA_EXIF_FLASH: - ctrl->value = state->exif.flash; - break; - - case V4L2_CID_CAMERA_ISO: - ctrl->value = state->exif.iso; - break; - - case V4L2_CID_CAMERA_EXIF_ISO: - ctrl->value = state->exif.iso; - break; - - case V4L2_CID_CAMERA_EXIF_TV: - ctrl->value = state->exif.tv; - break; - - case V4L2_CID_CAMERA_EXIF_BV: - ctrl->value = state->exif.bv; - break; - - case V4L2_CID_CAMERA_EXIF_EBV: - ctrl->value = state->exif.ebv; - break; - - case V4L2_CID_WHITE_BALANCE_PRESET: - ctrl->value = state->wb_mode; - break; - - default: - cam_err("no such control id %d\n", - ctrl->id - V4L2_CID_PRIVATE_BASE); - break; - } - - mutex_unlock(&state->ctrl_lock); - - return err; -} - -static int s5k4ecgx_set_iso(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - int err; - struct s5k4ecgx_state *state = to_state(sd); - cam_dbg("E, value %d\n", ctrl->value); - -retry: - switch (ctrl->value) { - case ISO_AUTO: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ISO_Auto_EVT1, \ - sizeof(s5k4ecgx_ISO_Auto_EVT1) / \ - sizeof(s5k4ecgx_ISO_Auto_EVT1[0])); - break; - - case ISO_50: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ISO_50_EVT1, \ - sizeof(s5k4ecgx_ISO_50_EVT1) / \ - sizeof(s5k4ecgx_ISO_50_EVT1[0])); - break; - - case ISO_100: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ISO_100_EVT1, \ - sizeof(s5k4ecgx_ISO_100_EVT1) / \ - sizeof(s5k4ecgx_ISO_100_EVT1[0])); - break; - - case ISO_200: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ISO_200_EVT1, \ - sizeof(s5k4ecgx_ISO_200_EVT1) / \ - sizeof(s5k4ecgx_ISO_200_EVT1[0])); - break; - - case ISO_400: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_ISO_400_EVT1, \ - sizeof(s5k4ecgx_ISO_400_EVT1) / \ - sizeof(s5k4ecgx_ISO_400_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", ctrl->value); - ctrl->value = ISO_AUTO; - goto retry; - } - - state->exif.iso = ctrl->value; - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_metering(struct v4l2_subdev *sd, int val) -{ - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case METERING_CENTER: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Metering_Center_EVT1, \ - sizeof(s5k4ecgx_Metering_Center_EVT1) / \ - sizeof(s5k4ecgx_Metering_Center_EVT1[0])); - break; - - case METERING_SPOT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Metering_Spot_EVT1, \ - sizeof(s5k4ecgx_Metering_Spot_EVT1) / \ - sizeof(s5k4ecgx_Metering_Spot_EVT1[0])); - break; - - case METERING_MATRIX: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Metering_Matrix_EVT1, \ - sizeof(s5k4ecgx_Metering_Matrix_EVT1) / \ - sizeof(s5k4ecgx_Metering_Matrix_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = METERING_CENTER; - goto retry; - } - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_exposure(struct v4l2_subdev *sd, \ - struct v4l2_control *ctrl) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -EINVAL; - - cam_dbg("E\n"); - - if (state->check_dataline) - return 0; - - switch (ctrl->value) { - case 0: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Minus_4_EVT1, \ - sizeof(s5k4ecgx_EV_Minus_4_EVT1) / \ - sizeof(s5k4ecgx_EV_Minus_4_EVT1[0])); - break; - case 1: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Minus_3_EVT1, \ - sizeof(s5k4ecgx_EV_Minus_3_EVT1) / \ - sizeof(s5k4ecgx_EV_Minus_3_EVT1[0])); - - break; - case 2: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Minus_2_EVT1, \ - sizeof(s5k4ecgx_EV_Minus_2_EVT1) / \ - sizeof(s5k4ecgx_EV_Minus_2_EVT1[0])); - break; - case 3: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Minus_1_EVT1, \ - sizeof(s5k4ecgx_EV_Minus_1_EVT1) / \ - sizeof(s5k4ecgx_EV_Minus_1_EVT1[0])); - break; - case 4: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Default_EVT1, \ - sizeof(s5k4ecgx_EV_Default_EVT1) / \ - sizeof(s5k4ecgx_EV_Default_EVT1[0])); - break; - case 5: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Plus_1_EVT1, \ - sizeof(s5k4ecgx_EV_Plus_1_EVT1) / \ - sizeof(s5k4ecgx_EV_Plus_1_EVT1[0])); - break; - case 6: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Plus_2_EVT1, \ - sizeof(s5k4ecgx_EV_Plus_2_EVT1) / \ - sizeof(s5k4ecgx_EV_Plus_2_EVT1[0])); - break; - case 7: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Plus_3_EVT1, \ - sizeof(s5k4ecgx_EV_Plus_3_EVT1) / \ - sizeof(s5k4ecgx_EV_Plus_3_EVT1[0])); - break; - case 8: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_EV_Plus_4_EVT1, \ - sizeof(s5k4ecgx_EV_Plus_4_EVT1) / \ - sizeof(s5k4ecgx_EV_Plus_4_EVT1[0])); - break; - default: - cam_err("ERR: invalid brightness(%d)\n", ctrl->value); - return err; - break; - } - - if (unlikely(err < 0)) { - cam_err("ERR: i2c_write for set brightness\n"); - return -EIO; - } - - return 0; -} - -static int s5k4ecgx_set_whitebalance(struct v4l2_subdev *sd, int val) -{ - int err; - struct s5k4ecgx_state *state = to_state(sd); - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case WHITE_BALANCE_AUTO: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WB_Auto_EVT1, \ - sizeof(s5k4ecgx_WB_Auto_EVT1) / \ - sizeof(s5k4ecgx_WB_Auto_EVT1[0])); - break; - - case WHITE_BALANCE_SUNNY: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WB_Sunny_EVT1, \ - sizeof(s5k4ecgx_WB_Sunny_EVT1) / \ - sizeof(s5k4ecgx_WB_Sunny_EVT1[0])); - break; - - case WHITE_BALANCE_CLOUDY: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WB_Cloudy_EVT1, \ - sizeof(s5k4ecgx_WB_Cloudy_EVT1) / \ - sizeof(s5k4ecgx_WB_Cloudy_EVT1[0])); - break; - - case WHITE_BALANCE_TUNGSTEN: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WB_Tungsten_EVT1, \ - sizeof(s5k4ecgx_WB_Tungsten_EVT1) / \ - sizeof(s5k4ecgx_WB_Tungsten_EVT1[0])); - break; - - case WHITE_BALANCE_FLUORESCENT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WB_Fluorescent_EVT1, \ - sizeof(s5k4ecgx_WB_Fluorescent_EVT1) / \ - sizeof(s5k4ecgx_WB_Fluorescent_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = WHITE_BALANCE_AUTO; - goto retry; - } - - state->wb_mode = val; - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_scene_mode(struct v4l2_subdev *sd, int val) -{ - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case SCENE_MODE_NONE: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Default_EVT1, \ - sizeof(s5k4ecgx_Scene_Default_EVT1) / \ - sizeof(s5k4ecgx_Scene_Default_EVT1[0])); - break; - - case SCENE_MODE_PORTRAIT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Portrait_EVT1, \ - sizeof(s5k4ecgx_Scene_Portrait_EVT1) / \ - sizeof(s5k4ecgx_Scene_Portrait_EVT1[0])); - break; - - case SCENE_MODE_LANDSCAPE: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Landscape_EVT1, \ - sizeof(s5k4ecgx_Scene_Landscape_EVT1) / \ - sizeof(s5k4ecgx_Scene_Landscape_EVT1[0])); - break; - - case SCENE_MODE_SPORTS: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Sports_EVT1, \ - sizeof(s5k4ecgx_Scene_Sports_EVT1) / \ - sizeof(s5k4ecgx_Scene_Sports_EVT1[0])); - break; - - case SCENE_MODE_PARTY_INDOOR: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Party_Indoor_EVT1,\ - sizeof(s5k4ecgx_Scene_Party_Indoor_EVT1) / \ - sizeof(s5k4ecgx_Scene_Party_Indoor_EVT1[0])); - break; - - case SCENE_MODE_BEACH_SNOW: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Beach_Snow_EVT1, \ - sizeof(s5k4ecgx_Scene_Beach_Snow_EVT1) / \ - sizeof(s5k4ecgx_Scene_Beach_Snow_EVT1[0])); - break; - - case SCENE_MODE_SUNSET: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Sunset_EVT1, \ - sizeof(s5k4ecgx_Scene_Sunset_EVT1) / \ - sizeof(s5k4ecgx_Scene_Sunset_EVT1[0])); - break; - - case SCENE_MODE_DUSK_DAWN: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Duskdawn_EVT1, \ - sizeof(s5k4ecgx_Scene_Duskdawn_EVT1) / \ - sizeof(s5k4ecgx_Scene_Duskdawn_EVT1[0])); - break; - - case SCENE_MODE_FALL_COLOR: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Fall_Color_EVT1, \ - sizeof(s5k4ecgx_Scene_Fall_Color_EVT1) / \ - sizeof(s5k4ecgx_Scene_Fall_Color_EVT1[0])); - break; - - case SCENE_MODE_NIGHTSHOT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Nightshot_EVT1, \ - sizeof(s5k4ecgx_Scene_Nightshot_EVT1) / \ - sizeof(s5k4ecgx_Scene_Nightshot_EVT1[0])); - break; - - case SCENE_MODE_BACK_LIGHT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Backlight_EVT1, \ - sizeof(s5k4ecgx_Scene_Backlight_EVT1) / \ - sizeof(s5k4ecgx_Scene_Backlight_EVT1[0])); - break; - - case SCENE_MODE_FIREWORKS: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Fireworks_EVT1, \ - sizeof(s5k4ecgx_Scene_Fireworks_EVT1) / \ - sizeof(s5k4ecgx_Scene_Fireworks_EVT1[0])); - break; - - case SCENE_MODE_TEXT: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Scene_Text_EVT1, \ - sizeof(s5k4ecgx_Scene_Text_EVT1) / \ - sizeof(s5k4ecgx_Scene_Text_EVT1[0])); - break; - - case SCENE_MODE_CANDLE_LIGHT: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_Scene_Candle_Light_EVT1, \ - sizeof(s5k4ecgx_Scene_Candle_Light_EVT1) / \ - sizeof(s5k4ecgx_Scene_Candle_Light_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = SCENE_MODE_NONE; - goto retry; - } - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_effect(struct v4l2_subdev *sd, int val) -{ - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case IMAGE_EFFECT_NONE: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Effect_Normal_EVT1, \ - sizeof(s5k4ecgx_Effect_Normal_EVT1) / \ - sizeof(s5k4ecgx_Effect_Normal_EVT1[0])); - break; - - case IMAGE_EFFECT_SEPIA: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Effect_Sepia_EVT1, \ - sizeof(s5k4ecgx_Effect_Sepia_EVT1) / \ - sizeof(s5k4ecgx_Effect_Sepia_EVT1[0])); - break; - - case IMAGE_EFFECT_BNW: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_Effect_Black_White_EVT1, \ - sizeof(s5k4ecgx_Effect_Black_White_EVT1) / \ - sizeof(s5k4ecgx_Effect_Black_White_EVT1[0])); - break; - - case IMAGE_EFFECT_NEGATIVE: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Effect_Negative_EVT1, \ - sizeof(s5k4ecgx_Effect_Negative_EVT1) / \ - sizeof(s5k4ecgx_Effect_Negative_EVT1[0])); - break; - - case IMAGE_EFFECT_AQUA: - err = s5k4ecgx_write_regs(sd, \ - s5k4ecgx_Effect_Solarization_EVT1, \ - sizeof(s5k4ecgx_Effect_Solarization_EVT1) / \ - sizeof(s5k4ecgx_Effect_Solarization_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = IMAGE_EFFECT_NONE; - goto retry; - } - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_wdr(struct v4l2_subdev *sd, int val) -{ - int err; - cam_dbg("E, value %d\n", val); - -retry: - switch (val) { - case WDR_OFF: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WDR_off_EVT1, \ - sizeof(s5k4ecgx_WDR_off_EVT1) / \ - sizeof(s5k4ecgx_WDR_off_EVT1[0])); - break; - - case WDR_ON: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_WDR_on_EVT1, \ - sizeof(s5k4ecgx_WDR_on_EVT1) / \ - sizeof(s5k4ecgx_WDR_on_EVT1[0])); - break; - - default: - cam_warn("invalid value, %d\n", val); - val = WDR_OFF; - goto retry; - } - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_set_jpeg_quality(struct v4l2_subdev *sd, int val) -{ - int err = -1; - cam_dbg("E, value %d\n", val); - - if (val <= 65) /* Normal */ - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Jpeg_Quality_Low_EVT1,\ - sizeof(s5k4ecgx_Jpeg_Quality_Low_EVT1) / \ - sizeof(s5k4ecgx_Jpeg_Quality_Low_EVT1[0])); - else if (val <= 75) /* Fine */ - err = s5k4ecgx_write_regs - (sd, s5k4ecgx_Jpeg_Quality_Normal_EVT1,\ - sizeof(s5k4ecgx_Jpeg_Quality_Normal_EVT1) / \ - sizeof(s5k4ecgx_Jpeg_Quality_Normal_EVT1[0])); - else /* Superfine */ - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Jpeg_Quality_High_EVT1,\ - sizeof(s5k4ecgx_Jpeg_Quality_High_EVT1) / \ - sizeof(s5k4ecgx_Jpeg_Quality_High_EVT1[0])); - - CHECK_ERR(err); - - cam_dbg("X\n"); - return 0; -} - -static int s5k4ecgx_return_focus(struct v4l2_subdev *sd) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -EINVAL; - - cam_info("E\n"); - - switch (state->focus.mode) { - case FOCUS_MODE_MACRO: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_1_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_1_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_1_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_2_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_2_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_2_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_3_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_3_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_3_EVT1[0])); - - break; - - default: - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_1_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_1_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_1_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_2_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_2_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_2_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_3_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_3_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_3_EVT1[0])); - - break; - } - - CHECK_ERR(err); - return 0; -} - -/* PX: Stop AF */ -static int s5k4ecgx_stop_af(struct v4l2_subdev *sd, s32 touch) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - cam_info("E\n"); - mutex_lock(&state->af_lock); - - switch (state->focus.status) { - case CAMERA_AF_STATUS_FAIL: - case CAMERA_AF_STATUS_SUCCESS: - cam_dbg("Stop AF, focus mode %d, AF result %d\n", - state->focus.mode, state->focus.status); - - err = s5k4ecgx_set_ae_lock(sd, false); - err = s5k4ecgx_set_awb_lock(sd, false); - if (unlikely(err)) { - cam_err("%s: ERROR, fail to set lock\n", __func__); - goto err_out; - } - state->focus.status = CAMERA_AF_STATUS_MAX; - state->preflash = PREFLASH_NONE; - break; - - case CAMERA_AF_STATUS_MAX: - break; - - default: - cam_err("%s: WARNING, unnecessary calling. AF status=%d\n", - __func__, state->focus.status); - /* Return 0. */ - goto err_out; - break; - } - - if (!touch) { - /* We move lens to default position if af is cancelled.*/ - err = s5k4ecgx_return_focus(sd); - if (unlikely(err)) { - cam_err("%s: ERROR, fail to af_norma_mode (%d)\n", - __func__, err); - goto err_out; - } - } - - mutex_unlock(&state->af_lock); - cam_info("X\n"); - return 0; - -err_out: - mutex_unlock(&state->af_lock); - return err; -} - -static int s5k4ecgx_set_af_mode(struct v4l2_subdev *sd, int val) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = -1; - u32 af_cancel = 0; - cam_info(" - value %d\n", val); - - mutex_lock(&state->af_lock); - -retry: - af_cancel = (u32)val & FOCUS_MODE_DEFAULT; - switch (val) { - case FOCUS_MODE_AUTO: - case FOCUS_MODE_INFINITY: - state->focus.mode = val; - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_1_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_1_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_1_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_2_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_2_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_2_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Normal_mode_3_EVT1,\ - sizeof(s5k4ecgx_AF_Normal_mode_3_EVT1) / \ - sizeof(s5k4ecgx_AF_Normal_mode_3_EVT1[0])); - - break; - - case FOCUS_MODE_MACRO: - state->focus.mode = val; - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_1_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_1_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_1_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_2_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_2_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_2_EVT1[0])); - - s5k4ecgx_cam_delay(sd); - - err = s5k4ecgx_write_regs(sd, s5k4ecgx_AF_Macro_mode_3_EVT1,\ - sizeof(s5k4ecgx_AF_Macro_mode_3_EVT1) / \ - sizeof(s5k4ecgx_AF_Macro_mode_3_EVT1[0])); - - break; - - default: - cam_warn("invalid value, %d\n", val); - val = FOCUS_MODE_AUTO; - goto retry; - } - - state->focus.mode = val; - mutex_unlock(&state->af_lock); - - if (af_cancel) - s5k4ecgx_stop_af(sd, 0); - - return 0; - - CHECK_ERR(err); - return 0; -} - -/* PX: Do AF */ -static int s5k4ecgx_do_af(struct v4l2_subdev *sd) -{ - struct i2c_client *client = v4l2_get_subdevdata(sd); - struct s5k4ecgx_state *state = to_state(sd); - u16 read_value = 0; - u32 count = 0; - int err = 0; - - cam_info("E\n"); - - /* AE, AWB Lock */ - err = s5k4ecgx_set_ae_lock(sd, true); - CHECK_ERR(err); - err = s5k4ecgx_set_awb_lock(sd, true); - CHECK_ERR(err); - - /* AF start */ - err = s5k4ecgx_write_regs(sd, s5k4ecgx_Single_AF_Start_EVT1,\ - sizeof(s5k4ecgx_Single_AF_Start_EVT1) / \ - sizeof(s5k4ecgx_Single_AF_Start_EVT1[0])); - CHECK_ERR(err); - - /* 1 frame delay */ - s5k4ecgx_cam_delay(sd); - - /* AF Searching */ - cam_dbg("AF 1st search\n"); - - /*1st search*/ - for (count = 0; count < FIRST_AF_SEARCH_COUNT; count++) { - if (state->focus.start == AUTO_FOCUS_OFF) { - cam_dbg("do_af: AF is cancelled while doing(1st)\n"); - state->focus.status = CAMERA_AF_STATUS_MAX; - goto check_done; - } - - /* 1 frame delay */ - s5k4ecgx_cam_delay(sd); - - read_value = 0x0; - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2EEE); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, &read_value); - CHECK_ERR(err); - cam_info("1st AF status(%02d) = 0x%04X\n", - count, read_value); - - if ((read_value & 0xff) != AF_PROGRESS_1ST) - break; - } - - if ((read_value & 0xff) != AF_SUCCESS_1ST) { - cam_err("%s: ERROR, 1st AF failed. count=%d, read_val=0x%X\n\n", - __func__, count, read_value); - state->focus.status = CAMERA_AF_STATUS_FAIL; - goto check_done; - } - - /*2nd search*/ - cam_dbg("AF 2nd search\n"); - for (count = 0; count < SECOND_AF_SEARCH_COUNT; count++) { - if (state->focus.start == AUTO_FOCUS_OFF) { - cam_dbg("do_af: AF is cancelled while doing(2nd)\n"); - state->focus.status = CAMERA_AF_STATUS_MAX; - goto check_done; - } - - read_value = 0x0; - err = s5k4ecgx_write(client, 0x002C7000); - CHECK_ERR(err); - err = s5k4ecgx_write(client, 0x002E2207); - CHECK_ERR(err); - err = s5k4ecgx_read(client, 0x0F12, &read_value); - CHECK_ERR(err); - cam_info("2nd AF status(%02d) = 0x%04X\n", - count, read_value); - if ((read_value & 0xff) == AF_SUCCESS_2ND) - break; - } - - if (count >= SECOND_AF_SEARCH_COUNT) { - /* 0x01XX means "Not Finish". */ - cam_err("%s: ERROR, 2nd AF failed. read_val=0x%X\n\n", - __func__, read_value & 0xff); - state->focus.status = CAMERA_AF_STATUS_FAIL; - goto check_done; - } - - cam_info("AF Success!\n"); - state->focus.status = CAMERA_AF_STATUS_SUCCESS; - -check_done: - /* restore write mode */ - - /* We only unlocked AE,AWB in case of being cancelled. - * But we now unlock it unconditionally if AF is started, - */ - if (state->focus.status == CAMERA_AF_STATUS_MAX) { - cam_dbg("%s: Single AF cancelled.\n", __func__); - /* AE, AWB Lock */ - err = s5k4ecgx_set_ae_lock(sd, false); - CHECK_ERR(err); - err = s5k4ecgx_set_awb_lock(sd, false); - CHECK_ERR(err); - } else { - state->focus.start = AUTO_FOCUS_OFF; - cam_dbg("%s: Single AF finished\n", __func__); - } - - if ((state->preflash == PREFLASH_ON) && - (state->sensor_mode == SENSOR_CAMERA)) { - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - if (state->focus.status == CAMERA_AF_STATUS_MAX) - state->preflash = PREFLASH_NONE; - } - - /* Notice: we here turn touch flag off set previously - * when doing Touch AF. */ - - return 0; -} - -static void s5k4ecgx_af_worker(struct work_struct *work) -{ - struct s5k4ecgx_state *state = container_of(work, \ - struct s5k4ecgx_state, af_work); - struct v4l2_subdev *sd = &state->sd; - int err = -EINVAL; - - cam_info("E\n"); - - mutex_lock(&state->af_lock); - - /* 1. Check Low Light */ - err = s5k4ecgx_get_lux(sd); - - /* 2. Turn on Pre Flash */ - switch (state->flash_mode) { - case FLASH_MODE_AUTO: - if (!state->lowlight) { - /* flash not needed */ - break; - } - - case FLASH_MODE_ON: - state->pdata->flash_ctrl(CAM_FLASH_TORCH); - state->preflash = PREFLASH_ON; - break; - - case FLASH_MODE_OFF: - default: - break; - } - - if (state->preflash == PREFLASH_ON) { - /* 3. Waiting until AE Stable */ - err = s5k4ecgx_ae_stable(sd); - } else if (state->focus.start == AUTO_FOCUS_OFF) { - cam_info("af_start_preflash: AF is cancelled!\n"); - state->focus.status = CAMERA_AF_STATUS_MAX; - } - - if (state->focus.status == CAMERA_AF_STATUS_MAX) { - if (state->preflash == PREFLASH_ON) { - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - } - goto out; - } - - s5k4ecgx_do_af(sd); - -out: - mutex_unlock(&state->af_lock); - cam_info("X\n"); - return; -} - -static int s5k4ecgx_set_af(struct v4l2_subdev *sd, s32 val) -{ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - cam_info("%s: %s, focus mode %d\n", __func__, - val ? "start" : "stop", state->focus.mode); - - if (unlikely((u32)val >= AUTO_FOCUS_MAX)) { - cam_err("%s: ERROR, invalid value(%d)\n", __func__, val); - return -EINVAL; - } - -/* need to check the AF scenario with SLP team - temp code */ -/* - if (state->focus.start == val) - return 0; -*/ - state->focus.start = val; - - if (val == AUTO_FOCUS_ON) { - err = queue_work(state->workqueue, &state->af_work); - if (likely(err)) - state->focus.status = CAMERA_AF_STATUS_IN_PROGRESS; - else - cam_warn("WARNING, AF is still processing. So new AF cannot start\n"); - } else { - /* Cancel AF */ - /* 1. AE/AWB UnLock */ - err = s5k4ecgx_set_ae_lock(sd, false); - CHECK_ERR(err); - err = s5k4ecgx_set_awb_lock(sd, false); - CHECK_ERR(err); - /* 2. Turn off on pre flash */ - state->pdata->flash_ctrl(CAM_FLASH_OFF); - state->preflash = PREFLASH_OFF; - /* 3. Cancel AF mode */ - err = s5k4ecgx_set_af_mode(sd, state->focus.mode); - cam_info("set_af: AF cancel requested!\n"); - } - - cam_info("X\n"); - return 0; -} - -static int s5k4ecgx_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) -{ - /* struct i2c_client *client = v4l2_get_subdevdata(sd); */ - struct s5k4ecgx_state *state = to_state(sd); - int err = 0; - - /* V4L2_CID_PRIVATE_BASE == 0x08000000 */ - /* V4L2_CID_CAMERA_CLASS_BASE == 0x009a0900 */ - /* V4L2_CID_BASE == 0x00980900 */ - - if (ctrl->id > V4L2_CID_PRIVATE_BASE) - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_PRIVATE_BASE\n", \ - ctrl->id - V4L2_CID_PRIVATE_BASE, ctrl->value); - else if (ctrl->id > V4L2_CID_CAMERA_CLASS_BASE) - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_CAMERA_CLASS_BASE\n",\ - ctrl->id - V4L2_CID_CAMERA_CLASS_BASE, ctrl->value); - else - cam_dbg("ctrl->id:%d, value=%d V4L2_CID_BASE\n", \ - ctrl->id - V4L2_CID_BASE, ctrl->value); - - if ((ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE) - && (ctrl->id != V4L2_CID_CAMERA_SENSOR_MODE) - && ((ctrl->id != V4L2_CID_CAMERA_VT_MODE)) - && (!state->initialized)) { - cam_warn("camera isn't initialized\n"); - return 0; - } - - if (ctrl->id != V4L2_CID_CAMERA_SET_AUTO_FOCUS) - mutex_lock(&state->ctrl_lock); - - switch (ctrl->id) { - case V4L2_CID_CAM_JPEG_QUALITY: - err = s5k4ecgx_set_jpeg_quality(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_ISO: - err = s5k4ecgx_set_iso(sd, ctrl); - break; - - case V4L2_CID_CAMERA_METERING: - if (state->sensor_mode == SENSOR_CAMERA) - err = s5k4ecgx_set_metering(sd, ctrl->value); - break; - - case V4L2_CID_EXPOSURE: - err = s5k4ecgx_set_exposure(sd, ctrl); - cam_dbg("V4L2_CID_EXPOSURE [%d]\n", ctrl->value); - break; - - case V4L2_CID_WHITE_BALANCE_PRESET: - case V4L2_CID_CAMERA_WHITE_BALANCE: - err = s5k4ecgx_set_whitebalance(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_SCENE_MODE: - state->scene_mode = ctrl->value; - err = s5k4ecgx_set_scene_mode(sd, ctrl->value); - break; - - case V4L2_CID_COLORFX: - err = s5k4ecgx_set_effect(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_WDR: - err = s5k4ecgx_set_wdr(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_FLASH_MODE: - state->flash_mode = ctrl->value; - break; - - case V4L2_CID_FOCUS_AUTO_MODE: - case V4L2_CID_CAMERA_FOCUS_MODE: - err = s5k4ecgx_set_af_mode(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_SET_AUTO_FOCUS: - err = s5k4ecgx_set_af(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_CHECK_DATALINE: - state->check_dataline = ctrl->value; - cam_dbg("check_dataline = %d\n", state->check_dataline); - err = 0; - break; - - case V4L2_CID_CAMERA_SENSOR_MODE: - err = s5k4ecgx_set_sensor_mode(sd, ctrl); - cam_dbg("sensor_mode = %d\n", ctrl->value); - break; - - case V4L2_CID_CAMERA_CHECK_DATALINE_STOP: - cam_dbg("do nothing\n"); - break; - - case V4L2_CID_CAMERA_CHECK_ESD: - err = s5k4ecgx_check_esd(sd); - break; - - case V4L2_CID_CAMERA_FRAME_RATE: - err = s5k4ecgx_set_frame_rate(sd, ctrl->value); - break; - - case V4L2_CID_CAMERA_CHECK_SENSOR_STATUS: - s5k4ecgx_debug_sensor_status(sd); - err = s5k4ecgx_check_sensor_status(sd); - break; - - default: - cam_err("ERR(ENOIOCTLCMD)\n"); - /* no errors return.*/ - break; - } - - if (ctrl->id != V4L2_CID_CAMERA_SET_AUTO_FOCUS) - mutex_unlock(&state->ctrl_lock); - - cam_dbg("X\n"); - return err; -} - -static const struct v4l2_subdev_core_ops s5k4ecgx_core_ops = { - .init = s5k4ecgx_init, /* initializing API */ - .g_ctrl = s5k4ecgx_g_ctrl, - .s_ctrl = s5k4ecgx_s_ctrl, -}; - -static const struct v4l2_subdev_video_ops s5k4ecgx_video_ops = { - .s_mbus_fmt = s5k4ecgx_s_fmt, - .s_stream = s5k4ecgx_s_stream, - .enum_framesizes = s5k4ecgx_enum_framesizes, - .g_parm = s5k4ecgx_g_parm, - .s_parm = s5k4ecgx_s_parm, -}; - -static const struct v4l2_subdev_ops s5k4ecgx_ops = { - .core = &s5k4ecgx_core_ops, - .video = &s5k4ecgx_video_ops, -}; - -/* - * s5k4ecgx_probe - * Fetching platform data is being done with s_config subdev call. - * In probe routine, we just register subdev device - */ -static int s5k4ecgx_probe(struct i2c_client *client, - const struct i2c_device_id *id) -{ - struct s5k4ecgx_state *state = NULL; - struct v4l2_subdev *sd = NULL; - struct s5k4ecgx_platform_data *pdata = NULL; - cam_dbg("E\n"); - - state = kzalloc(sizeof(struct s5k4ecgx_state), GFP_KERNEL); - if (state == NULL) - return -ENOMEM; - - sd = &state->sd; - strcpy(sd->name, S5K4ECGX_DRIVER_NAME); - - state->runmode = RUNMODE_NOTREADY; - state->initialized = 0; - state->req_fps = state->set_fps = 0; - state->sensor_mode = SENSOR_CAMERA; - state->zoom = 0; - state->flash_mode = FLASH_MODE_BASE; - state->lowlight = 0; - state->awb_lock = 0; - state->ae_lock = 0; - state->preflash = PREFLASH_NONE; - - pdata = client->dev.platform_data; - - if (!pdata) { - cam_err("no platform data\n"); - return -ENODEV; - } - - /* Registering subdev */ - v4l2_i2c_subdev_init(sd, client, &s5k4ecgx_ops); - - mutex_init(&state->ctrl_lock); - mutex_init(&state->af_lock); - - state->workqueue = create_workqueue("cam_workqueue"); - if (unlikely(!state->workqueue)) { - dev_err(&client->dev, "probe, fail to create workqueue\n"); - goto err_out; - } - INIT_WORK(&state->af_work, s5k4ecgx_af_worker); - - /* - * Assign default format and resolution - * Use configured default information in platform data - * or without them, use default information in driver - */ - - /*S5K4ECGX_PREVIEW_VGA*/ - state->preview_frmsizes = &preview_frmsizes[0]; - /*S5K4ECGX_CAPTURE_5MP */ - state->capture_frmsizes = &capture_frmsizes[0]; - cam_dbg("preview_width: %d , preview_height: %d, " - "capture_width: %d, capture_height: %d", - state->preview_frmsizes->width, state->preview_frmsizes->height, - state->capture_frmsizes->width, state->capture_frmsizes->height); - - state->req_fmt.width = state->preview_frmsizes->width; - state->req_fmt.height = state->preview_frmsizes->height; - - state->pdata = pdata; - - if (!pdata->pixelformat) - state->req_fmt.pixelformat = DEFAULT_FMT; - else - state->req_fmt.pixelformat = pdata->pixelformat; - - cam_dbg("probed!!\n"); - - return 0; - -err_out: - kfree(state); - return -ENOMEM; -} - -static int s5k4ecgx_remove(struct i2c_client *client) -{ - struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct s5k4ecgx_state *state = to_state(sd); - - cam_dbg("E\n"); - - destroy_workqueue(state->workqueue); - - state->initialized = 0; - - v4l2_device_unregister_subdev(sd); - - mutex_destroy(&state->ctrl_lock); - mutex_destroy(&state->af_lock); - - kfree(to_state(sd)); - - return 0; -} - -static const struct i2c_device_id s5k4ecgx_id[] = { - { S5K4ECGX_DRIVER_NAME, 0 }, - { }, -}; -MODULE_DEVICE_TABLE(i2c, s5k4ecgx_id); - -static struct i2c_driver s5k4ecgx_i2c_driver = { - .driver = { - .name = S5K4ECGX_DRIVER_NAME, - }, - .probe = s5k4ecgx_probe, - .remove = s5k4ecgx_remove, - .id_table = s5k4ecgx_id, -}; - -static int __init s5k4ecgx_mod_init(void) -{ - cam_dbg("E\n"); - return i2c_add_driver(&s5k4ecgx_i2c_driver); -} - -static void __exit s5k4ecgx_mod_exit(void) -{ - cam_dbg("E\n"); - i2c_del_driver(&s5k4ecgx_i2c_driver); -} -module_init(s5k4ecgx_mod_init); -module_exit(s5k4ecgx_mod_exit); - -MODULE_DESCRIPTION("S5K4ECGX MIPI sensor driver"); -MODULE_AUTHOR("seungwoolee<samuell.lee@samsung.com>"); -MODULE_AUTHOR("jinsookim<js1002.kim@samsung.com>"); -MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/slp_s5k4ecgx.h b/drivers/media/video/slp_s5k4ecgx.h deleted file mode 100644 index 400581f..0000000 --- a/drivers/media/video/slp_s5k4ecgx.h +++ /dev/null @@ -1,195 +0,0 @@ -/* - * Driver for S5K4ECGX 5M ISP from Samsung - * Copyright (C) 2012 Samsung Electronics Co., Ltd. - * 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. - */ - -#ifndef __S5K4ECGX_H -#define __S5K4ECGX_H - -#include <linux/types.h> - -#define S5K4ECGX_DRIVER_NAME "S5K4ECGX" -#define is_focus(__mode) (state->focus.mode == __mode) - -#define FIRST_AF_SEARCH_COUNT 80 -#define SECOND_AF_SEARCH_COUNT 80 - -extern struct class *camera_class; - -enum stream_cmd { - STREAM_STOP, - STREAM_START, -}; - -struct s5k4ecgx_framesize { - u32 index; - u32 width; - u32 height; -}; - -struct s5k4ecgx_exif { - u32 exptime; /* us */ - u16 flash; - u16 iso; - int tv; /* shutter speed */ - int bv; /* brightness */ - int ebv; /* exposure bias */ -}; - -struct s5k4ecgx_focus { - unsigned int mode; - unsigned int lock; - unsigned int status; - unsigned int touch; - unsigned int pos_x; - unsigned int pos_y; - unsigned int width; - unsigned int height; - unsigned int start; - bool focusing; - bool needed; - bool first; -}; - -enum preflash_status { - PREFLASH_NONE = 0, - PREFLASH_OFF, - PREFLASH_ON, -}; - -enum s5k4ecgx_runmode { - RUNMODE_NOTREADY, - RUNMODE_INIT, - RUNMODE_RUNNING, /* previewing */ - RUNMODE_RUNNING_STOP, - RUNMODE_CAPTURING, - RUNMODE_CAPTURE_STOP, -}; - -/* - * Driver information - */ -struct s5k4ecgx_state { - struct v4l2_subdev sd; - struct device *s5k4ecgx_dev; - struct s5k4ecgx_platform_data *pdata; - /* - * req_fmt is the requested format from the application. - * set_fmt is the output format of the camera. Finally FIMC - * converts the camera output(set_fmt) to the requested format - * with hardware scaler. - */ - struct v4l2_pix_format req_fmt; - const struct s5k4ecgx_framesize *preview_frmsizes; - const struct s5k4ecgx_framesize *capture_frmsizes; - struct s5k4ecgx_exif exif; - struct s5k4ecgx_focus focus; - - enum v4l2_flash_mode flash_mode; - enum preflash_status preflash; - enum v4l2_sensor_mode sensor_mode; - enum v4l2_scene_mode scene_mode; - enum v4l2_wb_mode wb_mode; - enum s5k4ecgx_runmode runmode; - - struct mutex ctrl_lock; /* Mutex */ - struct mutex af_lock; /* Mutex */ - struct work_struct af_work; /* workque for AF */ - struct work_struct af_win_work; /* workque for AF */ - struct workqueue_struct *workqueue; /* workque for AF */ - - s32 vt_mode; - s32 check_dataline; - u32 req_fps; - u32 set_fps; - u32 initialized; - u32 zoom; - bool lowlight; - bool ae_lock; - bool awb_lock; -}; - -enum AF_1ST_STATUS { - AF_PROGRESS_1ST = 1, - AF_SUCCESS_1ST , - AF_FAIL_1ST, -}; - -enum AF_2ND_STATUS { - AF_SUCCESS_2ND = 0, - AF_PROGRESS_2ND = 1, -}; - -enum s5k4ecgx_prev_frmsize { - S5K4ECGX_PREVIEW_176, /* 176 x 144 */ - S5K4ECGX_PREVIEW_320, /* 320 x 240 */ - S5K4ECGX_PREVIEW_640, /* 640 x 480 */ - S5K4ECGX_PREVIEW_720, /* 720 x 480 */ - S5K4ECGX_PREVIEW_800, /* 800 x 480 */ - S5K4ECGX_PREVIEW_1280, /* 1280 x 720 */ -}; - -enum s5k4ecgx_cap_frmsize { - S5K4ECGX_CAPTURE_VGA, /* 640 x 480 */ - S5K4ECGX_CAPTURE_XGA, /* 1024 x 768 */ - S5K4ECGX_CAPTURE_1MP, /* 1280 x 960 */ - S5K4ECGX_CAPTURE_2MP, /* UXGA - 1600 x 1200 */ - S5K4ECGX_CAPTURE_3MP, /* QXGA - 2048 x 1536 */ - S5K4ECGX_CAPTURE_5MP, /* 2560 x 1920 */ -}; - -static inline struct s5k4ecgx_state *to_state(struct v4l2_subdev *sd) -{ - return container_of(sd, struct s5k4ecgx_state, sd); -} - -/*#define CONFIG_CAM_DEBUG */ -#define cam_warn(fmt, ...) \ - do { \ - printk(KERN_WARNING "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_err(fmt, ...) \ - do { \ - printk(KERN_ERR "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#define cam_info(fmt, ...) \ - do { \ - printk(KERN_INFO "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) - -#ifdef CONFIG_CAM_DEBUG -#define cam_dbg(fmt, ...) \ - do { \ - printk(KERN_DEBUG "%s: " fmt, __func__, ##__VA_ARGS__); \ - } while (0) -#else -#define cam_dbg(fmt, ...) -#endif /* CONFIG_CAM_DEBUG */ - - -/************ driver feature ************/ -#define S5K4ECGX_USLEEP -/* #define CONFIG_LOAD_FILE */ - - -/*********** Sensor specific ************/ -/* #define S5K4ECGX_100MS_DELAY 0xAA55AA5F */ -/* #define S5K4ECGX_10MS_DELAY 0xAA55AA5E */ -#define S5K4ECGX_DELAY 0xFFFF0000 -#define S5K4ECGX_DEF_APEX_DEN 100 - -/* Register address */ -#define REG_PAGE_SHUTTER 0x7000 -#define REG_ADDR_SHUTTER 0x14D0 -#define REG_PAGE_ISO 0x7000 -#define REG_ADDR_ISO 0x14C8 - -#include "slp_s5k4ecgx_setfile.h" - -#endif /* __S5K4ECGX_H */ diff --git a/drivers/media/video/slp_s5k4ecgx_setfile.h b/drivers/media/video/slp_s5k4ecgx_setfile.h deleted file mode 100644 index 2c84c7b..0000000 --- a/drivers/media/video/slp_s5k4ecgx_setfile.h +++ /dev/null @@ -1,7308 +0,0 @@ -/* - * Driver for S5K4ECGX 5M ISP from Samsung - * - * Copyright (C) 2011, - * - * - * 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. - */ -#ifndef __S5K4ECGX_SETFILE_H -#define __S5K4ECGX_SETFILE_H - -#include <linux/types.h> - -/* - * s5k4ecgx register configuration for combinations of initialization - */ -/* FOR 4EC EVT1.1*/ - -/*//////////////////////////FOR EVT1.1//////////////////////////*/ -/* 20110706 SEMCO Base setting*/ -/* ARM Initiation */ -static const u32 s5k4ecgx_init_reg1_EVT1[] = { -/*================================================================== -// 01.Start Setting -//==================================================================*/ - 0xFCFCD000, - 0x00100001, /*S/W Reset */ - 0x10300000, /*contint_host_int */ - 0x00140001, /*sw_load_complete-Release CORE(Arm)from reset state*/ -}; - -/* Delay 10ms*/ - -static const u32 s5k4ecgx_init_reg2_EVT1[] = { -/*=============================================================== -//02.ETC Setting -//==============================================================*/ - - 0x0028D000, - 0x002A1082, /*Driving current Setting */ - 0x0F1202AA, /*d0_d4_cd10 d0_d4_cd10 9:0 */ - 0x0F1202AA, /*d5_d9_cd10 d5_d9_cd10 9:0 */ - 0x0F1200AA, /*gpio_cd10 gpio_cd10 */ - 0x0F120AAA, /*clks_output_cd10 clks_output_cd10 11:0 */ - 0x002A100E, - 0x0F120000, /*pclk_delay_r */ - - 0x002A007A, - 0x0F120000, - -/*This register is for FACTORY ONLY. -If you change it without prior notification*/ -/* YOU are RESPONSIBLE for the FAILURE that will happen in the future.*/ - - /*ISP FE(ADLC) */ - 0x002AE406, - 0x0F120092, - 0x002AE410, - 0x0F123804, - 0x002AE41A, - 0x0F120010, /*101022 ADD adlcptune_total */ - 0x002AE420, - 0x0F120003, - 0x0F120060, - 0x002AE42E, - 0x0F120004, - 0x002AF400, - 0x0F125A3C, - 0x0F120023, - 0x0F128080, - 0x0F1203AF, - 0x0F12000A, - 0x0F12AA54, - 0x0F120040, - 0x0F12464E, - 0x0F120240, - 0x0F120240, - 0x0F120040, - 0x0F121000, - 0x0F1255FF, /*555C -> 55FF */ - 0x0F12D000, - 0x0F120010, - 0x0F120202, - 0x0F120401, - 0x0F120022, - 0x0F120088, - 0x0F12009F, - 0x0F120000, - 0x0F121800, - 0x0F120088, - 0x0F120000, - 0x0F122428, - 0x0F120000, - 0x0F1203EE, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x002AF552, - 0x0F120708, - 0x0F12080C, - - 0x00287000, /*For subsampling Size */ - 0x002A18BC, - 0x0F120004, - 0x0F1205B6, - 0x0F120000, - 0x0F120000, - 0x0F120001, - 0x0F1205BA, - 0x0F120000, - 0x0F120000, - 0x0F120007, - 0x0F1205BA, - 0x0F120000, - 0x0F120000, - 0x0F1201F4, - 0x0F12024E, - 0x0F120000, - 0x0F120000, - 0x0F1201F4, - 0x0F1205B6, - 0x0F120000, - 0x0F120000, - 0x0F1201F4, - 0x0F1205BA, - 0x0F120000, - 0x0F120000, - 0x0F1201F4, - 0x0F12024F, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120075, - 0x0F1200CF, - 0x0F120000, - 0x0F120000, - 0x0F120075, - 0x0F1200D6, - 0x0F120000, - 0x0F120000, - 0x0F120004, - 0x0F1201F4, - 0x0F120000, - 0x0F120000, - 0x0F1200F0, - 0x0F1201F4, - 0x0F12029E, - 0x0F1205B2, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1201F8, - 0x0F120228, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120208, - 0x0F120238, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120218, - 0x0F120238, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120001, - 0x0F120009, - 0x0F1200DE, - 0x0F1205C0, - 0x0F120000, - 0x0F120000, - 0x0F1200DF, - 0x0F1200E4, - 0x0F1201F8, - 0x0F1201FD, - 0x0F1205B6, - 0x0F1205BB, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1201F8, - 0x0F120000, - 0x0F120000, - 0x0F120077, - 0x0F12007E, - 0x0F12024F, - 0x0F12025E, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120004, - 0x0F1209D1, - 0x0F120000, - 0x0F120000, - 0x0F120001, - 0x0F1209D5, - 0x0F120000, - 0x0F120000, - 0x0F120008, - 0x0F1209D5, - 0x0F120000, - 0x0F120000, - 0x0F1202AA, - 0x0F120326, - 0x0F120000, - 0x0F120000, - 0x0F1202AA, - 0x0F1209D1, - 0x0F120000, - 0x0F120000, - 0x0F1202AA, - 0x0F1209D5, - 0x0F120000, - 0x0F120000, - 0x0F1202AA, - 0x0F120327, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120008, - 0x0F120084, - 0x0F120000, - 0x0F120000, - 0x0F120008, - 0x0F12008D, - 0x0F120000, - 0x0F120000, - 0x0F120008, - 0x0F1202AA, - 0x0F120000, - 0x0F120000, - 0x0F1200AA, - 0x0F1202AA, - 0x0F1203AD, - 0x0F1209CD, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1202AE, - 0x0F1202DE, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1202BE, - 0x0F1202EE, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1202CE, - 0x0F1202EE, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120001, - 0x0F120009, - 0x0F120095, - 0x0F1209DB, - 0x0F120000, - 0x0F120000, - 0x0F120096, - 0x0F12009B, - 0x0F1202AE, - 0x0F1202B3, - 0x0F1209D1, - 0x0F1209D6, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F1202AE, - 0x0F120000, - 0x0F120000, - 0x0F120009, - 0x0F120010, - 0x0F120327, - 0x0F120336, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x002A1AF8, - 0x0F125A3C, /*senHal_TuneStr_AngTuneData1_2_D000F400 register */ - 0x002A1896, - 0x0F120002, /*senHal_SamplingType 0002 03EE: PLA*/ - 0x0F120000, /*senHal_SamplingMode 0 : 2 PLA / 1 : 4PLA*/ - 0x0F120003, /*senHal_PLAOption [0] VPLA enable [1] H*/ - - 0x002A189E, - 0x0F120FB0, /*senHal_ExpMinPixels*/ - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin*/ - 0x0F120060, /*senHal_uAddColsNoBin*/ - 0x0F1205C0, /*senHal_uMinColsBin*/ - 0x0F1205C0, /*senHal_uMinColsNoBin*/ - - 0x002A1AEA, - 0x0F128080, /*senHal_SubF404Tune*/ - 0x0F120080, /*senHal_FullF404Tune*/ - 0x002A1AE0, - 0x0F120000, /*senHal_bSenAAC*/ - - 0x002A1A72, - 0x0F120000, /*senHal_bSRX SRX off*/ - 0x002A18A2, - 0x0F120004, /*senHal_NExpLinesCheckFine extend For*/ - 0x002A1A6A, - 0x0F12009A, /*senHal_usForbiddenRightOfs*/ - 0x002A385E, - 0x0F12024C, /*Mon_Sen_uExpPixelsOfs*/ - - 0x002A0EE6, - 0x0F120000, /*setot_bUseDigitalHbin*/ - 0x002A1B2A, - 0x0F120300, /*senHal_TuneStr2_usAngTuneGainTh 2 */ - 0x0F1200D6, /*senHal_TuneStr2_AngTuneF4CA_0_ 2 70001B2*/ - 0x0F12008D, /*senHal_TuneStr2_AngTuneF4CA_1_ 2 70001B2*/ - 0x0F1200CF, /*senHal_TuneStr2_AngTuneF4C2_0_ 2 70001B3*/ - 0x0F120084, /*senHal_TuneStr2_AngTuneF4C2_1_ 2 70001B3*/ - - /* OTP setting*/ - 0x002A0722, - 0x0F120100, /*skl_OTP_usWaitTime This register sho*/ - 0x002A0726, - 0x0F120001, /*skl_bUseOTPfunc//OTP on/off function*/ - 0x002A08D6, - 0x0F120001, /*ash_bUseOTPData*/ - 0x002A146E, - 0x0F120000, /*awbb_otp_disable*/ - 0x002A08DC, - 0x0F120000, /*ash_bUseGasAlphaOTP*/ - -/*==================================================== -// 05.Trap and Patch -====================================================*/ -/* Start of Patch data*/ - 0x00287000, - 0x002A3AF8, - 0x0F12B570, /*70003AF8 */ - 0x0F124B39, /*70003AFA */ - 0x0F124939, /*70003AFC */ - 0x0F12483A, /*70003AFE */ - 0x0F122200, /*70003B00 */ - 0x0F12C008, /*70003B02 */ - 0x0F126001, /*70003B04 */ - 0x0F124939, /*70003B06 */ - 0x0F124839, /*70003B08 */ - 0x0F122401, /*70003B0A */ - 0x0F12F000, /*70003B0C */ - 0x0F12FBD4, /*70003B0E */ - 0x0F124938, /*70003B10 */ - 0x0F124839, /*70003B12 */ - 0x0F122502, /*70003B14 */ - 0x0F120022, /*70003B16 */ - 0x0F12F000, /*70003B18 */ - 0x0F12FBCE, /*70003B1A */ - 0x0F124837, /*70003B1C */ - 0x0F120261, /*70003B1E */ - 0x0F128001, /*70003B20 */ - 0x0F122100, /*70003B22 */ - 0x0F128041, /*70003B24 */ - 0x0F124936, /*70003B26 */ - 0x0F124836, /*70003B28 */ - 0x0F126041, /*70003B2A */ - 0x0F124936, /*70003B2C */ - 0x0F124837, /*70003B2E */ - 0x0F122403, /*70003B30 */ - 0x0F12002A, /*70003B32 */ - 0x0F12F000, /*70003B34 */ - 0x0F12FBC0, /*70003B36 */ - 0x0F124832, /*70003B38 */ - 0x0F124935, /*70003B3A */ - 0x0F1230C0, /*70003B3C */ - 0x0F1263C1, /*70003B3E */ - 0x0F124930, /*70003B40 */ - 0x0F124834, /*70003B42 */ - 0x0F123980, /*70003B44 */ - 0x0F126408, /*70003B46 */ - 0x0F124833, /*70003B48 */ - 0x0F124934, /*70003B4A */ - 0x0F126388, /*70003B4C */ - 0x0F124934, /*70003B4E */ - 0x0F124834, /*70003B50 */ - 0x0F120022, /*70003B52 */ - 0x0F122504, /*70003B54 */ - 0x0F12F000, /*70003B56 */ - 0x0F12FBAF, /*70003B58 */ - 0x0F124933, /*70003B5A */ - 0x0F124833, /*70003B5C */ - 0x0F122405, /*70003B5E */ - 0x0F12002A, /*70003B60 */ - 0x0F12F000, /*70003B62 */ - 0x0F12F881, /*70003B64 */ - 0x0F12491F, /*70003B66 */ - 0x0F124830, /*70003B68 */ - 0x0F120022, /*70003B6A */ - 0x0F122506, /*70003B6C */ - 0x0F1239B6, /*70003B6E */ - 0x0F121D80, /*70003B70 */ - 0x0F12F000, /*70003B72 */ - 0x0F12F879, /*70003B74 */ - 0x0F12482D, /*70003B76 */ - 0x0F12492D, /*70003B78 */ - 0x0F122407, /*70003B7A */ - 0x0F12002A, /*70003B7C */ - 0x0F12300C, /*70003B7E */ - 0x0F12F000, /*70003B80 */ - 0x0F12F872, /*70003B82 */ - 0x0F124829, /*70003B84 */ - 0x0F12492B, /*70003B86 */ - 0x0F120022, /*70003B88 */ - 0x0F122508, /*70003B8A */ - 0x0F123010, /*70003B8C */ - 0x0F12F000, /*70003B8E */ - 0x0F12F86B, /*70003B90 */ - 0x0F124929, /*70003B92 */ - 0x0F124829, /*70003B94 */ - 0x0F122409, /*70003B96 */ - 0x0F12002A, /*70003B98 */ - 0x0F12F000, /*70003B9A */ - 0x0F12FB8D, /*70003B9C */ - 0x0F124928, /*70003B9E */ - 0x0F124828, /*70003BA0 */ - 0x0F120022, /*70003BA2 */ - 0x0F12250A, /*70003BA4 */ - 0x0F12F000, /*70003BA6 */ - 0x0F12FB87, /*70003BA8 */ - 0x0F124927, /*70003BAA */ - 0x0F124827, /*70003BAC */ - 0x0F12240B, /*70003BAE */ - 0x0F12002A, /*70003BB0 */ - 0x0F12F000, /*70003BB2 */ - 0x0F12FB81, /*70003BB4 */ - 0x0F124926, /*70003BB6 */ - 0x0F124826, /*70003BB8 */ - 0x0F120022, /*70003BBA */ - 0x0F12250C, /*70003BBC */ - 0x0F12F000, /*70003BBE */ - 0x0F12FB7B, /*70003BC0 */ - 0x0F124925, /*70003BC2 */ - 0x0F124825, /*70003BC4 */ - 0x0F12240D, /*70003BC6 */ - 0x0F12002A, /*70003BC8 */ - 0x0F12F000, /*70003BCA */ - 0x0F12FB75, /*70003BCC */ - 0x0F124924, /*70003BCE */ - 0x0F124824, /*70003BD0 */ - 0x0F120022, /*70003BD2 */ - 0x0F12F000, /*70003BD4 */ - 0x0F12FB70, /*70003BD6 */ - 0x0F12BC70, /*70003BD8 */ - 0x0F12BC08, /*70003BDA */ - 0x0F124718, /*70003BDC */ - 0x0F120000, /*70003BDE */ - 0x0F12018F, /*70003BE0 */ - 0x0F124EC2, /*70003BE2 */ - 0x0F12037F, /*70003BE4 */ - 0x0F120000, /*70003BE6 */ - 0x0F121F90, /*70003BE8 */ - 0x0F127000, /*70003BEA */ - 0x0F123C81, /*70003BEC */ - 0x0F127000, /*70003BEE */ - 0x0F12E38B, /*70003BF0 */ - 0x0F120000, /*70003BF2 */ - 0x0F123CB9, /*70003BF4 */ - 0x0F127000, /*70003BF6 */ - 0x0F12C3B1, /*70003BF8 */ - 0x0F120000, /*70003BFA */ - 0x0F124780, /*70003BFC */ - 0x0F127000, /*70003BFE */ - 0x0F123D17, /*70003C00 */ - 0x0F127000, /*70003C02 */ - 0x0F120080, /*70003C04 */ - 0x0F127000, /*70003C06 */ - 0x0F123D53, /*70003C08 */ - 0x0F127000, /*70003C0A */ - 0x0F12B49D, /*70003C0C */ - 0x0F120000, /*70003C0E */ - 0x0F123DFF, /*70003C10 */ - 0x0F127000, /*70003C12 */ - 0x0F123DB3, /*70003C14 */ - 0x0F127000, /*70003C16 */ - 0x0F12FFFF, /*70003C18 */ - 0x0F1200FF, /*70003C1A */ - 0x0F1217E0, /*70003C1C */ - 0x0F127000, /*70003C1E */ - 0x0F123F7B, /*70003C20 */ - 0x0F127000, /*70003C22 */ - 0x0F12053D, /*70003C24 */ - 0x0F120000, /*70003C26 */ - 0x0F120000, /*70003C28 */ - 0x0F120A89, /*70003C2A */ - 0x0F126CD2, /*70003C2C */ - 0x0F120000, /*70003C2E */ - 0x0F120000, /*70003C30 */ - 0x0F120A9A, /*70003C32 */ - 0x0F120000, /*70003C34 */ - 0x0F1202D2, /*70003C36 */ - 0x0F123FC9, /*70003C38 */ - 0x0F127000, /*70003C3A */ - 0x0F129E65, /*70003C3C */ - 0x0F120000, /*70003C3E */ - 0x0F12403D, /*70003C40 */ - 0x0F127000, /*70003C42 */ - 0x0F127C49, /*70003C44 */ - 0x0F120000, /*70003C46 */ - 0x0F1240B1, /*70003C48 */ - 0x0F127000, /*70003C4A */ - 0x0F127C63, /*70003C4C */ - 0x0F120000, /*70003C4E */ - 0x0F1240CD, /*70003C50 */ - 0x0F127000, /*70003C52 */ - 0x0F128F01, /*70003C54 */ - 0x0F120000, /*70003C56 */ - 0x0F12416F, /*70003C58 */ - 0x0F127000, /*70003C5A */ - 0x0F127F3F, /*70003C5C */ - 0x0F120000, /*70003C5E */ - 0x0F1241FD, /*70003C60 */ - 0x0F127000, /*70003C62 */ - 0x0F1298C5, /*70003C64 */ - 0x0F120000, /*70003C66 */ - 0x0F12B570, /*70003C68 */ - 0x0F12000C, /*70003C6A */ - 0x0F120015, /*70003C6C */ - 0x0F120029, /*70003C6E */ - 0x0F12F000, /*70003C70 */ - 0x0F12FB2A, /*70003C72 */ - 0x0F1249F8, /*70003C74 */ - 0x0F1200A8, /*70003C76 */ - 0x0F12500C, /*70003C78 */ - 0x0F12BC70, /*70003C7A */ - 0x0F12BC08, /*70003C7C */ - 0x0F124718, /*70003C7E */ - 0x0F126808, /*70003C80 */ - 0x0F120400, /*70003C82 */ - 0x0F120C00, /*70003C84 */ - 0x0F126849, /*70003C86 */ - 0x0F120409, /*70003C88 */ - 0x0F120C09, /*70003C8A */ - 0x0F124AF3, /*70003C8C */ - 0x0F128992, /*70003C8E */ - 0x0F122A00, /*70003C90 */ - 0x0F12D00D, /*70003C92 */ - 0x0F122300, /*70003C94 */ - 0x0F121A89, /*70003C96 */ - 0x0F12D400, /*70003C98 */ - 0x0F12000B, /*70003C9A */ - 0x0F120419, /*70003C9C */ - 0x0F120C09, /*70003C9E */ - 0x0F1223FF, /*70003CA0 */ - 0x0F1233C1, /*70003CA2 */ - 0x0F121810, /*70003CA4 */ - 0x0F124298, /*70003CA6 */ - 0x0F12D800, /*70003CA8 */ - 0x0F120003, /*70003CAA */ - 0x0F120418, /*70003CAC */ - 0x0F120C00, /*70003CAE */ - 0x0F124AEB, /*70003CB0 */ - 0x0F128150, /*70003CB2 */ - 0x0F128191, /*70003CB4 */ - 0x0F124770, /*70003CB6 */ - 0x0F12B5F3, /*70003CB8 */ - 0x0F120004, /*70003CBA */ - 0x0F12B081, /*70003CBC */ - 0x0F129802, /*70003CBE */ - 0x0F126800, /*70003CC0 */ - 0x0F120600, /*70003CC2 */ - 0x0F120E00, /*70003CC4 */ - 0x0F122201, /*70003CC6 */ - 0x0F120015, /*70003CC8 */ - 0x0F120021, /*70003CCA */ - 0x0F123910, /*70003CCC */ - 0x0F12408A, /*70003CCE */ - 0x0F1240A5, /*70003CD0 */ - 0x0F124FE4, /*70003CD2 */ - 0x0F120016, /*70003CD4 */ - 0x0F122C10, /*70003CD6 */ - 0x0F12DA03, /*70003CD8 */ - 0x0F128839, /*70003CDA */ - 0x0F1243A9, /*70003CDC */ - 0x0F128039, /*70003CDE */ - 0x0F12E002, /*70003CE0 */ - 0x0F128879, /*70003CE2 */ - 0x0F1243B1, /*70003CE4 */ - 0x0F128079, /*70003CE6 */ - 0x0F12F000, /*70003CE8 */ - 0x0F12FAF6, /*70003CEA */ - 0x0F122C10, /*70003CEC */ - 0x0F12DA03, /*70003CEE */ - 0x0F128839, /*70003CF0 */ - 0x0F124329, /*70003CF2 */ - 0x0F128039, /*70003CF4 */ - 0x0F12E002, /*70003CF6 */ - 0x0F128879, /*70003CF8 */ - 0x0F124331, /*70003CFA */ - 0x0F128079, /*70003CFC */ - 0x0F1249DA, /*70003CFE */ - 0x0F128809, /*70003D00 */ - 0x0F122900, /*70003D02 */ - 0x0F12D102, /*70003D04 */ - 0x0F12F000, /*70003D06 */ - 0x0F12FAEF, /*70003D08 */ - 0x0F122000, /*70003D0A */ - 0x0F129902, /*70003D0C */ - 0x0F126008, /*70003D0E */ - 0x0F12BCFE, /*70003D10 */ - 0x0F12BC08, /*70003D12 */ - 0x0F124718, /*70003D14 */ - 0x0F12B538, /*70003D16 */ - 0x0F129C04, /*70003D18 */ - 0x0F120015, /*70003D1A */ - 0x0F12002A, /*70003D1C */ - 0x0F129400, /*70003D1E */ - 0x0F12F000, /*70003D20 */ - 0x0F12FAEA, /*70003D22 */ - 0x0F124AD1, /*70003D24 */ - 0x0F128811, /*70003D26 */ - 0x0F122900, /*70003D28 */ - 0x0F12D00F, /*70003D2A */ - 0x0F128820, /*70003D2C */ - 0x0F124281, /*70003D2E */ - 0x0F12D20C, /*70003D30 */ - 0x0F128861, /*70003D32 */ - 0x0F128853, /*70003D34 */ - 0x0F124299, /*70003D36 */ - 0x0F12D200, /*70003D38 */ - 0x0F121E40, /*70003D3A */ - 0x0F120400, /*70003D3C */ - 0x0F120C00, /*70003D3E */ - 0x0F128020, /*70003D40 */ - 0x0F128851, /*70003D42 */ - 0x0F128061, /*70003D44 */ - 0x0F124368, /*70003D46 */ - 0x0F121840, /*70003D48 */ - 0x0F126060, /*70003D4A */ - 0x0F12BC38, /*70003D4C */ - 0x0F12BC08, /*70003D4E */ - 0x0F124718, /*70003D50 */ - 0x0F12B5F8, /*70003D52 */ - 0x0F120004, /*70003D54 */ - 0x0F126808, /*70003D56 */ - 0x0F120400, /*70003D58 */ - 0x0F120C00, /*70003D5A */ - 0x0F122201, /*70003D5C */ - 0x0F120015, /*70003D5E */ - 0x0F120021, /*70003D60 */ - 0x0F123910, /*70003D62 */ - 0x0F12408A, /*70003D64 */ - 0x0F1240A5, /*70003D66 */ - 0x0F124FBE, /*70003D68 */ - 0x0F120016, /*70003D6A */ - 0x0F122C10, /*70003D6C */ - 0x0F12DA03, /*70003D6E */ - 0x0F128839, /*70003D70 */ - 0x0F1243A9, /*70003D72 */ - 0x0F128039, /*70003D74 */ - 0x0F12E002, /*70003D76 */ - 0x0F128879, /*70003D78 */ - 0x0F1243B1, /*70003D7A */ - 0x0F128079, /*70003D7C */ - 0x0F12F000, /*70003D7E */ - 0x0F12FAC3, /*70003D80 */ - 0x0F122C10, /*70003D82 */ - 0x0F12DA03, /*70003D84 */ - 0x0F128838, /*70003D86 */ - 0x0F124328, /*70003D88 */ - 0x0F128038, /*70003D8A */ - 0x0F12E002, /*70003D8C */ - 0x0F128878, /*70003D8E */ - 0x0F124330, /*70003D90 */ - 0x0F128078, /*70003D92 */ - 0x0F1248B6, /*70003D94 */ - 0x0F128800, /*70003D96 */ - 0x0F120400, /*70003D98 */ - 0x0F12D507, /*70003D9A */ - 0x0F124BB5, /*70003D9C */ - 0x0F127819, /*70003D9E */ - 0x0F124AB5, /*70003DA0 */ - 0x0F127810, /*70003DA2 */ - 0x0F127018, /*70003DA4 */ - 0x0F127011, /*70003DA6 */ - 0x0F1249B4, /*70003DA8 */ - 0x0F128188, /*70003DAA */ - 0x0F12BCF8, /*70003DAC */ - 0x0F12BC08, /*70003DAE */ - 0x0F124718, /*70003DB0 */ - 0x0F12B538, /*70003DB2 */ - 0x0F1248B2, /*70003DB4 */ - 0x0F124669, /*70003DB6 */ - 0x0F12F000, /*70003DB8 */ - 0x0F12FAAE, /*70003DBA */ - 0x0F1248B1, /*70003DBC */ - 0x0F1249B0, /*70003DBE */ - 0x0F1269C2, /*70003DC0 */ - 0x0F122400, /*70003DC2 */ - 0x0F1231A8, /*70003DC4 */ - 0x0F122A00, /*70003DC6 */ - 0x0F12D008, /*70003DC8 */ - 0x0F1261C4, /*70003DCA */ - 0x0F12684A, /*70003DCC */ - 0x0F126242, /*70003DCE */ - 0x0F126282, /*70003DD0 */ - 0x0F12466B, /*70003DD2 */ - 0x0F12881A, /*70003DD4 */ - 0x0F126302, /*70003DD6 */ - 0x0F12885A, /*70003DD8 */ - 0x0F126342, /*70003DDA */ - 0x0F126A02, /*70003DDC */ - 0x0F122A00, /*70003DDE */ - 0x0F12D00A, /*70003DE0 */ - 0x0F126204, /*70003DE2 */ - 0x0F126849, /*70003DE4 */ - 0x0F126281, /*70003DE6 */ - 0x0F12466B, /*70003DE8 */ - 0x0F128819, /*70003DEA */ - 0x0F126301, /*70003DEC */ - 0x0F128859, /*70003DEE */ - 0x0F126341, /*70003DF0 */ - 0x0F1249A5, /*70003DF2 */ - 0x0F1288C9, /*70003DF4 */ - 0x0F1263C1, /*70003DF6 */ - 0x0F12F000, /*70003DF8 */ - 0x0F12FA96, /*70003DFA */ - 0x0F12E7A6, /*70003DFC */ - 0x0F12B5F0, /*70003DFE */ - 0x0F12B08B, /*70003E00 */ - 0x0F1220FF, /*70003E02 */ - 0x0F121C40, /*70003E04 */ - 0x0F1249A1, /*70003E06 */ - 0x0F1289CC, /*70003E08 */ - 0x0F124E9E, /*70003E0A */ - 0x0F126AB1, /*70003E0C */ - 0x0F124284, /*70003E0E */ - 0x0F12D101, /*70003E10 */ - 0x0F12489F, /*70003E12 */ - 0x0F126081, /*70003E14 */ - 0x0F126A70, /*70003E16 */ - 0x0F120200, /*70003E18 */ - 0x0F12F000, /*70003E1A */ - 0x0F12FA8D, /*70003E1C */ - 0x0F120400, /*70003E1E */ - 0x0F120C00, /*70003E20 */ - 0x0F124A96, /*70003E22 */ - 0x0F128A11, /*70003E24 */ - 0x0F129109, /*70003E26 */ - 0x0F122101, /*70003E28 */ - 0x0F120349, /*70003E2A */ - 0x0F124288, /*70003E2C */ - 0x0F12D200, /*70003E2E */ - 0x0F120001, /*70003E30 */ - 0x0F124A92, /*70003E32 */ - 0x0F128211, /*70003E34 */ - 0x0F124D97, /*70003E36 */ - 0x0F128829, /*70003E38 */ - 0x0F129108, /*70003E3A */ - 0x0F124A8B, /*70003E3C */ - 0x0F122303, /*70003E3E */ - 0x0F123222, /*70003E40 */ - 0x0F121F91, /*70003E42 */ - 0x0F12F000, /*70003E44 */ - 0x0F12FA7E, /*70003E46 */ - 0x0F128028, /*70003E48 */ - 0x0F12488E, /*70003E4A */ - 0x0F124987, /*70003E4C */ - 0x0F126BC2, /*70003E4E */ - 0x0F126AC0, /*70003E50 */ - 0x0F124282, /*70003E52 */ - 0x0F12D201, /*70003E54 */ - 0x0F128CC8, /*70003E56 */ - 0x0F128028, /*70003E58 */ - 0x0F1288E8, /*70003E5A */ - 0x0F129007, /*70003E5C */ - 0x0F122240, /*70003E5E */ - 0x0F124310, /*70003E60 */ - 0x0F1280E8, /*70003E62 */ - 0x0F122000, /*70003E64 */ - 0x0F120041, /*70003E66 */ - 0x0F12194B, /*70003E68 */ - 0x0F12001E, /*70003E6A */ - 0x0F123680, /*70003E6C */ - 0x0F128BB2, /*70003E6E */ - 0x0F12AF04, /*70003E70 */ - 0x0F12527A, /*70003E72 */ - 0x0F124A7D, /*70003E74 */ - 0x0F12188A, /*70003E76 */ - 0x0F128897, /*70003E78 */ - 0x0F1283B7, /*70003E7A */ - 0x0F1233A0, /*70003E7C */ - 0x0F12891F, /*70003E7E */ - 0x0F12AE01, /*70003E80 */ - 0x0F125277, /*70003E82 */ - 0x0F128A11, /*70003E84 */ - 0x0F128119, /*70003E86 */ - 0x0F121C40, /*70003E88 */ - 0x0F120400, /*70003E8A */ - 0x0F120C00, /*70003E8C */ - 0x0F122806, /*70003E8E */ - 0x0F12D3E9, /*70003E90 */ - 0x0F12F000, /*70003E92 */ - 0x0F12FA5F, /*70003E94 */ - 0x0F12F000, /*70003E96 */ - 0x0F12FA65, /*70003E98 */ - 0x0F124F79, /*70003E9A */ - 0x0F1237A8, /*70003E9C */ - 0x0F122800, /*70003E9E */ - 0x0F12D10A, /*70003EA0 */ - 0x0F121FE0, /*70003EA2 */ - 0x0F1238FD, /*70003EA4 */ - 0x0F12D001, /*70003EA6 */ - 0x0F121CC0, /*70003EA8 */ - 0x0F12D105, /*70003EAA */ - 0x0F124874, /*70003EAC */ - 0x0F128829, /*70003EAE */ - 0x0F123818, /*70003EB0 */ - 0x0F126840, /*70003EB2 */ - 0x0F124348, /*70003EB4 */ - 0x0F126078, /*70003EB6 */ - 0x0F124972, /*70003EB8 */ - 0x0F126878, /*70003EBA */ - 0x0F126B89, /*70003EBC */ - 0x0F124288, /*70003EBE */ - 0x0F12D300, /*70003EC0 */ - 0x0F120008, /*70003EC2 */ - 0x0F126078, /*70003EC4 */ - 0x0F122000, /*70003EC6 */ - 0x0F120041, /*70003EC8 */ - 0x0F12AA04, /*70003ECA */ - 0x0F125A53, /*70003ECC */ - 0x0F12194A, /*70003ECE */ - 0x0F12269C, /*70003ED0 */ - 0x0F1252B3, /*70003ED2 */ - 0x0F12AB01, /*70003ED4 */ - 0x0F125A59, /*70003ED6 */ - 0x0F1232A0, /*70003ED8 */ - 0x0F128111, /*70003EDA */ - 0x0F121C40, /*70003EDC */ - 0x0F120400, /*70003EDE */ - 0x0F120C00, /*70003EE0 */ - 0x0F122806, /*70003EE2 */ - 0x0F12D3F0, /*70003EE4 */ - 0x0F124965, /*70003EE6 */ - 0x0F129809, /*70003EE8 */ - 0x0F128208, /*70003EEA */ - 0x0F129808, /*70003EEC */ - 0x0F128028, /*70003EEE */ - 0x0F129807, /*70003EF0 */ - 0x0F1280E8, /*70003EF2 */ - 0x0F121FE0, /*70003EF4 */ - 0x0F1238FD, /*70003EF6 */ - 0x0F12D13B, /*70003EF8 */ - 0x0F124D64, /*70003EFA */ - 0x0F1289E8, /*70003EFC */ - 0x0F121FC1, /*70003EFE */ - 0x0F1239FF, /*70003F00 */ - 0x0F12D136, /*70003F02 */ - 0x0F124C5F, /*70003F04 */ - 0x0F128AE0, /*70003F06 */ - 0x0F12F000, /*70003F08 */ - 0x0F12FA34, /*70003F0A */ - 0x0F120006, /*70003F0C */ - 0x0F128B20, /*70003F0E */ - 0x0F12F000, /*70003F10 */ - 0x0F12FA38, /*70003F12 */ - 0x0F129000, /*70003F14 */ - 0x0F126AA1, /*70003F16 */ - 0x0F126878, /*70003F18 */ - 0x0F121809, /*70003F1A */ - 0x0F120200, /*70003F1C */ - 0x0F12F000, /*70003F1E */ - 0x0F12FA0B, /*70003F20 */ - 0x0F120400, /*70003F22 */ - 0x0F120C00, /*70003F24 */ - 0x0F120022, /*70003F26 */ - 0x0F123246, /*70003F28 */ - 0x0F120011, /*70003F2A */ - 0x0F12310A, /*70003F2C */ - 0x0F122305, /*70003F2E */ - 0x0F12F000, /*70003F30 */ - 0x0F12FA08, /*70003F32 */ - 0x0F1266E8, /*70003F34 */ - 0x0F126B23, /*70003F36 */ - 0x0F120002, /*70003F38 */ - 0x0F120031, /*70003F3A */ - 0x0F120018, /*70003F3C */ - 0x0F12F000, /*70003F3E */ - 0x0F12FA29, /*70003F40 */ - 0x0F12466B, /*70003F42 */ - 0x0F128518, /*70003F44 */ - 0x0F126EEA, /*70003F46 */ - 0x0F126B60, /*70003F48 */ - 0x0F129900, /*70003F4A */ - 0x0F12F000, /*70003F4C */ - 0x0F12FA22, /*70003F4E */ - 0x0F12466B, /*70003F50 */ - 0x0F128558, /*70003F52 */ - 0x0F120029, /*70003F54 */ - 0x0F12980A, /*70003F56 */ - 0x0F123170, /*70003F58 */ - 0x0F12F000, /*70003F5A */ - 0x0F12FA23, /*70003F5C */ - 0x0F120028, /*70003F5E */ - 0x0F123060, /*70003F60 */ - 0x0F128A02, /*70003F62 */ - 0x0F124946, /*70003F64 */ - 0x0F123128, /*70003F66 */ - 0x0F12808A, /*70003F68 */ - 0x0F128A42, /*70003F6A */ - 0x0F1280CA, /*70003F6C */ - 0x0F128A80, /*70003F6E */ - 0x0F128108, /*70003F70 */ - 0x0F12B00B, /*70003F72 */ - 0x0F12BCF0, /*70003F74 */ - 0x0F12BC08, /*70003F76 */ - 0x0F124718, /*70003F78 */ - 0x0F12B570, /*70003F7A */ - 0x0F122400, /*70003F7C */ - 0x0F124D46, /*70003F7E */ - 0x0F124846, /*70003F80 */ - 0x0F128881, /*70003F82 */ - 0x0F124846, /*70003F84 */ - 0x0F128041, /*70003F86 */ - 0x0F122101, /*70003F88 */ - 0x0F128001, /*70003F8A */ - 0x0F12F000, /*70003F8C */ - 0x0F12FA12, /*70003F8E */ - 0x0F124842, /*70003F90 */ - 0x0F123820, /*70003F92 */ - 0x0F128BC0, /*70003F94 */ - 0x0F12F000, /*70003F96 */ - 0x0F12FA15, /*70003F98 */ - 0x0F124B42, /*70003F9A */ - 0x0F12220D, /*70003F9C */ - 0x0F120712, /*70003F9E */ - 0x0F1218A8, /*70003FA0 */ - 0x0F128806, /*70003FA2 */ - 0x0F1200E1, /*70003FA4 */ - 0x0F1218C9, /*70003FA6 */ - 0x0F1281CE, /*70003FA8 */ - 0x0F128846, /*70003FAA */ - 0x0F12818E, /*70003FAC */ - 0x0F128886, /*70003FAE */ - 0x0F12824E, /*70003FB0 */ - 0x0F1288C0, /*70003FB2 */ - 0x0F128208, /*70003FB4 */ - 0x0F123508, /*70003FB6 */ - 0x0F12042D, /*70003FB8 */ - 0x0F120C2D, /*70003FBA */ - 0x0F121C64, /*70003FBC */ - 0x0F120424, /*70003FBE */ - 0x0F120C24, /*70003FC0 */ - 0x0F122C07, /*70003FC2 */ - 0x0F12D3EC, /*70003FC4 */ - 0x0F12E658, /*70003FC6 */ - 0x0F12B510, /*70003FC8 */ - 0x0F124834, /*70003FCA */ - 0x0F124C34, /*70003FCC */ - 0x0F1288C0, /*70003FCE */ - 0x0F128060, /*70003FD0 */ - 0x0F122001, /*70003FD2 */ - 0x0F128020, /*70003FD4 */ - 0x0F124831, /*70003FD6 */ - 0x0F123820, /*70003FD8 */ - 0x0F128BC0, /*70003FDA */ - 0x0F12F000, /*70003FDC */ - 0x0F12F9F2, /*70003FDE */ - 0x0F1288E0, /*70003FE0 */ - 0x0F124A31, /*70003FE2 */ - 0x0F122800, /*70003FE4 */ - 0x0F12D003, /*70003FE6 */ - 0x0F124930, /*70003FE8 */ - 0x0F128849, /*70003FEA */ - 0x0F122900, /*70003FEC */ - 0x0F12D009, /*70003FEE */ - 0x0F122001, /*70003FF0 */ - 0x0F1203C0, /*70003FF2 */ - 0x0F128050, /*70003FF4 */ - 0x0F1280D0, /*70003FF6 */ - 0x0F122000, /*70003FF8 */ - 0x0F128090, /*70003FFA */ - 0x0F128110, /*70003FFC */ - 0x0F12BC10, /*70003FFE */ - 0x0F12BC08, /*70004000 */ - 0x0F124718, /*70004002 */ - 0x0F128050, /*70004004 */ - 0x0F128920, /*70004006 */ - 0x0F1280D0, /*70004008 */ - 0x0F128960, /*7000400A */ - 0x0F120400, /*7000400C */ - 0x0F121400, /*7000400E */ - 0x0F128090, /*70004010 */ - 0x0F1289A1, /*70004012 */ - 0x0F120409, /*70004014 */ - 0x0F121409, /*70004016 */ - 0x0F128111, /*70004018 */ - 0x0F1289E3, /*7000401A */ - 0x0F128A24, /*7000401C */ - 0x0F122B00, /*7000401E */ - 0x0F12D104, /*70004020 */ - 0x0F1217C3, /*70004022 */ - 0x0F120F5B, /*70004024 */ - 0x0F121818, /*70004026 */ - 0x0F1210C0, /*70004028 */ - 0x0F128090, /*7000402A */ - 0x0F122C00, /*7000402C */ - 0x0F12D1E6, /*7000402E */ - 0x0F1217C8, /*70004030 */ - 0x0F120F40, /*70004032 */ - 0x0F121840, /*70004034 */ - 0x0F1210C0, /*70004036 */ - 0x0F128110, /*70004038 */ - 0x0F12E7E0, /*7000403A */ - 0x0F12B510, /*7000403C */ - 0x0F12000C, /*7000403E */ - 0x0F124919, /*70004040 */ - 0x0F122204, /*70004042 */ - 0x0F126820, /*70004044 */ - 0x0F125E8A, /*70004046 */ - 0x0F120140, /*70004048 */ - 0x0F121A80, /*7000404A */ - 0x0F120280, /*7000404C */ - 0x0F128849, /*7000404E */ - 0x0F12F000, /*70004050 */ - 0x0F12F9C0, /*70004052 */ - 0x0F126020, /*70004054 */ - 0x0F12E7D2, /*70004056 */ - 0x0F1238D4, /*70004058 */ - 0x0F127000, /*7000405A */ - 0x0F1217D0, /*7000405C */ - 0x0F127000, /*7000405E */ - 0x0F125000, /*70004060 */ - 0x0F12D000, /*70004062 */ - 0x0F121100, /*70004064 */ - 0x0F12D000, /*70004066 */ - 0x0F12171A, /*70004068 */ - 0x0F127000, /*7000406A */ - 0x0F124780, /*7000406C */ - 0x0F127000, /*7000406E */ - 0x0F122FCA, /*70004070 */ - 0x0F127000, /*70004072 */ - 0x0F122FC5, /*70004074 */ - 0x0F127000, /*70004076 */ - 0x0F122FC6, /*70004078 */ - 0x0F127000, /*7000407A */ - 0x0F122ED8, /*7000407C */ - 0x0F127000, /*7000407E */ - 0x0F122BD0, /*70004080 */ - 0x0F127000, /*70004082 */ - 0x0F1217E0, /*70004084 */ - 0x0F127000, /*70004086 */ - 0x0F122DE8, /*70004088 */ - 0x0F127000, /*7000408A */ - 0x0F1237E0, /*7000408C */ - 0x0F127000, /*7000408E */ - 0x0F12210C, /*70004090 */ - 0x0F127000, /*70004092 */ - 0x0F121484, /*70004094 */ - 0x0F127000, /*70004096 */ - 0x0F12A006, /*70004098 */ - 0x0F120000, /*7000409A */ - 0x0F120724, /*7000409C */ - 0x0F127000, /*7000409E */ - 0x0F12A000, /*700040A0 */ - 0x0F12D000, /*700040A2 */ - 0x0F122270, /*700040A4 */ - 0x0F127000, /*700040A6 */ - 0x0F122558, /*700040A8 */ - 0x0F127000, /*700040AA */ - 0x0F12146C, /*700040AC */ - 0x0F127000, /*700040AE */ - 0x0F12B510, /*700040B0 */ - 0x0F12000C, /*700040B2 */ - 0x0F124979, /*700040B4 */ - 0x0F122208, /*700040B6 */ - 0x0F126820, /*700040B8 */ - 0x0F125E8A, /*700040BA */ - 0x0F120140, /*700040BC */ - 0x0F121A80, /*700040BE */ - 0x0F120280, /*700040C0 */ - 0x0F1288C9, /*700040C2 */ - 0x0F12F000, /*700040C4 */ - 0x0F12F986, /*700040C6 */ - 0x0F126020, /*700040C8 */ - 0x0F12E798, /*700040CA */ - 0x0F12B5FE, /*700040CC */ - 0x0F12000C, /*700040CE */ - 0x0F126825, /*700040D0 */ - 0x0F126866, /*700040D2 */ - 0x0F1268A0, /*700040D4 */ - 0x0F129001, /*700040D6 */ - 0x0F1268E7, /*700040D8 */ - 0x0F121BA8, /*700040DA */ - 0x0F1242B5, /*700040DC */ - 0x0F12DA00, /*700040DE */ - 0x0F121B70, /*700040E0 */ - 0x0F129000, /*700040E2 */ - 0x0F12496D, /*700040E4 */ - 0x0F12486E, /*700040E6 */ - 0x0F12884A, /*700040E8 */ - 0x0F128843, /*700040EA */ - 0x0F12435A, /*700040EC */ - 0x0F122304, /*700040EE */ - 0x0F125ECB, /*700040F0 */ - 0x0F120A92, /*700040F2 */ - 0x0F1218D2, /*700040F4 */ - 0x0F1202D2, /*700040F6 */ - 0x0F120C12, /*700040F8 */ - 0x0F1288CB, /*700040FA */ - 0x0F128880, /*700040FC */ - 0x0F124343, /*700040FE */ - 0x0F120A98, /*70004100 */ - 0x0F122308, /*70004102 */ - 0x0F125ECB, /*70004104 */ - 0x0F1218C0, /*70004106 */ - 0x0F1202C0, /*70004108 */ - 0x0F120C00, /*7000410A */ - 0x0F120411, /*7000410C */ - 0x0F120400, /*7000410E */ - 0x0F121409, /*70004110 */ - 0x0F121400, /*70004112 */ - 0x0F121A08, /*70004114 */ - 0x0F124962, /*70004116 */ - 0x0F1239E0, /*70004118 */ - 0x0F126148, /*7000411A */ - 0x0F129801, /*7000411C */ - 0x0F123040, /*7000411E */ - 0x0F127880, /*70004120 */ - 0x0F122800, /*70004122 */ - 0x0F12D103, /*70004124 */ - 0x0F129801, /*70004126 */ - 0x0F120029, /*70004128 */ - 0x0F12F000, /*7000412A */ - 0x0F12F959, /*7000412C */ - 0x0F128839, /*7000412E */ - 0x0F129800, /*70004130 */ - 0x0F124281, /*70004132 */ - 0x0F12D814, /*70004134 */ - 0x0F128879, /*70004136 */ - 0x0F129800, /*70004138 */ - 0x0F124281, /*7000413A */ - 0x0F12D20C, /*7000413C */ - 0x0F129801, /*7000413E */ - 0x0F120029, /*70004140 */ - 0x0F12F000, /*70004142 */ - 0x0F12F955, /*70004144 */ - 0x0F129801, /*70004146 */ - 0x0F120029, /*70004148 */ - 0x0F12F000, /*7000414A */ - 0x0F12F951, /*7000414C */ - 0x0F129801, /*7000414E */ - 0x0F120029, /*70004150 */ - 0x0F12F000, /*70004152 */ - 0x0F12F94D, /*70004154 */ - 0x0F12E003, /*70004156 */ - 0x0F129801, /*70004158 */ - 0x0F120029, /*7000415A */ - 0x0F12F000, /*7000415C */ - 0x0F12F948, /*7000415E */ - 0x0F129801, /*70004160 */ - 0x0F120032, /*70004162 */ - 0x0F120039, /*70004164 */ - 0x0F12F000, /*70004166 */ - 0x0F12F94B, /*70004168 */ - 0x0F126020, /*7000416A */ - 0x0F12E5D0, /*7000416C */ - 0x0F12B57C, /*7000416E */ - 0x0F12484C, /*70004170 */ - 0x0F12A901, /*70004172 */ - 0x0F120004, /*70004174 */ - 0x0F12F000, /*70004176 */ - 0x0F12F8CF, /*70004178 */ - 0x0F12466B, /*7000417A */ - 0x0F1288D9, /*7000417C */ - 0x0F128898, /*7000417E */ - 0x0F124B47, /*70004180 */ - 0x0F123346, /*70004182 */ - 0x0F121E9A, /*70004184 */ - 0x0F12F000, /*70004186 */ - 0x0F12F943, /*70004188 */ - 0x0F124846, /*7000418A */ - 0x0F124944, /*7000418C */ - 0x0F123812, /*7000418E */ - 0x0F123140, /*70004190 */ - 0x0F128A42, /*70004192 */ - 0x0F12888B, /*70004194 */ - 0x0F1218D2, /*70004196 */ - 0x0F128242, /*70004198 */ - 0x0F128AC2, /*7000419A */ - 0x0F1288C9, /*7000419C */ - 0x0F121851, /*7000419E */ - 0x0F1282C1, /*700041A0 */ - 0x0F120020, /*700041A2 */ - 0x0F124669, /*700041A4 */ - 0x0F12F000, /*700041A6 */ - 0x0F12F8B7, /*700041A8 */ - 0x0F12483F, /*700041AA */ - 0x0F12214D, /*700041AC */ - 0x0F128301, /*700041AE */ - 0x0F122196, /*700041B0 */ - 0x0F128381, /*700041B2 */ - 0x0F12211D, /*700041B4 */ - 0x0F123020, /*700041B6 */ - 0x0F128001, /*700041B8 */ - 0x0F12F000, /*700041BA */ - 0x0F12F931, /*700041BC */ - 0x0F12F000, /*700041BE */ - 0x0F12F937, /*700041C0 */ - 0x0F12483A, /*700041C2 */ - 0x0F124C3A, /*700041C4 */ - 0x0F126E00, /*700041C6 */ - 0x0F1260E0, /*700041C8 */ - 0x0F12466B, /*700041CA */ - 0x0F128818, /*700041CC */ - 0x0F128859, /*700041CE */ - 0x0F120025, /*700041D0 */ - 0x0F121A40, /*700041D2 */ - 0x0F123540, /*700041D4 */ - 0x0F1261A8, /*700041D6 */ - 0x0F124831, /*700041D8 */ - 0x0F129900, /*700041DA */ - 0x0F123060, /*700041DC */ - 0x0F12F000, /*700041DE */ - 0x0F12F92F, /*700041E0 */ - 0x0F12466B, /*700041E2 */ - 0x0F128819, /*700041E4 */ - 0x0F121DE0, /*700041E6 */ - 0x0F1230F9, /*700041E8 */ - 0x0F128741, /*700041EA */ - 0x0F128859, /*700041EC */ - 0x0F128781, /*700041EE */ - 0x0F122000, /*700041F0 */ - 0x0F1271A0, /*700041F2 */ - 0x0F1274A8, /*700041F4 */ - 0x0F12BC7C, /*700041F6 */ - 0x0F12BC08, /*700041F8 */ - 0x0F124718, /*700041FA */ - 0x0F12B5F8, /*700041FC */ - 0x0F120005, /*700041FE */ - 0x0F126808, /*70004200 */ - 0x0F120400, /*70004202 */ - 0x0F120C00, /*70004204 */ - 0x0F12684A, /*70004206 */ - 0x0F120412, /*70004208 */ - 0x0F120C12, /*7000420A */ - 0x0F12688E, /*7000420C */ - 0x0F1268CC, /*7000420E */ - 0x0F124922, /*70004210 */ - 0x0F12884B, /*70004212 */ - 0x0F124343, /*70004214 */ - 0x0F120A98, /*70004216 */ - 0x0F122304, /*70004218 */ - 0x0F125ECB, /*7000421A */ - 0x0F1218C0, /*7000421C */ - 0x0F1202C0, /*7000421E */ - 0x0F120C00, /*70004220 */ - 0x0F1288CB, /*70004222 */ - 0x0F124353, /*70004224 */ - 0x0F120A9A, /*70004226 */ - 0x0F122308, /*70004228 */ - 0x0F125ECB, /*7000422A */ - 0x0F1218D1, /*7000422C */ - 0x0F1202C9, /*7000422E */ - 0x0F120C09, /*70004230 */ - 0x0F122701, /*70004232 */ - 0x0F12003A, /*70004234 */ - 0x0F1240AA, /*70004236 */ - 0x0F129200, /*70004238 */ - 0x0F12002A, /*7000423A */ - 0x0F123A10, /*7000423C */ - 0x0F124097, /*7000423E */ - 0x0F122D10, /*70004240 */ - 0x0F12DA06, /*70004242 */ - 0x0F124A1B, /*70004244 */ - 0x0F129B00, /*70004246 */ - 0x0F128812, /*70004248 */ - 0x0F12439A, /*7000424A */ - 0x0F124B19, /*7000424C */ - 0x0F12801A, /*7000424E */ - 0x0F12E003, /*70004250 */ - 0x0F124B18, /*70004252 */ - 0x0F12885A, /*70004254 */ - 0x0F1243BA, /*70004256 */ - 0x0F12805A, /*70004258 */ - 0x0F120023, /*7000425A */ - 0x0F120032, /*7000425C */ - 0x0F12F000, /*7000425E */ - 0x0F12F8D7, /*70004260 */ - 0x0F122D10, /*70004262 */ - 0x0F12DA05, /*70004264 */ - 0x0F124913, /*70004266 */ - 0x0F129A00, /*70004268 */ - 0x0F128808, /*7000426A */ - 0x0F124310, /*7000426C */ - 0x0F128008, /*7000426E */ - 0x0F12E003, /*70004270 */ - 0x0F124810, /*70004272 */ - 0x0F128841, /*70004274 */ - 0x0F124339, /*70004276 */ - 0x0F128041, /*70004278 */ - 0x0F124D0D, /*7000427A */ - 0x0F122000, /*7000427C */ - 0x0F123580, /*7000427E */ - 0x0F1288AA, /*70004280 */ - 0x0F125E30, /*70004282 */ - 0x0F122100, /*70004284 */ - 0x0F12F000, /*70004286 */ - 0x0F12F8E3, /*70004288 */ - 0x0F128030, /*7000428A */ - 0x0F122000, /*7000428C */ - 0x0F1288AA, /*7000428E */ - 0x0F125E20, /*70004290 */ - 0x0F122100, /*70004292 */ - 0x0F12F000, /*70004294 */ - 0x0F12F8DC, /*70004296 */ - 0x0F128020, /*70004298 */ - 0x0F12E587, /*7000429A */ - 0x0F122558, /*7000429C */ - 0x0F127000, /*7000429E */ - 0x0F122AB8, /*700042A0 */ - 0x0F127000, /*700042A2 */ - 0x0F12145E, /*700042A4 */ - 0x0F127000, /*700042A6 */ - 0x0F122698, /*700042A8 */ - 0x0F127000, /*700042AA */ - 0x0F122BB8, /*700042AC */ - 0x0F127000, /*700042AE */ - 0x0F122998, /*700042B0 */ - 0x0F127000, /*700042B2 */ - 0x0F121100, /*700042B4 */ - 0x0F12D000, /*700042B6 */ - 0x0F124778, /*700042B8 */ - 0x0F1246C0, /*700042BA */ - 0x0F12C000, /*700042BC */ - 0x0F12E59F, /*700042BE */ - 0x0F12FF1C, /*700042C0 */ - 0x0F12E12F, /*700042C2 */ - 0x0F121789, /*700042C4 */ - 0x0F120001, /*700042C6 */ - 0x0F124778, /*700042C8 */ - 0x0F1246C0, /*700042CA */ - 0x0F12C000, /*700042CC */ - 0x0F12E59F, /*700042CE */ - 0x0F12FF1C, /*700042D0 */ - 0x0F12E12F, /*700042D2 */ - 0x0F1216F1, /*700042D4 */ - 0x0F120001, /*700042D6 */ - 0x0F124778, /*700042D8 */ - 0x0F1246C0, /*700042DA */ - 0x0F12C000, /*700042DC */ - 0x0F12E59F, /*700042DE */ - 0x0F12FF1C, /*700042E0 */ - 0x0F12E12F, /*700042E2 */ - 0x0F12C3B1, /*700042E4 */ - 0x0F120000, /*700042E6 */ - 0x0F124778, /*700042E8 */ - 0x0F1246C0, /*700042EA */ - 0x0F12C000, /*700042EC */ - 0x0F12E59F, /*700042EE */ - 0x0F12FF1C, /*700042F0 */ - 0x0F12E12F, /*700042F2 */ - 0x0F12C36D, /*700042F4 */ - 0x0F120000, /*700042F6 */ - 0x0F124778, /*700042F8 */ - 0x0F1246C0, /*700042FA */ - 0x0F12C000, /*700042FC */ - 0x0F12E59F, /*700042FE */ - 0x0F12FF1C, /*70004300 */ - 0x0F12E12F, /*70004302 */ - 0x0F12F6D7, /*70004304 */ - 0x0F120000, /*70004306 */ - 0x0F124778, /*70004308 */ - 0x0F1246C0, /*7000430A */ - 0x0F12C000, /*7000430C */ - 0x0F12E59F, /*7000430E */ - 0x0F12FF1C, /*70004310 */ - 0x0F12E12F, /*70004312 */ - 0x0F12B49D, /*70004314 */ - 0x0F120000, /*70004316 */ - 0x0F124778, /*70004318 */ - 0x0F1246C0, /*7000431A */ - 0x0F12C000, /*7000431C */ - 0x0F12E59F, /*7000431E */ - 0x0F12FF1C, /*70004320 */ - 0x0F12E12F, /*70004322 */ - 0x0F127EDF, /*70004324 */ - 0x0F120000, /*70004326 */ - 0x0F124778, /*70004328 */ - 0x0F1246C0, /*7000432A */ - 0x0F12C000, /*7000432C */ - 0x0F12E59F, /*7000432E */ - 0x0F12FF1C, /*70004330 */ - 0x0F12E12F, /*70004332 */ - 0x0F12448D, /*70004334 */ - 0x0F120000, /*70004336 */ - 0x0F124778, /*70004338 */ - 0x0F1246C0, /*7000433A */ - 0x0F12F004, /*7000433C */ - 0x0F12E51F, /*7000433E */ - 0x0F1229EC, /*70004340 */ - 0x0F120001, /*70004342 */ - 0x0F124778, /*70004344 */ - 0x0F1246C0, /*70004346 */ - 0x0F12C000, /*70004348 */ - 0x0F12E59F, /*7000434A */ - 0x0F12FF1C, /*7000434C */ - 0x0F12E12F, /*7000434E */ - 0x0F122EF1, /*70004350 */ - 0x0F120000, /*70004352 */ - 0x0F124778, /*70004354 */ - 0x0F1246C0, /*70004356 */ - 0x0F12C000, /*70004358 */ - 0x0F12E59F, /*7000435A */ - 0x0F12FF1C, /*7000435C */ - 0x0F12E12F, /*7000435E */ - 0x0F12EE03, /*70004360 */ - 0x0F120000, /*70004362 */ - 0x0F124778, /*70004364 */ - 0x0F1246C0, /*70004366 */ - 0x0F12C000, /*70004368 */ - 0x0F12E59F, /*7000436A */ - 0x0F12FF1C, /*7000436C */ - 0x0F12E12F, /*7000436E */ - 0x0F12A58B, /*70004370 */ - 0x0F120000, /*70004372 */ - 0x0F124778, /*70004374 */ - 0x0F1246C0, /*70004376 */ - 0x0F12C000, /*70004378 */ - 0x0F12E59F, /*7000437A */ - 0x0F12FF1C, /*7000437C */ - 0x0F12E12F, /*7000437E */ - 0x0F127C49, /*70004380 */ - 0x0F120000, /*70004382 */ - 0x0F124778, /*70004384 */ - 0x0F1246C0, /*70004386 */ - 0x0F12C000, /*70004388 */ - 0x0F12E59F, /*7000438A */ - 0x0F12FF1C, /*7000438C */ - 0x0F12E12F, /*7000438E */ - 0x0F127C63, /*70004390 */ - 0x0F120000, /*70004392 */ - 0x0F124778, /*70004394 */ - 0x0F1246C0, /*70004396 */ - 0x0F12C000, /*70004398 */ - 0x0F12E59F, /*7000439A */ - 0x0F12FF1C, /*7000439C */ - 0x0F12E12F, /*7000439E */ - 0x0F122DB7, /*700043A0 */ - 0x0F120000, /*700043A2 */ - 0x0F124778, /*700043A4 */ - 0x0F1246C0, /*700043A6 */ - 0x0F12C000, /*700043A8 */ - 0x0F12E59F, /*700043AA */ - 0x0F12FF1C, /*700043AC */ - 0x0F12E12F, /*700043AE */ - 0x0F12EB3D, /*700043B0 */ - 0x0F120000, /*700043B2 */ - 0x0F124778, /*700043B4 */ - 0x0F1246C0, /*700043B6 */ - 0x0F12C000, /*700043B8 */ - 0x0F12E59F, /*700043BA */ - 0x0F12FF1C, /*700043BC */ - 0x0F12E12F, /*700043BE */ - 0x0F12F061, /*700043C0 */ - 0x0F120000, /*700043C2 */ - 0x0F124778, /*700043C4 */ - 0x0F1246C0, /*700043C6 */ - 0x0F12C000, /*700043C8 */ - 0x0F12E59F, /*700043CA */ - 0x0F12FF1C, /*700043CC */ - 0x0F12E12F, /*700043CE */ - 0x0F12F0EF, /*700043D0 */ - 0x0F120000, /*700043D2 */ - 0x0F124778, /*700043D4 */ - 0x0F1246C0, /*700043D6 */ - 0x0F12F004, /*700043D8 */ - 0x0F12E51F, /*700043DA */ - 0x0F122824, /*700043DC */ - 0x0F120001, /*700043DE */ - 0x0F124778, /*700043E0 */ - 0x0F1246C0, /*700043E2 */ - 0x0F12C000, /*700043E4 */ - 0x0F12E59F, /*700043E6 */ - 0x0F12FF1C, /*700043E8 */ - 0x0F12E12F, /*700043EA */ - 0x0F128EDD, /*700043EC */ - 0x0F120000, /*700043EE */ - 0x0F124778, /*700043F0 */ - 0x0F1246C0, /*700043F2 */ - 0x0F12C000, /*700043F4 */ - 0x0F12E59F, /*700043F6 */ - 0x0F12FF1C, /*700043F8 */ - 0x0F12E12F, /*700043FA */ - 0x0F128DCB, /*700043FC */ - 0x0F120000, /*700043FE */ - 0x0F124778, /*70004400 */ - 0x0F1246C0, /*70004402 */ - 0x0F12C000, /*70004404 */ - 0x0F12E59F, /*70004406 */ - 0x0F12FF1C, /*70004408 */ - 0x0F12E12F, /*7000440A */ - 0x0F128E17, /*7000440C */ - 0x0F120000, /*7000440E */ - 0x0F124778, /*70004410 */ - 0x0F1246C0, /*70004412 */ - 0x0F12C000, /*70004414 */ - 0x0F12E59F, /*70004416 */ - 0x0F12FF1C, /*70004418 */ - 0x0F12E12F, /*7000441A */ - 0x0F1298C5, /*7000441C */ - 0x0F120000, /*7000441E */ - 0x0F124778, /*70004420 */ - 0x0F1246C0, /*70004422 */ - 0x0F12C000, /*70004424 */ - 0x0F12E59F, /*70004426 */ - 0x0F12FF1C, /*70004428 */ - 0x0F12E12F, /*7000442A */ - 0x0F127C7D, /*7000442C */ - 0x0F120000, /*7000442E */ - 0x0F124778, /*70004430 */ - 0x0F1246C0, /*70004432 */ - 0x0F12C000, /*70004434 */ - 0x0F12E59F, /*70004436 */ - 0x0F12FF1C, /*70004438 */ - 0x0F12E12F, /*7000443A */ - 0x0F127E31, /*7000443C */ - 0x0F120000, /*7000443E */ - 0x0F124778, /*70004440 */ - 0x0F1246C0, /*70004442 */ - 0x0F12C000, /*70004444 */ - 0x0F12E59F, /*70004446 */ - 0x0F12FF1C, /*70004448 */ - 0x0F12E12F, /*7000444A */ - 0x0F127EAB, /*7000444C */ - 0x0F120000, /*7000444E */ - 0x0F124778, /*70004450 */ - 0x0F1246C0, /*70004452 */ - 0x0F12C000, /*70004454 */ - 0x0F12E59F, /*70004456 */ - 0x0F12FF1C, /*70004458 */ - 0x0F12E12F, /*7000445A */ - 0x0F127501, /*7000445C */ - 0x0F120000, /*7000445E */ -/* End of Patch Data(Last : 7000445Eh) -// Total Size 2408 (0x0968) -// Addr : 3AF8 , Size : 2406(966h) - -//TNP_USER_MBCV_CONTROL -//TNP_4EC_MBR_TUNE -//TNP_4EC_FORBIDDEN_TUNE -//TNP_AF_FINESEARCH_DRIVEBACK -//TNP_FLASH_ALG -//TNP_GAS_ALPHA_OTP -//TNP_AWB_MODUL_COMP -//TNP_AWB_INIT_QUEUE -//TNP_AWB_GRID_LOWBR -//TNP_AWB_GRID_MODULECOMP*/ - - 0x0028D000, - 0x002A1000, - 0x0F120001, - /* End of FACTORY ONLY. */ - - /*AF setting */ - 0x00287000, - 0x002A01FC, - 0x0F120001, /*REG_TC_IPRM_LedGpio */ - /*70001720 0100 Only STW Use IT */ - 0x002A01FE, - 0x0F120003, - 0x0F120000, - 0x002A0204, - 0x0F120061, - 0x002A020C, - 0x0F122F0C, - 0x0F120190, - 0x002A0294, - 0x0F120100, - 0x0F1200E3, - 0x0F120200, - 0x0F120238, - 0x0F1201C6, - 0x0F120166, - 0x0F120074, - 0x0F120132, - 0x0F120001, - - 0x002A070E, - 0x0F1200FF, - 0x002A071E, - 0x0F120001, - 0x002A163C, - 0x0F120000, - - 0x002A1648, - 0x0F129002, /*2nd search on when 2nd search lens opsite direct moving*/ - 0x002A1652, - 0x0F120002, - 0x0F120000, - 0x002A15E0, - 0x0F120801, /* when 2nd search 1code distance 6+1 position move */ - - 0x002A164C, - 0x0F120003, - 0x002A163E, - 0x0F1200E5, - 0x0F1200CC, /*98(60%) -> CC(80%) */ - 0x002A15D4, - 0x0F120000, - 0x0F12D000, - 0x002A169A, - 0x0F12FF95, - 0x002A166A, - 0x0F120280, - 0x002A1676, - 0x0F1203A0, - 0x0F120320, - 0x002A16BC, - 0x0F120030, - 0x002A16E0, - 0x0F120060, - 0x002A16D4, - 0x0F120010, - 0x002A1656, - 0x0F120000, - 0x002A15E6, - 0x0F12003C, - - 0x0F120017, /*af_pos_usTableLastInd */ - 0x0F120026, - 0x0F12002C, - 0x0F120032, - 0x0F120038, - 0x0F12003E, - 0x0F120044, - 0x0F12004A, - 0x0F120050, - 0x0F120056, - 0x0F12005C, - 0x0F120062, - 0x0F120068, - 0x0F12006E, - 0x0F120074, - 0x0F12007A, - 0x0F120080, - 0x0F120086, - 0x0F12008C, - 0x0F120092, - 0x0F120098, - 0x0F12009E, - 0x0F1200A4, - 0x0F1200AA, - 0x0F1200B0, - - 0x002A1722, - 0x0F128000, - 0x0F120006, - 0x0F123FF0, - 0x0F1203E8, - 0x0F120000, - 0x0F120080, /*delay2 when threshold upper lens moving when moving*/ - 0x0F120009, /*threshold */ - 0x0F120020, /*delay1 when threshold lower lens moving when moving*/ - 0x0F120040, - 0x0F120080, - 0x0F1200C0, - 0x0F1200E0, - - 0x002A028C, - 0x0F120003, /*REG_TC_AF_AfCmd */ - -/*=================================================================== -//04.Gas_Anti Shading_Otp -//==================================================================*/ - 0x002A08B4, - 0x0F120001, /*wbt_bUseOutdoorASH */ - -/* Refer Mon_AWB_RotGain*/ - 0x002A08BC, - 0x0F1200C0, /*TVAR_ash_AwbAshCord_0_ 2300K*/ - 0x0F1200DF, /*TVAR_ash_AwbAshCord_1_ 2750K*/ - 0x0F120100, /*TVAR_ash_AwbAshCord_2_ 3300K*/ - 0x0F120125, /*TVAR_ash_AwbAshCord_3_ 4150K*/ - 0x0F12015F, /*TVAR_ash_AwbAshCord_4_ 5250K*/ - 0x0F12017C, /*TVAR_ash_AwbAshCord_5_ 6400K*/ - 0x0F120194, /*TVAR_ash_AwbAshCord_6_ 7500K*/ - -/* GAS Alpha Table*/ - 0x002A08F6, - 0x0F124000, /*TVAR_ash_GASAlpha_0__0_ R // 2300K */ - 0x0F124000, /*TVAR_ash_GASAlpha_0__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_0__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_0__3_ B */ - 0x0F124000, /*TVAR_ash_GASAlpha_1__0_ R // 2750K */ - 0x0F124000, /*TVAR_ash_GASAlpha_1__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_1__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_1__3_ B */ - 0x0F124000, /*TVAR_ash_GASAlpha_2__0_ R // 3300K */ - 0x0F124000, /*TVAR_ash_GASAlpha_2__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_2__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_2__3_ B */ - 0x0F123C00, /*TVAR_ash_GASAlpha_3__0_ R // 4150K */ - 0x0F124000, /*TVAR_ash_GASAlpha_3__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_3__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_3__3_ B */ - 0x0F123E00, /*TVAR_ash_GASAlpha_4__0_ R // 5250K */ - 0x0F124000, /*TVAR_ash_GASAlpha_4__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_4__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_4__3_ B */ - 0x0F124100, /*TVAR_ash_GASAlpha_5__0_ R // 6400K */ - 0x0F124000, /*TVAR_ash_GASAlpha_5__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_5__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_5__3_ B */ - 0x0F124200, /*TVAR_ash_GASAlpha_6__0_ R // 7500K */ - 0x0F124000, /*TVAR_ash_GASAlpha_6__1_ GR */ - 0x0F124000, /*TVAR_ash_GASAlpha_6__2_ GB */ - 0x0F124000, /*TVAR_ash_GASAlpha_6__3_ B */ - -/* Outdoor GAS Alpha*/ - 0x0F124500, /*TVAR_ash_GASOutdoorAlpha_0_ R */ - 0x0F124000, /*TVAR_ash_GASOutdoorAlpha_1_ GR */ - 0x0F124000, /*TVAR_ash_GASOutdoorAlpha_2_ GB */ - 0x0F124000, /*TVAR_ash_GASOutdoorAlpha_3_ B */ - - 0x002A08F4, - 0x0F120001, /*ash_bUseGasAlpha */ - -/*================================================================= -// 09.Auto Flicker Detection -//================================================================*/ - - 0x002A0F30, - 0x0F120001, /*AFC_D_ConvAccelerPower */ - -/*Auto Flicker (60Mhz start)*/ - 0x002A0F2A, - 0x0F120000, /*AFC_Default BIT[0] 1:60Hz 0:50Hz */ - 0x002A04E6, - 0x0F12077F, /*REG_TC_DBG 7F: 60Hz 5F:50Hz */ - -/*=========================================================== -// 10.AE Setting -//==========================================================*/ - 0x002A1484, - 0x0F12003C, /*TVAR_ae_BrAve */ - 0x002A148A, - 0x0F12000F, /*ae_StatMode */ - 0x002A058C, - 0x0F123520, - 0x0F120000, /*lt_uMaxExp1 */ - 0x0F12C350, - 0x0F120000, /*lt_uMaxExp2 */ - 0x0F123520, - 0x0F120000, /*lt_uCapMaxExp1 */ - 0x0F12C350, - 0x0F120000, /*lt_uCapMaxExp2*/ - 0x002A059C, - 0x0F120470, /*lt_uMaxAnGain1 */ - 0x0F120C00, /*lt_uMaxAnGain2 */ - 0x0F120100, /*lt_uMaxDigGain */ - 0x0F121000, /*lt_uMaxTotGain */ - - 0x002A0544, - 0x0F120111, /*lt_uLimitHigh */ - 0x0F1200EF, /*lt_uLimitLow */ - - 0x002A0F2A, - 0x0F120000, /*AFC_Default60Hz 0001:60Hz 0000h:50Hz */ - 0x002A04E6, - 0x0F12077F, /*REG_TC_DBG */ - - 0x002A0F30, - 0x0F120001, /*AFC_D_ConvAccelerPower */ - - 0x002A0608, - 0x0F120001, /*lt_ExpGain_uSubsamplingmode */ - 0x0F120001, /*lt_ExpGain_uNonSubsampling */ - 0x0F120800, /*lt_ExpGain_ExpCurveGainMaxStr */ - 0x0F120100,/*0100 //lt_ExpGain_ExpCurveGainMaxStr_0_uMaxDigGain*/ - 0x0F120001, /*0001 */ - 0x0F120000,/*0000 //lt_ExpGain_ExpCurveGainMaxStr_0__ulExpIn_0_ */ - 0x0F120A3C, /*0A3C */ - 0x0F120000, /*0000 */ - 0x0F120D05, /*0D05 */ - 0x0F120000, /*0000 */ - 0x0F124008, /*4008 */ - 0x0F120000, /*0000 */ - 0x0F127000, /*7400 //?? //700Lux */ - 0x0F120000, /*0000 */ - 0x0F129C00, /*C000 //?? //9C00->9F->A5 //400Lux */ - 0x0F120000, /*0000 */ - 0x0F12AD00, /*AD00 */ - 0x0F120001, /*0001 */ - 0x0F12F1D4, /*F1D4 */ - 0x0F120002, /*0002 */ - 0x0F12DC00, /*DC00 */ - 0x0F120005, /*0005 */ - 0x0F12DC00, /*DC00 */ - 0x0F120005, /*0005 */ - /**/ - 0x002A0638, /*0638 */ - 0x0F120001, /*0001 */ - 0x0F120000,/*0000 //lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_*/ - 0x0F120A3C, /*0A3C */ - 0x0F120000, /*0000 */ - 0x0F120D05, /*0D05 */ - 0x0F120000, /*0000 */ - 0x0F123408, /*3408 */ - 0x0F120000, /*0000 */ - 0x0F123408, /*3408 */ - 0x0F120000, /*0000 */ - 0x0F126810, /*6810 */ - 0x0F120000, /*0000 */ - 0x0F128214, /*8214 */ - 0x0F120000, /*0000 */ - 0x0F12C350, /*C350 */ - 0x0F120000, /*0000 */ - 0x0F12C350, /*C350 */ - 0x0F120000, /*0000 */ - 0x0F12C350, /*C350 */ - 0x0F120000, /*0000 */ - 0x002A0660, - 0x0F120650, /*lt_ExpGain_ExpCurveGainMaxStr_1_ */ - 0x0F120100, /*lt_ExpGain_ExpCurveGainMaxStr_1__uMaxDigGain */ - 0x002A06B8, - 0x0F12452C, - 0x0F120005, /*lt_uMaxLei */ - -/*=========================================================== -// 11.AE Weight (Normal) -//==========================================================*/ - 0x002A1492, - 0x0F120100, - 0x0F120101, - 0x0F120101, - 0x0F120001, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120201, - 0x0F120202, - 0x0F120202, - 0x0F120102, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - -/*============================================ -// 14.AWB-BASIC setting -//============================================*/ - -/*AWB init Start point*/ - 0x002A145E, - 0x0F120580, - 0x0F120428, - 0x0F1207B0, - - /*AWB Init */ -/*White Locus*/ - 0x002A11F0, - 0x0F120120, /*awbb_IntcR */ - 0x0F120121, /*awbb_IntcB */ - -/*Indoor Zone*/ - 0x002A101C, - 0x0F120386, - 0x0F1203A8, - 0x0F12033C, - 0x0F120394, - 0x0F1202FE, - 0x0F120372, - 0x0F1202A8, - 0x0F120352, - 0x0F12027C, - 0x0F120300, - 0x0F120264, - 0x0F1202C8, - 0x0F120244, - 0x0F1202A8, - 0x0F12022C, - 0x0F1202A0, - 0x0F12020C, - 0x0F1202A0, - 0x0F1201F4, - 0x0F120298, - 0x0F1201D4, - 0x0F120290, - 0x0F1201CC, - 0x0F120276, - 0x0F1201D2, - 0x0F120260, - 0x0F1201F6, - 0x0F12023A, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, /*awbb_IndoorGrZones_m_GridStep */ - 0x0F120005, - 0x002A1070, /*awbb_IndoorGrZones_ZInfo_m_GridSz */ - 0x0F12000F, - 0x002A1074, /*awbb_IndoorGrZones_m_Boffs */ - 0x0F120126, -/* Outdoor Zone*/ - 0x002A1078, - 0x0F120270, - 0x0F120296, - 0x0F12024A, - 0x0F1202AC, - 0x0F120240, - 0x0F1202B0, - 0x0F120234, - 0x0F1202B0, - 0x0F120228, - 0x0F1202AE, - 0x0F12021E, - 0x0F1202A8, - 0x0F120212, - 0x0F1202A0, - 0x0F120210, - 0x0F120294, - 0x0F12020E, - 0x0F120288, - 0x0F120218, - 0x0F12027E, - 0x0F120234, - 0x0F120256, - 0x0F120000, - 0x0F120000, - - 0x0F120004, /*awbb_OutdoorGrZones_m_GridStep */ - 0x002A10AC, - 0x0F12000B, /*awbb_OutdoorGrZones_ZInfo_m_GridSz */ - 0x002A10B0, - 0x0F1201E8, /*awbb_OutdoorGrZones_m_Boffs */ - - /*LowBR Zone */ - 0x002A10B4, - 0x0F120350, - 0x0F120422, - 0x0F1202C4, - 0x0F120452, - 0x0F120278, - 0x0F12041C, - 0x0F120230, - 0x0F1203EE, - 0x0F1201F0, - 0x0F120392, - 0x0F1201C0, - 0x0F120340, - 0x0F120194, - 0x0F120302, - 0x0F12016E, - 0x0F1202C2, - 0x0F120148, - 0x0F120286, - 0x0F12018A, - 0x0F120242, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - - 0x0F120006, /*awbb_LowBrGrZones_m_GridStep */ - 0x002A10E8, - 0x0F12000A, /*awbb_LowBrGrZones_ZInfo_m_GridSz */ - 0x002A10EC, - 0x0F120106, /*awbb_LowBrGrZones_m_Boffs */ - - /*LowTemp Zone */ - 0x002A10F0, - 0x0F120380, - 0x0F120000, /*awbb_CrclLowT_R_c */ - 0x0F120168, - 0x0F120000, /*awbb_CrclLowT_B_c */ - 0x0F122D90, - 0x0F120000, /*awbb_CrclLowT_Rad_c */ - - /*AWB Convergence Speed */ - 0x002A1464, - 0x0F120008, - 0x0F120190, - 0x0F1200A0, - - 0x002A1228, - 0x0F1200C0, - 0x002A122C, - 0x0F120010, - 0x002A122A, - 0x0F120010, - - 0x002A120A, - 0x0F1205D5, /*awbb_MvEq_RBthresh */ - 0x002A120E, - 0x0F120000, - - 0x0F120771, - 0x0F1203A4, - 0x0F120036, - 0x0F12002A, - - 0x002A1278, - 0x0F12FEF7, - 0x0F120021, - 0x0F120AF0, /*0E74 */ - 0x0F120AF0, /*0E74 */ - 0x0F12018F, - 0x0F120096, - 0x0F12000E, - 0x002A1224, - 0x0F120032, - 0x0F12001E, - 0x0F1200C0, - 0x0F120010, - 0x0F120002, /*awbb_YThreshLow_Low */ - 0x002A2BA4, - 0x0F120006, /*Mon_AWB_ByPassMode */ - - 0x002A146C, - 0x0F120002, /*awbb_GridEnable */ - - /*Grid */ - 0x002A1434, - 0x0F1202CE, /* awbb_GridConst_1 */ - 0x0F120347, /* awbb_GridConst_1_1_ */ - 0x0F1203C2, /* awbb_GridConst_1_2_ */ - 0x0F1210A0, /* awbb_GridConst_2 */ - 0x0F1210A1, /* awbb_GridConst_2_1_ */ - 0x0F121185, /* awbb_GridConst_2_2_ */ - 0x0F121186, /* awbb_GridConst_2_3_ */ - 0x0F1211E5, /* awbb_GridConst_2_4_ */ - 0x0F1211E6, /* awbb_GridConst_2_5_ */ - 0x0F1200AB, /* awbb_GridCoeff_R_1 */ - 0x0F1200BF, /* awbb_GridCoeff_B_1 */ - 0x0F1200D2, /* awbb_GridCoeff_R_2 */ - 0x0F120093, /* awbb_GridCoeff_B_2 */ - - /*Indoor Grid Offset */ - 0x002A13A4, - 0x0F120000, /*0000 */ - 0x0F12FFE8, /*FFD8 */ - 0x0F12FFE8, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFD0, /*FFF6 B */ - /**/ - 0x0F120000,/*0000 */ - 0x0F12FFD8, /*FFD8 */ - 0x0F12FFD8, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFD0, /*FFF6 */ - /**/ - 0x0F120000,/*0000 */ - 0x0F12FFD8, /*FFD8 */ - 0x0F12FFD8, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFC0, /*FFD8 */ - 0x0F12FFD0, /*FFF6 */ - /**/ - 0x0F12FFEC,/*FFEC*/ - 0x0F120010,/*000A */ - 0x0F120010, /*000A */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFBC, /*FF56 7 */ - /**/ - 0x0F12FFEC,/*FFEC*/ - 0x0F120010,/*000A */ - 0x0F120010, /*000A */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFBC, /*FF56 */ - /**/ - 0x0F12FFEC,/*FFEC*/ - 0x0F120010,/*000A */ - 0x0F120010, /*000A */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFC0, /*FFC4 */ - 0x0F12FFBC, /*FF56 */ - -/*Outdoor Grid Offset*/ - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F120000, - 0x0F120000, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F120000, - 0x0F120000, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F12FFE0, - 0x0F120000, - 0x0F120000, - 0x0F12FFB0, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F120000, - 0x0F120000, - 0x0F12FFB0, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F120000, - 0x0F120000, - 0x0F12FFB0, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F12FFA8, - 0x0F120000, - 0x0F120000, - 0x002A1208, - 0x0F120020, - - 0x002A144E, - 0x0F120000, /*awbb_RGainOff */ - 0x0F12FFE0, /*awbb_BGainOff */ - 0x0F120000, /*awbb_GGainOff */ - -/*====================================================== -// 15.CCM Setting -//=====================================================*/ - /*CCM*/ - 0x002A08A6, - 0x0F1200C0, - 0x0F120100, - 0x0F120125, - 0x0F12015F, - 0x0F12017C, - 0x0F120194, - - 0x0F120001, - - 0x002A0898, - 0x0F124800, - 0x0F127000, - 0x002A08A0, - 0x0F1248D8, - 0x0F127000, - 0x002A4800,/*Horizon */ - 0x0F120208, - 0x0F12FFB5, - 0x0F12FFE8, - 0x0F12FF20, - 0x0F1201BF, - 0x0F12FF53, - 0x0F120022, - 0x0F12FFEA, - 0x0F1201C2, - 0x0F1200C6, - 0x0F120095, - 0x0F12FEFD, - 0x0F120206, - 0x0F12FF7F, - 0x0F120191, - 0x0F12FF06, - 0x0F1201BA, - 0x0F120108, - - 0x0F120208, /* inca A */ - 0x0F12FFB5, - 0x0F12FFE8, - 0x0F12FF20, - 0x0F1201BF, - 0x0F12FF53, - 0x0F120022, - 0x0F12FFEA, - 0x0F1201C2, - 0x0F1200C6, - 0x0F120095, - 0x0F12FEFD, - 0x0F120206, - 0x0F12FF7F, - 0x0F120191, - 0x0F12FF06, - 0x0F1201BA, - 0x0F120108, - 0x0F120208,/*WW*/ - 0x0F12FFB5, - 0x0F12FFE8, - 0x0F12FF20, - 0x0F1201BF, - 0x0F12FF53, - 0x0F120022, - 0x0F12FFEA, - 0x0F1201C2, - 0x0F1200C6, - 0x0F120095, - 0x0F12FEFD, - 0x0F120206, - 0x0F12FF7F, - 0x0F120191, - 0x0F12FF06, - 0x0F1201BA, - 0x0F120108, - 0x0F120204,/*CW*/ - 0x0F12FFB2, - 0x0F12FFF5, - 0x0F12FEF1, - 0x0F12014E, - 0x0F12FF18, - 0x0F12FFE6, - 0x0F12FFDD, - 0x0F1201B2, - 0x0F1200F2, - 0x0F1200CA, - 0x0F12FF48, - 0x0F120151, - 0x0F12FF50, - 0x0F120147, - 0x0F12FF75, - 0x0F120187, - 0x0F1201BF, - 0x0F1201F5,/*D50*/ - 0x0F12FFB4, - 0x0F120001, - 0x0F12FED7, - 0x0F12014B, - 0x0F12FF35, - 0x0F12FFE6, - 0x0F12FFDD, - 0x0F1201B2, - 0x0F1200F2, - 0x0F1200CA, - 0x0F12FF48, - 0x0F120151, - 0x0F12FF50, - 0x0F120147, - 0x0F12FF75, - 0x0F120187, - 0x0F1201BF, - 0x0F1201F5,/*D65 */ - 0x0F12FFB4, - 0x0F120001, - 0x0F12FED7, - 0x0F12014B, - 0x0F12FF35, - 0x0F12FFE6, - 0x0F12FFDD, - 0x0F1201B2, - 0x0F1200F2, - 0x0F1200CA, - 0x0F12FF48, - 0x0F120151, - 0x0F12FF50, - 0x0F120147, - 0x0F12FF75, - 0x0F120187, - 0x0F1201BF, - 0x0F1201E5,/*Y hue-5. TVAR_wbt_pOutdoorCcm[0] */ - 0x0F12FFA4, - 0x0F12FFDC, - 0x0F12FE90, - 0x0F12013F, - 0x0F12FF1B, - 0x0F12FFD2, - 0x0F12FFDF, - 0x0F120236, - 0x0F1200F0, - 0x0F1200C9, - 0x0F12FF59, - 0x0F1201CE, - 0x0F12FF83, - 0x0F120195, - 0x0F12FEF3, - 0x0F120126, - 0x0F120162, -/*================================================================== -// 16.GAMMA -//================================================================*/ - 0x002A0734,/*R*/ - 0x0F120000, - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - 0x0F120000,/*G*/ - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - 0x0F120000,/*B*/ - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, -/*RGB OutdoorGamma*/ - 0x0F120000, - 0x0F12000B, - 0x0F120019, - 0x0F120036, - 0x0F12006F, - 0x0F1200D8, - 0x0F120135, - 0x0F12015F, - 0x0F120185, - 0x0F1201C1, - 0x0F1201F3, - 0x0F120220, - 0x0F12024A, - 0x0F120291, - 0x0F1202D0, - 0x0F12032A, - 0x0F12036A, - 0x0F12039F, - 0x0F1203CC, - 0x0F1203F9, - 0x0F120000, - 0x0F12000B, - 0x0F120019, - 0x0F120036, - 0x0F12006F, - 0x0F1200D8, - 0x0F120135, - 0x0F12015F, - 0x0F120185, - 0x0F1201C1, - 0x0F1201F3, - 0x0F120220, - 0x0F12024A, - 0x0F120291, - 0x0F1202D0, - 0x0F12032A, - 0x0F12036A, - 0x0F12039F, - 0x0F1203CC, - 0x0F1203F9, - 0x0F120000, - 0x0F12000B, - 0x0F120019, - 0x0F120036, - 0x0F12006F, - 0x0F1200D8, - 0x0F120135, - 0x0F12015F, - 0x0F120185, - 0x0F1201C1, - 0x0F1201F3, - 0x0F120220, - 0x0F12024A, - 0x0F120291, - 0x0F1202D0, - 0x0F12032A, - 0x0F12036A, - 0x0F12039F, - 0x0F1203CC, - 0x0F1203F9, -/*=========================================================== -// 17.AFIT -//==========================================================*/ - 0x002A0944, - 0x0F120050,/*afit_uNoiseIndInDoor */ - 0x0F1200B0, /*afit_uNoiseIndInDoor */ - 0x0F120196, /*afit_uNoiseIndInDoor */ - 0x0F120245, /*afit_uNoiseIndInDoor */ - 0x0F120300, /*afit_uNoiseIndInDoor */ - - 0x002A0938, - 0x0F120000,/* on/off AFIT by NB option */ - 0x0F120014, /*SARR_uNormBrInDoor */ - 0x0F1200D2, /*SARR_uNormBrInDoor */ - 0x0F120384, /*SARR_uNormBrInDoor */ - 0x0F1207D0, /*SARR_uNormBrInDoor */ - 0x0F121388, /*SARR_uNormBrInDoor */ - - 0x002A0976, - 0x0F120070,/*afit_usGamutTh */ - 0x0F120005, /*afit_usNeargrayOffset */ - 0x0F120000, /*afit_bUseSenBpr */ - 0x0F1201CC, /*afit_usBprThr_0_ */ - 0x0F1201CC, /*afit_usBprThr_1_ */ - 0x0F1201CC, /*afit_usBprThr_2_ */ - 0x0F1201CC, /*afit_usBprThr_3_ */ - 0x0F1201CC, /*afit_usBprThr_4_ */ - 0x0F120180, /*afit_NIContrastAFITValue */ - 0x0F120196, /*afit_NIContrastTh */ - - 0x002A098C, - 0x0F12FFEC, /*7000098C//_BRIGHTNESS */ - 0x0F120000, /*7000098E//_CONTRAST */ - 0x0F120000, /*70000990//_SATURATION */ - 0x0F120000, /*70000992//_SHARP_BLUR */ - 0x0F120000, /*70000994//_GLAMOUR */ - 0x0F1200C0, /*70000996//_bnr_edge_high */ - 0x0F120064, /*70000998//_postdmsc_iLowBright */ - 0x0F120384, /*7000099A//_postdmsc_iHighBright */ - 0x0F12005F, /*7000099C//_postdmsc_iLowSat */ - 0x0F1201F4, /*7000099E//_postdmsc_iHighSat */ - 0x0F120070, /*700009A0//_postdmsc_iTune */ - 0x0F120040, /*700009A2//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*700009A4//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*700009A6//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*700009A8//_yuvemix_mPosRanges_0 */ - 0x0F120040, /*700009AA//_yuvemix_mPosRanges_1 */ - 0x0F1200A0, /*700009AC//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*700009AE//_bnr_edge_low */ - 0x0F120201, /*700009B0//_bnr_repl_force */ - 0x0F120204, /*700009B2//_bnr_iHotThreshLow */ - 0x0F123604, /*700009B4//_bnr_iColdThreshLow */ - 0x0F12032A, /*700009B6//_bnr_DispTH_High */ - 0x0F120403, /*700009B8//_bnr_DISP_Limit_High */ - 0x0F121B06, /*700009BA//_bnr_iDistSigmaMax */ - 0x0F126015, /*700009BC//_bnr_iDiffSigmaHigh */ - 0x0F1200C0, /*700009BE//_bnr_iNormalizedSTD_Limit */ - 0x0F126080, /*700009C0//_bnr_iDirMinThres */ - 0x0F124080, /*700009C2//_bnr_iDirFltDiffThresLow */ - 0x0F120640, /*700009C4//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*700009C6//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*700009C8//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*700009CA//_bnr_iSlopeBlurStrength */ - 0x0F120000, /*700009CC//_bnr_AddNoisePower1 */ - 0x0F120400, /*700009CE//_bnr_iRadialTune */ - 0x0F12365A, /*700009D0//_bnr_iRadialLimit */ - 0x0F12102A, /*700009D2//_ee_iFSMagThHigh */ - 0x0F12000B, /*700009D4//_ee_iFSVarThHigh */ - 0x0F120600, /*700009D6//_ee_iFSThHigh */ - 0x0F125A0F, /*700009D8//_ee_iFSVarCountTh */ - 0x0F120505, /*700009DA//_ee_iRadialPower */ - 0x0F121802, /*700009DC//_ee_iROADThres */ - 0x0F120000, /*700009DE//_ee_iROADSubMaxNR */ - 0x0F122006, /*700009E0//_ee_iROADNeiThres */ - 0x0F123028, /*700009E2//_ee_iSmoothEdgeThres */ - 0x0F120418, /*700009E4//_ee_iWSharpen */ - 0x0F120101, /*700009E6//_ee_iWShThresh */ - 0x0F120800, /*700009E8//_ee_iEmbossCentAdd */ - 0x0F121804, /*700009EA//_ee_iReduceEdgeThresh */ - 0x0F124008, /*700009EC//_dmsc_iDesatThresh */ - 0x0F120540, /*700009EE//_dmsc_iDemBlurLow */ - 0x0F128006, /*700009F0//_dmsc_iDecisionThresh */ - 0x0F120020, /*700009F2//_dmsc_iMonochrom */ - 0x0F120000, /*700009F4//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*700009F6//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*700009F8//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*700009FA//_postdmsc_iBCoeff */ - 0x0F12000B, /*700009FC//_postdmsc_iWideMult */ - 0x0F120607, /*700009FE//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000A00//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000A02//_yuvemix_mPosSlopes_1 */ - 0x0F120705, /*70000A04//_yuvemix_mPosSlopes_3 */ - 0x0F120206, /*70000A06//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000A08//_yuviirnr_iHighYNorm */ - 0x0F120309, /*70000A0A//_yuviirnr_iHighUVNorm */ - 0x0F120305, /*70000A0C//_yuviirnr_iUVNormShift */ - 0x0F122006, /*70000A0E//_yuviirnr_iVertLength_UV */ - 0x0F121320, /*70000A10//_yuviirnr_iDiffThreshH_Y */ - 0x0F121014, /*70000A12//_yuviirnr_iDiffThreshH_UV */ - 0x0F121010, /*70000A14//_yuviirnr_iMaxThreshH_Y */ - 0x0F120C10, /*70000A16//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A0C, /*70000A18//_yuviirnr_iYNRStrengthH */ - 0x0F124A18, /*70000A1A//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000A1C//_RGBGamma2_iLinearity */ - 0x0F120350, /*70000A1E//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000A20//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000A22//_bnr_iClustMulT_H */ - 0x0F120101, /*70000A24//_bnr_iClustThresh_H */ - 0x0F122A36, /*70000A26//_bnr_iDenThreshLow */ - 0x0F126024, /*70000A28//_ee_iLowSharpPower */ - 0x0F122A36, /*70000A2A//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000A2C//_ee_iLowSharpClamp */ - 0x0F120808, /*70000A2E//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000A30//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000A32//_bnr_iClustMulT_C_Bin */ - 0x0F122701, /*70000A34//_bnr_iClustThresh_C_Bin */ - 0x0F12241E, /*70000A36//_bnr_iDenThreshHigh_Bin */ - 0x0F122E60, /*70000A38//_ee_iHighSharpPower_Bin */ - 0x0F12FF22, /*70000A3A//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000A3C//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000A3E//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000A40//_bnr_nClustLevel_C */ - 0x0F120000, /*70000A42//_BRIGHTNESS */ - 0x0F120000, /*70000A44//_CONTRAST */ - 0x0F120000, /*70000A46//_SATURATION */ - 0x0F120000, /*70000A48//_SHARP_BLUR */ - 0x0F120000, /*70000A4A//_GLAMOUR */ - 0x0F1200C0, /*70000A4C//_bnr_edge_high */ - 0x0F120064, /*70000A4E//_postdmsc_iLowBright */ - 0x0F120384, /*70000A50//_postdmsc_iHighBright */ - 0x0F120051, /*70000A52//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000A54//_postdmsc_iHighSat */ - 0x0F120070, /*70000A56//_postdmsc_iTune */ - 0x0F120040, /*70000A58//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000A5A//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000A5C//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000A5E//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000A60//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000A62//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000A64//_bnr_edge_low */ - 0x0F120201, /*70000A66//_bnr_repl_force */ - 0x0F120204, /*70000A68//_bnr_iHotThreshLow */ - 0x0F122404, /*70000A6A//_bnr_iColdThreshLow */ - 0x0F12031B, /*70000A6C//_bnr_DispTH_High */ - 0x0F120103, /*70000A6E//_bnr_DISP_Limit_High */ - 0x0F121205, /*70000A70//_bnr_iDistSigmaMax */ - 0x0F12400D, /*70000A72//_bnr_iDiffSigmaHigh */ - 0x0F120080, /*70000A74//_bnr_iNormalizedSTD_Limit */ - 0x0F121980, /*70000A76//_bnr_iDirMinThres */ - 0x0F12272E, /*70000A78//_bnr_iDirFltDiffThresLow */ - 0x0F120629, /*70000A7A//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000A7C//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000A7E//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000A80//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000A82//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000A84//_bnr_iRadialTune */ - 0x0F12245A, /*70000A86//_bnr_iRadialLimit */ - 0x0F121018, /*70000A88//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000A8A//_ee_iFSVarThHigh */ - 0x0F120B00, /*70000A8C//_ee_iFSThHigh */ - 0x0F125A0F, /*70000A8E//_ee_iFSVarCountTh */ - 0x0F120505, /*70000A90//_ee_iRadialPower */ - 0x0F121802, /*70000A92//_ee_iROADThres */ - 0x0F120000, /*70000A94//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000A96//_ee_iROADNeiThres */ - 0x0F123828, /*70000A98//_ee_iSmoothEdgeThres */ - 0x0F120425, /*70000A9A//_ee_iWSharpen */ - 0x0F120101, /*70000A9C//_ee_iWShThresh */ - 0x0F120800, /*70000A9E//_ee_iEmbossCentAdd */ - 0x0F121004, /*70000AA0//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000AA2//_dmsc_iDesatThresh */ - 0x0F120540, /*70000AA4//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000AA6//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000AA8//_dmsc_iMonochrom */ - 0x0F120000, /*70000AAA//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000AAC//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000AAE//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000AB0//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000AB2//_postdmsc_iWideMult */ - 0x0F120607, /*70000AB4//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000AB6//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000AB8//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000ABA//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*70000ABC//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000ABE//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000AC0//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000AC2//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000AC4//_yuviirnr_iVertLength_UV */ - 0x0F122204, /*70000AC6//_yuviirnr_iDiffThreshH_Y */ - 0x0F12021C, /*70000AC8//_yuviirnr_iDiffThreshH_UV */ - 0x0F121102, /*70000ACA//_yuviirnr_iMaxThreshH_Y */ - 0x0F120611, /*70000ACC//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000ACE//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000AD0//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000AD2//_RGBGamma2_iLinearity */ - 0x0F120374, /*70000AD4//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000AD6//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000AD8//_bnr_iClustMulT_H */ - 0x0F120101, /*70000ADA//_bnr_iClustThresh_H */ - 0x0F12141D, /*70000ADC//_bnr_iDenThreshLow */ - 0x0F126024, /*70000ADE//_ee_iLowSharpPower */ - 0x0F121217, /*70000AE0//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000AE2//_ee_iLowSharpClamp */ - 0x0F120808, /*70000AE4//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000AE6//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000AE8//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000AEA//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000AEC//_bnr_iDenThreshHigh_Bin */ - 0x0F121660, /*70000AEE//_ee_iHighSharpPower_Bin */ - 0x0F12FF10, /*70000AF0//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000AF2//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000AF4//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000AF6//_bnr_nClustLevel_C */ - 0x0F120000, /*70000AF8//_BRIGHTNESS AFIT 2 */ - 0x0F120000, /*70000AFA//_CONTRAST */ - 0x0F120000, /*70000AFC//_SATURATION */ - 0x0F120000, /*70000AFE//_SHARP_BLUR */ - 0x0F120000, /*70000B00//_GLAMOUR */ - 0x0F1200C0, /*70000B02//_bnr_edge_high */ - 0x0F120064, /*70000B04//_postdmsc_iLowBright */ - 0x0F120384, /*70000B06//_postdmsc_iHighBright */ - 0x0F120043, /*70000B08//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000B0A//_postdmsc_iHighSat */ - 0x0F120070, /*70000B0C//_postdmsc_iTune */ - 0x0F120040, /*70000B0E//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000B10//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000B12//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000B14//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000B16//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000B18//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000B1A//_bnr_edge_low */ - 0x0F120201, /*70000B1C//_bnr_repl_force */ - 0x0F120204, /*70000B1E//_bnr_iHotThreshLow */ - 0x0F121B04, /*70000B20//_bnr_iColdThreshLow */ - 0x0F120312, /*70000B22//_bnr_DispTH_High */ - 0x0F120003, /*70000B24//_bnr_DISP_Limit_High */ - 0x0F120C03, /*70000B26//_bnr_iDistSigmaMax */ - 0x0F122806, /*70000B28//_bnr_iDiffSigmaHigh */ - 0x0F120060, /*70000B2A//_bnr_iNormalizedSTD_Limit */ - 0x0F121580, /*70000B2C//_bnr_iDirMinThres */ - 0x0F122020, /*70000B2E//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000B30//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000B32//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000B34//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000B36//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000B38//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000B3A//_bnr_iRadialTune */ - 0x0F12145A, /*70000B3C//_bnr_iRadialLimit */ - 0x0F121010, /*70000B3E//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000B40//_ee_iFSVarThHigh */ - 0x0F120E00, /*70000B42//_ee_iFSThHigh */ - 0x0F125A0F, /*70000B44//_ee_iFSVarCountTh */ - 0x0F120504, /*70000B46//_ee_iRadialPower */ - 0x0F121802, /*70000B48//_ee_iROADThres */ - 0x0F120000, /*70000B4A//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000B4C//_ee_iROADNeiThres */ - 0x0F123828, /*70000B4E//_ee_iSmoothEdgeThres */ - 0x0F120428, /*70000B50//_ee_iWSharpen */ - 0x0F120101, /*70000B52//_ee_iWShThresh */ - 0x0F128000, /*70000B54//_ee_iEmbossCentAdd */ - 0x0F120A04, /*70000B56//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000B58//_dmsc_iDesatThresh */ - 0x0F120540, /*70000B5A//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000B5C//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000B5E//_dmsc_iMonochrom */ - 0x0F120000, /*70000B60//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000B62//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000B64//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000B66//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000B68//_postdmsc_iWideMult */ - 0x0F120607, /*70000B6A//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000B6C//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000B6E//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000B70//_yuvemix_mPosSlopes_3 */ - 0x0F120207, /*70000B72//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000B74//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000B76//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000B78//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000B7A//_yuviirnr_iVertLength_UV */ - 0x0F122404, /*70000B7C//_yuviirnr_iDiffThreshH_Y */ - 0x0F120221, /*70000B7E//_yuviirnr_iDiffThreshH_UV */ - 0x0F121202, /*70000B80//_yuviirnr_iMaxThreshH_Y */ - 0x0F120613, /*70000B82//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000B84//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000B86//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000B88//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000B8A//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000B8C//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000B8E//_bnr_iClustMulT_H */ - 0x0F120101, /*70000B90//_bnr_iClustThresh_H */ - 0x0F12121B, /*70000B92//_bnr_iDenThreshLow */ - 0x0F126024, /*70000B94//_ee_iLowSharpPower */ - 0x0F120C0C, /*70000B96//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000B98//_ee_iLowSharpClamp */ - 0x0F120808, /*70000B9A//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000B9C//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000B9E//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000BA0//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000BA2//_bnr_iDenThreshHigh_Bin */ - 0x0F120460, /*70000BA4//_ee_iHighSharpPower_Bin */ - 0x0F12FF04, /*70000BA6//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000BA8//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000BAA//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000BAC//_bnr_nClustLevel_C */ - 0x0F120000, /*70000BAE//_BRIGHTNESS AFIT 3 */ - 0x0F120000, /*70000BB0//_CONTRAST */ - 0x0F120000, /*70000BB2//_SATURATION */ - 0x0F120000, /*70000BB4//_SHARP_BLUR */ - 0x0F120000, /*70000BB6//_GLAMOUR */ - 0x0F1200C0, /*70000BB8//_bnr_edge_high */ - 0x0F120064, /*70000BBA//_postdmsc_iLowBright */ - 0x0F120384, /*70000BBC//_postdmsc_iHighBright */ - 0x0F120032, /*70000BBE//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000BC0//_postdmsc_iHighSat */ - 0x0F120070, /*70000BC2//_postdmsc_iTune */ - 0x0F120040, /*70000BC4//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000BC6//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000BC8//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000BCA//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000BCC//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000BCE//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000BD0//_bnr_edge_low */ - 0x0F120201, /*70000BD2//_bnr_repl_force */ - 0x0F120204, /*70000BD4//_bnr_iHotThreshLow */ - 0x0F121504, /*70000BD6//_bnr_iColdThreshLow */ - 0x0F12030F, /*70000BD8//_bnr_DispTH_High */ - 0x0F120003, /*70000BDA//_bnr_DISP_Limit_High */ - 0x0F120902, /*70000BDC//_bnr_iDistSigmaMax */ - 0x0F122004, /*70000BDE//_bnr_iDiffSigmaHigh */ - 0x0F120050, /*70000BE0//_bnr_iNormalizedSTD_Limit */ - 0x0F121140, /*70000BE2//_bnr_iDirMinThres */ - 0x0F12201C, /*70000BE4//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000BE6//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000BE8//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000BEA//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000BEC//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000BEE//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000BF0//_bnr_iRadialTune */ - 0x0F12145A, /*70000BF2//_bnr_iRadialLimit */ - 0x0F121010, /*70000BF4//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000BF6//_ee_iFSVarThHigh */ - 0x0F121000, /*70000BF8//_ee_iFSThHigh */ - 0x0F125A0F, /*70000BFA//_ee_iFSVarCountTh */ - 0x0F120503, /*70000BFC//_ee_iRadialPower */ - 0x0F121802, /*70000BFE//_ee_iROADThres */ - 0x0F120000, /*70000C00//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000C02//_ee_iROADNeiThres */ - 0x0F123C28, /*70000C04//_ee_iSmoothEdgeThres */ - 0x0F12042C, /*70000C06//_ee_iWSharpen */ - 0x0F120101, /*70000C08//_ee_iWShThresh */ - 0x0F12FF00, /*70000C0A//_ee_iEmbossCentAdd */ - 0x0F120904, /*70000C0C//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000C0E//_dmsc_iDesatThresh */ - 0x0F120540, /*70000C10//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000C12//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000C14//_dmsc_iMonochrom */ - 0x0F120000, /*70000C16//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000C18//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000C1A//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000C1C//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000C1E//_postdmsc_iWideMult */ - 0x0F120607, /*70000C20//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000C22//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000C24//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000C26//_yuvemix_mPosSlopes_3 */ - 0x0F120206, /*70000C28//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000C2A//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000C2C//_yuviirnr_iHighUVNorm */ - 0x0F120305, /*70000C2E//_yuviirnr_iUVNormShift */ - 0x0F120406, /*70000C30//_yuviirnr_iVertLength_UV */ - 0x0F122804, /*70000C32//_yuviirnr_iDiffThreshH_Y */ - 0x0F120228, /*70000C34//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*70000C36//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*70000C38//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000C3A//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000C3C//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000C3E//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000C40//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000C42//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000C44//_bnr_iClustMulT_H */ - 0x0F120101, /*70000C46//_bnr_iClustThresh_H */ - 0x0F120F15, /*70000C48//_bnr_iDenThreshLow */ - 0x0F126024, /*70000C4A//_ee_iLowSharpPower */ - 0x0F120A0A, /*70000C4C//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000C4E//_ee_iLowSharpClamp */ - 0x0F120808, /*70000C50//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000C52//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000C54//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000C56//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000C58//_bnr_iDenThreshHigh_Bin */ - 0x0F120260, /*70000C5A//_ee_iHighSharpPower_Bin */ - 0x0F12FF02, /*70000C5C//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000C5E//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000C60//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000C62//_bnr_nClustLevel_C */ - 0x0F120000, /*70000C64//_BRIGHTNESS AFIT 4 */ - 0x0F120000, /*70000C66//_CONTRAST */ - 0x0F120000, /*70000C68//_SATURATION */ - 0x0F120000, /*70000C6A//_SHARP_BLUR */ - 0x0F120000, /*70000C6C//_GLAMOUR */ - 0x0F1200C0, /*70000C6E//_bnr_edge_high */ - 0x0F120064, /*70000C70//_postdmsc_iLowBright */ - 0x0F120384, /*70000C72//_postdmsc_iHighBright */ - 0x0F120032, /*70000C74//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000C76//_postdmsc_iHighSat */ - 0x0F120070, /*70000C78//_postdmsc_iTune */ - 0x0F120040, /*70000C7A//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000C7C//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000C7E//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000C80//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000C82//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000C84//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000C86//_bnr_edge_low */ - 0x0F120201, /*70000C88//_bnr_repl_force */ - 0x0F120204, /*70000C8A//_bnr_iHotThreshLow */ - 0x0F120F04, /*70000C8C//_bnr_iColdThreshLow */ - 0x0F12030C, /*70000C8E//_bnr_DispTH_High */ - 0x0F120003, /*70000C90//_bnr_DISP_Limit_High */ - 0x0F120602, /*70000C92//_bnr_iDistSigmaMax */ - 0x0F121803, /*70000C94//_bnr_iDiffSigmaHigh */ - 0x0F120040, /*70000C96//_bnr_iNormalizedSTD_Limit */ - 0x0F120E20, /*70000C98//_bnr_iDirMinThres */ - 0x0F122018, /*70000C9A//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000C9C//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000C9E//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000CA0//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000CA2//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000CA4//_bnr_AddNoisePower1 */ - 0x0F120200, /*70000CA6//_bnr_iRadialTune */ - 0x0F12145A, /*70000CA8//_bnr_iRadialLimit */ - 0x0F121010, /*70000CAA//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000CAC//_ee_iFSVarThHigh */ - 0x0F121200, /*70000CAE//_ee_iFSThHigh */ - 0x0F125A0F, /*70000CB0//_ee_iFSVarCountTh */ - 0x0F120502, /*70000CB2//_ee_iRadialPower */ - 0x0F121802, /*70000CB4//_ee_iROADThres */ - 0x0F120000, /*70000CB6//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000CB8//_ee_iROADNeiThres */ - 0x0F124028, /*70000CBA//_ee_iSmoothEdgeThres */ - 0x0F120430, /*70000CBC//_ee_iWSharpen */ - 0x0F120101, /*70000CBE//_ee_iWShThresh */ - 0x0F12FF00, /*70000CC0//_ee_iEmbossCentAdd */ - 0x0F120804, /*70000CC2//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000CC4//_dmsc_iDesatThresh */ - 0x0F120540, /*70000CC6//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000CC8//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000CCA//_dmsc_iMonochrom */ - 0x0F120000, /*70000CCC//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000CCE//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000CD0//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000CD2//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000CD4//_postdmsc_iWideMult */ - 0x0F120607, /*70000CD6//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000CD8//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000CDA//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000CDC//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*70000CDE//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000CE0//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000CE2//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000CE4//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000CE6//_yuviirnr_iVertLength_UV */ - 0x0F122C04, /*70000CE8//_yuviirnr_iDiffThreshH_Y */ - 0x0F12022C, /*70000CEA//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*70000CEC//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*70000CEE//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000CF0//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000CF2//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000CF4//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000CF6//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000CF8//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000CFA//_bnr_iClustMulT_H */ - 0x0F120101, /*70000CFC//_bnr_iClustThresh_H */ - 0x0F120C0F, /*70000CFE//_bnr_iDenThreshLow */ - 0x0F126024, /*70000D00//_ee_iLowSharpPower */ - 0x0F120808, /*70000D02//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000D04//_ee_iLowSharpClamp */ - 0x0F120808, /*70000D06//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000D08//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000D0A//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000D0C//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000D0E//_bnr_iDenThreshHigh_Bin */ - 0x0F120060, /*70000D10//_ee_iHighSharpPower_Bin */ - 0x0F12FF00, /*70000D12//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000D14//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000D16//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000D18//_bnr_nClustLevel_C */ - - 0x0F1223CE, /*70000D1A//[0]CAFITB_bnr_bypass */ - 0x0F12FDC8, /*70000D1C//[0]CAFITB_bnr_bSlopenessTune */ - 0x0F12112E, /*70000D1E//[0]CAFITB_ee_bReduceNegMedSh */ - 0x0F1293A5, /*70000D20//[0]CAFITB_dmsc_bDoDesat */ - 0x0F12FE67, /*70000D22//[0]CAFITB_postdmsc_bSat */ - 0x0F120000, /*70000D24//[0]CAFITB_yuviirnr_bWideY */ - -/*======================================================= -// 06.Clock Setting -//=======================================================*/ -/*Input Clock (Mclk)*/ - 0x002A01F8, - 0x0F125DC0, /*REG_TC_IPRM_InClockLSBs */ - 0x002A0212, - 0x0F120000, /*REG_TC_IPRM_UseNPviClocks */ - 0x0F120002, /*REG_TC_IPRM_UseNMipiClocks */ - 0x0F120002, /*REG_TC_IPRM_NumberOfMipiLanes */ - -/*System Clock & Output clock (Pclk)*/ - - 0x002A021A, - 0x0F123A98, /*REG_TC_IPRM_OpClk4KHz_0 */ - 0x0F12278D, /*4F1A //REG_TC_IPRM_MinOutRate4KHz_0 */ - 0x0F12278D, /*4F1A //REG_TC_IPRM_MaxOutRate4KHz_0 */ - - 0x0F124F1A, /*REG_TC_IPRM_OpClk4KHz_11 */ - 0x0F12278D, /*4F1A //REG_TC_IPRM_MinOutRate4KHz_1 */ - 0x0F12278D, /*4F1A //REG_TC_IPRM_MaxOutRate4KHz_1 */ - - 0x002A022C, - 0x0F120001, /*REG_TC_IPRM_InitParamsUpdated */ - -/*============================================================= -// 18.JPEG Thumnail Setting -//=============================================================*/ - - 0x002A0478, - 0x0F12005F, /*REG_TC_BRC_usPrevQuality */ - 0x0F12005F, /*REG_TC_BRC_usCaptureQuality */ - -/*JPEG Thumnail*/ - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight */ - 0x0F120005, /*REG_TC_THUMB_Thumb_Format */ - - 0x002A17DC, - 0x0F120054, /*jpeg_ManualMBCV */ - 0x002A1AE4, - 0x0F12001C, /*senHal_bExtraAddLine */ - 0x002A0284, - 0x0F120001, /*REG_TC_GP_bBypassScalerJpg */ - 0x002A028A, - 0x0F120000, /*REG_TC_GP_bUse1FrameCaptureMode */ - - 0x002A1CC2, /*DRx_uDRxWeight for AutoCont function */ - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x002A147C, /*bp_uMaxBrightnessFactor*/ - 0x0F120170, - 0x002A1482, /*bp_uMinBrightnessFactor */ - 0x0F1201E0, - -/*======================================================= -// 07.Input Size Setting -//======================================================*/ -/*Input Size*/ - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs */ - 0x0F12000C, /*REG_TC_GP_PrevInputHeightOfs */ - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs */ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - -/*=========================================================== -// 08.Preview & Capture Configration Setting -//=======================================================*/ -/*Preview config[0] 640 480 10~30fps*/ - 0x002A02A6, - 0x0F120280, /*REG_0TC_PCFG_usWidth */ - 0x0F1201E0, /*REG_0TC_PCFG_usHeight */ - 0x0F120005, /*REG_0TC_PCFG_Format */ - 0x0F12278D, /*4F1A //REG_0TC_PCFG_usMaxOut4KHzRate */ - 0x0F12278D, /*4F1A //REG_0TC_PCFG_usMinOut4KHzRate */ - 0x0F120100, /*REG_0TC_PCFG_OutClkPerPix88 */ - 0x0F120300, /*REG_0TC_PCFG_uBpp88 */ - 0x0F120012, /*REG_0TC_PCFG_PVIMask */ - 0x0F120000, /*REG_0TC_PCFG_OIFMask */ - 0x0F1201E0, /*REG_0TC_PCFG_usJpegPacketSize */ - 0x0F120000, /*REG_0TC_PCFG_usJpegTotalPackets */ - 0x0F120000, /*REG_0TC_PCFG_uClockInd */ - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F1203E8, /*029A //REG_0TC_PCFG_usMaxFrTimeMsecMult10 */ - 0x0F12014A, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 */ - 0x002A02D0, - 0x0F120000, /*REG_0TC_PCFG_uPrevMirror 0711 0000->000A */ - 0x0F120000, /*REG_0TC_PCFG_uCaptureMirror 0711 0000->000A */ - -/*Capture Config[0] 2560 1920 7.5~15fps*/ - 0x002A0396, - 0x0F120000, /*REG_0TC_CCFG_uCaptureMode */ - 0x0F120A00, /*REG_0TC_CCFG_usWidth */ - 0x0F120780, /*REG_0TC_CCFG_usHeight */ - 0x0F120009, /*REG_0TC_CCFG_Format */ - 0x0F12278D, /*4F1A //REG_0TC_CCFG_usMaxOut4KHzRate */ - 0x0F12278D, /*4F1A //REG_0TC_CCFG_usMinOut4KHzRate */ - 0x0F120100, /*REG_0TC_CCFG_OutClkPerPix88 */ - 0x0F120300, /*REG_0TC_CCFG_uBpp88 */ - 0x0F120012, /*REG_0TC_CCFG_PVIMask */ - 0x0F120040, /*REG_0TC_CCFG_OIFMask */ - 0x0F120810, /*REG_0TC_CCFG_usJpegPacketSize */ - 0x0F120000, /*REG_0TC_CCFG_usJpegTotalPackets */ - 0x0F120001, /*REG_0TC_CCFG_uClockInd */ - 0x0F120000, /*REG_0TC_CCFG_usFrTimeType */ - 0x0F120002, /*REG_0TC_CCFG_FrRateQualityType */ - 0x0F120535, /*REG_0TC_CCFG_usMaxFrTimeMsecMult10 */ - 0x0F12029A, /*REG_0TC_CCFG_usMinFrTimeMsecMult10 */ - -/* Delay 100ms*/ - -/*=========================================================== -// 19.Select Cofigration Display -//===========================================================*/ - /*PREVIEW*/ - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - 0x002A023E, - 0x0F120001, /*REG_TC_GP_EnablePreview */ - 0x0F120001, /*REG_TC_GP_EnablePreviewChanged */ - - 0x00287000, - 0x002A0484, - 0x0F120002, /* capture flash on */ - - 0x002A183A, - 0x0F120001, /* one frame AE */ - - 0x002A17F6, - 0x0F12023C, /*210, 258 // AWB R point */ - 0x0F12020C, /*288, 228 ->258 -> 208 // AWB B point */ - - 0x002A1840, - 0x0F120001, /* Fls AE tune start */ - - 0x0F120100, /* fls_afl_FlsAFIn Rin */ - 0x0F120120, - 0x0F120180, - 0x0F120200, - 0x0F120400, - 0x0F120800, - 0x0F120A00, - 0x0F121000, - - 0x0F120100, /* fls_afl_FlsAFOut Rout */ - 0x0F1200A0, - 0x0F120090, - 0x0F120080, - 0x0F120070, - 0x0F120045, - 0x0F120030, - 0x0F120010, - - 0x002A1884, - 0x0F120100, /* fls_afl_FlsNBOut flash NB default */ - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x0F120100, - 0x0F120100, - - 0x002A1826, - - 0x0F120100, /* fls_afl_FlashWP_Weight flash NB default */ - 0x0F1200C0, - 0x0F120080, - 0x0F12000A, - 0x0F120000, - - 0x0F120030, /* fls_afl_FlashWP_Weight flash NB default */ - 0x0F120040, - 0x0F120048, - 0x0F120050, - 0x0F120060, - - 0x002A4784, - 0x0F1200A0, /*TNP_Regs_FlsWeightRIn weight tune start in */ - 0x0F1200C0, - 0x0F1200D0, - 0x0F120100, - 0x0F120200, - 0x0F120300, - - 0x0F120088, /* TNP_Regs_FlsWeightROut weight tune start out */ - 0x0F1200B0, - 0x0F1200C0, - 0x0F120100, - 0x0F120200, - 0x0F120300, - - 0x002A479C, - - 0x0F120120, /*Fls BRIn */ - 0x0F120150, - 0x0F120200, - - 0x0F12003C, /* Fls BROut */ - 0x0F12003B, - 0x0F120026, /*brightness // 23 //26 //30 */ -}; - -static const u32 s5k4ecgx_DTP_init_EVT1[] = { -/*Delay 500ms*/ - 0xFCFCD000, - 0x00287000, - 0x002A0944, - 0x0F12FFF0, /*af_uNoise_0_*/ - 0x0F12FFF1, /*afit_uNoiseIndInDoor_1_ */ - 0x0F12FFF2, /*afit_uNoiseIndInDoor_2_ */ - 0x0F12FFF3, /*afit_uNoiseIndInDoor_3_ */ - 0x0F12FFF4, /*afit_uNoiseIndInDoor_4_ */ - 0x002A0938, - 0x0F120000, /*afit_bUseNB_Afit */ - 0x0F12FFF0, /*SARR_uNormBrInDoor_0_ */ - 0x0F12FFF1, /*SARR_uNormBrInDoor_1_ */ - 0x0F12FFF2, /*SARR_uNormBrInDoor_2_ */ - 0x0F12FFF3, /*SARR_uNormBrInDoor_3_ */ - 0x0F12FFF4, /*SARR_uNormBrInDoor_4_ */ - 0x00287000, - 0x002A04A6, - 0x0F120001, - 0x002A04AA, - 0x0F120001, - 0x0028D000, - 0x002A4200, - 0x0F1208A3, /*GAS bypass */ - 0x002A6600, - 0x0F120001, /*CCM bypass */ - 0x002A6700, - 0x0F120001, /*Gamma bypass */ - 0x002A4900, - 0x0F120001, /*AWB bypass */ - -/*Delay 50ms*/ - 0x0028D000, - 0x002A3100, - 0x0F120002, /*Colorbar pattern */ - -}; - -static const u32 s5k4ecgx_DTP_stop_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0944, - 0x0F12004B, /*afit_uNoiser0*/ - 0x0F120092, /*afit_uNoiseIndInDoor_1_ */ - 0x0F120196, /*afit_uNoiseIndInDoor_2_ */ - 0x0F120217, /*afit_uNoiseIndInDoor_3_ */ - 0x0F1202B0, /*afit_uNoiseIndInDoor_4_ */ - - /* Normal Brightness setting */ - 0x002A0938, - 0x0F120000, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x00287000, - 0x002A04A6, - 0x0F120000, - 0x002A04AA, - 0x0F120001, - 0x0028D000, - 0x002A4200, - 0x0F1208A2, /*GAS bypass */ - 0x002A6600, - 0x0F120000, /*CCM bypass */ - 0x002A6700, - 0x0F120000, /*Gamma bypass */ - 0x002A4900, - 0x0F120000, /*AWB bypass */ - 0xFFFE0032, /*p50 */ - 0x0028D000, - 0x002A3100, - 0x0F120000, /*Colorbar pattern */ - -}; - -static const u32 s5k4ecgx_FPS_Auto_EVT1[] = { -/* frame rate 10~30fps*/ - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*usFrTimeType*/ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F1203E8, /*029A/REG_0TC_PCFG_usMaxFrTimeMsecMult10 029Ah:15fps*/ - 0x0F12014A, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps*/ - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ -}; - -static const u32 s5k4ecgx_FPS_5_EVT1[] = { - -}; - -static const u32 s5k4ecgx_FPS_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType*/ - 0x0F120535, /*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //0535h:7.5fps */ - 0x0F120535, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //0535h:7.5fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_FPS_10_EVT1[] = { - -}; - -static const u32 s5k4ecgx_FPS_15_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F12029A, /*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //029Ah:15fps */ - 0x0F12029A, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //029Ah:15fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_FPS_20_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F1201F4, /*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //01F4h:20fps */ - 0x0F1201F4, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //01F4h:20fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ -}; - -static const u32 s5k4ecgx_FPS_24_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02B4, - 0x0F120052, - 0x002A02BE, - 0x0F120000, - 0x0F120001, - 0x0F1201A1, - 0x0F1201A1, - 0x002A02D0, - 0x0F120000, - 0x0F120000, - 0x002A0266, - 0x0F120000, - 0x002A026A, - 0x0F120001, - 0x002A024E, - 0x0F120001, - 0x002A0268, - 0x0F120001, -}; - -static const u32 s5k4ecgx_FPS_25_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F120190, /*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //014Ah:30fps */ - 0x0F120190, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ -}; - - -static const u32 s5k4ecgx_FPS_30_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F12014A, /*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //014Ah:30fps */ - 0x0F12014A, /*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_FPS_60_EVT1[] = { - -}; - -static const u32 s5k4ecgx_FPS_120_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Effect_Normal_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A023C, - 0x0F120000, -}; - -static const u32 s5k4ecgx_Effect_Solarization_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A023C, - 0x0F120002, -}; - -static const u32 s5k4ecgx_Effect_Negative_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A023C, - 0x0F120003, -}; - -static const u32 s5k4ecgx_Effect_Sepia_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A023C, - 0x0F120004, -}; - -static const u32 s5k4ecgx_Effect_Black_White_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A023C, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Auto_EVT1[] = { - 0xFCFCD000, - 0x00287000, -}; - -static const u32 s5k4ecgx_WB_Sunny_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04BA, - 0x0F1205C0, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F120550, - - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Cloudy_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04BA, - 0x0F1206D8, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F1204B0, - - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Tungsten_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04BA, - 0x0F1203B0, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F1209B0, - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Fluorescent_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04BA, - 0x0F1205E0, - - 0x002A04BE, - 0x0F120440, - - 0x002A04C2, - 0x0F120998, - - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Auto_ISO_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002a04E6, - 0x0f12075F, -}; - -static const u32 s5k4ecgx_WB_Sunny_ISO_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0f120757, - 0x002A04BA, - 0x0F1205C0, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F120580, - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Cloudy_ISO_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0f120757, - 0x002A04BA, - 0x0F1206E0, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F1204B0, - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Tungsten_ISO_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0f120757, - 0x002A04BA, - 0x0F1203B0, - - 0x002A04BE, - 0x0F1203D0, - - 0x002A04C2, - 0x0F1209F0, - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WB_Fluorescent_ISO_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0f120757, - 0x002A04BA, - 0x0F120600, - - 0x002A04BE, - 0x0F120440, - - 0x002A04C2, - 0x0F1209E0, - 0x002A04C6, - 0x0F120001, -}; - -static const u32 s5k4ecgx_WDR_on_EVT1[] = { - -}; - -static const u32 s5k4ecgx_WDR_off_EVT1[] = { - -}; - -static const u32 s5k4ecgx_ISO_Auto_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, /*afit_bUseNB_Afit */ - 0x0F120000, - 0x0F120014, /*SARR_uNormBrInDoor_0_*/ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F12003C, - 0x002A0F2A, /*AFC_Default60Hz */ - 0x0F120000, /*00:50Hz 01:60Hz */ - 0x002A04D0, - 0x0F120000, /*REG_SF_USER_IsoType */ - 0x0F120000, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120200, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_50_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType*/ - 0x0F120100, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_100_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F12018A, /*REG_SF_USER_IsoVal/1BA/1CA:16.9msec/1AA: 17.8msec */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_200_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120114, /*SARR_uNormBrInDoor_0_ */ - 0x0F1204A2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120584, /*SARR_uNormBrInDoor_2_ */ - 0x0F1208D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120300, /*REG_SF_IsoVal/36A/370:8.9msec/360:8.8msec/400:7.5msec*/ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ - -}; - -static const u32 s5k4ecgx_ISO_400_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120214, /*SARR_uNormBrInDoor_0_ */ - 0x0F120BD2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120C84, /*SARR_uNormBrInDoor_2_ */ - 0x0F1210D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120764, /*REGSFUSER_IsoVal/6F4*/ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_Auto_MWB_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, /*afit_bUseNB_Afit */ - 0x0F120000, - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F12003C, - 0x002A0F2A, /*AFC_Default60Hz */ - 0x0F120000, /*00:50Hz 01:60Hz */ - 0x002A04E6, /*REG_TC_DBG_AutoAlgEnBits */ - 0x0F120777, - 0x002A04D0, - 0x0F120000, /*REG_SF_USER_IsoType */ - 0x0F120000, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120200, /*lt_bUseSecISODgain */ - -}; - -static const u32 s5k4ecgx_ISO_50_MWB_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit*/ - 0x0F120014, /*SARR_uNormBrInDoor_0_*/ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_*/ - 0x0F120384, /*SARR_uNormBrInDoor_2_*/ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_*/ - 0x0F121388, /*SARR_uNormBrInDoor_4_*/ - - 0x002A04E6, - 0x0F120757, /*REG_TC_DBG_AutoAlgEnBits */ - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120100, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_100_MWB_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1200D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120384, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04E6, - 0x0F120757, /*REG_TC_DBG_AutoAlgEnBits */ - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F12018A, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_200_MWB_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1203A2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120484, /*SARR_uNormBrInDoor_2_ */ - 0x0F1207D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04E6, - 0x0F120757, /*REG_TC_DBG_AutoAlgEnBits */ - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120300, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_ISO_400_MWB_on_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - 0x0F120014, /*SARR_uNormBrInDoor_0_ */ - 0x0F1208D2, /*SARR_uNormBrInDoor_1_ */ - 0x0F120C84, /*SARR_uNormBrInDoor_2_ */ - 0x0F1210D0, /*SARR_uNormBrInDoor_3_ */ - 0x0F121388, /*SARR_uNormBrInDoor_4_ */ - 0x002A1484, - 0x0F120044, - 0x002A04E6, - 0x0F120757, /*REG_TC_DBG_AutoAlgEnBits */ - 0x002A04D6, - 0x0F120000, /*REG_SF_USER_FlickerQuant */ - 0x0F120001, /*REG_SF_USER_FlickerQuantChanged */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120764, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120100, /*lt_bUseSecISODgain */ -}; - -static const u32 s5k4ecgx_Metering_Matrix_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1492, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - - 0x002A0268, /*REG_TC_GP_PrevConfigChanged */ - 0x0F120001, -}; - -static const u32 s5k4ecgx_Metering_Center_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1492, - 0x0F120100, - 0x0F120101, - 0x0F120101, - 0x0F120001, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - - 0x002A0268, /*REG_TC_GP_PrevConfigChanged */ - 0x0F120001, -}; - -static const u32 s5k4ecgx_Metering_Spot_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1492, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120101, - 0x0F120101, - 0x0F120000, - 0x0F120000, - 0x0F12010F, - 0x0F120F01, - 0x0F120000, - 0x0F120000, - 0x0F12010F, - 0x0F120F01, - 0x0F120000, - 0x0F120000, - 0x0F120101, - 0x0F120101, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - - 0x002A0268, /*REG_TC_GP_PrevConfigChanged */ - 0x0F120001, -}; - -static const u32 s5k4ecgx_EV_Minus_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120018, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Minus_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F12001E, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Minus_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120025, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Minus_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120030, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Default_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F12003C, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Plus_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F12004E, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Plus_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120060, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Plus_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120070, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_EV_Plus_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120080, /*TVAR_ae_BrAve */ -}; - -static const u32 s5k4ecgx_Contrast_Minus_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F12FF81, -}; - -static const u32 s5k4ecgx_Contrast_Minus_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F12FFA0, -}; - -static const u32 s5k4ecgx_Contrast_Minus_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F12FFC0, -}; - -static const u32 s5k4ecgx_Contrast_Minus_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F12FFE0, -}; - -static const u32 s5k4ecgx_Contrast_Default_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F120000, -}; - -static const u32 s5k4ecgx_Contrast_Plus_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F120020, -}; - -static const u32 s5k4ecgx_Contrast_Plus_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F120040, -}; - -static const u32 s5k4ecgx_Contrast_Plus_3_EVT1[] = {/*Setting Unavailable*/ - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F120060, -}; - -static const u32 s5k4ecgx_Contrast_Plus_4_EVT1[] = {/*Setting Unavailable*/ - 0xFCFCD000, - 0x00287000, - 0x002A0232, - 0x0F12007F, -}; - -static const u32 s5k4ecgx_Auto_Contrast_ON_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A098E, - 0x0F12FFB0, - - 0x002A0A44, - 0x0F12FFB0, - - 0x002A0AFA, - 0x0F12FFB0, - - 0x002A0BB0, - 0x0F12FFB0, - - 0x002A0C66, - 0x0F12FFB0, -}; - -static const u32 s5k4ecgx_Auto_Contrast_OFF_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A098E, - 0x0F120000, - - 0x002A0A44, - 0x0F120000, - - 0x002A0AFA, - 0x0F120000, - - 0x002A0BB0, - 0x0F120000, - - 0x002A0C66, - 0x0F120000, -}; - -static const u32 s5k4ecgx_Sharpness_Minus_3_EVT1[] = {/*Setting Unavailable*/ - 0x00287000, - 0x002A0A28, - 0x0F120000, - 0x002A0ADE, - 0x0F120000, - 0x002A0B94, - 0x0F120000, - 0x002A0C4A, - 0x0F120000, - 0x002A0D00, - 0x0F120000, -}; - -static const u32 s5k4ecgx_Sharpness_Minus_2_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F122010, - 0x002A0ADE, - 0x0F122010, - 0x002A0B94, - 0x0F122010, - 0x002A0C4A, - 0x0F122010, - 0x002A0D00, - 0x0F122010, -}; - -static const u32 s5k4ecgx_Sharpness_Minus_1_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F124020, - 0x002A0ADE, - 0x0F124020, - 0x002A0B94, - 0x0F124020, - 0x002A0C4A, - 0x0F124020, - 0x002A0D00, - 0x0F124020, -}; - -static const u32 s5k4ecgx_Sharpness_Default_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F126024, - 0x002A0ADE, - 0x0F126024, - 0x002A0B94, - 0x0F126024, - 0x002A0C4A, - 0x0F126024, - 0x002A0D00, - 0x0F126024, -}; - -static const u32 s5k4ecgx_Sharpness_Plus_1_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F128040, - 0x002A0ADE, - 0x0F128040, - 0x002A0B94, - 0x0F128040, - 0x002A0C4A, - 0x0F128040, - 0x002A0D00, - 0x0F128040, -}; - -static const u32 s5k4ecgx_Sharpness_Plus_2_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F12A060, - 0x002A0ADE, - 0x0F12A060, - 0x002A0B94, - 0x0F12A060, - 0x002A0C4A, - 0x0F12A060, - 0x002A0D00, - 0x0F12A060, -}; - -static const u32 s5k4ecgx_Sharpness_Plus_3_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F12C080, - 0x002A0ADE, - 0x0F12C080, - 0x002A0B94, - 0x0F12C080, - 0x002A0C4A, - 0x0F12C080, - 0x002A0D00, - 0x0F12C080, -}; - -static const u32 s5k4ecgx_Saturation_Minus_2_EVT1[] = { - 0x00287000, - 0x002A0234, - 0x0F12FF81, -}; - -static const u32 s5k4ecgx_Saturation_Minus_1_EVT1[] = { - 0x00287000, - 0x002A0234, - 0x0F12FFC0, -}; - -static const u32 s5k4ecgx_Saturation_Default_EVT1[] = { - 0x00287000, - 0x002A0234, - 0x0F120000, -}; - -static const u32 s5k4ecgx_Saturation_Plus_1_EVT1[] = { - 0x00287000, - 0x002A0234, - 0x0F120040, -}; - -static const u32 s5k4ecgx_Saturation_Plus_2_EVT1[] = { - 0x00287000, - 0x002A0234, - 0x0F12007F, -}; - -static const u32 s5k4ecgx_Jpeg_Quality_High_EVT1[] = { - 0x00287000, - 0x002A0478, - 0x0F12005F, - 0x0F12005F, -}; - -static const u32 s5k4ecgx_Jpeg_Quality_Normal_EVT1[] = { - 0x00287000, - 0x002A0478, - 0x0F12005A, - 0x0F12005A, -}; - -static const u32 s5k4ecgx_Jpeg_Quality_Low_EVT1[] = { - 0x00287000, - 0x002A0478, - 0x0F120054, - 0x0F120054, -}; - -static const u32 s5k4ecgx_Scene_Default_EVT1[] = { -/*scene Backlight landscape*/ - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F12003C, - 0x002A1492, - 0x0F120100, - 0x0F120101, - 0x0F120101, - 0x0F120001, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - -/* Sharpness 0*/ - 0x002A0A28, - 0x0F126024, /*_ee_iLowSharpPower*/ - 0x002A0ADE, - 0x0F126024, /*_ee_iLowSharpPower*/ - 0x002A0B94, - 0x0F126024, /*_ee_iLowSharpPower*/ - 0x002A0C4A, - 0x0F126024, /*_ee_iLowSharpPower*/ - 0x002A0D00, - 0x0F126024, /*_ee_iLowSharpPower*/ - -/* Saturation 0*/ - 0x002A0234, - 0x0F120000, /*REG_TC_UserSaturation */ - 0x002A06B8, - 0x0F12452C, - 0x0F120005, /*lt_uMaxLei */ - - 0x002A0A1E, - 0x0F120350,/*_ccm_oscar_iSaturation [7:0] AFIT8_RGB2YUV_iYOffset*/ - - 0x002A0638, - 0x0F120001, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_ */ - 0x0F120A3C, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_1_ */ - 0x0F120D05, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_2_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_3_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_4_ */ - 0x0F126810, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_5_ */ - 0x0F128214, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_6_ */ - 0x0F12C350, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_7_ */ - 0x0F12C350, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_8_ */ - 0x0F12C350, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_9_ */ - - 0x002A02C2, - 0x0F12029A,/*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //029Ah:15fps */ - 0x0F12014A,/*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps */ - 0x002A03B4, - 0x0F120535,/*REG_0TC_CCFG_usMaxFrTimeMsecMult10 //0535h:7.5fps */ - 0x0F12029A,/*REG_0TC_CCFG_usMinFrTimeMsecMult10 //029Ah:15fps */ - - 0x002A0938, - 0x0F120000, /*afit_bUseNB_Afit */ - - 0x002A04E6, - 0x0F12077F, /*REG_TC_DBG_AutoAlgEnBits */ - - 0x002A04D0, - 0x0F120000, /*REG_SF_USER_IsoType */ - 0x0F120000, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - - 0x002A06C2, - 0x0F120200, /*lt_bUseSecISODgain */ - - 0x002A1648, - 0x0F129002, /*af_search_usSingleAfFlags */ - - 0x002A15E8, - 0x0F120015, /*af_pos_usTableLastInd */ - 0x0F120027, /*af_pos_usTable_0_ */ - 0x0F120030, /*af_pos_usTable_1_ */ - 0x0F120036, /*af_pos_usTable_2_ */ - 0x0F12003C, /*af_pos_usTable_3_ */ - 0x0F120042, /*af_pos_usTable_4_ */ - 0x0F120048, /*af_pos_usTable_5_ */ - 0x0F12004E, /*af_pos_usTable_6_ */ - 0x0F120054, /*af_pos_usTable_7_ */ - 0x0F12005A, /*af_pos_usTable_8_ */ - 0x0F120060, /*af_pos_usTable_9_ */ - 0x0F120066, /*af_pos_usTable_10 */ - 0x0F12006C, /*af_pos_usTable_11_ */ - 0x0F120072, /*af_pos_usTable_12_ */ - 0x0F120078, /*af_pos_usTable_13_ */ - 0x0F12007E, /*af_pos_usTable_14_ */ - 0x0F120084, /*af_pos_usTable_15_ */ - 0x0F12008A, /*af_pos_usTable_16_ */ - 0x0F120090, /*af_pos_usTable_17_ */ - 0x0F120096, /*af_pos_usTable_18_ */ - 0x0F12009C, /*af_pos_usTable_19_ */ - 0x0F1200A2, /*af_pos_usTable_20_ */ - 0x0F1200A8, /*af_pos_usTable_21_ */ - 0x0F1200AE, /*af_pos_usTable_22_ */ - 0x0F1200B4, /*af_pos_usTable_23_ */ - 0x0F1200BA, /*af_pos_usTable_24_ */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - 0x002A023E, - 0x0F120001, /*REG_TC_GP_EnablePreview */ - 0x0F120001, /*REG_TC_GP_EnablePreviewChanged */ - -}; - -static const u32 s5k4ecgx_Scene_Portrait_EVT1[] = { - 0x00287000, - 0x002A0A28, - 0x0F124020, - 0x002A0ADE, - 0x0F124020, - 0x002A0B94, - 0x0F124020, - 0x002A0C4A, - 0x0F124020, - 0x002A0D00, - 0x0F124020, -}; - -static const u32 s5k4ecgx_Scene_Nightshot_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A06B8, - 0x0F12FFFF, /*lt_uMaxLei */ - 0x0F1200FF, /*lt_usMinExp */ - - 0x002A0A1E, - 0x0F1215C0,/*_ccm_oscar_iSaturation [7:0] AFIT8_RGB2YUV_iYOffset*/ - - 0x002A0638, - 0x0F120001, - 0x0F120000,/*ltExpGainExpCurveGainMaxStr_0_ulExpOut0*/ - 0x0F121478, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_1_ */ - 0x0F121A0A, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_2_ */ - 0x0F126810, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_3_ */ - 0x0F126810, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_4_ */ - 0x0F12D020, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_5_ */ - 0x0F120428, - 0x0F120001,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_6_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_7_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_8_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_9_ */ - - 0x002A02C2, - 0x0F1209C4,/*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //09C4h:4fps */ - 0x0F12014A,/*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps */ - 0x002A03B4, - 0x0F121388,/*REG_0TC_CCFG_usMaxFrTimeMsecMult10 //1388h:2fps */ - 0x0F121388,/*REG_0TC_CCFG_usMinFrTimeMsecMult10 //1388h:2fps */ - - 0x002A1648, /*af_search_usSingleAfFlags */ - 0x0F129000, - - 0x002A15E8, - 0x0F120006, /*af_pos_usTableLastInd */ - 0x0F120036, - 0x0F12003A, - 0x0F120040, - 0x0F120048, - 0x0F120050, - 0x0F120058, - 0x0F120060, - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - 0x002A023E, - 0x0F120001, /*REG_TC_GP_EnablePreview */ - 0x0F120001, /*REG_TC_GP_EnablePreviewChanged */ - -}; - -static const u32 s5k4ecgx_Scene_Backlight_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1492, - 0x0F120000, /*ae_WeightTbl_16 */ - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120101, - 0x0F120101, - 0x0F120000, - 0x0F120000, - 0x0F12010F, - 0x0F120F01, - 0x0F120000, - 0x0F120000, - 0x0F12010F, - 0x0F120F01, - 0x0F120000, - 0x0F120000, - 0x0F120101, - 0x0F120101, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - 0x0F120000, - -}; - -static const u32 s5k4ecgx_Scene_Landscape_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1492, - 0x0F120101, /*ae_WeightTbl_16 */ - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - - 0x002A0A28, - 0x0F12E082,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0ADE, - 0x0F12E082,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0B94, - 0x0F12E082,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0C4A, - 0x0F12E082,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0D00, - 0x0F12E082,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - - 0x002A0234, - 0x0F120030, /*REG_TC_UserSaturation */ -}; - -static const u32 s5k4ecgx_Scene_Sports_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0638, - 0x0F120001, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_ */ - 0x0F120A3C, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_1_ */ - 0x0F120D05, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_2_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_3_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_4_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_5_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_6_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_7_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_8_ */ - 0x0F123408, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_9_ */ - - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120200, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120150, /*lt_bUseSecISODgain */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - 0x002A023E, - 0x0F120001, /*REG_TC_GP_EnablePreview */ - 0x0F120001, /*REG_TC_GP_EnablePreviewChanged */ - -}; - -static const u32 s5k4ecgx_Scene_Party_Indoor_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F120340, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120180, /*lt_bUseSecISODgain */ - - 0x002A0234, - 0x0F120030, /*REG_TC_UserSaturation */ -}; - -static const u32 s5k4ecgx_Scene_Beach_Snow_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1484, - 0x0F120045, /*TVAR_ae_BrAve */ - - 0x002A0938, - 0x0F120001, /*afit_bUseNB_Afit */ - - 0x002A04D0, - 0x0F120001, /*REG_SF_USER_IsoType */ - 0x0F1200D0, /*REG_SF_USER_IsoVal */ - 0x0F120001, /*REG_SF_USER_IsoChanged */ - 0x002A06C2, - 0x0F120150, /*lt_bUseSecISODgain */ - - 0x002A0234, - 0x0F120030, /*REG_TC_UserSaturation */ -}; - -static const u32 s5k4ecgx_Scene_Sunset_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0F120777, /*REG_TC_DBG_AutoAlgEnBits //AWB Off */ - - 0x002A04BA, - 0x0F1205F0, /*REG_SF_USER_Rgain */ - 0x002A04BE, - 0x0F120400, /*REG_SF_USER_Ggain */ - 0x002A04C2, - 0x0F120588, /*REG_SF_USER_Bgain */ - - 0x002A04C6, - 0x0F120001, /*REG_SF_USER_RGBGainChanged */ -}; - -static const u32 s5k4ecgx_Scene_Duskdawn_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0F120777, /*REG_TC_DBG_AutoAlgEnBits //AWB Off */ - - 0x002A04BA, - 0x0F1205A5, /*REG_SF_USER_Rgain */ - 0x002A04BE, - 0x0F120400, /*REG_SF_USER_Ggain */ - 0x002A04C2, - 0x0F1208A8, /*REG_SF_USER_Bgain */ - - 0x002A04C6, - 0x0F120001, /*REG_SF_USER_RGBGainChanged */ -}; - -static const u32 s5k4ecgx_Scene_Fall_Color_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0234, - 0x0F120060, -}; - -static const u32 s5k4ecgx_Scene_Fireworks_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0638, - 0x0F120001, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_ */ - 0x0F121478, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_1_ */ - 0x0F121A0A, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_2_ */ - 0x0F126810, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_3_ */ - 0x0F126810, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_4_ */ - 0x0F12D020, - 0x0F120000,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_5_ */ - 0x0F120428, - 0x0F120001,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_6_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_7_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_8_ */ - 0x0F121A80, - 0x0F120006,/*lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_9_ */ - - 0x002A03B4, - 0x0F122710,/*REG_0TC_CCFG_usMaxFrTimeMsecMult10 //2710h:1fps */ - 0x0F122710,/*REG_0TC_CCFG_usMinFrTimeMsecMult10 //2710h:1fps */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - 0x002A023E, - 0x0F120001, /*REG_TC_GP_EnablePreview */ - 0x0F120001, /*REG_TC_GP_EnablePreviewChanged */ -}; - -static const u32 s5k4ecgx_Scene_Text_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0A28, - 0x0F12A060,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0ADE, - 0x0F12A060,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0B94, - 0x0F12A060,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0C4A, - 0x0F12A060,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ - 0x002A0D00, - 0x0F12A060,/*_ee_iLowSharpPower [7:0] AFIT8_ee_iHighSharpPower*/ -}; - -static const u32 s5k4ecgx_Scene_Candle_Light_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A04E6, - 0x0F120777, /*REG_TC_DBG_AutoAlgEnBits //AWB Off */ - - 0x002A04BA, - 0x0F1205F0, /*REG_SF_USER_Rgain */ - 0x002A04BE, - 0x0F120400, /*REG_SF_USER_Ggain */ - 0x002A04C2, - 0x0F120588, /*REG_SF_USER_Bgain */ - - 0x002A04C6, - 0x0F120001, /*REG_SF_USER_RGBGainChanged */ -}; - - /* AE Lock */ -static const u32 s5k4ecgx_ae_lock_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A2C5E, - 0x0F120000, -}; - - /* AE unLock */ -static const u32 s5k4ecgx_ae_unlock_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A2C5E, - 0x0F120001, -}; - - /* AWB Lock */ -static const u32 s5k4ecgx_awb_lock_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A2C66, - 0x0F120000, -}; - - /* AWB unLock */ -static const u32 s5k4ecgx_awb_unlock_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A2C66, - 0x0F120001, -}; - -static const u32 s5k4ecgx_Night_Mode_Off_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Return_Inf_pos_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A15D6, - 0x0F12D000, -}; - -static const u32 s5k4ecgx_AF_Return_Macro_pos_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A15E8, - 0x0F120018, - 0x0F12002A, - 0x0F120030, - 0x0F120036, - 0x0F12003C, - 0x0F120042, - 0x0F120048, - 0x0F12004E, - 0x0F120054, - 0x0F12005A, - 0x0F120060, - 0x0F120066, - 0x0F12006C, - 0x0F120072, - 0x0F120078, - 0x0F12007E, - 0x0F120084, - 0x0F12008A, - 0x0F120090, - 0x0F120096, - 0x0F12009C, - 0x0F1200A2, - 0x0F1200A8, - 0x0F1200AE, - 0x0F1200B4, - 0x0F1200BA, -}; - -static const u32 s5k4ecgx_AF_Normal_mode_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1648, - 0x0F129002, -}; - -static const u32 s5k4ecgx_AF_Normal_mode_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A028E, - 0x0F120000, -}; - -static const u32 s5k4ecgx_AF_Normal_mode_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A028C, - 0x0F120004, -}; - -static const u32 s5k4ecgx_AF_Normal_mode_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1648, - 0x0F129002, - - 0x002A15E8, - 0x0F120017, /*af_pos_usTableLastInd */ - 0x0F120026, - 0x0F12002C, - 0x0F120032, - 0x0F120038, - 0x0F12003E, - 0x0F120044, - 0x0F12004A, - 0x0F120050, - 0x0F120056, - 0x0F12005C, - 0x0F120062, - 0x0F120068, - 0x0F12006E, - 0x0F120074, - 0x0F12007A, - 0x0F120080, - 0x0F120086, - 0x0F12008C, - 0x0F120092, - 0x0F120098, - 0x0F12009E, - 0x0F1200A4, - 0x0F1200AA, - 0x0F1200B0, -}; - -static const u32 s5k4ecgx_AF_Macro_mode_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A028E, - 0x0F1200D0, -}; - -static const u32 s5k4ecgx_AF_Macro_mode_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A028C, - 0x0F120004, -}; - -static const u32 s5k4ecgx_AF_Macro_mode_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1648, - 0x0F129042, - - 0x002A15E8, - 0x0F120015, /*af_pos_usTableLastInd */ - 0x0F120032, - 0x0F120038, - 0x0F12003E, - 0x0F120044, - 0x0F12004A, - 0x0F120050, - 0x0F120056, - 0x0F12005C, - 0x0F120062, - 0x0F120068, - 0x0F12006E, - 0x0F120074, - 0x0F12007A, - 0x0F120080, - 0x0F120086, - 0x0F12008C, - 0x0F120092, - 0x0F120098, - 0x0F12009E, - 0x0F1200A4, - 0x0F1200AA, - 0x0F1200B0, - - 0x002A15DA, - 0x0F121500,/* 16 start number of table 00 End number of table */ -}; - -static const u32 s5k4ecgx_AF_Low_Light_normal_mode_1_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Low_Light_normal_mode_2_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Low_Light_normal_mode_3_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Low_Light_Macro_mode_1_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Low_Light_Macro_mode_2_EVT1[] = { - -}; - -static const u32 s5k4ecgx_AF_Low_Light_Macro_mode_3_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Single_AF_Start_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A028C, - 0x0F120005, -}; - -static const u32 s5k4ecgx_Single_AF_Off_1_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Single_AF_Off_2_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Single_AF_Off_3_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Face_Detection_On_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0294, - 0x0F120100, - 0x0F1200E3, - 0x0F120200, - 0x0F120238, - 0x0F1201C6, - 0x0F120166, - 0x0F120074, - 0x0F120132, - 0x0F120001, -}; - -static const u32 s5k4ecgx_Face_Detection_Off_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0294, - 0x0F120100, - 0x0F1200E3, - 0x0F120200, - 0x0F120238, - 0x0F1201C6, - 0x0F120166, - 0x0F120074, - 0x0F120132, - 0x0F120001, -}; - -static const u32 s5k4ecgx_Low_Cap_On_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A06B8, - 0x0F12552C, /*lt_uMaxLei */ - 0x0F120006, /*lt_usMinExp */ - - 0x002A0608, - 0x0F120001, /*lt_ExpGain_uSubsamplingmode */ - 0x0F120001, /*lt_ExpGain_uNonSubsampling */ - 0x0F120900, /*lt_ExpGain_ExpCurveGainMaxStr_0__uMaxAnGain */ - -}; - -static const u32 s5k4ecgx_Low_Cap_Off_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A06B8, - 0x0F12452C, /*lt_uMaxLei */ - 0x0F120005, /*lt_usMinExp // 0725 000C->0005 */ - - 0x002A0608, - 0x0F120001, /*lt_ExpGain_uSubsamplingmode */ - 0x0F120001, /*lt_ExpGain_uNonSubsampling */ - 0x0F120800, /*lt_ExpGain_ExpCurveGainMaxStr_0__uMaxAnGain */ - -}; - -static const u32 s5k4ecgx_Night_Mode_On_EVT1[] = { - -}; - -static const u32 s5k4ecgx_Capture_Start_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0242, - 0x0F120001, - 0x002A024E, - 0x0F120001, - 0x002A0244, - 0x0F120001, -}; - -static const u32 s5k4ecgx_Preview_Return_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A0242, - 0x0F120000, /*REG_TC_GP_EnableCapture*/ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync*/ - 0x002A0244, - 0x0F120001, /*REG_TC_GP_EnableCaptureChanged*/ - -}; - - /* Flash Control */ -static const u32 s5k4ecgx_Flash_init_EVT1[] = { -/* Include initial setting*/ -}; - -static const u32 s5k4ecgx_Pre_Flash_On_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A17FC, /* fls_FlashWP_0_Pre_Flash_Start*/ - 0x0F120001, -}; - -static const u32 s5k4ecgx_Pre_Flash_Off_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A1800, /*fls_afl_FlashWP_Weight_0_Pre_Flash_end*/ - 0x0F120001, -}; - -static const u32 s5k4ecgx_Main_Flash_On_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A17E8,/*fls_afl_FlashMode:Flash alg start*/ - 0x0F120001, - 0x002A180C,/*fls_afl_FlashWP_Weight_4:flash br avg*/ - 0x0F120027, -}; - -static const u32 s5k4ecgx_Main_Flash_Off_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A17E8, /*fls_afl_FlashMode Flash alg end*/ - 0x0F120000, -}; - -static const u32 s5k4ecgx_5M_Capture_EVT1[] = { /* 2560 x 1920 */ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120A00, /*REG_0TC_CCFG_usWidth //2560 */ - 0x0F120780, /*REG_0TC_CCFG_usHeight //1920 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ -}; - -static const u32 s5k4ecgx_3M_Capture_EVT1[] = { /*2048 x 1536 */ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120800, /*REG_0TC_CCFG_usWidth //2048 */ - 0x0F120600, /*REG_0TC_CCFG_usHeight //1536 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - -}; - -static const u32 s5k4ecgx_2M_Capture_EVT1[] = { /*1600 x 1200 */ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120640, /*REG_0TC_CCFG_usWidth //1600 */ - 0x0F1204B0, /*REG_0TC_CCFG_usHeight //1200 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ -}; - -static const u32 s5k4ecgx_1M_Capture_EVT1[] = { /* 1280 x 960 */ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120500, /*REG_0TC_CCFG_usWidth //1280 */ - 0x0F1203C0, /*REG_0TC_CCFG_usHeight //960 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ - -}; - - /* 1024 x 768 */ -static const u32 s5k4ecgx_XGA_Capture_EVT1[] = { -/* 0725 add*/ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120400, /*REG_0TC_CCFG_usWidth //1024 */ - 0x0F120300, /*REG_0TC_CCFG_usHeight //768 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ -}; - -static const u32 s5k4ecgx_VGA_Capture_EVT1[] = { /* 640 x 480 */ - 0xFCFCD000, - 0x00287000, - 0x002A0258, - 0x0F120A00, /*REG_TC_GP_CapReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_CapReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_CapInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_CapInputHeightOfs //(1944-1920)/2 */ - - 0x002A0264, - 0x0F120001, /*REG_TC_GP_bUseReqInputInCap */ - - 0x002A049C, - 0x0F120A00, /*REG_TC_PZOOM_CapZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_CapZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_CapZoomReqInputHeightOfs */ - - 0x002A047C, - 0x0F120001, /*REG_TC_THUMB_Thumb_bActive */ - 0x0F120280, /*REG_TC_THUMB_Thumb_uWidth //640 */ - 0x0F1201E0, /*REG_TC_THUMB_Thumb_uHeight //480 */ - - 0x002A0398, - 0x0F120280, /*REG_0TC_CCFG_usWidth //640 */ - 0x0F1201E0, /*REG_0TC_CCFG_usHeight //480 */ - - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0270, - 0x0F120001, /*REG_TC_GP_CapConfigChanged */ -}; - -static const u32 s5k4ecgx_QVGA_Capture_EVT1[] = { /* 320 x 240 */ - -}; - -static const u32 s5k4ecgx_1280_Preview_EVT1[] = { /* 1280 x 720 */ - /*720P enable setting */ - 0xFCFCD000, - 0x00287000, - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1207DC, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - /* Size */ - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F1205A0, /*REG_TC_GP_PrevReqInputHeight //1440 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs //(2592-2560)/2 */ - 0x0F1200FC, /*REG_TC_GP_PrevInputHeightOfs //(1944-1440)/2*/ - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F1205A0, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1440 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - 0x002A02A6, - 0x0F120500, /*REG_0TC_PCFG_usWidth //1280 */ - 0x0F1202D0, /*REG_0TC_PCFG_usHeight //720 */ - - /* Frame Rate */ - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType */ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F12014A,/*REG_0TC_PCFG_usMaxFrTimeMsecMult10 //014Ah:30fps */ - 0x0F12014A,/*REG_0TC_PCFG_usMinFrTimeMsecMult10 //014Ah:30fps */ - - /* AE Target */ - 0x002A1484, - 0x0F12002A, /*003C //TVAR_ae_BrAve */ - - /* AE Weight Matrix */ - 0x002A1492, - 0x0F120101, /*0100 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0001 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0201 */ - 0x0F120101, /*0102 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0202 */ - 0x0F120101, /*0202 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0201 */ - 0x0F120101, /*0302 */ - 0x0F120101, /*0203 */ - 0x0F120101, /*0102 */ - 0x0F120101, /*0201 */ - 0x0F120101, /*0302 */ - 0x0F120101, /*0203 */ - 0x0F120101, /*0102 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0202 */ - 0x0F120101, /*0202 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0201 */ - 0x0F120101, /*0102 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - 0x0F120101, /*0101 */ - - /* Slow AE */ - 0x002A1568, - 0x0F120030, /*0010 //ae_GainIn_0_ */ - 0x0F120090, /*0020 //ae_GainIn_1_ */ - 0x0F1200A8, /*0040 //ae_GainIn_2_ */ - 0x0F1200C0, /*0080 //ae_GainIn_3_ */ - 0x0F120100, /*0010 //ae_GainIn_4_ FIX */ - 0x0F120140, /*0200 //ae_GainIn_5_ */ - 0x0F120180, /*0400 //ae_GainIn_6_ */ - 0x0F120400, /*0800 //ae_GainIn_7_ */ - 0x0F122000, /*0800 //ae_GainIn_8_ */ - 0x0F120080, /*0010 //ae_GainOut_0_ */ - 0x0F1200D0, /*0020 //ae_GainOut_1_ */ - 0x0F1200D8, /*0040 //ae_GainOut_2_ */ - 0x0F1200F8, /*0080 //ae_GainOut_3_ */ - 0x0F120100, /*0100 //ae_GainOut_4_ FIX */ - 0x0F120103, /*0200 //ae_GainOut_5_ */ - 0x0F120110, /*0400 //ae_GainOut_6_ */ - 0x0F120150, /*0800 //ae_GainOut_7_ */ - 0x0F120400, /*2000 //ae_GainOut_8_*/ - 0x002A0544, - 0x0F120105, /*0111 //lt_uLimitHigh */ - 0x0F1200FA, /*00EF //lt_uLimitLow */ - 0x002A0588, - 0x0F120001, /*0000 //lt_uInitPostToleranceCnt */ - 0x002A0582, - 0x0F1200D0, /*0000 //lt_uSlowFilterCoef */ - - 0x002A0734, /*R*/ - 0x0F120000, - 0x0F120005, - 0x0F12000F, - 0x0F120026, - 0x0F120066, - 0x0F1200D5, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - 0x0F120000, /*G*/ - 0x0F120005, - 0x0F12000F, - 0x0F120026, - 0x0F120066, - 0x0F1200D5, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - 0x0F120000, /*B*/ - 0x0F120005, - 0x0F12000F, - 0x0F120026, - 0x0F120066, - 0x0F1200D5, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - /* Slow AWB */ - 0x002A139A, - 0x0F120158, /*0258 //awbb_GainsMaxMove */ - - /* AWB Convergence Speed */ - 0x002A1464, - 0x0F120008, /*awbb_WpFilterMinThr */ - 0x0F12FFFF, /*0190 //awbb_WpFilterMaxThr */ - 0x0F120010, /*00A0 //awbb_WpFilterCoef */ - 0x0F120020, /*0004 //awbb_WpFilterSize */ - 0x002A0938, - 0x0F120001,/*0000 // on/off AFIT by NB option */ - 0x0F120014, /*0014//SARR_uNormBrInDoor */ - 0x0F1200D2, /*00D2//SARR_uNormBrInDoor */ - 0x0F120784, /*0384//SARR_uNormBrInDoor */ - 0x0F1210D0, /*07D0//SARR_uNormBrInDoor */ - 0x0F121388, /*1388//SARR_uNormBrInDoor */ - 0x002A098C, - 0x0F120000, /*0000//7000098C//_BRIGHTNESS AFIT 0 */ - 0x0F120000, /*0000//7000098E//_CONTRAST */ - 0x0F120000, /*0000//70000990//_SATURATION */ - 0x0F120000, /*0000//70000992//_SHARP_BLUR */ - 0x0F120000, /*0000//70000994//_GLAMOUR */ - 0x0F1200C0, /*00C0//70000996//_bnr_edge_high */ - 0x0F120064, /*0064//70000998//_postdmsc_iLowBright */ - 0x0F120384, /*0384//7000099A//_postdmsc_iHighBright */ - 0x0F120051, /*005F//7000099C//_postdmsc_iLowSat */ - 0x0F1201F4, /*01F4//7000099E//_postdmsc_iHighSat */ - 0x0F120070, /*0070//700009A0//_postdmsc_iTune */ - 0x0F120040, /*0040//700009A2//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*00A0//700009A4//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*0100//700009A6//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*0010//700009A8//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*0040//700009AA//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*00A0//700009AC//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*1430//700009AE//_bnr_edge_low */ - 0x0F120201, /*0201//700009B0//_bnr_repl_force */ - 0x0F120204, /*0204//700009B2//_bnr_iHotThreshLow */ - 0x0F122404, /*3604//700009B4//_bnr_iColdThreshLow */ - 0x0F12031B, /*032A//700009B6//_bnr_DispTH_High */ - 0x0F120103, /*0403//700009B8//_bnr_DISP_Limit_High */ - 0x0F121205, /*1B06//700009BA//_bnr_iDistSigmaMax */ - 0x0F12400D, /*6015//700009BC//_bnr_iDiffSigmaHigh */ - 0x0F120080, /*00C0//700009BE//_bnr_iNormalizedSTD_Limit */ - 0x0F122080, /*6080//700009C0//_bnr_iDirMinThres */ - 0x0F123040, /*4080//700009C2//_bnr_iDirFltDiffThresLow*/ - 0x0F120630, /*0640//700009C4//_bnr_iDirSmoothPowerLow*/ - 0x0F120306, /*0306//700009C6//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*2003//700009C8//_bnr_iHighSlopeThresh*/ - 0x0F12FF01, /*FF01//700009CA//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*0000//700009CC//_bnr_AddNoisePower1 */ - 0x0F120300, /*0400//700009CE//_bnr_iRadialTune */ - 0x0F12245A, /*365A//700009D0//_bnr_iRadialLimit */ - 0x0F121018, /*102A//700009D2//_ee_iFSMagThHigh */ - 0x0F12000B, /*000B//700009D4//_ee_iFSVarThHigh */ - 0x0F120B00, /*0600//700009D6//_ee_iFSThHigh */ - 0x0F125A0F, /*5A0F//700009D8//_ee_iFSVarCountTh */ - 0x0F120505, /*0505//700009DA//_ee_iRadialPower */ - 0x0F121802, /*1802//700009DC//_ee_iROADThres */ - 0x0F120000, /*0000//700009DE//_ee_iROADSubMaxNR */ - 0x0F122006, /*2006//700009E0//_ee_iROADNeiThres */ - 0x0F123428, /*3028//700009E2//_ee_iSmoothEdgeThres */ - 0x0F12041C, /*0418//700009E4//_ee_iWSharpen */ - 0x0F120101, /*0101//700009E6//_ee_iWShThresh */ - 0x0F120800, /*0800//700009E8//_ee_iEmbossCentAdd */ - 0x0F121004, /*1804//700009EA//_ee_iReduceEdgeThresh */ - 0x0F124008, /*4008//700009EC//_dmsc_iDesatThresh */ - 0x0F120540, /*0540//700009EE//_dmsc_iDemBlurLow */ - 0x0F128006, /*8006//700009F0//_dmsc_iDecisionThresh */ - 0x0F120020, /*0020//700009F2//_dmsc_iMonochrom */ - 0x0F120000, /*0000//700009F4//_dmsc_iGRDenoiseVal */ - 0x0F121800, /*2000//700009F6//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*0000//700009F8//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*1E10//700009FA//_postdmsc_iBCoeff */ - 0x0F12000B, /*000B//700009FC//_postdmsc_iWideMult */ - 0x0F120607, /*0607//700009FE//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*0005//70000A00//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*0607//70000A02//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*0705//70000A04//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*0206//70000A06//_yuviirnr_iXSupportUV */ - 0x0F120304, /*0304//70000A08//_yuviirnr_iHighYNorm */ - 0x0F120409, /*0309//70000A0A//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*0305//70000A0C//_yuviirnr_iUVNormShift */ - 0x0F120407, /*2006//70000A0E//_yuviirnr_iVertLength_UV */ - 0x0F121F04, /*1320//70000A10//_yuviirnr_iDiffThreshH_Y */ - 0x0F120218, /*1014//70000A12//_yuviirnr_iDiffThreshH_UV */ - 0x0F121102, /*1010//70000A14//_yuviirnr_iMaxThreshH_Y */ - 0x0F120611, /*0C10//70000A16//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*1A0C//70000A18//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*4A18//70000A1A//_yuviirnr_iUVNRStrengthH */ - 0x0F1200B0, /*0080//70000A1C//_RGBGamma2_iLinearity */ - 0x0F121080, /*0350//70000A1E//_ccm_oscar_iSaturation */ - 0x0F120180, /*0180//70000A20//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*0A0A//70000A22//_bnr_iClustMulT_H */ - 0x0F120101, /*0101//70000A24//_bnr_iClustThresh_H */ - 0x0F121B24, /*2A36//70000A26//_bnr_iDenThreshLow */ - 0x0F126024, /*6024//70000A28//_ee_iLowSharpPower */ - 0x0F121D22, /*2A36//70000A2A//_ee_iLowShDenoise */ - 0x0F12FFFF, /*FFFF//70000A2C//_ee_iLowSharpClamp */ - 0x0F120808, /*0808//70000A2E//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*0A01//70000A30//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*010A//70000A32//_bnr_iClustMulT_C_Bin */ - 0x0F122401, /*2701//70000A34//_bnr_iClustThresh_C_Bin*/ - 0x0F12241B, /*241E//70000A36//_bnr_iDenThreshHigh_Bin*/ - 0x0F121E60, /*2E60//70000A38//_ee_iHighSharpPower_Bin*/ - 0x0F12FF18, /*FF22//70000A3A//_ee_iHighShDenoise_Bin */ - 0x0F1208FF, /*40FF//70000A3C//_ee_iHighSharpClamp_Bin */ - 0x0F120008, /*0009//70000A3E//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*0001//70000A40//_bnr_nClustLevel_C */ - 0x0F120000, /*0000//70000A42//_BRIGHTNESS AFIT 1 */ - 0x0F120000, /*0000//70000A44//_CONTRAST */ - 0x0F120000, /*0000//70000A46//_SATURATION */ - 0x0F120000, /*0000//70000A48//_SHARP_BLUR */ - 0x0F120000, /*0000//70000A4A//_GLAMOUR */ - 0x0F1200C0, /*00C0//70000A4C//_bnr_edge_high */ - 0x0F120064, /*0064//70000A4E//_postdmsc_iLowBright */ - 0x0F120384, /*0384//70000A50//_postdmsc_iHighBright */ - 0x0F120051, /*0051//70000A52//_postdmsc_iLowSat */ - 0x0F1201F4, /*01F4//70000A54//_postdmsc_iHighSat */ - 0x0F120070, /*0070//70000A56//_postdmsc_iTune */ - 0x0F120040, /*0040//70000A58//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*00A0//70000A5A//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*0100//70000A5C//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*0010//70000A5E//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*0060//70000A60//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*0100//70000A62//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*1430//70000A64//_bnr_edge_low */ - 0x0F120201, /*0201//70000A66//_bnr_repl_force */ - 0x0F120204, /*0204//70000A68//_bnr_iHotThreshLow */ - 0x0F121B04, /*2404//70000A6A//_bnr_iColdThreshLow */ - 0x0F120312, /*031B//70000A6C//_bnr_DispTH_High */ - 0x0F120003, /*0103//70000A6E//_bnr_DISP_Limit_High */ - 0x0F120C03, /*1205//70000A70//_bnr_iDistSigmaMax */ - 0x0F122806, /*400D//70000A72//_bnr_iDiffSigmaHigh */ - 0x0F120060, /*0080//70000A74//_bnr_iNormalizedSTD_Limit */ - 0x0F121540, /*1980//70000A76//_bnr_iDirMinThres */ - 0x0F12201C, /*272E//70000A78//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*0629//70000A7A//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*0306//70000A7C//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*2003//70000A7E//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*FF01//70000A80//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*0404//70000A82//_bnr_AddNoisePower1 */ - 0x0F120300, /*0300//70000A84//_bnr_iRadialTune */ - 0x0F12145A, /*245A//70000A86//_bnr_iRadialLimit */ - 0x0F121010, /*1018//70000A88//_ee_iFSMagThHigh */ - 0x0F12000B, /*000B//70000A8A//_ee_iFSVarThHigh */ - 0x0F120B00, /*0B00//70000A8C//_ee_iFSThHigh */ - 0x0F125A0F, /*5A0F//70000A8E//_ee_iFSVarCountTh */ - 0x0F120503, /*0505//70000A90//_ee_iRadialPower */ - 0x0F121802, /*1802//70000A92//_ee_iROADThres */ - 0x0F120000, /*0000//70000A94//_ee_iROADSubMaxNR */ - 0x0F122006, /*2006//70000A96//_ee_iROADNeiThres */ - 0x0F123C28, /*3828//70000A98//_ee_iSmoothEdgeThres */ - 0x0F120428, /*0425//70000A9A//_ee_iWSharpen */ - 0x0F120101, /*0101//70000A9C//_ee_iWShThresh */ - 0x0F128000, /*0800//70000A9E//_ee_iEmbossCentAdd */ - 0x0F121004, /*1004//70000AA0//_ee_iReduceEdgeThresh */ - 0x0F124008, /*4008//70000AA2//_dmsc_iDesatThresh */ - 0x0F120540, /*0540//70000AA4//_dmsc_iDemBlurLow */ - 0x0F128006, /*8006//70000AA6//_dmsc_iDecisionThresh */ - 0x0F120020, /*0020//70000AA8//_dmsc_iMonochrom */ - 0x0F120000, /*0000//70000AAA//_dmsc_iGRDenoiseVal */ - 0x0F121800, /*2000//70000AAC//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*0000//70000AAE//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*1E10//70000AB0//_postdmsc_iBCoeff */ - 0x0F12000B, /*000B//70000AB2//_postdmsc_iWideMult */ - 0x0F120607, /*0607//70000AB4//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*0005//70000AB6//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*0607//70000AB8//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*0405//70000ABA//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*0205//70000ABC//_yuviirnr_iXSupportUV */ - 0x0F120304, /*0304//70000ABE//_yuviirnr_iHighYNorm */ - 0x0F120409, /*0409//70000AC0//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*0306//70000AC2//_yuviirnr_iUVNormShift */ - 0x0F120407, /*0407//70000AC4//_yuviirnr_iVertLength_UV*/ - 0x0F121F04, /*2204//70000AC6//_yuviirnr_iDiffThreshH_Y*/ - 0x0F120228, /*021C//70000AC8//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*1102//70000ACA//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*0611//70000ACC//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*1A02//70000ACE//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*8018//70000AD0//_yuviirnr_iUVNRStrengthH*/ - 0x0F1200A0, /*0080//70000AD2//_RGBGamma2_iLinearity */ - 0x0F121080, /*0374//70000AD4//_ccm_oscar_iSaturation */ - 0x0F120180, /*0180//70000AD6//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*0A0A//70000AD8//_bnr_iClustMulT_H */ - 0x0F120101, /*0101//70000ADA//_bnr_iClustThresh_H */ - 0x0F121B24, /*141D//70000ADC//_bnr_iDenThreshLow */ - 0x0F126024, /*6024//70000ADE//_ee_iLowSharpPower */ - 0x0F120C0C, /*1217//70000AE0//_ee_iLowShDenoise */ - 0x0F12FFFF, /*FFFF//70000AE2//_ee_iLowSharpClamp */ - 0x0F120808, /*0808//70000AE4//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*0A01//70000AE6//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*010A//70000AE8//_bnr_iClustMulT_C_Bin */ - 0x0F121501, /*0001//70000AEA//_bnr_iClustThresh_C_Bin*/ - 0x0F12240F, /*2400//70000AEC//_bnr_iDenThreshHigh_Bin*/ - 0x0F120C60, /*1660//70000AEE//_ee_iHighSharpPower_Bin*/ - 0x0F12FF0C, /*FF10//70000AF0//_ee_iHighShDenoise_Bin */ - 0x0F1208FF, /*40FF//70000AF2//_ee_iHighSharpClamp_Bin*/ - 0x0F120008, /*0009//70000AF4//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*0001//70000AF6//_bnr_nClustLevel_C */ - 0x0F120000, /*0000//70000AF8//_BRIGHTNESS AFIT 2 */ - 0x0F120000, /*0000//70000AFA//_CONTRAST */ - 0x0F120000, /*0000//70000AFC//_SATURATION */ - 0x0F120000, /*0000//70000AFE//_SHARP_BLUR */ - 0x0F120000, /*0000//70000B00//_GLAMOUR */ - 0x0F1200C0, /*00C0//70000B02//_bnr_edge_high */ - 0x0F120064, /*0064//70000B04//_postdmsc_iLowBright */ - 0x0F120384, /*0384//70000B06//_postdmsc_iHighBright */ - 0x0F120043, /*0043//70000B08//_postdmsc_iLowSat */ - 0x0F1201F4, /*01F4//70000B0A//_postdmsc_iHighSat */ - 0x0F120070, /*0070//70000B0C//_postdmsc_iTune */ - 0x0F120040, /*0040//70000B0E//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*00A0//70000B10//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*0100//70000B12//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*0010//70000B14//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*0060//70000B16//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*0100//70000B18//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*1430//70000B1A//_bnr_edge_low */ - 0x0F120201, /*0201//70000B1C//_bnr_repl_force */ - 0x0F120204, /*0204//70000B1E//_bnr_iHotThreshLow */ - 0x0F121B04, /*1B04//70000B20//_bnr_iColdThreshLow */ - 0x0F120312, /*0312//70000B22//_bnr_DispTH_High */ - 0x0F120003, /*0003//70000B24//_bnr_DISP_Limit_High */ - 0x0F120C03, /*0C03//70000B26//_bnr_iDistSigmaMax */ - 0x0F122806, /*2806//70000B28//_bnr_iDiffSigmaHigh */ - 0x0F120060, /*0060//70000B2A//_bnr_iNormalizedSTD_Limit*/ - 0x0F121540, /*1580//70000B2C//_bnr_iDirMinThres */ - 0x0F12201C, /*2020//70000B2E//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*0620//70000B30//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*0306//70000B32//_bnr_iHighMaxSlopeAllowed*/ - 0x0F122003, /*2003//70000B34//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*FF01//70000B36//_bnr_iSlopeBlurStrength*/ - 0x0F120404, /*0404//70000B38//_bnr_AddNoisePower1 */ - 0x0F120300, /*0300//70000B3A//_bnr_iRadialTune */ - 0x0F12145A, /*145A//70000B3C//_bnr_iRadialLimit */ - 0x0F121010, /*1010//70000B3E//_ee_iFSMagThHigh*/ - 0x0F12000B, /*000B//70000B40//_ee_iFSVarThHigh*/ - 0x0F120E00, /*0E00//70000B42//_ee_iFSThHigh */ - 0x0F125A0F, /*5A0F//70000B44//_ee_iFSVarCountTh */ - 0x0F120503, /*0504//70000B46//_ee_iRadialPower*/ - 0x0F121802, /*1802//70000B48//_ee_iROADThres */ - 0x0F120000, /*0000//70000B4A//_ee_iROADSubMaxNR */ - 0x0F122006, /*2006//70000B4C//_ee_iROADNeiThres */ - 0x0F123C28, /*3828//70000B4E//_ee_iSmoothEdgeThres */ - 0x0F120428, /*0428//70000B50//_ee_iWSharpen */ - 0x0F120101, /*0101//70000B52//_ee_iWShThresh */ - 0x0F128000, /*8000//70000B54//_ee_iEmbossCentAdd */ - 0x0F120A04, /*0A04//70000B56//_ee_iReduceEdgeThresh */ - 0x0F124008, /*4008//70000B58//_dmsc_iDesatThresh */ - 0x0F120540, /*0540//70000B5A//_dmsc_iDemBlurLow */ - 0x0F128006, /*8006//70000B5C//_dmsc_iDecisionThresh */ - 0x0F120020, /*0020//70000B5E//_dmsc_iMonochrom */ - 0x0F120000, /*0000//70000B60//_dmsc_iGRDenoiseVal */ - 0x0F121800, /*2000//70000B62//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*0000//70000B64//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*1E10//70000B66//_postdmsc_iBCoeff */ - 0x0F12000B, /*000B//70000B68//_postdmsc_iWideMult */ - 0x0F120607, /*0607//70000B6A//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*0005//70000B6C//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*0607//70000B6E//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*0405//70000B70//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*0207//70000B72//_yuviirnr_iXSupportUV */ - 0x0F120304, /*0304//70000B74//_yuviirnr_iHighYNorm */ - 0x0F120409, /*0409//70000B76//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*0306//70000B78//_yuviirnr_iUVNormShift */ - 0x0F120407, /*0407//70000B7A//_yuviirnr_iVertLength_UV*/ - 0x0F122404, /*2404//70000B7C//_yuviirnr_iDiffThreshH_Y*/ - 0x0F120228, /*0221//70000B7E//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*1202//70000B80//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*0613//70000B82//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*1A02//70000B84//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*8018//70000B86//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*0080//70000B88//_RGBGamma2_iLinearity */ - 0x0F121080, /*0080//70000B8A//_ccm_oscar_iSaturation */ - 0x0F120180, /*0180//70000B8C//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*0A0A//70000B8E//_bnr_iClustMulT_H */ - 0x0F120101, /*0101//70000B90//_bnr_iClustThresh_H */ - 0x0F12141D, /*121B//70000B92//_bnr_iDenThreshLow */ - 0x0F126024, /*6024//70000B94//_ee_iLowSharpPower */ - 0x0F120C0C, /*0C0C//70000B96//_ee_iLowShDenoise */ - 0x0F12FFFF, /*FFFF//70000B98//_ee_iLowSharpClamp */ - 0x0F120808, /*0808//70000B9A//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*0A01//70000B9C//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*010A//70000B9E//_bnr_iClustMulT_C_Bin */ - 0x0F121501, /*0001//70000BA0//_bnr_iClustThresh_C_Bin*/ - 0x0F12240F, /*2400//70000BA2//_bnr_iDenThreshHigh_Bin*/ - 0x0F120C60, /*0460//70000BA4//_ee_iHighSharpPower_Bin*/ - 0x0F12FF0C, /*FF04//70000BA6//_ee_iHighShDenoise_Bin*/ - 0x0F1208FF, /*40FF//70000BA8//_ee_iHighSharpClamp_Bin */ - 0x0F120008, /*0009//70000BAA//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*0001//70000BAC//_bnr_nClustLevel_C */ - 0x0F120000, /*0000//70000BAE//_BRIGHTNESS AFIT 3 */ - 0x0F120000, /*0000//70000BB0//_CONTRAST */ - 0x0F120000, /*0000//70000BB2//_SATURATION */ - 0x0F120000, /*0000//70000BB4//_SHARP_BLUR */ - 0x0F120000, /*0000//70000BB6//_GLAMOUR */ - 0x0F1200C0, /*00C0//70000BB8//_bnr_edge_high */ - 0x0F120064, /*0064//70000BBA//_postdmsc_iLowBright */ - 0x0F120384, /*0384//70000BBC//_postdmsc_iHighBright */ - 0x0F120032, /*0032//70000BBE//_postdmsc_iLowSat */ - 0x0F1201F4, /*01F4//70000BC0//_postdmsc_iHighSat */ - 0x0F120070, /*0070//70000BC2//_postdmsc_iTune */ - 0x0F120040, /*0040//70000BC4//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*00A0//70000BC6//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*0100//70000BC8//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*0010//70000BCA//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*0060//70000BCC//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*0100//70000BCE//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*1430//70000BD0//_bnr_edge_low */ - 0x0F120201, /*0201//70000BD2//_bnr_repl_force */ - 0x0F120204, /*0204//70000BD4//_bnr_iHotThreshLow */ - 0x0F121504, /*1504//70000BD6//_bnr_iColdThreshLow */ - 0x0F12030F, /*030F//70000BD8//_bnr_DispTH_High */ - 0x0F120003, /*0003//70000BDA//_bnr_DISP_Limit_High */ - 0x0F120902, /*0902//70000BDC//_bnr_iDistSigmaMax */ - 0x0F122004, /*2004//70000BDE//_bnr_iDiffSigmaHigh */ - 0x0F120050, /*0050//70000BE0//_bnr_iNormalizedSTD_Limit*/ - 0x0F121140, /*1140//70000BE2//_bnr_iDirMinThres */ - 0x0F12201C, /*201C//70000BE4//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*0620//70000BE6//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*0306//70000BE8//_bnr_iHighMaxSlopeAllowed*/ - 0x0F122003, /*2003//70000BEA//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*FF01//70000BEC//_bnr_iSlopeBlurStrength*/ - 0x0F120404, /*0404//70000BEE//_bnr_AddNoisePower1 */ - 0x0F120300, /*0300//70000BF0//_bnr_iRadialTune */ - 0x0F12145A, /*145A//70000BF2//_bnr_iRadialLimit */ - 0x0F121010, /*1010//70000BF4//_ee_iFSMagThHigh */ - 0x0F12000B, /*000B//70000BF6//_ee_iFSVarThHigh */ - 0x0F121000, /*1000//70000BF8//_ee_iFSThHigh */ - 0x0F125A0F, /*5A0F//70000BFA//_ee_iFSVarCountTh */ - 0x0F120503, /*0503//70000BFC//_ee_iRadialPower */ - 0x0F121802, /*1802//70000BFE//_ee_iROADThres */ - 0x0F120000, /*0000//70000C00//_ee_iROADSubMaxNR */ - 0x0F122006, /*2006//70000C02//_ee_iROADNeiThres */ - 0x0F123C28, /*3C28//70000C04//_ee_iSmoothEdgeThres */ - 0x0F12042C, /*042C//70000C06//_ee_iWSharpen */ - 0x0F120101, /*0101//70000C08//_ee_iWShThresh */ - 0x0F128000, /*FF00//70000C0A//_ee_iEmbossCentAdd */ - 0x0F120904, /*0904//70000C0C//_ee_iReduceEdgeThresh */ - 0x0F124008, /*4008//70000C0E//_dmsc_iDesatThresh */ - 0x0F120540, /*0540//70000C10//_dmsc_iDemBlurLow */ - 0x0F128006, /*8006//70000C12//_dmsc_iDecisionThresh */ - 0x0F120020, /*0020//70000C14//_dmsc_iMonochrom */ - 0x0F120000, /*0000//70000C16//_dmsc_iGRDenoiseVal */ - 0x0F121800, /*2000//70000C18//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*0000//70000C1A//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*1E10//70000C1C//_postdmsc_iBCoeff */ - 0x0F12000B, /*000B//70000C1E//_postdmsc_iWideMult */ - 0x0F120607, /*0607//70000C20//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*0005//70000C22//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*0607//70000C24//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*0405//70000C26//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*0206//70000C28//_yuviirnr_iXSupportUV */ - 0x0F120304, /*0304//70000C2A//_yuviirnr_iHighYNorm */ - 0x0F120409, /*0409//70000C2C//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*0305//70000C2E//_yuviirnr_iUVNormShift */ - 0x0F120407, /*0406//70000C30//_yuviirnr_iVertLength_UV*/ - 0x0F122804, /*2804//70000C32//_yuviirnr_iDiffThreshH_Y*/ - 0x0F120228, /*0228//70000C34//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*1402//70000C36//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*0618//70000C38//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*1A02//70000C3A//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*8018//70000C3C//_yuviirnr_iUVNRStrengthH*/ - 0x0F120080, /*0080//70000C3E//_RGBGamma2_iLinearity */ - 0x0F121080, /*0080//70000C40//_ccm_oscar_iSaturation */ - 0x0F120180, /*0180//70000C42//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*0A0A//70000C44//_bnr_iClustMulT_H */ - 0x0F120101, /*0101//70000C46//_bnr_iClustThresh_H */ - 0x0F121117, /*0F15//70000C48//_bnr_iDenThreshLow */ - 0x0F126024, /*6024//70000C4A//_ee_iLowSharpPower */ - 0x0F120A0A, /*0A0A//70000C4C//_ee_iLowShDenoise */ - 0x0F12FFFF, /*FFFF//70000C4E//_ee_iLowSharpClamp */ - 0x0F120808, /*0808//70000C50//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*0A01//70000C52//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*010A//70000C54//_bnr_iClustMulT_C_Bin */ - 0x0F121501, /*0001//70000C56//_bnr_iClustThresh_C_Bin*/ - 0x0F12240F, /*2400//70000C58//_bnr_iDenThreshHigh_Bin*/ - 0x0F120A60, /*0260//70000C5A//_ee_iHighSharpPower_Bin*/ - 0x0F12FF0A, /*FF02//70000C5C//_ee_iHighShDenoise_Bin */ - 0x0F1208FF, /*40FF//70000C5E//_ee_iHighSharpClamp_Bin*/ - 0x0F120008, /*0009//70000C60//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*0001//70000C62//_bnr_nClustLevel_C */ - 0x0F120000, /*0000//70000C64//_BRIGHTNESS AFIT 4 */ - 0x0F120000, /*0000//70000C66//_CONTRAST */ - 0x0F120000, /*0000//70000C68//_SATURATION */ - 0x0F120000, /*0000//70000C6A//_SHARP_BLUR */ - 0x0F120000, /*0000//70000C6C//_GLAMOUR */ - 0x0F1200C0, /*00C0//70000C6E//_bnr_edge_high */ - 0x0F120064, /*0064//70000C70//_postdmsc_iLowBright */ - 0x0F120384, /*0384//70000C72//_postdmsc_iHighBright */ - 0x0F120032, /*0032//70000C74//_postdmsc_iLowSat */ - 0x0F1201F4, /*01F4//70000C76//_postdmsc_iHighSat */ - 0x0F120070, /*0070//70000C78//_postdmsc_iTune */ - 0x0F120040, /*0040//70000C7A//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*00A0//70000C7C//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*0100//70000C7E//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*0010//70000C80//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*0060//70000C82//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*0100//70000C84//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*1430//70000C86//_bnr_edge_low */ - 0x0F120201, /*0201//70000C88//_bnr_repl_force */ - 0x0F120204, /*0204//70000C8A//_bnr_iHotThreshLow */ - 0x0F120F04, /*0F04//70000C8C//_bnr_iColdThreshLow */ - 0x0F12030C, /*030C//70000C8E//_bnr_DispTH_High */ - 0x0F120003, /*0003//70000C90//_bnr_DISP_Limit_High */ - 0x0F120602, /*0602//70000C92//_bnr_iDistSigmaMax */ - 0x0F121803, /*1803//70000C94//_bnr_iDiffSigmaHigh */ - 0x0F120040, /*0040//70000C96//_bnr_iNormalizedSTD_Limit*/ - 0x0F120E20, /*0E20//70000C98//_bnr_iDirMinThres */ - 0x0F122018, /*2018//70000C9A//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*0620//70000C9C//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*0306//70000C9E//_bnr_iHighMaxSlopeAllowed*/ - 0x0F122003, /*2003//70000CA0//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*FF01//70000CA2//_bnr_iSlopeBlurStrength*/ - 0x0F120404, /*0404//70000CA4//_bnr_AddNoisePower1 */ - 0x0F120200, /*0200//70000CA6//_bnr_iRadialTune */ - 0x0F12145A, /*145A//70000CA8//_bnr_iRadialLimit */ - 0x0F121010, /*1010//70000CAA//_ee_iFSMagThHigh */ - 0x0F12000B, /*000B//70000CAC//_ee_iFSVarThHigh */ - 0x0F121200, /*1200//70000CAE//_ee_iFSThHigh */ - 0x0F125A0F, /*5A0F//70000CB0//_ee_iFSVarCountTh */ - 0x0F120502, /*0502//70000CB2//_ee_iRadialPower */ - 0x0F121802, /*1802//70000CB4//_ee_iROADThres */ - 0x0F120000, /*0000//70000CB6//_ee_iROADSubMaxNR */ - 0x0F122006, /*2006//70000CB8//_ee_iROADNeiThres */ - 0x0F124028, /*4028//70000CBA//_ee_iSmoothEdgeThres */ - 0x0F120430, /*0430//70000CBC//_ee_iWSharpen */ - 0x0F120101, /*0101//70000CBE//_ee_iWShThresh */ - 0x0F12FF00, /*FF00//70000CC0//_ee_iEmbossCentAdd */ - 0x0F120804, /*0804//70000CC2//_ee_iReduceEdgeThresh */ - 0x0F124008, /*4008//70000CC4//_dmsc_iDesatThresh */ - 0x0F120540, /*0540//70000CC6//_dmsc_iDemBlurLow */ - 0x0F128006, /*8006//70000CC8//_dmsc_iDecisionThresh */ - 0x0F120020, /*0020//70000CCA//_dmsc_iMonochrom */ - 0x0F120000, /*0000//70000CCC//_dmsc_iGRDenoiseVal */ - 0x0F121800, /*2000//70000CCE//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*0000//70000CD0//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*1E10//70000CD2//_postdmsc_iBCoeff */ - 0x0F12000B, /*000B//70000CD4//_postdmsc_iWideMult */ - 0x0F120607, /*0607//70000CD6//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*0005//70000CD8//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*0607//70000CDA//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*0405//70000CDC//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*0205//70000CDE//_yuviirnr_iXSupportUV */ - 0x0F120304, /*0304//70000CE0//_yuviirnr_iHighYNorm */ - 0x0F120409, /*0409//70000CE2//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*0306//70000CE4//_yuviirnr_iUVNormShift */ - 0x0F120407, /*0407//70000CE6//_yuviirnr_iVertLength_UV*/ - 0x0F122C04, /*2C04//70000CE8//_yuviirnr_iDiffThreshH_Y*/ - 0x0F12022C, /*022C//70000CEA//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*1402//70000CEC//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*0618//70000CEE//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*1A02//70000CF0//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*8018//70000CF2//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*0080//70000CF4//_RGBGamma2_iLinearity */ - 0x0F121080, /*0080//70000CF6//_ccm_oscar_iSaturation */ - 0x0F120180, /*0180//70000CF8//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*0A0A//70000CFA//_bnr_iClustMulT_H */ - 0x0F120101, /*0101//70000CFC//_bnr_iClustThresh_H */ - 0x0F120C0F, /*0C0F//70000CFE//_bnr_iDenThreshLow */ - 0x0F126024, /*6024//70000D00//_ee_iLowSharpPower */ - 0x0F120808, /*0808//70000D02//_ee_iLowShDenoise */ - 0x0F12FFFF, /*FFFF//70000D04//_ee_iLowSharpClamp */ - 0x0F120808, /*0808//70000D06//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*0A01//70000D08//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*010A//70000D0A//_bnr_iClustMulT_C_Bin */ - 0x0F120F01, /*0001//70000D0C//_bnr_iClustThresh_C_Bin*/ - 0x0F12240C, /*2400//70000D0E//_bnr_iDenThreshHigh_Bin*/ - 0x0F120860, /*0060//70000D10//_ee_iHighSharpPower_Bin*/ - 0x0F12FF08, /*FF00//70000D12//_ee_iHighShDenoise_Bin */ - 0x0F1208FF, /*40FF//70000D14//_ee_iHighSharpClamp_Bin*/ - 0x0F120008, /*0009//70000D16//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*0001//70000D18//_bnr_nClustLevel_C */ - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_1280_Preview_Disable_EVT1[] = {/*1280x720 */ - /* 720P disable setting */ - 0xFCFCD000, - 0x00287000, - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - /* Size */ - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs/(2592-2560)/2*/ - 0x0F12000C, /*REG_TC_GP_PrevInputHeightOfs/(1944-1920)/2*/ - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - 0x002A02A6, - 0x0F120280, /*REG_0TC_PCFG_usWidth //640 */ - 0x0F1201E0, /*REG_0TC_PCFG_usHeight //480 */ - - /* Frame Rate */ - 0x002A02BE, - 0x0F120000, /*REG_0TC_PCFG_usFrTimeType*/ - 0x0F120001, /*REG_0TC_PCFG_FrRateQualityType */ - 0x0F1203E8, /*029A/REG_0TC_PCFG_usMaxFrTimeMsecMult10/029Ah:15fps*/ - 0x0F12014A, /*REG_0TC_PCFG_usMinFrTimeMsecMult10/014Ah:30fps*/ - - /* AE Target */ - 0x002A1484, - 0x0F12003C, /*TVAR_ae_BrAve */ - - /* AE Weight Matrix */ - 0x002A1492, - 0x0F120100, - 0x0F120101, - 0x0F120101, - 0x0F120001, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120201, - 0x0F120302, - 0x0F120203, - 0x0F120102, - 0x0F120101, - 0x0F120202, - 0x0F120202, - 0x0F120101, - 0x0F120101, - 0x0F120201, - 0x0F120102, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - 0x0F120101, - - /* Slow AE */ - 0x002A1568, - 0x0F120010, /*ae_GainIn_0_ */ - 0x0F120020, /*ae_GainIn_1_ */ - 0x0F120040, /*ae_GainIn_2_ */ - 0x0F120080, /*ae_GainIn_3_ */ - 0x0F120100, /*ae_GainIn_4_ FIX */ - 0x0F120200, /*ae_GainIn_5_ */ - 0x0F120400, /*ae_GainIn_6_ */ - 0x0F120800, /*ae_GainIn_7_ */ - 0x0F120800, /*ae_GainIn_8_ */ - 0x0F120010, /*ae_GainOut_0_ */ - 0x0F120020, /*ae_GainOut_1_ */ - 0x0F120040, /*ae_GainOut_2_ */ - 0x0F120080, /*ae_GainOut_3_ */ - 0x0F120100, /*ae_GainOut_4_ FIX */ - 0x0F120200, /*ae_GainOut_5_ */ - 0x0F120400, /*ae_GainOut_6_ */ - 0x0F120800, /*ae_GainOut_7_ */ - 0x0F122000, /*ae_GainOut_8_ */ - 0x002A0544, - 0x0F120111, /*lt_uLimitHigh */ - 0x0F1200EF, /*lt_uLimitLow */ - 0x002A0588, - 0x0F120000, /*lt_uInitPostToleranceCnt */ - 0x002A0582, - 0x0F120000, /*lt_uSlowFilterCoef */ - 0x002A0734, /*R*/ - 0x0F120000, - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - 0x0F120000, /*G*/ - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - 0x0F120000, /*B*/ - 0x0F120001, - 0x0F120006, - 0x0F120017, - 0x0F12004A, - 0x0F1200C9, - 0x0F120138, - 0x0F120163, - 0x0F120189, - 0x0F1201C6, - 0x0F1201F8, - 0x0F120222, - 0x0F120247, - 0x0F120282, - 0x0F1202B5, - 0x0F12030F, - 0x0F12035F, - 0x0F1203A2, - 0x0F1203D8, - 0x0F1203FF, - - /* Slow AWB */ - 0x002A139A, - 0x0F120258, /*awbb_GainsMaxMove */ - - /* AWB Convergence Speed */ - 0x002A1464, - 0x0F120008, /*awbb_WpFilterMinThr */ - 0x0F120190, /*awbb_WpFilterMaxThr */ - 0x0F1200A0, /*awbb_WpFilterCoef */ - 0x0F120004, /*awbb_WpFilterSize */ - 0x002A0938, - 0x0F120000, /* on/off AFIT by NB option */ - 0x0F120014, /*SARR_uNormBrInDoor */ - 0x0F1200D2, /*SARR_uNormBrInDoor */ - 0x0F120384, /*SARR_uNormBrInDoor */ - 0x0F1207D0, /*SARR_uNormBrInDoor */ - 0x0F121388, /*SARR_uNormBrInDoor */ - 0x002A098C, - 0x0F120000, /*7000098C//_BRIGHTNESS AFIT 0 */ - 0x0F120000, /*7000098E//_CONTRAST */ - 0x0F120000, /*70000990//_SATURATION */ - 0x0F120000, /*70000992//_SHARP_BLUR */ - 0x0F120000, /*70000994//_GLAMOUR */ - 0x0F1200C0, /*70000996//_bnr_edge_high */ - 0x0F120064, /*70000998//_postdmsc_iLowBright */ - 0x0F120384, /*7000099A//_postdmsc_iHighBright */ - 0x0F12005F, /*7000099C//_postdmsc_iLowSat */ - 0x0F1201F4, /*7000099E//_postdmsc_iHighSat */ - 0x0F120070, /*700009A0//_postdmsc_iTune */ - 0x0F120040, /*700009A2//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*700009A4//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*700009A6//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*700009A8//_yuvemix_mPosRanges_0 */ - 0x0F120040, /*700009AA//_yuvemix_mPosRanges_1 */ - 0x0F1200A0, /*700009AC//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*700009AE//_bnr_edge_low */ - 0x0F120201, /*700009B0//_bnr_repl_force */ - 0x0F120204, /*700009B2//_bnr_iHotThreshLow */ - 0x0F123604, /*700009B4//_bnr_iColdThreshLow */ - 0x0F12032A, /*700009B6//_bnr_DispTH_High */ - 0x0F120403, /*700009B8//_bnr_DISP_Limit_High */ - 0x0F121B06, /*700009BA//_bnr_iDistSigmaMax */ - 0x0F126015, /*700009BC//_bnr_iDiffSigmaHigh */ - 0x0F1200C0, /*700009BE//_bnr_iNormalizedSTD_Limit */ - 0x0F126080, /*700009C0//_bnr_iDirMinThres */ - 0x0F124080, /*700009C2//_bnr_iDirFltDiffThresLow */ - 0x0F120640, /*700009C4//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*700009C6//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*700009C8//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*700009CA//_bnr_iSlopeBlurStrength */ - 0x0F120000, /*700009CC//_bnr_AddNoisePower1 */ - 0x0F120400, /*700009CE//_bnr_iRadialTune */ - 0x0F12365A, /*700009D0//_bnr_iRadialLimit */ - 0x0F12102A, /*700009D2//_ee_iFSMagThHigh */ - 0x0F12000B, /*700009D4//_ee_iFSVarThHigh */ - 0x0F120600, /*700009D6//_ee_iFSThHigh */ - 0x0F125A0F, /*700009D8//_ee_iFSVarCountTh */ - 0x0F120505, /*700009DA//_ee_iRadialPower */ - 0x0F121802, /*700009DC//_ee_iROADThres */ - 0x0F120000, /*700009DE//_ee_iROADSubMaxNR */ - 0x0F122006, /*700009E0//_ee_iROADNeiThres */ - 0x0F123028, /*700009E2//_ee_iSmoothEdgeThres */ - 0x0F120418, /*700009E4//_ee_iWSharpen */ - 0x0F120101, /*700009E6//_ee_iWShThresh */ - 0x0F120800, /*700009E8//_ee_iEmbossCentAdd */ - 0x0F121804, /*700009EA//_ee_iReduceEdgeThresh */ - 0x0F124008, /*700009EC//_dmsc_iDesatThresh */ - 0x0F120540, /*700009EE//_dmsc_iDemBlurLow */ - 0x0F128006, /*700009F0//_dmsc_iDecisionThresh */ - 0x0F120020, /*700009F2//_dmsc_iMonochrom */ - 0x0F120000, /*700009F4//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*700009F6//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*700009F8//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*700009FA//_postdmsc_iBCoeff */ - 0x0F12000B, /*700009FC//_postdmsc_iWideMult */ - 0x0F120607, /*700009FE//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000A00//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000A02//_yuvemix_mPosSlopes_1 */ - 0x0F120705, /*70000A04//_yuvemix_mPosSlopes_3 */ - 0x0F120206, /*70000A06//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000A08//_yuviirnr_iHighYNorm */ - 0x0F120309, /*70000A0A//_yuviirnr_iHighUVNorm */ - 0x0F120305, /*70000A0C//_yuviirnr_iUVNormShift */ - 0x0F122006, /*70000A0E//_yuviirnr_iVertLength_UV */ - 0x0F121320, /*70000A10//_yuviirnr_iDiffThreshH_Y */ - 0x0F121014, /*70000A12//_yuviirnr_iDiffThreshH_UV */ - 0x0F121010, /*70000A14//_yuviirnr_iMaxThreshH_Y */ - 0x0F120C10, /*70000A16//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A0C, /*70000A18//_yuviirnr_iYNRStrengthH */ - 0x0F124A18, /*70000A1A//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000A1C//_RGBGamma2_iLinearity */ - 0x0F120350, /*70000A1E//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000A20//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000A22//_bnr_iClustMulT_H */ - 0x0F120101, /*70000A24//_bnr_iClustThresh_H */ - 0x0F122A36, /*70000A26//_bnr_iDenThreshLow */ - 0x0F126024, /*70000A28//_ee_iLowSharpPower */ - 0x0F122A36, /*70000A2A//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000A2C//_ee_iLowSharpClamp */ - 0x0F120808, /*70000A2E//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000A30//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000A32//_bnr_iClustMulT_C_Bin */ - 0x0F122701, /*70000A34//_bnr_iClustThresh_C_Bin */ - 0x0F12241E, /*70000A36//_bnr_iDenThreshHigh_Bin */ - 0x0F122E60, /*70000A38//_ee_iHighSharpPower_Bin */ - 0x0F12FF22, /*70000A3A//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000A3C//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000A3E//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000A40//_bnr_nClustLevel_C */ - 0x0F120000, /*70000A42//_BRIGHTNESS AFIT 1 */ - 0x0F120000, /*70000A44//_CONTRAST */ - 0x0F120000, /*70000A46//_SATURATION */ - 0x0F120000, /*70000A48//_SHARP_BLUR */ - 0x0F120000, /*70000A4A//_GLAMOUR */ - 0x0F1200C0, /*70000A4C//_bnr_edge_high */ - 0x0F120064, /*70000A4E//_postdmsc_iLowBright */ - 0x0F120384, /*70000A50//_postdmsc_iHighBright */ - 0x0F120051, /*70000A52//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000A54//_postdmsc_iHighSat */ - 0x0F120070, /*70000A56//_postdmsc_iTune */ - 0x0F120040, /*70000A58//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000A5A//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000A5C//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000A5E//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000A60//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000A62//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000A64//_bnr_edge_low */ - 0x0F120201, /*70000A66//_bnr_repl_force */ - 0x0F120204, /*70000A68//_bnr_iHotThreshLow */ - 0x0F122404, /*70000A6A//_bnr_iColdThreshLow */ - 0x0F12031B, /*70000A6C//_bnr_DispTH_High */ - 0x0F120103, /*70000A6E//_bnr_DISP_Limit_High */ - 0x0F121205, /*70000A70//_bnr_iDistSigmaMax */ - 0x0F12400D, /*70000A72//_bnr_iDiffSigmaHigh */ - 0x0F120080, /*70000A74//_bnr_iNormalizedSTD_Limit */ - 0x0F121980, /*70000A76//_bnr_iDirMinThres */ - 0x0F12272E, /*70000A78//_bnr_iDirFltDiffThresLow */ - 0x0F120629, /*70000A7A//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000A7C//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000A7E//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000A80//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000A82//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000A84//_bnr_iRadialTune */ - 0x0F12245A, /*70000A86//_bnr_iRadialLimit */ - 0x0F121018, /*70000A88//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000A8A//_ee_iFSVarThHigh */ - 0x0F120B00, /*70000A8C//_ee_iFSThHigh */ - 0x0F125A0F, /*70000A8E//_ee_iFSVarCountTh */ - 0x0F120505, /*70000A90//_ee_iRadialPower */ - 0x0F121802, /*70000A92//_ee_iROADThres */ - 0x0F120000, /*70000A94//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000A96//_ee_iROADNeiThres */ - 0x0F123828, /*70000A98//_ee_iSmoothEdgeThres */ - 0x0F120425, /*70000A9A//_ee_iWSharpen */ - 0x0F120101, /*70000A9C//_ee_iWShThresh */ - 0x0F120800, /*70000A9E//_ee_iEmbossCentAdd */ - 0x0F121004, /*70000AA0//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000AA2//_dmsc_iDesatThresh */ - 0x0F120540, /*70000AA4//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000AA6//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000AA8//_dmsc_iMonochrom */ - 0x0F120000, /*70000AAA//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000AAC//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000AAE//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000AB0//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000AB2//_postdmsc_iWideMult */ - 0x0F120607, /*70000AB4//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000AB6//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000AB8//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000ABA//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*70000ABC//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000ABE//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000AC0//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000AC2//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000AC4//_yuviirnr_iVertLength_UV */ - 0x0F122204, /*70000AC6//_yuviirnr_iDiffThreshH_Y */ - 0x0F12021C, /*70000AC8//_yuviirnr_iDiffThreshH_UV */ - 0x0F121102, /*70000ACA//_yuviirnr_iMaxThreshH_Y */ - 0x0F120611, /*70000ACC//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000ACE//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000AD0//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000AD2//_RGBGamma2_iLinearity */ - 0x0F120374, /*70000AD4//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000AD6//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000AD8//_bnr_iClustMulT_H */ - 0x0F120101, /*70000ADA//_bnr_iClustThresh_H */ - 0x0F12141D, /*70000ADC//_bnr_iDenThreshLow */ - 0x0F126024, /*70000ADE//_ee_iLowSharpPower */ - 0x0F121217, /*70000AE0//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000AE2//_ee_iLowSharpClamp */ - 0x0F120808, /*70000AE4//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000AE6//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000AE8//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000AEA//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000AEC//_bnr_iDenThreshHigh_Bin */ - 0x0F121660, /*70000AEE//_ee_iHighSharpPower_Bin */ - 0x0F12FF10, /*70000AF0//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000AF2//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000AF4//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000AF6//_bnr_nClustLevel_C */ - 0x0F120000, /*70000AF8//_BRIGHTNESS AFIT 2 */ - 0x0F120000, /*70000AFA//_CONTRAST */ - 0x0F120000, /*70000AFC//_SATURATION */ - 0x0F120000, /*70000AFE//_SHARP_BLUR */ - 0x0F120000, /*70000B00//_GLAMOUR */ - 0x0F1200C0, /*70000B02//_bnr_edge_high */ - 0x0F120064, /*70000B04//_postdmsc_iLowBright */ - 0x0F120384, /*70000B06//_postdmsc_iHighBright */ - 0x0F120043, /*70000B08//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000B0A//_postdmsc_iHighSat */ - 0x0F120070, /*70000B0C//_postdmsc_iTune */ - 0x0F120040, /*70000B0E//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000B10//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000B12//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000B14//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000B16//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000B18//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000B1A//_bnr_edge_low */ - 0x0F120201, /*70000B1C//_bnr_repl_force */ - 0x0F120204, /*70000B1E//_bnr_iHotThreshLow */ - 0x0F121B04, /*70000B20//_bnr_iColdThreshLow */ - 0x0F120312, /*70000B22//_bnr_DispTH_High */ - 0x0F120003, /*70000B24//_bnr_DISP_Limit_High */ - 0x0F120C03, /*70000B26//_bnr_iDistSigmaMax */ - 0x0F122806, /*70000B28//_bnr_iDiffSigmaHigh */ - 0x0F120060, /*70000B2A//_bnr_iNormalizedSTD_Limit */ - 0x0F121580, /*70000B2C//_bnr_iDirMinThres */ - 0x0F122020, /*70000B2E//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000B30//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000B32//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000B34//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000B36//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000B38//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000B3A//_bnr_iRadialTune */ - 0x0F12145A, /*70000B3C//_bnr_iRadialLimit */ - 0x0F121010, /*70000B3E//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000B40//_ee_iFSVarThHigh */ - 0x0F120E00, /*70000B42//_ee_iFSThHigh */ - 0x0F125A0F, /*70000B44//_ee_iFSVarCountTh */ - 0x0F120504, /*70000B46//_ee_iRadialPower */ - 0x0F121802, /*70000B48//_ee_iROADThres */ - 0x0F120000, /*70000B4A//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000B4C//_ee_iROADNeiThres */ - 0x0F123828, /*70000B4E//_ee_iSmoothEdgeThres */ - 0x0F120428, /*70000B50//_ee_iWSharpen */ - 0x0F120101, /*70000B52//_ee_iWShThresh */ - 0x0F128000, /*70000B54//_ee_iEmbossCentAdd */ - 0x0F120A04, /*70000B56//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000B58//_dmsc_iDesatThresh */ - 0x0F120540, /*70000B5A//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000B5C//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000B5E//_dmsc_iMonochrom */ - 0x0F120000, /*70000B60//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000B62//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000B64//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000B66//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000B68//_postdmsc_iWideMult */ - 0x0F120607, /*70000B6A//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000B6C//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000B6E//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000B70//_yuvemix_mPosSlopes_3 */ - 0x0F120207, /*70000B72//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000B74//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000B76//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000B78//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000B7A//_yuviirnr_iVertLength_UV */ - 0x0F122404, /*70000B7C//_yuviirnr_iDiffThreshH_Y */ - 0x0F120221, /*70000B7E//_yuviirnr_iDiffThreshH_UV */ - 0x0F121202, /*70000B80//_yuviirnr_iMaxThreshH_Y*/ - 0x0F120613, /*70000B82//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000B84//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000B86//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000B88//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000B8A//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000B8C//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000B8E//_bnr_iClustMulT_H */ - 0x0F120101, /*70000B90//_bnr_iClustThresh_H */ - 0x0F12121B, /*70000B92//_bnr_iDenThreshLow */ - 0x0F126024, /*70000B94//_ee_iLowSharpPower */ - 0x0F120C0C, /*70000B96//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000B98//_ee_iLowSharpClamp */ - 0x0F120808, /*70000B9A//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000B9C//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000B9E//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000BA0//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000BA2//_bnr_iDenThreshHigh_Bin */ - 0x0F120460, /*70000BA4//_ee_iHighSharpPower_Bin */ - 0x0F12FF04, /*70000BA6//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000BA8//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000BAA//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000BAC//_bnr_nClustLevel_C */ - 0x0F120000, /*70000BAE//_BRIGHTNESS AFIT 3 */ - 0x0F120000, /*70000BB0//_CONTRAST */ - 0x0F120000, /*70000BB2//_SATURATION */ - 0x0F120000, /*70000BB4//_SHARP_BLUR */ - 0x0F120000, /*70000BB6//_GLAMOUR */ - 0x0F1200C0, /*70000BB8//_bnr_edge_high */ - 0x0F120064, /*70000BBA//_postdmsc_iLowBright */ - 0x0F120384, /*70000BBC//_postdmsc_iHighBright */ - 0x0F120032, /*70000BBE//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000BC0//_postdmsc_iHighSat */ - 0x0F120070, /*70000BC2//_postdmsc_iTune */ - 0x0F120040, /*70000BC4//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000BC6//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000BC8//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000BCA//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000BCC//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000BCE//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000BD0//_bnr_edge_low */ - 0x0F120201, /*70000BD2//_bnr_repl_force */ - 0x0F120204, /*70000BD4//_bnr_iHotThreshLow */ - 0x0F121504, /*70000BD6//_bnr_iColdThreshLow */ - 0x0F12030F, /*70000BD8//_bnr_DispTH_High */ - 0x0F120003, /*70000BDA//_bnr_DISP_Limit_High */ - 0x0F120902, /*70000BDC//_bnr_iDistSigmaMax */ - 0x0F122004, /*70000BDE//_bnr_iDiffSigmaHigh */ - 0x0F120050, /*70000BE0//_bnr_iNormalizedSTD_Limit */ - 0x0F121140, /*70000BE2//_bnr_iDirMinThres */ - 0x0F12201C, /*70000BE4//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000BE6//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000BE8//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000BEA//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000BEC//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000BEE//_bnr_AddNoisePower1 */ - 0x0F120300, /*70000BF0//_bnr_iRadialTune */ - 0x0F12145A, /*70000BF2//_bnr_iRadialLimit */ - 0x0F121010, /*70000BF4//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000BF6//_ee_iFSVarThHigh */ - 0x0F121000, /*70000BF8//_ee_iFSThHigh */ - 0x0F125A0F, /*70000BFA//_ee_iFSVarCountTh */ - 0x0F120503, /*70000BFC//_ee_iRadialPower */ - 0x0F121802, /*70000BFE//_ee_iROADThres */ - 0x0F120000, /*70000C00//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000C02//_ee_iROADNeiThres */ - 0x0F123C28, /*70000C04//_ee_iSmoothEdgeThres */ - 0x0F12042C, /*70000C06//_ee_iWSharpen */ - 0x0F120101, /*70000C08//_ee_iWShThresh */ - 0x0F12FF00, /*70000C0A//_ee_iEmbossCentAdd */ - 0x0F120904, /*70000C0C//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000C0E//_dmsc_iDesatThresh */ - 0x0F120540, /*70000C10//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000C12//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000C14//_dmsc_iMonochrom */ - 0x0F120000, /*70000C16//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000C18//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000C1A//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000C1C//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000C1E//_postdmsc_iWideMult */ - 0x0F120607, /*70000C20//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000C22//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000C24//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000C26//_yuvemix_mPosSlopes_3 */ - 0x0F120206, /*70000C28//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000C2A//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000C2C//_yuviirnr_iHighUVNorm */ - 0x0F120305, /*70000C2E//_yuviirnr_iUVNormShift */ - 0x0F120406, /*70000C30//_yuviirnr_iVertLength_UV */ - 0x0F122804, /*70000C32//_yuviirnr_iDiffThreshH_Y */ - 0x0F120228, /*70000C34//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*70000C36//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*70000C38//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000C3A//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000C3C//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000C3E//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000C40//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000C42//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000C44//_bnr_iClustMulT_H */ - 0x0F120101, /*70000C46//_bnr_iClustThresh_H */ - 0x0F120F15, /*70000C48//_bnr_iDenThreshLow */ - 0x0F126024, /*70000C4A//_ee_iLowSharpPower */ - 0x0F120A0A, /*70000C4C//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000C4E//_ee_iLowSharpClamp */ - 0x0F120808, /*70000C50//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000C52//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000C54//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000C56//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000C58//_bnr_iDenThreshHigh_Bin */ - 0x0F120260, /*70000C5A//_ee_iHighSharpPower_Bin */ - 0x0F12FF02, /*70000C5C//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000C5E//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000C60//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000C62//_bnr_nClustLevel_C */ - 0x0F120000, /*70000C64//_BRIGHTNESS AFIT 4 */ - 0x0F120000, /*70000C66//_CONTRAST */ - 0x0F120000, /*70000C68//_SATURATION */ - 0x0F120000, /*70000C6A//_SHARP_BLUR */ - 0x0F120000, /*70000C6C//_GLAMOUR */ - 0x0F1200C0, /*70000C6E//_bnr_edge_high */ - 0x0F120064, /*70000C70//_postdmsc_iLowBright */ - 0x0F120384, /*70000C72//_postdmsc_iHighBright */ - 0x0F120032, /*70000C74//_postdmsc_iLowSat */ - 0x0F1201F4, /*70000C76//_postdmsc_iHighSat */ - 0x0F120070, /*70000C78//_postdmsc_iTune */ - 0x0F120040, /*70000C7A//_yuvemix_mNegRanges_0 */ - 0x0F1200A0, /*70000C7C//_yuvemix_mNegRanges_1 */ - 0x0F120100, /*70000C7E//_yuvemix_mNegRanges_2 */ - 0x0F120010, /*70000C80//_yuvemix_mPosRanges_0 */ - 0x0F120060, /*70000C82//_yuvemix_mPosRanges_1 */ - 0x0F120100, /*70000C84//_yuvemix_mPosRanges_2 */ - 0x0F121430, /*70000C86//_bnr_edge_low */ - 0x0F120201, /*70000C88//_bnr_repl_force */ - 0x0F120204, /*70000C8A//_bnr_iHotThreshLow */ - 0x0F120F04, /*70000C8C//_bnr_iColdThreshLow */ - 0x0F12030C, /*70000C8E//_bnr_DispTH_High */ - 0x0F120003, /*70000C90//_bnr_DISP_Limit_High */ - 0x0F120602, /*70000C92//_bnr_iDistSigmaMax */ - 0x0F121803, /*70000C94//_bnr_iDiffSigmaHigh */ - 0x0F120040, /*70000C96//_bnr_iNormalizedSTD_Limit */ - 0x0F120E20, /*70000C98//_bnr_iDirMinThres */ - 0x0F122018, /*70000C9A//_bnr_iDirFltDiffThresLow */ - 0x0F120620, /*70000C9C//_bnr_iDirSmoothPowerLow */ - 0x0F120306, /*70000C9E//_bnr_iHighMaxSlopeAllowed */ - 0x0F122003, /*70000CA0//_bnr_iHighSlopeThresh */ - 0x0F12FF01, /*70000CA2//_bnr_iSlopeBlurStrength */ - 0x0F120404, /*70000CA4//_bnr_AddNoisePower1 */ - 0x0F120200, /*70000CA6//_bnr_iRadialTune */ - 0x0F12145A, /*70000CA8//_bnr_iRadialLimit */ - 0x0F121010, /*70000CAA//_ee_iFSMagThHigh */ - 0x0F12000B, /*70000CAC//_ee_iFSVarThHigh */ - 0x0F121200, /*70000CAE//_ee_iFSThHigh */ - 0x0F125A0F, /*70000CB0//_ee_iFSVarCountTh */ - 0x0F120502, /*70000CB2//_ee_iRadialPower */ - 0x0F121802, /*70000CB4//_ee_iROADThres */ - 0x0F120000, /*70000CB6//_ee_iROADSubMaxNR */ - 0x0F122006, /*70000CB8//_ee_iROADNeiThres */ - 0x0F124028, /*70000CBA//_ee_iSmoothEdgeThres */ - 0x0F120430, /*70000CBC//_ee_iWSharpen */ - 0x0F120101, /*70000CBE//_ee_iWShThresh */ - 0x0F12FF00, /*70000CC0//_ee_iEmbossCentAdd */ - 0x0F120804, /*70000CC2//_ee_iReduceEdgeThresh */ - 0x0F124008, /*70000CC4//_dmsc_iDesatThresh */ - 0x0F120540, /*70000CC6//_dmsc_iDemBlurLow */ - 0x0F128006, /*70000CC8//_dmsc_iDecisionThresh */ - 0x0F120020, /*70000CCA//_dmsc_iMonochrom */ - 0x0F120000, /*70000CCC//_dmsc_iGRDenoiseVal */ - 0x0F122000, /*70000CCE//_dmsc_iEdgeDesatThrLow */ - 0x0F120000, /*70000CD0//_dmsc_iNearGrayDesat */ - 0x0F121E10, /*70000CD2//_postdmsc_iBCoeff */ - 0x0F12000B, /*70000CD4//_postdmsc_iWideMult */ - 0x0F120607, /*70000CD6//_yuvemix_mNegSlopes_1 */ - 0x0F120005, /*70000CD8//_yuvemix_mNegSlopes_3 */ - 0x0F120607, /*70000CDA//_yuvemix_mPosSlopes_1 */ - 0x0F120405, /*70000CDC//_yuvemix_mPosSlopes_3 */ - 0x0F120205, /*70000CDE//_yuviirnr_iXSupportUV */ - 0x0F120304, /*70000CE0//_yuviirnr_iHighYNorm */ - 0x0F120409, /*70000CE2//_yuviirnr_iHighUVNorm */ - 0x0F120306, /*70000CE4//_yuviirnr_iUVNormShift */ - 0x0F120407, /*70000CE6//_yuviirnr_iVertLength_UV */ - 0x0F122C04, /*70000CE8//_yuviirnr_iDiffThreshH_Y */ - 0x0F12022C, /*70000CEA//_yuviirnr_iDiffThreshH_UV */ - 0x0F121402, /*70000CEC//_yuviirnr_iMaxThreshH_Y */ - 0x0F120618, /*70000CEE//_yuviirnr_iMaxThreshH_UV */ - 0x0F121A02, /*70000CF0//_yuviirnr_iYNRStrengthH */ - 0x0F128018, /*70000CF2//_yuviirnr_iUVNRStrengthH */ - 0x0F120080, /*70000CF4//_RGBGamma2_iLinearity */ - 0x0F120080, /*70000CF6//_ccm_oscar_iSaturation */ - 0x0F120180, /*70000CF8//_RGB2YUV_iRGBGain */ - 0x0F120A0A, /*70000CFA//_bnr_iClustMulT_H */ - 0x0F120101, /*70000CFC//_bnr_iClustThresh_H */ - 0x0F120C0F, /*70000CFE//_bnr_iDenThreshLow */ - 0x0F126024, /*70000D00//_ee_iLowSharpPower */ - 0x0F120808, /*70000D02//_ee_iLowShDenoise */ - 0x0F12FFFF, /*70000D04//_ee_iLowSharpClamp */ - 0x0F120808, /*70000D06//_ee_iReduceEdgeMinMult */ - 0x0F120A01, /*70000D08//_bnr_nClustLevel_H_Bin */ - 0x0F12010A, /*70000D0A//_bnr_iClustMulT_C_Bin */ - 0x0F120001, /*70000D0C//_bnr_iClustThresh_C_Bin */ - 0x0F122400, /*70000D0E//_bnr_iDenThreshHigh_Bin */ - 0x0F120060, /*70000D10//_ee_iHighSharpPower_Bin */ - 0x0F12FF00, /*70000D12//_ee_iHighShDenoise_Bin */ - 0x0F1240FF, /*70000D14//_ee_iHighSharpClamp_Bin */ - 0x0F120009, /*70000D16//_ee_iReduceEdgeSlope_Bin */ - 0x0F120001, /*70000D18//_bnr_nClustLevel_C */ - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_800_Preview_EVT1[] = { /* 800 x 480 // */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F120600, /*REG_TC_GP_PrevReqInputHeight //1536 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs //(2592-2560)/2*/ - 0x0F1200CC, /*REG_TC_GP_PrevInputHeightOfs/(1944-1536)/2*/ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F120600, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1536 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F120320, /*REG_0TC_PCFG_usWidth //800 */ - 0x0F1201E0, /*REG_0TC_PCFG_usHeight //480 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_720_Preview_EVT1[] = { /* 720 x 480 */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F1206A8, /*REG_TC_GP_PrevReqInputHeight //1704 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs/(2592-2560)/2*/ - 0x0F120078, /*REG_TC_GP_PrevInputHeightOfs //(1944-1704)/2*/ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F1206A8, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1704 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F1202D0, /*REG_0TC_PCFG_usWidth //720 */ - 0x0F1201E0, /*REG_0TC_PCFG_usHeight //480 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ -}; - -static const u32 s5k4ecgx_640_Preview_EVT1[] = { /* 640 x 480 */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs/(2592-2560)/2*/ - 0x0F12000C, /*REG_TC_GP_PrevInputHeightOfs/(1944-1920)/2*/ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F120280, /*REG_0TC_PCFG_usWidth //640 */ - 0x0F1201E0, /*REG_0TC_PCFG_usHeight //480 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_352_Preview_EVT1[] = { /* 352 x 288 */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120928, /*REG_TC_GP_PrevReqInputWidth //2344 */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight //1920 */ - 0x0F12007C, /*REG_TC_GP_PrevInputWidthOfs //(2592-2344)/2 */ - 0x0F12000C, /*REG_TC_GP_PrevInputHeightOfs //(1944-1920)/2 */ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120928, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2344 */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F120160, /*REG_0TC_PCFG_usWidth //352 */ - 0x0F120120, /*REG_0TC_PCFG_usHeight //288 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_320_Preview_EVT1[] = { /* 320 x 240 */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120A00, /*REG_TC_GP_PrevReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight //1920 */ - 0x0F120010, /*REG_TC_GP_PrevInputWidthOfs //(2592-2560)/2 */ - 0x0F12000C, /*REG_TC_GP_PrevInputHeightOfs //(1944-1920)/2*/ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120A00, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2560 */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F120140, /*REG_0TC_PCFG_usWidth //320 */ - 0x0F1200F0, /*REG_0TC_PCFG_usHeight //240 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ - -}; - -static const u32 s5k4ecgx_176_Preview_EVT1[] = { /* 176 x 144 */ - 0xFCFCD000, - 0x00287000, - - 0x002A18AC, - 0x0F120060, /*senHal_uAddColsBin */ - 0x0F120060, /*senHal_uAddColsNoBin */ - 0x0F1205C0, /*senHal_uMinColsBin */ - 0x0F1205C0, /*senHal_uMinColsNoBin */ - - 0x002A0250, - 0x0F120928, /*REG_TC_GP_PrevReqInputWidth //2344 */ - 0x0F120780, /*REG_TC_GP_PrevReqInputHeight //1920 */ - 0x0F12007C, /*REG_TC_GP_PrevInputWidthOfs //(2592-2344)/2 */ - 0x0F12000C,/*REG_TC_GP_PrevInputHeightOfs/(1944-1920)/2*/ - - 0x002A0262, - 0x0F120001, /*REG_TC_GP_bUseReqInputInPre */ - - 0x002A0494, - 0x0F120928, /*REG_TC_PZOOM_PrevZoomReqInputWidth //2344 */ - 0x0F120780, /*REG_TC_PZOOM_PrevZoomReqInputHeight //1920 */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputWidthOfs */ - 0x0F120000, /*REG_TC_PZOOM_PrevZoomReqInputHeightOfs */ - - 0x002A02A6, - 0x0F1200B0, /*REG_0TC_PCFG_usWidth //176 */ - 0x0F120090, /*REG_0TC_PCFG_usHeight //144 */ - - 0x002A0266, - 0x0F120000, /*REG_TC_GP_ActivePrevConfig */ - 0x002A026A, - 0x0F120001, /*REG_TC_GP_PrevOpenAfterChange */ - 0x002A024E, - 0x0F120001, /*REG_TC_GP_NewConfigSync */ - 0x002A0268, - 0x0F120001, /*REG_TC_GP_PrevConfigChanged */ -}; - -/* Zoom set for 320,176*/ -static const u32 s5k4ecgx_X4_Zoom_0_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120100, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120120, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120140, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120160, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120180, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_5_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201A0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_6_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201C0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201E0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X4_Zoom_8_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120200, - 0x002A04A4, - 0x0F120005, -}; - -/* Zoom set for 1280 x 640*/ -static const u32 s5k4ecgx_X2_Zoom_0_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120100, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120120, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120140, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120160, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120180, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_5_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201A0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_6_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201C0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201E0, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X2_Zoom_8_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120200, - 0x002A04A4, - 0x0F120005, -}; - -/* Zoom set for 720*/ -static const u32 s5k4ecgx_X1_77_Zoom_0_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120100, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120118, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120130, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120148, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120160, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_5_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120178, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_6_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120190, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201A8, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_77_Zoom_8_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F1201C5, - 0x002A04A4, - 0x0F120005, -}; - -/* Zoom set for 1600 */ -static const u32 s5k4ecgx_X1_6_Zoom_0_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120100, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120113, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120126, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120139, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F12014C, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_5_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F12015F, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_6_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120172, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120185, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_6_Zoom_8_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F12019A, - 0x002A04A4, - 0x0F120005, -}; - -/* Zoom set for 2048 */ -static const u32 s5k4ecgx_X1_25_Zoom_0_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120100, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_1_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120108, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_2_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120110, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_3_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120118, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_4_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120120, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_5_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120128, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_6_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120130, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_7_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120138, - 0x002A04A4, - 0x0F120005, -}; - -static const u32 s5k4ecgx_X1_25_Zoom_8_EVT1[] = { - 0xFCFCD000, - 0x00287000, - 0x002A048E, - 0x0F120140, - 0x002A04A4, - 0x0F120005, -}; - -#endif /* __S5K4ECGX_SETFILE_H */ |