From: Sakari Ailus <sakari.ailus@linux.intel.com>
To: Sergey Lebedev <lsa.uz@pm.me>
Cc: "Benjamin Mugnier" <benjamin.mugnier@foss.st.com>,
"Sylvain Petinot" <sylvain.petinot@foss.st.com>,
"Mauro Carvalho Chehab" <mchehab@kernel.org>,
"Dan Scally" <dan.scally@ideasonboard.com>,
"Hans de Goede" <hansg@kernel.org>,
"Ilpo Järvinen" <ilpo.jarvinen@linux.intel.com>,
"Rob Herring" <robh@kernel.org>,
"Krzysztof Kozlowski" <krzk+dt@kernel.org>,
"Conor Dooley" <conor+dt@kernel.org>,
"Peter Marshall" <pm@petermarshall.ca>,
"George Neacsu" <geocausa@gmail.com>,
"Hao Yao" <hao.yao@intel.com>,
"Fernando Rimoli" <fernandorimoli11@gmail.com>,
"Emfox Zhou" <emfox@debian.org>,
"D. Manresa" <dmanresa@gmail.com>,
"Jizhou Tong" <fqwqf@fqwqf.xyz>,
linux-media@vger.kernel.org, platform-driver-x86@vger.kernel.org,
devicetree@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH v5 2/6] media: i2c: Add ST VD55G0 global shutter sensor driver
Date: Fri, 20 Nov 2026 13:44:08 +0200 [thread overview]
Message-ID: <awAyiCEXYnf2TJpC@kekkonen.localdomain> (raw)
In-Reply-To: <20261114095815.74012-3-lsa.uz@pm.me>
Hi Sergey,
A few comments below...
You could post a fixup on top, I'll squash it to this one then.
On Sat, Nov 14, 2026 at 09:58:38AM +0000, Sergey Lebedev wrote:
> The VD55G0 is a 644x604 monochrome global shutter sensor from
> STMicroelectronics. It streams Y8 or Y10 over one CSI-2 lane, runs its own
> auto exposure, can strobe an illuminator from its GPIOs, and needs a
> firmware patch at every power-on, carried in the driver as vd55g1 does.
>
> The driver is ported from ST's own, GPL-2.0, to current interfaces: CCI
> register access, .enable_streams with the subdev state, fwnode properties,
> devm_v4l2_sensor_clk_get(), and an ACPI match for x86 machines where the
> sensor sits behind ipu-bridge:
> https://github.com/STMicroelectronics/vd55g0-linux-driver
> ST's st,out-sync and st,in-sync and its two private controls are left out,
> as vd55g1 has none of them. The supplies keep their DT names on ACPI too,
> where int3472 maps them.
>
> The clock tree is computed from the input clock and the one link frequency
> the endpoint gives, as in vd55g1. The MIPI rate must be an integer multiple
> of the input clock, or the sensor would run at another one, so any other
> link frequency fails probe.
>
> Exposure and the two gains form an auto cluster with auto exposure, as in
> vd55g1: while auto exposure runs, they read back what the sensor applies.
>
> Co-developed-by: Benjamin Mugnier <benjamin.mugnier@foss.st.com>
> Signed-off-by: Benjamin Mugnier <benjamin.mugnier@foss.st.com>
> Signed-off-by: Sergey Lebedev <lsa.uz@pm.me>
> ---
> v5: no change.
> v4: Sakari's review. The controls hold the settings, applied with
> __v4l2_ctrl_handler_setup() at stream start and written by s_ctrl only
> while powered; the subdev state holds the format and crop;
> media_entity_is_streaming() replaces the driver's flag; one supply list,
> which 3/6 maps on ACPI; and the smaller points. g_volatile_ctrl() still
> sets ->val, as discussed on v3. Also the handler's lock is the state
> lock, hflip and vflip form a cluster, AE_TARGET_PERCENTAGE is written as
> 16 bits, and LINE_LENGTH is written at stream start from the crop and
> HBLANK. pm_runtime_dont_use_autosuspend() is no longer called: the core
> does it since d1706f9da9f4, as Joshua Crofts's vd55g1 patch says.
> v3: Sashiko's three points on v2 (auto exposure readback after a
> stream, the runtime PM reference across probe, RUNTIME_PM_OPS() and
> pm_ptr()); registration through v4l2_async_register_subdev_sensor()
> (Jizhou Tong), with dev_err_probe() on failure.
> v2: no code change; MAINTAINERS no longer lists a binding for it.
>
> MAINTAINERS | 9 +
> drivers/media/i2c/Kconfig | 11 +
> drivers/media/i2c/Makefile | 1 +
> drivers/media/i2c/vd55g0.c | 2232 ++++++++++++++++++++++++++++++++++++
> 4 files changed, 2253 insertions(+)
> create mode 100644 drivers/media/i2c/vd55g0.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index af302622c84..1d8543a3f4f 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -26592,6 +26592,14 @@ F: Documentation/devicetree/bindings/hwmon/st,tsc1641.yaml
> F: Documentation/hwmon/tsc1641.rst
> F: drivers/hwmon/tsc1641.c
>
> +ST VD55G0 DRIVER
> +M: Benjamin Mugnier <benjamin.mugnier@foss.st.com>
> +M: Sergey Lebedev <lsa.uz@pm.me>
> +M: Sylvain Petinot <sylvain.petinot@foss.st.com>
> +L: linux-media@vger.kernel.org
> +S: Maintained
> +F: drivers/media/i2c/vd55g0.c
> +
> ST VD55G1 DRIVER
> M: Benjamin Mugnier <benjamin.mugnier@foss.st.com>
> M: Sylvain Petinot <sylvain.petinot@foss.st.com>
> @@ -29317,6 +29325,7 @@ F: drivers/media/i2c/mt*
> F: drivers/media/i2c/og*
> F: drivers/media/i2c/ov*
> F: drivers/media/i2c/s5*
> +F: drivers/media/i2c/vd55g0.c
> F: drivers/media/i2c/vd55g1.c
> F: drivers/media/i2c/vd56g3.c
> F: drivers/media/i2c/vgxy61.c
> diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> index 11c30252540..f8a653154de 100644
> --- a/drivers/media/i2c/Kconfig
> +++ b/drivers/media/i2c/Kconfig
> @@ -891,6 +891,17 @@ config VIDEO_T4KA3
> To compile this driver as a module, choose M here: the
> module will be called t4ka3.
>
> +config VIDEO_VD55G0
> + tristate "ST VD55G0 sensor support"
> + select V4L2_CCI_I2C
> + depends on GPIOLIB
> + help
> + This is a Video4Linux2 sensor driver for the ST VD55G0
> + camera sensor.
> +
> + To compile this driver as a module, choose M here: the
> + module will be called vd55g0.
> +
> config VIDEO_VD55G1
> tristate "ST VD55G1 sensor support"
> select V4L2_CCI_I2C
> diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> index 59e31af457c..a7e990ec650 100644
> --- a/drivers/media/i2c/Makefile
> +++ b/drivers/media/i2c/Makefile
> @@ -171,6 +171,7 @@ obj-$(CONFIG_VIDEO_TW9910) += tw9910.o
> obj-$(CONFIG_VIDEO_UDA1342) += uda1342.o
> obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o
> obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
> +obj-$(CONFIG_VIDEO_VD55G0) += vd55g0.o
> obj-$(CONFIG_VIDEO_VD55G1) += vd55g1.o
> obj-$(CONFIG_VIDEO_VD56G3) += vd56g3.o
> obj-$(CONFIG_VIDEO_VGXY61) += vgxy61.o
> diff --git a/drivers/media/i2c/vd55g0.c b/drivers/media/i2c/vd55g0.c
> new file mode 100644
> index 00000000000..99bfb05225d
> --- /dev/null
> +++ b/drivers/media/i2c/vd55g0.c
> @@ -0,0 +1,2232 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Driver for the ST VD55G0 global shutter sensor
> + *
> + * Copyright (C) 2026 STMicroelectronics SA
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/iopoll.h>
> +#include <linux/module.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/regmap.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/units.h>
> +
> +#include <media/mipi-csi2.h>
> +#include <media/v4l2-async.h>
> +#include <media/v4l2-cci.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-fwnode.h>
> +#include <media/v4l2-rect.h>
> +#include <media/v4l2-subdev.h>
> +
> +#define VD55G0_REG_MODEL_ID CCI_REG16_LE(0x0000)
> +#define VD55G0_MODEL_ID 0x4730
> +#define VD55G0_REG_REVISION CCI_REG16_LE(0x0004)
> +#define VD55G0_REVISION_CUT1 0x1111
> +#define VD55G0_REVISION_CUT2 0x1120
> +#define VD55G0_REG_FWPATCH_REVISION CCI_REG16_LE(0x0022)
> +#define VD55G0_REG_FWPATCH_START_ADDR CCI_REG8(0x2000)
> +#define VD55G0_REG_SYSTEM_FSM CCI_REG8(0x002c)
> +#define VD55G0_SYSTEM_FSM_READY_TO_BOOT 0x01
> +#define VD55G0_SYSTEM_FSM_SW_STBY 0x02
> +#define VD55G0_SYSTEM_FSM_STREAMING 0x03
> +#define VD55G0_REG_BOOT CCI_REG8(0x0200)
> +#define VD55G0_BOOT_BOOT 1
> +#define VD55G0_BOOT_PATCH_SETUP 2
> +#define VD55G0_REG_SW_STBY CCI_REG8(0x0201)
> +#define VD55G0_SW_STBY_START_STREAM 1
> +#define VD55G0_REG_STREAMING CCI_REG8(0x0202)
> +#define VD55G0_STREAMING_STOP_STREAM 1
> +#define VD55G0_REG_EXT_CLOCK CCI_REG32_LE(0x0220)
> +#define VD55G0_REG_LINE_LENGTH CCI_REG16_LE(0x0300)
> +#define VD55G0_REG_ORIENTATION CCI_REG8(0x0302)
> +#define VD55G0_REG_FORMAT_CTRL CCI_REG8(0x030a)
> +#define VD55G0_REG_OIF_CTRL CCI_REG16_LE(0x030c)
> +#define VD55G0_REG_OIF_IMG_CTRL CCI_REG8(0x030f)
> +#define VD55G0_REG_ISL_ENABLE CCI_REG8(0x0329)
> +#define VD55G0_REG_CLK_PLL_MIPI CCI_REG32_LE(0x0224)
> +#define VD55G0_REG_PATGEN_CTRL CCI_REG16_LE(0x0400)
> +#define VD55G0_PATGEN_TYPE_SHIFT 4
> +#define VD55G0_PATGEN_ENABLE BIT(0)
> +#define VD55G0_REG_MANUAL_ANALOG_GAIN CCI_REG8(0x044d)
> +#define VD55G0_REG_MANUAL_COARSE_EXPOSURE CCI_REG16_LE(0x044e)
> +#define VD55G0_REG_MANUAL_DIGITAL_GAIN CCI_REG16_LE(0x0450)
> +#define VD55G0_REG_APPLIED_COARSE_EXPOSURE CCI_REG16_LE(0x0064)
> +#define VD55G0_REG_APPLIED_ANALOG_GAIN CCI_REG8(0x0066)
> +#define VD55G0_REG_APPLIED_DIGITAL_GAIN CCI_REG16_LE(0x0068)
> +#define VD55G0_REG_AE_COLDSTART_COARSE_EXPOSURE CCI_REG16_LE(0x042e)
> +#define VD55G0_REG_AE_COLDSTART_ANALOG_GAIN CCI_REG8(0x0430)
> +#define VD55G0_REG_AE_COLDSTART_DIGITAL_GAIN CCI_REG16_LE(0x0432)
> +#define VD55G0_REG_EXP_MODE CCI_REG8(0x044c)
> +#define VD55G0_REG_FRAME_LENGTH CCI_REG16_LE(0x0458)
> +#define VD55G0_REG_ROI_X_START CCI_REG16_LE(0x045e)
> +#define VD55G0_REG_ROI_X_END CCI_REG16_LE(0x0460)
> +#define VD55G0_REG_ROI_Y_START CCI_REG16_LE(0x0462)
> +#define VD55G0_REG_ROI_Y_END CCI_REG16_LE(0x0464)
> +#define VD55G0_REG_AE_ROI_START_H CCI_REG16_LE(0x0436)
> +#define VD55G0_REG_AE_ROI_START_V CCI_REG16_LE(0x0438)
> +#define VD55G0_REG_AE_ROI_END_H CCI_REG16_LE(0x043a)
> +#define VD55G0_REG_AE_ROI_END_V CCI_REG16_LE(0x043c)
> +#define VD55G0_REG_GPIO_0_CTRL CCI_REG8(0x0467)
> +#define VD55G0_REG_READOUT_CTRL CCI_REG8(0x047a)
> +#define VD55G0_REG_DARKCAL_CTRL CCI_REG8(0x032c)
> +#define VD55G0_DARKCAL_BYPASS 0
> +#define VD55G0_DARKCAL_AUTO 1
> +#define VD55G0_REG_DUSTER_CTRL CCI_REG8(0x0316)
> +#define VD55G0_DUSTER_ENABLE BIT(0)
> +#define VD55G0_DUSTER_DISABLE 0
> +#define VD55G0_DUSTER_DYN_ENABLE BIT(1)
> +#define VD55G0_DUSTER_RING_ENABLE BIT(4)
> +#define VD55G0_REG_AE_TARGET_PERCENTAGE CCI_REG16_LE(0x0440)
> +
> +#define VD55G0_WIDTH 644
> +#define VD55G0_HEIGHT 604
> +#define VD55G0_DEFAULT_MODE 1
> +#define VD55G0_WRITE_MULTIPLE_CHUNK_MAX 16U
> +#define VD55G0_NB_GPIOS 4
> +#define VD55G0_MIN_FRAME_LENGTH (605 + 76)
> +#define VD55G0_FRAME_LENGTH_DEF 1860
> +#define VD55G0_TIMEOUT_MS 500
> +#define VD55G0_MEDIA_BUS_FMT_DEF MEDIA_BUS_FMT_Y8_1X8
> +#define VD55G0_EXPO_MAX_TERM 64
> +#define VD55G0_EXPO_DEF 200
> +#define VD55G0_LINE_LENGTH_SLOW 1200
> +#define VD55G0_LINE_LENGTH_FAST 1128
> +#define VD55G0_XCLK_FREQ_MIN (6 * HZ_PER_MHZ)
> +#define VD55G0_XCLK_FREQ_MAX (27 * HZ_PER_MHZ)
> +#define VD55G0_MIPI_RATE_MIN (750 * MEGA)
> +#define VD55G0_MIPI_RATE_MAX (1200 * MEGA)
> +#define VD55G0_MIPI_RATE_FAST (900 * MEGA)
> +
> +static const u8 cut1_patch[] = {
> + 0x81, 0x06, 0x0b, 0x02, 0x00, 0x09, 0x42, 0x00, 0xd2, 0x08, 0x42, 0x00,
> + 0xe6, 0x08, 0x42, 0x00, 0x12, 0x09, 0x42, 0x00, 0xe0, 0x3f, 0x80, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x40, 0x01, 0x60,
> + 0x10, 0x40, 0x11, 0x81, 0x16, 0x80, 0x93, 0xdd, 0x4c, 0x04, 0x04, 0xfa,
> + 0x06, 0x4c, 0x94, 0x60, 0xe6, 0x0e, 0xdc, 0xe0, 0x04, 0x18, 0x70, 0x02,
> + 0x08, 0xe7, 0xce, 0x44, 0x01, 0x60, 0x10, 0x40, 0x31, 0x85, 0x1e, 0x08,
> + 0x4e, 0x43, 0x01, 0x60, 0x10, 0xc0, 0x31, 0x40, 0x20, 0xe0, 0x04, 0x98,
> + 0x29, 0x00, 0x50, 0xeb, 0x2e, 0x84, 0x24, 0x84, 0x29, 0x86, 0x2e, 0x84,
> + 0x24, 0x84, 0x2b, 0xa1, 0x15, 0xfe, 0xd8, 0x41, 0x00, 0xe8, 0xf8, 0x47,
> + 0x00, 0xe8, 0x78, 0x44, 0x40, 0xef, 0x0a, 0x9c, 0x1a, 0x9e, 0x2a, 0xdc,
> + 0x3a, 0xde, 0x03, 0x4e, 0x7c, 0xf9, 0x13, 0x4e, 0x78, 0xf9, 0x23, 0x4e,
> + 0x74, 0xf9, 0x33, 0x4e, 0x70, 0xf9, 0x18, 0x50, 0x40, 0xef, 0x38, 0x49,
> + 0x44, 0xef, 0x04, 0x18, 0x11, 0x83, 0x11, 0x40, 0x20, 0xe0, 0x4c, 0x0c,
> + 0x04, 0xf2, 0x93, 0xdd, 0x86, 0x44, 0x88, 0xe0, 0x05, 0x04, 0x40, 0xf8,
> + 0x09, 0x00, 0x24, 0xe0, 0x4a, 0x40, 0x88, 0x60, 0x06, 0x40, 0x94, 0xe0,
> + 0x04, 0x80, 0x65, 0x86, 0x31, 0x01, 0x06, 0x02, 0x0c, 0xe1, 0x33, 0x40,
> + 0xc8, 0xe2, 0x33, 0x40, 0x70, 0xe2, 0x14, 0x84, 0x18, 0x48, 0x1b, 0xa3,
> + 0x55, 0x8a, 0x0a, 0x02, 0x08, 0x70, 0x16, 0x43, 0x58, 0xe0, 0x26, 0x08,
> + 0x00, 0x40, 0x16, 0x0a, 0x00, 0xc0, 0x41, 0x44, 0x08, 0x40, 0x06, 0x46,
> + 0x08, 0xe0, 0x51, 0x44, 0x04, 0xc0, 0x45, 0x85, 0x66, 0x02, 0x04, 0xe0,
> + 0x13, 0x40, 0x70, 0x62, 0x06, 0x02, 0x0c, 0xe1, 0x14, 0x84, 0x18, 0x48,
> + 0x1b, 0xa3, 0xb5, 0x86, 0x0a, 0x02, 0x08, 0x70, 0xa6, 0x02, 0x68, 0xe0,
> + 0x26, 0x0a, 0x00, 0x40, 0x16, 0x18, 0x00, 0xc0, 0x31, 0x01, 0xc6, 0x09,
> + 0x0c, 0xe0, 0x51, 0x44, 0x08, 0xc0, 0xc1, 0x44, 0x04, 0xc0, 0x95, 0x83,
> + 0x0a, 0x02, 0x04, 0xf0, 0x16, 0x02, 0x00, 0xc0, 0x11, 0x44, 0x08, 0xc0,
> + 0x11, 0x44, 0x04, 0x40, 0x11, 0x81, 0x33, 0x40, 0x18, 0xe3, 0x15, 0x83,
> + 0x0a, 0x02, 0x04, 0x70, 0x11, 0x81, 0x16, 0x0a, 0x00, 0x40, 0x31, 0x9d,
> + 0x51, 0x44, 0x08, 0x40, 0x06, 0x09, 0x04, 0xe0, 0x51, 0x44, 0x04, 0xc0,
> + 0x43, 0x40, 0x18, 0xe3, 0x33, 0x40, 0xc8, 0xe2, 0x13, 0x40, 0xc0, 0x62,
> + 0xa6, 0x05, 0x78, 0xe0, 0x23, 0x40, 0xd0, 0xe3, 0x93, 0xdd, 0xc3, 0xc1,
> + 0x4c, 0x04, 0x7c, 0xfa, 0x86, 0x42, 0x84, 0x60, 0x06, 0x00, 0x0c, 0xe1,
> + 0x14, 0x04, 0xf6, 0x50, 0x78, 0xe3, 0x04, 0x00, 0x26, 0x0f, 0x28, 0xe2,
> + 0x16, 0x15, 0x2c, 0x64, 0xb1, 0xbb, 0x6a, 0x84, 0x0b, 0xa3, 0x36, 0x10,
> + 0x10, 0x41, 0x2e, 0x54, 0x08, 0xd8, 0x16, 0x4f, 0x44, 0x43, 0x06, 0x16,
> + 0x00, 0xc0, 0x0b, 0x10, 0x1b, 0x8c, 0xb8, 0x4f, 0x00, 0x6f, 0xa4, 0x12,
> + 0x80, 0xfb, 0x06, 0x42, 0x1a, 0x60, 0x00, 0x40, 0xfc, 0x73, 0x03, 0xc0,
> + 0x83, 0x22, 0x0e, 0x02, 0xc1, 0x7f, 0x1f, 0xc0, 0x87, 0xd4, 0x8f, 0x02,
> + 0x1b, 0x8c, 0x8f, 0x20, 0x0b, 0x8e, 0x98, 0x4e, 0x00, 0xef, 0x06, 0x42,
> + 0x1a, 0x60, 0x00, 0x40, 0xfc, 0xf0, 0x73, 0xa2, 0x77, 0xcc, 0x70, 0x42,
> + 0x01, 0x73, 0xff, 0xc7, 0x12, 0x4e, 0x80, 0x79, 0x0b, 0x92, 0xb8, 0x4d,
> + 0x00, 0x6f, 0x1b, 0x8c, 0x06, 0x42, 0x94, 0x60, 0x06, 0x46, 0x1a, 0xe0,
> + 0x24, 0x04, 0x00, 0x40, 0xfd, 0x73, 0x03, 0xc0, 0xa3, 0xa6, 0xa7, 0xd4,
> + 0xb3, 0x44, 0x60, 0xe3, 0x85, 0x44, 0x9c, 0xe0, 0x24, 0x84, 0x75, 0x44,
> + 0xa0, 0x60, 0x0e, 0x04, 0xc0, 0x7f, 0x1f, 0xc0, 0x14, 0x04, 0xaf, 0x84,
> + 0xaf, 0xa0, 0xa5, 0x42, 0xa4, 0xe0, 0x4c, 0x0c, 0x7c, 0xf2, 0x93, 0xdd,
> + 0x0c, 0x04, 0x0c, 0xfa, 0x46, 0x0d, 0xcc, 0xe0, 0x09, 0x0c, 0xbc, 0xee,
> + 0x0a, 0x40, 0x80, 0xe0, 0x45, 0x82, 0xa6, 0x40, 0x08, 0xe0, 0x06, 0x98,
> + 0x08, 0x7f, 0x74, 0xef, 0x0b, 0xa1, 0xb5, 0xfe, 0x01, 0x87, 0x06, 0x98,
> + 0x06, 0x4c, 0x94, 0x60, 0x06, 0x42, 0x0c, 0xe0, 0x05, 0x0c, 0x14, 0xe0,
> + 0x11, 0x40, 0x30, 0x62, 0x26, 0x42, 0x00, 0xe0, 0x05, 0x0c, 0x14, 0xe0,
> + 0x11, 0x40, 0xa0, 0x62, 0x56, 0x43, 0x04, 0xe0, 0x05, 0x0c, 0x14, 0xe0,
> + 0x11, 0x40, 0x40, 0x62, 0x76, 0x43, 0x04, 0xe0, 0x05, 0x0c, 0x14, 0xe0,
> + 0x11, 0x40, 0x50, 0xe2, 0x04, 0x98, 0x19, 0x00, 0x50, 0xeb, 0x4a, 0x42,
> + 0x88, 0xe0, 0xc5, 0x80, 0x28, 0x67, 0x54, 0x6f, 0x66, 0x00, 0xa0, 0xe0,
> + 0x04, 0x98, 0x19, 0x00, 0x30, 0xe0, 0x19, 0xc4, 0x11, 0x40, 0x30, 0x60,
> + 0x11, 0x83, 0x04, 0x9a, 0x11, 0x40, 0x10, 0xe0, 0x04, 0x98, 0x11, 0x40,
> + 0x20, 0x60, 0x11, 0x81, 0x04, 0x98, 0x11, 0x40, 0xb0, 0xe7, 0x19, 0x00,
> + 0x50, 0xeb, 0x4a, 0x02, 0x0c, 0xfc, 0x85, 0xfe, 0xc6, 0x4c, 0xb4, 0xe0,
> + 0x60, 0x10, 0xb1, 0x64, 0x01, 0xc0, 0x0a, 0xe0, 0x0b, 0xa1, 0x95, 0x8c,
> + 0x04, 0xe0, 0x0b, 0xa1, 0x25, 0x8c, 0xd8, 0x43, 0x5c, 0xef, 0x0a, 0xe0,
> + 0x0b, 0xa1, 0x95, 0x8a, 0x04, 0xe0, 0x0b, 0xa1, 0x25, 0x8a, 0xc6, 0x4e,
> + 0x84, 0xe0, 0x04, 0x9c, 0x09, 0x00, 0x20, 0xe1, 0x4a, 0x40, 0x80, 0xe0,
> + 0x25, 0x86, 0x08, 0x22, 0x46, 0x43, 0x00, 0xe0, 0x06, 0x40, 0x06, 0xe0,
> + 0x63, 0x80, 0x09, 0x0c, 0x40, 0xe2, 0x09, 0x86, 0x0b, 0xa5, 0xd5, 0x82,
> + 0x68, 0x4e, 0x48, 0x6f, 0x01, 0x85, 0x78, 0x44, 0x48, 0x6f, 0x06, 0x00,
> + 0x80, 0xe1, 0xf8, 0x75, 0x4c, 0x6f, 0x06, 0x00, 0x80, 0xe1, 0x78, 0x48,
> + 0x48, 0xef, 0x09, 0x0e, 0x48, 0xe0, 0x0b, 0xa1, 0xb5, 0x80, 0x58, 0x7b,
> + 0x3c, 0xef, 0x78, 0x74, 0x40, 0xef, 0xa6, 0x40, 0x08, 0xe0, 0x0c, 0x0c,
> + 0x0c, 0xf2, 0x18, 0x12, 0x50, 0xff, 0xc3, 0xc1, 0x4c, 0x04, 0x04, 0xfa,
> + 0x7b, 0x00, 0x06, 0x01, 0x08, 0xe1, 0x08, 0x00, 0x6b, 0x82, 0x0b, 0xa1,
> + 0x15, 0x82, 0xa6, 0x41, 0x84, 0xe0, 0x18, 0x00, 0x01, 0x89, 0x18, 0x42,
> + 0x00, 0xef, 0x63, 0x80, 0x04, 0x1c, 0x64, 0x02, 0x84, 0xe0, 0x78, 0x40,
> + 0x00, 0x68, 0x00, 0x00, 0x40, 0xe6, 0x4c, 0x0c, 0x04, 0xf2, 0x93, 0xdd,
> + 0x1e, 0x80, 0x93, 0xdd, 0x0c, 0x04, 0x3c, 0xfa, 0xf0, 0x1e, 0x40, 0x6c,
> + 0x86, 0x0f, 0xe0, 0xe0, 0x01, 0x05, 0x91, 0x81, 0x06, 0x02, 0x00, 0x62,
> + 0x81, 0xb1, 0x01, 0x4e, 0xd8, 0x69, 0x0e, 0x00, 0x00, 0x60, 0x01, 0xc0,
> + 0x0e, 0x7c, 0x6b, 0x9e, 0x93, 0x4e, 0x14, 0x65, 0x86, 0x00, 0x30, 0xe1,
> + 0x93, 0x4e, 0x18, 0x65, 0x2b, 0x8c, 0x91, 0x4e, 0x50, 0xe1, 0x81, 0x4e,
> + 0xc8, 0xe9, 0x1e, 0xbe, 0x1e, 0x7e, 0x11, 0x8f, 0x9e, 0xbc, 0xd8, 0x55,
> + 0x30, 0xef, 0x06, 0x00, 0x00, 0x64, 0x46, 0x02, 0x54, 0xe1, 0x0e, 0x3e,
> + 0x06, 0x00, 0x20, 0xe0, 0x0e, 0x7e, 0x86, 0x00, 0x30, 0xe1, 0x1e, 0x7c,
> + 0x11, 0x91, 0x9e, 0x3c, 0x2b, 0x8c, 0xd8, 0x54, 0x30, 0xef, 0x06, 0x00,
> + 0x00, 0x66, 0xa1, 0x83, 0x0e, 0x3e, 0xf6, 0x41, 0xfc, 0xe9, 0x0e, 0x7e,
> + 0x06, 0x00, 0x01, 0x60, 0x20, 0xc0, 0x0e, 0x7c, 0x86, 0x00, 0x30, 0xe1,
> + 0xae, 0x3c, 0x11, 0x93, 0xc8, 0x53, 0x30, 0x6f, 0x2b, 0x8c, 0x06, 0x40,
> + 0x88, 0x60, 0xf6, 0x45, 0xfc, 0x63, 0xff, 0xc3, 0x14, 0x00, 0xf1, 0xa0,
> + 0x95, 0x4e, 0xa8, 0xe2, 0xa1, 0x4e, 0x44, 0xea, 0x81, 0x4e, 0xf0, 0x69,
> + 0x10, 0x42, 0x00, 0x7c, 0x00, 0xcc, 0x1f, 0x04, 0x21, 0x8b, 0x1e, 0x00,
> + 0x86, 0x40, 0xfc, 0xe7, 0x05, 0x4e, 0xa4, 0x62, 0xc6, 0x01, 0x5c, 0xe0,
> + 0x05, 0x4e, 0xac, 0x62, 0x9e, 0x00, 0x00, 0x60, 0x02, 0xc0, 0x05, 0x4e,
> + 0x94, 0x62, 0x86, 0x40, 0x3c, 0x60, 0x10, 0xe7, 0x0e, 0x9c, 0x09, 0x0e,
> + 0x0c, 0xe1, 0x15, 0x4e, 0x3c, 0x79, 0x06, 0x02, 0x80, 0xe0, 0x13, 0x4e,
> + 0xf4, 0x64, 0x86, 0x02, 0x00, 0x60, 0x02, 0xc0, 0x21, 0x4e, 0x5c, 0x69,
> + 0x00, 0x40, 0xc0, 0xf3, 0x1e, 0x9e, 0x01, 0x4e, 0x0c, 0xe1, 0x0c, 0x0c,
> + 0x3c, 0xf2, 0x93, 0xdd, 0xc6, 0x01, 0xcc, 0x60, 0x06, 0x42, 0x88, 0xe0,
> + 0x29, 0x00, 0x98, 0xee, 0x34, 0x84, 0x4a, 0x44, 0x80, 0x60, 0x86, 0x04,
> + 0x30, 0xe1, 0x24, 0x08, 0x30, 0x46, 0xfd, 0x73, 0xff, 0xc3, 0x3e, 0x04,
> + 0xa6, 0x08, 0xa0, 0x80, 0x34, 0x06, 0xc8, 0x9c, 0x45, 0x44, 0xa0, 0x80,
> + 0x35, 0x42, 0x00, 0x00, 0x06, 0x06, 0x00, 0xc0, 0x35, 0x44, 0xa0, 0xc0,
> + 0x35, 0x02, 0x00, 0xc0, 0x3e, 0x80, 0x93, 0xdd, 0x4c, 0x00, 0x00, 0xfa,
> + 0x88, 0x40, 0x00, 0xe8, 0x86, 0x02, 0x0c, 0xe1, 0x0e, 0x84, 0x4c, 0x08,
> + 0x00, 0xf2, 0x93, 0xdd, 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x04, 0x00, 0xf8,
> + 0xc6, 0x40, 0xb4, 0xe0, 0x00, 0x02, 0xb1, 0x64, 0x01, 0xc0, 0x2a, 0xc4,
> + 0x2b, 0xa1, 0x35, 0x92, 0x24, 0xc4, 0x2b, 0xa1, 0xc5, 0x90, 0x38, 0x06,
> + 0x46, 0x45, 0x00, 0xe0, 0x36, 0x46, 0x0a, 0xe0, 0x33, 0x80, 0x49, 0x06,
> + 0xf0, 0xe2, 0x4d, 0xe6, 0xc6, 0x40, 0x48, 0x41, 0x16, 0x02, 0x00, 0xc0,
> + 0x11, 0x40, 0x00, 0xc0, 0xd5, 0x8c, 0xc9, 0x06, 0x44, 0x62, 0x06, 0x4b,
> + 0x00, 0xe0, 0x46, 0x48, 0x16, 0x60, 0x86, 0x4a, 0xc8, 0xe0, 0x53, 0x08,
> + 0xc0, 0x58, 0x80, 0xf3, 0x49, 0x0a, 0xa4, 0xe7, 0x6b, 0x0a, 0xd8, 0xe3,
> + 0x49, 0xbe, 0xcf, 0xa8, 0xc1, 0x46, 0x44, 0xe2, 0x48, 0x86, 0xc9, 0x0a,
> + 0xa0, 0xe7, 0x46, 0x48, 0x0a, 0xe0, 0xc1, 0x46, 0x40, 0xe2, 0xcb, 0x0a,
> + 0xe0, 0x63, 0x43, 0x80, 0x63, 0x48, 0x28, 0xe1, 0x38, 0x86, 0x36, 0x46,
> + 0x0a, 0xe0, 0x33, 0x80, 0xc3, 0x46, 0x30, 0xe1, 0x18, 0x86, 0xcb, 0x0a,
> + 0xd4, 0xe3, 0x2b, 0x0a, 0xdc, 0x63, 0x16, 0x42, 0x0a, 0xe0, 0x5b, 0x0a,
> + 0xe4, 0xe3, 0xc3, 0x48, 0x24, 0x61, 0x03, 0x82, 0x23, 0x46, 0x2c, 0xe1,
> + 0x53, 0x40, 0x34, 0xe1, 0x4c, 0x0c, 0x00, 0xf0, 0x93, 0xdd, 0xc3, 0xc1,
> + 0x0c, 0x00, 0x80, 0xfa, 0x86, 0x43, 0xcc, 0x60, 0x0b, 0xa3, 0x29, 0x02,
> + 0xc4, 0xee, 0xb5, 0x84, 0x4a, 0x04, 0xfc, 0xfb, 0x45, 0x84, 0xc6, 0x40,
> + 0x84, 0xe0, 0x14, 0x82, 0x18, 0x84, 0x19, 0x86, 0x1b, 0xa5, 0x85, 0x8c,
> + 0x04, 0x80, 0x09, 0x00, 0x20, 0xe1, 0x4a, 0x40, 0x80, 0xe0, 0xc5, 0x8a,
> + 0x0c, 0x08, 0x80, 0xf2, 0x08, 0x34, 0x44, 0xff, 0x0b, 0xa5, 0x15, 0x8a,
> + 0x0a, 0x04, 0x04, 0xf0, 0xb5, 0x88, 0xc6, 0x40, 0x84, 0xe0, 0x24, 0x82,
> + 0x28, 0x88, 0x29, 0x86, 0x2b, 0xa5, 0xc5, 0x86, 0x04, 0x80, 0x09, 0x00,
> + 0x20, 0xe1, 0x4a, 0x40, 0x80, 0xe0, 0x05, 0x86, 0x09, 0x02, 0x24, 0xee,
> + 0x0b, 0xa3, 0xd5, 0x80, 0x08, 0x84, 0x0a, 0x40, 0x80, 0xe0, 0x75, 0xf8,
> + 0xf5, 0x81, 0x38, 0x72, 0x44, 0xef, 0xf8, 0x51, 0xfc, 0xef, 0x4e, 0x40,
> + 0x01, 0x60, 0x10, 0xc0, 0x08, 0x80, 0x0b, 0xa1, 0xa5, 0x80, 0x0c, 0x08,
> + 0x80, 0xf2, 0xb8, 0x11, 0xfc, 0xff, 0x0c, 0x08, 0x80, 0xf2, 0x93, 0xdd,
> + 0xcc, 0x04, 0x0c, 0xfa, 0x06, 0x4f, 0x84, 0x60, 0x86, 0x50, 0x4c, 0xe1,
> + 0x04, 0x1c, 0x80, 0x0c, 0x21, 0x6f, 0x01, 0xc0, 0xf0, 0x04, 0x50, 0x64,
> + 0x11, 0x81, 0x09, 0x00, 0x6c, 0xe0, 0x06, 0x29, 0x0b, 0x8c, 0x58, 0x4c,
> + 0x58, 0xef, 0x04, 0x9c, 0x19, 0x00, 0x6c, 0xe0, 0x10, 0x44, 0x3c, 0xf0,
> + 0x2b, 0xa3, 0x35, 0x82, 0x28, 0x2b, 0x10, 0x42, 0xbc, 0xf3, 0x27, 0xc8,
> + 0x29, 0xa0, 0x2f, 0xa2, 0x21, 0x40, 0x6c, 0xe0, 0x86, 0x43, 0xcc, 0xe0,
> + 0x29, 0x02, 0x24, 0xee, 0x2b, 0xa3, 0xd5, 0x80, 0x18, 0x84, 0x4a, 0x42,
> + 0x80, 0x60, 0x11, 0x8b, 0x65, 0x80, 0x19, 0x00, 0x70, 0xe0, 0x16, 0x29,
> + 0xf0, 0x04, 0x50, 0xe4, 0x11, 0x03, 0x0b, 0x8c, 0x28, 0x4a, 0x58, 0xef,
> + 0x04, 0x9c, 0x19, 0x00, 0x70, 0xe0, 0x10, 0x44, 0x3c, 0xf0, 0x2b, 0xa3,
> + 0x35, 0x82, 0x28, 0x2b, 0x10, 0x42, 0xbc, 0xf3, 0x27, 0xc8, 0x29, 0xa0,
> + 0x2f, 0xa2, 0x21, 0x40, 0x70, 0xe0, 0x09, 0x00, 0x74, 0x60, 0xf0, 0x04,
> + 0x50, 0xe4, 0x11, 0x85, 0x06, 0x29, 0x0b, 0x8c, 0xa8, 0x48, 0x58, 0xef,
> + 0x04, 0x9c, 0x19, 0x00, 0x74, 0xe0, 0x10, 0x44, 0x3c, 0xf0, 0x2b, 0xa3,
> + 0x35, 0x82, 0x28, 0x2b, 0x10, 0x42, 0xbc, 0xf3, 0x27, 0xc8, 0x29, 0xa0,
> + 0x2f, 0xa2, 0x21, 0x40, 0x74, 0xe0, 0x09, 0x00, 0x78, 0x60, 0xf0, 0x04,
> + 0x50, 0xe4, 0x11, 0x87, 0x06, 0x29, 0x0b, 0x8c, 0x28, 0x47, 0x58, 0xef,
> + 0x04, 0x9c, 0x19, 0x00, 0x78, 0xe0, 0x10, 0x44, 0x3c, 0xf0, 0x2b, 0xa3,
> + 0x35, 0x82, 0x28, 0x2b, 0x10, 0x42, 0xbc, 0xf3, 0x27, 0xc8, 0x29, 0xa0,
> + 0x2f, 0xa2, 0x21, 0x40, 0x78, 0xe0, 0x19, 0x0e, 0xd0, 0xe0, 0x1b, 0xa1,
> + 0x85, 0x86, 0x05, 0x00, 0x24, 0xe0, 0x1a, 0xa2, 0x04, 0x04, 0xc0, 0xe1,
> + 0x2b, 0x83, 0xd5, 0x80, 0x19, 0x10, 0x10, 0x60, 0x09, 0x9e, 0x0b, 0x83,
> + 0x85, 0x84, 0x08, 0xa0, 0x0b, 0xa1, 0x38, 0x61, 0x74, 0xcf, 0x58, 0x49,
> + 0x34, 0xef, 0x14, 0x9c, 0x25, 0x02, 0x24, 0xe0, 0x24, 0x02, 0xc0, 0x61,
> + 0x29, 0x9e, 0x18, 0x58, 0x74, 0xef, 0x55, 0x81, 0x08, 0xa0, 0x0b, 0xa1,
> + 0x48, 0x60, 0x74, 0xcf, 0x28, 0x72, 0x4c, 0x6f, 0x46, 0x01, 0x08, 0xe0,
> + 0xcc, 0x0c, 0x0c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x65, 0x5e, 0x04, 0xfa,
> + 0xf0, 0x0c, 0x10, 0xec, 0x60, 0x5e, 0x1c, 0x74, 0x61, 0x88, 0x6e, 0xbc,
> + 0xfc, 0x07, 0x80, 0xfe, 0xf0, 0x1e, 0x20, 0x6c, 0xe6, 0x40, 0x00, 0xe0,
> + 0xc8, 0x70, 0x4c, 0xef, 0x0b, 0xa1, 0xb5, 0x88, 0xc6, 0x0d, 0xdc, 0xe0,
> + 0x09, 0x0c, 0x94, 0xea, 0x0b, 0xa3, 0xf5, 0x80, 0x09, 0x0c, 0x91, 0x79,
> + 0x01, 0xc0, 0x0a, 0x40, 0x80, 0xe0, 0xe5, 0x82, 0xc8, 0x71, 0x44, 0xef,
> + 0x04, 0x18, 0x86, 0x02, 0x84, 0xe0, 0x24, 0x04, 0x31, 0x83, 0x01, 0x82,
> + 0x0e, 0x18, 0xe6, 0x00, 0x48, 0xe1, 0x36, 0x00, 0x21, 0x82, 0x2e, 0x84,
> + 0x46, 0x00, 0x2c, 0x61, 0x21, 0x83, 0x14, 0x00, 0x46, 0x40, 0x34, 0xe1,
> + 0x25, 0x42, 0x44, 0xe0, 0x28, 0x51, 0x28, 0xef, 0x88, 0x40, 0x00, 0xe8,
> + 0xf1, 0x90, 0xfc, 0x0f, 0x80, 0xf6, 0xf4, 0xbc, 0x64, 0xfd, 0x53, 0xc1,
> + 0x4c, 0x00, 0x00, 0xfa, 0x01, 0x03, 0x11, 0x81, 0x48, 0x79, 0x08, 0xef,
> + 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x00, 0x00, 0xfa,
> + 0x0d, 0x62, 0x8e, 0x45, 0xf0, 0xff, 0x75, 0x82, 0x4e, 0x05, 0x01, 0x60,
> + 0x10, 0x40, 0x07, 0xc8, 0x24, 0x88, 0x23, 0x80, 0x1e, 0x8a, 0x78, 0x40,
> + 0x00, 0xe8, 0x21, 0x81, 0x0b, 0x84, 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd,
> + 0x83, 0xc1, 0x93, 0xdd, 0x0c, 0x04, 0x00, 0xfa, 0x41, 0xb9, 0x06, 0x48,
> + 0x12, 0xe0, 0x33, 0x88, 0x45, 0x06, 0x14, 0xe0, 0x4b, 0xa3, 0xc5, 0x80,
> + 0x35, 0x06, 0x18, 0xe0, 0x3b, 0x23, 0x31, 0x81, 0x55, 0x80, 0x31, 0x83,
> + 0x0d, 0xe6, 0x04, 0x00, 0x88, 0x00, 0x4e, 0x08, 0x00, 0x00, 0x10, 0x80,
> + 0x05, 0x00, 0x10, 0x9c, 0x08, 0x40, 0x00, 0x98, 0x25, 0x0b, 0x8e, 0x40,
> + 0xf0, 0xff, 0x3b, 0xa1, 0x45, 0x8a, 0x2b, 0x23, 0x06, 0x4c, 0x00, 0xe0,
> + 0x45, 0x90, 0x2b, 0x25, 0x6e, 0x40, 0xf0, 0xff, 0x25, 0x87, 0x3b, 0xa1,
> + 0x25, 0x8a, 0x2b, 0x23, 0x06, 0x0c, 0x08, 0xe0, 0x05, 0x8e, 0x2b, 0x25,
> + 0x5e, 0x40, 0xf0, 0xff, 0x85, 0x0c, 0x06, 0x0c, 0x04, 0xe0, 0x95, 0x87,
> + 0x3b, 0xa1, 0xc5, 0x88, 0x2b, 0x23, 0x61, 0x91, 0x85, 0x8a, 0x2b, 0x25,
> + 0x7e, 0x40, 0xf0, 0xff, 0x25, 0x83, 0x2b, 0xa3, 0xc5, 0x08, 0x06, 0x0c,
> + 0x08, 0x80, 0x2b, 0x25, 0x4e, 0x40, 0xf0, 0xff, 0x15, 0x8a, 0xf5, 0x03,
> + 0x06, 0x0c, 0x04, 0xe0, 0x2b, 0x23, 0x61, 0x91, 0x45, 0x86, 0x2b, 0x25,
> + 0x6e, 0x40, 0xf0, 0xff, 0xc5, 0x04, 0x61, 0x89, 0xc5, 0x83, 0x2b, 0x23,
> + 0x06, 0x4c, 0x00, 0xe0, 0x05, 0x84, 0x2b, 0x25, 0x5e, 0x40, 0xf0, 0xff,
> + 0x85, 0x02, 0x61, 0xa1, 0x25, 0x83, 0x2b, 0x23, 0x61, 0x85, 0xe5, 0x80,
> + 0x2b, 0x25, 0x7e, 0x40, 0xf0, 0xff, 0x65, 0x00, 0x61, 0x83, 0x95, 0x81,
> + 0x0b, 0x02, 0x1b, 0x8c, 0x48, 0x78, 0xfc, 0xef, 0x0b, 0xa1, 0x00, 0x4c,
> + 0x00, 0xdc, 0x0b, 0x8c, 0x0c, 0x0c, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1,
> + 0x0c, 0x04, 0x04, 0xfa, 0x6b, 0x00, 0xc6, 0x40, 0xdc, 0xe0, 0x04, 0x00,
> + 0xf0, 0x1e, 0x30, 0xec, 0x48, 0x55, 0xfc, 0x6e, 0x0e, 0x02, 0x24, 0x74,
> + 0x03, 0xc0, 0xb8, 0x68, 0xfc, 0xee, 0x58, 0x71, 0x08, 0xef, 0x78, 0x68,
> + 0xfc, 0x6e, 0x0b, 0x8c, 0x71, 0x01, 0x5b, 0x80, 0x7e, 0x3c, 0x0e, 0x00,
> + 0x05, 0x60, 0x10, 0xc0, 0x11, 0x03, 0x21, 0x81, 0x31, 0x05, 0x41, 0x81,
> + 0xa8, 0x77, 0x08, 0xef, 0x0e, 0x3e, 0x0e, 0x00, 0x05, 0x60, 0x10, 0xc0,
> + 0x48, 0x4b, 0x0c, 0xef, 0x0e, 0x7c, 0x11, 0x81, 0x04, 0x3e, 0x21, 0x83,
> + 0x68, 0x76, 0xfc, 0x6f, 0x0e, 0x06, 0x04, 0x60, 0x10, 0xc0, 0xce, 0x0d,
> + 0x01, 0x60, 0x10, 0xc0, 0x76, 0x98, 0x04, 0xfc, 0xc8, 0x59, 0x0c, 0xef,
> + 0x13, 0xc3, 0x08, 0x98, 0x0b, 0xa1, 0xa5, 0xfe, 0x04, 0xfc, 0x18, 0x5c,
> + 0x0c, 0xef, 0x14, 0x3e, 0x0e, 0x00, 0x05, 0x60, 0x10, 0xc0, 0x38, 0x46,
> + 0x0c, 0xef, 0x01, 0x01, 0xf1, 0x98, 0x0c, 0x0c, 0x04, 0xf2, 0x93, 0xdd,
> + 0x65, 0x5e, 0x04, 0xfa, 0xf0, 0x0c, 0x10, 0xec, 0x60, 0x5e, 0x1c, 0x74,
> + 0x61, 0x88, 0x6e, 0xbc, 0xfc, 0x03, 0x80, 0xfe, 0x26, 0x00, 0x4c, 0x61,
> + 0x11, 0x83, 0x16, 0x00, 0xce, 0x01, 0x01, 0x60, 0x10, 0xc0, 0x16, 0x00,
> + 0x46, 0x00, 0x2c, 0xe1, 0x04, 0x00, 0xf0, 0x1e, 0x30, 0xec, 0x14, 0xc0,
> + 0x14, 0x02, 0x20, 0xfc, 0x1e, 0xc0, 0x98, 0x40, 0x00, 0xe8, 0xf1, 0x98,
> + 0xfc, 0x0b, 0x80, 0xf6, 0xf4, 0xbc, 0x64, 0xfd, 0x53, 0xc1, 0xc3, 0xc1,
> + 0x06, 0x00, 0x01, 0x60, 0x00, 0xe0, 0x06, 0x00, 0x62, 0xf4, 0x93, 0xdd,
> + 0x4c, 0x04, 0x7c, 0xfa, 0xc6, 0x54, 0x84, 0x60, 0x06, 0x0f, 0xdc, 0xe0,
> + 0x04, 0x2a, 0xae, 0x4d, 0x01, 0x60, 0x10, 0xc0, 0x29, 0x14, 0x70, 0x60,
> + 0x8e, 0x51, 0x00, 0x60, 0x10, 0xc0, 0x3b, 0x0e, 0x9c, 0x65, 0x06, 0x52,
> + 0x94, 0xe0, 0x1b, 0x00, 0x20, 0x60, 0x0e, 0x57, 0x08, 0x60, 0x10, 0xc0,
> + 0x0b, 0x00, 0x1c, 0xe0, 0x13, 0x20, 0x01, 0x81, 0x13, 0x84, 0x13, 0x86,
> + 0x11, 0x9e, 0x1c, 0x98, 0x0c, 0xa0, 0x04, 0xa4, 0x0b, 0x00, 0xa0, 0xe5,
> + 0x0c, 0xac, 0x0a, 0x98, 0x1a, 0xac, 0x0d, 0xc3, 0xf5, 0x82, 0x04, 0xa4,
> + 0x0b, 0x00, 0xa0, 0xe5, 0x0c, 0x2c, 0x01, 0x8b, 0x08, 0x56, 0x2c, 0xef,
> + 0x0a, 0xa0, 0x01, 0x82, 0x0c, 0xa0, 0x0a, 0xa0, 0x8a, 0x00, 0x24, 0xe7,
> + 0xf5, 0xfa, 0x05, 0x0e, 0xbc, 0x61, 0x06, 0x04, 0x00, 0x60, 0x00, 0xf0,
> + 0x13, 0x0e, 0xb8, 0x79, 0x06, 0x06, 0x00, 0x60, 0x00, 0xe0, 0x2f, 0x80,
> + 0x2b, 0x07, 0x0e, 0x45, 0x01, 0x60, 0x10, 0xc0, 0x1c, 0x88, 0x95, 0x86,
> + 0x07, 0xe1, 0x09, 0xbe, 0x0b, 0xa1, 0x05, 0x86, 0x21, 0xff, 0x1d, 0x84,
> + 0x85, 0x02, 0x00, 0x00, 0x08, 0x8c, 0x10, 0x04, 0x18, 0xec, 0x8a, 0x04,
> + 0x14, 0xed, 0xb5, 0x80, 0x8a, 0x02, 0x40, 0xe1, 0x75, 0x82, 0x01, 0x84,
> + 0x14, 0x24, 0x09, 0xbe, 0x29, 0x02, 0x00, 0xe3, 0x20, 0x44, 0x80, 0xf3,
> + 0x2f, 0xa0, 0x21, 0x42, 0x00, 0xe3, 0x8e, 0x41, 0x09, 0x60, 0x10, 0x40,
> + 0xc6, 0x0d, 0x30, 0xe1, 0x04, 0x80, 0x0b, 0xa3, 0x75, 0xa0, 0x19, 0x0c,
> + 0xcc, 0xe5, 0x4a, 0x02, 0xfc, 0xfb, 0xc5, 0x9e, 0xa8, 0x54, 0x00, 0x68,
> + 0x01, 0x81, 0x04, 0x24, 0x11, 0x85, 0x11, 0x40, 0x20, 0x60, 0x4e, 0x43,
> + 0x00, 0x60, 0x10, 0xc0, 0x04, 0xa4, 0x29, 0x00, 0x50, 0xeb, 0x2e, 0x84,
> + 0x24, 0x84, 0x29, 0x86, 0x2e, 0x84, 0x24, 0x84, 0x2b, 0xa1, 0x15, 0xfe,
> + 0xa8, 0x52, 0x44, 0xef, 0x04, 0xaa, 0x08, 0x80, 0x0b, 0xa5, 0xe5, 0x80,
> + 0x04, 0xa8, 0x09, 0x00, 0x20, 0xe1, 0x0b, 0xa1, 0x48, 0x4a, 0x44, 0x8f,
> + 0x46, 0x10, 0x74, 0xe1, 0x04, 0xa0, 0x14, 0xc0, 0x14, 0x02, 0x2c, 0xfc,
> + 0x1e, 0xc0, 0x14, 0xc0, 0x14, 0x02, 0x08, 0xfc, 0x1e, 0x40, 0x11, 0x83,
> + 0x04, 0xa4, 0x11, 0x40, 0xb0, 0x67, 0x11, 0x81, 0x04, 0xa6, 0x11, 0x40,
> + 0x10, 0xe0, 0xb8, 0x73, 0x74, 0xef, 0x84, 0x20, 0x70, 0x06, 0x00, 0xe7,
> + 0x8e, 0x17, 0x01, 0x60, 0x10, 0x40, 0xce, 0x54, 0x01, 0x60, 0x10, 0xc0,
> + 0x04, 0xe0, 0x04, 0x00, 0x04, 0xfc, 0x0e, 0xe0, 0x04, 0xe0, 0x04, 0x00,
> + 0x0c, 0xfc, 0x0e, 0xe0, 0x04, 0xe0, 0x04, 0x00, 0x10, 0xfc, 0x0e, 0xe0,
> + 0x45, 0x10, 0x2c, 0xe0, 0x44, 0x00, 0x00, 0xfc, 0x05, 0x50, 0x2c, 0x60,
> + 0x4e, 0x41, 0x08, 0x60, 0x10, 0xc0, 0x1b, 0x0e, 0xa0, 0xe1, 0x04, 0x80,
> + 0x2b, 0x0e, 0x9c, 0xe1, 0x1b, 0xc2, 0x03, 0x02, 0xce, 0x42, 0x01, 0x60,
> + 0x10, 0xc0, 0x3e, 0x04, 0x03, 0x84, 0x00, 0x00, 0xf4, 0xec, 0x0e, 0xac,
> + 0x09, 0x0e, 0x00, 0xe3, 0x4e, 0x8f, 0x0b, 0xa5, 0x0b, 0x0e, 0x10, 0xd8,
> + 0x95, 0x96, 0x0b, 0x0e, 0x84, 0xe1, 0x15, 0x0e, 0x10, 0xe0, 0x03, 0x4e,
> + 0x10, 0xf8, 0x1d, 0xc1, 0x13, 0x4e, 0x10, 0x58, 0x10, 0x40, 0x00, 0xdc,
> + 0x1a, 0x5e, 0x04, 0x04, 0x80, 0xfb, 0x2d, 0xc3, 0x13, 0x4e, 0x10, 0x58,
> + 0x10, 0x40, 0x00, 0xdc, 0x85, 0x89, 0x0b, 0xa1, 0x98, 0x0c, 0x00, 0xc0,
> + 0x68, 0x7b, 0x68, 0x6f, 0x01, 0x85, 0x60, 0x00, 0x10, 0x64, 0x11, 0x81,
> + 0xc8, 0x71, 0x54, 0xef, 0x28, 0x45, 0x70, 0xef, 0x09, 0x0e, 0xe8, 0xea,
> + 0x4a, 0x40, 0x90, 0xe0, 0x06, 0x00, 0x00, 0xc0, 0xa8, 0x4b, 0x00, 0xc8,
> + 0x09, 0x0e, 0x5c, 0xeb, 0x0a, 0x40, 0x80, 0xe0, 0x25, 0xac, 0x19, 0x0c,
> + 0xcc, 0xe5, 0x4a, 0x02, 0xfc, 0xfb, 0x85, 0xaa, 0x0a, 0x40, 0x90, 0xe0,
> + 0x45, 0x82, 0x46, 0x00, 0x74, 0xe1, 0x04, 0x80, 0x14, 0xc0, 0x14, 0x02,
> + 0x2c, 0xfc, 0x1e, 0xc0, 0x09, 0x0e, 0x5c, 0xeb, 0x0a, 0x40, 0x84, 0xe0,
> + 0x25, 0x82, 0xb8, 0x68, 0x30, 0x6f, 0x01, 0x81, 0xc8, 0x58, 0x2c, 0x6f,
> + 0x0b, 0x8c, 0x09, 0x0e, 0x5c, 0xeb, 0x0a, 0x40, 0x94, 0xe0, 0x45, 0x82,
> + 0x46, 0x00, 0x74, 0xe1, 0x04, 0x80, 0x14, 0xc0, 0x14, 0x02, 0x08, 0xfc,
> + 0x1e, 0xc0, 0x09, 0x0e, 0x5c, 0xeb, 0x0a, 0x40, 0x98, 0xe0, 0x18, 0x49,
> + 0x00, 0xc8, 0x45, 0x91, 0x14, 0x2c, 0x04, 0x00, 0x80, 0xfb, 0x13, 0x20,
> + 0x06, 0x41, 0x2c, 0xe0, 0x16, 0x40, 0x02, 0x60, 0x46, 0x42, 0x04, 0xe0,
> + 0xc8, 0x7a, 0xf8, 0xee, 0x0e, 0x2c, 0x0e, 0x4c, 0x01, 0x60, 0x10, 0xc0,
> + 0x04, 0xac, 0x00, 0x00, 0xd1, 0x6f, 0x0f, 0xc0, 0x0e, 0xac, 0x05, 0x10,
> + 0x40, 0xe0, 0x04, 0x00, 0x38, 0xfc, 0x0e, 0x98, 0x05, 0x50, 0x40, 0xe0,
> + 0x04, 0xac, 0xd8, 0x63, 0xfc, 0xef, 0x46, 0x10, 0x74, 0xe1, 0x04, 0xa0,
> + 0x15, 0x00, 0x40, 0xe0, 0x14, 0x02, 0xb8, 0xfc, 0x1e, 0x98, 0x15, 0x40,
> + 0x40, 0xe0, 0x98, 0x52, 0x30, 0xef, 0x0b, 0xa1, 0xa5, 0xfe, 0x34, 0x28,
> + 0xc6, 0x0d, 0x30, 0xe1, 0x08, 0x8c, 0x0b, 0xa5, 0x0b, 0x0e, 0x04, 0xd8,
> + 0x1b, 0x0e, 0x00, 0xc0, 0x2b, 0x0e, 0x04, 0xc0, 0x3b, 0x0e, 0x08, 0xc0,
> + 0x75, 0x84, 0x08, 0x8e, 0x19, 0x0e, 0x10, 0xeb, 0x12, 0x40, 0x80, 0xfb,
> + 0x01, 0x4e, 0x10, 0xf8, 0x0a, 0xcc, 0x03, 0x4e, 0x04, 0xf8, 0x1a, 0xce,
> + 0x1c, 0x9c, 0x2b, 0x06, 0x10, 0xe0, 0x2c, 0x9e, 0x3b, 0x06, 0x14, 0xe0,
> + 0x3c, 0xdc, 0xa4, 0x8f, 0x03, 0x4e, 0x80, 0xf9, 0x13, 0x4e, 0x7c, 0xf9,
> + 0x23, 0x4e, 0x78, 0xf9, 0x33, 0x4e, 0x74, 0xf9, 0xc8, 0x6d, 0x38, 0xef,
> + 0xe8, 0x66, 0x3c, 0xef, 0x04, 0x20, 0xa9, 0xc2, 0xa5, 0x40, 0x2c, 0xe0,
> + 0x19, 0x0c, 0x40, 0xe6, 0x1b, 0xa1, 0x55, 0x88, 0x14, 0xc0, 0x19, 0xd0,
> + 0x1e, 0xc0, 0x14, 0xc0, 0x19, 0xe0, 0x1e, 0xc0, 0x14, 0xc0, 0x19, 0xc4,
> + 0x1e, 0x40, 0x01, 0x83, 0xa8, 0x41, 0x00, 0xe8, 0x04, 0xa0, 0x14, 0xc0,
> + 0x14, 0x02, 0xac, 0xfc, 0x1e, 0xc0, 0x14, 0xc0, 0x19, 0xc8, 0x1e, 0xc0,
> + 0x48, 0x51, 0x74, 0xef, 0x04, 0x26, 0x11, 0x83, 0x11, 0x40, 0x10, 0xe0,
> + 0x04, 0xa4, 0x11, 0x40, 0x20, 0x60, 0x11, 0x81, 0x04, 0xa4, 0x11, 0x40,
> + 0xb0, 0xe7, 0x4c, 0x0c, 0x7c, 0xf2, 0x93, 0xdd, 0x1b, 0x00, 0x06, 0x01,
> + 0x38, 0xe1, 0x04, 0x80, 0xc8, 0x20, 0x04, 0x60, 0x01, 0xb8, 0xc3, 0xc1,
> + 0x83, 0xc1, 0x13, 0xc3, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa,
> + 0xe6, 0x41, 0x84, 0x60, 0x8e, 0x42, 0x00, 0x60, 0x10, 0xc0, 0x08, 0x80,
> + 0x14, 0x84, 0x0b, 0x21, 0xa6, 0x41, 0x04, 0xe1, 0x1c, 0x80, 0x05, 0x82,
> + 0x28, 0x47, 0x64, 0xef, 0x88, 0x7b, 0x28, 0x6f, 0x46, 0x40, 0x04, 0xe0,
> + 0x35, 0x81, 0x38, 0x56, 0x40, 0xef, 0xd8, 0x67, 0x64, 0xef, 0x38, 0x63,
> + 0x64, 0xef, 0xd8, 0x44, 0x44, 0xef, 0x06, 0x40, 0x94, 0xe0, 0x04, 0x80,
> + 0x09, 0x00, 0x50, 0xeb, 0x0a, 0x40, 0x88, 0xe0, 0x76, 0x00, 0xa0, 0xc0,
> + 0x68, 0x4e, 0x50, 0xcf, 0xc6, 0x0d, 0x30, 0xe1, 0x09, 0x0c, 0x30, 0xe7,
> + 0x0b, 0xa1, 0x78, 0x6c, 0x70, 0xcf, 0x98, 0x7f, 0x6c, 0xef, 0x38, 0x4b,
> + 0x2c, 0x6f, 0x0b, 0x8c, 0xc8, 0x5a, 0x30, 0x6f, 0x01, 0x81, 0x58, 0x49,
> + 0x30, 0xef, 0xb8, 0x5f, 0x70, 0xef, 0x01, 0x83, 0x01, 0x4c, 0xc0, 0xe5,
> + 0x0c, 0x0c, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x84, 0xfa,
> + 0x06, 0x4e, 0x88, 0x60, 0x06, 0x0c, 0x0c, 0xe1, 0x05, 0x0e, 0x38, 0x78,
> + 0x06, 0x04, 0x00, 0x70, 0x40, 0xc0, 0x19, 0x0c, 0x94, 0x78, 0x06, 0x06,
> + 0x10, 0x60, 0x40, 0xc0, 0x08, 0xc0, 0x4a, 0x02, 0x00, 0xe0, 0x09, 0x86,
> + 0x07, 0xc6, 0x2f, 0x61, 0x3f, 0xe1, 0x21, 0x4e, 0x10, 0xf8, 0x0c, 0x00,
> + 0x00, 0xe2, 0x31, 0x4e, 0x0c, 0xf8, 0x18, 0x62, 0x30, 0xef, 0x05, 0x0e,
> + 0x38, 0xf8, 0x14, 0x98, 0x09, 0x00, 0x24, 0xe0, 0x4a, 0x40, 0x88, 0xe0,
> + 0x65, 0x82, 0x0b, 0x0c, 0x28, 0x78, 0x1b, 0xa1, 0x0c, 0xde, 0x05, 0x84,
> + 0x0a, 0x01, 0x20, 0xec, 0xf5, 0x84, 0x55, 0x03, 0x01, 0x93, 0x0b, 0x0c,
> + 0x24, 0x78, 0x1b, 0xa1, 0x0c, 0xde, 0x65, 0x82, 0x0a, 0x01, 0x24, 0xec,
> + 0xb5, 0x82, 0xb5, 0x01, 0x01, 0x95, 0x0a, 0x01, 0x48, 0xec, 0x15, 0x82,
> + 0x65, 0x01, 0x01, 0xa7, 0x0a, 0x01, 0x50, 0xec, 0x75, 0x80, 0x01, 0xab,
> + 0x0c, 0xde, 0x15, 0x0c, 0x20, 0x79, 0x06, 0x04, 0x00, 0x60, 0x00, 0xf0,
> + 0x49, 0x0c, 0x64, 0x78, 0x06, 0x06, 0x00, 0x60, 0x00, 0xe0, 0x2f, 0x82,
> + 0x3b, 0x0c, 0x8c, 0x78, 0x2b, 0x87, 0x30, 0x42, 0x00, 0x5c, 0x4a, 0x08,
> + 0x14, 0xfc, 0x14, 0x04, 0x80, 0x7a, 0xce, 0x43, 0x00, 0x60, 0x10, 0xc0,
> + 0x2c, 0x04, 0x8e, 0x48, 0x01, 0x60, 0x10, 0xc0, 0x3e, 0x90, 0x85, 0x88,
> + 0x45, 0x0e, 0x30, 0xf8, 0x3b, 0x08, 0x18, 0xe0, 0x5b, 0x08, 0x20, 0xe0,
> + 0x4b, 0x08, 0x1c, 0xe0, 0x32, 0x4a, 0x94, 0xf1, 0x53, 0x88, 0x8a, 0x0a,
> + 0x89, 0x63, 0x05, 0xc0, 0xb5, 0x84, 0x54, 0x1a, 0x8e, 0x59, 0x09, 0x60,
> + 0x10, 0xc0, 0x71, 0x83, 0x7e, 0x30, 0x2e, 0x59, 0x09, 0x60, 0x10, 0xc0,
> + 0x5c, 0x30, 0x54, 0x08, 0x80, 0xfb, 0x4d, 0x44, 0x4e, 0x45, 0x09, 0x60,
> + 0x10, 0xc0, 0x3e, 0x88, 0x43, 0x42, 0x00, 0xc0, 0x65, 0x81, 0x8e, 0x43,
> + 0x09, 0x60, 0x10, 0x40, 0x21, 0x81, 0x2e, 0x84, 0x03, 0x4c, 0xd5, 0x79,
> + 0x02, 0x40, 0xd6, 0x41, 0x00, 0xe0, 0x0c, 0x0c, 0x84, 0xf2, 0x18, 0x34,
> + 0x48, 0xff, 0xc3, 0xc1, 0x0c, 0x04, 0xfc, 0xfa, 0x6b, 0x00, 0x06, 0x41,
> + 0x08, 0xe0, 0x98, 0x73, 0x48, 0xef, 0x0b, 0xa1, 0x78, 0x14, 0x00, 0xc0,
> + 0x86, 0x52, 0x84, 0xe0, 0x74, 0xe4, 0x08, 0x9c, 0x09, 0x86, 0x0b, 0xa3,
> + 0x36, 0x40, 0x98, 0x40, 0x06, 0x02, 0x00, 0xc0, 0x11, 0x40, 0x00, 0xc0,
> + 0xf5, 0x80, 0x21, 0x01, 0x36, 0x40, 0x98, 0xe0, 0x2e, 0x18, 0x11, 0x83,
> + 0x16, 0x80, 0x84, 0x26, 0x16, 0x44, 0x98, 0xe0, 0x18, 0x9c, 0x09, 0x10,
> + 0xb4, 0xe0, 0x0a, 0x02, 0x0c, 0xfc, 0x0c, 0x02, 0x00, 0xe2, 0x01, 0x4c,
> + 0x10, 0xe1, 0x0b, 0x10, 0x80, 0xe0, 0x16, 0x88, 0xe8, 0x75, 0xf8, 0xee,
> + 0x05, 0x4c, 0x48, 0xe0, 0x08, 0x9c, 0x00, 0x42, 0x08, 0xfc, 0x19, 0x86,
> + 0x1b, 0xa5, 0xd5, 0x80, 0x4a, 0x00, 0x0c, 0xf8, 0x0c, 0x00, 0x00, 0xe2,
> + 0x0e, 0x98, 0x09, 0x10, 0xb0, 0xe0, 0x98, 0x51, 0x00, 0x68, 0x09, 0x82,
> + 0x01, 0x4c, 0x18, 0x60, 0x11, 0x9f, 0x0b, 0x10, 0x88, 0xe0, 0x78, 0x51,
> + 0x00, 0xe8, 0x14, 0xa6, 0x05, 0x4c, 0x4c, 0xe0, 0x0b, 0x02, 0x84, 0x60,
> + 0x11, 0x91, 0xf8, 0x50, 0x00, 0xe8, 0xb4, 0xa6, 0x05, 0x4c, 0x50, 0xe0,
> + 0x09, 0x16, 0xd0, 0xe0, 0x0a, 0x40, 0x84, 0x60, 0x06, 0x00, 0x00, 0x60,
> + 0x48, 0xd0, 0x56, 0x01, 0x55, 0x15, 0x41, 0xd0, 0x05, 0x4c, 0x34, 0xe0,
> + 0x09, 0x16, 0xd0, 0xe0, 0x68, 0x4f, 0x00, 0x68, 0x09, 0x82, 0x14, 0x64,
> + 0x06, 0x54, 0xdc, 0xe0, 0x01, 0x4c, 0x10, 0x60, 0xce, 0x41, 0x00, 0x60,
> + 0x10, 0xc0, 0x0a, 0x80, 0x2b, 0x02, 0x18, 0xe0, 0x23, 0xa0, 0x23, 0x4c,
> + 0x60, 0xe0, 0x09, 0x14, 0x70, 0xea, 0x22, 0x40, 0x80, 0xf1, 0x03, 0x4c,
> + 0x60, 0xe0, 0x25, 0x14, 0xe0, 0xe2, 0x2b, 0xa3, 0x35, 0x88, 0x24, 0xa4,
> + 0x3b, 0x02, 0x18, 0xe0, 0x4b, 0x02, 0x20, 0xe0, 0x1b, 0x02, 0x1c, 0xe0,
> + 0x59, 0x04, 0x24, 0xe0, 0x33, 0xa8, 0x32, 0x44, 0x84, 0x70, 0x2e, 0x47,
> + 0x08, 0x60, 0x10, 0xc0, 0x20, 0x02, 0xfc, 0x6c, 0x0a, 0x4a, 0x88, 0xe0,
> + 0x1c, 0x0c, 0x20, 0x02, 0x14, 0xcc, 0x10, 0x02, 0xf0, 0xcc, 0x13, 0x46,
> + 0x00, 0x40, 0x0a, 0x41, 0x04, 0xec, 0x13, 0x4c, 0x60, 0x40, 0x10, 0x40,
> + 0x00, 0xdc, 0x15, 0x14, 0xdc, 0x62, 0x04, 0x00, 0x80, 0xfb, 0x86, 0x05,
> + 0x74, 0xe1, 0x1d, 0xc1, 0x13, 0x4c, 0x60, 0x40, 0x14, 0x00, 0x80, 0xdb,
> + 0x14, 0xa4, 0x0e, 0xa8, 0x04, 0x88, 0x7a, 0x84, 0x73, 0x4c, 0x64, 0xe0,
> + 0xe8, 0x6d, 0xf8, 0xee, 0x1b, 0x00, 0x8e, 0x40, 0xb1, 0x66, 0x9b, 0xd3,
> + 0x08, 0x6d, 0xf8, 0xee, 0x8b, 0x00, 0x0b, 0x8e, 0x85, 0x4c, 0x3c, 0xe0,
> + 0x28, 0x6d, 0xf8, 0xee, 0x1b, 0x00, 0x0b, 0x90, 0x28, 0x6d, 0xf8, 0xee,
> + 0x48, 0x6c, 0xf8, 0x6e, 0x0e, 0x02, 0x00, 0x60, 0x1e, 0xd1, 0x05, 0x4c,
> + 0x40, 0x60, 0x11, 0x91, 0x0b, 0x16, 0x64, 0xe0, 0x7b, 0x16, 0x5c, 0xe0,
> + 0x89, 0x16, 0xc0, 0xe0, 0x08, 0x49, 0x00, 0xe8, 0x3b, 0x00, 0x80, 0x44,
> + 0x7c, 0xf0, 0x81, 0x01, 0x11, 0x81, 0xb8, 0x40, 0x40, 0x6f, 0x0b, 0x8e,
> + 0x4b, 0x0c, 0x60, 0x60, 0x06, 0x0e, 0x00, 0x60, 0xe0, 0xcf, 0x0e, 0x5a,
> + 0x11, 0x81, 0x21, 0x01, 0x06, 0x06, 0x01, 0x60, 0xe0, 0xcf, 0xd8, 0x7f,
> + 0x3c, 0x6f, 0x0b, 0x88, 0x14, 0x64, 0x86, 0x57, 0x94, 0xe1, 0x05, 0x4c,
> + 0x2c, 0xe0, 0x0a, 0x86, 0x83, 0x4c, 0xe4, 0xe0, 0x03, 0x4c, 0xe0, 0xe0,
> + 0x08, 0x86, 0x09, 0xbe, 0x03, 0x4c, 0xe8, 0xe0, 0x08, 0x86, 0x09, 0xbe,
> + 0x07, 0xc4, 0x05, 0x00, 0x2c, 0xfc, 0x05, 0x4c, 0x54, 0xe0, 0x0a, 0xc4,
> + 0x03, 0x4c, 0xec, 0xe0, 0x0a, 0x44, 0x11, 0x91, 0xe8, 0x45, 0x00, 0xe8,
> + 0x14, 0xe4, 0x05, 0x4c, 0x58, 0xe0, 0x0a, 0x46, 0x11, 0x91, 0x78, 0x45,
> + 0x00, 0xe8, 0x14, 0xe4, 0x05, 0x4c, 0x5c, 0xe0, 0x0b, 0x02, 0x10, 0x60,
> + 0x11, 0x91, 0xf8, 0x44, 0x00, 0xe8, 0x14, 0xe4, 0x05, 0x4c, 0x60, 0xe0,
> + 0x0b, 0x02, 0x14, 0x60, 0x11, 0x91, 0x78, 0x44, 0x00, 0xe8, 0x14, 0xa6,
> + 0x05, 0x4c, 0x64, 0xe0, 0x85, 0x4c, 0x14, 0xe0, 0x85, 0x4c, 0x18, 0xe0,
> + 0x0b, 0x02, 0x7c, 0x60, 0x11, 0x91, 0xb8, 0x43, 0x00, 0xe8, 0x05, 0x4c,
> + 0x10, 0x60, 0x11, 0x91, 0x81, 0x4c, 0x14, 0xe0, 0x75, 0x4c, 0x1c, 0xe0,
> + 0x09, 0x14, 0xd0, 0xea, 0x07, 0xc4, 0x05, 0x00, 0x2c, 0xfc, 0x05, 0x4c,
> + 0x20, 0xe0, 0x0b, 0x14, 0x94, 0xe5, 0x98, 0x42, 0x00, 0xe8, 0x05, 0x4c,
> + 0x38, 0x60, 0x11, 0x91, 0x0b, 0x14, 0x64, 0xe5, 0x28, 0x42, 0x00, 0xe8,
> + 0x05, 0x4c, 0x28, 0x60, 0x11, 0x81, 0x09, 0x14, 0x8c, 0x6a, 0x21, 0x81,
> + 0x0b, 0x12, 0x7c, 0x60, 0x0a, 0x40, 0x88, 0xe0, 0xd6, 0x0e, 0xcd, 0x0c,
> + 0x73, 0xcf, 0x75, 0x4c, 0x24, 0x60, 0x3b, 0x8e, 0x28, 0x79, 0x3c, 0xef,
> + 0x0e, 0xd8, 0x16, 0x41, 0x08, 0xe0, 0x0c, 0x0c, 0xfc, 0xf2, 0xb8, 0x1e,
> + 0x48, 0xff, 0xc3, 0xc1, 0x4a, 0x00, 0x00, 0xe0, 0x0c, 0x00, 0x00, 0xe2,
> + 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x00, 0x00, 0xfa, 0x88, 0x61, 0x28, 0xef,
> + 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa,
> + 0x88, 0x5d, 0x48, 0x6f, 0xf6, 0x40, 0x04, 0xe0, 0x0b, 0xa1, 0x85, 0x80,
> + 0x0c, 0x0c, 0x00, 0xf2, 0x93, 0xdd, 0xb8, 0x6b, 0x54, 0xef, 0xc6, 0x4c,
> + 0x84, 0xe0, 0x04, 0x98, 0x09, 0x00, 0x20, 0xe1, 0x4a, 0x40, 0x80, 0xe0,
> + 0x85, 0x88, 0xc6, 0x40, 0xb4, 0x60, 0x46, 0x45, 0x00, 0xe0, 0x19, 0x00,
> + 0xb4, 0xe4, 0x16, 0x42, 0x0a, 0xe0, 0x03, 0x82, 0x09, 0x00, 0x40, 0xe2,
> + 0x0b, 0xa5, 0xf5, 0x84, 0x48, 0x56, 0x40, 0x6f, 0x01, 0x85, 0x58, 0x4c,
> + 0x40, 0x6f, 0x06, 0x00, 0x80, 0xe1, 0xd8, 0x7d, 0x44, 0x6f, 0x06, 0x00,
> + 0x80, 0xe1, 0x58, 0x50, 0x40, 0xef, 0x18, 0x70, 0xf4, 0xef, 0x4e, 0x40,
> + 0x01, 0x60, 0x10, 0xc0, 0x08, 0x80, 0x0b, 0xa1, 0x08, 0x70, 0xf4, 0xcf,
> + 0x09, 0x0c, 0x48, 0xe0, 0x0b, 0xa1, 0x95, 0x84, 0xe8, 0x70, 0x38, 0xef,
> + 0x06, 0x40, 0x94, 0x60, 0x16, 0x07, 0x04, 0xe1, 0x04, 0x80, 0x1b, 0x00,
> + 0x18, 0xe1, 0x2b, 0x00, 0x50, 0xe1, 0x48, 0x8c, 0x39, 0x06, 0xac, 0xe0,
> + 0x13, 0xa4, 0x13, 0xa8, 0x13, 0xa6, 0x15, 0x40, 0x2c, 0xe0, 0xc6, 0x00,
> + 0x2c, 0x61, 0x11, 0xa1, 0x04, 0x80, 0x13, 0x40, 0xd0, 0x65, 0xe6, 0x40,
> + 0xe0, 0xe0, 0x0a, 0x00, 0x06, 0x42, 0x94, 0xe0, 0x14, 0x84, 0x03, 0x42,
> + 0x10, 0x62, 0x06, 0x41, 0x04, 0xe0, 0x0c, 0x0c, 0x00, 0xf2, 0x98, 0x17,
> + 0x48, 0xff, 0xc3, 0xc1, 0x66, 0x01, 0xcc, 0xe0, 0x18, 0x80, 0x0a, 0x42,
> + 0x84, 0xe0, 0x10, 0x42, 0xf8, 0xd3, 0x11, 0x40, 0x00, 0xc0, 0x93, 0xdd,
> + 0x4a, 0x40, 0x80, 0xe0, 0x55, 0x84, 0x14, 0x04, 0xa0, 0x60, 0x0e, 0x06,
> + 0x00, 0x70, 0x3f, 0xc0, 0x2f, 0x06, 0x14, 0x06, 0xa0, 0xe1, 0x14, 0x00,
> + 0xe0, 0x61, 0x30, 0x46, 0x00, 0x70, 0xff, 0xc0, 0x17, 0x70, 0x3f, 0xa0,
> + 0x1f, 0xa4, 0x1f, 0xa6, 0x93, 0x5d, 0x0b, 0x82, 0x4c, 0x04, 0x04, 0xfa,
> + 0x86, 0x0d, 0xcc, 0x60, 0x71, 0x81, 0x7c, 0x98, 0x88, 0x55, 0x68, 0xef,
> + 0x0a, 0x98, 0x00, 0x42, 0xf1, 0x73, 0xff, 0xc0, 0x19, 0xc2, 0x1c, 0x18,
> + 0x60, 0x02, 0xe1, 0x65, 0x02, 0xc0, 0x65, 0x81, 0x24, 0x84, 0x2b, 0xa1,
> + 0xf5, 0x80, 0x71, 0x02, 0x11, 0x88, 0x0a, 0x0e, 0x00, 0xe1, 0x35, 0xfe,
> + 0x75, 0x81, 0x77, 0x50, 0x00, 0x40, 0xf0, 0xf3, 0x0f, 0xae, 0x09, 0xc4,
> + 0x0c, 0x98, 0x4c, 0x0c, 0x04, 0xf2, 0x93, 0xdd, 0x4c, 0x04, 0x7c, 0xfa,
> + 0xbb, 0x06, 0x6b, 0x82, 0x14, 0x2c, 0x9b, 0x80, 0x74, 0x24, 0xab, 0x84,
> + 0xa4, 0x00, 0xa0, 0x61, 0x8b, 0x88, 0x1b, 0x81, 0x65, 0x82, 0x0e, 0x2c,
> + 0x0b, 0x8e, 0x78, 0x56, 0x30, 0x6f, 0x1b, 0x8c, 0x24, 0x2c, 0x0b, 0x8e,
> + 0x28, 0x59, 0x30, 0x6f, 0x1b, 0x8c, 0x04, 0x18, 0xb1, 0x83, 0x11, 0x01,
> + 0x21, 0x83, 0x38, 0x44, 0x00, 0x68, 0x31, 0x85, 0xa4, 0x02, 0x80, 0x7a,
> + 0x21, 0x8b, 0xd8, 0x43, 0x00, 0x68, 0x06, 0x46, 0xfc, 0xe1, 0xab, 0x00,
> + 0x0b, 0x8e, 0x78, 0x40, 0xf8, 0x6f, 0x1b, 0x94, 0x09, 0x12, 0x10, 0x60,
> + 0x1b, 0x90, 0x98, 0x79, 0xfc, 0x6f, 0x70, 0x12, 0x10, 0xe4, 0x1b, 0x00,
> + 0x0b, 0x92, 0xb8, 0x7f, 0xf4, 0xef, 0x11, 0x03, 0x21, 0x85, 0x31, 0x09,
> + 0x0b, 0x94, 0x58, 0x42, 0x00, 0xe8, 0x8b, 0x00, 0x0b, 0x8e, 0x18, 0x7f,
> + 0xf4, 0x6f, 0x1b, 0x90, 0x70, 0x12, 0x50, 0x64, 0x36, 0x54, 0x48, 0xe1,
> + 0x08, 0x42, 0x00, 0x68, 0x0b, 0x92, 0x0a, 0x00, 0x00, 0xfb, 0xb1, 0x54,
> + 0x00, 0x40, 0x0a, 0x40, 0xa0, 0xe0, 0xe5, 0xfc, 0x11, 0x01, 0x21, 0x85,
> + 0x31, 0x09, 0x0b, 0x90, 0xc8, 0x40, 0x00, 0xe8, 0x8b, 0x00, 0x0b, 0x8e,
> + 0x88, 0x7d, 0xf4, 0x6f, 0x1b, 0x90, 0x8e, 0x98, 0x4c, 0x0c, 0x7c, 0xf2,
> + 0x93, 0xdd, 0xc3, 0xc1, 0x1f, 0x25, 0x32, 0x40, 0x80, 0xf8, 0x1f, 0x86,
> + 0x93, 0x5d, 0x0f, 0xa2, 0x04, 0x80, 0x93, 0xdd, 0x0c, 0x00, 0x80, 0xfa,
> + 0xa8, 0x4c, 0x48, 0x6f, 0xe6, 0x40, 0x08, 0xe0, 0x0b, 0xa1, 0x95, 0x84,
> + 0xc8, 0x46, 0x40, 0xef, 0x86, 0x02, 0x84, 0x60, 0xc6, 0x04, 0x84, 0xe0,
> + 0x14, 0x04, 0x5a, 0x00, 0x08, 0xe0, 0x24, 0x88, 0x4a, 0x42, 0x08, 0x60,
> + 0x46, 0x02, 0x84, 0xe0, 0x0a, 0x42, 0x80, 0xe1, 0x0c, 0x00, 0x00, 0xe2,
> + 0x06, 0x84, 0xf6, 0x40, 0x08, 0xe0, 0x0c, 0x08, 0x80, 0xf2, 0xd8, 0x0a,
> + 0x48, 0xff, 0xc3, 0xc1, 0x0c, 0x04, 0x0c, 0xfa, 0xf0, 0x1e, 0x60, 0x6c,
> + 0xa6, 0x01, 0x04, 0xe0, 0x48, 0x4a, 0x48, 0xef, 0x0b, 0xa1, 0x15, 0x90,
> + 0xc8, 0x5d, 0x2c, 0xef, 0xe8, 0x7a, 0xf4, 0x6e, 0x0e, 0x02, 0x24, 0x74,
> + 0x03, 0xc0, 0x86, 0x50, 0x84, 0xe0, 0x69, 0x10, 0x44, 0xe0, 0x58, 0x7a,
> + 0xf4, 0x6e, 0x1b, 0x8c, 0x04, 0x60, 0x7b, 0x80, 0x1b, 0x00, 0x28, 0xe0,
> + 0x0b, 0x00, 0x24, 0xe0, 0x13, 0xa0, 0x10, 0x00, 0x04, 0x64, 0x1b, 0x8c,
> + 0x88, 0x79, 0xf4, 0xee, 0x14, 0xa0, 0x19, 0x02, 0x28, 0xe0, 0x19, 0xbe,
> + 0x06, 0x44, 0x06, 0x60, 0x06, 0x41, 0xdc, 0xe0, 0x04, 0x00, 0x16, 0x42,
> + 0x1e, 0xe0, 0x21, 0xbe, 0x1e, 0x7c, 0x27, 0xcb, 0x2c, 0x7c, 0x0e, 0x02,
> + 0x25, 0x74, 0x03, 0xc0, 0x48, 0x78, 0xf4, 0xee, 0x0e, 0x7e, 0x11, 0x81,
> + 0x1e, 0x09, 0xf0, 0x00, 0x10, 0xe4, 0x1c, 0x95, 0x88, 0x7e, 0x1c, 0xef,
> + 0x0a, 0x95, 0x18, 0x41, 0x00, 0x68, 0x01, 0xa0, 0x06, 0x00, 0x38, 0x61,
> + 0x11, 0x83, 0x78, 0x7c, 0x1c, 0xef, 0x18, 0x46, 0x48, 0x6f, 0xb6, 0x01,
> + 0x04, 0xe0, 0xf1, 0xb0, 0x0c, 0x0c, 0x0c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1,
> + 0x1b, 0x00, 0x06, 0x00, 0x38, 0xe1, 0x04, 0x80, 0x08, 0x35, 0xf4, 0x7f,
> + 0x01, 0xc8, 0xc3, 0xc1, 0x0c, 0x04, 0x3c, 0xfa, 0x86, 0x4e, 0x84, 0x60,
> + 0xf0, 0x1e, 0x20, 0xee, 0x84, 0x9c, 0x19, 0x0e, 0x48, 0xe0, 0x0a, 0xe2,
> + 0x2a, 0xe0, 0x03, 0xa4, 0x01, 0x82, 0x38, 0x75, 0xf4, 0x6e, 0x04, 0x00,
> + 0x80, 0xfb, 0x0b, 0x10, 0x64, 0x60, 0x6b, 0x80, 0x0b, 0xa1, 0x05, 0x0e,
> + 0x04, 0xc0, 0x99, 0x00, 0xa0, 0xc0, 0xd5, 0x84, 0x09, 0x10, 0x24, 0x60,
> + 0x06, 0x03, 0xd0, 0xe0, 0x1a, 0x84, 0x07, 0xc5, 0x09, 0x82, 0x1f, 0x21,
> + 0x06, 0x00, 0x04, 0xe0, 0x10, 0x42, 0x01, 0x70, 0xff, 0xc0, 0x17, 0xd1,
> + 0x1b, 0xa1, 0x78, 0x73, 0xf4, 0x6e, 0x16, 0x02, 0x00, 0x80, 0x00, 0x12,
> + 0x04, 0xec, 0x18, 0x42, 0x48, 0x6f, 0x36, 0x01, 0x04, 0xe0, 0x0b, 0xa1,
> + 0xb5, 0xb0, 0x04, 0x1c, 0x06, 0x11, 0xd0, 0xe0, 0x19, 0x10, 0x24, 0x6e,
> + 0x46, 0x05, 0xb8, 0xe0, 0xa4, 0x9e, 0x09, 0x00, 0xb0, 0xe0, 0x18, 0x08,
> + 0x5a, 0x02, 0x00, 0xe0, 0x1c, 0x06, 0x00, 0xe2, 0x36, 0x3e, 0x09, 0x86,
> + 0x0b, 0x21, 0x19, 0x82, 0x0c, 0x04, 0x00, 0x62, 0x0b, 0xa5, 0x16, 0x7c,
> + 0x64, 0x02, 0x80, 0xfb, 0x26, 0x3c, 0x6b, 0x9e, 0x1e, 0xbe, 0x19, 0x0e,
> + 0x60, 0xe0, 0x2b, 0x10, 0x30, 0xf8, 0x0c, 0x00, 0x00, 0xe2, 0x16, 0x1b,
> + 0x11, 0x81, 0x06, 0x7e, 0x2b, 0xa3, 0x19, 0x14, 0x5c, 0xc0, 0x09, 0x0e,
> + 0x80, 0xe0, 0x25, 0x10, 0xa4, 0xe3, 0x35, 0x10, 0xa8, 0x63, 0x10, 0x42,
> + 0x3c, 0xd0, 0x0c, 0x0b, 0x01, 0x81, 0x16, 0x1d, 0x11, 0x81, 0x26, 0x1f,
> + 0x46, 0x05, 0x04, 0xe0, 0x0c, 0x89, 0x06, 0x99, 0x06, 0xa5, 0x0c, 0x91,
> + 0x3e, 0x8b, 0x0e, 0x91, 0x0e, 0x8f, 0x0e, 0x0d, 0x60, 0x00, 0xa0, 0xe4,
> + 0x91, 0x5e, 0x90, 0xe0, 0xc8, 0x7a, 0xf4, 0xee, 0x09, 0x14, 0x58, 0xe0,
> + 0x19, 0x10, 0xf0, 0xf8, 0x0e, 0x3f, 0xfe, 0x41, 0x3d, 0x70, 0xff, 0xc0,
> + 0x1b, 0x25, 0xf6, 0x43, 0x3c, 0xe0, 0x05, 0x5e, 0x80, 0x60, 0x16, 0x00,
> + 0x00, 0x80, 0x15, 0x5e, 0x84, 0xe0, 0x01, 0x5e, 0x34, 0x80, 0x05, 0x14,
> + 0x18, 0xe0, 0x38, 0x47, 0x00, 0x68, 0x00, 0x40, 0xfc, 0x73, 0xff, 0xc7,
> + 0x2a, 0x20, 0x11, 0x91, 0x0e, 0x97, 0x78, 0x5d, 0xfc, 0x6f, 0x0b, 0x84,
> + 0x19, 0x10, 0xc0, 0xe9, 0x0e, 0xb7, 0x4a, 0x42, 0x80, 0xe0, 0xc5, 0x82,
> + 0x60, 0x00, 0xc0, 0x65, 0x11, 0xfb, 0x75, 0x81, 0x24, 0x37, 0x11, 0x82,
> + 0x2e, 0xc1, 0x24, 0x97, 0x25, 0x40, 0x44, 0xf8, 0x1b, 0xa1, 0x35, 0xfe,
> + 0xe5, 0x85, 0x04, 0x9e, 0x05, 0x00, 0x1c, 0xe0, 0x28, 0x45, 0x00, 0x68,
> + 0x00, 0x40, 0xfc, 0x73, 0xff, 0xc7, 0x14, 0x9e, 0x0e, 0x99, 0x05, 0x02,
> + 0x20, 0xe0, 0x98, 0x44, 0x00, 0x68, 0x00, 0x40, 0xfc, 0x73, 0xff, 0xc7,
> + 0x14, 0x9e, 0x0e, 0x9b, 0x05, 0x02, 0x24, 0xe0, 0x08, 0x44, 0x00, 0x68,
> + 0x00, 0x40, 0xfc, 0x73, 0xff, 0xc7, 0x2a, 0x22, 0x11, 0x91, 0x0e, 0x9d,
> + 0x48, 0x5a, 0xfc, 0x6f, 0x0b, 0x84, 0x2a, 0x60, 0x11, 0x91, 0x0e, 0xb9,
> + 0xe8, 0x59, 0xfc, 0x6f, 0x0b, 0x84, 0x2a, 0x62, 0x11, 0x91, 0x0e, 0xbb,
> + 0x88, 0x59, 0xfc, 0x6f, 0x0b, 0x84, 0x0e, 0xbd, 0x04, 0x9c, 0x09, 0x00,
> + 0x24, 0xe0, 0x0a, 0x40, 0x88, 0xe0, 0xa5, 0x84, 0x04, 0xb7, 0xf8, 0x7a,
> + 0xf4, 0x6e, 0x1b, 0x80, 0x14, 0xb9, 0x0e, 0xb7, 0xa8, 0x7a, 0xf4, 0x6e,
> + 0x0b, 0x82, 0x14, 0xbb, 0x0e, 0xb9, 0x58, 0x7a, 0xf4, 0x6e, 0x0b, 0x82,
> + 0x14, 0xbd, 0x0e, 0xbb, 0x08, 0x7a, 0xf4, 0x6e, 0x0b, 0x82, 0x0e, 0xbd,
> + 0x86, 0x41, 0x30, 0x61, 0x1b, 0x9e, 0xd8, 0x4c, 0x08, 0xef, 0x78, 0x75,
> + 0x44, 0x6f, 0x46, 0x01, 0x04, 0xe0, 0xf0, 0x1e, 0x20, 0xe6, 0x0c, 0x0c,
> + 0x3c, 0xf2, 0x93, 0xdd, 0x4c, 0x00, 0x00, 0xfa, 0x08, 0x74, 0x24, 0x6f,
> + 0x11, 0x8f, 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0x0c, 0x04, 0x7c, 0xfe,
> + 0x6b, 0x04, 0xf0, 0x1e, 0x60, 0xec, 0xb5, 0x0c, 0x10, 0xe0, 0x85, 0x0c,
> + 0x18, 0xe0, 0x79, 0x0c, 0x24, 0xe0, 0xa4, 0xda, 0x1e, 0x0b, 0x11, 0x81,
> + 0x0e, 0x7e, 0x0b, 0x96, 0x68, 0x79, 0xf4, 0xee, 0x0b, 0xa1, 0x15, 0x82,
> + 0x14, 0x18, 0x0b, 0x96, 0x88, 0x79, 0xf4, 0xee, 0x0b, 0xa1, 0xb5, 0x4c,
> + 0x00, 0xc0, 0x11, 0x01, 0x0b, 0x94, 0x98, 0x78, 0xf4, 0xee, 0x94, 0x18,
> + 0x0b, 0xa1, 0x05, 0x1e, 0x14, 0xc0, 0xbe, 0xbe, 0x75, 0x82, 0x0b, 0x14,
> + 0x1b, 0x92, 0xf8, 0x78, 0xf4, 0xee, 0x04, 0x0b, 0x0b, 0xa1, 0xa5, 0x4c,
> + 0x00, 0x40, 0xa0, 0x52, 0x00, 0xdc, 0xae, 0x7c, 0xab, 0x80, 0x77, 0x42,
> + 0x0b, 0x92, 0x15, 0x14, 0x1c, 0xfe, 0x58, 0x75, 0xf4, 0xee, 0x0b, 0x14,
> + 0x44, 0x60, 0x9b, 0x80, 0x88, 0x75, 0xf4, 0xee, 0xbb, 0x00, 0x0b, 0x92,
> + 0x08, 0x77, 0xf4, 0x6e, 0x1b, 0x96, 0x0b, 0xa1, 0x90, 0x56, 0x00, 0x1c,
> + 0xa0, 0x12, 0x88, 0xe4, 0xc8, 0x75, 0xf4, 0x6e, 0x0b, 0x96, 0xab, 0x00,
> + 0x01, 0x81, 0x01, 0x4c, 0x20, 0x60, 0x8b, 0xa1, 0x04, 0x7e, 0x76, 0x03,
> + 0x71, 0x7b, 0x34, 0xce, 0xac, 0xd8, 0x03, 0x8e, 0x00, 0x00, 0x70, 0xe7,
> + 0x0e, 0x89, 0x65, 0x88, 0x8b, 0xa3, 0x35, 0x08, 0x06, 0x02, 0x01, 0x00,
> + 0xc0, 0xcf, 0x58, 0x74, 0xf4, 0x6e, 0x0b, 0x96, 0x28, 0x73, 0xf4, 0x6e,
> + 0x8b, 0x80, 0x1b, 0x00, 0x0b, 0x96, 0x58, 0x73, 0xf4, 0xee, 0xd8, 0x49,
> + 0x00, 0xe8, 0x18, 0x74, 0xf4, 0x6e, 0x76, 0x03, 0x70, 0x7b, 0x34, 0xce,
> + 0x0b, 0xa1, 0x25, 0x84, 0x11, 0x01, 0x0b, 0x96, 0x48, 0x74, 0xf4, 0xee,
> + 0x0b, 0xa1, 0x80, 0x14, 0x04, 0x04, 0x80, 0x54, 0x00, 0xdc, 0x75, 0x81,
> + 0xc8, 0x70, 0xf4, 0x6e, 0x0b, 0x96, 0x58, 0x72, 0xf4, 0xee, 0xab, 0x80,
> + 0xac, 0xd8, 0x0a, 0xa4, 0x08, 0x71, 0xf4, 0xee, 0x04, 0x0b, 0x9b, 0x80,
> + 0x73, 0x80, 0x0b, 0x0e, 0x40, 0xe0, 0x98, 0x70, 0xf4, 0xee, 0xbb, 0x00,
> + 0xa4, 0x00, 0x80, 0xfb, 0x48, 0x70, 0xf4, 0xee, 0x1b, 0x00, 0x0b, 0x96,
> + 0x68, 0x49, 0x00, 0xe8, 0x1b, 0x00, 0x0b, 0x92, 0xc8, 0x47, 0x00, 0xe8,
> + 0xa8, 0x70, 0xf4, 0xee, 0x04, 0x09, 0xab, 0x80, 0xac, 0xd8, 0x9a, 0x80,
> + 0x9c, 0xda, 0x0b, 0x0e, 0x4c, 0xe0, 0x18, 0x6f, 0xf4, 0xee, 0x0b, 0x0e,
> + 0x48, 0x60, 0xbb, 0x80, 0xc8, 0x6e, 0xf4, 0xee, 0x8b, 0x00, 0x0b, 0x92,
> + 0x88, 0x6e, 0xf4, 0xee, 0x1b, 0x00, 0x0b, 0x90, 0xa8, 0x47, 0x00, 0xe8,
> + 0x1b, 0x00, 0x0b, 0x96, 0x08, 0x46, 0x00, 0xe8, 0xe8, 0x6e, 0xf4, 0xee,
> + 0xb4, 0x3e, 0x9b, 0x80, 0x84, 0xfc, 0x9c, 0xda, 0x1b, 0x96, 0xf8, 0x6d,
> + 0xf4, 0x6e, 0x0b, 0x90, 0x68, 0x44, 0x00, 0xe8, 0xe8, 0x6e, 0xf4, 0x6e,
> + 0x11, 0x81, 0x0b, 0xa1, 0x85, 0x8e, 0x11, 0x01, 0x0b, 0x96, 0xf8, 0x6d,
> + 0xf4, 0xee, 0x2a, 0x00, 0x00, 0x60, 0x0b, 0x94, 0x24, 0x7e, 0x1b, 0x92,
> + 0x34, 0x8b, 0xf8, 0x74, 0x18, 0xef, 0x58, 0x01, 0x01, 0x40, 0x00, 0x40,
> + 0x9b, 0x80, 0x0b, 0x16, 0x1b, 0x92, 0x78, 0x6d, 0xf4, 0xee, 0x0b, 0xa1,
> + 0x85, 0x82, 0x1a, 0xd8, 0x09, 0x0c, 0x20, 0xe0, 0x11, 0x82, 0x04, 0x09,
> + 0x0b, 0xa1, 0x1c, 0x58, 0x70, 0x00, 0x90, 0xc4, 0x0a, 0x80, 0x0c, 0xda,
> + 0x11, 0x01, 0x0b, 0x90, 0xe8, 0x6b, 0xf4, 0xee, 0x0b, 0xa1, 0xb5, 0x84,
> + 0x0b, 0x10, 0x1b, 0x92, 0x88, 0x6c, 0xf4, 0xee, 0x0b, 0xa1, 0xe5, 0x82,
> + 0x09, 0x0c, 0x20, 0xe0, 0x1a, 0xd8, 0x0b, 0xa1, 0x70, 0x0e, 0x98, 0x44,
> + 0x10, 0x00, 0x04, 0xec, 0x75, 0x5e, 0x10, 0xc0, 0x0c, 0xd8, 0x04, 0x89,
> + 0x0a, 0x80, 0x0c, 0xda, 0xf1, 0xb0, 0x0c, 0x0c, 0x7c, 0xf6, 0x93, 0xdd,
> + 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x00, 0x11, 0x81, 0xe8, 0x6a, 0xf4, 0xee,
> + 0x0b, 0xa1, 0x64, 0x0c, 0x7c, 0xdd, 0x0b, 0x8c, 0x0c, 0x0c, 0x00, 0xf2,
> + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x0c, 0xfa, 0x6b, 0x02, 0x7b, 0x80,
> + 0x08, 0x6a, 0xf4, 0xee, 0x8b, 0x00, 0x0b, 0x8e, 0x48, 0x69, 0xf4, 0x6e,
> + 0x1b, 0x8c, 0x0b, 0xa1, 0x70, 0x4c, 0x00, 0x1c, 0x8b, 0xa1, 0x70, 0x4c,
> + 0x00, 0xdc, 0x0b, 0x8c, 0x0c, 0x0c, 0x0c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1,
> + 0x4c, 0x04, 0x04, 0xfa, 0x6b, 0x02, 0x7b, 0x80, 0xa8, 0x68, 0xf4, 0xee,
> + 0x0b, 0xa1, 0x70, 0x4c, 0x00, 0x9c, 0x0b, 0x8c, 0x4c, 0x0c, 0x04, 0xf2,
> + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x00, 0x21, 0x81,
> + 0x04, 0x18, 0x31, 0x83, 0x68, 0x53, 0xfc, 0xef, 0x0e, 0x98, 0x0c, 0x0c,
> + 0x00, 0xf2, 0x93, 0xdd, 0x18, 0xa9, 0x00, 0x00, 0x38, 0x90, 0x40, 0x00,
> + 0x08, 0x14, 0xb8, 0xe0, 0x80, 0x2c, 0x40, 0x00, 0xa8, 0x3a, 0xe8, 0xe0,
> + 0x08, 0x9f, 0x40, 0x00, 0x28, 0x28, 0xb0, 0xe0, 0x18, 0x72, 0x40, 0x00,
> + 0x88, 0x19, 0xc8, 0xe0, 0xe0, 0xbb, 0x40, 0x00, 0x08, 0x0c, 0xa4, 0xe0,
> + 0xa8, 0xe3, 0x40, 0x00, 0x28, 0x13, 0x90, 0xe0, 0xf0, 0xec, 0x40, 0x00,
> + 0x68, 0x0d, 0x8c, 0xe0, 0x48, 0xa8, 0x40, 0x00, 0xa8, 0x3c, 0xac, 0xe0,
> + 0x28, 0xe4, 0x40, 0x00, 0x08, 0x0e, 0x94, 0xe0, 0xb8, 0xe2, 0x40, 0x00,
> + 0x28, 0x3d, 0x90, 0xe0, 0x90, 0xa7, 0x40, 0x00, 0xc8, 0x13, 0xb0, 0xe0,
> + 0x18, 0xc1, 0x40, 0x00, 0xa8, 0x2a, 0xa4, 0xe0, 0xa8, 0x91, 0x40, 0x00,
> + 0x68, 0x2f, 0xbc, 0xe0, 0x88, 0xf1, 0x40, 0x00, 0x08, 0x1c, 0x88, 0xe0,
> + 0xd0, 0x8e, 0x40, 0x00, 0xa8, 0x19, 0xb8, 0xe0, 0x38, 0x82, 0x40, 0x00,
> + 0x28, 0x38, 0xbc, 0xe0, 0x88, 0xe0, 0x40, 0x00, 0xa8, 0x0e, 0x98, 0xe0,
> + 0xd8, 0xe4, 0x40, 0x00, 0x68, 0x32, 0x94, 0xe0, 0x18, 0xd7, 0x40, 0x00,
> + 0x28, 0x2d, 0x9c, 0xe0, 0x40, 0xe8, 0x40, 0x00, 0x28, 0x19, 0x94, 0xe0,
> + 0xa8, 0x78, 0x40, 0x00, 0x28, 0x18, 0xcc, 0xe0, 0xf0, 0x95, 0x40, 0x00,
> + 0x48, 0x34, 0xbc, 0xe0, 0xa8, 0xd2, 0x40, 0x00, 0x48, 0x16, 0xa0, 0xe0,
> + 0x18, 0x52, 0x40, 0x00, 0x68, 0x2b, 0xe0, 0xe0, 0x00, 0xb9, 0x00, 0x00,
> + 0x23, 0xdb, 0x00, 0x00,
> +};
> +
> +static const u8 cut2_patch[] = {
> + 0x37, 0x00, 0x05, 0x00, 0x0c, 0x04, 0x3c, 0xfa, 0x86, 0x0e, 0x84, 0x60,
> + 0x06, 0x11, 0x84, 0xe0, 0x04, 0x1c, 0x06, 0x13, 0x88, 0xe1, 0x14, 0xa0,
> + 0x0d, 0xc2, 0x95, 0x80, 0x04, 0xa4, 0x0b, 0xa3, 0xb5, 0x88, 0x78, 0x6c,
> + 0x40, 0xef, 0x6b, 0x00, 0x46, 0x01, 0x84, 0xe0, 0x88, 0x53, 0x48, 0x6f,
> + 0x46, 0x15, 0x84, 0xe0, 0x6b, 0x25, 0xc6, 0x0d, 0x84, 0xe0, 0x95, 0x84,
> + 0x08, 0xa8, 0x4a, 0x00, 0xfc, 0xfb, 0x05, 0x84, 0x09, 0x12, 0x1c, 0xe0,
> + 0xa8, 0x46, 0x48, 0xef, 0x04, 0x1c, 0x11, 0x83, 0x16, 0x18, 0xc6, 0x04,
> + 0x84, 0xe0, 0x0e, 0x08, 0x01, 0x87, 0xf8, 0x6a, 0x40, 0xef, 0x46, 0x0c,
> + 0x84, 0xe0, 0x04, 0x1c, 0x11, 0x81, 0x16, 0x98, 0x0e, 0xa0, 0x06, 0x41,
> + 0x84, 0x60, 0xc6, 0x02, 0xd8, 0xe0, 0x04, 0x80, 0x08, 0x80, 0x06, 0x84,
> + 0x0c, 0x0c, 0x3c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x00, 0x80, 0xfa,
> + 0xc6, 0x40, 0x84, 0x60, 0x86, 0x43, 0xd8, 0xe0, 0x04, 0x80, 0x09, 0x00,
> + 0x18, 0xe1, 0x06, 0x84, 0x88, 0x41, 0x68, 0xef, 0x0c, 0x08, 0x80, 0xf2,
> + 0x48, 0x20, 0x68, 0xff, 0x1e, 0xc0, 0xb5, 0x00, 0x2c, 0xe0, 0xb4, 0x02,
> + 0x00, 0xfc, 0x15, 0x40, 0x2c, 0xe0, 0x19, 0x10, 0x31, 0x78, 0x01, 0x40,
> + 0x86, 0x04, 0x0c, 0xe0, 0x4a, 0x04, 0x00, 0x64, 0x31, 0x81, 0x30, 0x0a,
> + 0x04, 0x64, 0x4b, 0x82, 0x1b, 0x06, 0x3b, 0x8a, 0xc8, 0x44, 0xfc, 0x87,
> + 0x41, 0x50, 0x31, 0x78, 0x01, 0x40, 0xa1, 0xe1, 0xe6, 0x43, 0x99, 0x6c,
> + 0x10, 0xc0, 0x08, 0x42, 0x00, 0xf8, 0x00, 0x00, 0x03, 0xa9, 0x00, 0x00,
> + 0x30, 0x85, 0x40, 0x00, 0xa8, 0x16, 0xbc, 0xe0, 0xcc, 0xc1, 0x40, 0x00,
> + 0xa8, 0x35, 0x9c, 0xe0, 0xb0, 0xc9, 0x40, 0x00, 0x88, 0x37, 0x98, 0xe0,
> + 0x00, 0xb9, 0x00, 0x00, 0x49, 0xa7, 0x00, 0x00,
> +};
> +
> +struct vd55g0_patch {
> + const u8 *bin;
> + unsigned int size;
> + /* As FWPATCH_REVISION reads it: major in the high byte */
> + u16 version;
> +};
> +
> +static const struct vd55g0_patch vd55g0_patch_cut1 = {
> + .bin = cut1_patch,
> + .size = ARRAY_SIZE(cut1_patch),
> + .version = 0x020b, /* 2.11 */
> +};
> +
> +static const struct vd55g0_patch vd55g0_patch_cut2 = {
> + .bin = cut2_patch,
> + .size = ARRAY_SIZE(cut2_patch),
> + .version = 0x0005, /* 0.5 */
> +};
> +
> +static const char * const vd55g0_test_pattern_menu[] = {
> + "Disabled",
> + "Solid",
> + "Colorbar",
> + "Gradbar",
> + "Hgrey",
> + "Vgrey",
> + "Dgrey",
A bit more verbatim naming would seem possible for these. See e.g. how the
other test patterns are named.
> + "PN28",
> +};
> +
> +static const s64 vd55g0_ev_bias_menu[] = {
> + -3000, -2500, -2000, -1500, -1000, -500,
> + 0,
> + 500, 1000, 1500, 2000, 2500, 3000,
> +};
> +
> +static const char * const vd55g0_supply_name[] = {
> + "vcore",
> + "vddio",
> + "vana",
> +};
> +
> +enum vd55g0_bin_mode {
> + VD55G0_BIN_MODE_NORMAL,
> + VD55G0_BIN_MODE_DIGITAL_X2,
> +};
> +
> +enum vd55g0_gpio_modes {
> + VD55G0_GPIO_MODE_DISABLED,
> + VD55G0_GPIO_MODE_STROBE,
> +};
> +
> +struct vd55g0_mode_info {
> + u32 width;
> + u32 height;
> + struct v4l2_rect crop;
> +};
> +
> +struct vd55g0_fmt_desc {
> + u32 code;
> + u8 bpp;
> + u8 data_type;
> +};
> +
> +static const struct vd55g0_fmt_desc vd55g0_supported_codes[] = {
> + {
> + .code = MEDIA_BUS_FMT_Y8_1X8,
> + .bpp = 8,
> + .data_type = MIPI_CSI2_DT_RAW8,
> + },
> + {
> + .code = MEDIA_BUS_FMT_Y10_1X10,
> + .bpp = 10,
> + .data_type = MIPI_CSI2_DT_RAW10,
> + },
> +};
> +
> +static const struct vd55g0_mode_info vd55g0_mode_data[] = {
> + {
> + .width = VD55G0_WIDTH,
> + .height = VD55G0_HEIGHT,
> + .crop = {
> + .left = 0,
> + .top = 0,
> + .width = VD55G0_WIDTH,
> + .height = VD55G0_HEIGHT,
> + },
> + },
> + {
> + .width = 640,
> + .height = 600,
> + .crop = {
> + .left = 2,
> + .top = 2,
> + .width = 640,
> + .height = 600,
> + },
> + },
> + {
> + .width = 640,
> + .height = 480,
> + .crop = {
> + .left = 2,
> + .top = 62,
> + .width = 640,
> + .height = 480,
> + },
> + },
> + {
> + .width = 320,
> + .height = 240,
> + .crop = {
> + .left = 2,
> + .top = 62,
> + .width = 640,
> + .height = 480,
> + },
> + },
> +};
> +
> +enum vd55g0_expo_state {
> + VD55G0_EXP_AUTO,
> + VD55G0_EXP_FREEZE,
> + VD55G0_EXP_MANUAL
> +};
> +
> +struct vd55g0_dev {
> + struct i2c_client *i2c_client;
> + struct regmap *regmap;
> + struct v4l2_subdev sd;
> + struct media_pad pad;
> + struct regulator_bulk_data supplies[ARRAY_SIZE(vd55g0_supply_name)];
> + struct gpio_desc *reset_gpio;
> + struct clk *xclk;
> + u32 clk_freq;
> + u16 oif_ctrl;
> + u64 link_freq;
> + u16 revision;
> + u32 leds[VD55G0_NB_GPIOS];
> + unsigned int nb_leds;
> + /* Its lock is also the subdev state lock and protects all below */
> + struct v4l2_ctrl_handler ctrl_handler;
> + struct v4l2_ctrl *vblank_ctrl;
> + struct v4l2_ctrl *hblank_ctrl;
> + /* The flip cluster */
> + struct {
> + struct v4l2_ctrl *hflip_ctrl;
> + struct v4l2_ctrl *vflip_ctrl;
> + };
> + struct v4l2_ctrl *pattern_ctrl;
> + /* The auto exposure cluster, the auto control first */
> + struct {
> + struct v4l2_ctrl *ae_ctrl;
> + struct v4l2_ctrl *expo_ctrl;
> + struct v4l2_ctrl *again_ctrl;
> + struct v4l2_ctrl *dgain_ctrl;
> + };
> + struct v4l2_ctrl *ae_lock_ctrl;
> + /* What the last stream applied, for the next one to start from */
> + struct {
> + u16 expo;
> + u16 digital_gain;
> + u8 analog_gain;
> + } cold_start;
> +};
> +
> +static inline struct vd55g0_dev *to_vd55g0_dev(struct v4l2_subdev *sd)
> +{
> + return container_of(sd, struct vd55g0_dev, sd);
> +}
> +
> +static inline struct v4l2_subdev *ctrl_to_sd(struct v4l2_ctrl *ctrl)
> +{
> + return &container_of(ctrl->handler, struct vd55g0_dev,
> + ctrl_handler)->sd;
> +}
> +
> +static u8 get_bpp_by_code(__u32 code)
> +{
> + for (unsigned int i = 0; i < ARRAY_SIZE(vd55g0_supported_codes); i++) {
> + if (vd55g0_supported_codes[i].code == code)
> + return vd55g0_supported_codes[i].bpp;
> + }
> + /* Should never happen */
> + WARN(1, "Unsupported code %d. default to 8 bpp\n", code);
> + return 8;
> +}
> +
> +static u8 get_data_type_by_code(__u32 code)
> +{
> + for (unsigned int i = 0; i < ARRAY_SIZE(vd55g0_supported_codes); i++) {
> + if (vd55g0_supported_codes[i].code == code)
> + return vd55g0_supported_codes[i].data_type;
> + }
> + /* Should never happen */
> + WARN(1, "Unsupported code %d. default to MIPI_CSI2_DT_RAW8 data type\n",
> + code);
> + return MIPI_CSI2_DT_RAW8;
> +}
> +
> +#define vd55g0_read(sensor, reg, val, err) \
> + cci_read((sensor)->regmap, reg, val, err)
> +
> +#define vd55g0_write(sensor, reg, val, err) \
> + cci_write((sensor)->regmap, reg, val, err)
> +
> +static unsigned int get_chunk_size(struct vd55g0_dev *sensor)
> +{
> + const struct i2c_adapter_quirks *quirks =
> + sensor->i2c_client->adapter->quirks;
> + unsigned int max_write_len = VD55G0_WRITE_MULTIPLE_CHUNK_MAX;
> +
> + /* Each write also carries the two address bytes */
> + if (quirks && quirks->max_write_len > 2)
> + max_write_len = min(max_write_len, quirks->max_write_len - 2U);
> +
> + return max_write_len;
> +}
> +
> +static int vd55g0_write_array(struct vd55g0_dev *sensor, u32 reg,
> + unsigned int nb, const u8 *array)
> +{
> + const unsigned int chunk_size = get_chunk_size(sensor);
> + unsigned int addr = CCI_REG_ADDR(reg);
> + unsigned int sz;
> + int ret;
> +
> + while (nb) {
> + sz = min(nb, chunk_size);
> + ret = regmap_bulk_write(sensor->regmap, addr, array, sz);
> + if (ret < 0)
> + return ret;
> + nb -= sz;
> + addr += sz;
> + array += sz;
> + }
> +
> + return 0;
> +}
> +
> +static int vd55g0_poll_reg(struct vd55g0_dev *sensor, u32 reg, u8 poll_val,
> + unsigned int timeout_ms)
> +{
> + unsigned int val = 0;
> +
> + return regmap_read_poll_timeout(sensor->regmap, CCI_REG_ADDR(reg), val,
> + (val == poll_val), 10 * USEC_PER_MSEC,
> + timeout_ms * USEC_PER_MSEC);
> +}
> +
> +static int vd55g0_wait_state(struct vd55g0_dev *sensor, int state,
> + unsigned int timeout_ms)
> +{
> + return vd55g0_poll_reg(sensor, VD55G0_REG_SYSTEM_FSM, state,
> + timeout_ms);
> +}
> +
> +/* The MIPI bus is double data rate; 32 bits, as the range is checked */
> +static u32 vd55g0_mipi_rate(struct vd55g0_dev *sensor)
> +{
> + return sensor->link_freq * 2;
> +}
> +
> +static u32 vd55g0_pixel_rate(struct vd55g0_dev *sensor)
> +{
> + u32 mipi_rate = vd55g0_mipi_rate(sensor);
> +
> + return mipi_rate / (mipi_rate <= VD55G0_MIPI_RATE_FAST ? 6 : 8);
> +}
> +
> +static unsigned int vd55g0_line_length(struct vd55g0_dev *sensor)
> +{
> + return vd55g0_mipi_rate(sensor) <= VD55G0_MIPI_RATE_FAST ?
> + VD55G0_LINE_LENGTH_SLOW : VD55G0_LINE_LENGTH_FAST;
> +}
> +
> +static int vd55g0_check_clock_tree(struct vd55g0_dev *sensor)
> +{
> + struct device *dev = &sensor->i2c_client->dev;
> +
> + if (sensor->clk_freq < VD55G0_XCLK_FREQ_MIN ||
> + sensor->clk_freq > VD55G0_XCLK_FREQ_MAX) {
> + dev_err(dev,
> + "Only %lu Hz-%lu Hz clock range supported. Provided %u Hz\n",
> + VD55G0_XCLK_FREQ_MIN, VD55G0_XCLK_FREQ_MAX,
> + sensor->clk_freq);
> + return -EINVAL;
> + }
> +
> + /*
> + * The MIPI rate is an integer multiple of the input clock. The sensor
> + * would round any other rate down (UM2829 13.6), so it is refused
> + * rather than used.
> + */
> + if (sensor->link_freq < VD55G0_MIPI_RATE_MIN / 2 ||
> + sensor->link_freq > VD55G0_MIPI_RATE_MAX / 2) {
> + dev_err(dev,
> + "Only %luMbps-%luMbps data rate range supported. Provided link frequency %llu Hz\n",
> + VD55G0_MIPI_RATE_MIN / MEGA,
> + VD55G0_MIPI_RATE_MAX / MEGA, sensor->link_freq);
> + return -EINVAL;
> + }
> + if (vd55g0_mipi_rate(sensor) % sensor->clk_freq) {
> + dev_err(dev,
> + "Link frequency %llu Hz is not a multiple of half the %u Hz input clock\n",
> + sensor->link_freq, sensor->clk_freq);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int vd55g0_update_gpio_mode(struct vd55g0_dev *sensor, u32 mode,
> + unsigned int gpio)
> +{
> + static const u8 index2val[] = { 0x01, 0x02 };
> +
> + return vd55g0_write(sensor, VD55G0_REG_GPIO_0_CTRL + gpio,
> + index2val[mode], NULL);
> +}
> +
> +static int vd55g0_set_gpios_array(struct vd55g0_dev *sensor, u32 *array,
> + unsigned int size,
> + enum vd55g0_gpio_modes mode)
> +{
> + int ret;
> +
> + for (unsigned int i = 0; i < size; i++) {
> + if (array[i] == ~0)
> + break;
> + ret = vd55g0_update_gpio_mode(sensor, mode, array[i]);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int vd55g0_apply_exposure_mode(struct vd55g0_dev *sensor, bool is_auto,
> + bool locked)
> +{
> + enum vd55g0_expo_state exp = VD55G0_EXP_MANUAL;
> +
> + if (is_auto)
> + exp = locked ? VD55G0_EXP_FREEZE : VD55G0_EXP_AUTO;
> +
> + return vd55g0_write(sensor, VD55G0_REG_EXP_MODE, exp, NULL);
> +}
> +
> +static int vd55g0_get_regulators(struct vd55g0_dev *sensor)
> +{
> + struct device *dev = &sensor->i2c_client->dev;
> +
> + for (unsigned int i = 0; i < ARRAY_SIZE(vd55g0_supply_name); i++)
> + sensor->supplies[i].supply = vd55g0_supply_name[i];
> +
> + return devm_regulator_bulk_get(dev, ARRAY_SIZE(vd55g0_supply_name),
> + sensor->supplies);
> +}
> +
> +static int vd55g0_apply_patgen(struct vd55g0_dev *sensor, u32 index)
> +{
> + static const u8 index2val[] = {
> + 0x0, 0x0, 0x8, 0x10, 0x20, 0x21, 0x22, 0x28
> + };
> + u32 pattern = index2val[index];
> + u32 reg = pattern << VD55G0_PATGEN_TYPE_SHIFT;
> + u8 darkcal = VD55G0_DARKCAL_AUTO;
> + u8 duster = VD55G0_DUSTER_RING_ENABLE | VD55G0_DUSTER_DYN_ENABLE |
> + VD55G0_DUSTER_ENABLE;
> + int ret = 0;
> +
> + if (index) {
> + reg |= VD55G0_PATGEN_ENABLE;
> + /*
> + * Take care of dark calibaration and duster to not mess up the
> + * test pattern output.
> + */
> + darkcal = VD55G0_DARKCAL_BYPASS;
> + duster = VD55G0_DUSTER_DISABLE;
> + }
> +
> + vd55g0_write(sensor, VD55G0_REG_DARKCAL_CTRL, darkcal, &ret);
> + vd55g0_write(sensor, VD55G0_REG_DUSTER_CTRL, duster, &ret);
> + if (ret)
> + return ret;
> +
> + return vd55g0_write(sensor, VD55G0_REG_PATGEN_CTRL, reg, NULL);
> +}
> +
> +static int vd55g0_apply_flash(struct vd55g0_dev *sensor, u32 led_mode)
> +{
> + enum vd55g0_gpio_modes mode = led_mode == V4L2_FLASH_LED_MODE_NONE ?
> + VD55G0_GPIO_MODE_DISABLED :
> + VD55G0_GPIO_MODE_STROBE;
> +
> + return vd55g0_set_gpios_array(sensor, sensor->leds,
> + ARRAY_SIZE(sensor->leds), mode);
> +}
> +
> +static int vd55g0_apply_exposure_target(struct vd55g0_dev *sensor, u32 index)
> +{
> + /*
> + * Find auto exposure target with: default target exposure * 2^EV,
> + * the default being the firmware's 27, at index 6.
> + */
> + static const unsigned int index2exposure_target[] = {
> + 3, 5, 7, 10, 14, 19, 27, 38, 54, 76, 108, 153, 216,
> + };
> +
> + return vd55g0_write(sensor, VD55G0_REG_AE_TARGET_PERCENTAGE,
> + index2exposure_target[index], NULL);
> +}
> +
> +static void vd55g0_apply_reset(struct vd55g0_dev *sensor)
> +{
> + gpiod_set_value_cansleep(sensor->reset_gpio, 0);
> + usleep_range(5000, 10000);
> + gpiod_set_value_cansleep(sensor->reset_gpio, 1);
> + usleep_range(5000, 10000);
> + gpiod_set_value_cansleep(sensor->reset_gpio, 0);
> + usleep_range(5000, 10000);
> +}
> +
> +static void vd55g0_fill_framefmt(const struct vd55g0_mode_info *mode,
> + struct v4l2_mbus_framefmt *fmt, u32 code)
> +{
> + fmt->code = code;
> + fmt->width = mode->width;
> + fmt->height = mode->height;
> + fmt->colorspace = V4L2_COLORSPACE_RAW;
> + fmt->field = V4L2_FIELD_NONE;
> + fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
> + fmt->quantization = V4L2_QUANTIZATION_DEFAULT;
> + fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT;
> +}
> +
> +static const struct vd55g0_mode_info *
> +vd55g0_try_fmt(struct v4l2_mbus_framefmt *fmt)
> +{
> + const struct vd55g0_mode_info *mode;
> + u32 code = vd55g0_supported_codes[0].code;
> +
> + for (unsigned int i = 0; i < ARRAY_SIZE(vd55g0_supported_codes); i++) {
> + if (vd55g0_supported_codes[i].code == fmt->code)
> + code = fmt->code;
> + }
> +
> + mode = v4l2_find_nearest_size(vd55g0_mode_data,
> + ARRAY_SIZE(vd55g0_mode_data), width,
> + height, fmt->width, fmt->height);
> + vd55g0_fill_framefmt(mode, fmt, code);
> +
> + return mode;
> +}
> +
> +static int vd55g0_apply_cold_start(struct vd55g0_dev *sensor)
> +{
> + int ret = 0;
> +
> + vd55g0_write(sensor, VD55G0_REG_AE_COLDSTART_COARSE_EXPOSURE,
> + sensor->cold_start.expo, &ret);
> + vd55g0_write(sensor, VD55G0_REG_AE_COLDSTART_ANALOG_GAIN,
> + sensor->cold_start.analog_gain, &ret);
> + vd55g0_write(sensor, VD55G0_REG_AE_COLDSTART_DIGITAL_GAIN,
> + sensor->cold_start.digital_gain, &ret);
> +
> + return ret;
> +}
> +
> +static int vd55g0_apply_frame_format(struct vd55g0_dev *sensor,
> + const struct v4l2_mbus_framefmt *fmt,
> + const struct v4l2_rect *crop)
> +{
> + enum vd55g0_bin_mode bin_mode = fmt->width < crop->width ?
> + VD55G0_BIN_MODE_DIGITAL_X2 :
> + VD55G0_BIN_MODE_NORMAL;
> + int ret = 0;
> +
> + vd55g0_write(sensor, VD55G0_REG_FORMAT_CTRL, get_bpp_by_code(fmt->code),
> + &ret);
> + vd55g0_write(sensor, VD55G0_REG_OIF_IMG_CTRL,
> + get_data_type_by_code(fmt->code), &ret);
> + vd55g0_write(sensor, VD55G0_REG_READOUT_CTRL, bin_mode, &ret);
> + vd55g0_write(sensor, VD55G0_REG_ROI_X_START, crop->left, &ret);
> + vd55g0_write(sensor, VD55G0_REG_ROI_X_END,
> + crop->left + crop->width - 1, &ret);
> + vd55g0_write(sensor, VD55G0_REG_ROI_Y_START, crop->top, &ret);
> + vd55g0_write(sensor, VD55G0_REG_ROI_Y_END,
> + crop->top + crop->height - 1, &ret);
> +
> + /*
> + * Use the same auto exposure crop as the image crop, performing auto
> + * exposure computation only on image boundaries.
> + */
> + vd55g0_write(sensor, VD55G0_REG_AE_ROI_START_H, crop->left, &ret);
> + vd55g0_write(sensor, VD55G0_REG_AE_ROI_END_H,
> + crop->left + crop->width - 1, &ret);
> + vd55g0_write(sensor, VD55G0_REG_AE_ROI_START_V, crop->top, &ret);
> + vd55g0_write(sensor, VD55G0_REG_AE_ROI_END_V,
> + crop->top + crop->height - 1, &ret);
> +
> + return ret;
> +}
> +
> +/* GPIOs in input (disabled) by default; the LED control may strobe some */
> +static int vd55g0_disable_gpios(struct vd55g0_dev *sensor)
> +{
> + int ret;
> +
> + for (unsigned int i = 0; i < VD55G0_NB_GPIOS; i++) {
> + ret = vd55g0_update_gpio_mode(sensor,
> + VD55G0_GPIO_MODE_DISABLED, i);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int vd55g0_stream_enable(struct vd55g0_dev *sensor,
> + struct v4l2_subdev_state *state)
> +{
> + const struct v4l2_mbus_framefmt *fmt =
> + v4l2_subdev_state_get_format(state, 0);
> + const struct v4l2_rect *crop = v4l2_subdev_state_get_crop(state, 0);
> + struct device *dev = &sensor->i2c_client->dev;
> + int ret;
> +
> + ret = pm_runtime_resume_and_get(dev);
> + if (ret < 0)
> + return ret;
> +
> + ret = vd55g0_disable_gpios(sensor);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = vd55g0_apply_frame_format(sensor, fmt, crop);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = vd55g0_apply_cold_start(sensor);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = __v4l2_ctrl_handler_setup(&sensor->ctrl_handler);
> + if (ret)
> + goto err_rpm_put;
> +
> + /* HBLANK is read-only, so s_ctrl leaves the line length to us */
> + ret = vd55g0_write(sensor, VD55G0_REG_LINE_LENGTH,
> + crop->width + sensor->hblank_ctrl->cur.val, NULL);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = vd55g0_write(sensor, VD55G0_REG_SW_STBY,
> + VD55G0_SW_STBY_START_STREAM, NULL);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = vd55g0_poll_reg(sensor, VD55G0_REG_SW_STBY, 0, VD55G0_TIMEOUT_MS);
> + if (ret)
> + goto err_rpm_put;
> +
> + ret = vd55g0_wait_state(sensor, VD55G0_SYSTEM_FSM_STREAMING,
> + VD55G0_TIMEOUT_MS);
> + if (ret)
> + goto err_rpm_put;
> +
> + return 0;
> +
> +err_rpm_put:
> + pm_runtime_put(dev);
> + return ret;
> +}
> +
> +static void vd55g0_save_exposure(struct vd55g0_dev *sensor)
> +{
> + u64 val;
> +
> + /* On a read error, keep what the previous stream left */
> + if (!vd55g0_read(sensor, VD55G0_REG_APPLIED_COARSE_EXPOSURE, &val,
> + NULL))
> + sensor->cold_start.expo = val;
> + if (!vd55g0_read(sensor, VD55G0_REG_APPLIED_DIGITAL_GAIN, &val, NULL))
> + sensor->cold_start.digital_gain = val;
> + if (!vd55g0_read(sensor, VD55G0_REG_APPLIED_ANALOG_GAIN, &val, NULL))
> + sensor->cold_start.analog_gain = val;
> +}
> +
> +static void vd55g0_stream_disable(struct vd55g0_dev *sensor)
> +{
> + struct i2c_client *client = v4l2_get_subdevdata(&sensor->sd);
> + int ret;
> +
> + /* Keep exposure values for next cold start boot */
> + vd55g0_save_exposure(sensor);
> +
> + ret = vd55g0_write(sensor, VD55G0_REG_STREAMING,
> + VD55G0_STREAMING_STOP_STREAM, NULL);
> + if (ret)
> + goto err_str_dis;
> +
> + ret = vd55g0_poll_reg(sensor, VD55G0_REG_STREAMING, 0, 2000);
> + if (ret)
> + goto err_str_dis;
> +
> + ret = vd55g0_wait_state(sensor, VD55G0_SYSTEM_FSM_SW_STBY,
> + VD55G0_TIMEOUT_MS);
> +
> +err_str_dis:
> + if (ret)
> + dev_err(&client->dev, "failed to stop streaming: %d\n", ret);
> + pm_runtime_put_autosuspend(&client->dev);
> +}
> +
> +static int vd55g0_tx_from_ep(struct vd55g0_dev *sensor,
> + struct fwnode_handle *handle)
> +{
> + struct i2c_client *client = sensor->i2c_client;
> + struct v4l2_fwnode_endpoint ep = { .bus_type = V4L2_MBUS_CSI2_DPHY };
> + int ret;
> +
> + ret = v4l2_fwnode_endpoint_alloc_parse(handle, &ep);
> + if (ret)
> + return ret;
> +
> + /* The sensor has a single data lane */
> + if (ep.bus.mipi_csi2.num_data_lanes != 1) {
> + dev_err(&client->dev, "only one data lane is supported, found %u\n",
> + ep.bus.mipi_csi2.num_data_lanes);
> + goto error_ep;
> + }
> +
> + if (ep.bus.mipi_csi2.clock_lane != 0) {
> + dev_err(&client->dev, "clock lane must be lane 0\n");
> + goto error_ep;
> + }
> +
> + /* Only the two polarity bits: the rest of OIF_CTRL is reserved */
> + sensor->oif_ctrl = (ep.bus.mipi_csi2.lane_polarities[0] << 3) |
> + (ep.bus.mipi_csi2.lane_polarities[1] << 6);
> +
> + if (ep.nr_of_link_frequencies != 1) {
> + dev_err(&client->dev, "one link frequency is needed, found %u\n",
> + ep.nr_of_link_frequencies);
> + goto error_ep;
> + }
> + sensor->link_freq = ep.link_frequencies[0];
> +
> + v4l2_fwnode_endpoint_free(&ep);
> +
> + return 0;
> +
> +error_ep:
> + v4l2_fwnode_endpoint_free(&ep);
> +
> + return -EINVAL;
> +}
> +
> +static int vd55g0_patch(struct vd55g0_dev *sensor)
> +{
> + struct i2c_client *client = sensor->i2c_client;
> + const struct vd55g0_patch *patch;
> + u64 patch_version;
> + int ret;
> +
> + /* Choose appropriate patch for sensor revision */
> + if (sensor->revision == VD55G0_REVISION_CUT1)
> + patch = &vd55g0_patch_cut1;
> + else if (sensor->revision == VD55G0_REVISION_CUT2)
> + patch = &vd55g0_patch_cut2;
> + else
> + return -EINVAL;
> +
> + /* Write patch */
> + ret = vd55g0_write_array(sensor, VD55G0_REG_FWPATCH_START_ADDR,
> + patch->size, patch->bin);
> + if (ret)
> + return ret;
> +
> + ret = vd55g0_write(sensor, VD55G0_REG_BOOT,
> + VD55G0_BOOT_PATCH_SETUP, NULL);
> + if (ret)
> + return ret;
> +
> + ret = vd55g0_poll_reg(sensor, VD55G0_REG_BOOT, 0, VD55G0_TIMEOUT_MS);
> + if (ret)
> + return ret;
> +
> + /* Read back patch version */
> + ret = vd55g0_read(sensor, VD55G0_REG_FWPATCH_REVISION, &patch_version,
> + NULL);
> + if (ret)
> + return ret;
> +
> + if (patch_version != patch->version) {
> + dev_err(&client->dev,
> + "bad patch version expected %u.%u got %llu.%llu\n",
> + patch->version >> 8, patch->version & 0xff,
> + patch_version >> 8, patch_version & 0xff);
> + return -ENODEV;
> + }
> + dev_dbg(&client->dev, "patch %llu.%llu applied\n",
> + patch_version >> 8, patch_version & 0xff);
> +
> + return 0;
> +}
> +
> +static int vd55g0_boot(struct vd55g0_dev *sensor)
> +{
> + int ret;
> +
> + ret = vd55g0_write(sensor, VD55G0_REG_BOOT, VD55G0_BOOT_BOOT, NULL);
> + if (ret)
> + return ret;
> +
> + ret = vd55g0_poll_reg(sensor, VD55G0_REG_BOOT, 0, VD55G0_TIMEOUT_MS);
> + if (ret)
> + return ret;
> +
> + ret = vd55g0_wait_state(sensor, VD55G0_SYSTEM_FSM_SW_STBY,
> + VD55G0_TIMEOUT_MS);
> + if (ret)
> + return ret;
> +
> + return 0;
> +}
> +
> +static int vd55g0_configure(struct vd55g0_dev *sensor)
> +{
> + int ret = 0;
> +
> + /*
> + * PLL_PREDIV and PLL_MULT are not accessible. We rely on the firmware
> + * to set the correct multiplier for the clock. Hence we don't do
> + * anything more here.
> + */
> + vd55g0_write(sensor, VD55G0_REG_EXT_CLOCK, sensor->clk_freq, &ret);
> +
> + vd55g0_write(sensor, VD55G0_REG_OIF_CTRL, sensor->oif_ctrl, &ret);
> + /* The status lines are not exposed, so do not send them, as vd55g1 */
> + vd55g0_write(sensor, VD55G0_REG_ISL_ENABLE, 0, &ret);
> + vd55g0_write(sensor, VD55G0_REG_CLK_PLL_MIPI, vd55g0_mipi_rate(sensor),
> + &ret);
> +
> + return ret;
> +}
> +
> +/* Called with the control handler's lock held, which is the state lock */
> +static void vd55g0_grab_stream_ctrls(struct vd55g0_dev *sensor, bool grab)
> +{
> + __v4l2_ctrl_grab(sensor->vflip_ctrl, grab);
> + __v4l2_ctrl_grab(sensor->hflip_ctrl, grab);
> + __v4l2_ctrl_grab(sensor->pattern_ctrl, grab);
> +}
> +
> +static int vd55g0_enable_streams(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state, u32 pad,
> + u64 streams_mask)
> +{
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> + int ret;
> +
> + ret = vd55g0_stream_enable(sensor, state);
> + if (ret)
> + return ret;
> +
> + vd55g0_grab_stream_ctrls(sensor, true);
> +
> + return 0;
> +}
> +
> +static int vd55g0_disable_streams(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state, u32 pad,
> + u64 streams_mask)
> +{
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> +
> + /* Powered down either way, so report success as call_s_stream() does */
> + vd55g0_stream_disable(sensor);
> +
> + vd55g0_grab_stream_ctrls(sensor, false);
> +
> + return 0;
> +}
> +
> +static int vd55g0_get_selection(struct v4l2_subdev *sd,
> + const struct v4l2_subdev_client_info *ci,
> + struct v4l2_subdev_state *sd_state,
> + struct v4l2_subdev_selection *sel)
> +{
> + switch (sel->target) {
> + case V4L2_SEL_TGT_CROP:
> + sel->r = *v4l2_subdev_state_get_crop(sd_state, 0);
> + return 0;
> + case V4L2_SEL_TGT_NATIVE_SIZE:
> + case V4L2_SEL_TGT_CROP_DEFAULT:
> + case V4L2_SEL_TGT_CROP_BOUNDS:
> + sel->r.top = 0;
> + sel->r.left = 0;
> + sel->r.width = VD55G0_WIDTH;
> + sel->r.height = VD55G0_HEIGHT;
> + return 0;
> + }
> +
> + return -EINVAL;
> +}
> +
> +static int vd55g0_enum_mbus_code(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *sd_state,
> + struct v4l2_subdev_mbus_code_enum *code)
> +{
> + if (code->index >= ARRAY_SIZE(vd55g0_supported_codes))
> + return -EINVAL;
> +
> + code->code = vd55g0_supported_codes[code->index].code;
> +
> + return 0;
> +}
> +
> +/* Max exposure follows the frame length */
> +static int vd55g0_update_expo_range(struct vd55g0_dev *sensor,
> + unsigned int frame_length)
> +{
> + return __v4l2_ctrl_modify_range(sensor->expo_ctrl, 0,
> + frame_length - VD55G0_EXPO_MAX_TERM, 1,
> + VD55G0_EXPO_DEF);
> +}
> +
> +/* Blanking counts from the analogue crop, as in vd55g1 */
> +static int vd55g0_update_blanking(struct vd55g0_dev *sensor,
> + const struct v4l2_rect *crop)
> +{
> + unsigned int vblank_def = VD55G0_FRAME_LENGTH_DEF - crop->height;
> + unsigned int hblank = vd55g0_line_length(sensor) - crop->width;
> + int ret;
> +
> + ret = __v4l2_ctrl_modify_range(sensor->vblank_ctrl,
> + VD55G0_MIN_FRAME_LENGTH - crop->height,
> + 0xffff - crop->height, 1, vblank_def);
> + if (ret)
> + return ret;
> +
> + /* The range change may keep the old vblank; set the default */
> + ret = __v4l2_ctrl_s_ctrl(sensor->vblank_ctrl, vblank_def);
> + if (ret)
> + return ret;
> +
> + /* Also when vblank kept its value and s_ctrl was not called */
> + ret = vd55g0_update_expo_range(sensor, crop->height + vblank_def);
> + if (ret)
> + return ret;
> +
> + return __v4l2_ctrl_modify_range(sensor->hblank_ctrl, hblank, hblank, 1,
> + hblank);
> +}
> +
> +static int vd55g0_set_fmt(struct v4l2_subdev *sd,
> + const struct v4l2_subdev_client_info *ci,
> + struct v4l2_subdev_state *sd_state,
> + struct v4l2_subdev_format *format)
> +{
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> + const struct vd55g0_mode_info *mode;
> + struct v4l2_rect *crop;
> + bool crop_changed;
> +
> + /* The mode cannot change under a running stream */
> + if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE &&
> + media_entity_is_streaming(&sd->entity))
> + return -EBUSY;
> +
> + mode = vd55g0_try_fmt(&format->format);
> + *v4l2_subdev_state_get_format(sd_state, 0) = format->format;
> +
> + crop = v4l2_subdev_state_get_crop(sd_state, 0);
> + crop_changed = !v4l2_rect_equal(crop, &mode->crop);
> + *crop = mode->crop;
> +
> + /* The code alone leaves the blanking as the user set it */
> + if (format->which != V4L2_SUBDEV_FORMAT_ACTIVE || !crop_changed)
> + return 0;
> +
> + return vd55g0_update_blanking(sensor, crop);
> +}
> +
> +static int vd55g0_init_state(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *sd_state)
> +{
> + struct v4l2_subdev_format fmt = { 0 };
> +
> + vd55g0_fill_framefmt(&vd55g0_mode_data[VD55G0_DEFAULT_MODE],
> + &fmt.format, VD55G0_MEDIA_BUS_FMT_DEF);
> +
> + return vd55g0_set_fmt(sd, NULL, sd_state, &fmt);
> +}
> +
> +static int vd55g0_enum_frame_size(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *sd_state,
> + struct v4l2_subdev_frame_size_enum *fse)
> +{
> + unsigned int i;
> +
> + if (fse->index >= ARRAY_SIZE(vd55g0_mode_data))
> + return -EINVAL;
> +
> + for (i = 0; i < ARRAY_SIZE(vd55g0_supported_codes); i++)
> + if (vd55g0_supported_codes[i].code == fse->code)
> + break;
> + if (i == ARRAY_SIZE(vd55g0_supported_codes))
> + return -EINVAL;
> +
> + fse->min_width = vd55g0_mode_data[fse->index].width;
> + fse->max_width = fse->min_width;
> + fse->min_height = vd55g0_mode_data[fse->index].height;
> + fse->max_height = fse->min_height;
> +
> + return 0;
> +}
> +
> +static const struct v4l2_subdev_video_ops vd55g0_video_ops = {
> + .s_stream = v4l2_subdev_s_stream_helper,
> +};
> +
> +static const struct v4l2_subdev_pad_ops vd55g0_pad_ops = {
> + .enum_mbus_code = vd55g0_enum_mbus_code,
> + .get_fmt = v4l2_subdev_get_fmt,
> + .set_fmt = vd55g0_set_fmt,
> + .enable_streams = vd55g0_enable_streams,
> + .disable_streams = vd55g0_disable_streams,
> + .get_selection = vd55g0_get_selection,
> + .enum_frame_size = vd55g0_enum_frame_size,
> +};
> +
> +static const struct v4l2_subdev_ops vd55g0_subdev_ops = {
> + .video = &vd55g0_video_ops,
> + .pad = &vd55g0_pad_ops,
> +};
> +
> +static const struct v4l2_subdev_internal_ops vd55g0_internal_ops = {
> + .init_state = vd55g0_init_state,
> +};
> +
> +/*
> + * The manual values only in manual mode, written before the mode so that a
> + * switch to manual starts from them. On that switch all three are written:
> + * under auto exposure the sensor never had them.
> + */
> +static int vd55g0_update_expo_cluster(struct vd55g0_dev *sensor)
> +{
> + bool is_auto = sensor->ae_ctrl->val == V4L2_EXPOSURE_AUTO;
> + bool all = sensor->ae_ctrl->is_new;
> + int ret = 0;
> +
> + if (!is_auto) {
> + /* A range change under auto exposure did not clamp it */
> + sensor->expo_ctrl->val = min(sensor->expo_ctrl->val,
> + sensor->expo_ctrl->maximum);
> + if (all || sensor->expo_ctrl->is_new)
> + vd55g0_write(sensor, VD55G0_REG_MANUAL_COARSE_EXPOSURE,
> + sensor->expo_ctrl->val, &ret);
> + if (all || sensor->again_ctrl->is_new)
> + vd55g0_write(sensor, VD55G0_REG_MANUAL_ANALOG_GAIN,
> + sensor->again_ctrl->val, &ret);
> + if (all || sensor->dgain_ctrl->is_new)
> + vd55g0_write(sensor, VD55G0_REG_MANUAL_DIGITAL_GAIN,
> + sensor->dgain_ctrl->val, &ret);
> + if (ret)
> + return ret;
> + }
> +
> + if (sensor->ae_ctrl->is_new)
> + ret = vd55g0_apply_exposure_mode(sensor, is_auto,
> + sensor->ae_lock_ctrl->cur.val &
> + V4L2_LOCK_EXPOSURE);
> +
> + return ret;
> +}
> +
> +/* Under auto exposure, the manual controls read what the sensor applies */
> +static int vd55g0_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + struct vd55g0_dev *sensor = to_vd55g0_dev(ctrl_to_sd(ctrl));
> + struct device *dev = &sensor->i2c_client->dev;
> + u64 expo, again, dgain;
> + int ret = 0;
> +
> + /* Unpowered: the last stream's values, the next one's start */
> + if (!pm_runtime_get_if_in_use(dev)) {
> + sensor->expo_ctrl->val = min_t(u32, sensor->cold_start.expo,
> + sensor->expo_ctrl->maximum);
> + sensor->again_ctrl->val = sensor->cold_start.analog_gain;
> + sensor->dgain_ctrl->val = sensor->cold_start.digital_gain;
Couldn't these values be kept in the control handler? (I think you'd need
to set cur.val.)
> + return 0;
> + }
> +
> + vd55g0_read(sensor, VD55G0_REG_APPLIED_COARSE_EXPOSURE, &expo, &ret);
> + vd55g0_read(sensor, VD55G0_REG_APPLIED_ANALOG_GAIN, &again, &ret);
> + vd55g0_read(sensor, VD55G0_REG_APPLIED_DIGITAL_GAIN, &dgain, &ret);
> + if (!ret) {
> + sensor->expo_ctrl->val = min_t(u64, expo,
> + sensor->expo_ctrl->maximum);
> + sensor->again_ctrl->val = again;
> + sensor->dgain_ctrl->val = dgain;
> + }
> +
> + pm_runtime_put_autosuspend(dev);
> +
> + return ret;
> +}
> +
> +static int vd55g0_s_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + struct v4l2_subdev *sd = ctrl_to_sd(ctrl);
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> + struct device *dev = &sensor->i2c_client->dev;
> + struct v4l2_subdev_state *state =
> + v4l2_subdev_get_locked_active_state(sd);
> + const struct v4l2_rect *crop = v4l2_subdev_state_get_crop(state, 0);
> + bool is_auto, locked;
> + int ret;
> +
> + /* Read-only controls are set by the driver: nothing to apply */
> + if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
> + return 0;
> +
> + /* The exposure range follows vblank whether the sensor is on or not */
> + if (ctrl->id == V4L2_CID_VBLANK) {
> + ret = vd55g0_update_expo_range(sensor,
> + crop->height + ctrl->val);
> + if (ret) {
> + vd55g0_update_expo_range(sensor,
> + crop->height + ctrl->cur.val);
> + return ret;
> + }
> + }
> +
> + /* The sensor gets the values at the next stream start */
> + if (!pm_runtime_get_if_in_use(dev))
> + return 0;
> +
> + switch (ctrl->id) {
> + case V4L2_CID_HFLIP:
> + ret = vd55g0_write(sensor, VD55G0_REG_ORIENTATION,
> + sensor->hflip_ctrl->val |
> + (sensor->vflip_ctrl->val << 1), NULL);
> + break;
> + case V4L2_CID_TEST_PATTERN:
> + ret = vd55g0_apply_patgen(sensor, ctrl->val);
> + break;
> + case V4L2_CID_EXPOSURE_AUTO:
> + ret = vd55g0_update_expo_cluster(sensor);
> + break;
> + case V4L2_CID_3A_LOCK:
> + is_auto = sensor->ae_ctrl->cur.val == V4L2_EXPOSURE_AUTO;
> + locked = ctrl->val & V4L2_LOCK_EXPOSURE;
> + ret = vd55g0_apply_exposure_mode(sensor, is_auto, locked);
> + break;
> + case V4L2_CID_VBLANK:
> + ret = vd55g0_write(sensor, VD55G0_REG_FRAME_LENGTH,
> + crop->height + ctrl->val, NULL);
> + /* Not applied: put the exposure range back */
> + if (ret)
> + vd55g0_update_expo_range(sensor,
> + crop->height + ctrl->cur.val);
> + break;
> + case V4L2_CID_AUTO_EXPOSURE_BIAS:
> + /*
> + * We use auto exposure target percentage register to control
> + * exposure bias for more precision.
> + */
> + ret = vd55g0_apply_exposure_target(sensor, ctrl->val);
> + break;
> + case V4L2_CID_FLASH_LED_MODE:
> + ret = vd55g0_apply_flash(sensor, ctrl->val);
> + break;
> + default:
> + ret = -EINVAL;
> + break;
> + }
> +
> + pm_runtime_put_autosuspend(dev);
> +
> + return ret;
> +}
> +
> +static const struct v4l2_ctrl_ops vd55g0_ctrl_ops = {
> + .g_volatile_ctrl = vd55g0_g_volatile_ctrl,
> + .s_ctrl = vd55g0_s_ctrl,
> +};
> +
> +static int vd55g0_init_controls(struct vd55g0_dev *sensor)
> +{
> + const struct v4l2_ctrl_ops *ops = &vd55g0_ctrl_ops;
> + struct v4l2_ctrl_handler *hdl = &sensor->ctrl_handler;
> + /* What vd55g0_init_state() puts in the active state */
> + const struct v4l2_rect *crop =
> + &vd55g0_mode_data[VD55G0_DEFAULT_MODE].crop;
> + struct v4l2_fwnode_device_properties fwnode_props;
> + struct v4l2_ctrl *ctrl;
> + unsigned int patgen_size = ARRAY_SIZE(vd55g0_test_pattern_menu) - 1;
> + unsigned int hblank = vd55g0_line_length(sensor) - crop->width;
> + u32 pixel_rate = vd55g0_pixel_rate(sensor);
> + int ret;
> +
> + ret = v4l2_fwnode_device_parse(&sensor->i2c_client->dev, &fwnode_props);
> + if (ret)
> + return ret;
> +
> + v4l2_ctrl_handler_init(hdl, 16);
> + v4l2_ctrl_new_int_menu(hdl, ops, V4L2_CID_AUTO_EXPOSURE_BIAS,
> + ARRAY_SIZE(vd55g0_ev_bias_menu) - 1,
> + ARRAY_SIZE(vd55g0_ev_bias_menu) / 2,
> + vd55g0_ev_bias_menu);
> + ctrl = v4l2_ctrl_new_int_menu(hdl, ops, V4L2_CID_LINK_FREQ,
> + 0, 0, &sensor->link_freq);
> + if (ctrl)
> + ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_PIXEL_RATE, pixel_rate,
> + pixel_rate, 1, pixel_rate);
> + sensor->ae_ctrl = v4l2_ctrl_new_std_menu(hdl, ops,
> + V4L2_CID_EXPOSURE_AUTO, 1,
> + ~0x3, V4L2_EXPOSURE_AUTO);
> + sensor->again_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_ANALOGUE_GAIN,
> + 0, 24, 1, 0);
> + sensor->dgain_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_DIGITAL_GAIN,
> + 256, 2048, 1, 256);
> + sensor->ae_lock_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_3A_LOCK,
> + 0, 1, 0, 0);
> + /* Only when the firmware describes the LED GPIOs */
> + if (sensor->nb_leds)
> + v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,
> + V4L2_FLASH_LED_MODE_FLASH, ~0x7,
> + V4L2_FLASH_LED_MODE_NONE);
> +
> + /*
> + * Keep a pointer to these controls as we need to update them when
> + * setting the format
> + */
> + sensor->vblank_ctrl =
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VBLANK,
> + VD55G0_MIN_FRAME_LENGTH - crop->height,
> + 0xffff - crop->height, 1,
> + VD55G0_FRAME_LENGTH_DEF - crop->height);
> + sensor->hblank_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HBLANK,
> + hblank, hblank, 1, hblank);
> + if (sensor->hblank_ctrl)
> + sensor->hblank_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> + sensor->hflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP,
> + 0, 1, 1, 0);
> + sensor->vflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP,
> + 0, 1, 1, 0);
> + sensor->pattern_ctrl =
> + v4l2_ctrl_new_std_menu_items(hdl, ops, V4L2_CID_TEST_PATTERN,
> + patgen_size, 0, 0,
> + vd55g0_test_pattern_menu);
> + sensor->expo_ctrl =
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_EXPOSURE, 0,
> + VD55G0_FRAME_LENGTH_DEF -
> + VD55G0_EXPO_MAX_TERM, 1, VD55G0_EXPO_DEF);
> +
> + ret = v4l2_ctrl_new_fwnode_properties(hdl, ops, &fwnode_props);
> + if (ret)
> + goto free_ctrls;
> +
> + v4l2_ctrl_cluster(2, &sensor->hflip_ctrl);
> + v4l2_ctrl_auto_cluster(4, &sensor->ae_ctrl, V4L2_EXPOSURE_MANUAL, true);
> +
> + sensor->sd.ctrl_handler = hdl;
> +
> + return 0;
> +
> +free_ctrls:
> + return v4l2_ctrl_handler_free(hdl);
> +}
> +
> +static int vd55g0_detect(struct vd55g0_dev *sensor)
> +{
> + struct i2c_client *client = sensor->i2c_client;
> + u64 revision, id = 0;
> + int ret;
> +
> + ret = vd55g0_read(sensor, VD55G0_REG_MODEL_ID, &id, NULL);
> + if (ret)
> + return ret;
> +
> + if (id != VD55G0_MODEL_ID) {
> + dev_warn(&client->dev, "Unsupported sensor id %llx\n", id);
> + return -ENODEV;
> + }
> +
> + ret = vd55g0_read(sensor, VD55G0_REG_REVISION, &revision, NULL);
> + if (ret)
> + return ret;
> + dev_dbg(&client->dev, "Sensor revision 0x%llx\n", revision);
> +
> + if (revision != VD55G0_REVISION_CUT1 &&
> + revision != VD55G0_REVISION_CUT2) {
> + dev_err(&client->dev, "Unsupported device revision 0x%llx\n",
> + revision);
> + return -ENODEV;
> + }
> +
> + sensor->revision = revision;
> +
> + return 0;
> +}
> +
> +/* Power/clock management functions */
> +static int vd55g0_power_on(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct v4l2_subdev *sd = i2c_get_clientdata(client);
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> + int ret;
> +
> + ret = regulator_bulk_enable(ARRAY_SIZE(vd55g0_supply_name),
> + sensor->supplies);
> + if (ret) {
> + dev_err(&client->dev, "failed to enable regulators %d\n", ret);
> + return ret;
> + }
> +
> + ret = clk_prepare_enable(sensor->xclk);
> + if (ret) {
> + dev_err(&client->dev, "failed to enable clock %d\n", ret);
> + goto disable_bulk;
> + }
> +
> + if (sensor->reset_gpio)
> + vd55g0_apply_reset(sensor);
> +
> + ret = vd55g0_wait_state(sensor, VD55G0_SYSTEM_FSM_READY_TO_BOOT,
> + VD55G0_TIMEOUT_MS);
> + if (ret) {
> + dev_err(&client->dev, "sensor reset failed %d\n", ret);
> + goto disable_clock;
> + }
> +
> + ret = vd55g0_detect(sensor);
> + if (ret) {
> + dev_err(&client->dev, "sensor detect failed %d\n", ret);
> + goto disable_clock;
> + }
> +
> + ret = vd55g0_patch(sensor);
> + if (ret) {
> + dev_err(&client->dev, "sensor patch failed %d\n", ret);
> + goto disable_clock;
> + }
> +
> + ret = vd55g0_boot(sensor);
> + if (ret) {
> + dev_err(&client->dev, "sensor boot failed %d\n", ret);
> + goto disable_clock;
> + }
> +
> + ret = vd55g0_configure(sensor);
> + if (ret) {
> + dev_err(&client->dev, "sensor configuration failed %d\n", ret);
> + goto disable_clock;
> + }
> +
> + return 0;
> +
> +disable_clock:
> + gpiod_set_value_cansleep(sensor->reset_gpio, 1);
> + clk_disable_unprepare(sensor->xclk);
> +disable_bulk:
> + regulator_bulk_disable(ARRAY_SIZE(vd55g0_supply_name),
> + sensor->supplies);
> +
> + return ret;
> +}
> +
> +static int vd55g0_power_off(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct v4l2_subdev *sd = i2c_get_clientdata(client);
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> +
> + /* Hold the sensor in reset while its rails are off, as vd55g1 does */
> + gpiod_set_value_cansleep(sensor->reset_gpio, 1);
> + clk_disable_unprepare(sensor->xclk);
> + regulator_bulk_disable(ARRAY_SIZE(vd55g0_supply_name),
> + sensor->supplies);
> + return 0;
> +}
> +
> +static int vd55g0_parse_dt_gpios_array(struct vd55g0_dev *sensor,
> + char *prop_name, u32 *array, int *nb)
> +{
> + struct i2c_client *client = sensor->i2c_client;
> + int ret;
> +
> + *nb = device_property_count_u32(&client->dev, prop_name);
> + if (*nb == -EINVAL) {
> + /* Property not found */
> + *nb = 0;
> + return 0;
> + }
> + if (*nb < 0)
> + return *nb;
> + if (*nb > VD55G0_NB_GPIOS) {
> + dev_err(&client->dev, "%s lists %d GPIOs, the sensor has %d\n",
> + prop_name, *nb, VD55G0_NB_GPIOS);
> + return -EINVAL;
> + }
> +
> + ret = device_property_read_u32_array(&client->dev, prop_name, array,
> + *nb);
> + if (ret) {
> + dev_err(&client->dev, "Failed to read %s prop\n", prop_name);
> + return ret;
> + }
> +
> + for (unsigned int i = 0; i < *nb; i++) {
> + if (array[i] >= VD55G0_NB_GPIOS) {
> + dev_err(&client->dev, "invalid GPIO %d for leds\n",
> + array[i]);
> + return -EINVAL;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int vd55g0_parse_dt_gpios(struct vd55g0_dev *sensor)
> +{
> + int nb_gpios_leds;
> + int ret;
> +
> + memset(sensor->leds, ~0, sizeof(sensor->leds));
> +
> + ret = vd55g0_parse_dt_gpios_array(sensor, "st,leds", sensor->leds,
> + &nb_gpios_leds);
> + if (ret)
> + return ret;
> +
> + sensor->nb_leds = nb_gpios_leds;
> +
> + return 0;
> +}
> +
> +static int vd55g0_probe(struct i2c_client *client)
> +{
> + struct device *dev = &client->dev;
> + struct fwnode_handle *handle;
> + struct vd55g0_dev *sensor;
> + int ret;
> +
> + sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
> + if (!sensor)
> + return -ENOMEM;
> +
> + sensor->i2c_client = client;
> + sensor->regmap = devm_cci_regmap_init_i2c(client, 16);
> + if (IS_ERR(sensor->regmap))
> + return dev_err_probe(&client->dev, PTR_ERR(sensor->regmap),
> + "failed to init CCI\n");
> + sensor->cold_start.expo = 0x32;
> + sensor->cold_start.digital_gain = 256;
> + sensor->cold_start.analog_gain = 0;
> +
> + handle = fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 0, 0, 0);
> +
> + sensor->reset_gpio = devm_gpiod_get_optional(dev, "reset",
> + GPIOD_OUT_HIGH);
> + if (IS_ERR(sensor->reset_gpio)) {
> + ret = dev_err_probe(dev, PTR_ERR(sensor->reset_gpio),
> + "Failed to get reset gpio\n");
> + goto error_put_handle;
> + }
> +
> + ret = vd55g0_parse_dt_gpios(sensor);
> + if (ret) {
> + dev_err(dev, "Failed to get gpios\n");
> + goto error_put_handle;
> + }
> +
> + ret = vd55g0_tx_from_ep(sensor, handle);
> + if (ret) {
> + dev_err_probe(dev, ret, "Failed to parse endpoint\n");
> + goto error_put_handle;
> + }
> + fwnode_handle_put(handle);
> +
> + sensor->xclk = devm_v4l2_sensor_clk_get(dev, NULL);
> + if (IS_ERR(sensor->xclk))
> + return dev_err_probe(dev, PTR_ERR(sensor->xclk),
> + "failed to get xclk\n");
> +
> + sensor->clk_freq = clk_get_rate(sensor->xclk);
> + ret = vd55g0_check_clock_tree(sensor);
> + if (ret)
> + return ret;
> +
> + v4l2_i2c_subdev_init(&sensor->sd, client, &vd55g0_subdev_ops);
> + sensor->sd.internal_ops = &vd55g0_internal_ops;
> + sensor->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> + sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
> + sensor->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
> +
> + ret = vd55g0_get_regulators(sensor);
> + if (ret)
> + return dev_err_probe(&client->dev, ret,
> + "failed to get regulators\n");
> +
> + /* Power on once to check that the sensor answers */
> + ret = vd55g0_power_on(dev);
> + if (ret)
> + return ret;
> +
> + ret = vd55g0_init_controls(sensor);
> + if (ret) {
> + dev_err(&client->dev, "controls initialization failed %d\n",
> + ret);
> + goto error_power_off;
> + }
> +
> + sensor->sd.state_lock = sensor->ctrl_handler.lock;
> +
> + ret = media_entity_pads_init(&sensor->sd.entity, 1, &sensor->pad);
> + if (ret) {
> + dev_err(&client->dev, "pads init failed %d\n", ret);
> + goto error_handler_free;
> + }
> +
> + ret = v4l2_subdev_init_finalize(&sensor->sd);
> + if (ret) {
> + dev_err(&client->dev, "subdev init error %d\n", ret);
> + goto error_media_entity;
> + }
> +
> + /* Held until registered, so that runtime PM cannot power it down */
> + pm_runtime_set_active(dev);
> + pm_runtime_get_noresume(dev);
Please drop this.
> + pm_runtime_enable(dev);
> + pm_runtime_set_autosuspend_delay(dev, 1000);
> + pm_runtime_use_autosuspend(dev);
> +
> + ret = v4l2_async_register_subdev_sensor(&sensor->sd);
> + if (ret) {
> + dev_err_probe(dev, ret, "async subdev register failed\n");
> + goto error_pm_runtime;
> + }
> +
> + pm_runtime_put_autosuspend(dev);
And replace this by:
pm_runtime_idle();
> +
> + dev_dbg(&client->dev, "vd55g0 probe successfully\n");
> +
> + return 0;
> +
> +error_put_handle:
> + fwnode_handle_put(handle);
> +
> + return ret;
> +
> +error_pm_runtime:
> + pm_runtime_disable(dev);
> + pm_runtime_set_suspended(dev);
> + pm_runtime_put_noidle(dev);
Drop this.
> + v4l2_subdev_cleanup(&sensor->sd);
> +error_media_entity:
> + media_entity_cleanup(&sensor->sd.entity);
> +error_handler_free:
> + v4l2_ctrl_handler_free(sensor->sd.ctrl_handler);
> +error_power_off:
> + vd55g0_power_off(dev);
> +
> + return ret;
> +}
> +
> +static void vd55g0_remove(struct i2c_client *client)
> +{
> + struct v4l2_subdev *sd = i2c_get_clientdata(client);
> + struct vd55g0_dev *sensor = to_vd55g0_dev(sd);
> +
> + v4l2_async_unregister_subdev(&sensor->sd);
> + v4l2_subdev_cleanup(&sensor->sd);
> + media_entity_cleanup(&sensor->sd.entity);
> + v4l2_ctrl_handler_free(sensor->sd.ctrl_handler);
> +
> + pm_runtime_disable(&client->dev);
> + if (!pm_runtime_status_suspended(&client->dev))
> + vd55g0_power_off(&client->dev);
> + pm_runtime_set_suspended(&client->dev);
This also needs to be conditional to the Runtime PM status not being
suspended here.
> +}
> +
> +static const struct of_device_id vd55g0_dt_ids[] = {
> + { .compatible = "st,vd55g0" },
> + { /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, vd55g0_dt_ids);
> +
> +static const struct acpi_device_id vd55g0_acpi_ids[] = {
> + { "SMO55F0" },
> + { /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(acpi, vd55g0_acpi_ids);
> +
> +static const struct dev_pm_ops vd55g0_pm_ops = {
> + RUNTIME_PM_OPS(vd55g0_power_off, vd55g0_power_on, NULL)
> +};
> +
> +static struct i2c_driver vd55g0_i2c_driver = {
> + .driver = {
> + .name = "vd55g0",
> + .of_match_table = vd55g0_dt_ids,
> + .acpi_match_table = vd55g0_acpi_ids,
> + .pm = pm_ptr(&vd55g0_pm_ops),
> + },
> + .probe = vd55g0_probe,
> + .remove = vd55g0_remove,
> +};
> +
> +module_i2c_driver(vd55g0_i2c_driver);
> +
> +MODULE_AUTHOR("Benjamin Mugnier <benjamin.mugnier@foss.st.com>");
> +MODULE_AUTHOR("Mickael Guene <mickael.guene@st.com>");
> +MODULE_AUTHOR("Sylvain Petinot <sylvain.petinot@foss.st.com>");
> +MODULE_AUTHOR("Sergey Lebedev <lsa.uz@pm.me>");
> +MODULE_DESCRIPTION("VD55G0 camera subdev driver");
> +MODULE_LICENSE("GPL");
--
Regards,
Sakari Ailus
next prev parent reply other threads:[~2026-11-20 11:44 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-14 9:58 [PATCH v5 0/6] media: Add the ST VD55G0 global shutter sensor Sergey Lebedev
2026-11-14 9:58 ` [PATCH v5 1/6] dt-bindings: media: i2c: st,vd55g1: Add ST VD55G0 Sergey Lebedev
2026-11-14 9:58 ` [PATCH v5 2/6] media: i2c: Add ST VD55G0 global shutter sensor driver Sergey Lebedev
2026-11-20 11:44 ` Sakari Ailus [this message]
2026-11-14 9:58 ` [PATCH v5 3/6] platform/x86: int3472: Map the VD55G0 supplies to "vddio" and "vana" Sergey Lebedev
2026-11-14 9:58 ` [PATCH v5 4/6] media: ipu-bridge: Add ST VD55G0 Sergey Lebedev
2026-11-14 9:58 ` [PATCH v5 5/6] media: ipu-bridge: Index the sensor device properties as the endpoint ones Sergey Lebedev
2026-11-14 9:59 ` [PATCH v5 6/6] media: ipu-bridge: Add the Surface Pro 8, 9 and 11 infrared illuminator Sergey Lebedev
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=awAyiCEXYnf2TJpC@kekkonen.localdomain \
--to=sakari.ailus@linux.intel.com \
--cc=benjamin.mugnier@foss.st.com \
--cc=conor+dt@kernel.org \
--cc=dan.scally@ideasonboard.com \
--cc=devicetree@vger.kernel.org \
--cc=dmanresa@gmail.com \
--cc=emfox@debian.org \
--cc=fernandorimoli11@gmail.com \
--cc=fqwqf@fqwqf.xyz \
--cc=geocausa@gmail.com \
--cc=hansg@kernel.org \
--cc=hao.yao@intel.com \
--cc=ilpo.jarvinen@linux.intel.com \
--cc=krzk+dt@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-media@vger.kernel.org \
--cc=lsa.uz@pm.me \
--cc=mchehab@kernel.org \
--cc=platform-driver-x86@vger.kernel.org \
--cc=pm@petermarshall.ca \
--cc=robh@kernel.org \
--cc=sylvain.petinot@foss.st.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®