aboutsummaryrefslogtreecommitdiffstats
path: root/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch
diff options
context:
space:
mode:
authorHarunobu Kurokawa <harunobu.kurokawa.dn@renesas.com>2018-04-27 14:30:40 +0900
committerHarunobu Kurokawa <harunobu.kurokawa.dn@renesas.com>2018-04-27 14:30:40 +0900
commitf8fb4a95d6f0ca9a92d3b9155e54ac1f3695a20d (patch)
tree7f5a50447e8a940b274c53581dc8af01e2fe0db6 /meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch
parent2e1a7e39e012ea4436c819f46cfcac05fb161184 (diff)
parentf4fad8b9a0d29946c39bb760b76bc9c16448555a (diff)
Merge remote-tracking branch 'cogent/v2.23.1' into sandbox/kingfisher_v2.23.1.20180427
Signed-off-by: Harunobu Kurokawa <harunobu.kurokawa.dn@renesas.com> Conflicts: meta-rcar-gen3-adas/conf/layer.conf meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/ulcb.cfg meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend meta-rcar-gen3-adas/recipes-multimedia/pulseaudio/pulseaudio_8.0.bbappend Change-Id: Ib0345634b8bec6a85357152138355d8f932bafc0
Diffstat (limited to 'meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch')
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch10804
1 files changed, 10104 insertions, 700 deletions
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch
index 00928d1..1623d12 100644
--- a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0030-Gen3-LVDS-cameras.patch
@@ -4,139 +4,122 @@ Date: Sun, 14 May 2017 15:20:01 +0300
Subject: [PATCH] Gen3: LVDS cameras
This add Gen3 LVDS cameras support:
-- deserializers: MAX9286, TI964, TI954, TI960
-- cameras: ov10635, ov490+ov10640, ov495+OV2775, ar0132, ap0101+ar014x
+- deserializers: MAX9286, DS90UB954/960/964
+- cameras: ov10635, ov490+ov10640, ov495+OV2775, ar0132, ar0220,
+ ap0101+ar014x, ov2775, imx390, ox03a
Signed-off-by: Vladimir Barinov <vladimir.barinov@cogentembedded.com>
---
- drivers/media/i2c/soc_camera/Kconfig | 47 +
- drivers/media/i2c/soc_camera/Makefile | 7 +
- drivers/media/i2c/soc_camera/ap0101_ar014x.c | 536 ++++++++++
+ drivers/media/i2c/soc_camera/Kconfig | 19 +
+ drivers/media/i2c/soc_camera/Makefile | 3 +
+ drivers/media/i2c/soc_camera/ap0101_ar014x.c | 588 ++++
drivers/media/i2c/soc_camera/ap0101_ar014x.h | 28 +
- drivers/media/i2c/soc_camera/ar0132.c | 581 +++++++++++
- drivers/media/i2c/soc_camera/ar0132.h | 213 ++++
- drivers/media/i2c/soc_camera/max9286.c | 672 +++++++++++++
- drivers/media/i2c/soc_camera/max9286.h | 244 +++++
- drivers/media/i2c/soc_camera/ov10635.c | 758 ++++++++++++++
- drivers/media/i2c/soc_camera/ov10635.h | 1139 +++++++++++++++++++++
+ drivers/media/i2c/soc_camera/ar0132.c | 565 ++++
+ drivers/media/i2c/soc_camera/ar0132.h | 212 ++
+ drivers/media/i2c/soc_camera/ar0220.c | 538 +++
+ drivers/media/i2c/soc_camera/ar0220.h | 43 +
+ drivers/media/i2c/soc_camera/imx390.c | 533 +++
+ drivers/media/i2c/soc_camera/imx390.h | 3817 ++++++++++++++++++++++
+ drivers/media/i2c/soc_camera/max9286.c | 692 ++++
+ drivers/media/i2c/soc_camera/max9286.h | 244 ++
+ drivers/media/i2c/soc_camera/ov10635.c | 759 +++++
+ drivers/media/i2c/soc_camera/ov10635.h | 1139 +++++++
drivers/media/i2c/soc_camera/ov10635_debug.h | 54 +
- drivers/media/i2c/soc_camera/ov106xx.c | 117 +++
- drivers/media/i2c/soc_camera/ov490_ov10640.c | 1156 ++++++++++++++++++++++
- drivers/media/i2c/soc_camera/ov490_ov10640.h | 102 ++
- drivers/media/i2c/soc_camera/ov495_ov2775.c | 658 ++++++++++++
+ drivers/media/i2c/soc_camera/ov106xx.c | 161 +
+ drivers/media/i2c/soc_camera/ov2775.c | 538 +++
+ drivers/media/i2c/soc_camera/ov2775.h | 1841 +++++++++++
+ drivers/media/i2c/soc_camera/ov490_ov10640.c | 1133 +++++++
+ drivers/media/i2c/soc_camera/ov490_ov10640.h | 102 +
+ drivers/media/i2c/soc_camera/ov495_ov2775.c | 650 ++++
drivers/media/i2c/soc_camera/ov495_ov2775.h | 23 +
- drivers/media/i2c/soc_camera/ti954_ti9x3.c | 431 ++++++++
- drivers/media/i2c/soc_camera/ti964_ti9x3.c | 400 ++++++++
- drivers/media/i2c/soc_camera/ti9x4_ti9x3.h | 153 +++
- drivers/media/platform/soc_camera/rcar_csi2.c | 297 ++++--
- drivers/media/platform/soc_camera/rcar_vin.c | 211 +++-
- drivers/media/platform/soc_camera/soc_camera.c | 17 +-
- drivers/media/platform/soc_camera/soc_mediabus.c | 16 +
+ drivers/media/i2c/soc_camera/ox03a.c | 526 +++
+ drivers/media/i2c/soc_camera/ox03a.h | 1724 ++++++++++
+ drivers/media/i2c/soc_camera/ti9x4.c | 518 +++
+ drivers/media/i2c/soc_camera/ti9x4.h | 156 +
+ drivers/media/platform/soc_camera/rcar_csi2.c | 312 +-
+ drivers/media/platform/soc_camera/rcar_vin.c | 194 +-
+ drivers/media/platform/soc_camera/soc_camera.c | 47 +-
+ drivers/media/platform/soc_camera/soc_mediabus.c | 26 +
include/media/drv-intf/soc_mediabus.h | 3 +
- include/media/soc_camera.h | 1 +
- 25 files changed, 7755 insertions(+), 109 deletions(-)
+ include/media/soc_camera.h | 5 +
+ 32 files changed, 17066 insertions(+), 127 deletions(-)
create mode 100644 drivers/media/i2c/soc_camera/ap0101_ar014x.c
create mode 100644 drivers/media/i2c/soc_camera/ap0101_ar014x.h
create mode 100644 drivers/media/i2c/soc_camera/ar0132.c
create mode 100644 drivers/media/i2c/soc_camera/ar0132.h
+ create mode 100644 drivers/media/i2c/soc_camera/ar0220.c
+ create mode 100644 drivers/media/i2c/soc_camera/ar0220.h
+ create mode 100644 drivers/media/i2c/soc_camera/imx390.c
+ create mode 100644 drivers/media/i2c/soc_camera/imx390.h
create mode 100644 drivers/media/i2c/soc_camera/max9286.c
create mode 100644 drivers/media/i2c/soc_camera/max9286.h
create mode 100644 drivers/media/i2c/soc_camera/ov10635.c
create mode 100644 drivers/media/i2c/soc_camera/ov10635.h
create mode 100644 drivers/media/i2c/soc_camera/ov10635_debug.h
create mode 100644 drivers/media/i2c/soc_camera/ov106xx.c
+ create mode 100644 drivers/media/i2c/soc_camera/ov2775.c
+ create mode 100644 drivers/media/i2c/soc_camera/ov2775.h
create mode 100644 drivers/media/i2c/soc_camera/ov490_ov10640.c
create mode 100644 drivers/media/i2c/soc_camera/ov490_ov10640.h
create mode 100644 drivers/media/i2c/soc_camera/ov495_ov2775.c
create mode 100644 drivers/media/i2c/soc_camera/ov495_ov2775.h
- create mode 100644 drivers/media/i2c/soc_camera/ti954_ti9x3.c
- create mode 100644 drivers/media/i2c/soc_camera/ti964_ti9x3.c
- create mode 100644 drivers/media/i2c/soc_camera/ti9x4_ti9x3.h
+ create mode 100644 drivers/media/i2c/soc_camera/ox03a.c
+ create mode 100644 drivers/media/i2c/soc_camera/ox03a.h
+ create mode 100644 drivers/media/i2c/soc_camera/ti9x4.c
+ create mode 100644 drivers/media/i2c/soc_camera/ti9x4.h
diff --git a/drivers/media/i2c/soc_camera/Kconfig b/drivers/media/i2c/soc_camera/Kconfig
-index 7704bcf..82da59f 100644
+index 7704bcf..2249b40 100644
--- a/drivers/media/i2c/soc_camera/Kconfig
+++ b/drivers/media/i2c/soc_camera/Kconfig
-@@ -6,6 +6,53 @@ config SOC_CAMERA_IMX074
+@@ -6,6 +6,25 @@ config SOC_CAMERA_IMX074
help
This driver supports IMX074 cameras from Sony
-+config SOC_CAMERA_MAX9286_MAX9271
-+ tristate "max9286-max9271 GMSL support"
++config SOC_CAMERA_MAX9286
++ tristate "max9286 GMSL support"
+ depends on SOC_CAMERA && I2C
+ help
-+ This is a MAXIM max9286-max9271 GMSL driver
++ This is a MAXIM max9286 GMSL driver
+
+config SOC_CAMERA_OV106XX
+ tristate "ov106xx camera support"
-+ depends on SOC_CAMERA && SOC_CAMERA_MAX9286_MAX9271 && I2C
++ depends on SOC_CAMERA && I2C
+ help
+ This is a runtime detected OmniVision ov10635 or ov490-ov10640
+ or ov495-ov2775 sensors camera driver
+
-+if !SOC_CAMERA_OV106XX
-+
-+config SOC_CAMERA_OV10635
-+ tristate "ov10635 camera support"
-+ depends on SOC_CAMERA && SOC_CAMERA_MAX9286_MAX9271 && I2C
-+ help
-+ This is an OmniVision ov10635 sensor camera driver
-+
-+config SOC_CAMERA_OV490_OV10640
-+ tristate "ov490-ov10640 camera support"
-+ depends on SOC_CAMERA && SOC_CAMERA_MAX9286_MAX9271 && I2C
-+ help
-+ This is an OmniVision ov490-ov10640 sensor camera driver
-+
-+config SOC_CAMERA_OV495_OV2775
-+ tristate "ov495-ov2775 camera support"
++config SOC_CAMERA_TI9X4
++ tristate "ti9x4 FPDLinkIII support"
+ depends on SOC_CAMERA && I2C
+ help
-+ This is an OmniVision ov495-ov2775 sensor camera driver
-+
-+endif
-+
-+config SOC_CAMERA_TI964_TI9X3
-+ tristate "ti964-ti9x3 FPDLinkIII support"
-+ depends on SOC_CAMERA && I2C
-+ help
-+ This is an Texas Instruments ti964-ti9X3 FPDLinkIII driver
-+
-+config SOC_CAMERA_TI954_TI9X3
-+ tristate "ti954-ti9X3 FPDLinkIII support"
-+ depends on SOC_CAMERA && I2C
-+ help
-+ This is an Texas Instruments ti954-ti9X3 FPDLinkIII driver
++ This is an Texas Instruments ti9X4 FPDLinkIII driver
+
config SOC_CAMERA_MT9M001
tristate "mt9m001 support"
depends on SOC_CAMERA && I2C
diff --git a/drivers/media/i2c/soc_camera/Makefile b/drivers/media/i2c/soc_camera/Makefile
-index 6f994f9..e88f6a9 100644
+index 6f994f9..2b2583a 100644
--- a/drivers/media/i2c/soc_camera/Makefile
+++ b/drivers/media/i2c/soc_camera/Makefile
-@@ -1,8 +1,15 @@
+@@ -1,8 +1,11 @@
obj-$(CONFIG_SOC_CAMERA_IMX074) += imx074.o
-+obj-$(CONFIG_SOC_CAMERA_MAX9286_MAX9271) += max9286.o
-+obj-$(CONFIG_SOC_CAMERA_TI964_TI9X3) += ti964_ti9x3.o
-+obj-$(CONFIG_SOC_CAMERA_TI954_TI9X3) += ti954_ti9x3.o
++obj-$(CONFIG_SOC_CAMERA_MAX9286) += max9286.o
++obj-$(CONFIG_SOC_CAMERA_TI9X4) += ti9x4.o
obj-$(CONFIG_SOC_CAMERA_MT9M001) += mt9m001.o
obj-$(CONFIG_SOC_CAMERA_MT9T031) += mt9t031.o
obj-$(CONFIG_SOC_CAMERA_MT9T112) += mt9t112.o
obj-$(CONFIG_SOC_CAMERA_MT9V022) += mt9v022.o
-+obj-$(CONFIG_SOC_CAMERA_OV10635) += ov10635.o
-+obj-$(CONFIG_SOC_CAMERA_OV490_OV10640) += ov490_ov10640.o
-+obj-$(CONFIG_SOC_CAMERA_OV495_OV2775) += ov495_ov2775.o
+obj-$(CONFIG_SOC_CAMERA_OV106XX) += ov106xx.o
obj-$(CONFIG_SOC_CAMERA_OV2640) += ov2640.o
obj-$(CONFIG_SOC_CAMERA_OV5642) += ov5642.o
obj-$(CONFIG_SOC_CAMERA_OV6650) += ov6650.o
diff --git a/drivers/media/i2c/soc_camera/ap0101_ar014x.c b/drivers/media/i2c/soc_camera/ap0101_ar014x.c
new file mode 100644
-index 0000000..4757657
+index 0000000..2c6b034
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ap0101_ar014x.c
-@@ -0,0 +1,536 @@
+@@ -0,0 +1,588 @@
+/*
+ * ON Semiconductor AP0101-AR014X sensor camera driver
+ *
@@ -168,6 +151,8 @@ index 0000000..4757657
+
+#define AP0101_MEDIA_BUS_FMT MEDIA_BUS_FMT_YUYV8_2X8
+
++static void ap0101_otp_id_read(struct i2c_client *client);
++
+struct ap0101_priv {
+ struct v4l2_subdev sd;
+ struct v4l2_ctrl_handler hdl;
@@ -184,7 +169,6 @@ index 0000000..4757657
+ int port;
+ int gpio_resetb;
+ int gpio_fsin;
-+
+};
+
+static inline struct ap0101_priv *to_ap0101(const struct i2c_client *client)
@@ -201,6 +185,7 @@ index 0000000..4757657
+ tmp_addr = client->addr;
+ client->addr = priv->max9286_addr; /* Deserializer I2C address */
+ reg8_write(client, 0x0a, fwd_en ? 0x11 << priv->port : 0); /* Enable/disable reverse/forward control for this port */
++ usleep_range(5000, 5500); /* wait 5ms */
+ client->addr = tmp_addr;
+ };
+}
@@ -222,6 +207,40 @@ index 0000000..4757657
+ return 0;
+}
+
++static u16 ap0101_ar014x_read(struct i2c_client *client, u16 addr)
++{
++ u16 reg_val = 0;
++
++ reg16_write16(client, 0x0040, 0x8d00);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_write16(client, 0xfc00, addr);
++ reg16_write16(client, 0xfc02, 0x0200); /* 2 bytes */
++ reg16_write16(client, 0x0040, 0x8d05);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_write16(client, 0x0040, 0x8d08);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_read16(client, 0xfc00, &reg_val);
++ reg16_write16(client, 0x0040, 0x8d02);
++ usleep_range(100, 150); /* wait 100 us */
++
++ return reg_val;
++}
++
++static void ap0101_ar014x_write(struct i2c_client *client, u16 addr, u16 val)
++{
++ reg16_write16(client, 0x0040, 0x8d00);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_write16(client, 0xfc00, addr);
++ reg16_write16(client, 0xfc02, 0x0200 | (val >> 8)); /* 2 bytes */
++ reg16_write16(client, 0xfc04, (val & 0xff) << 8);
++ reg16_write16(client, 0x0040, 0x8d06);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_write16(client, 0x0040, 0x8d08);
++ usleep_range(100, 150); /* wait 100 us */
++ reg16_write16(client, 0x0040, 0x8d02);
++ usleep_range(100, 150); /* wait 100 us */
++}
++
+static int ap0101_s_stream(struct v4l2_subdev *sd, int enable)
+{
+ return 0;
@@ -280,6 +299,8 @@ index 0000000..4757657
+ struct i2c_client *client = v4l2_get_subdevdata(sd);
+ struct ap0101_priv *priv = to_ap0101(client);
+
++ ap0101_otp_id_read(client);
++
+ memcpy(edid->edid, priv->id, 6);
+
+ edid->edid[6] = 0xff;
@@ -448,6 +469,19 @@ index 0000000..4757657
+
+static void ap0101_otp_id_read(struct i2c_client *client)
+{
++ struct ap0101_priv *priv = to_ap0101(client);
++ int i;
++
++ /* read camera id from ar014x OTP memory */
++ ap0101_ar014x_write(client, 0x3054, 0x400);
++ ap0101_ar014x_write(client, 0x304a, 0x110);
++ usleep_range(25000, 25500); /* wait 25 ms */
++
++ for (i = 0; i < 6; i += 2) {
++ /* first 4 bytes are equal on all ar014x */
++ priv->id[i] = ap0101_ar014x_read(client, 0x3800 + i + 4) >> 8;
++ priv->id[i + 1] = ap0101_ar014x_read(client, 0x3800 + i + 4) & 0xff;
++ }
+}
+
+static ssize_t ap0101_otp_id_show(struct device *dev,
@@ -457,6 +491,8 @@ index 0000000..4757657
+ struct i2c_client *client = v4l2_get_subdevdata(sd);
+ struct ap0101_priv *priv = to_ap0101(client);
+
++ ap0101_otp_id_read(client);
++
+ return snprintf(buf, 32, "%02x:%02x:%02x:%02x:%02x:%02x\n",
+ priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
+}
@@ -482,7 +518,6 @@ index 0000000..4757657
+
+ /* Program wizard registers */
+ ap0101_set_regs(client, ap0101_regs_wizard, ARRAY_SIZE(ap0101_regs_wizard));
-+
+ /* Read OTP IDs */
+ ap0101_otp_id_read(client);
+
@@ -709,10 +744,10 @@ index 0000000..16599a1
+};
diff --git a/drivers/media/i2c/soc_camera/ar0132.c b/drivers/media/i2c/soc_camera/ar0132.c
new file mode 100644
-index 0000000..bbaeeaae
+index 0000000..c0ac733
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ar0132.c
-@@ -0,0 +1,581 @@
+@@ -0,0 +1,565 @@
+/*
+ * ON Semiconductor AR0132 sensor camera driver
+ *
@@ -743,7 +778,7 @@ index 0000000..bbaeeaae
+#define AR0132_PID 0x3000
+#define AR0132_VERSION_REG 0x2400
+
-+#define AR0132_MEDIA_BUS_FMT MEDIA_BUS_FMT_SBGGR12_1X12
++#define AR0132_MEDIA_BUS_FMT MEDIA_BUS_FMT_SGRBG12_1X12
+
+struct ar0132_priv {
+ struct v4l2_subdev sd;
@@ -759,8 +794,7 @@ index 0000000..bbaeeaae
+ /* serializers */
+ int max9286_addr;
+ int max9271_addr;
-+ int ti964_addr;
-+ int ti954_addr;
++ int ti9x4_addr;
+ int ti9x3_addr;
+ int port;
+ int gpio_resetb;
@@ -782,6 +816,7 @@ index 0000000..bbaeeaae
+ tmp_addr = client->addr;
+ client->addr = priv->max9286_addr; /* Deserializer I2C address */
+ reg8_write(client, 0x0a, fwd_en ? 0x11 << priv->port : 0); /* Enable/disable reverse/forward control for this port */
++ usleep_range(5000, 5500); /* wait 5ms */
+ client->addr = tmp_addr;
+ };
+}
@@ -1107,19 +1142,13 @@ index 0000000..bbaeeaae
+ break;
+
+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti964-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti964_addr) &&
-+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
-+ break;
-+
-+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti954-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti954_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
+ break;
+ }
+
-+ if (!priv->max9286_addr && !priv->ti964_addr && !priv->ti954_addr) {
++ if (!priv->max9286_addr && !priv->ti9x4_addr) {
+ dev_err(&client->dev, "deserializer does not present for AR0132\n");
+ return -EINVAL;
+ }
@@ -1135,18 +1164,8 @@ index 0000000..bbaeeaae
+ reg8_write(client, 0x0A, AR0132_I2C_ADDR << 1); /* Sensor native I2C address */
+ usleep_range(2000, 2500); /* wait 2ms */
+ };
-+ if (priv->ti964_addr) {
-+ client->addr = priv->ti964_addr; /* Deserializer I2C address */
-+
-+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
-+ reg8_write(client, 0x5d, AR0132_I2C_ADDR << 1); /* Sensor native I2C address */
-+
-+ reg8_write(client, 0x6e, 0xa9); /* GPIO0 - reset, GPIO1 - fsin */
-+ }
-+ if (priv->ti954_addr) {
-+ client->addr = priv->ti954_addr; /* Deserializer I2C address */
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
+
+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
+ usleep_range(2000, 2500); /* wait 2ms */
@@ -1296,12 +1315,12 @@ index 0000000..bbaeeaae
+#endif
diff --git a/drivers/media/i2c/soc_camera/ar0132.h b/drivers/media/i2c/soc_camera/ar0132.h
new file mode 100644
-index 0000000..bcee0e5
+index 0000000..7dfc4e3
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ar0132.h
-@@ -0,0 +1,213 @@
+@@ -0,0 +1,212 @@
+/*
-+ * ON Semiconductor ar0132 sensor camera wizard 1110x620@30/BGGR/BT601/12bit
++ * ON Semiconductor AR0132 sensor camera wizard 1110x620@30/BGGR/BT601/12bit
+ *
+ * Copyright (C) 2017 Cogent Embedded, Inc.
+ *
@@ -1316,16 +1335,15 @@ index 0000000..bcee0e5
+
+#define AR0132_EMBEDDED_LINE
+
-+#define AR0132_MAX_WIDTH 1665 // (1110*3/2)
++#define AR0132_MAX_WIDTH 1104
+#define AR0132_MAX_HEIGHT 624
+
+#define AR0132_DELAY 0xffff
+
+#define AR0132_MAX_ROI_DIM_X 1288
+#define AR0132_MAX_ROI_DIM_Y 968
-+#define AR0132_InfoLines 4
+
-+#define AR0132_ROI_DIM_X 1110 // 1104
++#define AR0132_ROI_DIM_X 1104
+#define AR0132_ROI_DIM_Y 620 // AR0132_MAX_HEIGHT
+
+#define AR0132_ROI_Y_START 0x00AE
@@ -1359,11 +1377,11 @@ index 0000000..bcee0e5
+ //256: Walking 1 test pattern (12 bit)
+#ifdef AR0132_DISPLAY_PATTERN_FIXED
+{0x3070, 0x0001},
++#endif
+{0x3072, 0x0123}, // R
+{0x3074, 0x0456}, // G(GR row)
+{0x3076, 0x0abc}, // B
+{0x3078, 0x0def}, // G(GB row)
-+#endif
+#ifdef AR0132_DISPLAY_PATTERN_COLOR_BAR
+{0x3070, 0x0002},
+#endif
@@ -1452,7 +1470,7 @@ index 0000000..bcee0e5
+{0x302E, AR0132_PLL_Pre_Clk_Div},
+{0x3030, AR0132_PLL_Multiplier},
+{0x3032, 0x0000}, // SCALING_MODE = 0
-+{0x3040, 0xC000}, // READ_MODE = read_mode_vert_flip | read_mode_horiz_mirror
++{0x3040, 0x0000}, // READ_MODE = read_mode_vert_flip | read_mode_horiz_mirror
+{0x3044, 0x0404}, // Dark Control = 1028
+{0x30A6, 0x0001}, // Y Odd Inc. (A) = 1
+{0x30A8, 0x0001}, // Y Odd Inc. (B) = 1
@@ -1513,12 +1531,4967 @@ index 0000000..bcee0e5
+{0x31D0, 0x0001},
+{0x30B0, 0x2002},
+};
+diff --git a/drivers/media/i2c/soc_camera/ar0220.c b/drivers/media/i2c/soc_camera/ar0220.c
+new file mode 100644
+index 0000000..eb20187
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/ar0220.c
+@@ -0,0 +1,538 @@
++/*
++ * ON Semiconductor AR0220 sensor camera driver
++ *
++ * Copyright (C) 2017-2018 Cogent Embedded, Inc.
++ *
++ * 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/delay.h>
++#include <linux/init.h>
++#include <linux/i2c.h>
++#include <linux/module.h>
++#include <linux/videodev2.h>
++
++#include <media/soc_camera.h>
++#include <media/v4l2-common.h>
++#include <media/v4l2-ctrls.h>
++#include <media/v4l2-of.h>
++
++#include "ar0220.h"
++
++#define AR0220_I2C_ADDR 0x10
++//#define AR0220_I2C_ADDR 0x54 // eeprom
++
++#define AR0220_PID 0x3000
++#define AR0220_VERSION_REG 0x0C54
++
++#define AR0220_MEDIA_BUS_FMT MEDIA_BUS_FMT_SGRBG14_1X14
++
++struct ar0220_priv {
++ struct v4l2_subdev sd;
++ struct v4l2_ctrl_handler hdl;
++ struct media_pad pad;
++ struct v4l2_rect rect;
++ int init_complete;
++ u8 id[6];
++ int exposure;
++ int gain;
++ int autogain;
++ /* serializers */
++ int ti9x4_addr;
++ int ti9x3_addr;
++ int port;
++ int gpio_resetb;
++ int gpio_fsin;
++};
++
++static inline struct ar0220_priv *to_ar0220(const struct i2c_client *client)
++{
++ return container_of(i2c_get_clientdata(client), struct ar0220_priv, sd);
++}
++
++static int ar0220_set_regs(struct i2c_client *client,
++ const struct ar0220_reg *regs, int nr_regs)
++{
++ int i;
++
++ for (i = 0; i < nr_regs; i++) {
++ if (regs[i].reg == AR0220_DELAY) {
++ mdelay(regs[i].val);
++ continue;
++ }
++
++ reg16_write16(client, regs[i].reg, regs[i].val);
++ }
++
++ return 0;
++}
++
++static int ar0220_s_stream(struct v4l2_subdev *sd, int enable)
++{
++ return 0;
++}
++
++static int ar0220_get_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++
++ if (format->pad)
++ return -EINVAL;
++
++ mf->width = priv->rect.width;
++ mf->height = priv->rect.height;
++ mf->code = AR0220_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ return 0;
++}
++
++static int ar0220_set_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++
++ mf->code = AR0220_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ if (format->which == V4L2_SUBDEV_FORMAT_TRY)
++ cfg->try_fmt = *mf;
++
++ return 0;
++}
++
++static int ar0220_enum_mbus_code(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_mbus_code_enum *code)
++{
++ if (code->pad || code->index > 0)
++ return -EINVAL;
++
++ code->code = AR0220_MEDIA_BUS_FMT;
++
++ return 0;
++}
++
++static int ar0220_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++
++ memcpy(edid->edid, priv->id, 6);
++
++ edid->edid[6] = 0xff;
++ edid->edid[7] = client->addr;
++ edid->edid[8] = AR0220_VERSION_REG >> 8;
++ edid->edid[9] = AR0220_VERSION_REG & 0xff;
++
++ return 0;
++}
++
++static int ar0220_set_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct v4l2_rect *rect = &sel->r;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
++ sel->target != V4L2_SEL_TGT_CROP)
++ return -EINVAL;
++
++ rect->left = ALIGN(rect->left, 2);
++ rect->top = ALIGN(rect->top, 2);
++ rect->width = ALIGN(rect->width, 2);
++ rect->height = ALIGN(rect->height, 2);
++
++ if ((rect->left + rect->width > AR0220_MAX_WIDTH) ||
++ (rect->top + rect->height > AR0220_MAX_HEIGHT))
++ *rect = priv->rect;
++
++ priv->rect.left = rect->left;
++ priv->rect.top = rect->top;
++ priv->rect.width = rect->width;
++ priv->rect.height = rect->height;
++
++ return 0;
++}
++
++static int ar0220_get_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
++ return -EINVAL;
++
++ switch (sel->target) {
++ case V4L2_SEL_TGT_CROP_BOUNDS:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = AR0220_MAX_WIDTH;
++ sel->r.height = AR0220_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP_DEFAULT:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = AR0220_MAX_WIDTH;
++ sel->r.height = AR0220_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP:
++ sel->r = priv->rect;
++ return 0;
++ default:
++ return -EINVAL;
++ }
++}
++
++static int ar0220_g_mbus_config(struct v4l2_subdev *sd,
++ struct v4l2_mbus_config *cfg)
++{
++ cfg->flags = V4L2_MBUS_CSI2_1_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
++ V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
++ cfg->type = V4L2_MBUS_CSI2;
++
++ return 0;
++}
++
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++static int ar0220_g_register(struct v4l2_subdev *sd,
++ struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ int ret;
++ u16 val = 0;
++
++ ret = reg16_read16(client, (u16)reg->reg, &val);
++ if (ret < 0)
++ return ret;
++
++ reg->val = val;
++ reg->size = sizeof(u16);
++
++ return 0;
++}
++
++static int ar0220_s_register(struct v4l2_subdev *sd,
++ const struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++
++ return reg16_write16(client, (u16)reg->reg, (u16)reg->val);
++}
++#endif
++
++static struct v4l2_subdev_core_ops ar0220_core_ops = {
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ .g_register = ar0220_g_register,
++ .s_register = ar0220_s_register,
++#endif
++};
++
++static int ar0220_s_ctrl(struct v4l2_ctrl *ctrl)
++{
++ struct v4l2_subdev *sd = to_sd(ctrl);
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++ int ret = -EINVAL;
++
++ if (!priv->init_complete)
++ return 0;
++
++ switch (ctrl->id) {
++ case V4L2_CID_BRIGHTNESS:
++ case V4L2_CID_CONTRAST:
++ case V4L2_CID_SATURATION:
++ case V4L2_CID_HUE:
++ case V4L2_CID_GAMMA:
++ case V4L2_CID_SHARPNESS:
++ case V4L2_CID_AUTOGAIN:
++ case V4L2_CID_GAIN:
++ case V4L2_CID_EXPOSURE:
++ case V4L2_CID_HFLIP:
++ case V4L2_CID_VFLIP:
++ break;
++ }
++
++ return ret;
++}
++
++static const struct v4l2_ctrl_ops ar0220_ctrl_ops = {
++ .s_ctrl = ar0220_s_ctrl,
++};
++
++static struct v4l2_subdev_video_ops ar0220_video_ops = {
++ .s_stream = ar0220_s_stream,
++ .g_mbus_config = ar0220_g_mbus_config,
++};
++
++static const struct v4l2_subdev_pad_ops ar0220_subdev_pad_ops = {
++ .get_edid = ar0220_get_edid,
++ .enum_mbus_code = ar0220_enum_mbus_code,
++ .get_selection = ar0220_get_selection,
++ .set_selection = ar0220_set_selection,
++ .get_fmt = ar0220_get_fmt,
++ .set_fmt = ar0220_set_fmt,
++};
++
++static struct v4l2_subdev_ops ar0220_subdev_ops = {
++ .core = &ar0220_core_ops,
++ .video = &ar0220_video_ops,
++ .pad = &ar0220_subdev_pad_ops,
++};
++
++static void ar0220_otp_id_read(struct i2c_client *client)
++{
++}
++
++static ssize_t ar0220_otp_id_show(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ struct v4l2_subdev *sd = i2c_get_clientdata(to_i2c_client(dev));
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ar0220_priv *priv = to_ar0220(client);
++
++ return snprintf(buf, 32, "%02x:%02x:%02x:%02x:%02x:%02x\n",
++ priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++}
++
++static DEVICE_ATTR(otp_id_ar0220, S_IRUGO, ar0220_otp_id_show, NULL);
++
++static int ar0220_initialize(struct i2c_client *client)
++{
++ struct ar0220_priv *priv = to_ar0220(client);
++ u16 val = 0;
++ u16 pid = 0;
++ int ret = 0;
++ int tmp_addr;
++
++ /* check and show model ID */
++ reg16_read16(client, AR0220_PID, &pid);
++
++ if (pid != AR0220_VERSION_REG) {
++ dev_dbg(&client->dev, "Product ID error %x\n", pid);
++ ret = -ENODEV;
++ goto err;
++ }
++
++ /* setup XCLK */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ /* CLK_OUT=22.5792*160*M/N/CLKDIV -> CLK_OUT=27MHz: CLKDIV=2, M=15, N=251: 22.5792*160/8*15/251=26.987MHz=CLK_OUT */
++ client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++ reg8_write(client, 0x06, 0x6f); /* Set CLKDIV and M */
++ reg8_write(client, 0x07, 0xfb); /* Set N */
++ }
++ client->addr = tmp_addr;
++
++ /* Program wizard registers */
++ ar0220_set_regs(client, ar0220_regs_wizard, ARRAY_SIZE(ar0220_regs_wizard));
++
++ /* Enable stream */
++ reg16_read16(client, 0x301a, &val); // read inital reset_register value
++ val |= (1 << 2); // Set streamOn bit
++ reg16_write16(client, 0x301a, val); // Start Streaming
++
++ /* Read OTP IDs */
++ ar0220_otp_id_read(client);
++
++ dev_info(&client->dev, "ar0220 PID %x, res %dx%d, OTP_ID %02x:%02x:%02x:%02x:%02x:%02x\n",
++ pid, AR0220_MAX_WIDTH, AR0220_MAX_HEIGHT, priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++err:
++ return ret;
++}
++
++static int ar0220_parse_dt(struct device_node *np, struct ar0220_priv *priv)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(&priv->sd);
++ int i;
++ struct device_node *endpoint = NULL, *rendpoint = NULL;
++ int tmp_addr = 0;
++
++ for (i = 0; ; i++) {
++ endpoint = of_graph_get_next_endpoint(np, endpoint);
++ if (!endpoint)
++ break;
++
++ of_node_put(endpoint);
++
++ rendpoint = of_parse_phandle(endpoint, "remote-endpoint", 0);
++ if (!rendpoint)
++ continue;
++
++ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
++ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
++ break;
++ }
++
++ if (!priv->ti9x4_addr) {
++ dev_err(&client->dev, "deserializer does not present\n");
++ return -EINVAL;
++ }
++
++ /* setup I2C translator address */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
++
++ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
++ usleep_range(2000, 2500); /* wait 2ms */
++ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
++ reg8_write(client, 0x5d, AR0220_I2C_ADDR << 1); /* Sensor native I2C address */
++
++// reg8_write(client, 0x6e, 0xa9); /* GPIO0 - reset, GPIO1 - fsin */
++ }
++ client->addr = tmp_addr;
++
++ mdelay(10);
++
++ return 0;
++}
++
++static int ar0220_probe(struct i2c_client *client,
++ const struct i2c_device_id *did)
++{
++ struct ar0220_priv *priv;
++ int ret;
++
++ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
++ if (!priv)
++ return -ENOMEM;
++
++ v4l2_i2c_subdev_init(&priv->sd, client, &ar0220_subdev_ops);
++ priv->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
++
++ priv->exposure = 0x100;
++ priv->gain = 0x100;
++ priv->autogain = 1;
++ v4l2_ctrl_handler_init(&priv->hdl, 4);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_BRIGHTNESS, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_CONTRAST, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_SATURATION, 0, 7, 1, 2);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_HUE, 0, 23, 1, 12);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_GAMMA, -128, 128, 1, 0);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_SHARPNESS, 0, 10, 1, 3);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_AUTOGAIN, 0, 1, 1, priv->autogain);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_GAIN, 0, 0xffff, 1, priv->gain);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_EXPOSURE, 0, 0xffff, 1, priv->exposure);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_HFLIP, 0, 1, 1, 1);
++ v4l2_ctrl_new_std(&priv->hdl, &ar0220_ctrl_ops,
++ V4L2_CID_VFLIP, 0, 1, 1, 0);
++ priv->sd.ctrl_handler = &priv->hdl;
++
++ ret = priv->hdl.error;
++ if (ret)
++ goto cleanup;
++
++ v4l2_ctrl_handler_setup(&priv->hdl);
++
++ priv->pad.flags = MEDIA_PAD_FL_SOURCE;
++ priv->sd.entity.flags |= MEDIA_ENT_F_CAM_SENSOR;
++ ret = media_entity_pads_init(&priv->sd.entity, 1, &priv->pad);
++ if (ret < 0)
++ goto cleanup;
++
++ ret = ar0220_parse_dt(client->dev.of_node, priv);
++ if (ret)
++ goto cleanup;
++
++ ret = ar0220_initialize(client);
++ if (ret < 0)
++ goto cleanup;
++
++ priv->rect.left = 0;
++ priv->rect.top = 0;
++ priv->rect.width = AR0220_MAX_WIDTH;
++ priv->rect.height = AR0220_MAX_HEIGHT;
++
++ ret = v4l2_async_register_subdev(&priv->sd);
++ if (ret)
++ goto cleanup;
++
++ if (device_create_file(&client->dev, &dev_attr_otp_id_ar0220) != 0) {
++ dev_err(&client->dev, "sysfs otp_id entry creation failed\n");
++ goto cleanup;
++ }
++
++ priv->init_complete = 1;
++
++ return 0;
++
++cleanup:
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++#ifdef CONFIG_SOC_CAMERA_AR0220
++ v4l_err(client, "failed to probe @ 0x%02x (%s)\n",
++ client->addr, client->adapter->name);
++#endif
++ return ret;
++}
++
++static int ar0220_remove(struct i2c_client *client)
++{
++ struct ar0220_priv *priv = i2c_get_clientdata(client);
++
++ device_remove_file(&client->dev, &dev_attr_otp_id_ar0220);
++ v4l2_async_unregister_subdev(&priv->sd);
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++
++ return 0;
++}
++
++#ifdef CONFIG_SOC_CAMERA_AR0220
++static const struct i2c_device_id ar0220_id[] = {
++ { "ar0220", 0 },
++ { }
++};
++MODULE_DEVICE_TABLE(i2c, ar0220_id);
++
++static const struct of_device_id ar0220_of_ids[] = {
++ { .compatible = "aptina,ar0220", },
++ { }
++};
++MODULE_DEVICE_TABLE(of, ar0220_of_ids);
++
++static struct i2c_driver ar0220_i2c_driver = {
++ .driver = {
++ .name = "ar0220",
++ .of_match_table = ar0220_of_ids,
++ },
++ .probe = ar0220_probe,
++ .remove = ar0220_remove,
++ .id_table = ar0220_id,
++};
++
++module_i2c_driver(ar0220_i2c_driver);
++
++MODULE_DESCRIPTION("SoC Camera driver for AR0220");
++MODULE_AUTHOR("Vladimir Barinov");
++MODULE_LICENSE("GPL");
++#endif
+diff --git a/drivers/media/i2c/soc_camera/ar0220.h b/drivers/media/i2c/soc_camera/ar0220.h
+new file mode 100644
+index 0000000..205c351
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/ar0220.h
+@@ -0,0 +1,43 @@
++/*
++ * ON Semiconductor AR0220 sensor camera wizard 1820x940@44/RCCB/MIPI
++ *
++ * Copyright (C) 2017 Cogent Embedded, Inc.
++ *
++ * 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.
++ */
++
++//#define AR0220_DISPLAY_PATTERN_FIXED
++//#define AR0220_DISPLAY_PATTERN_COLOR_BAR
++
++#define AR0220_MAX_WIDTH 1820
++#define AR0220_MAX_HEIGHT 944
++
++#define AR0220_DELAY 0xffff
++
++struct ar0220_reg {
++ u16 reg;
++ u16 val;
++};
++
++static const struct ar0220_reg ar0220_regs_wizard[] = {
++{0x301A, 0x0018}, // RESET_REGISTER
++{AR0220_DELAY, 500}, // Wait 500ms
++{0x3070, 0x0000}, // 1: Solid color test pattern,
++ // 2: Full color bar test pattern,
++ // 3: Fade to grey color bar test pattern,
++ //256: Walking 1 test pattern (12 bit)
++{0x3072, 0x0123}, // R
++{0x3074, 0x0456}, // G(GR row)
++{0x3076, 0x0abc}, // B
++{0x3078, 0x0def}, // G(GB row)
++#ifdef AR0220_DISPLAY_PATTERN_FIXED
++{0x3070, 0x0001},
++#endif
++#ifdef AR0220_DISPLAY_PATTERN_COLOR_BAR
++{0x3070, 0x0002},
++#endif
++{AR0220_DELAY, 100}, // Wait 100ms
++};
+diff --git a/drivers/media/i2c/soc_camera/imx390.c b/drivers/media/i2c/soc_camera/imx390.c
+new file mode 100644
+index 0000000..61f430d
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/imx390.c
+@@ -0,0 +1,533 @@
++/*
++ * OmniVision IMX390 sensor camera driver
++ *
++ * Copyright (C) 2018 Cogent Embedded, Inc.
++ *
++ * 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/delay.h>
++#include <linux/init.h>
++#include <linux/i2c.h>
++#include <linux/module.h>
++#include <linux/videodev2.h>
++
++#include <media/soc_camera.h>
++#include <media/v4l2-common.h>
++#include <media/v4l2-ctrls.h>
++#include <media/v4l2-of.h>
++
++#include "imx390.h"
++
++#define IMX390_I2C_ADDR 0x21
++
++#define IMX390_PID 0x0330
++#define IMX390_VER 0x0330
++#define IMX390_VERSION_REG 0x1515
++
++#define IMX390_MEDIA_BUS_FMT MEDIA_BUS_FMT_SRGGB12_1X12
++
++struct imx390_priv {
++ struct v4l2_subdev sd;
++ struct v4l2_ctrl_handler hdl;
++ struct media_pad pad;
++ struct v4l2_rect rect;
++ int init_complete;
++ u8 id[6];
++ int exposure;
++ int gain;
++ int autogain;
++ /* serializers */
++ int ti9x4_addr;
++ int ti9x3_addr;
++ int port;
++ int gpio_resetb;
++ int gpio_fsin;
++};
++
++static inline struct imx390_priv *to_imx390(const struct i2c_client *client)
++{
++ return container_of(i2c_get_clientdata(client), struct imx390_priv, sd);
++}
++
++static int imx390_set_regs(struct i2c_client *client,
++ const struct imx390_reg *regs, int nr_regs)
++{
++ int i;
++
++ for (i = 0; i < nr_regs; i++) {
++ if (regs[i].reg == IMX390_DELAY) {
++ mdelay(regs[i].val);
++ continue;
++ }
++
++ reg16_write(client, regs[i].reg, regs[i].val);
++ }
++
++ return 0;
++}
++
++static int imx390_s_stream(struct v4l2_subdev *sd, int enable)
++{
++ return 0;
++}
++
++static int imx390_get_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++
++ if (format->pad)
++ return -EINVAL;
++
++ mf->width = priv->rect.width;
++ mf->height = priv->rect.height;
++ mf->code = IMX390_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ return 0;
++}
++
++static int imx390_set_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++
++ mf->code = IMX390_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ if (format->which == V4L2_SUBDEV_FORMAT_TRY)
++ cfg->try_fmt = *mf;
++
++ return 0;
++}
++
++static int imx390_enum_mbus_code(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_mbus_code_enum *code)
++{
++ if (code->pad || code->index > 0)
++ return -EINVAL;
++
++ code->code = IMX390_MEDIA_BUS_FMT;
++
++ return 0;
++}
++
++static int imx390_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++
++ memcpy(edid->edid, priv->id, 6);
++
++ edid->edid[6] = 0xff;
++ edid->edid[7] = client->addr;
++ edid->edid[8] = IMX390_VERSION_REG >> 8;
++ edid->edid[9] = IMX390_VERSION_REG & 0xff;
++
++ return 0;
++}
++
++static int imx390_set_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct v4l2_rect *rect = &sel->r;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
++ sel->target != V4L2_SEL_TGT_CROP)
++ return -EINVAL;
++
++ rect->left = ALIGN(rect->left, 2);
++ rect->top = ALIGN(rect->top, 2);
++ rect->width = ALIGN(rect->width, 2);
++ rect->height = ALIGN(rect->height, 2);
++
++ if ((rect->left + rect->width > IMX390_MAX_WIDTH) ||
++ (rect->top + rect->height > IMX390_MAX_HEIGHT))
++ *rect = priv->rect;
++
++ priv->rect.left = rect->left;
++ priv->rect.top = rect->top;
++ priv->rect.width = rect->width;
++ priv->rect.height = rect->height;
++
++ return 0;
++}
++
++static int imx390_get_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
++ return -EINVAL;
++
++ switch (sel->target) {
++ case V4L2_SEL_TGT_CROP_BOUNDS:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = IMX390_MAX_WIDTH;
++ sel->r.height = IMX390_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP_DEFAULT:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = IMX390_MAX_WIDTH;
++ sel->r.height = IMX390_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP:
++ sel->r = priv->rect;
++ return 0;
++ default:
++ return -EINVAL;
++ }
++}
++
++static int imx390_g_mbus_config(struct v4l2_subdev *sd,
++ struct v4l2_mbus_config *cfg)
++{
++ cfg->flags = V4L2_MBUS_CSI2_1_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
++ V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
++ cfg->type = V4L2_MBUS_CSI2;
++
++ return 0;
++}
++
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++static int imx390_g_register(struct v4l2_subdev *sd,
++ struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ int ret;
++ u8 val = 0;
++
++ ret = reg16_read(client, (u16)reg->reg, &val);
++ if (ret < 0)
++ return ret;
++
++ reg->val = val;
++ reg->size = sizeof(u8);
++
++ return 0;
++}
++
++static int imx390_s_register(struct v4l2_subdev *sd,
++ const struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++
++ return reg16_write(client, (u16)reg->reg, (u8)reg->val);
++}
++#endif
++
++static struct v4l2_subdev_core_ops imx390_core_ops = {
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ .g_register = imx390_g_register,
++ .s_register = imx390_s_register,
++#endif
++};
++
++static int imx390_s_ctrl(struct v4l2_ctrl *ctrl)
++{
++ struct v4l2_subdev *sd = to_sd(ctrl);
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++ int ret = -EINVAL;
++
++ if (!priv->init_complete)
++ return 0;
++
++ switch (ctrl->id) {
++ case V4L2_CID_BRIGHTNESS:
++ case V4L2_CID_CONTRAST:
++ case V4L2_CID_SATURATION:
++ case V4L2_CID_HUE:
++ case V4L2_CID_GAMMA:
++ case V4L2_CID_SHARPNESS:
++ case V4L2_CID_AUTOGAIN:
++ case V4L2_CID_GAIN:
++ case V4L2_CID_EXPOSURE:
++ case V4L2_CID_HFLIP:
++ case V4L2_CID_VFLIP:
++ break;
++ }
++
++ return ret;
++}
++
++static const struct v4l2_ctrl_ops imx390_ctrl_ops = {
++ .s_ctrl = imx390_s_ctrl,
++};
++
++static struct v4l2_subdev_video_ops imx390_video_ops = {
++ .s_stream = imx390_s_stream,
++ .g_mbus_config = imx390_g_mbus_config,
++};
++
++static const struct v4l2_subdev_pad_ops imx390_subdev_pad_ops = {
++ .get_edid = imx390_get_edid,
++ .enum_mbus_code = imx390_enum_mbus_code,
++ .get_selection = imx390_get_selection,
++ .set_selection = imx390_set_selection,
++ .get_fmt = imx390_get_fmt,
++ .set_fmt = imx390_set_fmt,
++};
++
++static struct v4l2_subdev_ops imx390_subdev_ops = {
++ .core = &imx390_core_ops,
++ .video = &imx390_video_ops,
++ .pad = &imx390_subdev_pad_ops,
++};
++
++static void imx390_otp_id_read(struct i2c_client *client)
++{
++}
++
++static ssize_t imx390_otp_id_show(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ struct v4l2_subdev *sd = i2c_get_clientdata(to_i2c_client(dev));
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct imx390_priv *priv = to_imx390(client);
++
++ return snprintf(buf, 32, "%02x:%02x:%02x:%02x:%02x:%02x\n",
++ priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++}
++
++static DEVICE_ATTR(otp_id_imx390, S_IRUGO, imx390_otp_id_show, NULL);
++
++static int imx390_initialize(struct i2c_client *client)
++{
++ struct imx390_priv *priv = to_imx390(client);
++ u8 val = 0;
++ u16 pid;
++ int ret = 0;
++ int tmp_addr;
++
++ /* check and show model ID */
++ reg16_read(client, IMX390_PID, &val);
++ pid = val;
++ reg16_read(client, IMX390_VER, &val);
++ pid = (pid << 8) | val;
++
++ if (pid != IMX390_VERSION_REG) {
++ dev_dbg(&client->dev, "Product ID error %x\n", pid);
++ ret = -ENODEV;
++ goto err;
++ }
++
++ /* setup XCLK */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ /* CLK_OUT=22.5792*160*M/N/CLKDIV -> CLK_OUT=25MHz: CLKDIV=4, M=7, N=253: 22.5792*160/4*7/253=24.989MHz=CLK_OUT */
++ client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++ reg8_write(client, 0x06, 0x47); /* Set CLKDIV and M */
++ reg8_write(client, 0x07, 0xfd); /* Set N */
++ }
++ client->addr = tmp_addr;
++
++ /* Program wizard registers */
++ imx390_set_regs(client, imx390_regs_wizard, ARRAY_SIZE(imx390_regs_wizard));
++ /* Read OTP IDs */
++ imx390_otp_id_read(client);
++
++ dev_info(&client->dev, "imx390 PID %x, res %dx%d, OTP_ID %02x:%02x:%02x:%02x:%02x:%02x\n",
++ pid, IMX390_MAX_WIDTH, IMX390_MAX_HEIGHT, priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++err:
++ return ret;
++}
++
++static int imx390_parse_dt(struct device_node *np, struct imx390_priv *priv)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(&priv->sd);
++ int i;
++ struct device_node *endpoint = NULL, *rendpoint = NULL;
++ int tmp_addr = 0;
++
++ for (i = 0; ; i++) {
++ endpoint = of_graph_get_next_endpoint(np, endpoint);
++ if (!endpoint)
++ break;
++
++ of_node_put(endpoint);
++
++ rendpoint = of_parse_phandle(endpoint, "remote-endpoint", 0);
++ if (!rendpoint)
++ continue;
++
++ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
++ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
++ break;
++ }
++
++ if (!priv->ti9x4_addr) {
++ dev_err(&client->dev, "deserializer does not present\n");
++ return -EINVAL;
++ }
++
++ /* setup I2C translator address */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
++ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
++ usleep_range(2000, 2500); /* wait 2ms */
++ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
++ reg8_write(client, 0x5d, IMX390_I2C_ADDR << 1); /* Sensor native I2C address */
++// reg8_write(client, 0x6e, 0xa9); /* GPIO0 - reset, GPIO1 - fsin */
++ }
++ client->addr = tmp_addr;
++
++ mdelay(10);
++
++ return 0;
++}
++
++static int imx390_probe(struct i2c_client *client,
++ const struct i2c_device_id *did)
++{
++ struct imx390_priv *priv;
++ int ret;
++
++ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
++ if (!priv)
++ return -ENOMEM;
++
++ v4l2_i2c_subdev_init(&priv->sd, client, &imx390_subdev_ops);
++ priv->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
++
++ priv->exposure = 0x100;
++ priv->gain = 0x100;
++ priv->autogain = 1;
++ v4l2_ctrl_handler_init(&priv->hdl, 4);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_BRIGHTNESS, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_CONTRAST, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_SATURATION, 0, 7, 1, 2);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_HUE, 0, 23, 1, 12);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_GAMMA, -128, 128, 1, 0);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_SHARPNESS, 0, 10, 1, 3);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_AUTOGAIN, 0, 1, 1, priv->autogain);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_GAIN, 0, 0xffff, 1, priv->gain);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_EXPOSURE, 0, 0xffff, 1, priv->exposure);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_HFLIP, 0, 1, 1, 1);
++ v4l2_ctrl_new_std(&priv->hdl, &imx390_ctrl_ops,
++ V4L2_CID_VFLIP, 0, 1, 1, 0);
++ priv->sd.ctrl_handler = &priv->hdl;
++
++ ret = priv->hdl.error;
++ if (ret)
++ goto cleanup;
++
++ v4l2_ctrl_handler_setup(&priv->hdl);
++
++ priv->pad.flags = MEDIA_PAD_FL_SOURCE;
++ priv->sd.entity.flags |= MEDIA_ENT_F_CAM_SENSOR;
++ ret = media_entity_pads_init(&priv->sd.entity, 1, &priv->pad);
++ if (ret < 0)
++ goto cleanup;
++
++ ret = imx390_parse_dt(client->dev.of_node, priv);
++ if (ret)
++ goto cleanup;
++
++ ret = imx390_initialize(client);
++ if (ret < 0)
++ goto cleanup;
++
++ priv->rect.left = 0;
++ priv->rect.top = 0;
++ priv->rect.width = IMX390_MAX_WIDTH;
++ priv->rect.height = IMX390_MAX_HEIGHT;
++
++ ret = v4l2_async_register_subdev(&priv->sd);
++ if (ret)
++ goto cleanup;
++
++ if (device_create_file(&client->dev, &dev_attr_otp_id_imx390) != 0) {
++ dev_err(&client->dev, "sysfs otp_id entry creation failed\n");
++ goto cleanup;
++ }
++
++ priv->init_complete = 1;
++
++ return 0;
++
++cleanup:
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++#ifdef CONFIG_SOC_CAMERA_IMX390
++ v4l_err(client, "failed to probe @ 0x%02x (%s)\n",
++ client->addr, client->adapter->name);
++#endif
++ return ret;
++}
++
++static int imx390_remove(struct i2c_client *client)
++{
++ struct imx390_priv *priv = i2c_get_clientdata(client);
++
++ device_remove_file(&client->dev, &dev_attr_otp_id_imx390);
++ v4l2_async_unregister_subdev(&priv->sd);
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++
++ return 0;
++}
++
++#ifdef CONFIG_SOC_CAMERA_IMX390
++static const struct i2c_device_id imx390_id[] = {
++ { "imx390", 0 },
++ { }
++};
++MODULE_DEVICE_TABLE(i2c, imx390_id);
++
++static const struct of_device_id imx390_of_ids[] = {
++ { .compatible = "sony,imx390", },
++ { }
++};
++MODULE_DEVICE_TABLE(of, imx390_of_ids);
++
++static struct i2c_driver imx390_i2c_driver = {
++ .driver = {
++ .name = "imx390",
++ .of_match_table = imx390_of_ids,
++ },
++ .probe = imx390_probe,
++ .remove = imx390_remove,
++ .id_table = imx390_id,
++};
++
++module_i2c_driver(imx390_i2c_driver);
++
++MODULE_DESCRIPTION("SoC Camera driver for IMX390");
++MODULE_AUTHOR("Vladimir Barinov");
++MODULE_LICENSE("GPL");
++#endif
+diff --git a/drivers/media/i2c/soc_camera/imx390.h b/drivers/media/i2c/soc_camera/imx390.h
+new file mode 100644
+index 0000000..4217cd9
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/imx390.h
+@@ -0,0 +1,3817 @@
++/*
++ * OmniVision IMX390 sensor camera wizard 1920x1080@30/BGGR/MIPI
++ *
++ * Copyright (C) 2018 Cogent Embedded, Inc.
++ *
++ * 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.
++ */
++
++//#define IMX390_DISPLAY_PATTERN_COLOR_BAR
++
++#define IMX390_MAX_WIDTH 1920
++#define IMX390_MAX_HEIGHT 1080
++
++#define IMX390_DELAY 0xffff
++#define IMX390_DT 0x2c /* MIPI Data Type RAW12 */
++
++struct imx390_reg {
++ u16 reg;
++ u8 val;
++};
++
++/* wizard: MIPI 1920x1080 RAW12 Linear 30fps 700Mbps */
++static const struct imx390_reg imx390_regs_wizard[] = {
++{0x000C, 0xF2},
++{0x000D, 0x02},
++{0x000E, 0x00},
++{0x0010, 0xF2},
++{0x0011, 0x02},
++{0x0012, 0x00},
++{0x0018, 0x15},
++{0x0019, 0x00},
++{0x001A, 0x0C},
++{0x001B, 0x00},
++{0x0038, 0x00},
++{0x003C, 0x00},
++{0x003D, 0x00},
++{0x003E, 0x00},
++{0x0040, 0x00},
++{0x0041, 0x00},
++{0x0042, 0x00},
++{0x0044, 0x00},
++{0x0045, 0x00},
++{0x0046, 0x00},
++{0x0048, 0x00},
++{0x0049, 0x00},
++{0x004A, 0x00},
++{0x004C, 0x00},
++{0x004D, 0x00},
++{0x004E, 0x00},
++{0x0050, 0x00},
++{0x0051, 0x00},
++{0x0052, 0x00},
++{0x0054, 0x00},
++{0x0055, 0x00},
++{0x0056, 0x00},
++{0x0058, 0x00},
++{0x0059, 0x00},
++{0x005A, 0x00},
++{0x005C, 0x00},
++{0x005D, 0x00},
++{0x005E, 0x00},
++{0x0060, 0x00},
++{0x0061, 0x00},
++{0x0062, 0x00},
++{0x0064, 0x00},
++{0x0065, 0x00},
++{0x0066, 0x00},
++{0x0068, 0x00},
++{0x0069, 0x00},
++{0x006A, 0x00},
++{0x0078, 0x00},
++{0x007C, 0x00},
++{0x007D, 0x00},
++{0x0080, 0x00},
++{0x0081, 0x00},
++{0x00F4, 0x1C},
++{0x00F5, 0xF8},
++{0x00F6, 0x01},
++{0x00F8, 0x03},
++{0x00F9, 0x00},
++{0x00FA, 0x00},
++{0x00FB, 0x00},
++{0x0114, 0x00},
++{0x0115, 0x01},
++{0x0118, 0x20},
++{0x0119, 0x03},
++{0x011A, 0x00},
++{0x011B, 0x41},
++{0x011C, 0x80},
++{0x011D, 0x00},
++{0x0120, 0x20},
++{0x0121, 0x00},
++{0x0122, 0x00},
++{0x0123, 0x44},
++{0x0124, 0x00},
++{0x0125, 0x01},
++{0x0128, 0xAC},
++{0x0129, 0x0D},
++{0x012A, 0x00},
++{0x012B, 0xA4},
++{0x012C, 0x00},
++{0x012D, 0x01},
++{0x0130, 0xC4},
++{0x0131, 0x09},
++{0x0132, 0x00},
++{0x0133, 0xDA},
++//{0x013A, ,3},
++{0x013B, 0x01},
++//{0x013C, ,3},
++//{0x013D, ,3},
++//{0x013E, ,3},
++//{0x0140, ,3},
++//{0x0141, ,3},
++//{0x0142, ,3},
++//{0x0144, ,3},
++//{0x0145, ,3},
++//{0x0146, ,3},
++//{0x0148, ,3},
++//{0x0149, ,3},
++//{0x014A, ,3},
++//{0x014C, ,3},
++//{0x014D, ,3},
++//{0x014E, ,3},
++//{0x0150, ,3},
++//{0x0151, ,3},
++//{0x0152, ,3},
++//{0x0154, ,3},
++//{0x0155, ,3},
++//{0x0156, ,3},
++//{0x0158, ,3},
++//{0x0159, ,3},
++//{0x015A, ,3},
++//{0x015C, ,3},
++//{0x015D, ,3},
++//{0x015E, ,3},
++//{0x0160, ,3},
++//{0x0161, ,3},
++//{0x0162, ,3},
++//{0x0164, ,3},
++//{0x0165, ,3},
++//{0x0166, ,3},
++//{0x0168, ,3},
++//{0x0169, ,3},
++//{0x016A, ,3},
++//{0x016C, ,3},
++//{0x016D, ,3},
++//{0x016E, ,3},
++//{0x0170, ,3},
++//{0x0171, ,3},
++//{0x0172, ,3},
++//{0x0174, ,3},
++//{0x0175, ,3},
++//{0x0176, ,3},
++//{0x0178, ,3},
++//{0x0179, ,3},
++//{0x017A, ,3},
++//{0x017C, ,3},
++//{0x017D, ,3},
++//{0x017E, ,3},
++//{0x0180, ,3},
++//{0x0181, ,3},
++//{0x0182, ,3},
++//{0x0184, ,3},
++//{0x0185, ,3},
++//{0x0186, ,3},
++//{0x0188, ,3},
++//{0x0189, ,3},
++//{0x018A, ,3},
++//{0x018C, ,3},
++//{0x018D, ,3},
++//{0x018E, ,3},
++//{0x0190, ,3},
++//{0x0191, ,3},
++//{0x0192, ,3},
++//{0x0194, ,3},
++//{0x0195, ,3},
++//{0x0196, ,3},
++//{0x0198, ,3},
++//{0x0199, ,3},
++//{0x019A, ,3},
++//{0x019B, ,3},
++//{0x019C, ,3},
++//{0x019D, ,3},
++//{0x019E, ,3},
++//{0x019F, ,3},
++//{0x01A0, ,3},
++//{0x01A1, ,3},
++//{0x01A2, ,3},
++//{0x01A3, ,3},
++//{0x01A4, ,3},
++//{0x01A5, ,3},
++//{0x01A6, ,3},
++//{0x01A7, ,3},
++//{0x01A8, ,3},
++//{0x01A9, ,3},
++//{0x01AA, ,3},
++//{0x01AB, ,3},
++//{0x01AC, ,3},
++//{0x01AD, ,3},
++//{0x01AE, ,3},
++//{0x01AF, ,3},
++//{0x01B0, ,3},
++//{0x01B1, ,3},
++//{0x01B2, ,3},
++//{0x01B3, ,3},
++//{0x01B4, ,3},
++//{0x01B5, ,3},
++//{0x01B6, ,3},
++//{0x01B7, ,3},
++//{0x01B8, ,3},
++//{0x01B9, ,3},
++//{0x01BA, ,3},
++//{0x01BB, ,3},
++//{0x01BC, ,3},
++//{0x01BD, ,3},
++//{0x01BE, ,3},
++//{0x01BF, ,3},
++//{0x01C0, ,3},
++//{0x01C1, ,3},
++//{0x01C2, ,3},
++//{0x01C3, ,3},
++{0x01C4, 0x00},
++{0x01C5, 0x00},
++{0x01CC, 0x01},
++{0x01D0, 0x09},
++{0x01D4, 0x01},
++{0x0232, 0x7E},
++{0x0233, 0x00},
++{0x0390, 0x00},
++{0x0391, 0x00},
++{0x0392, 0x00},
++#ifdef IMX390_DISPLAY_PATTERN_COLOR_BAR
++{0x01DB, 0x32},
++{0x03C0, 0x02},
++#else
++{0x03C0, 0x00},
++#endif
++{0x2000, 0x55},
++{0x2001, 0x55},
++{0x2002, 0x55},
++{0x2003, 0x05},
++{0x2004, 0x02},
++{0x2008, 0x65},
++{0x2009, 0x04},
++{0x200A, 0x00},
++{0x200C, 0x30},
++{0x200D, 0x11},
++{0x2010, 0x04},
++{0x2014, 0x01},
++{0x2018, 0x02},
++{0x2019, 0x04},
++{0x201A, 0x00},
++{0x201C, 0x21},
++{0x201D, 0x11},
++{0x201E, 0x00},
++{0x201F, 0x00},
++{0x2020, 0xBC},
++{0x2021, 0x00},
++{0x2022, 0x7F},
++{0x2023, 0x00},
++{0x2024, 0xBA},
++{0x2025, 0x00},
++{0x2026, 0x81},
++{0x2027, 0x00},
++{0x2028, 0x7D},
++{0x2029, 0x90},
++{0x202A, 0x05},
++{0x202C, 0xFC},
++{0x202D, 0x02},
++{0x202E, 0x25},
++{0x202F, 0x03},
++{0x2030, 0x05},
++{0x2031, 0x02},
++{0x2032, 0xCA},
++{0x2033, 0x02},
++{0x2034, 0xFC},
++{0x2035, 0x02},
++{0x2036, 0x25},
++{0x2037, 0x03},
++{0x2038, 0x25},
++{0x2039, 0x97},
++{0x203A, 0xEC},
++{0x203B, 0x01},
++{0x203C, 0xF5},
++{0x203D, 0x8E},
++{0x203E, 0x0C},
++{0x203F, 0x2D},
++{0x2040, 0x69},
++{0x2041, 0x01},
++{0x2042, 0x8E},
++{0x2043, 0x01},
++{0x2044, 0x0C},
++{0x2045, 0x02},
++{0x2046, 0x31},
++{0x2047, 0x02},
++{0x2048, 0x6A},
++{0x2049, 0x01},
++{0x204A, 0x8E},
++{0x204B, 0x01},
++{0x204C, 0x0D},
++{0x204D, 0x02},
++{0x204E, 0x31},
++{0x204F, 0x02},
++{0x2050, 0x7B},
++{0x2051, 0x00},
++{0x2052, 0x7D},
++{0x2053, 0x00},
++{0x2054, 0x95},
++{0x2055, 0x00},
++{0x2056, 0x97},
++{0x2057, 0x00},
++{0x2058, 0xAD},
++{0x2059, 0x00},
++{0x205A, 0xAF},
++{0x205B, 0x00},
++{0x205C, 0x92},
++{0x205D, 0x00},
++{0x205E, 0x94},
++{0x205F, 0x00},
++{0x2060, 0x8E},
++{0x2061, 0x00},
++{0x2062, 0x90},
++{0x2063, 0x00},
++{0x2064, 0xB1},
++{0x2065, 0x00},
++{0x2066, 0xB3},
++{0x2067, 0x00},
++{0x2068, 0x08},
++{0x2069, 0x00},
++{0x206A, 0x04},
++{0x206B, 0x00},
++{0x206C, 0x84},
++{0x206D, 0x00},
++{0x206E, 0x80},
++{0x206F, 0x00},
++{0x2070, 0x04},
++{0x2071, 0x00},
++{0x2072, 0x46},
++{0x2073, 0x00},
++{0x2074, 0xE9},
++{0x2075, 0x01},
++{0x2076, 0x74},
++{0x2077, 0x02},
++{0x2078, 0x80},
++{0x2079, 0x00},
++{0x207A, 0xC1},
++{0x207B, 0x00},
++{0x207C, 0xFF},
++{0x207D, 0x03},
++{0x207E, 0xFF},
++{0x207F, 0x03},
++{0x2080, 0x78},
++{0x2081, 0x00},
++{0x2082, 0x6A},
++{0x2083, 0x01},
++{0x2084, 0xE4},
++{0x2085, 0x01},
++{0x2086, 0x2B},
++{0x2087, 0x03},
++{0x2088, 0x00},
++{0x2089, 0x00},
++{0x208A, 0xFF},
++{0x208B, 0x03},
++{0x208C, 0xFF},
++{0x208D, 0x03},
++{0x208E, 0xFF},
++{0x208F, 0x03},
++{0x2090, 0x7D},
++{0x2091, 0x00},
++{0x2092, 0x62},
++{0x2093, 0x01},
++{0x2094, 0xE9},
++{0x2095, 0x01},
++{0x2096, 0x00},
++{0x2097, 0x00},
++{0x2098, 0x7C},
++{0x2099, 0x00},
++{0x209A, 0x21},
++{0x209B, 0x03},
++{0x209C, 0xE9},
++{0x209D, 0x01},
++{0x209E, 0x21},
++{0x209F, 0x03},
++{0x20A0, 0xFF},
++{0x20A1, 0x03},
++{0x20A2, 0xFF},
++{0x20A3, 0x03},
++{0x20A4, 0xFF},
++{0x20A5, 0x03},
++{0x20A6, 0xFF},
++{0x20A7, 0x03},
++{0x20A8, 0xFF},
++{0x20A9, 0x03},
++{0x20AA, 0xFF},
++{0x20AB, 0x03},
++{0x20AC, 0xFF},
++{0x20AD, 0x03},
++{0x20AE, 0xFF},
++{0x20AF, 0x03},
++{0x20B0, 0xFF},
++{0x20B1, 0x03},
++{0x20B2, 0xFF},
++{0x20B3, 0x03},
++{0x20B4, 0x87},
++{0x20B5, 0xCC},
++{0x20B6, 0x87},
++{0x20B7, 0x08},
++{0x20B8, 0xF4},
++{0x20B9, 0xA5},
++{0x20BA, 0x07},
++{0x20BC, 0x1F},
++{0x20BD, 0x01},
++{0x20BE, 0xF6},
++{0x20BF, 0x00},
++{0x20C0, 0x90},
++{0x20C1, 0x01},
++{0x20C2, 0x67},
++{0x20C3, 0x01},
++{0x20C4, 0xFF},
++{0x20C5, 0x03},
++{0x20C6, 0xFF},
++{0x20C7, 0x03},
++{0x20C8, 0x33},
++{0x20C9, 0x02},
++{0x20CA, 0x0A},
++{0x20CB, 0x02},
++{0x20CC, 0x7F},
++{0x20CD, 0x00},
++{0x20CE, 0xD2},
++{0x20CF, 0x00},
++{0x20D0, 0x81},
++{0x20D1, 0x00},
++{0x20D2, 0x87},
++{0x20D3, 0x00},
++{0x20D4, 0x09},
++{0x20D5, 0x00},
++{0x20D8, 0x7F},
++{0x20D9, 0x00},
++{0x20DA, 0x62},
++{0x20DB, 0x01},
++{0x20DC, 0x7F},
++{0x20DD, 0x00},
++{0x20DE, 0x62},
++{0x20DF, 0x01},
++{0x20E0, 0x65},
++{0x20E1, 0x00},
++{0x20E2, 0x75},
++{0x20E3, 0x00},
++{0x20E4, 0xE0},
++{0x20E5, 0x00},
++{0x20E6, 0xF0},
++{0x20E7, 0x00},
++{0x20E8, 0x4C},
++{0x20E9, 0x01},
++{0x20EA, 0x5C},
++{0x20EB, 0x01},
++{0x20EC, 0xD1},
++{0x20ED, 0x01},
++{0x20EE, 0xE1},
++{0x20EF, 0x01},
++{0x20F0, 0x93},
++{0x20F1, 0x02},
++{0x20F2, 0xA3},
++{0x20F3, 0x02},
++{0x20F4, 0x0D},
++{0x20F5, 0x03},
++{0x20F6, 0x1D},
++{0x20F7, 0x03},
++{0x20F8, 0x57},
++{0x20F9, 0x00},
++{0x20FA, 0x7B},
++{0x20FB, 0x00},
++{0x20FC, 0xD2},
++{0x20FD, 0x00},
++{0x20FE, 0xF6},
++{0x20FF, 0x00},
++{0x2100, 0x3E},
++{0x2101, 0x01},
++{0x2102, 0x60},
++{0x2103, 0x01},
++{0x2104, 0xC3},
++{0x2105, 0x01},
++{0x2106, 0xE5},
++{0x2107, 0x01},
++{0x2108, 0x85},
++{0x2109, 0x02},
++{0x210A, 0xA9},
++{0x210B, 0x02},
++{0x210C, 0xFF},
++{0x210D, 0x02},
++{0x210E, 0x21},
++{0x210F, 0x03},
++{0x2110, 0xFF},
++{0x2111, 0x03},
++{0x2112, 0x00},
++{0x2113, 0x00},
++{0x2114, 0xFF},
++{0x2115, 0x03},
++{0x2116, 0xFF},
++{0x2117, 0x03},
++{0x2118, 0xFF},
++{0x2119, 0x03},
++{0x211A, 0xFF},
++{0x211B, 0x03},
++{0x211C, 0xFF},
++{0x211D, 0x03},
++{0x211E, 0xFF},
++{0x211F, 0x03},
++{0x2120, 0xFF},
++{0x2121, 0x03},
++{0x2122, 0xFF},
++{0x2123, 0x03},
++{0x2124, 0xFF},
++{0x2125, 0x03},
++{0x2126, 0xFF},
++{0x2127, 0x03},
++{0x2128, 0x7D},
++{0x2129, 0x90},
++{0x212A, 0xD5},
++{0x212B, 0x07},
++{0x212C, 0x64},
++{0x212D, 0x01},
++{0x2130, 0x5F},
++{0x2131, 0x7D},
++{0x2132, 0x05},
++{0x2134, 0x78},
++{0x2135, 0x00},
++{0x2136, 0x76},
++{0x2137, 0x00},
++{0x2138, 0xF3},
++{0x2139, 0x00},
++{0x213A, 0xF1},
++{0x213B, 0x00},
++{0x213C, 0xA6},
++{0x213D, 0x02},
++{0x213E, 0xA4},
++{0x213F, 0x02},
++{0x2140, 0x7D},
++{0x2141, 0x00},
++{0x2142, 0x8D},
++{0x2143, 0x00},
++{0x2144, 0xA1},
++{0x2145, 0x01},
++{0x2146, 0xB1},
++{0x2147, 0x01},
++{0x2148, 0xAB},
++{0x2149, 0x02},
++{0x214A, 0xBB},
++{0x214B, 0x02},
++{0x214C, 0x17},
++{0x214D, 0x5C},
++{0x214E, 0x00},
++{0x2150, 0x00},
++{0x2151, 0x00},
++{0x2152, 0xF8},
++{0x2153, 0x00},
++{0x2154, 0xBE},
++{0x2155, 0x00},
++{0x2156, 0x7D},
++{0x2157, 0x00},
++{0x2158, 0x25},
++{0x2159, 0x00},
++{0x215A, 0x7D},
++{0x215B, 0x00},
++{0x215C, 0x62},
++{0x215D, 0x01},
++{0x215E, 0xFF},
++{0x215F, 0x03},
++{0x2160, 0x26},
++{0x2161, 0x00},
++{0x2162, 0x7D},
++{0x2163, 0x00},
++{0x2164, 0x63},
++{0x2165, 0x01},
++{0x2166, 0xFF},
++{0x2167, 0x03},
++{0x2168, 0xCB},
++{0x2169, 0x02},
++{0x216A, 0xCF},
++{0x216B, 0x02},
++{0x216C, 0xFF},
++{0x216D, 0x03},
++{0x216E, 0xFF},
++{0x216F, 0x03},
++{0x2170, 0xFF},
++{0x2171, 0x03},
++{0x2172, 0xFF},
++{0x2173, 0x03},
++{0x2174, 0xFF},
++{0x2175, 0x03},
++{0x2176, 0xFF},
++{0x2177, 0x03},
++{0x2178, 0x7E},
++{0x2179, 0x00},
++{0x217A, 0xBD},
++{0x217B, 0x00},
++{0x217C, 0xEC},
++{0x217D, 0x01},
++{0x217E, 0x7B},
++{0x217F, 0x02},
++{0x2180, 0xD1},
++{0x2181, 0x02},
++{0x2182, 0x25},
++{0x2183, 0x03},
++{0x2184, 0x7F},
++{0x2185, 0x00},
++{0x2186, 0xBD},
++{0x2187, 0x00},
++{0x2188, 0xED},
++{0x2189, 0x01},
++{0x218A, 0x7B},
++{0x218B, 0x02},
++{0x218C, 0xD2},
++{0x218D, 0x02},
++{0x218E, 0x25},
++{0x218F, 0x03},
++{0x2190, 0xFF},
++{0x2191, 0x03},
++{0x2192, 0xFF},
++{0x2193, 0x03},
++{0x2194, 0xE9},
++{0x2195, 0x01},
++{0x2196, 0x21},
++{0x2197, 0x03},
++{0x2198, 0x17},
++{0x2199, 0xFC},
++{0x219A, 0x7F},
++{0x219B, 0x01},
++{0x219C, 0xFF},
++{0x219D, 0x03},
++{0x21A0, 0x1B},
++{0x21A1, 0x1B},
++{0x21A2, 0x1B},
++{0x21A3, 0x1B},
++{0x21A4, 0x2E},
++{0x21A5, 0x80},
++{0x21A6, 0x00},
++{0x21A8, 0x04},
++{0x21A9, 0x98},
++{0x21AA, 0x60},
++{0x21AB, 0x03},
++{0x21AC, 0x7F},
++{0x21AD, 0x80},
++{0x21AE, 0x09},
++{0x21B0, 0x1C},
++{0x21B1, 0x00},
++{0x21B2, 0xA0},
++{0x21B3, 0x00},
++{0x21B4, 0x0C},
++{0x21B5, 0x00},
++{0x21B6, 0x2D},
++{0x21B7, 0x00},
++{0x21B8, 0x20},
++{0x21B9, 0x00},
++{0x21BA, 0x02},
++{0x21BB, 0x00},
++{0x21BC, 0xCC},
++{0x21BD, 0x00},
++{0x21BE, 0x4A},
++{0x21BF, 0x00},
++{0x21C0, 0xD0},
++{0x21C1, 0x00},
++{0x21C2, 0x44},
++{0x21C3, 0x00},
++{0x21C4, 0x00},
++{0x21C5, 0xE0},
++{0x21C6, 0x00},
++{0x21C8, 0x11},
++{0x21C9, 0x00},
++{0x21CA, 0x02},
++{0x21CC, 0x08},
++{0x21CD, 0xC0},
++{0x21CE, 0x0C},
++{0x21D0, 0x44},
++{0x21D1, 0x00},
++{0x21D2, 0x02},
++{0x21D4, 0x02},
++{0x21D5, 0x20},
++{0x21D6, 0x2C},
++{0x21D8, 0xFE},
++{0x21D9, 0x9D},
++{0x21DA, 0xDF},
++{0x21DB, 0x03},
++{0x21DC, 0x62},
++{0x21DD, 0x01},
++{0x21DE, 0x7F},
++{0x21DF, 0x00},
++{0x21E0, 0xB7},
++{0x21E1, 0x01},
++{0x21E2, 0xB5},
++{0x21E3, 0x01},
++{0x21E4, 0xC1},
++{0x21E5, 0x02},
++{0x21E6, 0xBF},
++{0x21E7, 0x02},
++{0x21E8, 0xB3},
++{0x21E9, 0x0D},
++{0x21EA, 0x00},
++{0x21EB, 0x04},
++#if 1
++{0x21EC, 0x90},
++{0x21ED, 0x07},
++{0x21EE, 0x58},
++{0x21EF, 0x04},
++#else
++{0x21EC, 0x80},
++{0x21ED, 0x07},
++{0x21EE, 0x38},
++{0x21EF, 0x04},
++#endif
++{0x21F0, 0x54},
++{0x21F1, 0x04},
++{0x21F4, 0x02},
++{0x21F5, 0x00},
++{0x21F6, 0x00},
++{0x21F8, 0x3C},
++{0x21F9, 0x00},
++{0x21FC, 0x28},
++{0x21FD, 0x00},
++{0x21FE, 0x3C},
++{0x21FF, 0x00},
++{0x2200, 0x00},
++{0x2204, 0x4C},
++{0x2205, 0x04},
++{0x2206, 0x65},
++{0x2207, 0x04},
++{0x2208, 0x0A},
++{0x2209, 0x00},
++{0x220C, 0x47},
++{0x220D, 0x00},
++{0x220E, 0x1F},
++{0x220F, 0x00},
++{0x2210, 0x17},
++{0x2211, 0x00},
++{0x2212, 0x0F},
++{0x2213, 0x00},
++{0x2214, 0x17},
++{0x2215, 0x00},
++{0x2216, 0x47},
++{0x2217, 0x00},
++{0x2218, 0x0F},
++{0x2219, 0x00},
++{0x221A, 0x0F},
++{0x221B, 0x00},
++{0x221C, 0x03},
++{0x2220, 0x20},
++{0x2221, 0x20},
++{0x2222, 0x22},
++{0x2223, 0x02},
++{0x2224, 0xA7},
++{0x2225, 0xAA},
++{0x2226, 0x80},
++{0x2227, 0x08},
++{0x2228, 0x01},
++{0x22B2, 0x92},
++{0x22B4, 0x20},
++{0x22B5, 0x00},
++{0x22B6, 0x20},
++{0x22B7, 0x00},
++{0x22B8, 0x20},
++{0x22B9, 0x00},
++{0x22BA, 0x20},
++{0x22BB, 0x00},
++{0x22BC, 0x20},
++{0x22BD, 0x00},
++{0x22BE, 0x20},
++{0x22BF, 0x00},
++{0x22C0, 0x20},
++{0x22C1, 0x00},
++{0x22C2, 0x20},
++{0x22C3, 0x00},
++{0x22C4, 0x20},
++{0x22C5, 0x00},
++{0x22C6, 0x20},
++{0x22C7, 0x00},
++{0x22C8, 0x20},
++{0x22C9, 0x00},
++{0x22CA, 0x20},
++{0x22CB, 0x00},
++{0x22CC, 0x20},
++{0x22CD, 0x00},
++{0x22CE, 0x20},
++{0x22CF, 0x00},
++{0x22DA, 0x00},
++{0x2308, 0x01},
++{0x2311, 0x09},
++{0x2318, 0x40},
++{0x2319, 0xCD},
++{0x231A, 0x54},
++{0x2324, 0x20},
++{0x2325, 0x00},
++{0x2328, 0x00},
++{0x2354, 0x0C},
++{0x23C0, 0x5D},
++{0x244C, 0x00},
++{0x244D, 0x02},
++{0x244E, 0x54},
++{0x244F, 0x02},
++{0x24A0, 0x00},
++{0x24DA, 0x6F},
++{0x24DB, 0x00},
++{0x24DC, 0x62},
++{0x24DD, 0x01},
++{0x24EA, 0x32},
++{0x24EB, 0x00},
++{0x24EC, 0xDC},
++{0x24ED, 0x00},
++{0x24FA, 0x32},
++{0x24FB, 0x00},
++{0x24FC, 0xDD},
++{0x24FD, 0x00},
++{0x254A, 0x15},
++{0x254B, 0x01},
++{0x255A, 0x15},
++{0x255B, 0x01},
++{0x2560, 0x01},
++{0x2561, 0x00},
++{0x2562, 0x2A},
++{0x2563, 0x00},
++{0x2564, 0xF8},
++{0x2565, 0x00},
++{0x2566, 0x15},
++{0x2567, 0x01},
++{0x2568, 0x0C},
++{0x2569, 0x02},
++{0x256A, 0x31},
++{0x256B, 0x02},
++{0x2578, 0x90},
++{0x2579, 0x01},
++{0x257A, 0x92},
++{0x257B, 0x01},
++{0x257C, 0xB8},
++{0x257D, 0x02},
++{0x257E, 0xBA},
++{0x257F, 0x02},
++{0x2584, 0x90},
++{0x2585, 0x01},
++{0x2586, 0x92},
++{0x2587, 0x01},
++{0x2588, 0xB8},
++{0x2589, 0x02},
++{0x258A, 0xBA},
++{0x258B, 0x02},
++{0x26B8, 0x10},
++{0x26B9, 0x00},
++{0x26BA, 0x33},
++{0x26BB, 0x00},
++{0x26BC, 0x89},
++{0x26BD, 0x00},
++{0x26BE, 0xB0},
++{0x26BF, 0x00},
++{0x26C4, 0x4E},
++{0x26C5, 0x00},
++{0x26C8, 0xC9},
++{0x26C9, 0x00},
++{0x26CC, 0x35},
++{0x26CD, 0x01},
++{0x26D0, 0xBA},
++{0x26D1, 0x01},
++{0x26D4, 0x7C},
++{0x26D5, 0x02},
++{0x26D8, 0xF6},
++{0x26D9, 0x02},
++{0x26DE, 0x51},
++{0x26DF, 0x00},
++{0x26E0, 0x7F},
++{0x26E1, 0x00},
++{0x26E2, 0xCC},
++{0x26E3, 0x00},
++{0x26E4, 0xF8},
++{0x26E5, 0x00},
++{0x26E6, 0x38},
++{0x26E7, 0x01},
++{0x26E8, 0x65},
++{0x26E9, 0x01},
++{0x26EA, 0xBD},
++{0x26EB, 0x01},
++{0x26EE, 0x7F},
++{0x26EF, 0x02},
++{0x26F0, 0xAB},
++{0x26F1, 0x02},
++{0x26F2, 0xF9},
++{0x26F3, 0x02},
++{0x2722, 0x59},
++{0x2723, 0x02},
++{0x2938, 0x55},
++{0x2939, 0x00},
++{0x293A, 0x17},
++{0x293B, 0x00},
++{0x293C, 0xD0},
++{0x293D, 0x00},
++{0x293E, 0x91},
++{0x293F, 0x00},
++{0x2940, 0x3C},
++{0x2941, 0x01},
++{0x2942, 0x0C},
++{0x2943, 0x01},
++{0x2944, 0xC1},
++{0x2945, 0x01},
++{0x2946, 0x76},
++{0x2947, 0x01},
++{0x2948, 0x83},
++{0x2949, 0x02},
++{0x294A, 0xFB},
++{0x294B, 0x01},
++{0x294C, 0xFD},
++{0x294D, 0x02},
++{0x294E, 0xBF},
++{0x294F, 0x02},
++{0x2A06, 0xFF},
++{0x2A07, 0x03},
++{0x2A20, 0x00},
++{0x2A21, 0x00},
++{0x2A22, 0x7D},
++{0x2A23, 0x00},
++{0x2B11, 0x19},
++{0x2B13, 0x15},
++{0x2B14, 0x14},
++{0x2B15, 0x13},
++{0x2B16, 0x12},
++{0x2B17, 0x11},
++{0x2B18, 0x10},
++{0x2B19, 0x0F},
++{0x2B1A, 0x0E},
++{0x2B1B, 0x0D},
++{0x2B1C, 0x0C},
++{0x2B1D, 0x0B},
++{0x2B1E, 0x0A},
++{0x2B1F, 0x09},
++{0x2B20, 0x08},
++{0x2B21, 0x07},
++{0x2B22, 0x06},
++{0x2B23, 0x05},
++{0x2B24, 0x04},
++{0x2B25, 0x03},
++{0x2B26, 0x03},
++{0x2B38, 0x01},
++{0x2B45, 0xE3},
++{0x2B50, 0x01},
++{0x2B51, 0x00},
++//{0x2B62, ,3},
++{0x2B6D, 0x47},
++{0x2B70, 0x02},
++{0x2B71, 0x02},
++{0x2B72, 0x02},
++{0x2B7F, 0x7F},
++{0x2B80, 0x94},
++{0x2B81, 0x06},
++{0x2B87, 0x1B},
++{0x2B88, 0x1B},
++{0x2B89, 0x17},
++{0x2B8A, 0x12},
++{0x2B8B, 0x12},
++{0x2B8D, 0x2B},
++{0x2B8E, 0x2B},
++{0x2B8F, 0x2B},
++{0x2B90, 0x7F},
++{0x2B91, 0x1F},
++{0x2B94, 0x7F},
++{0x2B95, 0x27},
++{0x2B98, 0x7F},
++{0x2B99, 0x57},
++{0x2BA8, 0xBC},
++{0x2BA9, 0x62},
++{0x2BC1, 0x70},
++{0x2BC5, 0x80},
++{0x2BD5, 0x30},
++{0x2BD6, 0xF0},
++{0x2BD8, 0xDB},
++{0x2BD9, 0xF6},
++{0x2BDA, 0x63},
++{0x2BDB, 0x0C},
++{0x2BDC, 0x5C},
++{0x2C98, 0xE1},
++{0x2C99, 0x2E},
++{0x2C9B, 0x86},
++{0x2CA9, 0x80},
++{0x2CAA, 0x01},
++{0x2D39, 0x0E},
++{0x2D54, 0x00},
++{0x2D5B, 0x58},
++{0x3000, 0x00},
++{0x3001, 0x40},
++{0x3002, 0x23},
++{0x3003, 0xA1},
++{0x3004, 0x00},
++{0x3005, 0x20},
++{0x3006, 0x94},
++{0x3007, 0x00},
++{0x3008, 0x06},
++{0x3009, 0xB4},
++{0x300A, 0x1F},
++{0x300B, 0x28},
++{0x300C, 0x00},
++{0x300D, 0x18},
++{0x300E, 0x90},
++{0x300F, 0x97},
++{0x3010, 0x00},
++{0x3011, 0x40},
++{0x3012, 0x21},
++{0x3013, 0x21},
++{0x3014, 0x00},
++{0x3015, 0x20},
++{0x3016, 0x94},
++{0x3017, 0x00},
++{0x3018, 0x00},
++{0x3019, 0x09},
++{0x301A, 0x46},
++{0x301B, 0x28},
++//{0x3053, ,3},
++{0x3070, 0xC1},
++{0x3071, 0x81},
++{0x3072, 0x29},
++{0x3073, 0x81},
++//{0x3370, ,3},
++//{0x3374, ,3},
++//{0x3375, ,3},
++//{0x3376, ,3},
++//{0x3377, ,3},
++#if 1
++{0x3410, 0x90},
++{0x3411, 0x07},
++{0x3418, 0x48},
++{0x3419, 0x04},
++#else
++{0x3410, 0x80},
++{0x3411, 0x07},
++{0x3418, 0x38},
++{0x3419, 0x04},
++#endif
++//{0x34C0, ,3},
++//{0x34C1, ,3},
++//{0x34C2, ,3},
++//{0x34C3, ,3},
++//{0x34C4, ,3},
++//{0x34C5, ,3},
++//{0x34C6, ,3},
++//{0x34C7, ,3},
++//{0x34C8, ,3},
++//{0x34C9, ,3},
++//{0x34CA, ,3},
++//{0x34CB, ,3},
++//{0x34CC, ,3},
++//{0x34CD, ,3},
++//{0x34CE, ,3},
++//{0x34CF, ,3},
++{0x3584, 0x00},
++{0x3586, 0x00},
++{0x3587, 0x01},
++{0x3588, 0xE6},
++{0x3589, 0x00},
++{0x3590, 0x00},
++{0x3591, 0x00},
++{0x3594, 0x40},
++{0x3598, 0x03},
++{0x3599, 0x00},
++{0x359A, 0x80},
++{0x359B, 0x00},
++{0x359C, 0x00},
++{0x359D, 0x01},
++{0x359E, 0x00},
++{0x359F, 0x02},
++{0x35A0, 0x00},
++{0x35A1, 0x04},
++{0x35A2, 0x20},
++{0x35A3, 0x00},
++{0x35A4, 0x40},
++{0x35A5, 0x00},
++{0x35A6, 0x80},
++{0x35A7, 0x00},
++{0x35A8, 0x00},
++{0x35A9, 0x01},
++{0x35AA, 0x3A},
++{0x35AB, 0x00},
++{0x35AC, 0x80},
++{0x35AD, 0x00},
++{0x35AE, 0x00},
++{0x35AF, 0x01},
++{0x35B0, 0x00},
++{0x35B1, 0x02},
++{0x35B2, 0x00},
++{0x35B3, 0x04},
++{0x35B4, 0x02},
++{0x35B5, 0x00},
++{0x35B6, 0x04},
++{0x35B7, 0x00},
++{0x35B8, 0x08},
++{0x35B9, 0x00},
++{0x35BA, 0x10},
++{0x35BB, 0x00},
++{0x35BC, 0x03},
++{0x35BD, 0x00},
++{0x35C8, 0x00},
++{0x35C9, 0x01},
++{0x35CA, 0x00},
++{0x35CB, 0x04},
++{0x35CC, 0x00},
++{0x35CD, 0x10},
++{0x35CE, 0x00},
++{0x35CF, 0x40},
++{0x35D0, 0x00},
++{0x35D1, 0x0C},
++{0x35D2, 0x00},
++{0x35D3, 0x0C},
++{0x35D4, 0x00},
++{0x35D5, 0x0C},
++{0x35D6, 0x00},
++{0x35D7, 0x0C},
++{0x35D8, 0x00},
++{0x35D9, 0x00},
++{0x35DA, 0x08},
++{0x35DB, 0x00},
++{0x35DC, 0xD8},
++{0x35DD, 0x0E},
++{0x35F0, 0x00},
++{0x35F1, 0x10},
++{0x35F2, 0x00},
++{0x35F3, 0x10},
++{0x35F4, 0x00},
++{0x35F5, 0x10},
++{0x35F6, 0x00},
++{0x35F7, 0x03},
++{0x35F8, 0x00},
++{0x35F9, 0x01},
++{0x35FA, 0x38},
++{0x35FB, 0x00},
++{0x35FC, 0xB3},
++{0x35FD, 0x01},
++{0x35FE, 0x00},
++{0x35FF, 0x00},
++{0x3600, 0x04},
++{0x3601, 0x06},
++{0x3604, 0x03},
++{0x3605, 0x00},
++{0x3608, 0x03},
++{0x3609, 0x00},
++{0x360C, 0x00},
++{0x360D, 0x00},
++{0x3610, 0x10},
++{0x3611, 0x01},
++{0x3612, 0x00},
++{0x3613, 0x00},
++{0x3614, 0x00},
++{0x3615, 0x00},
++{0x361C, 0x00},
++{0x361D, 0x01},
++{0x361E, 0x00},
++{0x361F, 0x01},
++{0x3620, 0x01},
++{0x3621, 0x00},
++{0x3622, 0xB0},
++{0x3623, 0x04},
++{0x3624, 0xDC},
++{0x3625, 0x05},
++{0x3626, 0x00},
++{0x3627, 0x01},
++{0x3628, 0xFF},
++{0x3629, 0x0F},
++{0x362A, 0x00},
++{0x362B, 0x10},
++{0x362C, 0x00},
++{0x362D, 0x01},
++//{0x3630, ,3},
++//{0x3631, ,3},
++//{0x3632, ,3},
++//{0x3633, ,3},
++//{0x3634, ,3},
++//{0x3635, ,3},
++//{0x3636, ,3},
++//{0x3637, ,3},
++//{0x3638, ,3},
++//{0x3639, ,3},
++//{0x363A, ,3},
++//{0x363B, ,3},
++//{0x363C, ,3},
++//{0x363D, ,3},
++//{0x363E, ,3},
++//{0x363F, ,3},
++{0x36C4, 0x99},
++{0x36C5, 0x09},
++{0x36C6, 0x18},
++{0x36C7, 0x07},
++{0x36C8, 0x65},
++{0x36C9, 0x0E},
++{0x36CC, 0x99},
++{0x36CD, 0x01},
++{0x36CE, 0x47},
++{0x36CF, 0x00},
++{0x36D0, 0x04},
++{0x36D1, 0x00},
++{0x36D4, 0x65},
++{0x36D5, 0x0E},
++{0x36D6, 0xA4},
++{0x36D7, 0x0A},
++{0x36D8, 0x65},
++{0x36D9, 0x0E},
++{0x36DC, 0x65},
++{0x36DD, 0x0E},
++{0x36DE, 0xA4},
++{0x36DF, 0x0A},
++{0x36E0, 0x65},
++{0x36E1, 0x0E},
++{0x36E4, 0x65},
++{0x36E5, 0x0E},
++{0x36E6, 0xA4},
++{0x36E7, 0x0A},
++{0x36E8, 0x65},
++{0x36E9, 0x0E},
++{0x36EE, 0x00},
++{0x36EF, 0x00},
++{0x36F0, 0x00},
++{0x36F1, 0x80},
++{0x36F8, 0x00},
++{0x3702, 0x03},
++{0x3703, 0x04},
++{0x3704, 0x08},
++{0x370E, 0x0E},
++{0x3718, 0x62},
++{0x3719, 0x4A},
++{0x371A, 0x38},
++{0x371B, 0x20},
++{0x371C, 0x64},
++{0x371D, 0x42},
++{0x371E, 0x32},
++{0x371F, 0x1B},
++{0x3720, 0x98},
++{0x3721, 0xA0},
++{0x3722, 0xA8},
++{0x3723, 0xB0},
++{0x3748, 0xA5},
++{0x3749, 0x9B},
++{0x374A, 0x91},
++{0x374B, 0x7D},
++{0x37C0, 0x00},
++{0x37C1, 0x00},
++{0x37C2, 0x00},
++{0x37C4, 0x00},
++{0x37C5, 0x00},
++{0x37C6, 0x00},
++{0x37C8, 0x00},
++{0x37C9, 0x00},
++{0x37CA, 0x00},
++{0x37CC, 0x00},
++{0x37CD, 0x00},
++{0x37CE, 0x00},
++{0x37D0, 0x00},
++{0x37D1, 0x00},
++{0x37D2, 0x00},
++{0x37D4, 0x00},
++{0x37D5, 0x00},
++{0x37D6, 0x00},
++{0x37D8, 0x00},
++{0x37D9, 0x00},
++{0x37DA, 0x00},
++{0x37DC, 0x00},
++{0x37DD, 0x00},
++{0x37DE, 0x00},
++{0x37E0, 0x00},
++{0x37E1, 0x00},
++{0x37E2, 0x00},
++{0x37E4, 0x00},
++{0x37E5, 0x00},
++{0x37E6, 0x00},
++{0x37E8, 0x00},
++{0x37E9, 0x00},
++{0x37EA, 0x00},
++{0x37EC, 0x00},
++{0x37ED, 0x00},
++{0x37EE, 0x00},
++{0x37F0, 0x00},
++{0x37F4, 0x00},
++{0x37F5, 0x1E},
++{0x37F6, 0x34},
++{0x37F7, 0x00},
++{0x37F8, 0xFF},
++{0x37F9, 0xFF},
++{0x37FA, 0x03},
++{0x37FC, 0x00},
++{0x37FD, 0x00},
++{0x37FE, 0x04},
++{0x3800, 0xFF},
++{0x3801, 0xFF},
++{0x3802, 0x03},
++{0x3804, 0x00},
++{0x3805, 0x00},
++{0x3806, 0x04},
++{0x3808, 0x00},
++{0x3809, 0x00},
++{0x380A, 0x00},
++{0x380C, 0x00},
++{0x380D, 0x00},
++{0x380E, 0x00},
++{0x3810, 0x00},
++{0x3811, 0x00},
++{0x3812, 0x00},
++{0x3814, 0x00},
++{0x3815, 0x00},
++{0x3816, 0x00},
++{0x3818, 0x00},
++{0x3819, 0x00},
++{0x381A, 0x00},
++{0x381C, 0x00},
++{0x381D, 0x00},
++{0x381E, 0x00},
++{0x3820, 0x00},
++{0x3821, 0x00},
++{0x3822, 0x00},
++{0x3824, 0x00},
++{0x3825, 0x00},
++{0x3826, 0x00},
++{0x3828, 0x00},
++{0x3829, 0x00},
++{0x382A, 0x00},
++{0x382C, 0x00},
++{0x382D, 0x00},
++{0x382E, 0x00},
++{0x3830, 0x00},
++{0x3831, 0x00},
++{0x3832, 0x00},
++{0x3834, 0x00},
++{0x3835, 0x00},
++{0x3836, 0x00},
++{0x3838, 0x22},
++{0x3839, 0x00},
++{0x383A, 0x25},
++{0x383B, 0x00},
++{0x383C, 0x1A},
++{0x383D, 0x00},
++{0x383E, 0x26},
++{0x383F, 0x00},
++{0x3840, 0x07},
++{0x3841, 0x00},
++{0x3842, 0x06},
++{0x3843, 0x00},
++{0x3844, 0x03},
++{0x3845, 0x00},
++{0x3846, 0x02},
++{0x3847, 0x00},
++{0x3848, 0xFB},
++{0x3849, 0xFF},
++{0x384A, 0xFF},
++{0x384B, 0xFF},
++{0x384C, 0xF3},
++{0x384D, 0xFF},
++{0x384E, 0xF2},
++{0x384F, 0xFF},
++{0x3850, 0xFF},
++{0x3851, 0x0F},
++{0x3852, 0x00},
++{0x3853, 0x10},
++{0x3854, 0xFF},
++{0x3855, 0x0F},
++{0x3856, 0x00},
++{0x3857, 0x10},
++{0x3858, 0xFF},
++{0x3859, 0x0F},
++{0x385A, 0x00},
++{0x385B, 0x10},
++{0x385C, 0x02},
++{0x385D, 0x00},
++{0x385E, 0x06},
++{0x385F, 0x00},
++{0x3860, 0x06},
++{0x3861, 0x00},
++{0x3862, 0x08},
++{0x3863, 0x00},
++{0x3864, 0x02},
++{0x3865, 0x00},
++{0x38A0, 0x01},
++{0x38A1, 0x01},
++{0x38A2, 0x00},
++{0x38A3, 0x01},
++{0x38A4, 0x07},
++{0x38A5, 0x00},
++{0x38A6, 0x04},
++{0x38A7, 0x05},
++{0x38A8, 0x00},
++{0x38A9, 0x00},
++{0x38AC, 0x00},
++{0x38AD, 0x00},
++{0x38AE, 0x01},
++{0x38B0, 0x02},
++{0x38B2, 0x22},
++{0x38B3, 0x00},
++{0x38B4, 0x17},
++{0x38B5, 0x00},
++{0x38B6, 0x11},
++{0x38B7, 0x00},
++{0x38B8, 0x0E},
++{0x38B9, 0x00},
++{0x38BA, 0x2A},
++{0x38BB, 0x00},
++{0x38BC, 0x1C},
++{0x38BD, 0x00},
++{0x38BE, 0x14},
++{0x38BF, 0x00},
++{0x38C0, 0x10},
++{0x38C1, 0x00},
++{0x38C2, 0x31},
++{0x38C3, 0x00},
++{0x38C4, 0x21},
++{0x38C5, 0x00},
++{0x38C6, 0x18},
++{0x38C7, 0x00},
++{0x38C8, 0x12},
++{0x38C9, 0x00},
++{0x38CA, 0x3C},
++{0x38CB, 0x00},
++{0x38CC, 0x29},
++{0x38CD, 0x00},
++{0x38CE, 0x1D},
++{0x38CF, 0x00},
++{0x38D0, 0x15},
++{0x38D1, 0x00},
++{0x38D2, 0x4E},
++{0x38D3, 0x00},
++{0x38D4, 0x35},
++{0x38D5, 0x00},
++{0x38D6, 0x26},
++{0x38D7, 0x00},
++{0x38D8, 0x1A},
++{0x38D9, 0x00},
++{0x38DA, 0x69},
++{0x38DB, 0x00},
++{0x38DC, 0x48},
++{0x38DD, 0x00},
++{0x38DE, 0x33},
++{0x38DF, 0x00},
++{0x38E0, 0x22},
++{0x38E1, 0x00},
++{0x38E2, 0x93},
++{0x38E3, 0x00},
++{0x38E4, 0x64},
++{0x38E5, 0x00},
++{0x38E6, 0x48},
++{0x38E7, 0x00},
++{0x38E8, 0x30},
++{0x38E9, 0x00},
++{0x38EA, 0xD3},
++{0x38EB, 0x00},
++{0x38EC, 0x90},
++{0x38ED, 0x00},
++{0x38EE, 0x69},
++{0x38EF, 0x00},
++{0x38F0, 0x49},
++{0x38F1, 0x00},
++{0x38F2, 0x39},
++{0x38F3, 0x01},
++{0x38F4, 0xD5},
++{0x38F5, 0x00},
++{0x38F6, 0x9F},
++{0x38F7, 0x00},
++{0x38F8, 0x75},
++{0x38F9, 0x00},
++{0x38FA, 0x00},
++{0x38FB, 0x01},
++{0x38FC, 0x00},
++{0x38FD, 0x01},
++{0x38FE, 0x00},
++{0x38FF, 0x01},
++{0x3900, 0x00},
++{0x3901, 0x01},
++{0x3902, 0x60},
++{0x3903, 0x00},
++{0x3904, 0x25},
++{0x3905, 0x00},
++{0x3906, 0x18},
++{0x3907, 0x00},
++{0x3908, 0x10},
++{0x3909, 0x00},
++{0x390A, 0xFF},
++{0x390B, 0x00},
++{0x390C, 0xD5},
++{0x390D, 0x00},
++{0x390E, 0xAA},
++{0x390F, 0x00},
++{0x3910, 0x85},
++{0x3911, 0x00},
++{0x3912, 0xFF},
++{0x3913, 0x00},
++{0x3914, 0xD5},
++{0x3915, 0x00},
++{0x3916, 0xAA},
++{0x3917, 0x00},
++{0x3918, 0x85},
++{0x3919, 0x00},
++{0x391A, 0xFF},
++{0x391B, 0x00},
++{0x391C, 0xD5},
++{0x391D, 0x00},
++{0x391E, 0xAA},
++{0x391F, 0x00},
++{0x3920, 0x85},
++{0x3921, 0x00},
++{0x3922, 0x40},
++{0x3923, 0x00},
++{0x3924, 0x40},
++{0x3925, 0x00},
++{0x3926, 0x40},
++{0x3927, 0x00},
++{0x3928, 0x40},
++{0x3929, 0x00},
++{0x392A, 0x80},
++{0x392B, 0x00},
++{0x392C, 0x80},
++{0x392D, 0x00},
++{0x392E, 0x80},
++{0x392F, 0x00},
++{0x3930, 0x80},
++{0x3931, 0x00},
++{0x3932, 0x4C},
++{0x3933, 0x4C},
++{0x3934, 0x4C},
++{0x3940, 0x01},
++{0x3941, 0x01},
++{0x3942, 0x00},
++{0x3943, 0x01},
++{0x3944, 0x07},
++{0x3945, 0x00},
++{0x3946, 0x04},
++{0x3947, 0x05},
++{0x3948, 0x00},
++{0x3949, 0x00},
++{0x394C, 0x00},
++{0x394D, 0x00},
++{0x394E, 0x01},
++{0x3950, 0x03},
++{0x3952, 0x14},
++{0x3953, 0x00},
++{0x3954, 0x0F},
++{0x3955, 0x00},
++{0x3956, 0x0E},
++{0x3957, 0x00},
++{0x3958, 0x0E},
++{0x3959, 0x00},
++{0x395A, 0x19},
++{0x395B, 0x00},
++{0x395C, 0x11},
++{0x395D, 0x00},
++{0x395E, 0x0F},
++{0x395F, 0x00},
++{0x3960, 0x0E},
++{0x3961, 0x00},
++{0x3962, 0x1C},
++{0x3963, 0x00},
++{0x3964, 0x13},
++{0x3965, 0x00},
++{0x3966, 0x0F},
++{0x3967, 0x00},
++{0x3968, 0x0E},
++{0x3969, 0x00},
++{0x396A, 0x23},
++{0x396B, 0x00},
++{0x396C, 0x15},
++{0x396D, 0x00},
++{0x396E, 0x11},
++{0x396F, 0x00},
++{0x3970, 0x0E},
++{0x3971, 0x00},
++{0x3972, 0x2E},
++{0x3973, 0x00},
++{0x3974, 0x1A},
++{0x3975, 0x00},
++{0x3976, 0x14},
++{0x3977, 0x00},
++{0x3978, 0x0F},
++{0x3979, 0x00},
++{0x397A, 0x3E},
++{0x397B, 0x00},
++{0x397C, 0x23},
++{0x397D, 0x00},
++{0x397E, 0x1A},
++{0x397F, 0x00},
++{0x3980, 0x12},
++{0x3981, 0x00},
++{0x3982, 0x56},
++{0x3983, 0x00},
++{0x3984, 0x31},
++{0x3985, 0x00},
++{0x3986, 0x25},
++{0x3987, 0x00},
++{0x3988, 0x1A},
++{0x3989, 0x00},
++{0x398A, 0x7B},
++{0x398B, 0x00},
++{0x398C, 0x49},
++{0x398D, 0x00},
++{0x398E, 0x39},
++{0x398F, 0x00},
++{0x3990, 0x2C},
++{0x3991, 0x00},
++{0x3992, 0xB4},
++{0x3993, 0x00},
++{0x3994, 0x75},
++{0x3995, 0x00},
++{0x3996, 0x61},
++{0x3997, 0x00},
++{0x3998, 0x53},
++{0x3999, 0x00},
++{0x399A, 0x00},
++{0x399B, 0x01},
++{0x399C, 0x00},
++{0x399D, 0x01},
++{0x399E, 0x00},
++{0x399F, 0x01},
++{0x39A0, 0x00},
++{0x39A1, 0x01},
++{0x39A2, 0x60},
++{0x39A3, 0x00},
++{0x39A4, 0x20},
++{0x39A5, 0x00},
++{0x39A6, 0x15},
++{0x39A7, 0x00},
++{0x39A8, 0x10},
++{0x39A9, 0x00},
++{0x39AA, 0xFF},
++{0x39AB, 0x00},
++{0x39AC, 0xD5},
++{0x39AD, 0x00},
++{0x39AE, 0xAA},
++{0x39AF, 0x00},
++{0x39B0, 0x85},
++{0x39B1, 0x00},
++{0x39B2, 0xFF},
++{0x39B3, 0x00},
++{0x39B4, 0xD5},
++{0x39B5, 0x00},
++{0x39B6, 0xAA},
++{0x39B7, 0x00},
++{0x39B8, 0x85},
++{0x39B9, 0x00},
++{0x39BA, 0xFF},
++{0x39BB, 0x00},
++{0x39BC, 0xD5},
++{0x39BD, 0x00},
++{0x39BE, 0xAA},
++{0x39BF, 0x00},
++{0x39C0, 0x85},
++{0x39C1, 0x00},
++{0x39C2, 0x40},
++{0x39C3, 0x00},
++{0x39C4, 0x40},
++{0x39C5, 0x00},
++{0x39C6, 0x40},
++{0x39C7, 0x00},
++{0x39C8, 0x40},
++{0x39C9, 0x00},
++{0x39CA, 0x80},
++{0x39CB, 0x00},
++{0x39CC, 0x80},
++{0x39CD, 0x00},
++{0x39CE, 0x80},
++{0x39CF, 0x00},
++{0x39D0, 0x80},
++{0x39D1, 0x00},
++{0x39D2, 0x4C},
++{0x39D3, 0x4C},
++{0x39D4, 0x4C},
++{0x39E0, 0x01},
++{0x39E1, 0x00},
++{0x39E4, 0x40},
++{0x39E5, 0x01},
++{0x39E6, 0x01},
++{0x39E8, 0x00},
++{0x39E9, 0x01},
++{0x39EA, 0x00},
++{0x39EB, 0x00},
++{0x39EC, 0x01},
++{0x39ED, 0x00},
++{0x39EE, 0x01},
++{0x39F0, 0x03},
++{0x39F1, 0x04},
++{0x39F2, 0x0E},
++{0x39F4, 0x1C},
++{0x39F5, 0x00},
++{0x39F6, 0x13},
++{0x39F7, 0x00},
++{0x39F8, 0x0D},
++{0x39F9, 0x00},
++{0x39FA, 0x07},
++{0x39FB, 0x00},
++{0x39FC, 0x38},
++{0x39FD, 0x00},
++{0x39FE, 0x1C},
++{0x39FF, 0x00},
++{0x3A00, 0x11},
++{0x3A01, 0x00},
++{0x3A02, 0x08},
++{0x3A03, 0x00},
++{0x3A04, 0x4A},
++{0x3A05, 0x00},
++{0x3A06, 0x23},
++{0x3A07, 0x00},
++{0x3A08, 0x15},
++{0x3A09, 0x00},
++{0x3A0A, 0x09},
++{0x3A0B, 0x00},
++{0x3A0C, 0x65},
++{0x3A0D, 0x00},
++{0x3A0E, 0x2D},
++{0x3A0F, 0x00},
++{0x3A10, 0x1A},
++{0x3A11, 0x00},
++{0x3A12, 0x0B},
++{0x3A13, 0x00},
++{0x3A14, 0x8D},
++{0x3A15, 0x00},
++{0x3A16, 0x3D},
++{0x3A17, 0x00},
++{0x3A18, 0x23},
++{0x3A19, 0x00},
++{0x3A1A, 0x0E},
++{0x3A1B, 0x00},
++{0x3A1C, 0xC5},
++{0x3A1D, 0x00},
++{0x3A1E, 0x55},
++{0x3A1F, 0x00},
++{0x3A20, 0x30},
++{0x3A21, 0x00},
++{0x3A22, 0x13},
++{0x3A23, 0x00},
++{0x3A24, 0x16},
++{0x3A25, 0x01},
++{0x3A26, 0x76},
++{0x3A27, 0x00},
++{0x3A28, 0x42},
++{0x3A29, 0x00},
++{0x3A2A, 0x1A},
++{0x3A2B, 0x00},
++{0x3A2C, 0x88},
++{0x3A2D, 0x01},
++{0x3A2E, 0xA7},
++{0x3A2F, 0x00},
++{0x3A30, 0x5D},
++{0x3A31, 0x00},
++{0x3A32, 0x24},
++{0x3A33, 0x00},
++{0x3A34, 0x2A},
++{0x3A35, 0x02},
++{0x3A36, 0xEB},
++{0x3A37, 0x00},
++{0x3A38, 0x83},
++{0x3A39, 0x00},
++{0x3A3A, 0x32},
++{0x3A3B, 0x00},
++{0x3A3C, 0x00},
++{0x3A3D, 0x01},
++{0x3A3E, 0x00},
++{0x3A3F, 0x01},
++{0x3A40, 0x00},
++{0x3A41, 0x01},
++{0x3A42, 0x00},
++{0x3A43, 0x01},
++{0x3A44, 0x70},
++{0x3A45, 0x00},
++{0x3A46, 0x25},
++{0x3A47, 0x00},
++{0x3A48, 0x18},
++{0x3A49, 0x00},
++{0x3A4A, 0x10},
++{0x3A4B, 0x00},
++{0x3A4C, 0xFF},
++{0x3A4D, 0x00},
++{0x3A4E, 0xD5},
++{0x3A4F, 0x00},
++{0x3A50, 0xAA},
++{0x3A51, 0x00},
++{0x3A52, 0x85},
++{0x3A53, 0x00},
++{0x3A54, 0xFF},
++{0x3A55, 0x00},
++{0x3A56, 0xD5},
++{0x3A57, 0x00},
++{0x3A58, 0xAA},
++{0x3A59, 0x00},
++{0x3A5A, 0x85},
++{0x3A5B, 0x00},
++{0x3A5C, 0xFF},
++{0x3A5D, 0x00},
++{0x3A5E, 0xD5},
++{0x3A5F, 0x00},
++{0x3A60, 0xAA},
++{0x3A61, 0x00},
++{0x3A62, 0x85},
++{0x3A63, 0x00},
++{0x3A64, 0x1C},
++{0x3A65, 0x00},
++{0x3A66, 0x13},
++{0x3A67, 0x00},
++{0x3A68, 0x0D},
++{0x3A69, 0x00},
++{0x3A6A, 0x07},
++{0x3A6B, 0x00},
++{0x3A6C, 0x0D},
++{0x3A6D, 0x00},
++{0x3A6E, 0x0B},
++{0x3A6F, 0x00},
++{0x3A70, 0x06},
++{0x3A71, 0x00},
++{0x3A72, 0x05},
++{0x3A73, 0x00},
++{0x3A74, 0x19},
++{0x3A75, 0x00},
++{0x3A76, 0x14},
++{0x3A77, 0x00},
++{0x3A78, 0x0F},
++{0x3A79, 0x00},
++{0x3A7A, 0x0A},
++{0x3A7B, 0x00},
++{0x3A7C, 0x80},
++{0x3A7D, 0x00},
++{0x3A7E, 0x80},
++{0x3A7F, 0x00},
++{0x3A80, 0x80},
++{0x3A81, 0x00},
++{0x3A82, 0x80},
++{0x3A83, 0x00},
++{0x3A84, 0x08},
++{0x3A85, 0x00},
++{0x3A86, 0x05},
++{0x3A87, 0x00},
++{0x3A88, 0x04},
++{0x3A89, 0x00},
++{0x3A8A, 0x03},
++{0x3A8B, 0x00},
++{0x3A8C, 0xCD},
++{0x3A8D, 0x00},
++{0x3A8E, 0xAA},
++{0x3A8F, 0x00},
++{0x3A90, 0x8C},
++{0x3A91, 0x00},
++{0x3A92, 0x64},
++{0x3A93, 0x00},
++{0x3A94, 0xCD},
++{0x3A95, 0x00},
++{0x3A96, 0xAA},
++{0x3A97, 0x00},
++{0x3A98, 0x8C},
++{0x3A99, 0x00},
++{0x3A9A, 0x64},
++{0x3A9B, 0x00},
++{0x3A9C, 0x08},
++{0x3A9D, 0x10},
++{0x3A9E, 0x4C},
++{0x3A9F, 0x4C},
++{0x3AA0, 0x4C},
++{0x3AA1, 0x04},
++{0x3AA2, 0x05},
++{0x3AC0, 0x01},
++{0x3AC4, 0x81},
++{0x3AC5, 0x00},
++{0x3AC6, 0x00},
++{0x3AC7, 0x00},
++{0x3AC8, 0x00},
++{0x3AC9, 0x00},
++{0x3ACA, 0x00},
++{0x3ACB, 0x00},
++{0x3ACC, 0x02},
++{0x3ACD, 0x00},
++{0x3ACE, 0x81},
++{0x3ACF, 0x00},
++{0x3AD0, 0x00},
++{0x3AD1, 0x00},
++{0x3AD2, 0xFD},
++{0x3AD3, 0x03},
++{0x3AD4, 0x02},
++{0x3AD5, 0x00},
++{0x3AD6, 0x00},
++{0x3AD7, 0x00},
++{0x3AD8, 0x81},
++{0x3AD9, 0x00},
++{0x3ADA, 0xFD},
++{0x3ADB, 0x03},
++{0x3ADC, 0xFF},
++{0x3ADD, 0x03},
++{0x3ADE, 0x01},
++{0x3ADF, 0x00},
++{0x3AE0, 0x01},
++{0x3AE1, 0x00},
++{0x3AE2, 0x7E},
++{0x3AE3, 0x00},
++{0x3AF4, 0x00},
++{0x3AF6, 0x40},
++{0x3AF7, 0x1E},
++{0x3AF8, 0x01},
++{0x3AFA, 0x63},
++{0x3AFB, 0x09},
++{0x3AFC, 0x11},
++{0x3AFD, 0x09},
++{0x3AFE, 0x00},
++{0x3AFF, 0x00},
++{0x3B00, 0x00},
++{0x3B01, 0x00},
++{0x3B02, 0x84},
++{0x3B03, 0x06},
++{0x3B04, 0x30},
++{0x3B05, 0x06},
++{0x3B06, 0x00},
++{0x3B07, 0x00},
++{0x3B08, 0x00},
++{0x3B09, 0x00},
++{0x3B0A, 0x00},
++{0x3B0B, 0x00},
++{0x3B0C, 0x00},
++{0x3B0D, 0x00},
++{0x3B0E, 0x00},
++{0x3B0F, 0x00},
++{0x3B10, 0x00},
++{0x3B11, 0x00},
++{0x3B12, 0x00},
++{0x3B13, 0x00},
++{0x3B14, 0x00},
++{0x3B15, 0x00},
++{0x3B16, 0x00},
++{0x3B17, 0x00},
++{0x3B18, 0x00},
++{0x3B19, 0x00},
++{0x3B1A, 0x00},
++{0x3B1B, 0x00},
++{0x3B1C, 0x00},
++{0x3B1D, 0x00},
++{0x3B1E, 0x00},
++{0x3B1F, 0x00},
++{0x3B20, 0x00},
++{0x3B21, 0x00},
++{0x3B22, 0x00},
++{0x3B23, 0x00},
++{0x3B24, 0x00},
++{0x3B25, 0x00},
++{0x3B26, 0x00},
++{0x3B27, 0x00},
++{0x3B28, 0x00},
++{0x3B29, 0x00},
++{0x3B2A, 0x00},
++{0x3B2C, 0x00},
++{0x3B2E, 0x00},
++{0x3B30, 0x00},
++{0x3B32, 0x0C},
++{0x4000, 0xD1},
++{0x4001, 0xC0},
++{0x4002, 0xC0},
++{0x4003, 0xB8},
++{0x4004, 0xC0},
++{0x4005, 0xB8},
++{0x4006, 0xB9},
++{0x4007, 0xB7},
++{0x4008, 0xB0},
++{0x4009, 0xAB},
++{0x400A, 0xAC},
++{0x400B, 0xAB},
++{0x400C, 0xA8},
++{0x400D, 0xA6},
++{0x400E, 0xA6},
++{0x400F, 0xA5},
++{0x4010, 0xA2},
++{0x4011, 0xA0},
++{0x4012, 0xA0},
++{0x4013, 0x9F},
++{0x4014, 0xA4},
++{0x4015, 0xA2},
++{0x4016, 0xA2},
++{0x4017, 0x9C},
++{0x4018, 0xA8},
++{0x4019, 0xA6},
++{0x401A, 0xA8},
++{0x401B, 0xAA},
++{0x401C, 0xB0},
++{0x401D, 0xAE},
++{0x401E, 0xAE},
++{0x401F, 0xAE},
++{0x4020, 0xBA},
++{0x4021, 0xAE},
++{0x4022, 0xAF},
++{0x4023, 0xAE},
++{0x4024, 0xC6},
++{0x4025, 0xBD},
++{0x4026, 0xBD},
++{0x4027, 0xBA},
++{0x4028, 0xB0},
++{0x4029, 0xA9},
++{0x402A, 0xAA},
++{0x402B, 0xA8},
++{0x402C, 0x9F},
++{0x402D, 0x9C},
++{0x402E, 0x9C},
++{0x402F, 0x9B},
++{0x4030, 0x93},
++{0x4031, 0x91},
++{0x4032, 0x92},
++{0x4033, 0x91},
++{0x4034, 0x8D},
++{0x4035, 0x8C},
++{0x4036, 0x8C},
++{0x4037, 0x8C},
++{0x4038, 0x8F},
++{0x4039, 0x8E},
++{0x403A, 0x8E},
++{0x403B, 0x8E},
++{0x403C, 0x98},
++{0x403D, 0x96},
++{0x403E, 0x96},
++{0x403F, 0x95},
++{0x4040, 0xA4},
++{0x4041, 0xA0},
++{0x4042, 0xA0},
++{0x4043, 0x9E},
++{0x4044, 0xB3},
++{0x4045, 0xAE},
++{0x4046, 0xAF},
++{0x4047, 0xAB},
++{0x4048, 0xC2},
++{0x4049, 0xB7},
++{0x404A, 0xB8},
++{0x404B, 0xB5},
++{0x404C, 0xAB},
++{0x404D, 0xA4},
++{0x404E, 0xA5},
++{0x404F, 0xA3},
++{0x4050, 0x99},
++{0x4051, 0x96},
++{0x4052, 0x96},
++{0x4053, 0x96},
++{0x4054, 0x8B},
++{0x4055, 0x8A},
++{0x4056, 0x8A},
++{0x4057, 0x8A},
++{0x4058, 0x82},
++{0x4059, 0x81},
++{0x405A, 0x81},
++{0x405B, 0x81},
++{0x405C, 0x85},
++{0x405D, 0x86},
++{0x405E, 0x85},
++{0x405F, 0x85},
++{0x4060, 0x90},
++{0x4061, 0x90},
++{0x4062, 0x8F},
++{0x4063, 0x8F},
++{0x4064, 0x9D},
++{0x4065, 0x9B},
++{0x4066, 0x9B},
++{0x4067, 0x9A},
++{0x4068, 0xAF},
++{0x4069, 0xAA},
++{0x406A, 0xAC},
++{0x406B, 0xAA},
++{0x406C, 0xC2},
++{0x406D, 0xB7},
++{0x406E, 0xB8},
++{0x406F, 0xB5},
++{0x4070, 0xAB},
++{0x4071, 0xA4},
++{0x4072, 0xA4},
++{0x4073, 0xA3},
++{0x4074, 0x99},
++{0x4075, 0x96},
++{0x4076, 0x96},
++{0x4077, 0x96},
++{0x4078, 0x8B},
++{0x4079, 0x8A},
++{0x407A, 0x8A},
++{0x407B, 0x8A},
++{0x407C, 0x82},
++{0x407D, 0x82},
++{0x407E, 0x82},
++{0x407F, 0x82},
++{0x4080, 0x85},
++{0x4081, 0x86},
++{0x4082, 0x86},
++{0x4083, 0x86},
++{0x4084, 0x90},
++{0x4085, 0x90},
++{0x4086, 0x8F},
++{0x4087, 0x8F},
++{0x4088, 0x9D},
++{0x4089, 0x9B},
++{0x408A, 0x9B},
++{0x408B, 0x99},
++{0x408C, 0xAE},
++{0x408D, 0xAA},
++{0x408E, 0xAA},
++{0x408F, 0xA7},
++{0x4090, 0xC7},
++{0x4091, 0xBA},
++{0x4092, 0xBC},
++{0x4093, 0xB9},
++{0x4094, 0xB1},
++{0x4095, 0xA8},
++{0x4096, 0xA8},
++{0x4097, 0xA7},
++{0x4098, 0x9F},
++{0x4099, 0x9B},
++{0x409A, 0x9B},
++{0x409B, 0x9B},
++{0x409C, 0x93},
++{0x409D, 0x91},
++{0x409E, 0x91},
++{0x409F, 0x91},
++{0x40A0, 0x8D},
++{0x40A1, 0x8C},
++{0x40A2, 0x8C},
++{0x40A3, 0x8C},
++{0x40A4, 0x8E},
++{0x40A5, 0x8E},
++{0x40A6, 0x8D},
++{0x40A7, 0x8D},
++{0x40A8, 0x96},
++{0x40A9, 0x95},
++{0x40AA, 0x95},
++{0x40AB, 0x94},
++{0x40AC, 0xA2},
++{0x40AD, 0x9F},
++{0x40AE, 0x9F},
++{0x40AF, 0x9D},
++{0x40B0, 0xB1},
++{0x40B1, 0xAC},
++{0x40B2, 0xAB},
++{0x40B3, 0xAA},
++{0x40B4, 0xD3},
++{0x40B5, 0xBC},
++{0x40B6, 0xBD},
++{0x40B7, 0xBC},
++{0x40B8, 0xC1},
++{0x40B9, 0xB7},
++{0x40BA, 0xB7},
++{0x40BB, 0xB5},
++{0x40BC, 0xB0},
++{0x40BD, 0xAA},
++{0x40BE, 0xAA},
++{0x40BF, 0xAA},
++{0x40C0, 0xA8},
++{0x40C1, 0xA4},
++{0x40C2, 0xA4},
++{0x40C3, 0xA4},
++{0x40C4, 0xA2},
++{0x40C5, 0x9F},
++{0x40C6, 0x9F},
++{0x40C7, 0x9F},
++{0x40C8, 0xA3},
++{0x40C9, 0xA0},
++{0x40CA, 0xA0},
++{0x40CB, 0xA0},
++{0x40CC, 0xA6},
++{0x40CD, 0xA3},
++{0x40CE, 0xA3},
++{0x40CF, 0xA2},
++{0x40D0, 0xAF},
++{0x40D1, 0xAB},
++{0x40D2, 0xAA},
++{0x40D3, 0xA8},
++{0x40D4, 0xBA},
++{0x40D5, 0xAE},
++{0x40D6, 0xAE},
++{0x40D7, 0xAB},
++{0x4100, 0xBD},
++{0x4101, 0xBA},
++{0x4102, 0xBD},
++{0x4103, 0xB7},
++{0x4104, 0xB7},
++{0x4105, 0xB7},
++{0x4106, 0xB8},
++{0x4107, 0xB5},
++{0x4108, 0xAB},
++{0x4109, 0xAA},
++{0x410A, 0xAC},
++{0x410B, 0xAB},
++{0x410C, 0xA4},
++{0x410D, 0xA5},
++{0x410E, 0xA5},
++{0x410F, 0xA4},
++{0x4110, 0x9F},
++{0x4111, 0xA0},
++{0x4112, 0xA0},
++{0x4113, 0x9F},
++{0x4114, 0xA0},
++{0x4115, 0xA0},
++{0x4116, 0xA0},
++{0x4117, 0x9F},
++{0x4118, 0xA1},
++{0x4119, 0xA1},
++{0x411A, 0xA1},
++{0x411B, 0xA0},
++{0x411C, 0xA7},
++{0x411D, 0xA6},
++{0x411E, 0xA6},
++{0x411F, 0xA6},
++{0x4120, 0xA7},
++{0x4121, 0xA6},
++{0x4122, 0xA6},
++{0x4123, 0xA3},
++{0x4124, 0xB9},
++{0x4125, 0xB9},
++{0x4126, 0xBA},
++{0x4127, 0xB8},
++{0x4128, 0xA6},
++{0x4129, 0xA7},
++{0x412A, 0xA7},
++{0x412B, 0xA6},
++{0x412C, 0x9B},
++{0x412D, 0x9B},
++{0x412E, 0x9B},
++{0x412F, 0x9B},
++{0x4130, 0x91},
++{0x4131, 0x92},
++{0x4132, 0x92},
++{0x4133, 0x91},
++{0x4134, 0x8C},
++{0x4135, 0x8C},
++{0x4136, 0x8C},
++{0x4137, 0x8C},
++{0x4138, 0x8D},
++{0x4139, 0x8D},
++{0x413A, 0x8D},
++{0x413B, 0x8D},
++{0x413C, 0x93},
++{0x413D, 0x93},
++{0x413E, 0x93},
++{0x413F, 0x92},
++{0x4140, 0x9A},
++{0x4141, 0x9A},
++{0x4142, 0x9A},
++{0x4143, 0x99},
++{0x4144, 0xA7},
++{0x4145, 0xA5},
++{0x4146, 0xA6},
++{0x4147, 0xA6},
++{0x4148, 0xB8},
++{0x4149, 0xB4},
++{0x414A, 0xB4},
++{0x414B, 0xB3},
++{0x414C, 0xA3},
++{0x414D, 0xA2},
++{0x414E, 0xA3},
++{0x414F, 0xA2},
++{0x4150, 0x96},
++{0x4151, 0x96},
++{0x4152, 0x96},
++{0x4153, 0x96},
++{0x4154, 0x8A},
++{0x4155, 0x8A},
++{0x4156, 0x8A},
++{0x4157, 0x8A},
++{0x4158, 0x82},
++{0x4159, 0x82},
++{0x415A, 0x82},
++{0x415B, 0x82},
++{0x415C, 0x84},
++{0x415D, 0x85},
++{0x415E, 0x84},
++{0x415F, 0x84},
++{0x4160, 0x8D},
++{0x4161, 0x8D},
++{0x4162, 0x8D},
++{0x4163, 0x8D},
++{0x4164, 0x96},
++{0x4165, 0x96},
++{0x4166, 0x96},
++{0x4167, 0x95},
++{0x4168, 0xA5},
++{0x4169, 0xA2},
++{0x416A, 0xA3},
++{0x416B, 0xA2},
++{0x416C, 0xB7},
++{0x416D, 0xB3},
++{0x416E, 0xB5},
++{0x416F, 0xB4},
++{0x4170, 0xA4},
++{0x4171, 0xA2},
++{0x4172, 0xA3},
++{0x4173, 0xA2},
++{0x4174, 0x97},
++{0x4175, 0x96},
++{0x4176, 0x96},
++{0x4177, 0x96},
++{0x4178, 0x8B},
++{0x4179, 0x8A},
++{0x417A, 0x8A},
++{0x417B, 0x8A},
++{0x417C, 0x81},
++{0x417D, 0x81},
++{0x417E, 0x81},
++{0x417F, 0x81},
++{0x4180, 0x84},
++{0x4181, 0x84},
++{0x4182, 0x84},
++{0x4183, 0x84},
++{0x4184, 0x8C},
++{0x4185, 0x8D},
++{0x4186, 0x8D},
++{0x4187, 0x8D},
++{0x4188, 0x95},
++{0x4189, 0x96},
++{0x418A, 0x96},
++{0x418B, 0x95},
++{0x418C, 0xA1},
++{0x418D, 0xA1},
++{0x418E, 0xA1},
++{0x418F, 0xA0},
++{0x4190, 0xBC},
++{0x4191, 0xB8},
++{0x4192, 0xB8},
++{0x4193, 0xB9},
++{0x4194, 0xA8},
++{0x4195, 0xA5},
++{0x4196, 0xA6},
++{0x4197, 0xA5},
++{0x4198, 0x9C},
++{0x4199, 0x9A},
++{0x419A, 0x9A},
++{0x419B, 0x9A},
++{0x419C, 0x91},
++{0x419D, 0x91},
++{0x419E, 0x91},
++{0x419F, 0x91},
++{0x41A0, 0x8B},
++{0x41A1, 0x8B},
++{0x41A2, 0x8B},
++{0x41A3, 0x8B},
++{0x41A4, 0x8C},
++{0x41A5, 0x8C},
++{0x41A6, 0x8C},
++{0x41A7, 0x8C},
++{0x41A8, 0x91},
++{0x41A9, 0x92},
++{0x41AA, 0x91},
++{0x41AB, 0x91},
++{0x41AC, 0x98},
++{0x41AD, 0x99},
++{0x41AE, 0x99},
++{0x41AF, 0x98},
++{0x41B0, 0xA3},
++{0x41B1, 0xA3},
++{0x41B2, 0xA3},
++{0x41B3, 0xA2},
++{0x41B4, 0xC1},
++{0x41B5, 0xB8},
++{0x41B6, 0xB9},
++{0x41B7, 0xBA},
++{0x41B8, 0xB8},
++{0x41B9, 0xB4},
++{0x41BA, 0xB4},
++{0x41BB, 0xB4},
++{0x41BC, 0xAA},
++{0x41BD, 0xA7},
++{0x41BE, 0xA7},
++{0x41BF, 0xA8},
++{0x41C0, 0xA4},
++{0x41C1, 0xA2},
++{0x41C2, 0xA2},
++{0x41C3, 0xA3},
++{0x41C4, 0x9E},
++{0x41C5, 0x9D},
++{0x41C6, 0x9D},
++{0x41C7, 0x9D},
++{0x41C8, 0x9E},
++{0x41C9, 0x9D},
++{0x41CA, 0x9D},
++{0x41CB, 0x9D},
++{0x41CC, 0x9E},
++{0x41CD, 0x9E},
++{0x41CE, 0x9E},
++{0x41CF, 0x9E},
++{0x41D0, 0xA3},
++{0x41D1, 0xA3},
++{0x41D2, 0xA2},
++{0x41D3, 0xA1},
++{0x41D4, 0xA7},
++{0x41D5, 0xA7},
++{0x41D6, 0xA7},
++{0x41D7, 0xA3},
++{0x4200, 0xCE},
++{0x4201, 0xC0},
++{0x4202, 0xC1},
++{0x4203, 0xB9},
++{0x4204, 0xC3},
++{0x4205, 0xB9},
++{0x4206, 0xBC},
++{0x4207, 0xBD},
++{0x4208, 0xB3},
++{0x4209, 0xAE},
++{0x420A, 0xAF},
++{0x420B, 0xAE},
++{0x420C, 0xAA},
++{0x420D, 0xA8},
++{0x420E, 0xA8},
++{0x420F, 0xA6},
++{0x4210, 0xA4},
++{0x4211, 0xA2},
++{0x4212, 0xA2},
++{0x4213, 0xA0},
++{0x4214, 0xA4},
++{0x4215, 0xA3},
++{0x4216, 0xA2},
++{0x4217, 0xA0},
++{0x4218, 0xA7},
++{0x4219, 0xA5},
++{0x421A, 0xA3},
++{0x421B, 0xA1},
++{0x421C, 0xB0},
++{0x421D, 0xA8},
++{0x421E, 0xA8},
++{0x421F, 0xA6},
++{0x4220, 0xB4},
++{0x4221, 0xAA},
++{0x4222, 0xA5},
++{0x4223, 0xA3},
++{0x4224, 0xC7},
++{0x4225, 0xBC},
++{0x4226, 0xBE},
++{0x4227, 0xBC},
++{0x4228, 0xB0},
++{0x4229, 0xA9},
++{0x422A, 0xA9},
++{0x422B, 0xA8},
++{0x422C, 0xA0},
++{0x422D, 0x9D},
++{0x422E, 0x9D},
++{0x422F, 0x9C},
++{0x4230, 0x94},
++{0x4231, 0x93},
++{0x4232, 0x93},
++{0x4233, 0x92},
++{0x4234, 0x8E},
++{0x4235, 0x8D},
++{0x4236, 0x8D},
++{0x4237, 0x8C},
++{0x4238, 0x8F},
++{0x4239, 0x8E},
++{0x423A, 0x8E},
++{0x423B, 0x8D},
++{0x423C, 0x96},
++{0x423D, 0x94},
++{0x423E, 0x94},
++{0x423F, 0x92},
++{0x4240, 0xA1},
++{0x4241, 0x9C},
++{0x4242, 0x9C},
++{0x4243, 0x99},
++{0x4244, 0xB0},
++{0x4245, 0xA8},
++{0x4246, 0xAB},
++{0x4247, 0xA7},
++{0x4248, 0xC3},
++{0x4249, 0xB7},
++{0x424A, 0xB7},
++{0x424B, 0xBC},
++{0x424C, 0xAB},
++{0x424D, 0xA4},
++{0x424E, 0xA5},
++{0x424F, 0xA5},
++{0x4250, 0x9A},
++{0x4251, 0x97},
++{0x4252, 0x97},
++{0x4253, 0x98},
++{0x4254, 0x8C},
++{0x4255, 0x8B},
++{0x4256, 0x8B},
++{0x4257, 0x8B},
++{0x4258, 0x82},
++{0x4259, 0x82},
++{0x425A, 0x82},
++{0x425B, 0x82},
++{0x425C, 0x85},
++{0x425D, 0x85},
++{0x425E, 0x85},
++{0x425F, 0x84},
++{0x4260, 0x8F},
++{0x4261, 0x8E},
++{0x4262, 0x8E},
++{0x4263, 0x8D},
++{0x4264, 0x9B},
++{0x4265, 0x98},
++{0x4266, 0x98},
++{0x4267, 0x95},
++{0x4268, 0xAE},
++{0x4269, 0xA5},
++{0x426A, 0xA7},
++{0x426B, 0xA2},
++{0x426C, 0xC2},
++{0x426D, 0xB7},
++{0x426E, 0xB8},
++{0x426F, 0xB9},
++{0x4270, 0xAA},
++{0x4271, 0xA4},
++{0x4272, 0xA4},
++{0x4273, 0xA5},
++{0x4274, 0x99},
++{0x4275, 0x96},
++{0x4276, 0x97},
++{0x4277, 0x98},
++{0x4278, 0x8B},
++{0x4279, 0x8A},
++{0x427A, 0x8A},
++{0x427B, 0x8B},
++{0x427C, 0x81},
++{0x427D, 0x81},
++{0x427E, 0x81},
++{0x427F, 0x82},
++{0x4280, 0x84},
++{0x4281, 0x84},
++{0x4282, 0x84},
++{0x4283, 0x84},
++{0x4284, 0x8E},
++{0x4285, 0x8E},
++{0x4286, 0x8D},
++{0x4287, 0x8C},
++{0x4288, 0x9A},
++{0x4289, 0x97},
++{0x428A, 0x97},
++{0x428B, 0x95},
++{0x428C, 0xAA},
++{0x428D, 0xA3},
++{0x428E, 0xA3},
++{0x428F, 0xA2},
++{0x4290, 0xC7},
++{0x4291, 0xBA},
++{0x4292, 0xC0},
++{0x4293, 0xC3},
++{0x4294, 0xB0},
++{0x4295, 0xA7},
++{0x4296, 0xA7},
++{0x4297, 0xA9},
++{0x4298, 0x9F},
++{0x4299, 0x9B},
++{0x429A, 0x9B},
++{0x429B, 0x9D},
++{0x429C, 0x93},
++{0x429D, 0x91},
++{0x429E, 0x91},
++{0x429F, 0x92},
++{0x42A0, 0x8C},
++{0x42A1, 0x8B},
++{0x42A2, 0x8B},
++{0x42A3, 0x8C},
++{0x42A4, 0x8D},
++{0x42A5, 0x8C},
++{0x42A6, 0x8C},
++{0x42A7, 0x8C},
++{0x42A8, 0x94},
++{0x42A9, 0x93},
++{0x42AA, 0x92},
++{0x42AB, 0x91},
++{0x42AC, 0x9E},
++{0x42AD, 0x9B},
++{0x42AE, 0x9B},
++{0x42AF, 0x98},
++{0x42B0, 0xAC},
++{0x42B1, 0xA6},
++{0x42B2, 0xA6},
++{0x42B3, 0xA2},
++{0x42B4, 0xCE},
++{0x42B5, 0xBA},
++{0x42B6, 0xBC},
++{0x42B7, 0xB7},
++{0x42B8, 0xC5},
++{0x42B9, 0xB5},
++{0x42BA, 0xBA},
++{0x42BB, 0xC0},
++{0x42BC, 0xB1},
++{0x42BD, 0xA8},
++{0x42BE, 0xAE},
++{0x42BF, 0xAF},
++{0x42C0, 0xA7},
++{0x42C1, 0xA3},
++{0x42C2, 0xA3},
++{0x42C3, 0xA5},
++{0x42C4, 0xA0},
++{0x42C5, 0x9D},
++{0x42C6, 0x9D},
++{0x42C7, 0x9F},
++{0x42C8, 0xA0},
++{0x42C9, 0x9E},
++{0x42CA, 0x9E},
++{0x42CB, 0x9F},
++{0x42CC, 0xA2},
++{0x42CD, 0xA0},
++{0x42CE, 0xA0},
++{0x42CF, 0xA0},
++{0x42D0, 0xA8},
++{0x42D1, 0xA5},
++{0x42D2, 0xA5},
++{0x42D3, 0xA2},
++{0x42D4, 0xB3},
++{0x42D5, 0xAA},
++{0x42D6, 0xAB},
++{0x42D7, 0xA3},
++{0x42D8, 0x00},
++{0x42D9, 0x00},
++{0x4300, 0xA2},
++{0x4301, 0xAE},
++{0x4302, 0xAD},
++{0x4303, 0xB5},
++{0x4304, 0x95},
++{0x4305, 0x9A},
++{0x4306, 0x98},
++{0x4307, 0x9B},
++{0x4308, 0x8D},
++{0x4309, 0x90},
++{0x430A, 0x8F},
++{0x430B, 0x91},
++{0x430C, 0x86},
++{0x430D, 0x88},
++{0x430E, 0x87},
++{0x430F, 0x89},
++{0x4310, 0x86},
++{0x4311, 0x87},
++{0x4312, 0x86},
++{0x4313, 0x88},
++{0x4314, 0x89},
++{0x4315, 0x88},
++{0x4316, 0x88},
++{0x4317, 0x8E},
++{0x4318, 0x90},
++{0x4319, 0x8F},
++{0x431A, 0x8C},
++{0x431B, 0x8C},
++{0x431C, 0x9C},
++{0x431D, 0x99},
++{0x431E, 0x98},
++{0x431F, 0x99},
++{0x4320, 0xAB},
++{0x4321, 0xB0},
++{0x4322, 0xAD},
++{0x4323, 0xAF},
++{0x4324, 0x9B},
++{0x4325, 0x9F},
++{0x4326, 0x9E},
++{0x4327, 0xA1},
++{0x4328, 0x8E},
++{0x4329, 0x91},
++{0x432A, 0x90},
++{0x432B, 0x93},
++{0x432C, 0x86},
++{0x432D, 0x88},
++{0x432E, 0x87},
++{0x432F, 0x89},
++{0x4330, 0x82},
++{0x4331, 0x84},
++{0x4332, 0x83},
++{0x4333, 0x84},
++{0x4334, 0x82},
++{0x4335, 0x82},
++{0x4336, 0x82},
++{0x4337, 0x83},
++{0x4338, 0x85},
++{0x4339, 0x84},
++{0x433A, 0x84},
++{0x433B, 0x85},
++{0x433C, 0x8A},
++{0x433D, 0x89},
++{0x433E, 0x88},
++{0x433F, 0x89},
++{0x4340, 0x93},
++{0x4341, 0x91},
++{0x4342, 0x91},
++{0x4343, 0x93},
++{0x4344, 0xA0},
++{0x4345, 0x9E},
++{0x4346, 0x9D},
++{0x4347, 0xA1},
++{0x4348, 0x95},
++{0x4349, 0x9B},
++{0x434A, 0x9A},
++{0x434B, 0x9C},
++{0x434C, 0x8A},
++{0x434D, 0x8D},
++{0x434E, 0x8C},
++{0x434F, 0x8D},
++{0x4350, 0x83},
++{0x4351, 0x85},
++{0x4352, 0x84},
++{0x4353, 0x85},
++{0x4354, 0x80},
++{0x4355, 0x81},
++{0x4356, 0x81},
++{0x4357, 0x81},
++{0x4358, 0x80},
++{0x4359, 0x80},
++{0x435A, 0x80},
++{0x435B, 0x80},
++{0x435C, 0x82},
++{0x435D, 0x81},
++{0x435E, 0x81},
++{0x435F, 0x81},
++{0x4360, 0x85},
++{0x4361, 0x84},
++{0x4362, 0x84},
++{0x4363, 0x85},
++{0x4364, 0x8D},
++{0x4365, 0x8B},
++{0x4366, 0x8B},
++{0x4367, 0x8D},
++{0x4368, 0x98},
++{0x4369, 0x98},
++{0x436A, 0x95},
++{0x436B, 0x98},
++{0x436C, 0x95},
++{0x436D, 0x9A},
++{0x436E, 0x99},
++{0x436F, 0x9A},
++{0x4370, 0x8A},
++{0x4371, 0x8D},
++{0x4372, 0x8C},
++{0x4373, 0x8C},
++{0x4374, 0x83},
++{0x4375, 0x85},
++{0x4376, 0x84},
++{0x4377, 0x84},
++{0x4378, 0x80},
++{0x4379, 0x80},
++{0x437A, 0x80},
++{0x437B, 0x80},
++{0x437C, 0x7F},
++{0x437D, 0x7F},
++{0x437E, 0x7F},
++{0x437F, 0x7F},
++{0x4380, 0x81},
++{0x4381, 0x80},
++{0x4382, 0x80},
++{0x4383, 0x81},
++{0x4384, 0x84},
++{0x4385, 0x83},
++{0x4386, 0x83},
++{0x4387, 0x84},
++{0x4388, 0x8B},
++{0x4389, 0x8A},
++{0x438A, 0x8A},
++{0x438B, 0x8C},
++{0x438C, 0x97},
++{0x438D, 0x96},
++{0x438E, 0x96},
++{0x438F, 0x99},
++{0x4390, 0x99},
++{0x4391, 0x9F},
++{0x4392, 0x9E},
++{0x4393, 0x9D},
++{0x4394, 0x8D},
++{0x4395, 0x90},
++{0x4396, 0x90},
++{0x4397, 0x8F},
++{0x4398, 0x85},
++{0x4399, 0x87},
++{0x439A, 0x87},
++{0x439B, 0x86},
++{0x439C, 0x81},
++{0x439D, 0x83},
++{0x439E, 0x82},
++{0x439F, 0x82},
++{0x43A0, 0x80},
++{0x43A1, 0x81},
++{0x43A2, 0x81},
++{0x43A3, 0x81},
++{0x43A4, 0x82},
++{0x43A5, 0x82},
++{0x43A6, 0x82},
++{0x43A7, 0x82},
++{0x43A8, 0x86},
++{0x43A9, 0x85},
++{0x43AA, 0x85},
++{0x43AB, 0x87},
++{0x43AC, 0x8D},
++{0x43AD, 0x8D},
++{0x43AE, 0x8D},
++{0x43AF, 0x90},
++{0x43B0, 0x9A},
++{0x43B1, 0x9A},
++{0x43B2, 0x9B},
++{0x43B3, 0x9D},
++{0x43B4, 0xA0},
++{0x43B5, 0xAD},
++{0x43B6, 0xAC},
++{0x43B7, 0xAA},
++{0x43B8, 0x93},
++{0x43B9, 0x97},
++{0x43BA, 0x97},
++{0x43BB, 0x96},
++{0x43BC, 0x8B},
++{0x43BD, 0x8E},
++{0x43BE, 0x8E},
++{0x43BF, 0x8C},
++{0x43C0, 0x83},
++{0x43C1, 0x85},
++{0x43C2, 0x85},
++{0x43C3, 0x84},
++{0x43C4, 0x82},
++{0x43C5, 0x84},
++{0x43C6, 0x83},
++{0x43C7, 0x83},
++{0x43C8, 0x83},
++{0x43C9, 0x84},
++{0x43CA, 0x84},
++{0x43CB, 0x85},
++{0x43CC, 0x8A},
++{0x43CD, 0x8A},
++{0x43CE, 0x8A},
++{0x43CF, 0x8C},
++{0x43D0, 0x92},
++{0x43D1, 0x93},
++{0x43D2, 0x93},
++{0x43D3, 0x96},
++{0x43D4, 0x9F},
++{0x43D5, 0xA6},
++{0x43D6, 0xA5},
++{0x43D7, 0xAA},
++{0x4400, 0xA1},
++{0x4401, 0xAB},
++{0x4402, 0xA7},
++{0x4403, 0xB0},
++{0x4404, 0x91},
++{0x4405, 0x96},
++{0x4406, 0x94},
++{0x4407, 0x99},
++{0x4408, 0x8A},
++{0x4409, 0x8E},
++{0x440A, 0x8C},
++{0x440B, 0x8F},
++{0x440C, 0x85},
++{0x440D, 0x86},
++{0x440E, 0x86},
++{0x440F, 0x88},
++{0x4410, 0x85},
++{0x4411, 0x86},
++{0x4412, 0x85},
++{0x4413, 0x87},
++{0x4414, 0x88},
++{0x4415, 0x87},
++{0x4416, 0x87},
++{0x4417, 0x89},
++{0x4418, 0x91},
++{0x4419, 0x8F},
++{0x441A, 0x8F},
++{0x441B, 0x90},
++{0x441C, 0x9C},
++{0x441D, 0x9B},
++{0x441E, 0x9A},
++{0x441F, 0x9A},
++{0x4420, 0xB3},
++{0x4421, 0xB1},
++{0x4422, 0xB0},
++{0x4423, 0xB2},
++{0x4424, 0x96},
++{0x4425, 0x9C},
++{0x4426, 0x9A},
++{0x4427, 0x9E},
++{0x4428, 0x8B},
++{0x4429, 0x8F},
++{0x442A, 0x8E},
++{0x442B, 0x91},
++{0x442C, 0x84},
++{0x442D, 0x87},
++{0x442E, 0x86},
++{0x442F, 0x88},
++{0x4430, 0x82},
++{0x4431, 0x83},
++{0x4432, 0x82},
++{0x4433, 0x84},
++{0x4434, 0x82},
++{0x4435, 0x82},
++{0x4436, 0x82},
++{0x4437, 0x83},
++{0x4438, 0x84},
++{0x4439, 0x84},
++{0x443A, 0x84},
++{0x443B, 0x84},
++{0x443C, 0x8B},
++{0x443D, 0x89},
++{0x443E, 0x89},
++{0x443F, 0x89},
++{0x4440, 0x95},
++{0x4441, 0x93},
++{0x4442, 0x93},
++{0x4443, 0x93},
++{0x4444, 0xA2},
++{0x4445, 0xA2},
++{0x4446, 0xA1},
++{0x4447, 0xA0},
++{0x4448, 0x8F},
++{0x4449, 0x97},
++{0x444A, 0x97},
++{0x444B, 0x98},
++{0x444C, 0x87},
++{0x444D, 0x8B},
++{0x444E, 0x8A},
++{0x444F, 0x8B},
++{0x4450, 0x81},
++{0x4451, 0x83},
++{0x4452, 0x83},
++{0x4453, 0x84},
++{0x4454, 0x7F},
++{0x4455, 0x80},
++{0x4456, 0x80},
++{0x4457, 0x81},
++{0x4458, 0x80},
++{0x4459, 0x80},
++{0x445A, 0x80},
++{0x445B, 0x80},
++{0x445C, 0x82},
++{0x445D, 0x81},
++{0x445E, 0x81},
++{0x445F, 0x81},
++{0x4460, 0x87},
++{0x4461, 0x85},
++{0x4462, 0x85},
++{0x4463, 0x86},
++{0x4464, 0x90},
++{0x4465, 0x8E},
++{0x4466, 0x8E},
++{0x4467, 0x8E},
++{0x4468, 0x9B},
++{0x4469, 0x9C},
++{0x446A, 0x9A},
++{0x446B, 0x9A},
++{0x446C, 0x91},
++{0x446D, 0x97},
++{0x446E, 0x95},
++{0x446F, 0x95},
++{0x4470, 0x87},
++{0x4471, 0x8A},
++{0x4472, 0x8A},
++{0x4473, 0x89},
++{0x4474, 0x81},
++{0x4475, 0x83},
++{0x4476, 0x83},
++{0x4477, 0x83},
++{0x4478, 0x7F},
++{0x4479, 0x80},
++{0x447A, 0x80},
++{0x447B, 0x80},
++{0x447C, 0x80},
++{0x447D, 0x80},
++{0x447E, 0x80},
++{0x447F, 0x7F},
++{0x4480, 0x81},
++{0x4481, 0x81},
++{0x4482, 0x81},
++{0x4483, 0x81},
++{0x4484, 0x85},
++{0x4485, 0x85},
++{0x4486, 0x85},
++{0x4487, 0x85},
++{0x4488, 0x8E},
++{0x4489, 0x8D},
++{0x448A, 0x8D},
++{0x448B, 0x8E},
++{0x448C, 0x9D},
++{0x448D, 0x9C},
++{0x448E, 0x9C},
++{0x448F, 0x9C},
++{0x4490, 0x94},
++{0x4491, 0x9B},
++{0x4492, 0x9A},
++{0x4493, 0x97},
++{0x4494, 0x8A},
++{0x4495, 0x8E},
++{0x4496, 0x8E},
++{0x4497, 0x8C},
++{0x4498, 0x84},
++{0x4499, 0x86},
++{0x449A, 0x86},
++{0x449B, 0x84},
++{0x449C, 0x81},
++{0x449D, 0x83},
++{0x449E, 0x83},
++{0x449F, 0x81},
++{0x44A0, 0x81},
++{0x44A1, 0x82},
++{0x44A2, 0x82},
++{0x44A3, 0x81},
++{0x44A4, 0x83},
++{0x44A5, 0x83},
++{0x44A6, 0x83},
++{0x44A7, 0x83},
++{0x44A8, 0x88},
++{0x44A9, 0x88},
++{0x44AA, 0x88},
++{0x44AB, 0x88},
++{0x44AC, 0x91},
++{0x44AD, 0x91},
++{0x44AE, 0x91},
++{0x44AF, 0x92},
++{0x44B0, 0xA0},
++{0x44B1, 0xA0},
++{0x44B2, 0xA0},
++{0x44B3, 0xA0},
++{0x44B4, 0x9E},
++{0x44B5, 0xA9},
++{0x44B6, 0xA8},
++{0x44B7, 0xA3},
++{0x44B8, 0x90},
++{0x44B9, 0x95},
++{0x44BA, 0x95},
++{0x44BB, 0x92},
++{0x44BC, 0x8A},
++{0x44BD, 0x8E},
++{0x44BE, 0x8E},
++{0x44BF, 0x8B},
++{0x44C0, 0x84},
++{0x44C1, 0x86},
++{0x44C2, 0x86},
++{0x44C3, 0x84},
++{0x44C4, 0x84},
++{0x44C5, 0x85},
++{0x44C6, 0x85},
++{0x44C7, 0x84},
++{0x44C8, 0x86},
++{0x44C9, 0x87},
++{0x44CA, 0x87},
++{0x44CB, 0x86},
++{0x44CC, 0x8D},
++{0x44CD, 0x8E},
++{0x44CE, 0x8E},
++{0x44CF, 0x8D},
++{0x44D0, 0x98},
++{0x44D1, 0x98},
++{0x44D2, 0x99},
++{0x44D3, 0x9A},
++{0x44D4, 0xA9},
++{0x44D5, 0xAA},
++{0x44D6, 0xAA},
++{0x44D7, 0xAD},
++{0x4500, 0x9F},
++{0x4501, 0xA8},
++{0x4502, 0xA5},
++{0x4503, 0xAF},
++{0x4504, 0x8F},
++{0x4505, 0x96},
++{0x4506, 0x92},
++{0x4507, 0x94},
++{0x4508, 0x89},
++{0x4509, 0x8D},
++{0x450A, 0x8A},
++{0x450B, 0x8E},
++{0x450C, 0x84},
++{0x450D, 0x85},
++{0x450E, 0x84},
++{0x450F, 0x87},
++{0x4510, 0x84},
++{0x4511, 0x85},
++{0x4512, 0x84},
++{0x4513, 0x86},
++{0x4514, 0x87},
++{0x4515, 0x86},
++{0x4516, 0x86},
++{0x4517, 0x88},
++{0x4518, 0x8F},
++{0x4519, 0x8D},
++{0x451A, 0x8D},
++{0x451B, 0x8F},
++{0x451C, 0x9A},
++{0x451D, 0x9A},
++{0x451E, 0x98},
++{0x451F, 0x9A},
++{0x4520, 0xAF},
++{0x4521, 0xAF},
++{0x4522, 0xB2},
++{0x4523, 0xB1},
++{0x4524, 0x95},
++{0x4525, 0x9B},
++{0x4526, 0x97},
++{0x4527, 0x9C},
++{0x4528, 0x8A},
++{0x4529, 0x8E},
++{0x452A, 0x8D},
++{0x452B, 0x90},
++{0x452C, 0x84},
++{0x452D, 0x86},
++{0x452E, 0x85},
++{0x452F, 0x87},
++{0x4530, 0x81},
++{0x4531, 0x82},
++{0x4532, 0x82},
++{0x4533, 0x83},
++{0x4534, 0x81},
++{0x4535, 0x81},
++{0x4536, 0x81},
++{0x4537, 0x82},
++{0x4538, 0x84},
++{0x4539, 0x83},
++{0x453A, 0x83},
++{0x453B, 0x84},
++{0x453C, 0x8A},
++{0x453D, 0x88},
++{0x453E, 0x88},
++{0x453F, 0x89},
++{0x4540, 0x94},
++{0x4541, 0x92},
++{0x4542, 0x91},
++{0x4543, 0x92},
++{0x4544, 0xA1},
++{0x4545, 0xA0},
++{0x4546, 0x9C},
++{0x4547, 0x9D},
++{0x4548, 0x8F},
++{0x4549, 0x96},
++{0x454A, 0x95},
++{0x454B, 0x92},
++{0x454C, 0x87},
++{0x454D, 0x8A},
++{0x454E, 0x89},
++{0x454F, 0x8A},
++{0x4550, 0x81},
++{0x4551, 0x83},
++{0x4552, 0x82},
++{0x4553, 0x83},
++{0x4554, 0x7F},
++{0x4555, 0x80},
++{0x4556, 0x80},
++{0x4557, 0x81},
++{0x4558, 0x7F},
++{0x4559, 0x80},
++{0x455A, 0x7F},
++{0x455B, 0x80},
++{0x455C, 0x81},
++{0x455D, 0x81},
++{0x455E, 0x81},
++{0x455F, 0x81},
++{0x4560, 0x86},
++{0x4561, 0x85},
++{0x4562, 0x85},
++{0x4563, 0x85},
++{0x4564, 0x8F},
++{0x4565, 0x8D},
++{0x4566, 0x8D},
++{0x4567, 0x8D},
++{0x4568, 0x99},
++{0x4569, 0x9A},
++{0x456A, 0x97},
++{0x456B, 0x99},
++{0x456C, 0x90},
++{0x456D, 0x95},
++{0x456E, 0x93},
++{0x456F, 0x92},
++{0x4570, 0x87},
++{0x4571, 0x8A},
++{0x4572, 0x88},
++{0x4573, 0x87},
++{0x4574, 0x81},
++{0x4575, 0x83},
++{0x4576, 0x82},
++{0x4577, 0x82},
++{0x4578, 0x7F},
++{0x4579, 0x80},
++{0x457A, 0x80},
++{0x457B, 0x80},
++{0x457C, 0x80},
++{0x457D, 0x80},
++{0x457E, 0x80},
++{0x457F, 0x80},
++{0x4580, 0x81},
++{0x4581, 0x81},
++{0x4582, 0x81},
++{0x4583, 0x81},
++{0x4584, 0x85},
++{0x4585, 0x85},
++{0x4586, 0x84},
++{0x4587, 0x85},
++{0x4588, 0x8E},
++{0x4589, 0x8D},
++{0x458A, 0x8C},
++{0x458B, 0x8D},
++{0x458C, 0x9B},
++{0x458D, 0x9B},
++{0x458E, 0x9A},
++{0x458F, 0x98},
++{0x4590, 0x94},
++{0x4591, 0x9A},
++{0x4592, 0x94},
++{0x4593, 0x90},
++{0x4594, 0x8A},
++{0x4595, 0x8D},
++{0x4596, 0x8C},
++{0x4597, 0x89},
++{0x4598, 0x84},
++{0x4599, 0x86},
++{0x459A, 0x85},
++{0x459B, 0x83},
++{0x459C, 0x82},
++{0x459D, 0x83},
++{0x459E, 0x82},
++{0x459F, 0x80},
++{0x45A0, 0x81},
++{0x45A1, 0x82},
++{0x45A2, 0x81},
++{0x45A3, 0x80},
++{0x45A4, 0x83},
++{0x45A5, 0x83},
++{0x45A6, 0x83},
++{0x45A7, 0x83},
++{0x45A8, 0x88},
++{0x45A9, 0x87},
++{0x45AA, 0x87},
++{0x45AB, 0x88},
++{0x45AC, 0x91},
++{0x45AD, 0x90},
++{0x45AE, 0x90},
++{0x45AF, 0x91},
++{0x45B0, 0x9F},
++{0x45B1, 0x9F},
++{0x45B2, 0x9E},
++{0x45B3, 0x9F},
++{0x45B4, 0x9F},
++{0x45B5, 0xA8},
++{0x45B6, 0xA6},
++{0x45B7, 0xA7},
++{0x45B8, 0x8D},
++{0x45B9, 0x95},
++{0x45BA, 0x90},
++{0x45BB, 0x8A},
++{0x45BC, 0x89},
++{0x45BD, 0x8D},
++{0x45BE, 0x88},
++{0x45BF, 0x86},
++{0x45C0, 0x84},
++{0x45C1, 0x86},
++{0x45C2, 0x85},
++{0x45C3, 0x82},
++{0x45C4, 0x84},
++{0x45C5, 0x85},
++{0x45C6, 0x85},
++{0x45C7, 0x83},
++{0x45C8, 0x86},
++{0x45C9, 0x86},
++{0x45CA, 0x86},
++{0x45CB, 0x85},
++{0x45CC, 0x8E},
++{0x45CD, 0x8D},
++{0x45CE, 0x8D},
++{0x45CF, 0x8C},
++{0x45D0, 0x99},
++{0x45D1, 0x98},
++{0x45D2, 0x98},
++{0x45D3, 0x98},
++{0x45D4, 0xA6},
++{0x45D5, 0xA9},
++{0x45D6, 0xA7},
++{0x45D7, 0xAC},
++{0x7000, 0xAB},
++{0x7001, 0xBA},
++{0x7002, 0x40},
++{0x7003, 0x02},
++{0x7004, 0x00},
++{0x7005, 0x00},
++{0x7006, 0x00},
++{0x7007, 0x00},
++{0x7008, 0x00},
++{0x7009, 0x00},
++{0x700A, 0x00},
++{0x700B, 0x00},
++{0x700C, 0x00},
++{0x700D, 0x00},
++{0x700E, 0x00},
++{0x700F, 0x00},
++{0x7010, 0x55},
++{0x7011, 0x88},
++{0x7012, 0x40},
++{0x7013, 0x01},
++{0x7014, 0x72},
++{0x7015, 0xF1},
++{0x7016, 0x02},
++{0x7017, 0xF8},
++{0x7018, 0x00},
++{0x7019, 0x00},
++{0x701A, 0x00},
++{0x701B, 0x00},
++{0x701C, 0x00},
++{0x701D, 0x00},
++{0x701E, 0x00},
++{0x701F, 0x00},
++{0x7020, 0x00},
++{0x7021, 0x00},
++{0x7022, 0x00},
++{0x7023, 0x00},
++{0x7024, 0x00},
++{0x7025, 0x00},
++{0x7026, 0x00},
++{0x7027, 0x00},
++{0x7028, 0x00},
++{0x7029, 0x00},
++{0x702A, 0x00},
++{0x702B, 0x00},
++{0x702C, 0x00},
++{0x702D, 0x00},
++{0x702E, 0x00},
++{0x702F, 0x00},
++{0x7030, 0x00},
++{0x7031, 0x00},
++{0x7032, 0x00},
++{0x7033, 0x00},
++{0x7034, 0x00},
++{0x7035, 0x00},
++{0x7036, 0x00},
++{0x7037, 0x00},
++{0x7038, 0x00},
++{0x7039, 0x00},
++{0x703A, 0x00},
++{0x703B, 0x00},
++{0x703C, 0x00},
++{0x703D, 0x00},
++{0x703E, 0x00},
++{0x703F, 0x00},
++{0x7040, 0x00},
++{0x7041, 0x00},
++{0x7042, 0x00},
++{0x7043, 0x00},
++{0x7044, 0x00},
++{0x7045, 0x00},
++{0x7046, 0x00},
++{0x7047, 0x00},
++{0x7048, 0x00},
++{0x7049, 0x00},
++{0x704A, 0x00},
++{0x704B, 0x00},
++{0x704C, 0x00},
++{0x704D, 0x00},
++{0x704E, 0x00},
++{0x704F, 0x00},
++{0x7050, 0x00},
++{0x7051, 0x00},
++{0x7052, 0x00},
++{0x7053, 0x00},
++{0x7054, 0x00},
++{0x7055, 0x00},
++{0x7056, 0x00},
++{0x7057, 0x00},
++{0x7058, 0x00},
++{0x7059, 0x00},
++{0x705A, 0x00},
++{0x705B, 0x00},
++{0x705C, 0x00},
++{0x705D, 0x00},
++{0x705E, 0x00},
++{0x705F, 0x00},
++{0x7060, 0x00},
++{0x7061, 0x00},
++{0x7062, 0x00},
++{0x7063, 0x00},
++{0x7064, 0x00},
++{0x7065, 0x00},
++{0x7066, 0x00},
++{0x7067, 0x00},
++{0x7068, 0x00},
++{0x7069, 0x00},
++{0x706A, 0x00},
++{0x706B, 0x00},
++{0x706C, 0x00},
++{0x706D, 0x00},
++{0x706E, 0x00},
++{0x706F, 0x00},
++{0x7070, 0x00},
++{0x7071, 0x00},
++{0x7072, 0x00},
++{0x7073, 0x00},
++{0x7074, 0x00},
++{0x7075, 0x00},
++{0x7076, 0x00},
++{0x7077, 0x00},
++{0x7078, 0x00},
++{0x7079, 0x00},
++{0x707A, 0x00},
++{0x707B, 0x00},
++{0x707C, 0x00},
++{0x707D, 0x00},
++{0x707E, 0x00},
++{0x707F, 0x00},
++{0x7080, 0x00},
++{0x7081, 0x00},
++{0x7082, 0x00},
++{0x7083, 0x00},
++{0x7084, 0x00},
++{0x7085, 0x00},
++{0x7086, 0x00},
++{0x7087, 0x00},
++{0x7088, 0x00},
++{0x7089, 0x00},
++{0x708A, 0x00},
++{0x708B, 0x00},
++{0x708C, 0x00},
++{0x708D, 0x00},
++{0x708E, 0x00},
++{0x708F, 0x00},
++{0x7090, 0x00},
++{0x7091, 0xF0},
++{0x7092, 0x02},
++{0x7093, 0xF8},
++{0x7094, 0x8D},
++{0x7095, 0xF6},
++{0x7096, 0xFA},
++{0x7097, 0xFF},
++{0x7098, 0xF0},
++{0x7099, 0xB5},
++{0x709A, 0x04},
++{0x709B, 0x46},
++{0x709C, 0x8F},
++{0x709D, 0xB0},
++{0x709E, 0x5F},
++{0x709F, 0x48},
++{0x70A0, 0x0C},
++{0x70A1, 0x90},
++{0x70A2, 0x5F},
++{0x70A3, 0x48},
++{0x70A4, 0x06},
++{0x70A5, 0x90},
++{0x70A6, 0x20},
++{0x70A7, 0x46},
++{0x70A8, 0x34},
++{0x70A9, 0x30},
++{0x70AA, 0x0B},
++{0x70AB, 0x90},
++{0x70AC, 0x5B},
++{0x70AD, 0x48},
++{0x70AE, 0x5A},
++{0x70AF, 0x49},
++{0x70B0, 0x26},
++{0x70B1, 0x46},
++{0x70B2, 0x66},
++{0x70B3, 0x30},
++{0x70B4, 0x3A},
++{0x70B5, 0x31},
++{0x70B6, 0x3C},
++{0x70B7, 0x36},
++{0x70B8, 0x05},
++{0x70B9, 0x90},
++{0x70BA, 0x0A},
++{0x70BB, 0x30},
++{0x70BC, 0x04},
++{0x70BD, 0x90},
++{0x70BE, 0x59},
++{0x70BF, 0x48},
++{0x70C0, 0x55},
++{0x70C1, 0x4A},
++{0x70C2, 0x40},
++{0x70C3, 0x6E},
++{0x70C4, 0xC0},
++{0x70C5, 0x07},
++{0x70C6, 0x7D},
++{0x70C7, 0xD1},
++{0x70C8, 0x17},
++{0x70C9, 0x88},
++{0x70CA, 0x0A},
++{0x70CB, 0x5E},
++{0x70CC, 0x0D},
++{0x70CD, 0x92},
++{0x70CE, 0x53},
++{0x70CF, 0x49},
++{0x70D0, 0x55},
++{0x70D1, 0x48},
++{0x70D2, 0x94},
++{0x70D3, 0x31},
++{0x70D4, 0x89},
++{0x70D5, 0x6B},
++{0x70D6, 0x80},
++{0x70D7, 0x68},
++{0x70D8, 0x09},
++{0x70D9, 0x02},
++{0x70DA, 0x00},
++{0x70DB, 0x03},
++{0x70DC, 0x09},
++{0x70DD, 0x0E},
++{0x70DE, 0x00},
++{0x70DF, 0x0B},
++{0x70E0, 0x49},
++{0x70E1, 0x1C},
++{0x70E2, 0x48},
++{0x70E3, 0x43},
++{0x70E4, 0x4D},
++{0x70E5, 0x49},
++{0x70E6, 0x6C},
++{0x70E7, 0x39},
++{0x70E8, 0x8A},
++{0x70E9, 0x6A},
++{0x70EA, 0x07},
++{0x70EB, 0x92},
++{0x70EC, 0xCA},
++{0x70ED, 0x6A},
++{0x70EE, 0x00},
++{0x70EF, 0x21},
++{0x70F0, 0xC9},
++{0x70F1, 0x43},
++{0x70F2, 0x03},
++{0x70F3, 0x92},
++{0x70F4, 0x00},
++{0x70F5, 0x22},
++{0x70F6, 0x00},
++{0x70F7, 0x91},
++{0x70F8, 0x01},
++{0x70F9, 0x92},
++{0x70FA, 0x39},
++{0x70FB, 0x46},
++{0x70FC, 0x8F},
++{0x70FD, 0xF6},
++{0x70FE, 0xCE},
++{0x70FF, 0xFB},
++{0x7100, 0x01},
++{0x7101, 0x22},
++{0x7102, 0x00},
++{0x7103, 0x23},
++{0x7104, 0x8C},
++{0x7105, 0xF6},
++{0x7106, 0x02},
++{0x7107, 0xFA},
++{0x7108, 0x00},
++{0x7109, 0x21},
++{0x710A, 0x05},
++{0x710B, 0x46},
++{0x710C, 0x01},
++{0x710D, 0x91},
++{0x710E, 0x00},
++{0x710F, 0x90},
++{0x7110, 0x39},
++{0x7111, 0x46},
++{0x7112, 0x07},
++{0x7113, 0x98},
++{0x7114, 0x8F},
++{0x7115, 0xF6},
++{0x7116, 0xC2},
++{0x7117, 0xFB},
++{0x7118, 0x0D},
++{0x7119, 0x9A},
++{0x711A, 0xD3},
++{0x711B, 0x17},
++{0x711C, 0x80},
++{0x711D, 0x18},
++{0x711E, 0x59},
++{0x711F, 0x41},
++{0x7120, 0x01},
++{0x7121, 0x22},
++{0x7122, 0x00},
++{0x7123, 0x23},
++{0x7124, 0x8C},
++{0x7125, 0xF6},
++{0x7126, 0xCD},
++{0x7127, 0xF9},
++{0x7128, 0x07},
++{0x7129, 0x90},
++{0x712A, 0x00},
++{0x712B, 0x20},
++{0x712C, 0x01},
++{0x712D, 0x90},
++{0x712E, 0x00},
++{0x712F, 0x95},
++{0x7130, 0x39},
++{0x7131, 0x46},
++{0x7132, 0x03},
++{0x7133, 0x98},
++{0x7134, 0x8F},
++{0x7135, 0xF6},
++{0x7136, 0xB2},
++{0x7137, 0xFB},
++{0x7138, 0x01},
++{0x7139, 0x22},
++{0x713A, 0x00},
++{0x713B, 0x23},
++{0x713C, 0x8C},
++{0x713D, 0xF6},
++{0x713E, 0xE6},
++{0x713F, 0xF9},
++{0x7140, 0x02},
++{0x7141, 0x46},
++{0x7142, 0x07},
++{0x7143, 0x98},
++{0x7144, 0x00},
++{0x7145, 0x23},
++{0x7146, 0x81},
++{0x7147, 0x0B},
++{0x7148, 0x80},
++{0x7149, 0x04},
++{0x714A, 0x7A},
++{0x714B, 0xF6},
++{0x714C, 0x54},
++{0x714D, 0xF8},
++{0x714E, 0x37},
++{0x714F, 0x4A},
++{0x7150, 0x00},
++{0x7151, 0x23},
++{0x7152, 0x00},
++{0x7153, 0x92},
++{0x7154, 0x01},
++{0x7155, 0x93},
++{0x7156, 0x01},
++{0x7157, 0x22},
++{0x7158, 0x8C},
++{0x7159, 0xF6},
++{0x715A, 0xD8},
++{0x715B, 0xF9},
++{0x715C, 0x05},
++{0x715D, 0x46},
++{0x715E, 0x60},
++{0x715F, 0x68},
++{0x7160, 0x00},
++{0x7161, 0x23},
++{0x7162, 0x01},
++{0x7163, 0x0C},
++{0x7164, 0x00},
++{0x7165, 0x04},
++{0x7166, 0xE2},
++{0x7167, 0x68},
++{0x7168, 0x7A},
++{0x7169, 0xF6},
++{0x716A, 0x45},
++{0x716B, 0xF8},
++{0x716C, 0x00},
++{0x716D, 0x22},
++{0x716E, 0xD2},
++{0x716F, 0x43},
++{0x7170, 0x00},
++{0x7171, 0x23},
++{0x7172, 0x00},
++{0x7173, 0x92},
++{0x7174, 0x01},
++{0x7175, 0x93},
++{0x7176, 0x1A},
++{0x7177, 0x46},
++{0x7178, 0x8C},
++{0x7179, 0xF6},
++{0x717A, 0xC8},
++{0x717B, 0xF9},
++{0x717C, 0x29},
++{0x717D, 0x46},
++{0x717E, 0x8F},
++{0x717F, 0xF6},
++{0x7180, 0x8D},
++{0x7181, 0xFB},
++{0x7182, 0x8A},
++{0x7183, 0x03},
++{0x7184, 0x80},
++{0x7185, 0x0C},
++{0x7186, 0x10},
++{0x7187, 0x43},
++{0x7188, 0x00},
++{0x7189, 0x22},
++{0x718A, 0xD2},
++{0x718B, 0x43},
++{0x718C, 0x00},
++{0x718D, 0x23},
++{0x718E, 0x00},
++{0x718F, 0x92},
++{0x7190, 0x89},
++{0x7191, 0x0C},
++{0x7192, 0x01},
++{0x7193, 0x93},
++{0x7194, 0x1A},
++{0x7195, 0x46},
++{0x7196, 0x8C},
++{0x7197, 0xF6},
++{0x7198, 0xB9},
++{0x7199, 0xF9},
++{0x719A, 0x00},
++{0x719B, 0x24},
++{0x719C, 0x03},
++{0x719D, 0x90},
++{0x719E, 0x0C},
++{0x719F, 0x98},
++{0x71A0, 0x61},
++{0x71A1, 0x00},
++{0x71A2, 0x45},
++{0x71A3, 0x5A},
++{0x71A4, 0x06},
++{0x71A5, 0x98},
++{0x71A6, 0x22},
++{0x71A7, 0x4A},
++{0x71A8, 0x40},
++{0x71A9, 0x5A},
++{0x71AA, 0x00},
++{0x71AB, 0x21},
++{0x71AC, 0x8C},
++{0x71AD, 0xF6},
++{0x71AE, 0xBE},
++{0x71AF, 0xF9},
++{0x71B0, 0x07},
++{0x71B1, 0x46},
++{0x71B2, 0x28},
++{0x71B3, 0x46},
++{0x71B4, 0x03},
++{0x71B5, 0x99},
++{0x71B6, 0x8F},
++{0x71B7, 0xF6},
++{0x71B8, 0x71},
++{0x71B9, 0xFB},
++{0x71BA, 0x3A},
++{0x71BB, 0x46},
++{0x71BC, 0x00},
++{0x71BD, 0x23},
++{0x71BE, 0x79},
++{0x71BF, 0xF6},
++{0x71C0, 0xCA},
++{0x71C1, 0xFF},
++{0x71C2, 0x00},
++{0x71C3, 0xE0},
++{0x71C4, 0x0F},
++{0x71C5, 0xE0},
++{0x71C6, 0x8A},
++{0x71C7, 0x02},
++{0x71C8, 0x80},
++{0x71C9, 0x0D},
++{0x71CA, 0x10},
++{0x71CB, 0x43},
++{0x71CC, 0x19},
++{0x71CD, 0x4A},
++{0x71CE, 0x00},
++{0x71CF, 0x23},
++{0x71D0, 0x00},
++{0x71D1, 0x92},
++{0x71D2, 0x89},
++{0x71D3, 0x0D},
++{0x71D4, 0x01},
++{0x71D5, 0x93},
++{0x71D6, 0x40},
++{0x71D7, 0x22},
++{0x71D8, 0x8C},
++{0x71D9, 0xF6},
++{0x71DA, 0x98},
++{0x71DB, 0xF9},
++{0x71DC, 0xA1},
++{0x71DD, 0x00},
++{0x71DE, 0x64},
++{0x71DF, 0x1C},
++{0x71E0, 0x70},
++{0x71E1, 0x50},
++{0x71E2, 0x04},
++{0x71E3, 0x2C},
++{0x71E4, 0xDB},
++{0x71E5, 0xD3},
++{0x71E6, 0x14},
++{0x71E7, 0x4D},
++{0x71E8, 0x00},
++{0x71E9, 0x24},
++{0x71EA, 0x0B},
++{0x71EB, 0x98},
++{0x71EC, 0x67},
++{0x71ED, 0x00},
++{0x71EE, 0xC0},
++{0x71EF, 0x5B},
++{0x71F0, 0x2A},
++{0x71F1, 0x46},
++{0x71F2, 0x40},
++{0x71F3, 0x21},
++{0x71F4, 0x8C},
++{0x71F5, 0xF6},
++{0x71F6, 0x9A},
++{0x71F7, 0xF9},
++{0x71F8, 0x05},
++{0x71F9, 0x99},
++{0x71FA, 0x0E},
++{0x71FB, 0x4A},
++{0x71FC, 0xC8},
++{0x71FD, 0x53},
++{0x71FE, 0xA7},
++{0x71FF, 0x00},
++{0x7200, 0xF0},
++{0x7201, 0x59},
++{0x7202, 0x40},
++{0x7203, 0x21},
++{0x7204, 0x8C},
++{0x7205, 0xF6},
++{0x7206, 0x7B},
++{0x7207, 0xF9},
++{0x7208, 0x04},
++{0x7209, 0x99},
++{0x720A, 0x64},
++{0x720B, 0x1C},
++{0x720C, 0xC8},
++{0x720D, 0x51},
++{0x720E, 0x04},
++{0x720F, 0x2C},
++{0x7210, 0xEB},
++{0x7211, 0xD3},
++{0x7212, 0x0F},
++{0x7213, 0xB0},
++{0x7214, 0xF0},
++{0x7215, 0xBD},
++{0x7216, 0x00},
++{0x7217, 0x00},
++{0x7218, 0x76},
++{0x7219, 0x69},
++{0x721A, 0x18},
++{0x721B, 0x00},
++{0x721C, 0xEC},
++{0x721D, 0x58},
++{0x721E, 0x18},
++{0x721F, 0x00},
++{0x7220, 0x38},
++{0x7221, 0x36},
++{0x7222, 0x18},
++{0x7223, 0x00},
++{0x7224, 0x00},
++{0x7225, 0x35},
++{0x7226, 0x18},
++{0x7227, 0x00},
++{0x7228, 0x00},
++{0x7229, 0x20},
++{0x722A, 0x18},
++{0x722B, 0x00},
++{0x722C, 0xFF},
++{0x722D, 0xFF},
++{0x722E, 0xFF},
++{0x722F, 0x3F},
++{0x7230, 0xFF},
++{0x7231, 0x07},
++{0x7232, 0x00},
++{0x7233, 0x00},
++{0x7234, 0xFF},
++{0x7235, 0xFF},
++{0x7236, 0x07},
++{0x7237, 0x00},
++{0x7238, 0xFF},
++{0x7239, 0x1F},
++{0x723A, 0x00},
++{0x723B, 0x00},
++{0x723C, 0x01},
++{0x723D, 0xF6},
++{0x723E, 0x45},
++{0x723F, 0x12},
++{0x0000, 0x00},
++};
diff --git a/drivers/media/i2c/soc_camera/max9286.c b/drivers/media/i2c/soc_camera/max9286.c
new file mode 100644
-index 0000000..20ef2de
+index 0000000..c850196
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/max9286.c
-@@ -0,0 +1,672 @@
+@@ -0,0 +1,692 @@
+/*
+ * MAXIM max9286 GMSL driver
+ *
@@ -1535,7 +6508,6 @@ index 0000000..20ef2de
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/of_gpio.h>
-+#include <linux/regulator/consumer.h>
+#include <linux/videodev2.h>
+
+#include <media/v4l2-common.h>
@@ -1572,37 +6544,52 @@ index 0000000..20ef2de
+ int hsync;
+ int vsync;
+ int timeout;
++ int poc_delay;
+ atomic_t use_count;
+ u32 csi2_outord;
+ struct i2c_client *client;
+ int max9271_addr_map[4];
+ int ser_id;
-+ struct regulator *poc_supply[4]; /* PoC power supply */
++ struct gpio_desc *poc_gpio[4]; /* PoC power supply */
+};
+
++static char fsync_mode_default[20] = "manual"; /* manual, automatic, semi-automatic, external */
++
+static int conf_link;
+module_param(conf_link, int, 0644);
+MODULE_PARM_DESC(conf_link, " Force configuration link. Used only if robust firmware flashing required (f.e. recovery)");
+
+static int poc_trig;
+module_param(poc_trig, int, 0644);
-+MODULE_PARM_DESC(poc_trig, " Use PoC triggering during reverse channel setup. Useful on systems with dedicated PoC and unstable ser-des lock */");
++MODULE_PARM_DESC(poc_trig, " Use PoC triggering during reverse channel setup. Useful on systems with dedicated PoC and unstable ser-des lock");
+
+static int him;
+module_param(him, int, 0644);
-+MODULE_PARM_DESC(him, " Use High-Immunity mode (default: leagacy mode) */");
++MODULE_PARM_DESC(him, " Use High-Immunity mode (default: leagacy mode)");
+
+static int fsync_period;
+module_param(fsync_period, int, 0644);
-+MODULE_PARM_DESC(fsync_period, " Frame sync period (default: 3.2MHz) */");
++MODULE_PARM_DESC(fsync_period, " Frame sync period (default: 3.2MHz)");
+
+static int hsync;
+module_param(hsync, int, 0644);
-+MODULE_PARM_DESC(hsync, " HSYNC invertion (default: 0 - not inverted) */");
++MODULE_PARM_DESC(hsync, " HSYNC invertion (default: 0 - not inverted)");
+
+static int vsync = 1;
+module_param(vsync, int, 0644);
-+MODULE_PARM_DESC(vsync, " VSYNC invertion (default: 1 - inverted) */");
++MODULE_PARM_DESC(vsync, " VSYNC invertion (default: 1 - inverted)");
++
++static int gpio_resetb;
++module_param(gpio_resetb, int, 0644);
++MODULE_PARM_DESC(gpio_resetb, " Serializer GPIO reset (default: 0 - not used)");
++
++static int active_low_resetb;
++module_param(active_low_resetb, int, 0644);
++MODULE_PARM_DESC(active_low_resetb, " Serializer GPIO reset level (default: 0 - active high)");
++
++static int poc_delay;
++module_param(poc_delay, int, 0644);
++MODULE_PARM_DESC(poc_delay, " Delay in ms after POC enable (default: 0 ms)");
+
+static char* ser_name(int id)
+{
@@ -1661,6 +6648,16 @@ index 0000000..20ef2de
+ reg8_write(client, 0x15, 0x9b); /* enable CSI output, VC is set accordingly to Link number, BIT7 magic must be set */
+ reg8_write(client, 0x1b, priv->links_mask); /* enable equalizer for CAMs */
+ usleep_range(5000, 5500); /* wait 2ms after any change of reverse channel settings */
++
++ if (strcmp(priv->fsync_mode, "manual") == 0) {
++ reg8_write(client, 0x01, 0x00); /* manual: FRAMESYNC set manually via [0x06:0x08] regs */
++ } else if (strcmp(priv->fsync_mode, "automatic") == 0) {
++ reg8_write(client, 0x01, 0x02); /* automatic: FRAMESYNC taken from the slowest Link */
++ } else if (strcmp(priv->fsync_mode, "semi-automatic") == 0) {
++ reg8_write(client, 0x01, 0x01); /* semi-automatic: FRAMESYNC taken from the slowest Link */
++ } else if (strcmp(priv->fsync_mode, "external") == 0) {
++ reg8_write(client, 0x01, 0xc0); /* ECU (aka MCU) based FrameSync using GPI-to-GPO */
++ }
+}
+
+static int max9286_reverse_channel_setup(struct i2c_client *client, int idx)
@@ -1715,12 +6712,11 @@ index 0000000..20ef2de
+ }
+
+ if (timeout == priv->timeout / 2 && poc_trig) {
-+ if (!IS_ERR(priv->poc_supply[idx])) {
-+ if (regulator_disable(priv->poc_supply[idx]))
-+ dev_err(&client->dev, "fail to disable POC%d regulator\n", idx);
++ if (!IS_ERR(priv->poc_gpio[idx])) {
++ gpiod_direction_output(priv->poc_gpio[idx], 0); /* POC power off */
+ mdelay(200);
-+ if (regulator_enable(priv->poc_supply[idx]))
-+ dev_err(&client->dev, "fail to enable POC%d regulator\n", idx);
++ gpiod_direction_output(priv->poc_gpio[idx], 1); /* POC power on */
++ mdelay(priv->poc_delay);
+ }
+ }
+ }
@@ -1771,20 +6767,12 @@ index 0000000..20ef2de
+ dev_err(&client->dev, "CSI2 lanes number is invalid (%d)\n", priv->lanes);
+ }
+
++ /* Start GMSL initialization with FSYNC disabled. This is required for some odd LVDS cameras */
++ reg8_write(client, 0x01, 0xc0); /* ECU (aka MCU) based FrameSync using GPI-to-GPO */
+ reg8_write(client, 0x06, priv->fsync_period & 0xff);
+ reg8_write(client, 0x07, (priv->fsync_period >> 8) & 0xff);
+ reg8_write(client, 0x08, priv->fsync_period >> 16);
+
-+ if (strcmp(priv->fsync_mode, "manual") == 0) {
-+ reg8_write(client, 0x01, 0x00); /* manual: FRAMESYNC set manually via [0x06:0x08] regs */
-+ } else if (strcmp(priv->fsync_mode, "automatic") == 0) {
-+ reg8_write(client, 0x01, 0x02); /* automatic: FRAMESYNC taken from the slowest Link */
-+ } else if (strcmp(priv->fsync_mode, "semi-automatic") == 0) {
-+ reg8_write(client, 0x01, 0x01); /* semi-automatic: FRAMESYNC taken from the slowest Link */
-+ } else if (strcmp(priv->fsync_mode, "external") == 0) {
-+ reg8_write(client, 0x01, 0xc0); /* ECU (aka MCU) based FrameSync using GPI-to-GPO */
-+ }
-+
+ reg8_write(client, 0x63, 0); /* disable overlap window */
+ reg8_write(client, 0x64, 0);
+ reg8_write(client, 0x0c, 0x91 | (priv->vsync ? BIT(3) : 0) | (priv->hsync ? BIT(2) : 0)); /* enable HS/VS encoding, use D14/15 for HS/VS, invert HS/VS */
@@ -1866,9 +6854,9 @@ index 0000000..20ef2de
+ max9286_initial_setup(client);
+
+ for (idx = 0; idx < priv->links; idx++) {
-+ if (!IS_ERR(priv->poc_supply[idx])) {
-+ if (regulator_enable(priv->poc_supply[idx]))
-+ dev_err(&client->dev, "fail to enable POC%d regulator\n", idx);
++ if (!IS_ERR(priv->poc_gpio[idx])) {
++ gpiod_direction_output(priv->poc_gpio[idx], 1); /* POC power on */
++ mdelay(priv->poc_delay);
+ }
+
+ ret = max9286_reverse_channel_setup(client, idx);
@@ -1975,8 +6963,8 @@ index 0000000..20ef2de
+ struct property *prop;
+ int err, pwen, i;
+ int sensor_delay, gpio0 = 1, gpio1 = 1;
-+ char fsync_mode_default[20] = "manual"; /* manual, automatic, semi-automatic, external */
+ u8 val = 0;
++ char poc_name[10];
+
+ if (of_property_read_u32(np, "maxim,links", &priv->links))
+ priv->links = 4;
@@ -1993,6 +6981,11 @@ index 0000000..20ef2de
+
+ mdelay(250);
+
++ for (i = 0; i < 4; i++) {
++ sprintf(poc_name, "POC%d", i);
++ priv->poc_gpio[i] = devm_gpiod_get_optional(&client->dev, poc_name, 0);
++ }
++
+ reg8_read(client, 0x1e, &val); /* read max9286 ID */
+ if (val != MAX9286_ID) {
+ prop = of_find_property(np, "reg", NULL);
@@ -2009,17 +7002,15 @@ index 0000000..20ef2de
+ priv->gpio_resetb = -1;
+ } else {
+ if (of_property_read_bool(np, "maxim,resetb-active-high"))
-+ priv->active_low_resetb = false;
++ priv->active_low_resetb = 0;
+ else
-+ priv->active_low_resetb = true;
++ priv->active_low_resetb = 1;
+ }
+
+ if (!of_property_read_u32(np, "maxim,sensor_delay", &sensor_delay))
+ mdelay(sensor_delay);
-+
+ if (of_property_read_string(np, "maxim,fsync-mode", &priv->fsync_mode))
+ priv->fsync_mode = fsync_mode_default;
-+
+ if (of_property_read_u32(np, "maxim,fsync-period", &priv->fsync_period))
+ priv->fsync_period = 3200000; /* 96MHz/30fps */
+ priv->pclk_rising_edge = true;
@@ -2035,6 +7026,8 @@ index 0000000..20ef2de
+ priv->hsync = 0;
+ if (of_property_read_u32(np, "maxim,vsync", &priv->vsync))
+ priv->vsync = 1;
++ if (of_property_read_u32(np, "maxim,poc-delay", &priv->poc_delay))
++ priv->poc_delay = 50;
+
+ /* module params override dts */
+ if (him)
@@ -2047,6 +7040,12 @@ index 0000000..20ef2de
+ priv->hsync = hsync;
+ if (!vsync)
+ priv->vsync = vsync;
++ if (gpio_resetb)
++ priv->gpio_resetb = gpio_resetb;
++ if (active_low_resetb)
++ priv->active_low_resetb = active_low_resetb;
++ if (poc_delay)
++ priv->poc_delay = poc_delay;
+
+ for (i = 0; i < priv->links; i++) {
+ endpoint = of_graph_get_next_endpoint(np, endpoint);
@@ -2104,7 +7103,6 @@ index 0000000..20ef2de
+{
+ struct max9286_priv *priv;
+ int err, i;
-+ char supply_name[10];
+
+ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
@@ -2120,11 +7118,6 @@ index 0000000..20ef2de
+ if (err)
+ goto out;
+
-+ for (i = 0; i < 4; i++) {
-+ sprintf(supply_name, "POC%d", i);
-+ priv->poc_supply[i] = devm_regulator_get_optional(&client->dev, supply_name);
-+ }
-+
+ err = max9286_initialize(client);
+ if (err < 0)
+ goto out;
@@ -2443,10 +7436,10 @@ index 0000000..6c2a9e0
+#endif /* _MAX9286_MAX9271_H */
diff --git a/drivers/media/i2c/soc_camera/ov10635.c b/drivers/media/i2c/soc_camera/ov10635.c
new file mode 100644
-index 0000000..c8da1f4
+index 0000000..8c06e59
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ov10635.c
-@@ -0,0 +1,758 @@
+@@ -0,0 +1,759 @@
+/*
+ * OmniVision ov10635 sensor camera driver
+ *
@@ -2519,6 +7512,7 @@ index 0000000..c8da1f4
+ tmp_addr = client->addr;
+ client->addr = priv->max9286_addr; /* Deserializer I2C address */
+ reg8_write(client, 0x0a, fwd_en ? 0x11 << priv->port : 0); /* Enable/disable reverse/forward control for this port */
++ usleep_range(5000, 5500); /* wait 5ms */
+ client->addr = tmp_addr;
+ };
+}
@@ -4412,10 +9406,10 @@ index 0000000..4c3515a
+#endif
diff --git a/drivers/media/i2c/soc_camera/ov106xx.c b/drivers/media/i2c/soc_camera/ov106xx.c
new file mode 100644
-index 0000000..4c797f9
+index 0000000..08786ab
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ov106xx.c
-@@ -0,0 +1,117 @@
+@@ -0,0 +1,161 @@
+/*
+ * OmniVision ov10635/ov490-ov10640/ov495-ov2775 sensor camera driver
+ *
@@ -4431,14 +9425,22 @@ index 0000000..4c797f9
+#include "ov490_ov10640.c"
+#include "ov495_ov2775.c"
+#include "ar0132.c"
++#include "ar0220.c"
+#include "ap0101_ar014x.c"
++#include "ov2775.c"
++#include "imx390.c"
++#include "ox03a.c"
+
+static enum {
+ ID_OV10635,
+ ID_OV490_OV10640,
+ ID_OV495_OV2775,
+ ID_AR0132,
++ ID_AR0220,
+ ID_AP0101_AR014X,
++ ID_OV2775,
++ ID_IMX390,
++ ID_OX03A,
+} chip_id;
+
+static int ov106xx_probe(struct i2c_client *client,
@@ -4471,12 +9473,36 @@ index 0000000..4c797f9
+ goto out;
+ }
+
++ ret = ar0220_probe(client, did);
++ if (!ret) {
++ chip_id = ID_AR0220;
++ goto out;
++ }
++
+ ret = ap0101_probe(client, did);
+ if (!ret) {
+ chip_id = ID_AP0101_AR014X;
+ goto out;
+ }
+
++ ret = ov2775_probe(client, did);
++ if (!ret) {
++ chip_id = ID_OV2775;
++ goto out;
++ }
++
++ ret = imx390_probe(client, did);
++ if (!ret) {
++ chip_id = ID_IMX390;
++ goto out;
++ }
++
++ ret = ox03a_probe(client, did);
++ if (!ret) {
++ chip_id = ID_OX03A;
++ goto out;
++ }
++
+ v4l_err(client, "failed to probe @ 0x%02x (%s)\n",
+ client->addr, client->adapter->name);
+out:
@@ -4498,9 +9524,21 @@ index 0000000..4c797f9
+ case ID_AR0132:
+ ar0132_remove(client);
+ break;
++ case ID_AR0220:
++ ar0220_remove(client);
++ break;
+ case ID_AP0101_AR014X:
+ ap0101_remove(client);
+ break;
++ case ID_OV2775:
++ ov2775_remove(client);
++ break;
++ case ID_IMX390:
++ imx390_remove(client);
++ break;
++ case ID_OX03A:
++ ox03a_remove(client);
++ break;
+ };
+
+ return 0;
@@ -4530,19 +9568,2410 @@ index 0000000..4c797f9
+
+module_i2c_driver(ov106xx_i2c_driver);
+
-+MODULE_DESCRIPTION("SoC Camera driver for OV10635 or OV490/OV10640 or OV495/OV2775 or AR0132 or AP0101/AR014X");
++MODULE_DESCRIPTION("SoC Camera driver for OV10635, OV490/OV10640, OV495/OV2775, AR0132, AR0220, AP0101/AR014X");
++MODULE_AUTHOR("Vladimir Barinov");
++MODULE_LICENSE("GPL");
+diff --git a/drivers/media/i2c/soc_camera/ov2775.c b/drivers/media/i2c/soc_camera/ov2775.c
+new file mode 100644
+index 0000000..f57fc71
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/ov2775.c
+@@ -0,0 +1,538 @@
++/*
++ * OmniVision OV2775 sensor camera driver
++ *
++ * Copyright (C) 2018 Cogent Embedded, Inc.
++ *
++ * 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/delay.h>
++#include <linux/init.h>
++#include <linux/i2c.h>
++#include <linux/module.h>
++#include <linux/videodev2.h>
++
++#include <media/soc_camera.h>
++#include <media/v4l2-common.h>
++#include <media/v4l2-ctrls.h>
++#include <media/v4l2-of.h>
++
++#include "ov2775.h"
++
++#define OV2775_I2C_ADDR 0x36
++
++#define OV2775_PID 0x300a
++#define OV2775_VER 0x300b
++#define OV2775_VERSION_REG 0x2770
++
++#define OV2775_MEDIA_BUS_FMT MEDIA_BUS_FMT_SBGGR12_1X12
++
++struct ov2775_priv {
++ struct v4l2_subdev sd;
++ struct v4l2_ctrl_handler hdl;
++ struct media_pad pad;
++ struct v4l2_rect rect;
++ int init_complete;
++ u8 id[6];
++ int exposure;
++ int gain;
++ int autogain;
++ /* serializers */
++ int ti9x4_addr;
++ int ti9x3_addr;
++ int port;
++ int gpio_resetb;
++ int gpio_fsin;
++
++};
++
++static inline struct ov2775_priv *to_ov2775(const struct i2c_client *client)
++{
++ return container_of(i2c_get_clientdata(client), struct ov2775_priv, sd);
++}
++
++static int ov2775_set_regs(struct i2c_client *client,
++ const struct ov2775_reg *regs, int nr_regs)
++{
++ int i;
++
++ for (i = 0; i < nr_regs; i++) {
++ if (regs[i].reg == OV2775_DELAY) {
++ mdelay(regs[i].val);
++ continue;
++ }
++
++ reg16_write(client, regs[i].reg, regs[i].val);
++ }
++
++ return 0;
++}
++
++static int ov2775_s_stream(struct v4l2_subdev *sd, int enable)
++{
++ return 0;
++}
++
++static int ov2775_get_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++
++ if (format->pad)
++ return -EINVAL;
++
++ mf->width = priv->rect.width;
++ mf->height = priv->rect.height;
++ mf->code = OV2775_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ return 0;
++}
++
++static int ov2775_set_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++
++ mf->code = OV2775_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ if (format->which == V4L2_SUBDEV_FORMAT_TRY)
++ cfg->try_fmt = *mf;
++
++ return 0;
++}
++
++static int ov2775_enum_mbus_code(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_mbus_code_enum *code)
++{
++ if (code->pad || code->index > 0)
++ return -EINVAL;
++
++ code->code = OV2775_MEDIA_BUS_FMT;
++
++ return 0;
++}
++
++static int ov2775_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++
++ memcpy(edid->edid, priv->id, 6);
++
++ edid->edid[6] = 0xff;
++ edid->edid[7] = client->addr;
++ edid->edid[8] = OV2775_VERSION_REG >> 8;
++ edid->edid[9] = OV2775_VERSION_REG & 0xff;
++
++ return 0;
++}
++
++static int ov2775_set_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct v4l2_rect *rect = &sel->r;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
++ sel->target != V4L2_SEL_TGT_CROP)
++ return -EINVAL;
++
++ rect->left = ALIGN(rect->left, 2);
++ rect->top = ALIGN(rect->top, 2);
++ rect->width = ALIGN(rect->width, 2);
++ rect->height = ALIGN(rect->height, 2);
++
++ if ((rect->left + rect->width > OV2775_MAX_WIDTH) ||
++ (rect->top + rect->height > OV2775_MAX_HEIGHT))
++ *rect = priv->rect;
++
++ priv->rect.left = rect->left;
++ priv->rect.top = rect->top;
++ priv->rect.width = rect->width;
++ priv->rect.height = rect->height;
++
++ return 0;
++}
++
++static int ov2775_get_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
++ return -EINVAL;
++
++ switch (sel->target) {
++ case V4L2_SEL_TGT_CROP_BOUNDS:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = OV2775_MAX_WIDTH;
++ sel->r.height = OV2775_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP_DEFAULT:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = OV2775_MAX_WIDTH;
++ sel->r.height = OV2775_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP:
++ sel->r = priv->rect;
++ return 0;
++ default:
++ return -EINVAL;
++ }
++}
++
++static int ov2775_g_mbus_config(struct v4l2_subdev *sd,
++ struct v4l2_mbus_config *cfg)
++{
++ cfg->flags = V4L2_MBUS_CSI2_1_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
++ V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
++ cfg->type = V4L2_MBUS_CSI2;
++
++ return 0;
++}
++
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++static int ov2775_g_register(struct v4l2_subdev *sd,
++ struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ int ret;
++ u8 val = 0;
++
++ ret = reg16_read(client, (u16)reg->reg, &val);
++ if (ret < 0)
++ return ret;
++
++ reg->val = val;
++ reg->size = sizeof(u8);
++
++ return 0;
++}
++
++static int ov2775_s_register(struct v4l2_subdev *sd,
++ const struct v4l2_dbg_register *reg)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++
++ return reg16_write(client, (u16)reg->reg, (u8)reg->val);
++}
++#endif
++
++static struct v4l2_subdev_core_ops ov2775_core_ops = {
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ .g_register = ov2775_g_register,
++ .s_register = ov2775_s_register,
++#endif
++};
++
++static int ov2775_s_ctrl(struct v4l2_ctrl *ctrl)
++{
++ struct v4l2_subdev *sd = to_sd(ctrl);
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++ int ret = -EINVAL;
++
++ if (!priv->init_complete)
++ return 0;
++
++ switch (ctrl->id) {
++ case V4L2_CID_BRIGHTNESS:
++ case V4L2_CID_CONTRAST:
++ case V4L2_CID_SATURATION:
++ case V4L2_CID_HUE:
++ case V4L2_CID_GAMMA:
++ case V4L2_CID_SHARPNESS:
++ case V4L2_CID_AUTOGAIN:
++ case V4L2_CID_GAIN:
++ case V4L2_CID_EXPOSURE:
++ case V4L2_CID_HFLIP:
++ case V4L2_CID_VFLIP:
++ break;
++ }
++
++ return ret;
++}
++
++static const struct v4l2_ctrl_ops ov2775_ctrl_ops = {
++ .s_ctrl = ov2775_s_ctrl,
++};
++
++static struct v4l2_subdev_video_ops ov2775_video_ops = {
++ .s_stream = ov2775_s_stream,
++ .g_mbus_config = ov2775_g_mbus_config,
++};
++
++static const struct v4l2_subdev_pad_ops ov2775_subdev_pad_ops = {
++ .get_edid = ov2775_get_edid,
++ .enum_mbus_code = ov2775_enum_mbus_code,
++ .get_selection = ov2775_get_selection,
++ .set_selection = ov2775_set_selection,
++ .get_fmt = ov2775_get_fmt,
++ .set_fmt = ov2775_set_fmt,
++};
++
++static struct v4l2_subdev_ops ov2775_subdev_ops = {
++ .core = &ov2775_core_ops,
++ .video = &ov2775_video_ops,
++ .pad = &ov2775_subdev_pad_ops,
++};
++
++static void ov2775_otp_id_read(struct i2c_client *client)
++{
++}
++
++static ssize_t ov2775_otp_id_show(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ struct v4l2_subdev *sd = i2c_get_clientdata(to_i2c_client(dev));
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ov2775_priv *priv = to_ov2775(client);
++
++ return snprintf(buf, 32, "%02x:%02x:%02x:%02x:%02x:%02x\n",
++ priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++}
++
++static DEVICE_ATTR(otp_id_ov2775, S_IRUGO, ov2775_otp_id_show, NULL);
++
++static int ov2775_initialize(struct i2c_client *client)
++{
++ struct ov2775_priv *priv = to_ov2775(client);
++ u8 val = 0;
++ u16 pid;
++ int ret = 0;
++ int tmp_addr;
++
++ /* check and show model ID */
++ reg16_read(client, OV2775_PID, &val);
++ pid = val;
++ reg16_read(client, OV2775_VER, &val);
++ pid = (pid << 8) | val;
++
++ if (pid != OV2775_VERSION_REG) {
++ dev_dbg(&client->dev, "Product ID error %x\n", pid);
++ ret = -ENODEV;
++ goto err;
++ }
++
++ /* setup XCLK */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ /* CLK_OUT=22.5792*160*M/N/CLKDIV -> CLK_OUT=25MHz: CLKDIV=4, M=7, N=253: 22.5792*160/4*7/253=24.989MHz=CLK_OUT */
++ client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++ reg8_write(client, 0x06, 0x47); /* Set CLKDIV and M */
++ reg8_write(client, 0x07, 0xfd); /* Set N */
++ }
++ client->addr = tmp_addr;
++
++ /* Program wizard registers */
++ ov2775_set_regs(client, ov2775_regs_wizard, ARRAY_SIZE(ov2775_regs_wizard));
++ /* Read OTP IDs */
++ ov2775_otp_id_read(client);
++
++ dev_info(&client->dev, "ov2775 PID %x, res %dx%d, OTP_ID %02x:%02x:%02x:%02x:%02x:%02x\n",
++ pid, OV2775_MAX_WIDTH, OV2775_MAX_HEIGHT, priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++err:
++ return ret;
++}
++
++static int ov2775_parse_dt(struct device_node *np, struct ov2775_priv *priv)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(&priv->sd);
++ int i;
++ struct device_node *endpoint = NULL, *rendpoint = NULL;
++ int tmp_addr = 0;
++
++ for (i = 0; ; i++) {
++ endpoint = of_graph_get_next_endpoint(np, endpoint);
++ if (!endpoint)
++ break;
++
++ of_node_put(endpoint);
++
++ rendpoint = of_parse_phandle(endpoint, "remote-endpoint", 0);
++ if (!rendpoint)
++ continue;
++
++ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
++ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
++ break;
++ }
++
++ if (!priv->ti9x4_addr) {
++ dev_err(&client->dev, "deserializer does not present\n");
++ return -EINVAL;
++ }
++
++ /* setup I2C translator address */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
++ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
++ usleep_range(2000, 2500); /* wait 2ms */
++ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
++ reg8_write(client, 0x5d, OV2775_I2C_ADDR << 1); /* Sensor native I2C address */
++// reg8_write(client, 0x6e, 0xa9); /* GPIO0 - reset, GPIO1 - fsin */
++
++ client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++ reg8_write(client, 0x0d, 0x03); /* unreset gpios */
++ reg8_write(client, 0x0e, 0xf0); /* unreset gpios */
++ }
++ client->addr = tmp_addr;
++
++ mdelay(10);
++
++ return 0;
++}
++
++static int ov2775_probe(struct i2c_client *client,
++ const struct i2c_device_id *did)
++{
++ struct ov2775_priv *priv;
++ int ret;
++
++ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
++ if (!priv)
++ return -ENOMEM;
++
++ v4l2_i2c_subdev_init(&priv->sd, client, &ov2775_subdev_ops);
++ priv->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
++
++ priv->exposure = 0x100;
++ priv->gain = 0x100;
++ priv->autogain = 1;
++ v4l2_ctrl_handler_init(&priv->hdl, 4);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_BRIGHTNESS, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_CONTRAST, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_SATURATION, 0, 7, 1, 2);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_HUE, 0, 23, 1, 12);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_GAMMA, -128, 128, 1, 0);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_SHARPNESS, 0, 10, 1, 3);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_AUTOGAIN, 0, 1, 1, priv->autogain);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_GAIN, 0, 0xffff, 1, priv->gain);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_EXPOSURE, 0, 0xffff, 1, priv->exposure);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_HFLIP, 0, 1, 1, 1);
++ v4l2_ctrl_new_std(&priv->hdl, &ov2775_ctrl_ops,
++ V4L2_CID_VFLIP, 0, 1, 1, 0);
++ priv->sd.ctrl_handler = &priv->hdl;
++
++ ret = priv->hdl.error;
++ if (ret)
++ goto cleanup;
++
++ v4l2_ctrl_handler_setup(&priv->hdl);
++
++ priv->pad.flags = MEDIA_PAD_FL_SOURCE;
++ priv->sd.entity.flags |= MEDIA_ENT_F_CAM_SENSOR;
++ ret = media_entity_pads_init(&priv->sd.entity, 1, &priv->pad);
++ if (ret < 0)
++ goto cleanup;
++
++ ret = ov2775_parse_dt(client->dev.of_node, priv);
++ if (ret)
++ goto cleanup;
++
++ ret = ov2775_initialize(client);
++ if (ret < 0)
++ goto cleanup;
++
++ priv->rect.left = 0;
++ priv->rect.top = 0;
++ priv->rect.width = OV2775_MAX_WIDTH;
++ priv->rect.height = OV2775_MAX_HEIGHT;
++
++ ret = v4l2_async_register_subdev(&priv->sd);
++ if (ret)
++ goto cleanup;
++
++ if (device_create_file(&client->dev, &dev_attr_otp_id_ov2775) != 0) {
++ dev_err(&client->dev, "sysfs otp_id entry creation failed\n");
++ goto cleanup;
++ }
++
++ priv->init_complete = 1;
++
++ return 0;
++
++cleanup:
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++#ifdef CONFIG_SOC_CAMERA_OV2775
++ v4l_err(client, "failed to probe @ 0x%02x (%s)\n",
++ client->addr, client->adapter->name);
++#endif
++ return ret;
++}
++
++static int ov2775_remove(struct i2c_client *client)
++{
++ struct ov2775_priv *priv = i2c_get_clientdata(client);
++
++ device_remove_file(&client->dev, &dev_attr_otp_id_ov2775);
++ v4l2_async_unregister_subdev(&priv->sd);
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++
++ return 0;
++}
++
++#ifdef CONFIG_SOC_CAMERA_OV2775
++static const struct i2c_device_id ov2775_id[] = {
++ { "ov2775", 0 },
++ { }
++};
++MODULE_DEVICE_TABLE(i2c, ov2775_id);
++
++static const struct of_device_id ov2775_of_ids[] = {
++ { .compatible = "ovti,ov2775", },
++ { }
++};
++MODULE_DEVICE_TABLE(of, ov2775_of_ids);
++
++static struct i2c_driver ov2775_i2c_driver = {
++ .driver = {
++ .name = "ov2775",
++ .of_match_table = ov2775_of_ids,
++ },
++ .probe = ov2775_probe,
++ .remove = ov2775_remove,
++ .id_table = ov2775_id,
++};
++
++module_i2c_driver(ov2775_i2c_driver);
++
++MODULE_DESCRIPTION("SoC Camera driver for OV2775");
+MODULE_AUTHOR("Vladimir Barinov");
+MODULE_LICENSE("GPL");
++#endif
+diff --git a/drivers/media/i2c/soc_camera/ov2775.h b/drivers/media/i2c/soc_camera/ov2775.h
+new file mode 100644
+index 0000000..7e1ee31
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/ov2775.h
+@@ -0,0 +1,1841 @@
++/*
++ * OmniVision OV2775 sensor camera wizard 1920x1080@30/BGGR/MIPI
++ *
++ * Copyright (C) 2018 Cogent Embedded, Inc.
++ *
++ * 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.
++ */
++
++#define OV2775_DISPLAY_PATTERN_COLOR_BAR
++
++#define OV2775_MAX_WIDTH 1920
++#define OV2775_MAX_HEIGHT 1080
++
++#define OV2775_DELAY 0xffff
++#define OV2775_DT 0x2c /* MIPI Data Type RAW12 */
++
++struct ov2775_reg {
++ u16 reg;
++ u8 val;
++};
++
++/* wizard: MIPI 1920x1080 RAW12 Linear 30fps 600Mbps XCLK=25MHz */
++static const struct ov2775_reg ov2775_regs_wizard[] = {
++{0x3013, 0x01}, // s/w reset
++{OV2775_DELAY, 10}, // Wait 10ms
++{0x3000, 0x03},
++{0x3001, 0x18},
++{0x3002, 0x01},
++{0x3003, 0x01},
++{0x3004, 0x03},
++{0x3005, 0x1c},
++{0x3006, 0x00},
++{0x3007, 0x07},
++{0x3008, 0x01},
++{0x3009, 0x00},
++{0x300c, 0x6c},
++{0x300e, 0x80},
++{0x300f, 0x00},
++{0x3012, 0x00},
++{0x3013, 0x00},
++{0x3014, 0x44},
++{0x3015, 0x00},
++{0x3017, 0x00},
++{0x3018, 0x00},
++{0x3019, 0x00},
++{0x301a, 0x00},
++{0x301b, 0x01},
++{0x301e, 0x17},
++{0x301f, 0xe1},
++{0x3030, 0x02},
++{0x3031, 0x72},
++{0x3032, 0xf0},
++{0x3033, 0x30},
++{0x3034, 0x3f},
++{0x3035, 0x5f},
++{0x3036, 0x02},
++{0x3037, 0x9f},
++{0x3038, 0x04},
++{0x3039, 0xb7},
++{0x303a, 0x04},
++{0x303b, 0x07},
++{0x303c, 0xf0},
++{0x303d, 0x00},
++{0x303e, 0x0b},
++{0x303f, 0xe3},
++{0x3040, 0xf3},
++{0x3041, 0x29},
++{0x3042, 0xf6},
++{0x3043, 0x65},
++{0x3044, 0x06},
++{0x3045, 0x0f},
++{0x3046, 0x59},
++{0x3047, 0x07},
++{0x3048, 0x82},
++{0x3049, 0xcf},
++{0x304a, 0x12},
++{0x304b, 0x40},
++{0x304c, 0x33},
++{0x304d, 0xa4},
++{0x304e, 0x0b},
++{0x304f, 0x3d},
++{0x3050, 0x10},
++{0x3060, 0x00},
++{0x3061, 0x64},
++{0x3062, 0x00},
++{0x3063, 0xe4},
++{0x3066, 0x80},
++{0x3080, 0x00},
++{0x3081, 0x00},
++{0x3082, 0x01},
++{0x3083, 0xe3},
++{0x3084, 0x06},
++{0x3085, 0x00},
++{0x3086, 0x10},
++{0x3087, 0x10},
++{0x3089, 0x00},
++{0x308a, 0x01},
++{0x3093, 0x00},
++{0x30a0, 0x00},
++{0x30a1, 0x00},
++{0x30a2, 0x00},
++{0x30a3, 0x00},
++{0x30a4, 0x07},
++{0x30a5, 0x8f},
++{0x30a6, 0x04},
++{0x30a7, 0x47},
++{0x30a8, 0x00},
++{0x30a9, 0x00},
++{0x30aa, 0x00},
++{0x30ab, 0x00},
++{0x30ac, 0x07},
++{0x30ad, 0x90},
++{0x30ae, 0x04},
++{0x30af, 0x48},
++{0x30b0, 0x04},
++{0x30b1, 0x7e},
++{0x30b2, 0x04},
++{0x30b3, 0x65},
++{0x30b4, 0x00},
++{0x30b5, 0x00},
++{0x30b6, 0x00},
++{0x30b7, 0x10},
++{0x30b8, 0x00},
++{0x30b9, 0x02},
++{0x30ba, 0x10},
++{0x30bb, 0x00},
++{0x30bc, 0x00},
++{0x30bd, 0x03},
++{0x30be, 0x5c},
++{0x30bf, 0x00},
++{0x30c0, 0x01},
++{0x30c1, 0x00},
++{0x30c2, 0x20},
++{0x30c3, 0x00},
++{0x30c4, 0x4a},
++{0x30c5, 0x00},
++{0x30c7, 0x00},
++{0x30c8, 0x00},
++{0x30d1, 0x00},
++{0x30d2, 0x00},
++{0x30d3, 0x80},
++{0x30d4, 0x00},
++{0x30d9, 0x09},
++{0x30da, 0x64},
++{0x30dd, 0x00},
++{0x30de, 0x16},
++{0x30df, 0x00},
++{0x30e0, 0x17},
++{0x30e1, 0x00},
++{0x30e2, 0x18},
++{0x30e3, 0x10},
++{0x30e4, 0x04},
++{0x30e5, 0x00},
++{0x30e6, 0x00},
++{0x30e7, 0x00},
++{0x30e8, 0x00},
++{0x30e9, 0x00},
++{0x30ea, 0x00},
++{0x30eb, 0x00},
++{0x30ec, 0x00},
++{0x30ed, 0x00},
++{0x3101, 0x00},
++{0x3102, 0x00},
++{0x3103, 0x00},
++{0x3104, 0x00},
++{0x3105, 0x8c},
++{0x3106, 0x87},
++{0x3107, 0xc0},
++{0x3108, 0x9d},
++{0x3109, 0x8d},
++{0x310a, 0x8d},
++{0x310b, 0x6a},
++{0x310c, 0x3a},
++{0x310d, 0x5a},
++{0x310e, 0x00},
++{0x3120, 0x00},
++{0x3121, 0x00},
++{0x3122, 0x00},
++{0x3123, 0xf0},
++{0x3124, 0x00},
++{0x3125, 0x70},
++{0x3126, 0x1f},
++{0x3127, 0x0f},
++{0x3128, 0x00},
++{0x3129, 0x3a},
++{0x312a, 0x02},
++{0x312b, 0x0f},
++{0x312c, 0x00},
++{0x312d, 0x0f},
++{0x312e, 0x1d},
++{0x312f, 0x00},
++{0x3130, 0x00},
++{0x3131, 0x00},
++{0x3132, 0x00},
++{0x3140, 0x0a},
++{0x3141, 0x03},
++{0x3142, 0x00},
++{0x3143, 0x00},
++{0x3144, 0x00},
++{0x3145, 0x00},
++{0x3146, 0x00},
++{0x3147, 0x00},
++{0x3148, 0x00},
++{0x3149, 0x00},
++{0x314a, 0x00},
++{0x314b, 0x00},
++{0x314c, 0x00},
++{0x314d, 0x00},
++{0x314e, 0x1c},
++{0x314f, 0xff},
++{0x3150, 0xff},
++{0x3151, 0xff},
++{0x3152, 0x10},
++{0x3153, 0x10},
++{0x3154, 0x10},
++{0x3155, 0x00},
++{0x3156, 0x03},
++{0x3157, 0x00},
++{0x3158, 0x0f},
++{0x3159, 0xff},
++{0x315a, 0x01},
++{0x315b, 0x00},
++{0x315c, 0x01},
++{0x315d, 0x00},
++{0x315e, 0x01},
++{0x315f, 0x00},
++{0x3160, 0x00},
++{0x3161, 0x40},
++{0x3162, 0x00},
++{0x3163, 0x40},
++{0x3164, 0x00},
++{0x3165, 0x40},
++{0x3190, 0x08},
++{0x3191, 0x99},
++{0x3193, 0x08},
++{0x3194, 0x13},
++{0x3195, 0x33},
++{0x3196, 0x00},
++{0x3197, 0x10},
++{0x3198, 0x00},
++{0x3199, 0x7f},
++{0x319a, 0x80},
++{0x319b, 0xff},
++{0x319c, 0x80},
++{0x319d, 0xbf},
++{0x319e, 0xc0},
++{0x319f, 0xff},
++{0x31a0, 0x24},
++{0x31a1, 0x55},
++{0x31a2, 0x00},
++{0x31a3, 0x00},
++{0x31a6, 0x00},
++{0x31a7, 0x00},
++{0x31b0, 0x00},
++{0x31b1, 0x00},
++{0x31b2, 0x02},
++{0x31b3, 0x00},
++{0x31b4, 0x00},
++{0x31b5, 0x01},
++{0x31b6, 0x00},
++{0x31b7, 0x00},
++{0x31b8, 0x00},
++{0x31b9, 0x00},
++{0x31ba, 0x00},
++{0x31d0, 0x3c},
++{0x31d1, 0x34},
++{0x31d2, 0x3c},
++{0x31d3, 0x00},
++{0x31d4, 0x2d},
++{0x31d5, 0x00},
++{0x31d6, 0x01},
++{0x31d7, 0x06},
++{0x31d8, 0x00},
++{0x31d9, 0x64},
++{0x31da, 0x00},
++{0x31db, 0x30},
++{0x31dc, 0x04},
++{0x31dd, 0x69},
++{0x31de, 0x0a},
++{0x31df, 0x3c},
++{0x31e0, 0x04},
++{0x31e1, 0x32},
++{0x31e2, 0x00},
++{0x31e3, 0x00},
++{0x31e4, 0x08},
++{0x31e5, 0x80},
++{0x31e6, 0x00},
++{0x31e7, OV2775_DT},
++{0x31e8, 0x6c},
++{0x31e9, 0xac},
++{0x31ea, 0xec},
++{0x31eb, 0x3f},
++{0x31ec, 0x0f},
++{0x31ed, 0x20},
++{0x31ee, 0x04},
++{0x31ef, 0x48},
++{0x31f0, 0x07},
++{0x31f1, 0x90},
++{0x31f2, 0x04},
++{0x31f3, 0x48},
++{0x31f4, 0x07},
++{0x31f5, 0x90},
++{0x31f6, 0x04},
++{0x31f7, 0x48},
++{0x31f8, 0x07},
++{0x31f9, 0x90},
++{0x31fa, 0x04},
++{0x31fb, 0x48},
++{0x31fd, 0xcb},
++{0x31fe, 0x0f},
++{0x31ff, 0x03},
++{0x3200, 0x00},
++{0x3201, 0xff},
++{0x3202, 0x00},
++{0x3203, 0xff},
++{0x3204, 0xff},
++{0x3205, 0xff},
++{0x3206, 0xff},
++{0x3207, 0xff},
++{0x3208, 0xff},
++{0x3209, 0xff},
++{0x320a, 0xff},
++{0x320b, 0x1b},
++{0x320c, 0x1f},
++{0x320d, 0x1e},
++{0x320e, 0x30},
++{0x320f, 0x2d},
++{0x3210, 0x2c},
++{0x3211, 0x2b},
++{0x3212, 0x2a},
++{0x3213, 0x24},
++{0x3214, 0x22},
++{0x3215, 0x00},
++{0x3216, 0x04},
++{0x3217, OV2775_DT},
++{0x3218, 0x6c},
++{0x3219, 0xac},
++{0x321a, 0xec},
++{0x321b, 0x00},
++{0x3230, 0x3a},
++{0x3231, 0x00},
++{0x3232, 0x80},
++{0x3233, 0x00},
++{0x3234, 0x10},
++{0x3235, 0xaa},
++{0x3236, 0x55},
++{0x3237, 0x99},
++{0x3238, 0x66},
++{0x3239, 0x08},
++{0x323a, 0x88},
++{0x323b, 0x00},
++{0x323c, 0x00},
++{0x323d, 0x03},
++{0x3250, 0x33},
++{0x3251, 0x00},
++{0x3252, 0x20},
++#ifdef OV2775_DISPLAY_PATTERN_COLOR_BAR
++{0x3253, 0xC0},
++#else
++{0x3253, 0x00},
++#endif
++{0x3254, 0x00},
++{0x3255, 0x01},
++{0x3256, 0x00},
++{0x3257, 0x00},
++{0x3258, 0x00},
++{0x3270, 0x01},
++{0x3271, 0x60},
++{0x3272, 0xc0},
++{0x3273, 0x00},
++{0x3274, 0x80},
++{0x3275, 0x40},
++{0x3276, 0x02},
++{0x3277, 0x08},
++{0x3278, 0x10},
++{0x3279, 0x04},
++{0x327a, 0x00},
++{0x327b, 0x03},
++{0x327c, 0x10},
++{0x327d, 0x60},
++{0x327e, 0xc0},
++{0x327f, 0x06},
++{0x3288, 0x10},
++{0x3289, 0x00},
++{0x328a, 0x08},
++{0x328b, 0x00},
++{0x328c, 0x04},
++{0x328d, 0x00},
++{0x328e, 0x02},
++{0x328f, 0x00},
++{0x3290, 0x20},
++{0x3291, 0x00},
++{0x3292, 0x10},
++{0x3293, 0x00},
++{0x3294, 0x08},
++{0x3295, 0x00},
++{0x3296, 0x04},
++{0x3297, 0x00},
++{0x3298, 0x40},
++{0x3299, 0x00},
++{0x329a, 0x20},
++{0x329b, 0x00},
++{0x329c, 0x10},
++{0x329d, 0x00},
++{0x329e, 0x08},
++{0x329f, 0x00},
++{0x32a0, 0x7f},
++{0x32a1, 0xff},
++{0x32a2, 0x40},
++{0x32a3, 0x00},
++{0x32a4, 0x20},
++{0x32a5, 0x00},
++{0x32a6, 0x10},
++{0x32a7, 0x00},
++{0x32a8, 0x00},
++{0x32a9, 0x00},
++{0x32aa, 0x00},
++{0x32ab, 0x00},
++{0x32ac, 0x00},
++{0x32ad, 0x00},
++{0x32ae, 0x00},
++{0x32af, 0x00},
++{0x32b0, 0x00},
++{0x32b1, 0x00},
++{0x32b2, 0x00},
++{0x32b3, 0x00},
++{0x32b4, 0x00},
++{0x32b5, 0x00},
++{0x32b6, 0x00},
++{0x32b7, 0x00},
++{0x32b8, 0x00},
++{0x32b9, 0x00},
++{0x32ba, 0x00},
++{0x32bb, 0x00},
++{0x32bc, 0x00},
++{0x32bd, 0x00},
++{0x32be, 0x00},
++{0x32bf, 0x00},
++{0x32c0, 0x00},
++{0x32c1, 0x00},
++{0x32c2, 0x00},
++{0x32c3, 0x00},
++{0x32c4, 0x00},
++{0x32c5, 0x00},
++{0x32c6, 0x00},
++{0x32c7, 0x00},
++{0x32c8, 0x87},
++{0x32c9, 0x00},
++{0x3330, 0x03},
++{0x3331, 0xc8},
++{0x3332, 0x02},
++{0x3333, 0x24},
++{0x3334, 0x00},
++{0x3335, 0x00},
++{0x3336, 0x00},
++{0x3337, 0x00},
++{0x3338, 0x03},
++{0x3339, 0xc8},
++{0x333a, 0x02},
++{0x333b, 0x24},
++{0x333c, 0x00},
++{0x333d, 0x00},
++{0x333e, 0x00},
++{0x333f, 0x00},
++{0x3340, 0x03},
++{0x3341, 0xc8},
++{0x3342, 0x02},
++{0x3343, 0x24},
++{0x3344, 0x00},
++{0x3345, 0x00},
++{0x3346, 0x00},
++{0x3347, 0x00},
++{0x3348, 0x40},
++{0x3349, 0x00},
++{0x334a, 0x00},
++{0x334b, 0x00},
++{0x334c, 0x00},
++{0x334d, 0x00},
++{0x334e, 0x80},
++{0x3360, 0x01},
++{0x3361, 0x00},
++{0x3362, 0x01},
++{0x3363, 0x00},
++{0x3364, 0x01},
++{0x3365, 0x00},
++{0x3366, 0x01},
++{0x3367, 0x00},
++{0x3368, 0x01},
++{0x3369, 0x00},
++{0x336a, 0x01},
++{0x336b, 0x00},
++{0x336c, 0x01},
++{0x336d, 0x00},
++{0x336e, 0x01},
++{0x336f, 0x00},
++{0x3370, 0x01},
++{0x3371, 0x00},
++{0x3372, 0x01},
++{0x3373, 0x00},
++{0x3374, 0x01},
++{0x3375, 0x00},
++{0x3376, 0x01},
++{0x3377, 0x00},
++{0x3378, 0x00},
++{0x3379, 0x00},
++{0x337a, 0x00},
++{0x337b, 0x00},
++{0x337c, 0x00},
++{0x337d, 0x00},
++{0x337e, 0x00},
++{0x337f, 0x00},
++{0x3380, 0x00},
++{0x3381, 0x00},
++{0x3382, 0x00},
++{0x3383, 0x00},
++{0x3384, 0x00},
++{0x3385, 0x00},
++{0x3386, 0x00},
++{0x3387, 0x00},
++{0x3388, 0x00},
++{0x3389, 0x00},
++{0x338a, 0x00},
++{0x338b, 0x00},
++{0x338c, 0x00},
++{0x338d, 0x00},
++{0x338e, 0x00},
++{0x338f, 0x00},
++{0x3390, 0x00},
++{0x3391, 0x00},
++{0x3392, 0x00},
++{0x3393, 0x00},
++{0x3394, 0x00},
++{0x3395, 0x00},
++{0x3396, 0x00},
++{0x3397, 0x00},
++{0x3398, 0x00},
++{0x3399, 0x00},
++{0x339a, 0x00},
++{0x339b, 0x00},
++{0x33b0, 0x00},
++{0x33b1, 0x50},
++{0x33b2, 0x01},
++{0x33b3, 0xff},
++{0x33b4, 0xe0},
++{0x33b5, 0x6b},
++{0x33b6, 0x00},
++{0x33b7, 0x00},
++{0x33b8, 0x00},
++{0x33b9, 0x00},
++{0x33ba, 0x00},
++{0x33bb, 0x1f},
++{0x33bc, 0x01},
++{0x33bd, 0x01},
++{0x33be, 0x01},
++{0x33bf, 0x01},
++{0x33c0, 0x00},
++{0x33c1, 0x00},
++{0x33c2, 0x00},
++{0x33c3, 0x00},
++{0x33e0, 0x14},
++{0x33e1, 0x0f},
++{0x33e2, 0x02},
++{0x33e3, 0x01},
++{0x33e4, 0x01},
++{0x33e5, 0x01},
++{0x33e6, 0x00},
++{0x33e7, 0x04},
++{0x33e8, 0x0c},
++{0x33e9, 0x02},
++{0x33ea, 0x02},
++{0x33eb, 0x02},
++{0x33ec, 0x03},
++{0x33ed, 0x01},
++{0x33ee, 0x02},
++{0x33ef, 0x08},
++{0x33f0, 0x08},
++{0x33f1, 0x04},
++{0x33f2, 0x04},
++{0x33f3, 0x00},
++{0x33f4, 0x03},
++{0x33f5, 0x14},
++{0x33f6, 0x0f},
++{0x33f7, 0x02},
++{0x33f8, 0x01},
++{0x33f9, 0x01},
++{0x33fa, 0x01},
++{0x33fb, 0x00},
++{0x33fc, 0x04},
++{0x33fd, 0x0c},
++{0x33fe, 0x02},
++{0x33ff, 0x02},
++{0x3400, 0x02},
++{0x3401, 0x03},
++{0x3402, 0x01},
++{0x3403, 0x02},
++{0x3404, 0x08},
++{0x3405, 0x08},
++{0x3406, 0x04},
++{0x3407, 0x04},
++{0x3408, 0x00},
++{0x3409, 0x03},
++{0x340a, 0x14},
++{0x340b, 0x0f},
++{0x340c, 0x04},
++{0x340d, 0x02},
++{0x340e, 0x01},
++{0x340f, 0x01},
++{0x3410, 0x00},
++{0x3411, 0x04},
++{0x3412, 0x0c},
++{0x3413, 0x00},
++{0x3414, 0x01},
++{0x3415, 0x02},
++{0x3416, 0x03},
++{0x3417, 0x02},
++{0x3418, 0x05},
++{0x3419, 0x0a},
++{0x341a, 0x08},
++{0x341b, 0x04},
++{0x341c, 0x04},
++{0x341d, 0x00},
++{0x341e, 0x03},
++{0x3440, 0x00},
++{0x3441, 0x00},
++{0x3442, 0x00},
++{0x3443, 0x00},
++{0x3444, 0x02},
++{0x3445, 0xf0},
++{0x3446, 0x02},
++{0x3447, 0x08},
++{0x3448, 0x00},
++{0x3460, 0x40},
++{0x3461, 0x40},
++{0x3462, 0x40},
++{0x3463, 0x40},
++{0x3464, 0x03},
++{0x3465, 0x01},
++{0x3466, 0x01},
++{0x3467, 0x02},
++{0x3468, 0x30},
++{0x3469, 0x00},
++{0x346a, 0x33},
++{0x346b, 0xbf},
++{0x3480, 0x40},
++{0x3481, 0x00},
++{0x3482, 0x00},
++{0x3483, 0x00},
++{0x3484, 0x0d},
++{0x3485, 0x00},
++{0x3486, 0x00},
++{0x3487, 0x00},
++{0x3488, 0x00},
++{0x3489, 0x00},
++{0x348a, 0x00},
++{0x348b, 0x04},
++{0x348c, 0x00},
++{0x348d, 0x01},
++{0x348f, 0x01},
++{0x3030, 0x0a},
++{0x3030, 0x02},
++{0x7000, 0x58},
++{0x7001, 0x7a},
++{0x7002, 0x1a},
++{0x7003, 0xc1},
++{0x7004, 0x03},
++{0x7005, 0xda},
++{0x7006, 0xbd},
++{0x7007, 0x03},
++{0x7008, 0xbd},
++{0x7009, 0x06},
++{0x700a, 0xe6},
++{0x700b, 0xec},
++{0x700c, 0xbc},
++{0x700d, 0xff},
++{0x700e, 0xbc},
++{0x700f, 0x73},
++{0x7010, 0xda},
++{0x7011, 0x72},
++{0x7012, 0x76},
++{0x7013, 0xb6},
++{0x7014, 0xee},
++{0x7015, 0xcf},
++{0x7016, 0xac},
++{0x7017, 0xd0},
++{0x7018, 0xac},
++{0x7019, 0xd1},
++{0x701a, 0x50},
++{0x701b, 0xac},
++{0x701c, 0xd2},
++{0x701d, 0xbc},
++{0x701e, 0x2e},
++{0x701f, 0xb4},
++{0x7020, 0x00},
++{0x7021, 0xdc},
++{0x7022, 0xdf},
++{0x7023, 0xb0},
++{0x7024, 0x6e},
++{0x7025, 0xbd},
++{0x7026, 0x01},
++{0x7027, 0xd7},
++{0x7028, 0xed},
++{0x7029, 0xe1},
++{0x702a, 0x36},
++{0x702b, 0x30},
++{0x702c, 0xd3},
++{0x702d, 0x2e},
++{0x702e, 0x54},
++{0x702f, 0x46},
++{0x7030, 0xbc},
++{0x7031, 0x22},
++{0x7032, 0x66},
++{0x7033, 0xbc},
++{0x7034, 0x24},
++{0x7035, 0x2c},
++{0x7036, 0x28},
++{0x7037, 0xbc},
++{0x7038, 0x3c},
++{0x7039, 0xa1},
++{0x703a, 0xac},
++{0x703b, 0xd8},
++{0x703c, 0xd6},
++{0x703d, 0xb4},
++{0x703e, 0x04},
++{0x703f, 0x46},
++{0x7040, 0xb7},
++{0x7041, 0x04},
++{0x7042, 0xbe},
++{0x7043, 0x08},
++{0x7044, 0xc3},
++{0x7045, 0xd9},
++{0x7046, 0xad},
++{0x7047, 0xc3},
++{0x7048, 0xbc},
++{0x7049, 0x19},
++{0x704a, 0xc1},
++{0x704b, 0x27},
++{0x704c, 0xe7},
++{0x704d, 0x00},
++{0x704e, 0x50},
++{0x704f, 0x20},
++{0x7050, 0xb8},
++{0x7051, 0x02},
++{0x7052, 0xbc},
++{0x7053, 0x17},
++{0x7054, 0xdb},
++{0x7055, 0xc7},
++{0x7056, 0xb8},
++{0x7057, 0x00},
++{0x7058, 0x28},
++{0x7059, 0x54},
++{0x705a, 0xb4},
++{0x705b, 0x14},
++{0x705c, 0xab},
++{0x705d, 0xbe},
++{0x705e, 0x06},
++{0x705f, 0xd8},
++{0x7060, 0xd6},
++{0x7061, 0x00},
++{0x7062, 0xb4},
++{0x7063, 0xc7},
++{0x7064, 0x07},
++{0x7065, 0xb9},
++{0x7066, 0x05},
++{0x7067, 0xee},
++{0x7068, 0xe6},
++{0x7069, 0xad},
++{0x706a, 0xb4},
++{0x706b, 0x26},
++{0x706c, 0x19},
++{0x706d, 0xc1},
++{0x706e, 0x3a},
++{0x706f, 0xc3},
++{0x7070, 0xaf},
++{0x7071, 0x00},
++{0x7072, 0xc0},
++{0x7073, 0x3c},
++{0x7074, 0xc3},
++{0x7075, 0xbe},
++{0x7076, 0xe7},
++{0x7077, 0x00},
++{0x7078, 0x15},
++{0x7079, 0xc2},
++{0x707a, 0x40},
++{0x707b, 0xc3},
++{0x707c, 0xa4},
++{0x707d, 0xc0},
++{0x707e, 0x3c},
++{0x707f, 0x00},
++{0x7080, 0xb9},
++{0x7081, 0x64},
++{0x7082, 0x29},
++{0x7083, 0x00},
++{0x7084, 0xb8},
++{0x7085, 0x12},
++{0x7086, 0xbe},
++{0x7087, 0x01},
++{0x7088, 0xd0},
++{0x7089, 0xbc},
++{0x708a, 0x01},
++{0x708b, 0xac},
++{0x708c, 0x37},
++{0x708d, 0xd2},
++{0x708e, 0xac},
++{0x708f, 0x45},
++{0x7090, 0xad},
++{0x7091, 0x28},
++{0x7092, 0x00},
++{0x7093, 0xb8},
++{0x7094, 0x00},
++{0x7095, 0xbc},
++{0x7096, 0x01},
++{0x7097, 0x36},
++{0x7098, 0xd3},
++{0x7099, 0x30},
++{0x709a, 0x04},
++{0x709b, 0xe0},
++{0x709c, 0xd8},
++{0x709d, 0xb4},
++{0x709e, 0xe9},
++{0x709f, 0x00},
++{0x70a0, 0xbe},
++{0x70a1, 0x05},
++{0x70a2, 0x62},
++{0x70a3, 0x07},
++{0x70a4, 0xb9},
++{0x70a5, 0x05},
++{0x70a6, 0xad},
++{0x70a7, 0xc3},
++{0x70a8, 0xcf},
++{0x70a9, 0x00},
++{0x70aa, 0x15},
++{0x70ab, 0xc2},
++{0x70ac, 0x59},
++{0x70ad, 0xc3},
++{0x70ae, 0xc9},
++{0x70af, 0xc0},
++{0x70b0, 0x55},
++{0x70b1, 0x00},
++{0x70b2, 0x46},
++{0x70b3, 0xa1},
++{0x70b4, 0xb9},
++{0x70b5, 0x64},
++{0x70b6, 0x29},
++{0x70b7, 0x00},
++{0x70b8, 0xb8},
++{0x70b9, 0x02},
++{0x70ba, 0xbe},
++{0x70bb, 0x02},
++{0x70bc, 0xd0},
++{0x70bd, 0xdc},
++{0x70be, 0xac},
++{0x70bf, 0xbc},
++{0x70c0, 0x01},
++{0x70c1, 0x37},
++{0x70c2, 0xac},
++{0x70c3, 0xd2},
++{0x70c4, 0x45},
++{0x70c5, 0xad},
++{0x70c6, 0x28},
++{0x70c7, 0x00},
++{0x70c8, 0xb8},
++{0x70c9, 0x00},
++{0x70ca, 0xbc},
++{0x70cb, 0x01},
++{0x70cc, 0x36},
++{0x70cd, 0x30},
++{0x70ce, 0xe0},
++{0x70cf, 0xd8},
++{0x70d0, 0xb5},
++{0x70d1, 0x0b},
++{0x70d2, 0xd6},
++{0x70d3, 0xbe},
++{0x70d4, 0x07},
++{0x70d5, 0x00},
++{0x70d6, 0x62},
++{0x70d7, 0x07},
++{0x70d8, 0xb9},
++{0x70d9, 0x05},
++{0x70da, 0xad},
++{0x70db, 0xc3},
++{0x70dc, 0xcf},
++{0x70dd, 0x46},
++{0x70de, 0xcd},
++{0x70df, 0x07},
++{0x70e0, 0xcd},
++{0x70e1, 0x00},
++{0x70e2, 0xe3},
++{0x70e3, 0x18},
++{0x70e4, 0xc2},
++{0x70e5, 0xa2},
++{0x70e6, 0xb9},
++{0x70e7, 0x64},
++{0x70e8, 0xd1},
++{0x70e9, 0xdd},
++{0x70ea, 0xac},
++{0x70eb, 0xcf},
++{0x70ec, 0xdf},
++{0x70ed, 0xb5},
++{0x70ee, 0x19},
++{0x70ef, 0x46},
++{0x70f0, 0x50},
++{0x70f1, 0xb6},
++{0x70f2, 0xee},
++{0x70f3, 0xe8},
++{0x70f4, 0xe6},
++{0x70f5, 0xbc},
++{0x70f6, 0x31},
++{0x70f7, 0xe1},
++{0x70f8, 0x36},
++{0x70f9, 0x30},
++{0x70fa, 0xd3},
++{0x70fb, 0x2e},
++{0x70fc, 0x54},
++{0x70fd, 0xbd},
++{0x70fe, 0x03},
++{0x70ff, 0xec},
++{0x7100, 0x2c},
++{0x7101, 0x50},
++{0x7102, 0x20},
++{0x7103, 0x04},
++{0x7104, 0xb8},
++{0x7105, 0x02},
++{0x7106, 0xbc},
++{0x7107, 0x18},
++{0x7108, 0xc7},
++{0x7109, 0xb8},
++{0x710a, 0x00},
++{0x710b, 0x28},
++{0x710c, 0x54},
++{0x710d, 0xbc},
++{0x710e, 0x02},
++{0x710f, 0xb4},
++{0x7110, 0xda},
++{0x7111, 0xbe},
++{0x7112, 0x04},
++{0x7113, 0xd6},
++{0x7114, 0xd8},
++{0x7115, 0xab},
++{0x7116, 0x00},
++{0x7117, 0x62},
++{0x7118, 0x07},
++{0x7119, 0xb9},
++{0x711a, 0x05},
++{0x711b, 0xad},
++{0x711c, 0xc3},
++{0x711d, 0xbc},
++{0x711e, 0xe7},
++{0x711f, 0xb9},
++{0x7120, 0x64},
++{0x7121, 0x29},
++{0x7122, 0x00},
++{0x7123, 0xb8},
++{0x7124, 0x02},
++{0x7125, 0xbe},
++{0x7126, 0x00},
++{0x7127, 0x45},
++{0x7128, 0xad},
++{0x7129, 0xe2},
++{0x712a, 0x28},
++{0x712b, 0x00},
++{0x712c, 0xb8},
++{0x712d, 0x00},
++{0x712e, 0xe0},
++{0x712f, 0xd8},
++{0x7130, 0xb4},
++{0x7131, 0xe9},
++{0x7132, 0xbe},
++{0x7133, 0x03},
++{0x7134, 0x00},
++{0x7135, 0x30},
++{0x7136, 0x62},
++{0x7137, 0x07},
++{0x7138, 0xb9},
++{0x7139, 0x05},
++{0x713a, 0xad},
++{0x713b, 0xc3},
++{0x713c, 0xcf},
++{0x713d, 0x42},
++{0x713e, 0xe4},
++{0x713f, 0xcd},
++{0x7140, 0x07},
++{0x7141, 0xcd},
++{0x7142, 0x00},
++{0x7143, 0x00},
++{0x7144, 0x17},
++{0x7145, 0xc2},
++{0x7146, 0xbb},
++{0x7147, 0xde},
++{0x7148, 0xcf},
++{0x7149, 0xdf},
++{0x714a, 0xac},
++{0x714b, 0xd1},
++{0x714c, 0x44},
++{0x714d, 0xac},
++{0x714e, 0xb9},
++{0x714f, 0x76},
++{0x7150, 0xb8},
++{0x7151, 0x08},
++{0x7152, 0xb6},
++{0x7153, 0xfe},
++{0x7154, 0xb4},
++{0x7155, 0xca},
++{0x7156, 0xd6},
++{0x7157, 0xd8},
++{0x7158, 0xab},
++{0x7159, 0x00},
++{0x715a, 0xe1},
++{0x715b, 0x36},
++{0x715c, 0x30},
++{0x715d, 0xd3},
++{0x715e, 0xbc},
++{0x715f, 0x29},
++{0x7160, 0xb4},
++{0x7161, 0x1f},
++{0x7162, 0xaa},
++{0x7163, 0xbd},
++{0x7164, 0x01},
++{0x7165, 0xb8},
++{0x7166, 0x0c},
++{0x7167, 0x45},
++{0x7168, 0xa4},
++{0x7169, 0xbd},
++{0x716a, 0x03},
++{0x716b, 0xec},
++{0x716c, 0xbc},
++{0x716d, 0x3d},
++{0x716e, 0xc3},
++{0x716f, 0xcf},
++{0x7170, 0x42},
++{0x7171, 0xb8},
++{0x7172, 0x00},
++{0x7173, 0xe4},
++{0x7174, 0xd5},
++{0x7175, 0x00},
++{0x7176, 0xb6},
++{0x7177, 0x00},
++{0x7178, 0x74},
++{0x7179, 0xbd},
++{0x717a, 0x03},
++{0x717b, 0x40},
++{0x717c, 0xb5},
++{0x717d, 0x39},
++{0x717e, 0x58},
++{0x717f, 0xdd},
++{0x7180, 0x19},
++{0x7181, 0xc1},
++{0x7182, 0xc8},
++{0x7183, 0xbd},
++{0x7184, 0x06},
++{0x7185, 0x17},
++{0x7186, 0xc1},
++{0x7187, 0xc6},
++{0x7188, 0xe8},
++{0x7189, 0x00},
++{0x718a, 0xc0},
++{0x718b, 0xc8},
++{0x718c, 0xe6},
++{0x718d, 0x95},
++{0x718e, 0x15},
++{0x718f, 0x00},
++{0x7190, 0xbc},
++{0x7191, 0x19},
++{0x7192, 0xb9},
++{0x7193, 0xf6},
++{0x7194, 0x14},
++{0x7195, 0xc1},
++{0x7196, 0xd0},
++{0x7197, 0xd1},
++{0x7198, 0xac},
++{0x7199, 0x37},
++{0x719a, 0xbc},
++{0x719b, 0x35},
++{0x719c, 0x36},
++{0x719d, 0x30},
++{0x719e, 0xe1},
++{0x719f, 0xd3},
++{0x71a0, 0x7a},
++{0x71a1, 0xb6},
++{0x71a2, 0x0c},
++{0x71a3, 0xff},
++{0x71a4, 0xb4},
++{0x71a5, 0xc7},
++{0x71a6, 0xd9},
++{0x71a7, 0x00},
++{0x71a8, 0xbd},
++{0x71a9, 0x01},
++{0x71aa, 0x56},
++{0x71ab, 0xc0},
++{0x71ac, 0xda},
++{0x71ad, 0xb4},
++{0x71ae, 0x1f},
++{0x71af, 0x56},
++{0x71b0, 0xaa},
++{0x71b1, 0xbc},
++{0x71b2, 0x08},
++{0x71b3, 0x00},
++{0x71b4, 0x57},
++{0x71b5, 0xe8},
++{0x71b6, 0xb5},
++{0x71b7, 0x36},
++{0x71b8, 0x00},
++{0x71b9, 0x54},
++{0x71ba, 0xe7},
++{0x71bb, 0xc8},
++{0x71bc, 0xb4},
++{0x71bd, 0x1f},
++{0x71be, 0x56},
++{0x71bf, 0xaa},
++{0x71c0, 0xbc},
++{0x71c1, 0x08},
++{0x71c2, 0x57},
++{0x71c3, 0x00},
++{0x71c4, 0xb5},
++{0x71c5, 0x36},
++{0x71c6, 0x00},
++{0x71c7, 0x54},
++{0x71c8, 0xc8},
++{0x71c9, 0xb5},
++{0x71ca, 0x18},
++{0x71cb, 0xd9},
++{0x71cc, 0x00},
++{0x71cd, 0xbd},
++{0x71ce, 0x01},
++{0x71cf, 0x56},
++{0x71d0, 0x08},
++{0x71d1, 0x57},
++{0x71d2, 0xe8},
++{0x71d3, 0xb4},
++{0x71d4, 0x42},
++{0x71d5, 0x00},
++{0x71d6, 0x54},
++{0x71d7, 0xe7},
++{0x71d8, 0xc8},
++{0x71d9, 0xab},
++{0x71da, 0x00},
++{0x71db, 0x66},
++{0x71dc, 0x62},
++{0x71dd, 0x06},
++{0x71de, 0x74},
++{0x71df, 0xb9},
++{0x71e0, 0x05},
++{0x71e1, 0xb7},
++{0x71e2, 0x14},
++{0x71e3, 0x0e},
++{0x71e4, 0xb7},
++{0x71e5, 0x04},
++{0x71e6, 0xc8},
++{0x7600, 0x04},
++{0x7601, 0x80},
++{0x7602, 0x07},
++{0x7603, 0x44},
++{0x7604, 0x05},
++{0x7605, 0x33},
++{0x7606, 0x0f},
++{0x7607, 0x00},
++{0x7608, 0x07},
++{0x7609, 0x40},
++{0x760a, 0x04},
++{0x760b, 0xe5},
++{0x760c, 0x06},
++{0x760d, 0x50},
++{0x760e, 0x04},
++{0x760f, 0xe4},
++{0x7610, 0x00},
++{0x7611, 0x00},
++{0x7612, 0x06},
++{0x7613, 0x5c},
++{0x7614, 0x00},
++{0x7615, 0x0f},
++{0x7616, 0x06},
++{0x7617, 0x1c},
++{0x7618, 0x00},
++{0x7619, 0x02},
++{0x761a, 0x06},
++{0x761b, 0xa2},
++{0x761c, 0x00},
++{0x761d, 0x01},
++{0x761e, 0x06},
++{0x761f, 0xae},
++{0x7620, 0x00},
++{0x7621, 0x0e},
++{0x7622, 0x05},
++{0x7623, 0x30},
++{0x7624, 0x07},
++{0x7625, 0x00},
++{0x7626, 0x0f},
++{0x7627, 0x00},
++{0x7628, 0x04},
++{0x7629, 0xe5},
++{0x762a, 0x05},
++{0x762b, 0x33},
++{0x762c, 0x06},
++{0x762d, 0x12},
++{0x762e, 0x00},
++{0x762f, 0x01},
++{0x7630, 0x06},
++{0x7631, 0x52},
++{0x7632, 0x00},
++{0x7633, 0x01},
++{0x7634, 0x06},
++{0x7635, 0x5e},
++{0x7636, 0x04},
++{0x7637, 0xe4},
++{0x7638, 0x00},
++{0x7639, 0x01},
++{0x763a, 0x05},
++{0x763b, 0x30},
++{0x763c, 0x0f},
++{0x763d, 0x00},
++{0x763e, 0x06},
++{0x763f, 0xa6},
++{0x7640, 0x00},
++{0x7641, 0x02},
++{0x7642, 0x06},
++{0x7643, 0x26},
++{0x7644, 0x00},
++{0x7645, 0x02},
++{0x7646, 0x05},
++{0x7647, 0x33},
++{0x7648, 0x06},
++{0x7649, 0x20},
++{0x764a, 0x0f},
++{0x764b, 0x00},
++{0x764c, 0x06},
++{0x764d, 0x56},
++{0x764e, 0x00},
++{0x764f, 0x02},
++{0x7650, 0x06},
++{0x7651, 0x16},
++{0x7652, 0x05},
++{0x7653, 0x33},
++{0x7654, 0x06},
++{0x7655, 0x10},
++{0x7656, 0x0f},
++{0x7657, 0x00},
++{0x7658, 0x06},
++{0x7659, 0x10},
++{0x765a, 0x0f},
++{0x765b, 0x00},
++{0x765c, 0x06},
++{0x765d, 0x20},
++{0x765e, 0x0f},
++{0x765f, 0x00},
++{0x7660, 0x00},
++{0x7661, 0x00},
++{0x7662, 0x00},
++{0x7663, 0x02},
++{0x7664, 0x04},
++{0x7665, 0xe5},
++{0x7666, 0x04},
++{0x7667, 0xe4},
++{0x7668, 0x0f},
++{0x7669, 0x00},
++{0x766a, 0x00},
++{0x766b, 0x00},
++{0x766c, 0x00},
++{0x766d, 0x01},
++{0x766e, 0x04},
++{0x766f, 0xe5},
++{0x7670, 0x04},
++{0x7671, 0xe4},
++{0x7672, 0x0f},
++{0x7673, 0x00},
++{0x7674, 0x00},
++{0x7675, 0x02},
++{0x7676, 0x04},
++{0x7677, 0xe4},
++{0x7678, 0x00},
++{0x7679, 0x02},
++{0x767a, 0x04},
++{0x767b, 0xc4},
++{0x767c, 0x00},
++{0x767d, 0x02},
++{0x767e, 0x04},
++{0x767f, 0xc4},
++{0x7680, 0x05},
++{0x7681, 0x83},
++{0x7682, 0x0f},
++{0x7683, 0x00},
++{0x7684, 0x00},
++{0x7685, 0x02},
++{0x7686, 0x04},
++{0x7687, 0xe4},
++{0x7688, 0x00},
++{0x7689, 0x02},
++{0x768a, 0x04},
++{0x768b, 0xc4},
++{0x768c, 0x00},
++{0x768d, 0x02},
++{0x768e, 0x04},
++{0x768f, 0xc4},
++{0x7690, 0x05},
++{0x7691, 0x83},
++{0x7692, 0x03},
++{0x7693, 0x0b},
++{0x7694, 0x05},
++{0x7695, 0x83},
++{0x7696, 0x00},
++{0x7697, 0x07},
++{0x7698, 0x05},
++{0x7699, 0x03},
++{0x769a, 0x00},
++{0x769b, 0x05},
++{0x769c, 0x05},
++{0x769d, 0x32},
++{0x769e, 0x05},
++{0x769f, 0x30},
++{0x76a0, 0x00},
++{0x76a1, 0x02},
++{0x76a2, 0x05},
++{0x76a3, 0x78},
++{0x76a4, 0x00},
++{0x76a5, 0x01},
++{0x76a6, 0x05},
++{0x76a7, 0x7c},
++{0x76a8, 0x03},
++{0x76a9, 0x9a},
++{0x76aa, 0x05},
++{0x76ab, 0x83},
++{0x76ac, 0x00},
++{0x76ad, 0x04},
++{0x76ae, 0x05},
++{0x76af, 0x03},
++{0x76b0, 0x00},
++{0x76b1, 0x03},
++{0x76b2, 0x05},
++{0x76b3, 0x32},
++{0x76b4, 0x05},
++{0x76b5, 0x30},
++{0x76b6, 0x00},
++{0x76b7, 0x02},
++{0x76b8, 0x05},
++{0x76b9, 0x78},
++{0x76ba, 0x00},
++{0x76bb, 0x01},
++{0x76bc, 0x05},
++{0x76bd, 0x7c},
++{0x76be, 0x03},
++{0x76bf, 0x99},
++{0x76c0, 0x05},
++{0x76c1, 0x83},
++{0x76c2, 0x00},
++{0x76c3, 0x03},
++{0x76c4, 0x05},
++{0x76c5, 0x03},
++{0x76c6, 0x00},
++{0x76c7, 0x01},
++{0x76c8, 0x05},
++{0x76c9, 0x32},
++{0x76ca, 0x05},
++{0x76cb, 0x30},
++{0x76cc, 0x00},
++{0x76cd, 0x02},
++{0x76ce, 0x05},
++{0x76cf, 0x78},
++{0x76d0, 0x00},
++{0x76d1, 0x01},
++{0x76d2, 0x05},
++{0x76d3, 0x7c},
++{0x76d4, 0x03},
++{0x76d5, 0x98},
++{0x76d6, 0x05},
++{0x76d7, 0x83},
++{0x76d8, 0x00},
++{0x76d9, 0x00},
++{0x76da, 0x05},
++{0x76db, 0x03},
++{0x76dc, 0x00},
++{0x76dd, 0x01},
++{0x76de, 0x05},
++{0x76df, 0x32},
++{0x76e0, 0x05},
++{0x76e1, 0x30},
++{0x76e2, 0x00},
++{0x76e3, 0x02},
++{0x76e4, 0x05},
++{0x76e5, 0x78},
++{0x76e6, 0x00},
++{0x76e7, 0x01},
++{0x76e8, 0x05},
++{0x76e9, 0x7c},
++{0x76ea, 0x03},
++{0x76eb, 0x97},
++{0x76ec, 0x05},
++{0x76ed, 0x83},
++{0x76ee, 0x00},
++{0x76ef, 0x00},
++{0x76f0, 0x05},
++{0x76f1, 0x03},
++{0x76f2, 0x05},
++{0x76f3, 0x32},
++{0x76f4, 0x05},
++{0x76f5, 0x30},
++{0x76f6, 0x00},
++{0x76f7, 0x02},
++{0x76f8, 0x05},
++{0x76f9, 0x78},
++{0x76fa, 0x00},
++{0x76fb, 0x01},
++{0x76fc, 0x05},
++{0x76fd, 0x7c},
++{0x76fe, 0x03},
++{0x76ff, 0x96},
++{0x7700, 0x05},
++{0x7701, 0x83},
++{0x7702, 0x05},
++{0x7703, 0x03},
++{0x7704, 0x05},
++{0x7705, 0x32},
++{0x7706, 0x05},
++{0x7707, 0x30},
++{0x7708, 0x00},
++{0x7709, 0x02},
++{0x770a, 0x05},
++{0x770b, 0x78},
++{0x770c, 0x00},
++{0x770d, 0x01},
++{0x770e, 0x05},
++{0x770f, 0x7c},
++{0x7710, 0x03},
++{0x7711, 0x95},
++{0x7712, 0x05},
++{0x7713, 0x83},
++{0x7714, 0x05},
++{0x7715, 0x03},
++{0x7716, 0x05},
++{0x7717, 0x32},
++{0x7718, 0x05},
++{0x7719, 0x30},
++{0x771a, 0x00},
++{0x771b, 0x02},
++{0x771c, 0x05},
++{0x771d, 0x78},
++{0x771e, 0x00},
++{0x771f, 0x01},
++{0x7720, 0x05},
++{0x7721, 0x7c},
++{0x7722, 0x03},
++{0x7723, 0x94},
++{0x7724, 0x05},
++{0x7725, 0x83},
++{0x7726, 0x00},
++{0x7727, 0x01},
++{0x7728, 0x05},
++{0x7729, 0x03},
++{0x772a, 0x00},
++{0x772b, 0x01},
++{0x772c, 0x05},
++{0x772d, 0x32},
++{0x772e, 0x05},
++{0x772f, 0x30},
++{0x7730, 0x00},
++{0x7731, 0x02},
++{0x7732, 0x05},
++{0x7733, 0x78},
++{0x7734, 0x00},
++{0x7735, 0x01},
++{0x7736, 0x05},
++{0x7737, 0x7c},
++{0x7738, 0x03},
++{0x7739, 0x93},
++{0x773a, 0x05},
++{0x773b, 0x83},
++{0x773c, 0x00},
++{0x773d, 0x00},
++{0x773e, 0x05},
++{0x773f, 0x03},
++{0x7740, 0x00},
++{0x7741, 0x00},
++{0x7742, 0x05},
++{0x7743, 0x32},
++{0x7744, 0x05},
++{0x7745, 0x30},
++{0x7746, 0x00},
++{0x7747, 0x02},
++{0x7748, 0x05},
++{0x7749, 0x78},
++{0x774a, 0x00},
++{0x774b, 0x01},
++{0x774c, 0x05},
++{0x774d, 0x7c},
++{0x774e, 0x03},
++{0x774f, 0x92},
++{0x7750, 0x05},
++{0x7751, 0x83},
++{0x7752, 0x05},
++{0x7753, 0x03},
++{0x7754, 0x00},
++{0x7755, 0x00},
++{0x7756, 0x05},
++{0x7757, 0x32},
++{0x7758, 0x05},
++{0x7759, 0x30},
++{0x775a, 0x00},
++{0x775b, 0x02},
++{0x775c, 0x05},
++{0x775d, 0x78},
++{0x775e, 0x00},
++{0x775f, 0x01},
++{0x7760, 0x05},
++{0x7761, 0x7c},
++{0x7762, 0x03},
++{0x7763, 0x91},
++{0x7764, 0x05},
++{0x7765, 0x83},
++{0x7766, 0x05},
++{0x7767, 0x03},
++{0x7768, 0x05},
++{0x7769, 0x32},
++{0x776a, 0x05},
++{0x776b, 0x30},
++{0x776c, 0x00},
++{0x776d, 0x02},
++{0x776e, 0x05},
++{0x776f, 0x78},
++{0x7770, 0x00},
++{0x7771, 0x01},
++{0x7772, 0x05},
++{0x7773, 0x7c},
++{0x7774, 0x03},
++{0x7775, 0x90},
++{0x7776, 0x05},
++{0x7777, 0x83},
++{0x7778, 0x05},
++{0x7779, 0x03},
++{0x777a, 0x05},
++{0x777b, 0x32},
++{0x777c, 0x05},
++{0x777d, 0x30},
++{0x777e, 0x00},
++{0x777f, 0x02},
++{0x7780, 0x05},
++{0x7781, 0x78},
++{0x7782, 0x00},
++{0x7783, 0x01},
++{0x7784, 0x05},
++{0x7785, 0x7c},
++{0x7786, 0x02},
++{0x7787, 0x90},
++{0x7788, 0x05},
++{0x7789, 0x03},
++{0x778a, 0x07},
++{0x778b, 0x00},
++{0x778c, 0x0f},
++{0x778d, 0x00},
++{0x778e, 0x08},
++{0x778f, 0x30},
++{0x7790, 0x08},
++{0x7791, 0xee},
++{0x7792, 0x0f},
++{0x7793, 0x00},
++{0x7794, 0x05},
++{0x7795, 0x33},
++{0x7796, 0x04},
++{0x7797, 0xe5},
++{0x7798, 0x06},
++{0x7799, 0x52},
++{0x779a, 0x04},
++{0x779b, 0xe4},
++{0x779c, 0x00},
++{0x779d, 0x00},
++{0x779e, 0x06},
++{0x779f, 0x5e},
++{0x77a0, 0x00},
++{0x77a1, 0x0f},
++{0x77a2, 0x06},
++{0x77a3, 0x1e},
++{0x77a4, 0x00},
++{0x77a5, 0x02},
++{0x77a6, 0x06},
++{0x77a7, 0xa2},
++{0x77a8, 0x00},
++{0x77a9, 0x01},
++{0x77aa, 0x06},
++{0x77ab, 0xae},
++{0x77ac, 0x00},
++{0x77ad, 0x03},
++{0x77ae, 0x05},
++{0x77af, 0x30},
++{0x77b0, 0x09},
++{0x77b1, 0x19},
++{0x77b2, 0x0f},
++{0x77b3, 0x00},
++{0x77b4, 0x05},
++{0x77b5, 0x33},
++{0x77b6, 0x04},
++{0x77b7, 0xe5},
++{0x77b8, 0x06},
++{0x77b9, 0x52},
++{0x77ba, 0x04},
++{0x77bb, 0xe4},
++{0x77bc, 0x00},
++{0x77bd, 0x00},
++{0x77be, 0x06},
++{0x77bf, 0x5e},
++{0x77c0, 0x00},
++{0x77c1, 0x0f},
++{0x77c2, 0x06},
++{0x77c3, 0x1e},
++{0x77c4, 0x00},
++{0x77c5, 0x02},
++{0x77c6, 0x06},
++{0x77c7, 0xa2},
++{0x77c8, 0x00},
++{0x77c9, 0x01},
++{0x77ca, 0x06},
++{0x77cb, 0xae},
++{0x77cc, 0x00},
++{0x77cd, 0x03},
++{0x77ce, 0x05},
++{0x77cf, 0x30},
++{0x77d0, 0x0f},
++{0x77d1, 0x00},
++{0x77d2, 0x00},
++{0x77d3, 0x00},
++{0x77d4, 0x00},
++{0x77d5, 0x02},
++{0x77d6, 0x04},
++{0x77d7, 0xe5},
++{0x77d8, 0x04},
++{0x77d9, 0xe4},
++{0x77da, 0x05},
++{0x77db, 0x33},
++{0x77dc, 0x07},
++{0x77dd, 0x10},
++{0x77de, 0x00},
++{0x77df, 0x00},
++{0x77e0, 0x01},
++{0x77e1, 0xbb},
++{0x77e2, 0x00},
++{0x77e3, 0x00},
++{0x77e4, 0x01},
++{0x77e5, 0xaa},
++{0x77e6, 0x00},
++{0x77e7, 0x00},
++{0x77e8, 0x01},
++{0x77e9, 0x99},
++{0x77ea, 0x00},
++{0x77eb, 0x00},
++{0x77ec, 0x01},
++{0x77ed, 0x88},
++{0x77ee, 0x00},
++{0x77ef, 0x00},
++{0x77f0, 0x01},
++{0x77f1, 0x77},
++{0x77f2, 0x00},
++{0x77f3, 0x00},
++{0x77f4, 0x01},
++{0x77f5, 0x66},
++{0x77f6, 0x00},
++{0x77f7, 0x00},
++{0x77f8, 0x01},
++{0x77f9, 0x55},
++{0x77fa, 0x00},
++{0x77fb, 0x00},
++{0x77fc, 0x01},
++{0x77fd, 0x44},
++{0x77fe, 0x00},
++{0x77ff, 0x00},
++{0x7800, 0x01},
++{0x7801, 0x33},
++{0x7802, 0x00},
++{0x7803, 0x00},
++{0x7804, 0x01},
++{0x7805, 0x22},
++{0x7806, 0x00},
++{0x7807, 0x00},
++{0x7808, 0x01},
++{0x7809, 0x11},
++{0x780a, 0x00},
++{0x780b, 0x00},
++{0x780c, 0x01},
++{0x780d, 0x00},
++{0x780e, 0x01},
++{0x780f, 0xff},
++{0x7810, 0x07},
++{0x7811, 0x00},
++{0x7812, 0x02},
++{0x7813, 0xa0},
++{0x7814, 0x0f},
++{0x7815, 0x00},
++{0x7816, 0x08},
++{0x7817, 0x35},
++{0x7818, 0x06},
++{0x7819, 0x52},
++{0x781a, 0x04},
++{0x781b, 0xe4},
++{0x781c, 0x00},
++{0x781d, 0x00},
++{0x781e, 0x06},
++{0x781f, 0x5e},
++{0x7820, 0x05},
++{0x7821, 0x33},
++{0x7822, 0x09},
++{0x7823, 0x19},
++{0x7824, 0x06},
++{0x7825, 0x1e},
++{0x7826, 0x05},
++{0x7827, 0x33},
++{0x7828, 0x00},
++{0x7829, 0x01},
++{0x782a, 0x06},
++{0x782b, 0x24},
++{0x782c, 0x06},
++{0x782d, 0x20},
++{0x782e, 0x0f},
++{0x782f, 0x00},
++{0x7830, 0x08},
++{0x7831, 0x35},
++{0x7832, 0x07},
++{0x7833, 0x10},
++{0x7834, 0x00},
++{0x7835, 0x00},
++{0x7836, 0x01},
++{0x7837, 0xbb},
++{0x7838, 0x00},
++{0x7839, 0x00},
++{0x783a, 0x01},
++{0x783b, 0xaa},
++{0x783c, 0x00},
++{0x783d, 0x00},
++{0x783e, 0x01},
++{0x783f, 0x99},
++{0x7840, 0x00},
++{0x7841, 0x00},
++{0x7842, 0x01},
++{0x7843, 0x88},
++{0x7844, 0x00},
++{0x7845, 0x00},
++{0x7846, 0x01},
++{0x7847, 0x77},
++{0x7848, 0x00},
++{0x7849, 0x00},
++{0x784a, 0x01},
++{0x784b, 0x66},
++{0x784c, 0x00},
++{0x784d, 0x00},
++{0x784e, 0x01},
++{0x784f, 0x55},
++{0x7850, 0x00},
++{0x7851, 0x00},
++{0x7852, 0x01},
++{0x7853, 0x44},
++{0x7854, 0x00},
++{0x7855, 0x00},
++{0x7856, 0x01},
++{0x7857, 0x33},
++{0x7858, 0x00},
++{0x7859, 0x00},
++{0x785a, 0x01},
++{0x785b, 0x22},
++{0x785c, 0x00},
++{0x785d, 0x00},
++{0x785e, 0x01},
++{0x785f, 0x11},
++{0x7860, 0x00},
++{0x7861, 0x00},
++{0x7862, 0x01},
++{0x7863, 0x00},
++{0x7864, 0x07},
++{0x7865, 0x00},
++{0x7866, 0x01},
++{0x7867, 0xff},
++{0x7868, 0x02},
++{0x7869, 0xa0},
++{0x786a, 0x0f},
++{0x786b, 0x00},
++{0x786c, 0x08},
++{0x786d, 0x3a},
++{0x786e, 0x08},
++{0x786f, 0x6a},
++{0x7870, 0x0f},
++{0x7871, 0x00},
++{0x7872, 0x04},
++{0x7873, 0xc0},
++{0x7874, 0x09},
++{0x7875, 0x19},
++{0x7876, 0x04},
++{0x7877, 0x99},
++{0x7878, 0x07},
++{0x7879, 0x14},
++{0x787a, 0x00},
++{0x787b, 0x01},
++{0x787c, 0x04},
++{0x787d, 0xa4},
++{0x787e, 0x00},
++{0x787f, 0x0f},
++{0x7880, 0x00},
++{0x7881, 0x0f},
++{0x7882, 0x04},
++{0x7883, 0xa6},
++{0x7884, 0x00},
++{0x7885, 0x00},
++{0x7886, 0x04},
++{0x7887, 0xa0},
++{0x7888, 0x04},
++{0x7889, 0x80},
++{0x788a, 0x04},
++{0x788b, 0x00},
++{0x788c, 0x05},
++{0x788d, 0x03},
++{0x788e, 0x06},
++{0x788f, 0x00},
++{0x7890, 0x0f},
++{0x7891, 0x00},
++{0x7892, 0x0f},
++{0x7893, 0x00},
++{0x7894, 0x0f},
++{0x7895, 0x00},
++{0x30a0, 0x00},
++{0x30a1, 0x00},
++{0x30a2, 0x00},
++{0x30a3, 0x00},
++{0x30a4, 0x07},
++{0x30a5, 0x8f},
++{0x30a6, 0x04},
++{0x30a7, 0x47},
++{0x30a8, 0x00},
++{0x30a9, 0x04},
++{0x30aa, 0x00},
++{0x30ab, 0x04},
++{0x30ac, 0x07}, /* OV2775_MAX_WIDTH */
++{0x30ad, 0x88},
++{0x30ae, 0x04}, /* OV2775_MAX_HEIGHT */
++{0x30af, 0x40},
++{0x30b0, 0x0d},
++{0x30b1, 0xde},
++{0x30b2, 0x04},
++{0x30b3, 0x66},
++{0x3196, 0x00},
++{0x3197, 0x0a},
++{0x3195, 0x29},
++{0x315a, 0x02},
++{0x315b, 0x00},
++{0x30bb, 0x40},
++{0x3250, 0xf7},
++{0x3012, 0x01},
++};
diff --git a/drivers/media/i2c/soc_camera/ov490_ov10640.c b/drivers/media/i2c/soc_camera/ov490_ov10640.c
new file mode 100644
-index 0000000..be7098e
+index 0000000..812f367
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ov490_ov10640.c
-@@ -0,0 +1,1156 @@
+@@ -0,0 +1,1133 @@
+/*
+ * OmniVision ov490-ov10640 sensor camera driver
+ *
-+ * Copyright (C) 2016-2017 Cogent Embedded, Inc.
++ * Copyright (C) 2016-2018 Cogent Embedded, Inc.
+ *
+ * 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
@@ -4598,8 +12027,7 @@ index 0000000..be7098e
+ /* serializers */
+ int max9286_addr;
+ int max9271_addr;
-+ int ti964_addr;
-+ int ti954_addr;
++ int ti9x4_addr;
+ int ti9x3_addr;
+ int port;
+ int gpio_resetb;
@@ -4607,16 +12035,21 @@ index 0000000..be7098e
+ int gpio_fsin;
+};
+
-+static int force_conf_link;
++static int conf_link;
++module_param(conf_link, int, 0644);
++MODULE_PARM_DESC(conf_link, " Force configuration link. Used only if robust firmware flashing required (f.e. recovery)");
+
-+static __init int ov490_force_conf_link(char *str)
-+{
-+ /* force configuration link */
-+ /* used only if robust firmware flashing required (f.e. recovery) */
-+ force_conf_link = 1;
-+ return 0;
-+}
-+early_param("force_conf_link", ov490_force_conf_link);
++static int dvp_order;
++module_param(dvp_order, int, 0644);
++MODULE_PARM_DESC(dvp_order, " DVP bus bits order");
++
++static int max_width;
++module_param(max_width, int, 0644);
++MODULE_PARM_DESC(max_width, " Fixed sensor width");
++
++static int max_height;
++module_param(max_height, int, 0644);
++MODULE_PARM_DESC(max_height, " Fixed sensor height");
+
+static inline struct ov490_priv *to_ov490(const struct i2c_client *client)
+{
@@ -4632,7 +12065,7 @@ index 0000000..be7098e
+ tmp_addr = client->addr;
+ client->addr = priv->max9286_addr; /* Deserializer I2C address */
+ reg8_write(client, 0x0a, fwd_en ? 0x11 << priv->port : 0); /* Enable/disable reverse/forward control for this port */
-+ usleep_range(2000, 2500); /* wait 2ms */
++ usleep_range(5000, 5500); /* wait 5ms */
+ client->addr = tmp_addr;
+ };
+}
@@ -4658,18 +12091,8 @@ index 0000000..be7098e
+ client->addr = tmp_addr;
+ }
+
-+ if (priv->ti964_addr) {
-+ client->addr = priv->ti964_addr; /* TI964 I2C address */
-+
-+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x6e, 0x8a); /* set GPIO1 value to reset */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x6e, 0x9a); /* set GPIO1 value to un-reset */
-+ }
-+
-+ if (priv->ti954_addr) {
-+ client->addr = priv->ti954_addr; /* TI964 I2C address */
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* TI9x4 I2C address */
+
+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
+ usleep_range(2000, 2500); /* wait 2ms */
@@ -5355,7 +12778,7 @@ index 0000000..be7098e
+ goto err;
+ }
+
-+ if (unlikely(force_conf_link))
++ if (unlikely(conf_link))
+ goto out;
+
+again:
@@ -5440,7 +12863,7 @@ index 0000000..be7098e
+static int ov490_parse_dt(struct device_node *np, struct ov490_priv *priv)
+{
+ struct i2c_client *client = v4l2_get_subdevdata(&priv->sd);
-+ int err, i;
++ int i;
+ const char *fixed_sensor;
+ struct device_node *endpoint = NULL, *rendpoint = NULL;
+ int tmp_addr = 0;
@@ -5473,19 +12896,13 @@ index 0000000..be7098e
+ }
+
+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti964-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti964_addr) &&
-+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
-+ break;
-+
-+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti954-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti954_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
+ break;
+ }
+
-+ if (!priv->max9286_addr && !priv->ti964_addr && !priv->ti954_addr) {
++ if (!priv->max9286_addr && !priv->ti9x4_addr) {
+ dev_err(&client->dev, "deserializer does not present for OV490\n");
+ return -EINVAL;
+ }
@@ -5501,18 +12918,8 @@ index 0000000..be7098e
+ reg8_write(client, 0x0A, OV490_I2C_ADDR << 1); /* Sensor native I2C address */
+ usleep_range(2000, 2500); /* wait 2ms */
+ };
-+ if (priv->ti964_addr) {
-+ client->addr = priv->ti964_addr; /* Deserializer I2C address */
-+
-+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
-+ reg8_write(client, 0x5d, OV490_I2C_ADDR << 1); /* Sensor native I2C address */
-+
-+ reg8_write(client, 0x6e, 0x9a); /* GPIO0 - fsin, GPIO1 - resetb */
-+ }
-+ if (priv->ti954_addr) {
-+ client->addr = priv->ti954_addr; /* Deserializer I2C address */
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
+
+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
+ usleep_range(2000, 2500); /* wait 2ms */
@@ -5523,28 +12930,27 @@ index 0000000..be7098e
+ }
+ client->addr = tmp_addr;
+
-+ err = of_property_read_string(np, "maxim,fixed-sensor", &fixed_sensor);
-+ if (err)
-+ return 0;
++ if (!of_property_read_string(np, "maxim,fixed-sensor", &fixed_sensor) &&
++ strcmp(fixed_sensor, "ov490") == 0) {
++ if (of_property_read_u32(np, "maxim,width", &priv->max_width))
++ priv->max_width = 1280;
+
-+ if (strcmp(fixed_sensor, "ov490") == 0) {
-+ err = of_property_read_u32(np, "maxim,width", &priv->max_width);
-+ if (err) {
-+ dev_err(&client->dev, "maxim,width must be set for fixed-sensor\n");
-+ goto out;
-+ }
++ if (of_property_read_u32(np, "maxim,height", &priv->max_height))
++ priv->max_height = 966;
+
-+ err = of_property_read_u32(np, "maxim,height", &priv->max_height);
-+ if (err) {
-+ dev_err(&client->dev, "maxim,height must be set for fixed-sensor\n");
-+ goto out;
-+ }
++ priv->is_fixed_sensor = true;
++ }
+
++ /* module params override dts */
++ if (dvp_order)
++ priv->dvp_order = dvp_order;
++ if (max_width && max_height) {
++ priv->max_width = max_width;
++ priv->max_height = max_height;
+ priv->is_fixed_sensor = true;
+ }
+
-+out:
-+ return err;
++ return 0;
+}
+
+static int ov490_probe(struct i2c_client *client,
@@ -5805,10 +13211,10 @@ index 0000000..b22e93e
+};
diff --git a/drivers/media/i2c/soc_camera/ov495_ov2775.c b/drivers/media/i2c/soc_camera/ov495_ov2775.c
new file mode 100644
-index 0000000..6dc0675
+index 0000000..a371e22
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ov495_ov2775.c
-@@ -0,0 +1,658 @@
+@@ -0,0 +1,650 @@
+/*
+ * OmniVision ov495-ov2775 sensor camera driver
+ *
@@ -5860,8 +13266,7 @@ index 0000000..6dc0675
+ /* serializers */
+ int max9286_addr;
+ int max9271_addr;
-+ int ti960_addr;
-+ int ti954_addr;
++ int ti9x4_addr;
+ int ti9x3_addr;
+ int port;
+ int gpio_resetb;
@@ -6214,6 +13619,7 @@ index 0000000..6dc0675
+ struct ov495_priv *priv = to_ov495(client);
+ u8 pid = 0, ver = 0;
+ int ret = 0;
++ int tmp_addr;
+
+ /* check and show product ID and manufacturer ID */
+ reg16_write(client, 0xFFFD, 0x80);
@@ -6228,6 +13634,16 @@ index 0000000..6dc0675
+ goto err;
+ }
+
++ /* setup XCLK */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ /* CLK_OUT=22.5792*160*M/N/CLKDIV -> CLK_OUT=25MHz: CLKDIV=4, M=7, N=253: 22.5792*160/4*7/253=24.989MHz=CLK_OUT */
++ client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++ reg8_write(client, 0x06, 0x47); /* Set CLKDIV and M */
++ reg8_write(client, 0x07, 0xfd); /* Set N */
++ }
++ client->addr = tmp_addr;
++
+ if (unlikely(force_conf_link))
+ goto out;
+
@@ -6282,39 +13698,21 @@ index 0000000..6dc0675
+ continue;
+
+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti964-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti960_addr) &&
-+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
-+ break;
-+
-+ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
-+ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti954-ti9x3") &&
-+ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti954_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
+ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
+ break;
+ }
+
-+ if (!priv->ti960_addr && !priv->ti954_addr) {
++ if (!priv->ti9x4_addr) {
+ dev_err(&client->dev, "deserializer does not present for OV495\n");
+ return -EINVAL;
+ }
+
+ /* setup I2C translator address */
+ tmp_addr = client->addr;
-+ if (priv->ti960_addr) {
-+ client->addr = priv->ti960_addr; /* Deserializer I2C address */
-+
-+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
-+ reg8_write(client, 0x5d, OV495_I2C_ADDR << 1); /* Sensor native I2C address */
-+
-+ reg8_write(client, 0x6e, 0x9a); /* GPIO0 - fsin, GPIO1 - resetb */
-+ /* TODO: why too long? move logic to workqueue? */
-+ mdelay(350); /* time needed to boot all sensor IPs */
-+ }
-+ if (priv->ti954_addr) {
-+ client->addr = priv->ti954_addr; /* Deserializer I2C address */
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
+
+ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
+ usleep_range(2000, 2500); /* wait 2ms */
@@ -6469,12 +13867,12 @@ index 0000000..6dc0675
+#endif
diff --git a/drivers/media/i2c/soc_camera/ov495_ov2775.h b/drivers/media/i2c/soc_camera/ov495_ov2775.h
new file mode 100644
-index 0000000..3f53689
+index 0000000..17c94ae
--- /dev/null
+++ b/drivers/media/i2c/soc_camera/ov495_ov2775.h
@@ -0,0 +1,23 @@
+/*
-+ * OmniVision ov495-ov2775 sensor camera wizard 1280x1080@30/UYVY/BT601/8bit
++ * OmniVision ov495-ov2775 sensor camera wizard 1920x1080@30/UYVY/MIPI
+ *
+ * Copyright (C) 2017 Cogent Embedded, Inc.
+ *
@@ -6496,16 +13894,16 @@ index 0000000..3f53689
+{0x8017, 0x1e | (0 << 6)},
+{0x7c10, 0x01}, /* UYVY */
+};
-diff --git a/drivers/media/i2c/soc_camera/ti954_ti9x3.c b/drivers/media/i2c/soc_camera/ti954_ti9x3.c
+diff --git a/drivers/media/i2c/soc_camera/ox03a.c b/drivers/media/i2c/soc_camera/ox03a.c
new file mode 100644
-index 0000000..1672173
+index 0000000..d51512b9
--- /dev/null
-+++ b/drivers/media/i2c/soc_camera/ti954_ti9x3.c
-@@ -0,0 +1,431 @@
++++ b/drivers/media/i2c/soc_camera/ox03a.c
+@@ -0,0 +1,526 @@
+/*
-+ * TI ti954-(ti913/ti953) FPDLinkIII driver
++ * OmniVision OX03A sensor camera driver
+ *
-+ * Copyright (C) 2017 Cogent Embedded, Inc.
++ * Copyright (C) 2018 Cogent Embedded, Inc.
+ *
+ * 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
@@ -6514,190 +13912,213 @@ index 0000000..1672173
+ */
+
+#include <linux/delay.h>
++#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
-+#include <linux/notifier.h>
-+#include <linux/of_gpio.h>
-+#include <linux/regulator/consumer.h>
+#include <linux/videodev2.h>
+
++#include <media/soc_camera.h>
+#include <media/v4l2-common.h>
-+#include <media/v4l2-device.h>
++#include <media/v4l2-ctrls.h>
+#include <media/v4l2-of.h>
-+#include <media/v4l2-subdev.h>
+
-+#include "ti9x4_ti9x3.h"
++#include "ox03a.h"
+
-+struct ti954_ti9x3_priv {
-+ struct v4l2_subdev sd[4];
-+ struct device_node *sd_of_node[4];
-+ int des_addr;
-+ int links;
-+ int lanes;
-+ int csi_rate;
-+ const char *forwarding_mode;
-+ const char *cable_mode;
-+ atomic_t use_count;
-+ struct i2c_client *client;
-+ int ti9x3_addr_map[4];
-+ char chip_id[6];
-+ struct regulator *poc_supply[4]; /* PoC power supply */
-+ int xtal_gpio;
++#define OX03A_I2C_ADDR 0x36
++
++#define OX03A_PID 0x300A
++#define OX03A_VER 0x300B
++#define OX03A_VERSION_REG 0x5803
++
++#define OX03A_MEDIA_BUS_FMT MEDIA_BUS_FMT_SBGGR12_1X12
++
++struct ox03a_priv {
++ struct v4l2_subdev sd;
++ struct v4l2_ctrl_handler hdl;
++ struct media_pad pad;
++ struct v4l2_rect rect;
++ int init_complete;
++ u8 id[6];
++ int exposure;
++ int gain;
++ int autogain;
++ /* serializers */
++ int ti9x4_addr;
++ int ti9x3_addr;
++ int port;
++ int gpio_resetb;
++ int gpio_fsin;
+};
+
-+static int indirect_write(struct i2c_client *client, unsigned int page, u8 reg, u8 val)
++static inline struct ox03a_priv *to_ox03a(const struct i2c_client *client)
+{
-+ if (page > 7)
-+ return -EINVAL;
++ return container_of(i2c_get_clientdata(client), struct ox03a_priv, sd);
++}
+
-+ reg8_write(client, 0xb0, page << 2);
-+ reg8_write(client, 0xb1, reg);
-+ reg8_write(client, 0xb2, val);
++static int ox03a_set_regs(struct i2c_client *client,
++ const struct ox03a_reg *regs, int nr_regs)
++{
++ int i;
++
++ for (i = 0; i < nr_regs; i++) {
++ if (regs[i].reg == OX03A_DELAY) {
++ mdelay(regs[i].val);
++ continue;
++ }
++
++ reg16_write(client, regs[i].reg, regs[i].val);
++ }
+
+ return 0;
+}
+
-+#if 0
-+static int indirect_read(struct i2c_client *client, unsigned int page, u8 reg, u8 *val)
++static int ox03a_s_stream(struct v4l2_subdev *sd, int enable)
+{
-+ if (page > 7)
++ return 0;
++}
++
++static int ox03a_get_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
++{
++ struct v4l2_mbus_framefmt *mf = &format->format;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
++
++ if (format->pad)
+ return -EINVAL;
+
-+ reg8_write(client, 0xb0, page << 2);
-+ reg8_write(client, 0xb1, reg);
-+ reg8_read(client, 0xb2, val);
++ mf->width = priv->rect.width;
++ mf->height = priv->rect.height;
++ mf->code = OX03A_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
+
+ return 0;
+}
-+#endif
+
-+static void ti954_ti9x3_read_chipid(struct i2c_client *client)
++static int ox03a_set_fmt(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_format *format)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct v4l2_mbus_framefmt *mf = &format->format;
+
-+ /* Chip ID */
-+ reg8_read(client, 0xf1, &priv->chip_id[0]);
-+ reg8_read(client, 0xf2, &priv->chip_id[1]);
-+ reg8_read(client, 0xf3, &priv->chip_id[2]);
-+ reg8_read(client, 0xf4, &priv->chip_id[3]);
-+ reg8_read(client, 0xf5, &priv->chip_id[4]);
-+ priv->chip_id[5] = '\0';
++ mf->code = OX03A_MEDIA_BUS_FMT;
++ mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
++ mf->field = V4L2_FIELD_NONE;
++
++ if (format->which == V4L2_SUBDEV_FORMAT_TRY)
++ cfg->try_fmt = *mf;
++
++ return 0;
+}
+
-+static void ti954_ti9x3_initial_setup(struct i2c_client *client)
++static int ox03a_enum_mbus_code(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_mbus_code_enum *code)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
++ if (code->pad || code->index > 0)
++ return -EINVAL;
+
-+ /* Initial setup */
-+ client->addr = priv->des_addr; /* TI954 I2C */
-+ reg8_write(client, 0x08, 0x1c); /* I2C glitch filter depth */
-+ reg8_write(client, 0x0a, 0x79); /* I2C high pulse width */
-+ reg8_write(client, 0x0b, 0x79); /* I2C low pulse width */
-+ reg8_write(client, 0x0d, 0xb9); /* VDDIO 3.3V */
-+ switch (priv->csi_rate) {
-+ case 1600: /* REFCLK = 25MHZ */
-+ case 1450: /* REFCLK = 22.5MHZ */
-+ reg8_write(client, 0x1f, 0x00); /* CSI rate 1.5/1.6Gbps */
-+ break;
-+ case 800: /* REFCLK = 25MHZ */
-+ reg8_write(client, 0x1f, 0x02); /* CSI rate 800Mbps */
-+ break;
-+ case 400: /* REFCLK = 25MHZ */
-+ reg8_write(client, 0x1f, 0x03); /* CSI rate 400Mbps */
-+ break;
-+ default:
-+ dev_err(&client->dev, "unsupported CSI rate %d\n", priv->csi_rate);
-+ }
++ code->code = OX03A_MEDIA_BUS_FMT;
+
-+ if (strcmp(priv->forwarding_mode, "round-robin") == 0) {
-+ reg8_write(client, 0x21, 0x01); /* Round Robin forwarding enable */
-+ } else if (strcmp(priv->forwarding_mode, "synchronized") == 0) {
-+ reg8_write(client, 0x21, 0x44); /* Basic Syncronized forwarding enable (FrameSync must be enabled!!) */
-+ }
-+
-+ reg8_write(client, 0x32, 0x01); /* Select TX (CSI) port 0 */
-+ reg8_write(client, 0x33, ((priv->lanes - 1) ^ 0x3) << 4); /* disable CSI output, set CSI lane count, non-continuous CSI mode */
-+ reg8_write(client, 0x20, 0xf0); /* disable port forwarding */
-+#if 0
-+ /* FrameSync setup for REFCLK=25MHz, FPS=30: period_counts=1/2/FPS*25MHz =1/2/30*25Mhz =416666 -> FS_TIME=416666 */
-+ /* FrameSync setup for REFCLK=22.5MHz, FPS=30: period_counts=1/2/FPS*22.5Mhz=1/2/30*22.5Mhz=375000 -> FS_TIME=375000 */
-+// #define FS_TIME (priv->csi_rate == 1450 ? 376000 : 417666)
-+ #define FS_TIME (priv->csi_rate == 1450 ? 385000 : 428000) // FPS=29.2 (new vendor's firmware AWB restriction?)
-+ reg8_write(client, 0x1a, FS_TIME >> 16); /* FrameSync time 24bit */
-+ reg8_write(client, 0x1b, (FS_TIME >> 8) & 0xff);
-+ reg8_write(client, 0x1c, FS_TIME & 0xff);
-+ reg8_write(client, 0x18, 0x43); /* Enable FrameSync, 50/50 mode, Frame clock from 25MHz */
-+#else
-+ /* FrameSync setup for REFCLK=25MHz, FPS=30: period_counts=1/FPS/12mks=1/30/12e-6=2777 -> HI=2, LO=2775 */
-+ /* FrameSync setup for REFCLK=22.5MHz, FPS=30: period_counts=1/FPS/13.333mks=1/30/13.333e-6=2500 -> HI=2, LO=2498 */
-+ #define FS_TIME (priv->csi_rate == 1450 ? (2498+15) : (2775+15))
-+ reg8_write(client, 0x19, 2 >> 8); /* FrameSync high time MSB */
-+ reg8_write(client, 0x1a, 2 & 0xff); /* FrameSync high time LSB */
-+ reg8_write(client, 0x1b, FS_TIME >> 8); /* FrameSync low time MSB */
-+ reg8_write(client, 0x1c, FS_TIME & 0xff); /* FrameSync low time LSB */
-+ reg8_write(client, 0x18, 0x01); /* Enable FrameSync, HI/LO mode, Frame clock from port0 */
-+#endif
++ return 0;
+}
+
-+//#define SENSOR_ID 0x30 // ov10635
-+//#define SENSOR_ID 0x24 // ov490
-+
-+static void ti954_ti9x3_fpdlink3_setup(struct i2c_client *client, int idx)
++static int ox03a_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
+
-+ /* FPDLinkIII setup */
-+ client->addr = priv->des_addr; /* TI954 I2C */
-+ reg8_write(client, 0x4c, (idx << 4) | (1 << idx)); /* Select RX port number */
-+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x58, 0x58); /* Back channel: pass-through/backchannel/CRC enable, Freq=2.5Mbps */
-+ reg8_write(client, 0x5c, priv->ti9x3_addr_map[idx] << 1); /* TI9X3 I2C addr */
-+// reg8_write(client, 0x5d, SENSOR_ID << 1); /* SENSOR I2C native - must be set by sensor driver */
-+// reg8_write(client, 0x65, (0x60 + idx) << 1); /* SENSOR I2C translated - must be set by sensor driver */
-+ if (strcmp(priv->cable_mode, "coax") == 0) {
-+ reg8_write(client, 0x6d, 0x7f); /* Coax, RAW10 */
-+ } else if (strcmp(priv->cable_mode, "stp") == 0) {
-+ reg8_write(client, 0x6d, 0x78); /* STP, CSI */
-+ }
-+ reg8_write(client, 0x70, (idx << 6) | 0x1e); /* CSI data type: yuv422 8-bit, assign VC */
-+ reg8_write(client, 0x7c, 0x81); /* BIT(7) - magic to Use RAW10 as 8-bit mode */
-+ reg8_write(client, 0x6e, 0x88); /* Sensor reset: backchannel GPIO0/GPIO1 set low */
++ memcpy(edid->edid, priv->id, 6);
++
++ edid->edid[6] = 0xff;
++ edid->edid[7] = client->addr;
++ edid->edid[8] = OX03A_VERSION_REG >> 8;
++ edid->edid[9] = OX03A_VERSION_REG & 0xff;
++
++ return 0;
+}
+
-+static int ti954_ti9x3_initialize(struct i2c_client *client)
++static int ox03a_set_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
-+ int idx;
++ struct v4l2_rect *rect = &sel->r;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
+
-+ dev_info(&client->dev, "LINKs=%d, LANES=%d, FORWARDING=%s, CABLE=%s, ID=%s\n",
-+ priv->links, priv->lanes, priv->forwarding_mode, priv->cable_mode, priv->chip_id);
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
++ sel->target != V4L2_SEL_TGT_CROP)
++ return -EINVAL;
+
-+ ti954_ti9x3_initial_setup(client);
++ rect->left = ALIGN(rect->left, 2);
++ rect->top = ALIGN(rect->top, 2);
++ rect->width = ALIGN(rect->width, 2);
++ rect->height = ALIGN(rect->height, 2);
+
-+ for (idx = 0; idx < priv->links; idx++) {
-+ if (!IS_ERR(priv->poc_supply[idx])) {
-+ if (regulator_enable(priv->poc_supply[idx]))
-+ dev_err(&client->dev, "fail to enable POC%d regulator\n", idx);
-+ }
++ if ((rect->left + rect->width > OX03A_MAX_WIDTH) ||
++ (rect->top + rect->height > OX03A_MAX_HEIGHT))
++ *rect = priv->rect;
++
++ priv->rect.left = rect->left;
++ priv->rect.top = rect->top;
++ priv->rect.width = rect->width;
++ priv->rect.height = rect->height;
+
-+ ti954_ti9x3_fpdlink3_setup(client, idx);
++ return 0;
++}
++
++static int ox03a_get_selection(struct v4l2_subdev *sd,
++ struct v4l2_subdev_pad_config *cfg,
++ struct v4l2_subdev_selection *sel)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
++
++ if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
++ return -EINVAL;
++
++ switch (sel->target) {
++ case V4L2_SEL_TGT_CROP_BOUNDS:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = OX03A_MAX_WIDTH;
++ sel->r.height = OX03A_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP_DEFAULT:
++ sel->r.left = 0;
++ sel->r.top = 0;
++ sel->r.width = OX03A_MAX_WIDTH;
++ sel->r.height = OX03A_MAX_HEIGHT;
++ return 0;
++ case V4L2_SEL_TGT_CROP:
++ sel->r = priv->rect;
++ return 0;
++ default:
++ return -EINVAL;
+ }
++}
+
-+ client->addr = priv->des_addr;
++static int ox03a_g_mbus_config(struct v4l2_subdev *sd,
++ struct v4l2_mbus_config *cfg)
++{
++ cfg->flags = V4L2_MBUS_CSI2_1_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
++ V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
++ cfg->type = V4L2_MBUS_CSI2;
+
+ return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
-+static int ti954_ti9x3_g_register(struct v4l2_subdev *sd,
-+ struct v4l2_dbg_register *reg)
++static int ox03a_g_register(struct v4l2_subdev *sd,
++ struct v4l2_dbg_register *reg)
+{
-+ struct ti954_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
-+ struct i2c_client *client = priv->client;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
+ int ret;
+ u8 val = 0;
+
-+ ret = reg8_read(client, (u8)reg->reg, &val);
++ ret = reg16_read(client, (u16)reg->reg, &val);
+ if (ret < 0)
+ return ret;
+
@@ -6707,108 +14128,127 @@ index 0000000..1672173
+ return 0;
+}
+
-+static int ti954_ti9x3_s_register(struct v4l2_subdev *sd,
-+ const struct v4l2_dbg_register *reg)
++static int ox03a_s_register(struct v4l2_subdev *sd,
++ const struct v4l2_dbg_register *reg)
+{
-+ struct ti954_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
-+ struct i2c_client *client = priv->client;
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
+
-+ return reg8_write(client, (u8)reg->reg, (u8)reg->val);
++ return reg16_write(client, (u16)reg->reg, (u8)reg->val);
+}
+#endif
+
-+static int ti954_ti9x3_s_power(struct v4l2_subdev *sd, int on)
++static struct v4l2_subdev_core_ops ox03a_core_ops = {
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ .g_register = ox03a_g_register,
++ .s_register = ox03a_s_register,
++#endif
++};
++
++static int ox03a_s_ctrl(struct v4l2_ctrl *ctrl)
+{
-+ struct ti954_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
-+ struct i2c_client *client = priv->client;
++ struct v4l2_subdev *sd = to_sd(ctrl);
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
++ int ret = -EINVAL;
+
-+ if (on) {
-+ if (atomic_inc_return(&priv->use_count) == 1)
-+ reg8_write(client, 0x20, 0x00); /* enable port forwarding to CSI */
-+ } else {
-+ if (atomic_dec_return(&priv->use_count) == 0)
-+ reg8_write(client, 0x20, 0xf0); /* disable port forwarding to CSI */
++ if (!priv->init_complete)
++ return 0;
++
++ switch (ctrl->id) {
++ case V4L2_CID_BRIGHTNESS:
++ case V4L2_CID_CONTRAST:
++ case V4L2_CID_SATURATION:
++ case V4L2_CID_HUE:
++ case V4L2_CID_GAMMA:
++ case V4L2_CID_SHARPNESS:
++ case V4L2_CID_AUTOGAIN:
++ case V4L2_CID_GAIN:
++ case V4L2_CID_EXPOSURE:
++ case V4L2_CID_HFLIP:
++ case V4L2_CID_VFLIP:
++ break;
+ }
+
-+ return 0;
++ return ret;
+}
+
-+static int ti954_ti9x3_registered_async(struct v4l2_subdev *sd)
-+{
-+ struct ti954_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
-+ struct i2c_client *client = priv->client;
-+
-+ reg8_write(client, 0x33, ((priv->lanes - 1) ^ 0x3) << 4 | 0x1); /* enable CSI output, set CSI lane count, non-continuous CSI mode */
++static const struct v4l2_ctrl_ops ox03a_ctrl_ops = {
++ .s_ctrl = ox03a_s_ctrl,
++};
+
-+ return 0;
-+}
++static struct v4l2_subdev_video_ops ox03a_video_ops = {
++ .s_stream = ox03a_s_stream,
++ .g_mbus_config = ox03a_g_mbus_config,
++};
+
-+static struct v4l2_subdev_core_ops ti954_ti9x3_subdev_core_ops = {
-+#ifdef CONFIG_VIDEO_ADV_DEBUG
-+ .g_register = ti954_ti9x3_g_register,
-+ .s_register = ti954_ti9x3_s_register,
-+#endif
-+ .s_power = ti954_ti9x3_s_power,
-+ .registered_async = ti954_ti9x3_registered_async,
++static const struct v4l2_subdev_pad_ops ox03a_subdev_pad_ops = {
++ .get_edid = ox03a_get_edid,
++ .enum_mbus_code = ox03a_enum_mbus_code,
++ .get_selection = ox03a_get_selection,
++ .set_selection = ox03a_set_selection,
++ .get_fmt = ox03a_get_fmt,
++ .set_fmt = ox03a_set_fmt,
+};
+
-+static struct v4l2_subdev_ops ti954_ti9x3_subdev_ops = {
-+ .core = &ti954_ti9x3_subdev_core_ops,
++static struct v4l2_subdev_ops ox03a_subdev_ops = {
++ .core = &ox03a_core_ops,
++ .video = &ox03a_video_ops,
++ .pad = &ox03a_subdev_pad_ops,
+};
+
-+static int ti954_ti9x3_parse_dt(struct i2c_client *client)
++static void ox03a_otp_id_read(struct i2c_client *client)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
-+ struct device_node *np = client->dev.of_node;
-+ struct device_node *endpoint = NULL, *rendpoint = NULL;
-+ struct property *prop;
-+ int err, i;
-+ int sensor_delay;
-+ char forwarding_mode_default[20] = "round-robin"; /* round-robin, synchronized */
-+ char cable_mode_default[5] = "coax"; /* coax, stp */
-+ struct property *csi_rate_prop, *dvp_order_prop;
-+ u8 val = 0;
++}
+
-+ if (of_property_read_u32(np, "ti,links", &priv->links))
-+ priv->links = 2;
++static ssize_t ox03a_otp_id_show(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ struct v4l2_subdev *sd = i2c_get_clientdata(to_i2c_client(dev));
++ struct i2c_client *client = v4l2_get_subdevdata(sd);
++ struct ox03a_priv *priv = to_ox03a(client);
+
-+ if (of_property_read_u32(np, "ti,lanes", &priv->lanes))
-+ priv->lanes = 4;
++ return snprintf(buf, 32, "%02x:%02x:%02x:%02x:%02x:%02x\n",
++ priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++}
+
-+ priv->xtal_gpio = of_get_gpio(np, 0);
-+ if (priv->xtal_gpio > 0) {
-+ err = devm_gpio_request_one(&client->dev, priv->xtal_gpio, GPIOF_OUT_INIT_LOW, dev_name(&client->dev));
-+ if (err)
-+ dev_err(&client->dev, "cannot request XTAL gpio %d: %d\n", priv->xtal_gpio, err);
-+ else
-+ mdelay(250);
-+ }
++static DEVICE_ATTR(otp_id_ox03a, S_IRUGO, ox03a_otp_id_show, NULL);
+
-+ reg8_read(client, 0x00, &val); /* read TI954 I2C address */
-+ if (val != (priv->des_addr << 1)) {
-+ prop = of_find_property(np, "reg", NULL);
-+ if (prop)
-+ of_remove_property(np, prop);
-+ return -ENODEV;
-+ }
++static int ox03a_initialize(struct i2c_client *client)
++{
++ struct ox03a_priv *priv = to_ox03a(client);
++ u8 val = 0;
++ u16 pid;
++ int ret = 0;
+
-+ ti954_ti9x3_read_chipid(client);
++ /* check and show model ID */
++ reg16_read(client, OX03A_PID, &val);
++ pid = val;
++ reg16_read(client, OX03A_VER, &val);
++ pid = (pid << 8) | val;
+
-+ indirect_write(client, 7, 0x15, 0x30);
-+ gpio_set_value(priv->xtal_gpio, 1);
-+ usleep_range(5000, 5500); /* wait 5ms */
-+ indirect_write(client, 7, 0x15, 0);
++ if (pid != OX03A_VERSION_REG) {
++ dev_dbg(&client->dev, "Product ID error %x\n", pid);
++ ret = -ENODEV;
++ goto err;
++ }
+
-+ if (!of_property_read_u32(np, "ti,sensor_delay", &sensor_delay))
-+ mdelay(sensor_delay);
++ /* Program wizard registers */
++ ox03a_set_regs(client, ox03a_regs_wizard, ARRAY_SIZE(ox03a_regs_wizard));
++ /* Read OTP IDs */
++ ox03a_otp_id_read(client);
+
-+ err = of_property_read_string(np, "ti,forwarding-mode", &priv->forwarding_mode);
-+ if (err)
-+ priv->forwarding_mode = forwarding_mode_default;
++ dev_info(&client->dev, "ox03a PID %x, res %dx%d, OTP_ID %02x:%02x:%02x:%02x:%02x:%02x\n",
++ pid, OX03A_MAX_WIDTH, OX03A_MAX_HEIGHT, priv->id[0], priv->id[1], priv->id[2], priv->id[3], priv->id[4], priv->id[5]);
++err:
++ return ret;
++}
+
-+ err = of_property_read_string(np, "ti,cable-mode", &priv->cable_mode);
-+ if (err)
-+ priv->cable_mode = cable_mode_default;
++static int ox03a_parse_dt(struct device_node *np, struct ox03a_priv *priv)
++{
++ struct i2c_client *client = v4l2_get_subdevdata(&priv->sd);
++ int i;
++ struct device_node *endpoint = NULL, *rendpoint = NULL;
++ int tmp_addr = 0;
+
+ for (i = 0; ; i++) {
+ endpoint = of_graph_get_next_endpoint(np, endpoint);
@@ -6817,132 +14257,1915 @@ index 0000000..1672173
+
+ of_node_put(endpoint);
+
-+ if (i < priv->links) {
-+ if (of_property_read_u32(endpoint, "ti9x3-addr", &priv->ti9x3_addr_map[i])) {
-+ dev_err(&client->dev, "ti9x3-addr not set\n");
-+ return -EINVAL;
-+ }
-+ priv->sd_of_node[i] = endpoint;
-+ }
-+
+ rendpoint = of_parse_phandle(endpoint, "remote-endpoint", 0);
+ if (!rendpoint)
+ continue;
+
-+ csi_rate_prop = of_find_property(endpoint, "csi-rate", NULL);
-+ if (csi_rate_prop) {
-+ of_property_read_u32(endpoint, "csi-rate", &priv->csi_rate);
-+ of_update_property(rendpoint, csi_rate_prop);
-+ }
++ if (!of_property_read_u32(rendpoint, "ti9x3-addr", &priv->ti9x3_addr) &&
++ !of_property_match_string(rendpoint->parent->parent, "compatible", "ti,ti9x4") &&
++ !of_property_read_u32(rendpoint->parent->parent, "reg", &priv->ti9x4_addr) &&
++ !kstrtouint(strrchr(rendpoint->full_name, '@') + 1, 0, &priv->port))
++ break;
++ }
+
-+ dvp_order_prop = of_find_property(endpoint, "dvp-order", NULL);
-+ if (dvp_order_prop)
-+ of_update_property(rendpoint, dvp_order_prop);
++ if (!priv->ti9x4_addr) {
++ dev_err(&client->dev, "deserializer does not present\n");
++ return -EINVAL;
+ }
+
++ /* setup I2C translator address */
++ tmp_addr = client->addr;
++ if (priv->ti9x4_addr) {
++ client->addr = priv->ti9x4_addr; /* Deserializer I2C address */
++ reg8_write(client, 0x4c, (priv->port << 4) | (1 << priv->port)); /* Select RX port number */
++ usleep_range(2000, 2500); /* wait 2ms */
++ reg8_write(client, 0x65, tmp_addr << 1); /* Sensor translated I2C address */
++ reg8_write(client, 0x5d, OX03A_I2C_ADDR << 1); /* Sensor native I2C address */
++// reg8_write(client, 0x6e, 0xa9); /* GPIO0 - reset, GPIO1 - fsin */
++
++// client->addr = priv->ti9x3_addr; /* Serializer I2C address */
++// reg8_write(client, 0x0d, 0x03); /* unreset gpios */
++// reg8_write(client, 0x0e, 0xf0); /* unreset gpios */
++ }
++ client->addr = tmp_addr;
++
++ mdelay(10);
++
+ return 0;
+}
+
-+static int ti954_ti9x3_probe(struct i2c_client *client,
-+ const struct i2c_device_id *did)
++static int ox03a_probe(struct i2c_client *client,
++ const struct i2c_device_id *did)
+{
-+ struct ti954_ti9x3_priv *priv;
-+ int err, i;
-+ char supply_name[10];
++ struct ox03a_priv *priv;
++ int ret;
+
+ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
-+ i2c_set_clientdata(client, priv);
-+ priv->des_addr = client->addr;
-+ priv->client = client;
-+ atomic_set(&priv->use_count, 0);
++ v4l2_i2c_subdev_init(&priv->sd, client, &ox03a_subdev_ops);
++ priv->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
+
-+ err = ti954_ti9x3_parse_dt(client);
-+ if (err)
-+ goto out;
++ priv->exposure = 0x100;
++ priv->gain = 0x100;
++ priv->autogain = 1;
++ v4l2_ctrl_handler_init(&priv->hdl, 4);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_BRIGHTNESS, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_CONTRAST, 0, 16, 1, 7);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_SATURATION, 0, 7, 1, 2);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_HUE, 0, 23, 1, 12);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_GAMMA, -128, 128, 1, 0);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_SHARPNESS, 0, 10, 1, 3);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_AUTOGAIN, 0, 1, 1, priv->autogain);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_GAIN, 0, 0xffff, 1, priv->gain);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_EXPOSURE, 0, 0xffff, 1, priv->exposure);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_HFLIP, 0, 1, 1, 1);
++ v4l2_ctrl_new_std(&priv->hdl, &ox03a_ctrl_ops,
++ V4L2_CID_VFLIP, 0, 1, 1, 0);
++ priv->sd.ctrl_handler = &priv->hdl;
+
-+ for (i = 0; i < 4; i++) {
-+ sprintf(supply_name, "POC%d", i);
-+ priv->poc_supply[i] = devm_regulator_get_optional(&client->dev, supply_name);
-+ }
++ ret = priv->hdl.error;
++ if (ret)
++ goto cleanup;
+
-+ err = ti954_ti9x3_initialize(client);
-+ if (err < 0)
-+ goto out;
++ v4l2_ctrl_handler_setup(&priv->hdl);
+
-+ for (i = 0; i < priv->links; i++) {
-+ v4l2_subdev_init(&priv->sd[i], &ti954_ti9x3_subdev_ops);
-+ priv->sd[i].owner = client->dev.driver->owner;
-+ priv->sd[i].dev = &client->dev;
-+ priv->sd[i].grp_id = i;
-+ v4l2_set_subdevdata(&priv->sd[i], priv);
-+ priv->sd[i].of_node = priv->sd_of_node[i];
++ priv->pad.flags = MEDIA_PAD_FL_SOURCE;
++ priv->sd.entity.flags |= MEDIA_ENT_F_CAM_SENSOR;
++ ret = media_entity_pads_init(&priv->sd.entity, 1, &priv->pad);
++ if (ret < 0)
++ goto cleanup;
+
-+ snprintf(priv->sd[i].name, V4L2_SUBDEV_NAME_SIZE, "%s %d-%04x",
-+ client->dev.driver->name, i2c_adapter_id(client->adapter),
-+ client->addr);
++ ret = ox03a_parse_dt(client->dev.of_node, priv);
++ if (ret)
++ goto cleanup;
+
-+ err = v4l2_async_register_subdev(&priv->sd[i]);
-+ if (err < 0)
-+ goto out;
++ ret = ox03a_initialize(client);
++ if (ret < 0)
++ goto cleanup;
++
++ priv->rect.left = 0;
++ priv->rect.top = 0;
++ priv->rect.width = OX03A_MAX_WIDTH;
++ priv->rect.height = OX03A_MAX_HEIGHT;
++
++ ret = v4l2_async_register_subdev(&priv->sd);
++ if (ret)
++ goto cleanup;
++
++ if (device_create_file(&client->dev, &dev_attr_otp_id_ox03a) != 0) {
++ dev_err(&client->dev, "sysfs otp_id entry creation failed\n");
++ goto cleanup;
+ }
+
-+out:
-+ return err;
++ priv->init_complete = 1;
++
++ return 0;
++
++cleanup:
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
++#ifdef CONFIG_SOC_CAMERA_OX03A
++ v4l_err(client, "failed to probe @ 0x%02x (%s)\n",
++ client->addr, client->adapter->name);
++#endif
++ return ret;
+}
+
-+static int ti954_ti9x3_remove(struct i2c_client *client)
++static int ox03a_remove(struct i2c_client *client)
+{
-+ struct ti954_ti9x3_priv *priv = i2c_get_clientdata(client);
-+ int i;
++ struct ox03a_priv *priv = i2c_get_clientdata(client);
+
-+ for (i = 0; i < priv->links; i++) {
-+ v4l2_async_unregister_subdev(&priv->sd[i]);
-+ v4l2_device_unregister_subdev(&priv->sd[i]);
-+ }
++ device_remove_file(&client->dev, &dev_attr_otp_id_ox03a);
++ v4l2_async_unregister_subdev(&priv->sd);
++ media_entity_cleanup(&priv->sd.entity);
++ v4l2_ctrl_handler_free(&priv->hdl);
++ v4l2_device_unregister_subdev(&priv->sd);
+
+ return 0;
+}
+
-+static const struct of_device_id ti954_ti9x3_dt_ids[] = {
-+ { .compatible = "ti,ti954-ti9x3" },
-+ {},
++#ifdef CONFIG_SOC_CAMERA_OX03A
++static const struct i2c_device_id ox03a_id[] = {
++ { "ox03a", 0 },
++ { }
+};
-+MODULE_DEVICE_TABLE(of, ti954_ti9x3_dt_ids);
++MODULE_DEVICE_TABLE(i2c, ox03a_id);
+
-+static const struct i2c_device_id ti954_ti9x3_id[] = {
-+ { "ti954_ti9x3", 0 },
++static const struct of_device_id ox03a_of_ids[] = {
++ { .compatible = "ovti,ox03a", },
+ { }
+};
-+MODULE_DEVICE_TABLE(i2c, ti954_ti9x3_id);
++MODULE_DEVICE_TABLE(of, ox03a_of_ids);
+
-+static struct i2c_driver ti954_ti9x3_i2c_driver = {
++static struct i2c_driver ox03a_i2c_driver = {
+ .driver = {
-+ .name = "ti954_ti9x3",
-+ .of_match_table = of_match_ptr(ti954_ti9x3_dt_ids),
++ .name = "ox03a",
++ .of_match_table = ox03a_of_ids,
+ },
-+ .probe = ti954_ti9x3_probe,
-+ .remove = ti954_ti9x3_remove,
-+ .id_table = ti954_ti9x3_id,
++ .probe = ox03a_probe,
++ .remove = ox03a_remove,
++ .id_table = ox03a_id,
+};
+
-+module_i2c_driver(ti954_ti9x3_i2c_driver);
++module_i2c_driver(ox03a_i2c_driver);
+
-+MODULE_DESCRIPTION("FPDLinkIII driver for TI954-TI9X3");
++MODULE_DESCRIPTION("SoC Camera driver for OX03A");
+MODULE_AUTHOR("Vladimir Barinov");
+MODULE_LICENSE("GPL");
-diff --git a/drivers/media/i2c/soc_camera/ti964_ti9x3.c b/drivers/media/i2c/soc_camera/ti964_ti9x3.c
++#endif
+diff --git a/drivers/media/i2c/soc_camera/ox03a.h b/drivers/media/i2c/soc_camera/ox03a.h
new file mode 100644
-index 0000000..bffd7c2
+index 0000000..b69273a
--- /dev/null
-+++ b/drivers/media/i2c/soc_camera/ti964_ti9x3.c
-@@ -0,0 +1,400 @@
++++ b/drivers/media/i2c/soc_camera/ox03a.h
+@@ -0,0 +1,1724 @@
+/*
-+ * TI (ti964/ti960)-(ti913/ti953) FPDLinkIII driver
++ * OmniVision OX03A sensor camera wizard 1920x1080@30/BGGR/MIPI
+ *
-+ * Copyright (C) 2017 Cogent Embedded, Inc.
++ * Copyright (C) 2018 Cogent Embedded, Inc.
++ *
++ * 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.
++ */
++
++#define OX03A_DISPLAY_PATTERN_COLOR_BAR
++
++#define OX03A_MAX_WIDTH 1920
++#define OX03A_MAX_HEIGHT 1080
++
++#define OX03A_DELAY 0xffff
++#define OX03A_DT 0x2c /* MIPI Data Type RAW12 */
++
++struct ox03a_reg {
++ u16 reg;
++ u8 val;
++};
++
++/* wizard: MIPI 1920x1280 3x12 30fps 750MBPS */
++static const struct ox03a_reg ox03a_regs_wizard[] = {
++{0x0103, 0x01}, // s/w reset
++{OX03A_DELAY, 10}, // Wait 10ms
++{0x0100, 0x00},
++{0x0102, 0x00},
++{0x0103, 0x00},
++{0x0104, 0x04},
++{0x0105, 0x00},
++{0x0106, 0x00},
++{0x0107, 0x00},
++{0x0109, 0x00},
++{0x0300, 0x00},
++{0x0301, 0x01},
++{0x0302, 0x00},
++{0x0303, 0x02},
++{0x0304, 0x00},
++{0x0305, 0x3c},
++{0x0306, 0x00},
++{0x0307, 0x00},
++{0x0308, 0x04},
++{0x0309, 0x02},
++{0x030a, 0x00},
++{0x030c, 0x00},
++{0x030d, 0x00},
++{0x0310, 0x00},
++{0x0311, 0x00},
++{0x0312, 0x00},
++{0x0313, 0x00},
++{0x0314, 0x00},
++{0x0315, 0x00},
++{0x0316, 0x00},
++{0x0317, 0x12},
++{0x0318, 0x01},
++{0x0320, 0x00},
++{0x0321, 0x01},
++{0x0322, 0x00},
++{0x0323, 0x02},
++{0x0324, 0x00},
++{0x0325, 0x6c},
++{0x0326, 0x00},
++{0x0327, 0x05},
++{0x0328, 0x05},
++{0x0329, 0x01},
++{0x032a, 0x02},
++{0x032b, 0x00},
++{0x032c, 0x00},
++{0x0400, 0xe7},
++{0x0401, 0xff},
++{0x0404, 0x2b},
++{0x0405, 0x32},
++{0x0406, 0x33},
++{0x0407, 0x8f},
++{0x0408, 0x0c},
++{0x040a, 0x00},
++{0x0410, 0xe7},
++{0x0411, 0xff},
++{0x0414, 0x2b},
++{0x0415, 0x32},
++{0x0416, 0x33},
++{0x0417, 0x8f},
++{0x0418, 0x0c},
++{0x041a, 0x00},
++{0x2803, 0x00},
++{0x3000, 0x00},
++{0x3001, 0x03},
++{0x3002, 0x03},
++{0x3003, 0x00},
++{0x3004, 0x04},
++{0x3005, 0x00},
++{0x3006, 0x00},
++{0x3007, 0x04},
++{0x3008, 0x00},
++{0x3009, 0x06},
++{0x300d, 0x11},
++{0x300e, 0x11},
++{0x300f, 0x11},
++{0x3012, 0x41},
++{0x3016, 0xf0},
++{0x3017, 0xf0},
++{0x3018, 0xf0},
++{0x3019, 0xf0},
++{0x301a, 0xf0},
++{0x301b, 0xb4},
++{0x301c, 0x01},
++{0x301d, 0x02},
++{0x301e, 0xb8},
++{0x301f, 0xe1},
++{0x3020, 0x01},
++{0x3021, 0x00},
++{0x3022, 0xf8},
++{0x3023, 0xf0},
++{0x3024, 0xf0},
++{0x3025, 0x02},
++{0x3026, 0x00},
++{0x3027, 0x00},
++{0x3028, 0xf0},
++{0x3029, 0x80},
++{0x3035, 0x6c},
++{0x3036, 0x42},
++{0x3037, 0x20},
++{0x3038, 0x00},
++{0x3700, 0x26},
++{0x3701, 0x1e},
++{0x3702, 0x25},
++{0x3703, 0x28},
++{0x3704, 0x0f},
++{0x3705, 0x00},
++{0x3706, 0x39},
++{0x3707, 0x0a},
++{0x3708, 0x36},
++{0x3709, 0x41},
++{0x370a, 0x00},
++{0x370b, 0xa3},
++{0x370c, 0x0f},
++{0x370d, 0x00},
++{0x370e, 0xa6},
++{0x370f, 0x95},
++{0x3710, 0x15},
++{0x3711, 0x72},
++{0x3712, 0x12},
++{0x3713, 0x00},
++{0x3714, 0x22},
++{0x3715, 0x00},
++{0x3716, 0x04},
++{0x3717, 0x02},
++{0x3718, 0x09},
++{0x3719, 0x1f},
++{0x371a, 0x0c},
++{0x371b, 0x16},
++{0x371c, 0x00},
++{0x371d, 0x08},
++{0x371e, 0x00},
++{0x371f, 0x02},
++{0x3720, 0x03},
++{0x3721, 0x1c},
++{0x3722, 0x87},
++{0x3723, 0x08},
++{0x3724, 0x0d},
++{0x3725, 0x08},
++{0x3726, 0x0d},
++{0x3727, 0x08},
++{0x3728, 0x04},
++{0x3729, 0x0c},
++{0x372a, 0x01},
++{0x372b, 0x01},
++{0x372c, 0x17},
++{0x372d, 0x01},
++{0x372e, 0x35},
++{0x372f, 0x43},
++{0x3730, 0x04},
++{0x3731, 0x06},
++{0x3732, 0x01},
++{0x3733, 0x41},
++{0x3734, 0x0a},
++{0x3735, 0x11},
++{0x3736, 0x11},
++{0x3737, 0x00},
++{0x3738, 0x54},
++{0x3739, 0x54},
++{0x373a, 0x54},
++{0x373b, 0x54},
++{0x373c, 0x11},
++{0x373d, 0x11},
++{0x373e, 0x00},
++{0x373f, 0x4c},
++{0x3740, 0x4c},
++{0x3741, 0x4c},
++{0x3742, 0x23},
++{0x3743, 0x01},
++{0x3744, 0x16},
++{0x3745, 0x08},
++{0x3746, 0x03},
++{0x3747, 0x01},
++{0x3748, 0x07},
++{0x3749, 0x01},
++{0x374a, 0x07},
++{0x374b, 0x03},
++{0x374c, 0xb1},
++{0x374d, 0x01},
++{0x374e, 0x01},
++{0x374f, 0x01},
++{0x3750, 0x07},
++{0x3751, 0x02},
++{0x3752, 0x03},
++{0x3753, 0xd0},
++{0x3754, 0x08},
++{0x3755, 0x00},
++{0x3758, 0xdd},
++{0x3759, 0x50},
++{0x375a, 0x49},
++{0x375b, 0x02},
++{0x375c, 0x2f},
++{0x375d, 0x00},
++{0x375e, 0x0f},
++{0x375f, 0x03},
++{0x3760, 0x13},
++{0x3761, 0x12},
++{0x3762, 0x1c},
++{0x3763, 0x03},
++{0x3764, 0x0d},
++{0x3765, 0x25},
++{0x3766, 0x08},
++{0x3767, 0x08},
++{0x3768, 0x21},
++{0x3769, 0x01},
++{0x376a, 0x01},
++{0x376b, 0x00},
++{0x376c, 0x15},
++{0x376d, 0x08},
++{0x376e, 0x08},
++{0x376f, 0x08},
++{0x3770, 0x91},
++{0x3771, 0x00},
++{0x3772, 0x00},
++{0x3773, 0x00},
++{0x3774, 0x02},
++{0x3775, 0x00},
++{0x3776, 0x00},
++{0x3777, 0x00},
++{0x3778, 0x00},
++{0x3779, 0x22},
++{0x377a, 0x00},
++{0x377b, 0x00},
++{0x377c, 0x48},
++{0x377d, 0x00},
++{0x377e, 0x00},
++{0x377f, 0x07},
++{0x3780, 0x00},
++{0x3781, 0x02},
++{0x3782, 0x04},
++{0x3783, 0x02},
++{0x3784, 0x08},
++{0x3785, 0x08},
++{0x3786, 0x00},
++{0x3787, 0x04},
++{0x3788, 0x02},
++{0x3789, 0x02},
++{0x378a, 0x04},
++{0x378b, 0x00},
++{0x378c, 0x00},
++{0x378d, 0x00},
++{0x378e, 0x00},
++{0x378f, 0x00},
++{0x3790, 0x10},
++{0x3791, 0x05},
++{0x3792, 0x31},
++{0x3793, 0x00},
++{0x3795, 0x00},
++{0x3796, 0x00},
++{0x3797, 0x00},
++{0x3798, 0x00},
++{0x3799, 0x00},
++{0x379a, 0x00},
++{0x379b, 0x10},
++{0x379c, 0x01},
++{0x379d, 0x00},
++{0x379e, 0x0d},
++{0x379f, 0x03},
++{0x37a0, 0x08},
++{0x37a1, 0x80},
++{0x37a2, 0x03},
++{0x37a3, 0x05},
++{0x37a4, 0x04},
++{0x37a5, 0x14},
++{0x37a6, 0x17},
++{0x37a7, 0x14},
++{0x37a8, 0x05},
++{0x37a9, 0x08},
++{0x37aa, 0x05},
++{0x37ab, 0x06},
++{0x37ac, 0x05},
++{0x37ad, 0x0d},
++{0x37ae, 0x0d},
++{0x37af, 0x01},
++{0x37b0, 0x0c},
++{0x37b1, 0x05},
++{0x37b2, 0x08},
++{0x37b3, 0x0a},
++{0x37b4, 0x08},
++{0x37b5, 0x08},
++{0x37b6, 0x08},
++{0x37b7, 0x08},
++{0x37b8, 0xff},
++{0x37b9, 0x01},
++{0x37ba, 0x08},
++{0x37bb, 0x08},
++{0x37bd, 0x01},
++{0x37be, 0x01},
++{0x37bf, 0x01},
++{0x37c0, 0x01},
++{0x37c1, 0x11},
++{0x37c2, 0x11},
++{0x37c3, 0x00},
++{0x37c4, 0x63},
++{0x37c5, 0x63},
++{0x37c6, 0x63},
++{0x37c7, 0x34},
++{0x37c8, 0x21},
++{0x37c9, 0x00},
++{0x37ca, 0x08},
++{0x37cb, 0x00},
++{0x37cc, 0x40},
++{0x37cd, 0x00},
++{0x37ce, 0x01},
++{0x37cf, 0x08},
++{0x37d0, 0x00},
++{0x37d1, 0x39},
++{0x37d2, 0x00},
++{0x37d3, 0xa3},
++{0x37d4, 0x00},
++{0x37d5, 0x39},
++{0x37d6, 0x00},
++{0x37d7, 0xa3},
++{0x37da, 0x00},
++{0x37db, 0x00},
++{0x37dc, 0x00},
++{0x37dd, 0x00},
++{0x37de, 0x00},
++{0x37df, 0x00},
++{0x37e0, 0x00},
++{0x37e1, 0x00},
++{0x37e2, 0x00},
++{0x37e3, 0x00},
++{0x37e4, 0x00},
++{0x37e5, 0x00},
++{0x37e6, 0x00},
++{0x37e7, 0x00},
++{0x37e8, 0x00},
++{0x37e9, 0x00},
++{0x37ea, 0x00},
++{0x37eb, 0x00},
++{0x37ec, 0x00},
++{0x37ed, 0x00},
++{0x37ee, 0x00},
++{0x37ef, 0x00},
++{0x37f0, 0x00},
++{0x37f1, 0x00},
++{0x37f2, 0x00},
++{0x37f3, 0x00},
++{0x37f4, 0x00},
++{0x37f5, 0x00},
++{0x37f6, 0x00},
++{0x37f7, 0x00},
++{0x37f8, 0x00},
++{0x37f9, 0x00},
++{0x37fa, 0x00},
++{0x37fb, 0x00},
++{0x37fc, 0x00},
++{0x37fd, 0x00},
++{0x37fe, 0x00},
++{0x37ff, 0x00},
++{0x3c00, 0x00},
++{0x3c01, 0x11},
++{0x3c02, 0x20},
++{0x3c03, 0x04},
++{0x3c04, 0x04},
++{0x3c05, 0x00},
++{0x3c06, 0x29},
++{0x3c07, 0x01},
++{0x3c08, 0x05},
++{0x3c09, 0x0c},
++{0x3c0a, 0x04},
++{0x3c0b, 0xa8},
++{0x3c0c, 0x11},
++{0x3c0d, 0x08},
++{0x3c0e, 0x03},
++{0x3c0f, 0x02},
++{0x3c10, 0x01},
++{0x3c11, 0x08},
++{0x3c12, 0x89},
++{0x3c13, 0x21},
++{0x3c14, 0x81},
++{0x3c15, 0x21},
++{0x3c16, 0x11},
++{0x3c17, 0x01},
++{0x3c18, 0x0c},
++{0x3c19, 0x00},
++{0x3c1a, 0x16},
++{0x3c1b, 0x81},
++{0x3c1c, 0x04},
++{0x3c1d, 0x16},
++{0x3c1e, 0x11},
++{0x3c1f, 0x3a},
++{0x3c20, 0x20},
++{0x3c21, 0x00},
++{0x3c22, 0x17},
++{0x3c23, 0x07},
++{0x3c24, 0x1a},
++{0x3c25, 0x1e},
++{0x3c26, 0x24},
++{0x3c27, 0x37},
++{0x3c28, 0x0a},
++{0x3c29, 0x14},
++{0x3c2a, 0xd1},
++{0x3c2b, 0x27},
++{0x3c2c, 0x33},
++{0x3c2d, 0x0c},
++{0x3c2e, 0x12},
++{0x3c2f, 0x08},
++{0x3c30, 0x16},
++{0x3c31, 0x24},
++{0x3c32, 0x35},
++{0x3c33, 0x29},
++{0x3c34, 0x31},
++{0x3c35, 0x21},
++{0x3c36, 0x11},
++{0x3c37, 0x12},
++{0x3c38, 0x11},
++{0x3c39, 0x11},
++{0x3c3a, 0x08},
++{0x3c3b, 0x38},
++{0x3c3c, 0x03},
++{0x3c3d, 0x23},
++{0x3c3e, 0x05},
++{0x3c3f, 0x0a},
++{0x3c40, 0xc1},
++{0x3c41, 0x04},
++{0x3c42, 0x01},
++{0x3c43, 0x18},
++{0x3c44, 0x21},
++{0x3c45, 0x20},
++{0x3c46, 0x0b},
++{0x3c47, 0x11},
++{0x3c48, 0x11},
++{0x3c4a, 0x02},
++{0x3c4b, 0x63},
++{0x3c4c, 0x02},
++{0x3c4d, 0x63},
++{0x3c4e, 0x00},
++{0x3c4f, 0x2a},
++{0x3c50, 0x2a},
++{0x3c51, 0x2a},
++{0x3c52, 0x2a},
++{0x3c53, 0x08},
++{0x3c54, 0x1d},
++{0x3c55, 0xeb},
++{0x3c56, 0x24},
++{0x3c57, 0x10},
++{0x3c58, 0x10},
++{0x3c59, 0x16},
++{0x3c5a, 0x55},
++{0x3c5b, 0x25},
++{0x3c5c, 0x8e},
++{0x3ce0, 0x00},
++{0x3ce1, 0x00},
++{0x3ce2, 0x00},
++{0x3ce3, 0x00},
++{0x3ce4, 0x00},
++{0x3ce5, 0x00},
++{0x3ce6, 0x00},
++{0x3ce7, 0x00},
++{0x3ce8, 0x00},
++{0x3ce9, 0x00},
++{0x3cea, 0x00},
++{0x3ceb, 0x00},
++{0x3cec, 0x00},
++{0x3ced, 0x00},
++{0x3cee, 0x00},
++{0x3cef, 0x00},
++{0x3cf0, 0x00},
++{0x3cf1, 0x00},
++{0x3cf2, 0x00},
++{0x3cf3, 0x00},
++{0x3cf4, 0x00},
++{0x3cf5, 0x00},
++{0x3cf6, 0x00},
++{0x3cf7, 0x00},
++{0x3cf8, 0x00},
++{0x3cf9, 0x00},
++{0x3cfa, 0x00},
++{0x3cfb, 0x00},
++{0x3cfc, 0x00},
++{0x3cfd, 0x00},
++{0x3cfe, 0x00},
++{0x3cff, 0x00},
++{0x3100, 0x00},
++{0x3101, 0x32},
++{0x3102, 0x00},
++{0x3103, 0x25},
++{0x3104, 0x01},
++{0x3105, 0x11},
++{0x3106, 0x10},
++{0x3107, 0x01},
++{0x3108, 0x01},
++{0x3109, 0x00},
++{0x3182, 0x10},
++{0x3183, 0xff},
++{0x3184, 0xff},
++{0x3187, 0xff},
++{0x3189, 0x00},
++{0x318a, 0x00},
++{0x318b, 0x00},
++{0x318c, 0x00},
++{0x318d, 0x00},
++{0x318e, 0x00},
++{0x318f, 0x00},
++{0x3190, 0x00},
++{0x3191, 0x00},
++{0x3192, 0x00},
++{0x3193, 0x00},
++{0x3194, 0x00},
++{0x3200, 0x00},
++{0x3201, 0x08},
++{0x3202, 0x10},
++{0x3203, 0x18},
++{0x3204, 0x20},
++{0x3205, 0x30},
++{0x3206, 0x00},
++{0x3209, 0x00},
++{0x320a, 0x00},
++{0x320b, 0x00},
++{0x320c, 0x00},
++{0x320d, 0x01},
++{0x3216, 0x01},
++{0x3217, 0x00},
++{0x3218, 0xf7},
++{0x3219, 0x55},
++{0x321b, 0x00},
++{0x3220, 0x1c},
++{0x3221, 0x00},
++{0x3304, 0x04},
++{0x3305, 0x00},
++{0x3306, 0x03},
++{0x3307, 0x00},
++{0x3308, 0x00},
++{0x3309, 0x00},
++{0x330a, 0x00},
++{0x330b, 0x00},
++{0x330c, 0x00},
++{0x330d, 0x00},
++{0x330e, 0x00},
++{0x330f, 0x00},
++{0x3310, 0x06},
++{0x3311, 0x05},
++{0x3312, 0x55},
++{0x3313, 0x0a},
++{0x3314, 0xaa},
++{0x3315, 0x0f},
++{0x3316, 0xf0},
++{0x3317, 0x00},
++{0x3400, 0x08},
++{0x3401, 0x00},
++{0x3402, 0x00},
++{0x3403, 0xb1},
++{0x3404, 0x00},
++{0x3405, 0x0f},
++{0x3406, 0x08},
++{0x3407, 0x08},
++{0x3408, 0x01},
++{0x3409, 0x02},
++{0x340a, 0x02},
++{0x340c, 0x10},
++{0x340d, 0x00},
++{0x3410, 0x00},
++{0x3412, 0x00},
++{0x3413, 0x00},
++{0x3414, 0x00},
++{0x3415, 0x00},
++{0x3416, 0x00},
++{0x3417, 0x00},
++{0x3420, 0x00},
++{0x3421, 0x00},
++{0x3422, 0x00},
++{0x3423, 0x00},
++{0x3424, 0x00},
++{0x3425, 0x00},
++{0x3426, 0x00},
++{0x3427, 0x00},
++{0x3428, 0x00},
++{0x3429, 0x00},
++{0x342a, 0x00},
++{0x342b, 0x00},
++{0x3501, 0x00},
++{0x3502, 0x24},
++{0x3503, 0xa8},
++{0x3504, 0x08},
++{0x3506, 0x00},
++{0x3507, 0x00},
++{0x3508, 0x01},
++{0x3509, 0x00},
++{0x350a, 0x01},
++{0x350b, 0x00},
++{0x350c, 0x00},
++{0x350d, 0x00},
++{0x3541, 0x00},
++{0x3542, 0x40},
++{0x3543, 0xa8},
++{0x3544, 0x08},
++{0x3546, 0x00},
++{0x3547, 0x00},
++{0x3548, 0x01},
++{0x3549, 0x00},
++{0x354a, 0x01},
++{0x354b, 0x00},
++{0x354c, 0x00},
++{0x354d, 0x00},
++{0x3581, 0x00},
++{0x3582, 0x24},
++{0x3583, 0xa8},
++{0x3584, 0x08},
++{0x3586, 0x00},
++{0x3587, 0x00},
++{0x3588, 0x01},
++{0x3589, 0x00},
++{0x358a, 0x01},
++{0x358b, 0x00},
++{0x358c, 0x00},
++{0x358d, 0x00},
++{0x3600, 0x00},
++{0x3601, 0x70},
++{0x3602, 0x42},
++{0x3603, 0xe3},
++{0x3604, 0x93},
++{0x3605, 0x40},
++{0x3606, 0x80},
++{0x3607, 0x4a},
++{0x3608, 0x98},
++{0x3609, 0x70},
++{0x360a, 0x90},
++{0x360b, 0x0a},
++{0x360c, 0x40},
++{0x360d, 0x88},
++{0x360e, 0x88},
++{0x360f, 0x88},
++{0x3610, 0x89},
++{0x3611, 0x4f},
++{0x3612, 0x4f},
++{0x3613, 0xba},
++{0x3614, 0x99},
++{0x3615, 0x99},
++{0x3616, 0x00},
++{0x3617, 0x00},
++{0x3618, 0x18},
++{0x3619, 0x00},
++{0x3620, 0x02},
++{0x3621, 0x80},
++{0x3622, 0x00},
++{0x3623, 0x00},
++{0x3624, 0x00},
++{0x3625, 0x00},
++{0x3626, 0x0e},
++{0x3627, 0x0f},
++{0x3628, 0x0a},
++{0x3629, 0x0a},
++{0x362a, 0x0e},
++{0x362b, 0x0e},
++{0x362c, 0x0e},
++{0x362d, 0x0e},
++{0x362e, 0x00},
++{0x362f, 0x00},
++{0x3630, 0x00},
++{0x3631, 0x00},
++{0x3632, 0x99},
++{0x3633, 0x99},
++{0x3634, 0x30},
++{0x3635, 0x30},
++{0x3636, 0x30},
++{0x3637, 0x30},
++{0x3638, 0x00},
++{0x3639, 0x00},
++{0x363a, 0x00},
++{0x363b, 0x0f},
++{0x363c, 0x0f},
++{0x363d, 0x0a},
++{0x363e, 0x0a},
++{0x363f, 0x0a},
++{0x3640, 0x0a},
++{0x3641, 0x0a},
++{0x3642, 0x0a},
++{0x3643, 0x10},
++{0x3644, 0x00},
++{0x3645, 0x10},
++{0x3646, 0x16},
++{0x3647, 0x10},
++{0x3648, 0x00},
++{0x3649, 0x13},
++{0x364a, 0x1d},
++{0x364b, 0x00},
++{0x364c, 0x0e},
++{0x364d, 0x0e},
++{0x364e, 0x0e},
++{0x364f, 0x0e},
++{0x3650, 0x00},
++{0x3651, 0x00},
++{0x3652, 0xc5},
++{0x3653, 0x00},
++{0x3654, 0x40},
++{0x3655, 0x00},
++{0x3656, 0xcf},
++{0x3657, 0x2b},
++{0x3658, 0x09},
++{0x3659, 0x00},
++{0x365a, 0x00},
++{0x365b, 0x00},
++{0x365c, 0x00},
++{0x365d, 0x00},
++{0x3660, 0x01},
++{0x3661, 0x07},
++{0x3662, 0x00},
++{0x3663, 0x20},
++{0x3664, 0x00},
++{0x3665, 0x12},
++{0x3666, 0x13},
++{0x3667, 0x14},
++{0x3668, 0x95},
++{0x3669, 0x16},
++{0x366a, 0x00},
++{0x366b, 0x00},
++{0x366c, 0x00},
++{0x366d, 0x00},
++{0x366e, 0x00},
++{0x366f, 0xc4},
++{0x3670, 0x6f},
++{0x3671, 0x0b},
++{0x3672, 0x1d},
++{0x3673, 0x6a},
++{0x3674, 0x6f},
++{0x3675, 0x1d},
++{0x3676, 0x6f},
++{0x3677, 0x1d},
++{0x3678, 0x80},
++{0x3679, 0x04},
++{0x367a, 0x00},
++{0x367b, 0x04},
++{0x367c, 0x00},
++{0x367d, 0x00},
++{0x367e, 0x00},
++{0x367f, 0x00},
++{0x3680, 0x00},
++{0x3800, 0x00},
++{0x3801, 0x00},
++{0x3802, 0x00},
++{0x3803, 0x04},
++{0x3804, 0x07},
++{0x3805, 0x8f},
++{0x3806, 0x05},
++{0x3807, 0x0b},
++{0x3808, 0x07},
++{0x3809, 0x80},
++{0x380a, 0x05},
++{0x380b, 0x00},
++{0x380c, 0x02},
++{0x380d, 0x14},
++{0x380e, 0x05},
++{0x380f, 0x40},
++{0x3810, 0x00},
++{0x3811, 0x08},
++{0x3812, 0x00},
++{0x3813, 0x04},
++{0x3814, 0x01},
++{0x3815, 0x01},
++{0x3816, 0x01},
++{0x3817, 0x01},
++{0x3818, 0x00},
++{0x3819, 0x00},
++{0x381a, 0x00},
++{0x381b, 0x01},
++{0x381c, 0x08},
++{0x381d, 0x00},
++{0x3820, 0x00},
++{0x3821, 0x20},
++{0x3822, 0x04},
++{0x3823, 0x08},
++{0x3824, 0x00},
++{0x3825, 0x20},
++{0x3826, 0x00},
++{0x3827, 0x08},
++{0x3828, 0x38},
++{0x382a, 0x00},
++{0x382b, 0x00},
++{0x382c, 0x00},
++{0x382d, 0x00},
++{0x3832, 0x00},
++{0x3833, 0x00},
++{0x3834, 0x00},
++{0x3838, 0x00},
++{0x3839, 0x00},
++{0x383a, 0x00},
++{0x383b, 0x00},
++{0x383c, 0x48},
++{0x383d, 0x20},
++{0x383e, 0x00},
++{0x3842, 0x00},
++{0x3843, 0x00},
++{0x3844, 0x00},
++{0x384c, 0x02},
++{0x384d, 0x14},
++{0x384e, 0x00},
++{0x384f, 0x40},
++{0x3850, 0x01},
++{0x3851, 0x02},
++{0x3852, 0x01},
++{0x3853, 0x00},
++{0x3854, 0x00},
++{0x3855, 0x05},
++{0x3856, 0x05},
++{0x3857, 0x33},
++{0x3858, 0x7c},
++{0x3859, 0x00},
++{0x385a, 0x03},
++{0x385b, 0x05},
++{0x385c, 0x32},
++{0x385d, 0x00},
++{0x385e, 0x12},
++{0x385f, 0x00},
++{0x3860, 0x10},
++{0x3861, 0x00},
++{0x3862, 0x40},
++{0x3863, 0x00},
++{0x3864, 0x40},
++{0x3865, 0x00},
++{0x3866, 0x40},
++{0x3881, 0x02},
++{0x3882, 0x00},
++{0x3883, 0x08},
++{0x3b40, 0x3e},
++{0x3b41, 0x00},
++{0x3b42, 0x02},
++{0x3b43, 0x00},
++{0x3b44, 0x03},
++{0x3b45, 0x00},
++{0x3b46, 0x03},
++{0x3b47, 0x00},
++{0x3b80, 0x00},
++{0x3b81, 0x00},
++{0x3b82, 0x07},
++{0x3b83, 0x87},
++{0x3b84, 0x36},
++{0x3b85, 0x00},
++{0x3b86, 0x00},
++{0x3b87, 0x04},
++{0x3b88, 0x00},
++{0x3b89, 0x04},
++{0x3b8a, 0x00},
++{0x3b8b, 0x0a},
++{0x3b8c, 0x00},
++{0x3b8d, 0x01},
++{0x3b8e, 0x03},
++{0x3b8f, 0xe8},
++{0x3d82, 0xbc},
++{0x3d83, 0x08},
++{0x3d84, 0x00},
++{0x3d85, 0x1b},
++{0x3d86, 0x02},
++{0x3d87, 0x0a},
++{0x3d88, 0x00},
++{0x3d89, 0x00},
++{0x3d8a, 0x03},
++{0x3d8b, 0xff},
++{0x3d8c, 0x00},
++{0x3d8d, 0x00},
++{0x3d90, 0x00},
++{0x3d91, 0x00},
++{0x3d92, 0xe2},
++{0x3d93, 0x46},
++{0x3d94, 0x14},
++{0x3d95, 0x06},
++{0x3d96, 0x01},
++{0x3d97, 0x00},
++{0x3d98, 0x00},
++{0x3d99, 0x00},
++{0x3d9a, 0x00},
++{0x3d9b, 0x00},
++{0x3d9c, 0x00},
++{0x3d9d, 0x00},
++{0x3d9e, 0x00},
++{0x3d9f, 0x00},
++{0x3da0, 0x00},
++{0x3da1, 0x00},
++{0x3da2, 0x00},
++{0x3da4, 0x00},
++{0x3e00, 0x00},
++{0x3e01, 0x00},
++{0x3e02, 0x0f},
++{0x3e03, 0xdb},
++{0x3e04, 0x14},
++{0x3e05, 0x00},
++{0x3e06, 0x03},
++{0x3e07, 0x40},
++{0x3e08, 0x00},
++{0x3e09, 0x00},
++{0x3e0a, 0x00},
++{0x3e0b, 0x00},
++{0x3e0c, 0x00},
++{0x3e0d, 0x00},
++{0x3e0e, 0x00},
++{0x3f00, 0x04},
++{0x3f01, 0x00},
++{0x3f02, 0x00},
++{0x3f03, 0x01},
++{0x4000, 0xf8},
++{0x4001, 0xeb},
++{0x4004, 0x00},
++{0x4005, 0x40},
++{0x4006, 0x00},
++{0x4007, 0x10},
++{0x4008, 0x00},
++{0x4009, 0x05},
++{0x400a, 0x02},
++{0x400b, 0x00},
++{0x400c, 0x00},
++{0x400d, 0x10},
++{0x400e, 0x00},
++{0x400f, 0xa0},
++{0x4010, 0x10},
++{0x4011, 0xff},
++{0x4012, 0x08},
++{0x4013, 0x02},
++{0x4014, 0x02},
++{0x4015, 0x02},
++{0x4016, 0x00},
++{0x4017, 0x04},
++{0x4018, 0x18},
++{0x4019, 0x04},
++{0x401a, 0x58},
++{0x4020, 0x00},
++{0x4021, 0x00},
++{0x4022, 0x00},
++{0x4023, 0x00},
++{0x4024, 0x00},
++{0x4025, 0x00},
++{0x4026, 0x00},
++{0x4027, 0x00},
++{0x4028, 0x4f},
++{0x4029, 0x01},
++{0x402a, 0x00},
++{0x402b, 0x00},
++{0x402c, 0x00},
++{0x402d, 0x00},
++{0x402e, 0x00},
++{0x402f, 0x40},
++{0x4030, 0x00},
++{0x4031, 0x40},
++{0x4032, 0x9e},
++{0x4033, 0x80},
++{0x4034, 0x00},
++{0x4035, 0x80},
++{0x4036, 0x00},
++{0x4037, 0x80},
++{0x4038, 0x00},
++{0x4039, 0x80},
++{0x403a, 0x00},
++{0x403b, 0x80},
++{0x403c, 0x00},
++{0x403d, 0x00},
++{0x4040, 0x00},
++{0x4041, 0x00},
++{0x4042, 0x00},
++{0x4043, 0x00},
++{0x4044, 0x00},
++{0x4045, 0x00},
++{0x4046, 0x00},
++{0x4047, 0x00},
++{0x4048, 0x00},
++{0x4049, 0x00},
++{0x404a, 0x00},
++{0x404b, 0x00},
++{0x404c, 0x00},
++{0x404d, 0x00},
++{0x404e, 0x00},
++{0x404f, 0x00},
++{0x4050, 0x00},
++{0x4051, 0x05},
++{0x4052, 0x00},
++{0x4053, 0x80},
++{0x4054, 0x00},
++{0x4055, 0x80},
++{0x4056, 0x00},
++{0x4057, 0x80},
++{0x4058, 0x00},
++{0x4059, 0x80},
++{0x405a, 0x30},
++{0x405b, 0x18},
++{0x405c, 0x00},
++{0x405d, 0x00},
++{0x405e, 0x00},
++{0x405f, 0x00},
++{0x4060, 0x00},
++{0x4065, 0x00},
++{0x4066, 0x02},
++{0x406d, 0x00},
++{0x406e, 0x00},
++{0x406f, 0x00},
++{0x40a0, 0x00},
++{0x40a1, 0x00},
++{0x40a2, 0x00},
++{0x40a3, 0x00},
++{0x40a4, 0x00},
++{0x40a5, 0x00},
++{0x40a6, 0x00},
++{0x40a7, 0x00},
++{0x40c0, 0x00},
++{0x40c1, 0x00},
++{0x40c2, 0x00},
++{0x40c3, 0x00},
++{0x40c4, 0x00},
++{0x40c5, 0x00},
++{0x40c6, 0x00},
++{0x40c7, 0x00},
++{0x40c8, 0x00},
++{0x40c9, 0x00},
++{0x40ca, 0x00},
++{0x40cb, 0x00},
++{0x40cc, 0x00},
++{0x40cd, 0x00},
++{0x40ce, 0x00},
++{0x40cf, 0x00},
++{0x4200, 0x00},
++{0x4201, 0x00},
++{0x4202, 0x00},
++{0x4203, 0x00},
++{0x4204, 0x00},
++{0x4205, 0x00},
++{0x4206, 0x00},
++{0x4207, 0x00},
++{0x4208, 0x00},
++{0x4300, 0x00},
++{0x4301, 0x00},
++{0x4302, 0x00},
++{0x4303, 0x00},
++{0x4304, 0x00},
++{0x4305, 0x00},
++{0x4306, 0x00},
++{0x4307, 0x00},
++{0x4308, 0x00},
++{0x4309, 0x00},
++{0x430a, 0x00},
++{0x430b, 0xff},
++{0x430c, 0xff},
++{0x430d, 0x00},
++{0x430e, 0x00},
++{0x430f, 0x02},
++{0x4500, 0x16},
++{0x4501, 0x18},
++{0x4502, 0x00},
++{0x4503, 0x00},
++{0x4504, 0x01},
++{0x4505, 0x00},
++{0x4506, 0x32},
++{0x4507, 0x07},
++{0x4508, 0x1a},
++{0x4580, 0x68},
++{0x4581, 0xc7},
++{0x4582, 0x07},
++{0x4583, 0x07},
++{0x4584, 0xec},
++{0x4585, 0x09},
++{0x4586, 0xae},
++{0x4587, 0x04},
++{0x4588, 0x52},
++{0x4589, 0x05},
++{0x458a, 0x47},
++{0x458b, 0x02},
++{0x458c, 0xe2},
++{0x458d, 0x03},
++{0x458e, 0x85},
++{0x458f, 0x00},
++{0x4590, 0x20},
++{0x4591, 0x09},
++{0x4592, 0x60},
++{0x45a6, 0x18},
++{0x4600, 0x00},
++{0x4601, 0x30},
++{0x4602, 0x00},
++{0x4603, 0x01},
++{0x4604, 0x00},
++{0x4605, 0x03},
++{0x4609, 0x00},
++{0x460a, 0x30},
++{0x460b, 0x00},
++{0x460c, 0x30},
++{0x460d, 0x01},
++{0x460e, 0x00},
++{0x4700, 0x2a},
++{0x4702, 0x00},
++{0x4703, 0x80},
++{0x4704, 0x00},
++{0x4705, 0x10},
++{0x4706, 0xaa},
++{0x4707, 0x55},
++{0x4708, 0x99},
++{0x4709, 0x66},
++{0x470a, 0x08},
++{0x470b, 0x88},
++{0x470c, 0x00},
++{0x470d, 0x02},
++{0x470e, 0x00},
++{0x470f, 0x00},
++{0x4710, 0x00},
++{0x4711, 0x00},
++{0x4712, 0x00},
++{0x4713, 0x00},
++{0x4800, 0x04},
++{0x4802, 0x00},
++{0x4803, 0x00},
++{0x4804, 0x08},
++{0x4805, 0x00},
++{0x4806, 0x00},
++{0x4807, 0x03},
++{0x4808, 0x18},
++{0x480e, 0x04},
++{0x4810, 0xff},
++{0x4811, 0xff},
++{0x4813, 0xe4}, // VC
++{0x4814, 0x2a},
++{0x4815, 0x2b},
++{0x4816, 0x2b},
++{0x4818, 0x00},
++{0x4819, 0x70},
++{0x481a, 0x00},
++{0x481b, 0x3c},
++{0x481c, 0x01},
++{0x481d, 0x2c},
++{0x481e, 0x5f},
++{0x481f, 0x26},
++{0x4820, 0x00},
++{0x4821, 0x3c},
++{0x4822, 0x00},
++{0x4823, 0x3c},
++{0x4824, 0x00},
++{0x4825, 0x32},
++{0x4826, 0x32},
++{0x4827, 0x55},
++{0x4828, 0x00},
++{0x4829, 0x64},
++{0x482a, 0x06},
++{0x482b, 0x04},
++{0x482c, 0x00},
++{0x482d, 0x00},
++{0x482e, 0x34},
++{0x482f, 0x00},
++{0x4830, 0x00},
++{0x4831, 0x64},
++{0x4832, 0x00},
++{0x4833, 0x10},
++{0x4837, 0x15},
++{0x4838, 0x00},
++{0x4839, 0x00},
++{0x483c, 0x10},
++{0x483d, 0x00},
++{0x484a, 0x3f},
++{0x484b, 0x67},
++{0x484c, 0x00},
++{0x484e, 0x10},
++{0x4850, 0x40},
++{0x4851, 0xaa},
++{0x4852, 0xff},
++{0x4853, 0x8a},
++{0x4854, 0x08},
++{0x4855, 0x30},
++{0x4856, 0x01},
++{0x4860, 0x00},
++{0x4861, 0xa0},
++{0x4862, 0x01},
++{0x4863, 0x01},
++{0x4864, 0x02},
++{0x4865, 0x66},
++{0x4866, 0x99},
++{0x4867, 0x88},
++{0x4868, 0xaa},
++{0x4869, 0xff},
++{0x486a, 0x3f},
++{0x486b, 0x84},
++{0x486c, 0x36},
++{0x486d, 0x00},
++{0x486e, 0x84},
++{0x486f, 0x36},
++{0x4870, 0x00},
++{0x4880, 0x00},
++{0x4881, 0x00},
++{0x4882, 0x00},
++{0x4883, 0x00},
++{0x4884, 0x08},
++{0x4885, 0x00},
++{0x4886, 0x00},
++{0x4900, 0x08},
++{0x4901, 0x00},
++{0x4902, 0x00},
++{0x4903, 0x80},
++{0x4f00, 0xff},
++{0x4f01, 0xff},
++{0x4f04, 0x00},
++{0x4f05, 0x01},
++{0x5180, 0x04},
++{0x5181, 0x00},
++{0x5182, 0x04},
++{0x5183, 0x00},
++{0x5184, 0x04},
++{0x5185, 0x00},
++{0x5186, 0x04},
++{0x5187, 0x00},
++{0x5188, 0x00},
++{0x5189, 0x00},
++{0x518a, 0x00},
++{0x518b, 0x10},
++{0x51a0, 0x04},
++{0x51a1, 0x00},
++{0x51a2, 0x04},
++{0x51a3, 0x00},
++{0x51a4, 0x04},
++{0x51a5, 0x00},
++{0x51a6, 0x04},
++{0x51a7, 0x00},
++{0x51a8, 0x00},
++{0x51a9, 0x00},
++{0x51aa, 0x00},
++{0x51ab, 0x10},
++{0x51c0, 0x04},
++{0x51c1, 0x00},
++{0x51c2, 0x04},
++{0x51c3, 0x00},
++{0x51c4, 0x04},
++{0x51c5, 0x00},
++{0x51c6, 0x04},
++{0x51c7, 0x00},
++{0x51c8, 0x00},
++{0x51c9, 0x00},
++{0x51ca, 0x00},
++{0x51cb, 0x10},
++{0x5380, 0x19},
++{0x5381, 0x94},
++{0x5382, 0x2e},
++{0x5383, 0x24},
++{0x5384, 0x12},
++{0x5385, 0x41},
++{0x5386, 0x48},
++{0x5387, 0x84},
++{0x5388, 0x40},
++{0x5389, 0x00},
++{0x538a, 0x00},
++{0x538b, 0x03},
++{0x538c, 0x00},
++{0x538d, 0x0f},
++{0x538e, 0x00},
++{0x538f, 0x3f},
++{0x5390, 0x0f},
++{0x5391, 0xfd},
++{0x5392, 0xf5},
++{0x5393, 0xf5},
++{0x5394, 0x02},
++{0x5395, 0xff},
++{0x5396, 0x00},
++{0x5397, 0x00},
++{0x53a0, 0x41},
++{0x53a2, 0x04},
++{0x53a3, 0x00},
++{0x53a4, 0x04},
++{0x53a5, 0x00},
++{0x53a6, 0x04},
++{0x53a7, 0x00},
++{0x53ac, 0x04},
++{0x53ad, 0x00},
++{0x53ae, 0x04},
++{0x53af, 0x00},
++{0x53b0, 0x04},
++{0x53b1, 0x00},
++{0x5400, 0x19},
++{0x5401, 0x94},
++{0x5402, 0x2e},
++{0x5403, 0x24},
++{0x5404, 0x12},
++{0x5405, 0x41},
++{0x5406, 0x48},
++{0x5407, 0x84},
++{0x5408, 0x40},
++{0x5409, 0x00},
++{0x540a, 0x00},
++{0x540b, 0x03},
++{0x540c, 0x00},
++{0x540d, 0x0f},
++{0x540e, 0x00},
++{0x540f, 0x3f},
++{0x5410, 0x0f},
++{0x5411, 0xfd},
++{0x5412, 0xf5},
++{0x5413, 0xf5},
++{0x5414, 0x02},
++{0x5415, 0xff},
++{0x5416, 0x00},
++{0x5417, 0x00},
++{0x5420, 0x41},
++{0x5422, 0x04},
++{0x5423, 0x00},
++{0x5424, 0x04},
++{0x5425, 0x00},
++{0x5426, 0x04},
++{0x5427, 0x00},
++{0x542c, 0x04},
++{0x542d, 0x00},
++{0x542e, 0x04},
++{0x542f, 0x00},
++{0x5430, 0x04},
++{0x5431, 0x00},
++{0x5480, 0x19},
++{0x5481, 0x94},
++{0x5482, 0x2e},
++{0x5483, 0x24},
++{0x5484, 0x12},
++{0x5485, 0x41},
++{0x5486, 0x48},
++{0x5487, 0x84},
++{0x5488, 0x40},
++{0x5489, 0x00},
++{0x548a, 0x00},
++{0x548b, 0x03},
++{0x548c, 0x00},
++{0x548d, 0x0f},
++{0x548e, 0x00},
++{0x548f, 0x3f},
++{0x5490, 0x0f},
++{0x5491, 0xfd},
++{0x5492, 0xf5},
++{0x5493, 0xf5},
++{0x5494, 0x02},
++{0x5495, 0xff},
++{0x5496, 0x00},
++{0x5497, 0x00},
++{0x54a0, 0x41},
++{0x54a2, 0x04},
++{0x54a3, 0x00},
++{0x54a4, 0x04},
++{0x54a5, 0x00},
++{0x54a6, 0x04},
++{0x54a7, 0x00},
++{0x54ac, 0x04},
++{0x54ad, 0x00},
++{0x54ae, 0x04},
++{0x54af, 0x00},
++{0x54b0, 0x04},
++{0x54b1, 0x00},
++{0x5800, 0x19},
++{0x5801, 0x03},
++{0x5802, 0x60},
++{0x5803, 0xf0},
++{0x5804, 0x00},
++{0x5805, 0x40},
++{0x5806, 0x01},
++{0x5807, 0x00},
++{0x5808, 0x60},
++{0x5809, 0xf0},
++{0x580a, 0x33},
++{0x580b, 0x10},
++{0x580c, 0x04},
++{0x580d, 0x00},
++{0x580e, 0x10},
++{0x580f, 0x10},
++{0x5810, 0x02},
++{0x5811, 0x08},
++{0x5812, 0x38},
++{0x5813, 0x00},
++{0x5814, 0x00},
++{0x5815, 0x00},
++{0x5816, 0x00},
++{0x5000, 0x81},
++{0x5001, 0x42},
++{0x5002, 0x19},
++{0x5003, 0x16},
++{0x5004, 0x02},
++{0x5005, 0x00},
++{0x5006, 0x01},
++{0x5007, 0x00},
++{0x5008, 0x00},
++{0x5009, 0x40},
++{0x500a, 0x00},
++{0x500b, 0x00},
++{0x500c, 0x00},
++{0x500d, 0x00},
++{0x500e, 0x00},
++{0x500f, 0x00},
++{0x5010, 0x07},
++{0x5011, 0x8f},
++{0x5012, 0x05},
++{0x5013, 0x0f},
++{0x5014, 0x01},
++{0x5015, 0x01},
++{0x5016, 0x01},
++{0x5017, 0x01},
++{0x5018, 0x00},
++{0x5019, 0x00},
++{0x501a, 0x00},
++{0x501b, 0x10},
++{0x501c, 0x00},
++{0x501d, 0x10},
++{0x501e, 0x00},
++{0x501f, 0x10},
++{0x5020, 0x04},
++{0x5021, 0x00},
++{0x5022, 0x04},
++{0x5023, 0x00},
++{0x5024, 0x04},
++{0x5025, 0x00},
++{0x5026, 0x00},
++{0x5027, 0x10},
++{0x5028, 0x00},
++{0x5029, 0x10},
++{0x502a, 0x00},
++{0x502b, 0x10},
++{0x502c, 0x00},
++{0x502d, 0x10},
++{0x502e, 0x00},
++{0x502f, 0x10},
++{0x5030, 0x00},
++{0x5031, 0x10},
++{0x5032, 0x04},
++{0x5033, 0x00},
++{0x5034, 0x04},
++{0x5035, 0x00},
++{0x5036, 0x04},
++{0x5037, 0x00},
++{0x5038, 0x00},
++{0x5039, 0x10},
++{0x503a, 0x00},
++{0x503b, 0x10},
++{0x503c, 0x00},
++{0x503d, 0x10},
++{0x503e, 0x00},
++{0x503f, 0x00},
++{0x5040, 0x00},
++{0x5041, 0x01},
++{0x5042, 0x00},
++{0x5043, 0x00},
++{0x5600, 0x0f},
++{0x5601, 0xab},
++{0x5602, 0x02},
++{0x5603, 0x58},
++{0x5604, 0x03},
++{0x5605, 0x20},
++{0x5606, 0x02},
++{0x5607, 0x58},
++{0x5608, 0x03},
++{0x5609, 0x20},
++{0x560a, 0x02},
++{0x560b, 0x58},
++{0x560c, 0x03},
++{0x560d, 0x20},
++{0x560e, 0x02},
++{0x560f, 0x58},
++{0x5610, 0x03},
++{0x5611, 0x20},
++{0x5612, 0x02},
++{0x5613, 0x58},
++{0x5614, 0x03},
++{0x5615, 0x20},
++{0x5616, 0x02},
++{0x5617, 0x58},
++{0x5618, 0x03},
++{0x5619, 0x20},
++{0x5640, 0x0f},
++{0x5641, 0xab},
++{0x5642, 0x02},
++{0x5643, 0x58},
++{0x5644, 0x03},
++{0x5645, 0x20},
++{0x5646, 0x02},
++{0x5647, 0x58},
++{0x5648, 0x03},
++{0x5649, 0x20},
++{0x564a, 0x02},
++{0x564b, 0x58},
++{0x564c, 0x03},
++{0x564d, 0x20},
++{0x564e, 0x02},
++{0x564f, 0x58},
++{0x5650, 0x03},
++{0x5651, 0x20},
++{0x5652, 0x02},
++{0x5653, 0x58},
++{0x5654, 0x03},
++{0x5655, 0x20},
++{0x5656, 0x02},
++{0x5657, 0x58},
++{0x5658, 0x03},
++{0x5659, 0x20},
++{0x5680, 0x0f},
++{0x5681, 0xab},
++{0x5682, 0x02},
++{0x5683, 0x58},
++{0x5684, 0x03},
++{0x5685, 0x20},
++{0x5686, 0x02},
++{0x5687, 0x58},
++{0x5688, 0x03},
++{0x5689, 0x20},
++{0x568a, 0x02},
++{0x568b, 0x58},
++{0x568c, 0x03},
++{0x568d, 0x20},
++{0x568e, 0x02},
++{0x568f, 0x58},
++{0x5690, 0x03},
++{0x5691, 0x20},
++{0x5692, 0x02},
++{0x5693, 0x58},
++{0x5694, 0x03},
++{0x5695, 0x20},
++{0x5696, 0x02},
++{0x5697, 0x58},
++{0x5698, 0x03},
++{0x5699, 0x20},
++{0x5700, 0x00},
++{0x5701, 0x00},
++{0x5702, 0x00},
++{0x5703, 0x00},
++{0x5704, 0x02},
++{0x5705, 0x80},
++{0x5706, 0x01},
++{0x5707, 0xe0},
++{0x5708, 0x00},
++{0x5709, 0x0e},
++{0x5740, 0x00},
++{0x5741, 0x00},
++{0x5742, 0x00},
++{0x5743, 0x00},
++{0x5744, 0x02},
++{0x5745, 0x80},
++{0x5746, 0x01},
++{0x5747, 0xe0},
++{0x5748, 0x00},
++{0x5749, 0x0e},
++{0x5780, 0x00},
++{0x5781, 0x00},
++{0x5782, 0x00},
++{0x5783, 0x00},
++{0x5784, 0x02},
++{0x5785, 0x80},
++{0x5786, 0x01},
++{0x5787, 0xe0},
++{0x5788, 0x00},
++{0x5789, 0x0e},
++{0x5200, 0x70},
++{0x5201, 0x80},
++{0x5202, 0x73},
++{0x5203, 0xff},
++{0x5204, 0x02},
++{0x5205, 0x6c},
++{0x5206, 0x00},
++{0x5207, 0x00},
++{0x5209, 0x08},
++{0x520a, 0x00},
++{0x520b, 0x07},
++{0x520c, 0x01},
++{0x520d, 0x01},
++{0x520e, 0x01},
++{0x520f, 0x01},
++{0x5210, 0x00},
++{0x5211, 0x00},
++{0x5212, 0x00},
++{0x5213, 0x00},
++{0x5214, 0x00},
++{0x5215, 0x00},
++{0x5216, 0x07},
++{0x5217, 0x8b},
++{0x5218, 0x00},
++{0x5219, 0x00},
++{0x5280, 0x00},
++{0x5281, 0x00},
++{0x5282, 0xff},
++{0x5283, 0xff},
++{0x5284, 0x02},
++{0x5285, 0x6c},
++{0x5286, 0x00},
++{0x5287, 0x00},
++{0x5289, 0x08},
++{0x528a, 0x00},
++{0x528b, 0x07},
++{0x528c, 0x01},
++{0x528d, 0x01},
++{0x528e, 0x01},
++{0x528f, 0x01},
++{0x5290, 0x00},
++{0x5291, 0x00},
++{0x5292, 0x00},
++{0x5293, 0x00},
++{0x5294, 0x00},
++{0x5295, 0x00},
++{0x5296, 0x07},
++{0x5297, 0x8b},
++{0x5298, 0x00},
++{0x5299, 0x00},
++{0x5300, 0x00},
++{0x5301, 0x00},
++{0x5302, 0xff},
++{0x5303, 0xff},
++{0x5304, 0x02},
++{0x5305, 0x6c},
++{0x5306, 0x00},
++{0x5307, 0x00},
++{0x5309, 0x08},
++{0x530a, 0x00},
++{0x530b, 0x07},
++{0x530c, 0x01},
++{0x530d, 0x01},
++{0x530e, 0x01},
++{0x530f, 0x01},
++{0x5310, 0x00},
++{0x5311, 0x00},
++{0x5312, 0x00},
++{0x5313, 0x00},
++{0x5314, 0x00},
++{0x5315, 0x00},
++{0x5316, 0x07},
++{0x5317, 0x8b},
++{0x5318, 0x00},
++{0x5319, 0x00},
++#ifdef OX03A_DISPLAY_PATTERN_COLOR_BAR
++{0x5080, 0x80}, /* Rolling test pattern for HCG */
++#else
++{0x5080, 0x00},
++#endif
++{0x5081, 0x01},
++{0x5082, 0xb0},
++{0x5083, 0x0f},
++{0x5084, 0x00},
++{0x5085, 0x00},
++{0x5086, 0x00},
++{0x5087, 0x01},
++{0x5088, 0x00},
++{0x5089, 0x00},
++{0x508a, 0x00},
++{0x508b, 0x00},
++{0x508c, 0x00},
++{0x508d, 0x00},
++{0x508e, 0x00},
++{0x508f, 0x00},
++{0x5090, 0x00},
++{0x5091, 0x00},
++{0x5092, 0x00},
++{0x5093, 0x00},
++{0x5094, 0x00},
++{0x5095, 0x00},
++{0x5096, 0x00},
++{0x5097, 0x00},
++#ifdef OX03A_DISPLAY_PATTERN_COLOR_BAR
++{0x50c0, 0x80}, /* Rolling test pattern for LCG */
++#else
++{0x50c0, 0x00},
++#endif
++{0x50c1, 0x01},
++{0x50c2, 0xb0},
++{0x50c3, 0x0f},
++{0x50c4, 0x00},
++{0x50c5, 0x00},
++{0x50c6, 0x00},
++{0x50c7, 0x01},
++{0x50c8, 0x00},
++{0x50c9, 0x00},
++{0x50ca, 0x00},
++{0x50cb, 0x00},
++{0x50cc, 0x00},
++{0x50cd, 0x00},
++{0x50ce, 0x00},
++{0x50cf, 0x00},
++{0x50d0, 0x00},
++{0x50d1, 0x00},
++{0x50d2, 0x00},
++{0x50d3, 0x00},
++{0x50d4, 0x00},
++{0x50d5, 0x00},
++{0x50d6, 0x00},
++{0x50d7, 0x00},
++#ifdef OX03A_DISPLAY_PATTERN_COLOR_BAR
++{0x5100, 0x80}, /* Rolling test pattern for VS */
++#else
++{0x5100, 0x00},
++#endif
++{0x5101, 0x01},
++{0x5102, 0xb0},
++{0x5103, 0x0f},
++{0x5104, 0x00},
++{0x5105, 0x00},
++{0x5106, 0x00},
++{0x5107, 0x01},
++{0x5108, 0x00},
++{0x5109, 0x00},
++{0x510a, 0x00},
++{0x510b, 0x00},
++{0x510c, 0x00},
++{0x510d, 0x00},
++{0x510e, 0x00},
++{0x510f, 0x00},
++{0x5110, 0x00},
++{0x5111, 0x00},
++{0x5112, 0x00},
++{0x5113, 0x00},
++{0x5114, 0x00},
++{0x5115, 0x00},
++{0x5116, 0x00},
++{0x5117, 0x00},
++{0x380e, 0x05},
++{0x380f, 0x34},
++{0x380c, 0x06},
++{0x380d, 0xcc},
++{0x384c, 0x03},
++{0x384d, 0xc0},
++{0x4603, 0x01},
++{0x4601, 0x00},
++{0x3501, 0x01},
++{0x0100, 0x01},
++};
+diff --git a/drivers/media/i2c/soc_camera/ti9x4.c b/drivers/media/i2c/soc_camera/ti9x4.c
+new file mode 100644
+index 0000000..222db9b
+--- /dev/null
++++ b/drivers/media/i2c/soc_camera/ti9x4.c
+@@ -0,0 +1,518 @@
++ /*
++ * TI DS90UB954/960/964 FPDLinkIII driver
++ *
++ * Copyright (C) 2017-2018 Cogent Embedded, Inc.
+ *
+ * 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
@@ -6955,7 +16178,6 @@ index 0000000..bffd7c2
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/of_gpio.h>
-+#include <linux/regulator/consumer.h>
+#include <linux/videodev2.h>
+
+#include <media/v4l2-common.h>
@@ -6963,9 +16185,9 @@ index 0000000..bffd7c2
+#include <media/v4l2-of.h>
+#include <media/v4l2-subdev.h>
+
-+#include "ti9x4_ti9x3.h"
++#include "ti9x4.h"
+
-+struct ti964_ti9x3_priv {
++struct ti9x4_priv {
+ struct v4l2_subdev sd[4];
+ struct device_node *sd_of_node[4];
+ int des_addr;
@@ -6973,17 +16195,72 @@ index 0000000..bffd7c2
+ int lanes;
+ int csi_rate;
+ const char *forwarding_mode;
-+ const char *cable_mode;
++ int is_coax;
++ int dvp_bus;
++ int hsync;
++ int vsync;
++ int poc_delay;
+ atomic_t use_count;
+ struct i2c_client *client;
+ int ti9x3_addr_map[4];
+ char chip_id[6];
-+ struct regulator *poc_supply[4]; /* PoC power supply */
++ int ser_id;
++ struct gpio_desc *poc_gpio[4]; /* PoC power supply */
+};
+
-+static void ti964_ti9x3_read_chipid(struct i2c_client *client)
++static int ser_id;
++module_param(ser_id, int, 0644);
++MODULE_PARM_DESC(ser_id, " Serializer ID (default: TI913)");
++
++static int is_stp;
++module_param(is_stp, int, 0644);
++MODULE_PARM_DESC(is_stp, " STP cable (default: Coax cable)");
++
++static int dvp_bus = 8;
++module_param(dvp_bus, int, 0644);
++MODULE_PARM_DESC(dvp_bus, " DVP/CSI over FPDLink (default: DVP 8-bit)");
++
++static int hsync;
++module_param(hsync, int, 0644);
++MODULE_PARM_DESC(hsync, " HSYNC invertion (default: 0 - not inverted)");
++
++static int vsync = 1;
++module_param(vsync, int, 0644);
++MODULE_PARM_DESC(vsync, " VSYNC invertion (default: 1 - inverted)");
++
++static int poc_delay;
++module_param(poc_delay, int, 0644);
++MODULE_PARM_DESC(poc_delay, " Delay in ms after POC enable (default: 0 ms)");
++
++#ifdef TI954_SILICON_ERRATA
++static int indirect_write(struct i2c_client *client, unsigned int page, u8 reg, u8 val)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ if (page > 7)
++ return -EINVAL;
++
++ reg8_write(client, 0xb0, page << 2);
++ reg8_write(client, 0xb1, reg);
++ reg8_write(client, 0xb2, val);
++
++ return 0;
++}
++
++static int indirect_read(struct i2c_client *client, unsigned int page, u8 reg, u8 *val)
++{
++ if (page > 7)
++ return -EINVAL;
++
++ reg8_write(client, 0xb0, page << 2);
++ reg8_write(client, 0xb1, reg);
++ reg8_read(client, 0xb2, val);
++
++ return 0;
++}
++#endif
++
++static void ti9x4_read_chipid(struct i2c_client *client)
++{
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
+
+ /* Chip ID */
+ reg8_read(client, 0xf1, &priv->chip_id[0]);
@@ -6994,12 +16271,12 @@ index 0000000..bffd7c2
+ priv->chip_id[5] = '\0';
+}
+
-+static void ti964_ti9x3_initial_setup(struct i2c_client *client)
++static void ti9x4_initial_setup(struct i2c_client *client)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
+
+ /* Initial setup */
-+ client->addr = priv->des_addr; /* TI964 I2C */
++ client->addr = priv->des_addr; /* TI9x4 I2C */
+ reg8_write(client, 0x08, 0x1c); /* I2C glitch filter depth */
+ reg8_write(client, 0x0a, 0x79); /* I2C high pulse width */
+ reg8_write(client, 0x0b, 0x79); /* I2C low pulse width */
@@ -7045,7 +16322,7 @@ index 0000000..bffd7c2
+ reg8_write(client, 0x19, 2 >> 8); /* FrameSync high time MSB */
+ reg8_write(client, 0x1a, 2 & 0xff); /* FrameSync high time LSB */
+ reg8_write(client, 0x1b, FS_TIME >> 8); /* FrameSync low time MSB */
-+ reg8_write(client, 0x1c, FS_TIME & 0xff); /* FrameSync low time LSB */
++ reg8_write(client, 0x1c, FS_TIME & 0xff); /* FrameSync low time LSB */
+ reg8_write(client, 0x18, 0x01); /* Enable FrameSync, HI/LO mode, Frame clock from port0 */
+#endif
+}
@@ -7053,45 +16330,81 @@ index 0000000..bffd7c2
+//#define SENSOR_ID 0x30 // ov10635
+//#define SENSOR_ID 0x24 // ov490
+
-+static void ti964_ti9x3_fpdlink3_setup(struct i2c_client *client, int idx)
++static void ti9x4_fpdlink3_setup(struct i2c_client *client, int idx)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
++ u8 port_config = 0x78;
++ u8 port_config2 = 0;
+
+ /* FPDLinkIII setup */
-+ client->addr = priv->des_addr; /* TI964 I2C */
++ client->addr = priv->des_addr; /* TI9x4 I2C */
+ reg8_write(client, 0x4c, (idx << 4) | (1 << idx)); /* Select RX port number */
+ usleep_range(2000, 2500); /* wait 2ms */
-+ reg8_write(client, 0x58, 0x58); /* Back channel: pass-through/backchannel/CRC enable, Freq=2.5Mbps */
++
++ switch (priv->ser_id) {
++ case TI913_ID:
++ reg8_write(client, 0x58, 0x58); /* Back channel: Freq=2.5Mbps */
++ break;
++ case TI953_ID:
++ reg8_write(client, 0x58, 0x5e); /* Back channel: Freq=50Mbps */
++ break;
++ default:
++ break;
++ }
++
+ reg8_write(client, 0x5c, priv->ti9x3_addr_map[idx] << 1); /* TI9X3 I2C addr */
+// reg8_write(client, 0x5d, SENSOR_ID << 1); /* SENSOR I2C native - must be set by sensor driver */
+// reg8_write(client, 0x65, (0x60 + idx) << 1); /* SENSOR I2C translated - must be set by sensor driver */
-+ if (strcmp(priv->cable_mode, "coax") == 0) {
-+ reg8_write(client, 0x6d, 0x7f); /* Coax, RAW10 */
-+ } else if (strcmp(priv->cable_mode, "stp") == 0) {
-+ reg8_write(client, 0x6d, 0x78); /* STP, CSI */
++
++ if (priv->is_coax)
++ port_config |= 0x04; /* Coax */
++ else
++ port_config |= 0x00; /* STP */
++
++ switch (priv->dvp_bus) {
++ case 8:
++ port_config2 |= 0x80; /* RAW10 as 8-bit prosessing using upper bits */
++ /* fall through */
++ case 10:
++ port_config |= 0x03; /* DVP over FPDLink (TI913 compatible) RAW10/RAW8 */
++ break;
++ case 12:
++ port_config |= 0x02; /* DVP over FPDLink (TI913 compatible) RAW12 */
++ break;
++ default:
++ port_config |= 0x00; /* CSI over FPDLink (TI953 compatible) */
+ }
++
++ if (priv->vsync)
++ port_config2 |= 0x01; /* VSYNC acive low */
++ if (priv->hsync)
++ port_config2 |= 0x02; /* HSYNC acive low */
++
++ reg8_write(client, 0x6d, port_config);
++ reg8_write(client, 0x7c, port_config2);
+ reg8_write(client, 0x70, (idx << 6) | 0x1e); /* CSI data type: yuv422 8-bit, assign VC */
-+ reg8_write(client, 0x7c, 0x81); /* BIT(7) - magic to Use RAW10 as 8-bit mode */
++ reg8_write(client, 0x71, (idx << 6) | 0x2c); /* CSI data type: RAW12, assign VC */
++ reg8_write(client, 0xbc, 0x00); /* Setup minimal time between FV and LV to 3 PCLKs */
+ reg8_write(client, 0x6e, 0x88); /* Sensor reset: backchannel GPIO0/GPIO1 set low */
+}
+
-+static int ti964_ti9x3_initialize(struct i2c_client *client)
++static int ti9x4_initialize(struct i2c_client *client)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
+ int idx;
+
+ dev_info(&client->dev, "LINKs=%d, LANES=%d, FORWARDING=%s, CABLE=%s, ID=%s\n",
-+ priv->links, priv->lanes, priv->forwarding_mode, priv->cable_mode, priv->chip_id);
++ priv->links, priv->lanes, priv->forwarding_mode, priv->is_coax ? "coax" : "stp", priv->chip_id);
+
-+ ti964_ti9x3_initial_setup(client);
++ ti9x4_initial_setup(client);
+
+ for (idx = 0; idx < priv->links; idx++) {
-+ if (!IS_ERR(priv->poc_supply[idx])) {
-+ if (regulator_enable(priv->poc_supply[idx]))
-+ dev_err(&client->dev, "fail to enable POC%d regulator\n", idx);
++ if (!IS_ERR(priv->poc_gpio[idx])) {
++ gpiod_direction_output(priv->poc_gpio[idx], 1); /* POC power on */
++ mdelay(priv->poc_delay);
+ }
+
-+ ti964_ti9x3_fpdlink3_setup(client, idx);
++ ti9x4_fpdlink3_setup(client, idx);
+ }
+
+ client->addr = priv->des_addr;
@@ -7100,10 +16413,10 @@ index 0000000..bffd7c2
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
-+static int ti964_ti9x3_g_register(struct v4l2_subdev *sd,
++static int ti9x4_g_register(struct v4l2_subdev *sd,
+ struct v4l2_dbg_register *reg)
+{
-+ struct ti964_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
++ struct ti9x4_priv *priv = v4l2_get_subdevdata(sd);
+ struct i2c_client *client = priv->client;
+ int ret;
+ u8 val = 0;
@@ -7118,19 +16431,19 @@ index 0000000..bffd7c2
+ return 0;
+}
+
-+static int ti964_ti9x3_s_register(struct v4l2_subdev *sd,
++static int ti9x4_s_register(struct v4l2_subdev *sd,
+ const struct v4l2_dbg_register *reg)
+{
-+ struct ti964_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
++ struct ti9x4_priv *priv = v4l2_get_subdevdata(sd);
+ struct i2c_client *client = priv->client;
+
+ return reg8_write(client, (u8)reg->reg, (u8)reg->val);
+}
+#endif
+
-+static int ti964_ti9x3_s_power(struct v4l2_subdev *sd, int on)
++static int ti9x4_s_power(struct v4l2_subdev *sd, int on)
+{
-+ struct ti964_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
++ struct ti9x4_priv *priv = v4l2_get_subdevdata(sd);
+ struct i2c_client *client = priv->client;
+
+ if (on) {
@@ -7144,9 +16457,9 @@ index 0000000..bffd7c2
+ return 0;
+}
+
-+static int ti964_ti9x3_registered_async(struct v4l2_subdev *sd)
++static int ti9x4_registered_async(struct v4l2_subdev *sd)
+{
-+ struct ti964_ti9x3_priv *priv = v4l2_get_subdevdata(sd);
++ struct ti9x4_priv *priv = v4l2_get_subdevdata(sd);
+ struct i2c_client *client = priv->client;
+
+ reg8_write(client, 0x33, ((priv->lanes - 1) ^ 0x3) << 4 | 0x1); /* enable CSI output, set CSI lane count, non-continuous CSI mode */
@@ -7154,31 +16467,31 @@ index 0000000..bffd7c2
+ return 0;
+}
+
-+static struct v4l2_subdev_core_ops ti964_ti9x3_subdev_core_ops = {
++static struct v4l2_subdev_core_ops ti9x4_subdev_core_ops = {
+#ifdef CONFIG_VIDEO_ADV_DEBUG
-+ .g_register = ti964_ti9x3_g_register,
-+ .s_register = ti964_ti9x3_s_register,
++ .g_register = ti9x4_g_register,
++ .s_register = ti9x4_s_register,
+#endif
-+ .s_power = ti964_ti9x3_s_power,
-+ .registered_async = ti964_ti9x3_registered_async,
++ .s_power = ti9x4_s_power,
++ .registered_async = ti9x4_registered_async,
+};
+
-+static struct v4l2_subdev_ops ti964_ti9x3_subdev_ops = {
-+ .core = &ti964_ti9x3_subdev_core_ops,
++static struct v4l2_subdev_ops ti9x4_subdev_ops = {
++ .core = &ti9x4_subdev_core_ops,
+};
+
-+static int ti964_ti9x3_parse_dt(struct i2c_client *client)
++static int ti9x4_parse_dt(struct i2c_client *client)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
+ struct device_node *np = client->dev.of_node;
+ struct device_node *endpoint = NULL, *rendpoint = NULL;
+ struct property *prop;
+ int err, pwen, i;
+ int sensor_delay;
+ char forwarding_mode_default[20] = "round-robin"; /* round-robin, synchronized */
-+ char cable_mode_default[5] = "coax"; /* coax, stp */
+ struct property *csi_rate_prop, *dvp_order_prop;
+ u8 val = 0;
++ char poc_name[10];
+
+ if (of_property_read_u32(np, "ti,links", &priv->links))
+ priv->links = 4;
@@ -7188,14 +16501,19 @@ index 0000000..bffd7c2
+
+ pwen = of_get_gpio(np, 0);
+ if (pwen > 0) {
-+ err = devm_gpio_request_one(&client->dev, pwen, GPIOF_OUT_INIT_HIGH, dev_name(&client->dev));
++ err = devm_gpio_request_one(&client->dev, pwen, GPIOF_OUT_INIT_LOW, dev_name(&client->dev));
+ if (err)
+ dev_err(&client->dev, "cannot request PWEN gpio %d: %d\n", pwen, err);
+ else
+ mdelay(250);
+ }
+
-+ reg8_read(client, 0x00, &val); /* read TI964 I2C address */
++ for (i = 0; i < 4; i++) {
++ sprintf(poc_name, "POC%d", i);
++ priv->poc_gpio[i] = devm_gpiod_get_optional(&client->dev, poc_name, 0);
++ }
++
++ reg8_read(client, 0x00, &val); /* read TI9x4 I2C address */
+ if (val != (priv->des_addr << 1)) {
+ prop = of_find_property(np, "reg", NULL);
+ if (prop)
@@ -7203,18 +16521,47 @@ index 0000000..bffd7c2
+ return -ENODEV;
+ }
+
-+ ti964_ti9x3_read_chipid(client);
++ ti9x4_read_chipid(client);
+
++#ifdef TI954_SILICON_ERRATA
++ indirect_write(client, 7, 0x15, 0x30);
++ if (pwen > 0)
++ gpio_set_value(pwen, 1);
++ usleep_range(5000, 5500); /* wait 5ms */
++ indirect_write(client, 7, 0x15, 0);
++#endif
+ if (!of_property_read_u32(np, "ti,sensor_delay", &sensor_delay))
+ mdelay(sensor_delay);
-+
-+ err = of_property_read_string(np, "ti,forwarding-mode", &priv->forwarding_mode);
-+ if (err)
++ if (of_property_read_string(np, "ti,forwarding-mode", &priv->forwarding_mode))
+ priv->forwarding_mode = forwarding_mode_default;
++ if (of_property_read_bool(np, "ti,stp"))
++ priv->is_coax = 0;
++ else
++ priv->is_coax = 1;
++ if (of_property_read_u32(np, "ti,dvp_bus", &priv->dvp_bus))
++ priv->dvp_bus = 8;
++ if (of_property_read_u32(np, "ti,hsync", &priv->hsync))
++ priv->vsync = 0;
++ if (of_property_read_u32(np, "ti,vsync", &priv->vsync))
++ priv->vsync = 1;
++ if (of_property_read_u32(np, "ti,ser_id", &priv->ser_id))
++ priv->ser_id = TI913_ID;
++ if (of_property_read_u32(np, "ti,poc-delay", &priv->poc_delay))
++ priv->poc_delay = 50;
+
-+ err = of_property_read_string(np, "ti,cable-mode", &priv->cable_mode);
-+ if (err)
-+ priv->cable_mode = cable_mode_default;
++ /* module params override dts */
++ if (is_stp)
++ priv->is_coax = 0;
++ if (dvp_bus != 8)
++ priv->dvp_bus = dvp_bus;
++ if (hsync)
++ priv->hsync = hsync;
++ if (!vsync)
++ priv->vsync = vsync;
++ if (ser_id)
++ priv->ser_id = ser_id;
++ if (poc_delay)
++ priv->poc_delay = poc_delay;
+
+ for (i = 0; ; i++) {
+ endpoint = of_graph_get_next_endpoint(np, endpoint);
@@ -7249,12 +16596,11 @@ index 0000000..bffd7c2
+ return 0;
+}
+
-+static int ti964_ti9x3_probe(struct i2c_client *client,
++static int ti9x4_probe(struct i2c_client *client,
+ const struct i2c_device_id *did)
+{
-+ struct ti964_ti9x3_priv *priv;
++ struct ti9x4_priv *priv;
+ int err, i;
-+ char supply_name[10];
+
+ priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
@@ -7265,21 +16611,16 @@ index 0000000..bffd7c2
+ priv->client = client;
+ atomic_set(&priv->use_count, 0);
+
-+ err = ti964_ti9x3_parse_dt(client);
++ err = ti9x4_parse_dt(client);
+ if (err)
+ goto out;
+
-+ for (i = 0; i < 4; i++) {
-+ sprintf(supply_name, "POC%d", i);
-+ priv->poc_supply[i] = devm_regulator_get_optional(&client->dev, supply_name);
-+ }
-+
-+ err = ti964_ti9x3_initialize(client);
++ err = ti9x4_initialize(client);
+ if (err < 0)
+ goto out;
+
+ for (i = 0; i < priv->links; i++) {
-+ v4l2_subdev_init(&priv->sd[i], &ti964_ti9x3_subdev_ops);
++ v4l2_subdev_init(&priv->sd[i], &ti9x4_subdev_ops);
+ priv->sd[i].owner = client->dev.driver->owner;
+ priv->sd[i].dev = &client->dev;
+ priv->sd[i].grp_id = i;
@@ -7299,9 +16640,9 @@ index 0000000..bffd7c2
+ return err;
+}
+
-+static int ti964_ti9x3_remove(struct i2c_client *client)
++static int ti9x4_remove(struct i2c_client *client)
+{
-+ struct ti964_ti9x3_priv *priv = i2c_get_clientdata(client);
++ struct ti9x4_priv *priv = i2c_get_clientdata(client);
+ int i;
+
+ for (i = 0; i < priv->links; i++) {
@@ -7312,39 +16653,39 @@ index 0000000..bffd7c2
+ return 0;
+}
+
-+static const struct of_device_id ti964_ti9x3_dt_ids[] = {
-+ { .compatible = "ti,ti964-ti9x3" },
++static const struct of_device_id ti9x4_dt_ids[] = {
++ { .compatible = "ti,ti9x4" },
+ {},
+};
-+MODULE_DEVICE_TABLE(of, ti964_ti9x3_dt_ids);
++MODULE_DEVICE_TABLE(of, ti9x4_dt_ids);
+
-+static const struct i2c_device_id ti964_ti9x3_id[] = {
-+ { "ti964_ti9x3", 0 },
++static const struct i2c_device_id ti9x4_id[] = {
++ { "ti9x4", 0 },
+ { }
+};
-+MODULE_DEVICE_TABLE(i2c, ti964_ti9x3_id);
++MODULE_DEVICE_TABLE(i2c, ti9x4_id);
+
-+static struct i2c_driver ti964_ti9x3_i2c_driver = {
++static struct i2c_driver ti9x4_i2c_driver = {
+ .driver = {
-+ .name = "ti964_ti9x3",
-+ .of_match_table = of_match_ptr(ti964_ti9x3_dt_ids),
++ .name = "ti9x4",
++ .of_match_table = of_match_ptr(ti9x4_dt_ids),
+ },
-+ .probe = ti964_ti9x3_probe,
-+ .remove = ti964_ti9x3_remove,
-+ .id_table = ti964_ti9x3_id,
++ .probe = ti9x4_probe,
++ .remove = ti9x4_remove,
++ .id_table = ti9x4_id,
+};
+
-+module_i2c_driver(ti964_ti9x3_i2c_driver);
++module_i2c_driver(ti9x4_i2c_driver);
+
-+MODULE_DESCRIPTION("FPDLinkIII driver for TI964-TI9X3");
++MODULE_DESCRIPTION("FPDLinkIII driver for DS90UB9x4");
+MODULE_AUTHOR("Vladimir Barinov");
+MODULE_LICENSE("GPL");
-diff --git a/drivers/media/i2c/soc_camera/ti9x4_ti9x3.h b/drivers/media/i2c/soc_camera/ti9x4_ti9x3.h
+diff --git a/drivers/media/i2c/soc_camera/ti9x4.h b/drivers/media/i2c/soc_camera/ti9x4.h
new file mode 100644
-index 0000000..69d3728
+index 0000000..b53b4c6
--- /dev/null
-+++ b/drivers/media/i2c/soc_camera/ti9x4_ti9x3.h
-@@ -0,0 +1,153 @@
++++ b/drivers/media/i2c/soc_camera/ti9x4.h
+@@ -0,0 +1,156 @@
+/*
+ * TI FPDLinkIII driver include file
+ *
@@ -7366,6 +16707,9 @@ index 0000000..69d3728
+#endif
+
+#define MAXIM_NUM_RETRIES 1 /* number of read/write retries */
++#define TI913_ID 0x58
++#define TI953_ID 0x30 /* or starapped to 0x32 */
++#define TI9X4_ID 0x00 /* strapped */
+#define BROADCAST 0x6f
+
+static inline int reg8_read(struct i2c_client *client, u8 reg, u8 *val)
@@ -7499,7 +16843,7 @@ index 0000000..69d3728
+}
+#endif /* _TI9X4_H */
diff --git a/drivers/media/platform/soc_camera/rcar_csi2.c b/drivers/media/platform/soc_camera/rcar_csi2.c
-index 4d95da6..2ef27e8 100644
+index 4d95da6..53fc644 100644
--- a/drivers/media/platform/soc_camera/rcar_csi2.c
+++ b/drivers/media/platform/soc_camera/rcar_csi2.c
@@ -37,8 +37,9 @@
@@ -7532,6 +16876,15 @@ index 4d95da6..2ef27e8 100644
#define RCAR_CSI2_PHYCNT_SHUTDOWNZ (1 << 17)
#define RCAR_CSI2_PHYCNT_RSTZ (1 << 16)
#define RCAR_CSI2_PHYCNT_ENABLECLK (1 << 4)
+@@ -80,7 +86,7 @@
+
+ #define RCAR_CSI2_VCDT_VCDTN_EN (1 << 15)
+ #define RCAR_CSI2_VCDT_SEL_VCN (1 << 8)
+-#define RCAR_CSI2_VCDT_SEL_DTN_ON (1 << 6)
++#define RCAR_CSI2_VCDT_SEL_DTN_ON (0 << 6)
+ #define RCAR_CSI2_VCDT_SEL_DTN (1 << 0)
+
+ #define RCAR_CSI2_LINKCNT_MONITOR_EN (1 << 31)
@@ -106,6 +112,9 @@
#define RCAR_CSI2_LSWAP_L0SEL_PLANE2 (2 << 0)
#define RCAR_CSI2_LSWAP_L0SEL_PLANE3 (3 << 0)
@@ -7865,7 +17218,7 @@ index 4d95da6..2ef27e8 100644
}
return ret;
-@@ -543,18 +642,19 @@ static int rcar_csi2_parse_dt(struct device_node *np,
+@@ -543,39 +642,30 @@ static int rcar_csi2_parse_dt(struct device_node *np,
return -EINVAL;
v4l2_of_parse_endpoint(endpoint, &bus_cfg);
@@ -7891,25 +17244,42 @@ index 4d95da6..2ef27e8 100644
for (i = 0; i < VC_MAX_CHANNEL; i++) {
sprintf(csi_name, "csi2_vc%d", i);
-@@ -573,6 +673,8 @@ static int rcar_csi2_parse_dt(struct device_node *np,
- config->vcdt |= (0x24 << (i * 16));
- else if (!strcmp(str, "ycbcr422"))
- config->vcdt |= (0x1e << (i * 16));
-+ else if (!strcmp(str, "raw8"))
-+ config->vcdt |= (0x2a << (i * 16));
- else
- config->vcdt |= 0;
+ vc_ch = of_get_child_by_name(vc_np, csi_name);
+ if (!vc_ch)
+ continue;
+- ret = of_property_read_string(vc_ch, "data,type", &str);
+- if (ret < 0)
+- return ret;
+ ret = of_property_read_u32(vc_ch, "receive,vc", &ch);
+ if (ret < 0)
+ return ret;
-@@ -587,6 +689,8 @@ static int rcar_csi2_parse_dt(struct device_node *np,
- config->vcdt2 |= (0x24 << (j * 16));
- else if (!strcmp(str, "ycbcr422"))
- config->vcdt2 |= (0x1e << (j * 16));
-+ else if (!strcmp(str, "raw8"))
-+ config->vcdt2 |= (0x2a << (j * 16));
- else
- config->vcdt2 |= 0;
+ if (i < 2) {
+- if (!strcmp(str, "rgb888"))
+- config->vcdt |= (0x24 << (i * 16));
+- else if (!strcmp(str, "ycbcr422"))
+- config->vcdt |= (0x1e << (i * 16));
+- else
+- config->vcdt |= 0;
+-
+ config->vcdt |= (ch << (8 + (i * 16)));
+ config->vcdt |= (RCAR_CSI2_VCDT_VCDTN_EN << (i * 16)) |
+ (RCAR_CSI2_VCDT_SEL_DTN_ON << (i * 16));
+@@ -583,13 +673,6 @@ static int rcar_csi2_parse_dt(struct device_node *np,
+ if (i >= 2) {
+ int j = (i - 2);
-@@ -608,6 +712,7 @@ static int rcar_csi2_probe(struct platform_device *pdev)
+- if (!strcmp(str, "rgb888"))
+- config->vcdt2 |= (0x24 << (j * 16));
+- else if (!strcmp(str, "ycbcr422"))
+- config->vcdt2 |= (0x1e << (j * 16));
+- else
+- config->vcdt2 |= 0;
+-
+ config->vcdt2 |= (ch << (8 + (j * 16)));
+ config->vcdt2 |= (RCAR_CSI2_VCDT_VCDTN_EN << (j * 16)) |
+ (RCAR_CSI2_VCDT_SEL_DTN_ON << (j * 16));
+@@ -608,6 +691,7 @@ static int rcar_csi2_probe(struct platform_device *pdev)
/* Platform data specify the PHY, lanes, ECC, CRC */
struct rcar_csi2_pdata *pdata;
struct rcar_csi2_link_config link_config;
@@ -7917,7 +17287,7 @@ index 4d95da6..2ef27e8 100644
dev_dbg(&pdev->dev, "CSI2 probed.\n");
-@@ -618,12 +723,7 @@ static int rcar_csi2_probe(struct platform_device *pdev)
+@@ -618,12 +702,7 @@ static int rcar_csi2_probe(struct platform_device *pdev)
if (ret)
return ret;
@@ -7931,7 +17301,7 @@ index 4d95da6..2ef27e8 100644
} else {
pdata = pdev->dev.platform_data;
if (!pdata)
-@@ -655,23 +755,27 @@ static int rcar_csi2_probe(struct platform_device *pdev)
+@@ -655,23 +734,27 @@ static int rcar_csi2_probe(struct platform_device *pdev)
return ret;
priv->pdev = pdev;
@@ -7969,7 +17339,7 @@ index 4d95da6..2ef27e8 100644
spin_lock_init(&priv->lock);
-@@ -684,10 +788,11 @@ static int rcar_csi2_probe(struct platform_device *pdev)
+@@ -684,10 +767,11 @@ static int rcar_csi2_probe(struct platform_device *pdev)
static int rcar_csi2_remove(struct platform_device *pdev)
{
@@ -7985,7 +17355,7 @@ index 4d95da6..2ef27e8 100644
return 0;
diff --git a/drivers/media/platform/soc_camera/rcar_vin.c b/drivers/media/platform/soc_camera/rcar_vin.c
-index 74fb005..ac75af6 100644
+index 74fb005..f6119e5 100644
--- a/drivers/media/platform/soc_camera/rcar_vin.c
+++ b/drivers/media/platform/soc_camera/rcar_vin.c
@@ -95,17 +95,21 @@
@@ -8150,7 +17520,7 @@ index 74fb005..ac75af6 100644
while (priv->state != STOPPED) {
/* issue stop if running */
if (priv->state == RUNNING)
-@@ -1361,6 +1422,31 @@ static struct v4l2_subdev *find_csi2(struct rcar_vin_priv *pcdev)
+@@ -1361,6 +1422,26 @@ static struct v4l2_subdev *find_csi2(struct rcar_vin_priv *pcdev)
return NULL;
}
@@ -8158,8 +17528,7 @@ index 74fb005..ac75af6 100644
+{
+ struct v4l2_subdev *sd;
+ char name[] = "max9286";
-+ char name2[] = "ti964_ti9x3";
-+ char name3[] = "ti954_ti9x3";
++ char name2[] = "ti9x4";
+
+ v4l2_device_for_each_subdev(sd, &pcdev->ici.v4l2_dev) {
+ if (!strncmp(name, sd->name, sizeof(name) - 1)) {
@@ -8170,10 +17539,6 @@ index 74fb005..ac75af6 100644
+ pcdev->deser_sd = sd;
+ return sd;
+ }
-+ if (!strncmp(name3, sd->name, sizeof(name3) - 1)) {
-+ pcdev->deser_sd = sd;
-+ return sd;
-+ }
+ }
+
+ return NULL;
@@ -8182,7 +17547,7 @@ index 74fb005..ac75af6 100644
static int rcar_vin_add_device(struct soc_camera_device *icd)
{
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-@@ -1375,7 +1461,8 @@ static int rcar_vin_add_device(struct soc_camera_device *icd)
+@@ -1375,7 +1456,8 @@ static int rcar_vin_add_device(struct soc_camera_device *icd)
if (priv->chip == RCAR_H3 || priv->chip == RCAR_M3 ||
priv->chip == RCAR_V3M) {
struct v4l2_subdev *csi2_sd = find_csi2(priv);
@@ -8192,7 +17557,7 @@ index 74fb005..ac75af6 100644
if (csi2_sd) {
csi2_sd->grp_id = soc_camera_grp_id(icd);
-@@ -1390,6 +1477,18 @@ static int rcar_vin_add_device(struct soc_camera_device *icd)
+@@ -1390,6 +1472,18 @@ static int rcar_vin_add_device(struct soc_camera_device *icd)
if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
return ret;
}
@@ -8211,7 +17576,7 @@ index 74fb005..ac75af6 100644
/*
* -ENODEV is special:
* either csi2_sd == NULL or the CSI-2 driver
-@@ -1417,6 +1516,7 @@ static void rcar_vin_remove_device(struct soc_camera_device *icd)
+@@ -1417,6 +1511,7 @@ static void rcar_vin_remove_device(struct soc_camera_device *icd)
struct rcar_vin_priv *priv = ici->priv;
struct vb2_v4l2_buffer *vbuf;
struct v4l2_subdev *csi2_sd = find_csi2(priv);
@@ -8219,7 +17584,7 @@ index 74fb005..ac75af6 100644
int i;
/* disable capture, disable interrupts */
-@@ -1443,6 +1543,8 @@ static void rcar_vin_remove_device(struct soc_camera_device *icd)
+@@ -1443,6 +1538,8 @@ static void rcar_vin_remove_device(struct soc_camera_device *icd)
if ((csi2_sd) && (priv->csi_sync))
v4l2_subdev_call(csi2_sd, core, s_power, 0);
@@ -8228,7 +17593,7 @@ index 74fb005..ac75af6 100644
dev_dbg(icd->parent, "R-Car VIN driver detached from camera %d\n",
icd->devnum);
-@@ -1621,13 +1723,19 @@ static int rcar_vin_set_rect(struct soc_camera_device *icd)
+@@ -1621,13 +1718,19 @@ static int rcar_vin_set_rect(struct soc_camera_device *icd)
if (priv->chip == RCAR_H3 || priv->chip == RCAR_M3 ||
priv->chip == RCAR_V3M) {
@@ -8250,7 +17615,7 @@ index 74fb005..ac75af6 100644
(icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_NV16) ||
(icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_NV12))
iowrite32(ALIGN(cam->out_width, 0x20),
-@@ -1868,6 +1976,14 @@ static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
+@@ -1868,6 +1971,14 @@ static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
.layout = SOC_MBUS_LAYOUT_PACKED,
},
{
@@ -8265,7 +17630,7 @@ index 74fb005..ac75af6 100644
.fourcc = V4L2_PIX_FMT_RGB565,
.name = "RGB565",
.bits_per_sample = 16,
-@@ -1899,6 +2015,22 @@ static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
+@@ -1899,6 +2010,22 @@ static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
.order = SOC_MBUS_ORDER_LE,
.layout = SOC_MBUS_LAYOUT_PACKED,
},
@@ -8288,7 +17653,7 @@ index 74fb005..ac75af6 100644
};
static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
-@@ -2012,6 +2144,8 @@ static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
+@@ -2012,6 +2139,8 @@ static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
case MEDIA_BUS_FMT_YUYV8_2X8:
case MEDIA_BUS_FMT_YUYV10_2X10:
case MEDIA_BUS_FMT_RGB888_1X24:
@@ -8297,7 +17662,7 @@ index 74fb005..ac75af6 100644
if (cam->extra_fmt)
break;
-@@ -2218,12 +2352,15 @@ static int rcar_vin_set_fmt(struct soc_camera_device *icd,
+@@ -2218,12 +2347,15 @@ static int rcar_vin_set_fmt(struct soc_camera_device *icd,
case V4L2_PIX_FMT_ABGR32:
case V4L2_PIX_FMT_UYVY:
case V4L2_PIX_FMT_YUYV:
@@ -8313,7 +17678,7 @@ index 74fb005..ac75af6 100644
default:
can_scale = false;
break;
-@@ -2316,7 +2453,8 @@ static int rcar_vin_try_fmt(struct soc_camera_device *icd,
+@@ -2316,7 +2448,8 @@ static int rcar_vin_try_fmt(struct soc_camera_device *icd,
/* odd number clipping by pixel post clip processing, */
/* it is outputted to a memory per even pixels. */
if ((pixfmt == V4L2_PIX_FMT_NV16) || (pixfmt == V4L2_PIX_FMT_NV12) ||
@@ -8323,7 +17688,7 @@ index 74fb005..ac75af6 100644
v4l_bound_align_image(&pix->width, 5, priv->max_width, 1,
&pix->height, 2, priv->max_height, 0, 0);
else
-@@ -2486,6 +2624,19 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
+@@ -2486,6 +2619,19 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
}
#endif
@@ -8343,7 +17708,7 @@ index 74fb005..ac75af6 100644
static struct soc_camera_host_ops rcar_vin_host_ops = {
.owner = THIS_MODULE,
.add = rcar_vin_add_device,
-@@ -2504,6 +2655,7 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
+@@ -2504,6 +2650,7 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
.get_selection = rcar_vin_get_selection,
.cropcap = rcar_vin_cropcap,
#endif
@@ -8351,7 +17716,7 @@ index 74fb005..ac75af6 100644
};
#ifdef CONFIG_OF
-@@ -2524,7 +2676,7 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
+@@ -2524,7 +2671,7 @@ static int rcar_vin_cropcap(struct soc_camera_device *icd,
MODULE_DEVICE_TABLE(of, rcar_vin_of_table);
#endif
@@ -8360,19 +17725,18 @@ index 74fb005..ac75af6 100644
static DECLARE_BITMAP(device_map, MAP_MAX_NUM);
static DEFINE_MUTEX(list_lock);
-@@ -2714,7 +2866,11 @@ static int rcar_vin_probe(struct platform_device *pdev)
+@@ -2714,7 +2861,10 @@ static int rcar_vin_probe(struct platform_device *pdev)
const char *str;
unsigned int i;
struct device_node *epn = NULL, *ren = NULL;
-+ struct device_node *csi2_ren = NULL, *max9286_ren = NULL, *ti964_ren = NULL, *ti954_ren = NULL;
++ struct device_node *csi2_ren = NULL, *max9286_ren = NULL, *ti9x4_ren = NULL;
bool csi_use = false;
+ bool max9286_use = false;
-+ bool ti964_use = false;
-+ bool ti954_use = false;
++ bool ti9x4_use = false;
match = of_match_device(of_match_ptr(rcar_vin_of_table), &pdev->dev);
-@@ -2741,13 +2897,27 @@ static int rcar_vin_probe(struct platform_device *pdev)
+@@ -2741,13 +2891,22 @@ static int rcar_vin_probe(struct platform_device *pdev)
dev_dbg(&pdev->dev, "node name:%s\n",
of_node_full_name(ren->parent));
@@ -8390,21 +17754,16 @@ index 74fb005..ac75af6 100644
- if (i)
- break;
-+ if (strcmp(ren->parent->name, "ti964-ti9x3") == 0) {
-+ ti964_ren = of_parse_phandle(epn, "remote-endpoint", 0);
-+ ti964_use = true;
-+ }
-+
-+ if (strcmp(ren->parent->name, "ti954-ti9x3") == 0) {
-+ ti954_ren = of_parse_phandle(epn, "remote-endpoint", 0);
-+ ti954_use = true;
++ if (strcmp(ren->parent->name, "ti9x4") == 0) {
++ ti9x4_ren = of_parse_phandle(epn, "remote-endpoint", 0);
++ ti9x4_use = true;
+ }
+
+ of_node_put(ren);
}
ret = v4l2_of_parse_endpoint(np, &ep);
-@@ -2799,6 +2969,7 @@ static int rcar_vin_probe(struct platform_device *pdev)
+@@ -2799,6 +2958,7 @@ static int rcar_vin_probe(struct platform_device *pdev)
priv->ici.drv_name = dev_name(&pdev->dev);
priv->ici.ops = &rcar_vin_host_ops;
priv->csi_sync = false;
@@ -8412,7 +17771,7 @@ index 74fb005..ac75af6 100644
priv->pdata_flags = pdata_flags;
if (!match) {
-@@ -2983,7 +3154,25 @@ static int rcar_vin_probe(struct platform_device *pdev)
+@@ -2983,7 +3143,19 @@ static int rcar_vin_probe(struct platform_device *pdev)
goto cleanup;
if (csi_use) {
@@ -8428,19 +17787,13 @@ index 74fb005..ac75af6 100644
+ goto cleanup;
+ }
+
-+ if (ti964_use) {
-+ ret = rcar_vin_soc_of_bind(priv, &priv->ici, epn, ti964_ren);
-+ if (ret)
-+ goto cleanup;
-+ }
-+
-+ if (ti954_use) {
-+ ret = rcar_vin_soc_of_bind(priv, &priv->ici, epn, ti954_ren);
++ if (ti9x4_use) {
++ ret = rcar_vin_soc_of_bind(priv, &priv->ici, epn, ti9x4_ren);
if (ret)
goto cleanup;
}
diff --git a/drivers/media/platform/soc_camera/soc_camera.c b/drivers/media/platform/soc_camera/soc_camera.c
-index edd1c1d..54f4c9d 100644
+index edd1c1d..ae04c6e 100644
--- a/drivers/media/platform/soc_camera/soc_camera.c
+++ b/drivers/media/platform/soc_camera/soc_camera.c
@@ -49,7 +49,7 @@
@@ -8452,7 +17805,7 @@ index edd1c1d..54f4c9d 100644
static DECLARE_BITMAP(device_map, MAP_MAX_NUM);
static LIST_HEAD(hosts);
static LIST_HEAD(devices);
-@@ -1106,6 +1106,18 @@ static int soc_camera_s_parm(struct file *file, void *fh,
+@@ -1106,6 +1106,44 @@ static int soc_camera_s_parm(struct file *file, void *fh,
return -ENOIOCTLCMD;
}
@@ -8468,10 +17821,36 @@ index edd1c1d..54f4c9d 100644
+ return -ENOIOCTLCMD;
+}
+
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++static int soc_camera_g_register(struct file *file, void *priv,
++ struct v4l2_dbg_register *reg)
++{
++ struct soc_camera_device *icd = file->private_data;
++ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
++
++ if (ici->ops->get_register)
++ return ici->ops->get_register(icd, reg);
++
++ return -ENOIOCTLCMD;
++}
++
++static int soc_camera_s_register(struct file *file, void *priv,
++ const struct v4l2_dbg_register *reg)
++{
++ struct soc_camera_device *icd = file->private_data;
++ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
++
++ if (ici->ops->set_register)
++ return ici->ops->set_register(icd, reg);
++
++ return -ENOIOCTLCMD;
++}
++#endif
++
static int soc_camera_probe(struct soc_camera_host *ici,
struct soc_camera_device *icd);
-@@ -1664,7 +1676,7 @@ static void scan_of_host(struct soc_camera_host *ici)
+@@ -1664,7 +1702,7 @@ static void scan_of_host(struct soc_camera_host *ici)
of_node_put(ren);
if (i) {
@@ -8480,16 +17859,20 @@ index edd1c1d..54f4c9d 100644
break;
}
}
-@@ -2077,6 +2089,7 @@ static int soc_camera_device_register(struct soc_camera_device *icd)
+@@ -2077,6 +2115,11 @@ static int soc_camera_device_register(struct soc_camera_device *icd)
.vidioc_s_selection = soc_camera_s_selection,
.vidioc_g_parm = soc_camera_g_parm,
.vidioc_s_parm = soc_camera_s_parm,
+ .vidioc_g_edid = soc_camera_g_edid,
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ .vidioc_g_register = soc_camera_g_register,
++ .vidioc_s_register = soc_camera_s_register,
++#endif
};
static int video_dev_create(struct soc_camera_device *icd)
diff --git a/drivers/media/platform/soc_camera/soc_mediabus.c b/drivers/media/platform/soc_camera/soc_mediabus.c
-index e3e665e..84754a4 100644
+index e3e665e..b47d515 100644
--- a/drivers/media/platform/soc_camera/soc_mediabus.c
+++ b/drivers/media/platform/soc_camera/soc_mediabus.c
@@ -57,6 +57,16 @@
@@ -8509,7 +17892,24 @@ index e3e665e..84754a4 100644
.code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
.fmt = {
.fourcc = V4L2_PIX_FMT_RGB555,
-@@ -403,6 +413,10 @@ int soc_mbus_samples_per_pixel(const struct soc_mbus_pixelfmt *mf,
+@@ -382,6 +392,16 @@
+ .order = SOC_MBUS_ORDER_LE,
+ .layout = SOC_MBUS_LAYOUT_PACKED,
+ },
++}, {
++ .code = MEDIA_BUS_FMT_SBGGR16_1X16,
++ .fmt = {
++ .fourcc = V4L2_PIX_FMT_SBGGR16,
++ .name = "Bayer 16 RGGB",
++ .bits_per_sample = 16,
++ .packing = SOC_MBUS_PACKING_NONE,
++ .order = SOC_MBUS_ORDER_LE,
++ .layout = SOC_MBUS_LAYOUT_PACKED,
++ },
+ },
+ };
+
+@@ -403,6 +423,10 @@ int soc_mbus_samples_per_pixel(const struct soc_mbus_pixelfmt *mf,
*numerator = 2;
*denominator = 1;
return 0;
@@ -8520,7 +17920,7 @@ index e3e665e..84754a4 100644
case SOC_MBUS_PACKING_1_5X8:
*numerator = 3;
*denominator = 2;
-@@ -428,6 +442,8 @@ s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf)
+@@ -428,6 +452,8 @@ s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf)
case SOC_MBUS_PACKING_2X8_PADLO:
case SOC_MBUS_PACKING_EXTEND16:
return width * 2;
@@ -8551,14 +17951,18 @@ index 2ff7737..e5f3f53 100644
SOC_MBUS_PACKING_VARIABLE,
SOC_MBUS_PACKING_1_5X8,
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
-index 1a15c3e..dad1ed8 100644
+index 1a15c3e..76e90be 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
-@@ -125,6 +125,7 @@ struct soc_camera_host_ops {
+@@ -125,6 +125,11 @@ struct soc_camera_host_ops {
int (*set_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
int (*enum_framesizes)(struct soc_camera_device *, struct v4l2_frmsizeenum *);
unsigned int (*poll)(struct file *, poll_table *);
+ int (*get_edid)(struct soc_camera_device *, struct v4l2_edid *);
++#ifdef CONFIG_VIDEO_ADV_DEBUG
++ int (*get_register)(struct soc_camera_device *, struct v4l2_dbg_register *reg);
++ int (*set_register)(struct soc_camera_device *, const struct v4l2_dbg_register *reg);
++#endif
};
#define SOCAM_SENSOR_INVERT_PCLK (1 << 0)