drivers/media/i2c/m5mols/m5mols.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Header for M-5MOLS 8M Pixel camera sensor with ISP
   4  *
   5  * Copyright (C) 2011 Samsung Electronics Co., Ltd.
   6  * Author: HeungJun Kim <riverful.kim@samsung.com>
   7  *
   8  * Copyright (C) 2009 Samsung Electronics Co., Ltd.
   9  * Author: Dongsoo Nathaniel Kim <dongsoo45.kim@samsung.com>
  10  */
  11
  12 #ifndef M5MOLS_H
  13 #define M5MOLS_H
  14
  15 #include <linux/sizes.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <media/v4l2-subdev.h>
  18 #include "m5mols_reg.h"
  19
  20
  21 /* An amount of data transmitted in addition to the value
  22  * determined by CAPP_JPEG_SIZE_MAX register.
  23  */
  24 #define M5MOLS_JPEG_TAGS_SIZE           0x20000
  25 #define M5MOLS_MAIN_JPEG_SIZE_MAX       (5 * SZ_1M)
  26
  27 extern int m5mols_debug;
  28
  29 enum m5mols_restype {
  30         M5MOLS_RESTYPE_MONITOR,
  31         M5MOLS_RESTYPE_CAPTURE,
  32         M5MOLS_RESTYPE_MAX,
  33 };
  34
  35 /**
  36  * struct m5mols_resolution - structure for the resolution
  37  * @type: resolution type according to the pixel code
  38  * @width: width of the resolution
  39  * @height: height of the resolution
  40  * @reg: resolution preset register value
  41  */
  42 struct m5mols_resolution {
  43         u8 reg;
  44         enum m5mols_restype type;
  45         u16 width;
  46         u16 height;
  47 };
  48
  49 /**
  50  * struct m5mols_exif - structure for the EXIF information of M-5MOLS
  51  * @exposure_time: exposure time register value
  52  * @shutter_speed: speed of the shutter register value
  53  * @aperture: aperture register value
  54  * @brightness: brightness register value
  55  * @exposure_bias: it calls also EV bias
  56  * @iso_speed: ISO register value
  57  * @flash: status register value of the flash
  58  * @sdr: status register value of the Subject Distance Range
  59  * @qval: not written exact meaning in document
  60  */
  61 struct m5mols_exif {
  62         u32 exposure_time;
  63         u32 shutter_speed;
  64         u32 aperture;
  65         u32 brightness;
  66         u32 exposure_bias;
  67         u16 iso_speed;
  68         u16 flash;
  69         u16 sdr;
  70         u16 qval;
  71 };
  72
  73 /**
  74  * struct m5mols_capture - Structure for the capture capability
  75  * @exif: EXIF information
  76  * @buf_size: internal JPEG frame buffer size, in bytes
  77  * @main: size in bytes of the main image
  78  * @thumb: size in bytes of the thumb image, if it was accompanied
  79  * @total: total size in bytes of the produced image
  80  */
  81 struct m5mols_capture {
  82         struct m5mols_exif exif;
  83         unsigned int buf_size;
  84         u32 main;
  85         u32 thumb;
  86         u32 total;
  87 };
  88
  89 /**
  90  * struct m5mols_scenemode - structure for the scenemode capability
  91  * @metering: metering light register value
  92  * @ev_bias: EV bias register value
  93  * @wb_mode: mode which means the WhiteBalance is Auto or Manual
  94  * @wb_preset: whitebalance preset register value in the Manual mode
  95  * @chroma_en: register value whether the Chroma capability is enabled or not
  96  * @chroma_lvl: chroma's level register value
  97  * @edge_en: register value Whether the Edge capability is enabled or not
  98  * @edge_lvl: edge's level register value
  99  * @af_range: Auto Focus's range
 100  * @fd_mode: Face Detection mode
 101  * @mcc: Multi-axis Color Conversion which means emotion color
 102  * @light: status of the Light
 103  * @flash: status of the Flash
 104  * @tone: Tone color which means Contrast
 105  * @iso: ISO register value
 106  * @capt_mode: Mode of the Image Stabilization while the camera capturing
 107  * @wdr: Wide Dynamic Range register value
 108  *
 109  * The each value according to each scenemode is recommended in the documents.
 110  */
 111 struct m5mols_scenemode {
 112         u8 metering;
 113         u8 ev_bias;
 114         u8 wb_mode;
 115         u8 wb_preset;
 116         u8 chroma_en;
 117         u8 chroma_lvl;
 118         u8 edge_en;
 119         u8 edge_lvl;
 120         u8 af_range;
 121         u8 fd_mode;
 122         u8 mcc;
 123         u8 light;
 124         u8 flash;
 125         u8 tone;
 126         u8 iso;
 127         u8 capt_mode;
 128         u8 wdr;
 129 };
 130
 131 #define VERSION_STRING_SIZE     22
 132
 133 /**
 134  * struct m5mols_version - firmware version information
 135  * @customer:   customer information
 136  * @project:    version of project information according to customer
 137  * @fw:         firmware revision
 138  * @hw:         hardware revision
 139  * @param:      version of the parameter
 140  * @awb:        Auto WhiteBalance algorithm version
 141  * @str:        information about manufacturer and packaging vendor
 142  * @af:         Auto Focus version
 143  *
 144  * The register offset starts the customer version at 0x0, and it ends
 145  * the awb version at 0x09. The customer, project information occupies 1 bytes
 146  * each. And also the fw, hw, param, awb each requires 2 bytes. The str is
 147  * unique string associated with firmware's version. It includes information
 148  * about manufacturer and the vendor of the sensor's packaging. The least
 149  * significant 2 bytes of the string indicate packaging manufacturer.
 150  */
 151 struct m5mols_version {
 152         u8      customer;
 153         u8      project;
 154         u16     fw;
 155         u16     hw;
 156         u16     param;
 157         u16     awb;
 158         u8      str[VERSION_STRING_SIZE];
 159         u8      af;
 160 };
 161
 162 /**
 163  * struct m5mols_info - M-5MOLS driver data structure
 164  * @pdata: platform data
 165  * @sd: v4l-subdev instance
 166  * @pad: media pad
 167  * @irq_waitq: waitqueue for the capture
 168  * @irq_done: set to 1 in the interrupt handler
 169  * @handle: control handler
 170  * @auto_exposure: auto/manual exposure control
 171  * @exposure_bias: exposure compensation control
 172  * @exposure: manual exposure control
 173  * @metering: exposure metering control
 174  * @auto_iso: auto/manual ISO sensitivity control
 175  * @iso: manual ISO sensitivity control
 176  * @auto_wb: auto white balance control
 177  * @lock_3a: 3A lock control
 178  * @colorfx: color effect control
 179  * @saturation: saturation control
 180  * @zoom: zoom control
 181  * @wdr: wide dynamic range control
 182  * @stabilization: image stabilization control
 183  * @jpeg_quality: JPEG compression quality control
 184  * @set_power: optional power callback to the board code
 185  * @reset: GPIO driving the reset pin of M-5MOLS
 186  * @lock: mutex protecting the structure fields below
 187  * @ffmt: current fmt according to resolution type
 188  * @res_type: current resolution type
 189  * @ver: information of the version
 190  * @cap: the capture mode attributes
 191  * @isp_ready: 1 when the ISP controller has completed booting
 192  * @power: current sensor's power status
 193  * @ctrl_sync: 1 when the control handler state is restored in H/W
 194  * @resolution: register value for current resolution
 195  * @mode: register value for current operation mode
 196  */
 197 struct m5mols_info {
 198         const struct m5mols_platform_data *pdata;
 199         struct v4l2_subdev sd;
 200         struct media_pad pad;
 201
 202         wait_queue_head_t irq_waitq;
 203         atomic_t irq_done;
 204
 205         struct v4l2_ctrl_handler handle;
 206         struct {
 207                 /* exposure/exposure bias/auto exposure cluster */
 208                 struct v4l2_ctrl *auto_exposure;
 209                 struct v4l2_ctrl *exposure_bias;
 210                 struct v4l2_ctrl *exposure;
 211                 struct v4l2_ctrl *metering;
 212         };
 213         struct {
 214                 /* iso/auto iso cluster */
 215                 struct v4l2_ctrl *auto_iso;
 216                 struct v4l2_ctrl *iso;
 217         };
 218         struct v4l2_ctrl *auto_wb;
 219
 220         struct v4l2_ctrl *lock_3a;
 221         struct v4l2_ctrl *colorfx;
 222         struct v4l2_ctrl *saturation;
 223         struct v4l2_ctrl *zoom;
 224         struct v4l2_ctrl *wdr;
 225         struct v4l2_ctrl *stabilization;
 226         struct v4l2_ctrl *jpeg_quality;
 227
 228         int (*set_power)(struct device *dev, int on);
 229         struct gpio_desc *reset;
 230
 231         struct mutex lock;
 232
 233         struct v4l2_mbus_framefmt ffmt[M5MOLS_RESTYPE_MAX];
 234         int res_type;
 235
 236         struct m5mols_version ver;
 237         struct m5mols_capture cap;
 238
 239         unsigned int isp_ready:1;
 240         unsigned int power:1;
 241         unsigned int ctrl_sync:1;
 242
 243         u8 resolution;
 244         u8 mode;
 245 };
 246
 247 #define is_available_af(__info) (__info->ver.af)
 248 #define is_code(__code, __type) (__code == m5mols_default_ffmt[__type].code)
 249 #define is_manufacturer(__info, __manufacturer) \
 250                                 (__info->ver.str[0] == __manufacturer[0] && \
 251                                  __info->ver.str[1] == __manufacturer[1])
 252 /*
 253  * I2C operation of the M-5MOLS
 254  *
 255  * The I2C read operation of the M-5MOLS requires 2 messages. The first
 256  * message sends the information about the command, command category, and total
 257  * message size. The second message is used to retrieve the data specified in
 258  * the first message
 259  *
 260  *   1st message                                2nd message
 261  *   +-------+---+----------+-----+-------+     +------+------+------+------+
 262  *   | size1 | R | category | cmd | size2 |     | d[0] | d[1] | d[2] | d[3] |
 263  *   +-------+---+----------+-----+-------+     +------+------+------+------+
 264  *   - size1: message data size(5 in this case)
 265  *   - size2: desired buffer size of the 2nd message
 266  *   - d[0..3]: according to size2
 267  *
 268  * The I2C write operation needs just one message. The message includes
 269  * category, command, total size, and desired data.
 270  *
 271  *   1st message
 272  *   +-------+---+----------+-----+------+------+------+------+
 273  *   | size1 | W | category | cmd | d[0] | d[1] | d[2] | d[3] |
 274  *   +-------+---+----------+-----+------+------+------+------+
 275  *   - d[0..3]: according to size1
 276  */
 277 int m5mols_read_u8(struct v4l2_subdev *sd, u32 reg_comb, u8 *val);
 278 int m5mols_read_u16(struct v4l2_subdev *sd, u32 reg_comb, u16 *val);
 279 int m5mols_read_u32(struct v4l2_subdev *sd, u32 reg_comb, u32 *val);
 280 int m5mols_write(struct v4l2_subdev *sd, u32 reg_comb, u32 val);
 281
 282 int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,
 283                      int timeout);
 284
 285 /* Mask value for busy waiting until M-5MOLS I2C interface is initialized */
 286 #define M5MOLS_I2C_RDY_WAIT_FL          (1 << 16)
 287 /* ISP state transition timeout, in ms */
 288 #define M5MOLS_MODE_CHANGE_TIMEOUT      200
 289 #define M5MOLS_BUSY_WAIT_DEF_TIMEOUT    250
 290
 291 /*
 292  * Mode operation of the M-5MOLS
 293  *
 294  * Changing the mode of the M-5MOLS is needed right executing order.
 295  * There are three modes(PARAMETER, MONITOR, CAPTURE) which can be changed
 296  * by user. There are various categories associated with each mode.
 297  *
 298  * +============================================================+
 299  * | mode       | category                                      |
 300  * +============================================================+
 301  * | FLASH      | FLASH(only after Stand-by or Power-on)        |
 302  * | SYSTEM     | SYSTEM(only after sensor arm-booting)         |
 303  * | PARAMETER  | PARAMETER                                     |
 304  * | MONITOR    | MONITOR(preview), Auto Focus, Face Detection  |
 305  * | CAPTURE    | Single CAPTURE, Preview(recording)            |
 306  * +============================================================+
 307  *
 308  * The available executing order between each modes are as follows:
 309  *   PARAMETER <---> MONITOR <---> CAPTURE
 310  */
 311 int m5mols_set_mode(struct m5mols_info *info, u8 mode);
 312
 313 int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg);
 314 int m5mols_wait_interrupt(struct v4l2_subdev *sd, u8 condition, u32 timeout);
 315 int m5mols_restore_controls(struct m5mols_info *info);
 316 int m5mols_start_capture(struct m5mols_info *info);
 317 int m5mols_do_scenemode(struct m5mols_info *info, u8 mode);
 318 int m5mols_lock_3a(struct m5mols_info *info, bool lock);
 319 int m5mols_set_ctrl(struct v4l2_ctrl *ctrl);
 320 int m5mols_init_controls(struct v4l2_subdev *sd);
 321
 322 /* The firmware function */
 323 int m5mols_update_fw(struct v4l2_subdev *sd,
 324                      int (*set_power)(struct m5mols_info *, bool));
 325
 326 static inline struct m5mols_info *to_m5mols(struct v4l2_subdev *subdev)
 327 {
 328         return container_of(subdev, struct m5mols_info, sd);
 329 }
 330
 331 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
 332 {
 333         struct m5mols_info *info = container_of(ctrl->handler,
 334                                                 struct m5mols_info, handle);
 335         return &info->sd;
 336 }
 337
 338 static inline void m5mols_set_ctrl_mode(struct v4l2_ctrl *ctrl,
 339                                         unsigned int mode)
 340 {
 341         ctrl->priv = (void *)(uintptr_t)mode;
 342 }
 343
 344 static inline unsigned int m5mols_get_ctrl_mode(struct v4l2_ctrl *ctrl)
 345 {
 346         return (unsigned int)(uintptr_t)ctrl->priv;
 347 }
 348
 349 #endif  /* M5MOLS_H */