drivers/media/video/m5mo.c

   1 /*
   2  * driver for Fusitju M5MO LS 8MP camera
   3  *
   4  * Copyright (c) 2010, Samsung Electronics. All rights reserved
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include <linux/i2c.h>
  17 #include <linux/init.h>
  18 #include <media/v4l2-device.h>
  19 #include <linux/delay.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/irq.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/firmware.h>
  24 #include <linux/videodev2.h>
  25
  26 #ifdef CONFIG_VIDEO_SAMSUNG_V4L2
  27 #include <linux/videodev2_exynos_media.h>
  28 #include <linux/videodev2_exynos_camera.h>
  29 #endif
  30
  31 #include <linux/regulator/machine.h>
  32
  33 #include <media/m5mo_platform.h>
  34 #include "m5mo.h"
  35
  36 #define M5MO_DRIVER_NAME        "M5MO"
  37 #define SDCARD_FW
  38 #ifdef SDCARD_FW
  39 #define M5MO_FW_PATH            "/sdcard/RS_M5LS.bin"
  40 #endif  /* SDCARD_FW */
  41 #define M5MOT_FW_REQUEST_PATH   "m5mo/RS_M5LS_T.bin"    /* Techwin */
  42 #define M5MOO_FW_REQUEST_PATH   "m5mo/RS_M5LS_O.bin"    /* Optical communication */
  43 #define M5MO_FW_DUMP_PATH       "/data/RS_M5LS_dump.bin"
  44 #define M5MO_FW_VER_LEN         22
  45 #define M5MO_FW_VER_FILE_CUR    0x16FF00
  46
  47 #define M5MO_FLASH_BASE_ADDR    0x10000000
  48 #define M5MO_INT_RAM_BASE_ADDR  0x68000000
  49
  50 #define M5MO_I2C_RETRY          5
  51 #define M5MO_I2C_VERIFY         500
  52 #define M5MO_TIMEOUT            5000
  53 #define M5MO_AFB_TIMEOUT        15000 /* FIXME */
  54 #define M5MO_ESD_TIMEOUT        1000
  55
  56 #define M5MO_POSTVIEW_SUPPORT
  57 #define M5MO_JPEG_MAXSIZE       0x3A0000
  58 #define M5MO_THUMB_MAXSIZE      0x10000
  59 #define M5MO_POST_MAXSIZE       0xBB800
  60 #define M5MO_POST_SIZE_VGA      0x70800
  61 #define M5MO_POST_SIZE_WVGA     0x8CA00
  62
  63 #define M5MO_DEF_APEX_DEN       100
  64
  65 #define m5mo_readb(sd, g, b, v)         m5mo_read(sd, 1, g, b, v)
  66 #define m5mo_readw(sd, g, b, v)         m5mo_read(sd, 2, g, b, v)
  67 #define m5mo_readl(sd, g, b, v)         m5mo_read(sd, 4, g, b, v)
  68
  69 #define m5mo_writeb(sd, g, b, v)        m5mo_write(sd, 1, g, b, v)
  70 #define m5mo_writew(sd, g, b, v)        m5mo_write(sd, 2, g, b, v)
  71 #define m5mo_writel(sd, g, b, v)        m5mo_write(sd, 4, g, b, v)
  72
  73 static const struct m5mo_frmsizeenum preview_frmsizes[] = {
  74         { M5MO_PREVIEW_QCIF,    176,    144,    0x05,   0 },    /* 176 x 144 */
  75         { M5MO_PREVIEW_QCIF2,   528,    432,    0x2C,   0 },    /* 176 x 144 */
  76         { M5MO_PREVIEW_QVGA,    320,    240,    0x09,   0 },
  77         { M5MO_PREVIEW_VGA,             640,    480,    0x17,   0 },
  78         { M5MO_PREVIEW_D1,              720,    480,    0x18,   0 },
  79         { M5MO_PREVIEW_WVGA,    800,    480,    0x1A,   1 },
  80         { M5MO_PREVIEW_720P,    1280,   720,    0x21,   1 },
  81         { M5MO_PREVIEW_1080P,   1920,   1080,   0x28,   1 },
  82         { M5MO_PREVIEW_HDR,             3264,   2448,   0x27,   0 },
  83 };
  84
  85 static const struct m5mo_frmsizeenum capture_frmsizes[] = {
  86         { M5MO_CAPTURE_VGA,             640,    480,    0x09,   0 },
  87         { M5MO_CAPTURE_WVGA,    800,    480,    0x0A,   1 },
  88         { M5MO_CAPTURE_HD,              1280,   720,    0x10,   1 },
  89         { M5MO_CAPTURE_2MP,             1600,   1200,   0x17,   0 },
  90         { M5MO_CAPTURE_FULLHD,  1920,   1080,   0x19,   1 },
  91         { M5MO_CAPTURE_W2MP,    2048,   1232,   0x2C,   1 },
  92         { M5MO_CAPTURE_3MP,             2048,   1536,   0x1B,   0 },
  93         { M5MO_CAPTURE_W4MP,    2560,   1536,   0x1D,   1 },
  94         { M5MO_CAPTURE_5MP,             2560,   1920,   0x1F,   0 },
  95         { M5MO_CAPTURE_6MP,             3264,   1960,   0x22,   1 },
  96         { M5MO_CAPTURE_W7MP,    3264,   1968,   0x2D,   1 },
  97         { M5MO_CAPTURE_8MP,             3264,   2448,   0x25,   0 },
  98 };
  99
 100 static struct m5mo_control m5mo_ctrls[] = {
 101         /* SENSOR itself */
 102         {
 103                 .id = V4L2_CID_CAMERA_SENSOR_MODE,
 104                 .minimum = SENSOR_CAMERA,
 105                 .maximum = SENSOR_MOVIE,
 106                 .step = 1,
 107                 .value = SENSOR_CAMERA,
 108                 .default_value = SENSOR_CAMERA,
 109         }, {
 110                 .id = V4L2_CID_CAM_DR,
 111                 .minimum = 0,
 112                 .maximum = 1,
 113                 .step = 1,
 114                 .value = 0,
 115                 .default_value = 0,
 116         }, {
 117                 .id = V4L2_CID_CAMERA_HDR,
 118                 .minimum = 0,
 119                 .maximum = 2,
 120                 .step = 1,
 121                 .value = 0,
 122                 .default_value = 0,
 123         },
 124
 125         /* Flash */
 126         {
 127                 .id = V4L2_CID_CAMERA_FLASH_MODE,
 128                 .minimum = FLASH_MODE_OFF,
 129                 .maximum = FLASH_MODE_MAX - 1,
 130                 .step = 1,
 131                 .value = FLASH_MODE_OFF,
 132                 .default_value = FLASH_MODE_OFF,
 133         },
 134
 135         /* Exposure & Scenemode stuff(ISO, Metering, Saturation, etc) */
 136         {
 137                 .id = V4L2_CID_CAMERA_ISO,
 138                 .minimum = ISO_AUTO,
 139                 .maximum = ISO_800,
 140                 .step = 1,
 141                 .value = ISO_AUTO,
 142                 .default_value = ISO_AUTO,
 143         }, {
 144                 .id = V4L2_CID_CAMERA_METERING,
 145                 .minimum = METERING_MATRIX,
 146                 .maximum = METERING_MAX - 1,
 147                 .step = 1,
 148                 .value = METERING_MATRIX,
 149                 .default_value = METERING_MATRIX,
 150         }, {
 151                 .id = V4L2_CID_EXPOSURE,
 152                 .minimum = 0,
 153                 .maximum = 8,
 154                 .step = 1,
 155                 .value = 4,
 156                 .default_value = 4,
 157         }, {
 158                 .id = V4L2_CID_SATURATION,
 159                 .minimum = 0,   /* -2 */
 160                 .maximum = 4,   /* +2 */
 161                 .step = 1,
 162                 .value = 0,
 163                 .default_value = 0,
 164         }, {
 165                 .id = V4L2_CID_SHARPNESS,
 166                 .minimum = 0,   /* -2 */
 167                 .maximum = 4,   /* +2 */
 168                 .step = 1,
 169                 .value = 0,
 170                 .default_value = 0,
 171         }, {
 172                 .id = V4L2_CID_WHITE_BALANCE_PRESET,
 173                 .minimum = WHITE_BALANCE_AUTO,
 174                 .maximum = WHITE_BALANCE_MAX - 1,
 175                 .step = 1,
 176                 .value = WHITE_BALANCE_AUTO,
 177                 .default_value = WHITE_BALANCE_AUTO,
 178         }, {
 179                 .id = V4L2_CID_COLORFX,
 180                 .minimum = V4L2_COLORFX_NONE,
 181                 .maximum = V4L2_COLORFX_VIVID,
 182                 .step = 1,
 183                 .value = V4L2_COLORFX_NONE,
 184                 .default_value = V4L2_COLORFX_NONE,
 185         }, {
 186                 .id = V4L2_CID_CAMERA_SCENE_MODE,
 187                 .minimum = SCENE_MODE_NONE,
 188                 .maximum = SCENE_MODE_MAX - 1,
 189                 .step = 1,
 190                 .value = SCENE_MODE_NONE,
 191                 .default_value = SCENE_MODE_MAX,
 192         },
 193
 194         /* Zoom */
 195         {
 196                 .id = V4L2_CID_ZOOM_ABSOLUTE,
 197                 .minimum = ZOOM_LEVEL_0,
 198                 .maximum = ZOOM_LEVEL_MAX - 1,
 199                 .step = 1,
 200                 .value = ZOOM_LEVEL_0,
 201                 .default_value = ZOOM_LEVEL_0,
 202         },
 203
 204         /* Focus */
 205         {
 206                 .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT,
 207                 .minimum = 0,
 208                 .maximum = 4000,        /* FIXME */
 209                 .step = 1,
 210                 .value = 0,
 211                 .default_value = 0,
 212         }, {
 213                 .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP,
 214                 .minimum = 0,
 215                 .maximum = 3000,        /* FIXME */
 216                 .step = 1,
 217                 .value = 0,
 218                 .default_value = 0,
 219         }, {
 220                 .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH,
 221                 .minimum = 0,
 222                 .maximum = 4000,        /* FIXME */
 223                 .step = 1,
 224                 .value = 0,
 225                 .default_value = 0,
 226         }, {
 227                 .id = V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT,
 228                 .minimum = 0,
 229                 .maximum = 3000,        /* FIXME */
 230                 .step = 1,
 231                 .value = 0,
 232                 .default_value = 0,
 233         }, {
 234                 .id = V4L2_CID_FOCUS_AUTO_MODE,
 235                 .minimum = V4L2_FOCUS_AUTO_NORMAL,
 236                 .maximum = V4L2_FOCUS_AUTO_RECTANGLE,
 237                 .step = 1,
 238                 .value = V4L2_FOCUS_AUTO_NORMAL,
 239                 .default_value = V4L2_FOCUS_AUTO_NORMAL,
 240         }, {
 241                 .id = V4L2_CID_CAMERA_SET_AUTO_FOCUS,
 242                 .minimum = 0,
 243                 .maximum = 1,
 244                 .step = 1,
 245                 .value = 0,
 246                 .default_value = 0,
 247         },
 248
 249         /* Capture */
 250         {
 251                 .id = V4L2_CID_CAMERA_CAPTURE,
 252                 .minimum = 0,
 253                 .maximum = 1,
 254                 .step = 1,
 255                 .value = 0,
 256                 .default_value = 0,
 257         }, {
 258                 .id = V4L2_CID_CAM_JPEG_QUALITY,
 259                 .minimum = 1,
 260                 .maximum = 100,
 261                 .step = 1,
 262                 .value = 100,
 263                 .default_value = 100,
 264         },
 265
 266         /* <-- TODO: duplicated CID. will be removed. */
 267         {
 268                 .id = V4L2_CID_CAMERA_WDR,
 269                 .minimum = 0,
 270                 .maximum = 1,
 271                 .step = 1,
 272                 .value = 0,
 273                 .default_value = 0,
 274         }, {
 275                 .id = V4L2_CID_CAMERA_ZOOM,
 276                 .minimum = ZOOM_LEVEL_0,
 277                 .maximum = ZOOM_LEVEL_MAX - 1,
 278                 .step = 1,
 279                 .value = ZOOM_LEVEL_0,
 280                 .default_value = ZOOM_LEVEL_0,
 281         },
 282         /* --> End */
 283 };
 284
 285 static inline struct m5mo_state *to_state(struct v4l2_subdev *sd)
 286 {
 287         return container_of(sd, struct m5mo_state, sd);
 288 }
 289
 290 #define M5MOLS_I2C_MAX_SIZE     4
 291 #define M5MOLS_BYTE_READ        0x01
 292 #define M5MOLS_BYTE_WRITE       0x02
 293
 294 static int m5mo_read(struct v4l2_subdev *sd,
 295                      u8 len, u8 category, u8 byte, u32 *val)
 296 {
 297         struct i2c_client *client = v4l2_get_subdevdata(sd);
 298         struct device *cdev = &client->dev;
 299         struct i2c_msg msg[2];
 300         unsigned char data[5];
 301         unsigned char recv_data[len + 1];
 302         int ret = 0;
 303
 304         if (!client->adapter)
 305                 return -ENODEV;
 306
 307         if (len != 0x01 && len != 0x02 && len != 0x04)
 308                 return -EINVAL;
 309
 310         msg[0].addr = client->addr;
 311         msg[0].flags = 0;
 312         msg[0].len = 5;
 313         msg[0].buf = data;
 314         data[0] = 5;
 315         data[1] = M5MOLS_BYTE_READ;
 316         data[2] = category;
 317         data[3] = byte;
 318         data[4] = len;
 319
 320         msg[1].addr = client->addr;
 321         msg[1].flags = I2C_M_RD;
 322         msg[1].len = len + 1;
 323         msg[1].buf = recv_data;
 324
 325         ret = i2c_transfer(client->adapter, msg, 2);
 326
 327         if (ret < 0) {
 328                 dev_err(cdev, "read failed: len:%d cat:%02x byte:%02x. %d\n",
 329                          len, category, byte, ret);
 330                 return ret;
 331         }
 332
 333         if (len == 0x01)
 334                 *val = recv_data[1];
 335         else if (len == 0x02)
 336                 *val = recv_data[1] << 8 | recv_data[2];
 337         else
 338                 *val = recv_data[1] << 24 | recv_data[2] << 16 |
 339                                 recv_data[3] << 8 | recv_data[4];
 340
 341         return 0;
 342 }
 343
 344 static int m5mo_write(struct v4l2_subdev *sd,
 345                       u8 len, u8 category, u8 byte, u32 val)
 346 {
 347         struct i2c_client *client = v4l2_get_subdevdata(sd);
 348         struct device *cdev = &client->dev;
 349         struct i2c_msg msg[1];
 350         unsigned char data[len + 4];
 351         int ret;
 352         int i;
 353
 354         if (!client->adapter)
 355                 return -ENODEV;
 356
 357         if (len != 0x01 && len != 0x02 && len != 0x04)
 358                 return -EINVAL;
 359
 360         msg->addr = client->addr;
 361         msg->flags = 0;
 362         msg->len = (u16)len + 4;
 363         msg->buf = data;
 364         data[0] = len + 4;
 365         data[1] = M5MOLS_BYTE_WRITE;
 366         data[2] = category;
 367         data[3] = byte;
 368
 369         if (len == 0x01) {
 370                 data[4] = val & 0xFF;
 371         } else if (len == 0x02) {
 372                 data[4] = (val >> 8) & 0xFF;
 373                 data[5] = val & 0xFF;
 374         } else {
 375                 data[4] = (val >> 24) & 0xFF;
 376                 data[5] = (val >> 16) & 0xFF;
 377                 data[6] = (val >> 8) & 0xFF;
 378                 data[7] = val & 0xFF;
 379         }
 380
 381         for (i = M5MO_I2C_RETRY; i; i--) {
 382         ret = i2c_transfer(client->adapter, msg, 1);
 383                 if (ret == 1)
 384                         break;
 385                 usleep_range(10000, 10000);
 386         }
 387         if (ret < 0) {
 388                 dev_err(cdev, "write failed: len:%d cat:%02x byte:%02x "
 389                                 "val:%02x. %d\n",
 390                                 len, category, byte, val, ret);
 391                 return ret;
 392         }
 393         dev_dbg(cdev, "I2C write : len:%d cat:%02x byte:%02x val:%02x.\n",
 394                         len, category, byte, val);
 395
 396         return 0;
 397 }
 398
 399 static int m5mo_mem_read(struct v4l2_subdev *sd, u16 len, u32 addr, u8 *val)
 400 {
 401         struct i2c_client *client = v4l2_get_subdevdata(sd);
 402         struct device *cdev = &client->dev;
 403         struct i2c_msg msg;
 404         unsigned char data[8];
 405         unsigned char recv_data[len + 3];
 406         int i, err = 0;
 407
 408         if (!client->adapter)
 409                 return -ENODEV;
 410
 411         if (len <= 0)
 412                 return -EINVAL;
 413
 414         msg.addr = client->addr;
 415         msg.flags = 0;
 416         msg.len = sizeof(data);
 417         msg.buf = data;
 418
 419         /* high byte goes out first */
 420         data[0] = 0x00;
 421         data[1] = 0x03;
 422         data[2] = (addr >> 24) & 0xFF;
 423         data[3] = (addr >> 16) & 0xFF;
 424         data[4] = (addr >> 8) & 0xFF;
 425         data[5] = addr & 0xFF;
 426         data[6] = (len >> 8) & 0xFF;
 427         data[7] = len & 0xFF;
 428
 429         for (i = M5MO_I2C_RETRY; i; i--) {
 430                 err = i2c_transfer(client->adapter, &msg, 1);
 431                 if (err == 1)
 432                         break;
 433                 usleep_range(2000, 2000);
 434         }
 435
 436         if (err != 1)
 437                 return err;
 438
 439         msg.flags = I2C_M_RD;
 440         msg.len = sizeof(recv_data);
 441         msg.buf = recv_data;
 442         for (i = M5MO_I2C_RETRY; i; i--) {
 443                 err = i2c_transfer(client->adapter, &msg, 1);
 444                 if (err == 1)
 445                         break;
 446                 usleep_range(2000, 2000);
 447         }
 448
 449         if (err != 1)
 450                 return err;
 451
 452         if (len != (recv_data[1] << 8 | recv_data[2])){
 453                 dev_info(cdev, "expected length %d, but return length %d\n",
 454                         len, recv_data[1] << 8 | recv_data[2]);
 455         }
 456
 457         memcpy(val, recv_data + 3, len);
 458
 459         dev_info(cdev, "address %#x, length %d\n", addr, len);
 460         return err;
 461 }
 462
 463 static int m5mo_mem_write(struct v4l2_subdev *sd,
 464                           u8 cmd, u16 len, u32 addr, u8 *val)
 465 {
 466         struct i2c_client *client = v4l2_get_subdevdata(sd);
 467         struct device *cdev = &client->dev;
 468         struct i2c_msg msg;
 469         unsigned char data[len + 8];
 470         int i, err = 0;
 471
 472         if (!client->adapter)
 473                 return -ENODEV;
 474
 475         msg.addr = client->addr;
 476         msg.flags = 0;
 477         msg.len = sizeof(data);
 478         msg.buf = data;
 479
 480         /* high byte goes out first */
 481         data[0] = 0x00;
 482         data[1] = cmd;
 483         data[2] = (addr >> 24) & 0xFF;
 484         data[3] = (addr >> 16) & 0xFF;
 485         data[4] = (addr >> 8) & 0xFF;
 486         data[5] = addr & 0xFF;
 487         data[6] = (len >> 8) & 0xFF;
 488         data[7] = len & 0xFF;
 489         memcpy(data + 2 + sizeof(addr) + sizeof(len), val, len);
 490
 491         dev_info(cdev, "address %#x, length %d\n", addr, len);
 492
 493         for (i = M5MO_I2C_RETRY; i; i--) {
 494                 err = i2c_transfer(client->adapter, &msg, 1);
 495                 if (err == 1)
 496                         break;
 497                 usleep_range(2000, 2000);
 498         }
 499
 500         return err;
 501 }
 502
 503 static int m5mo_busy(struct v4l2_subdev *sd, u8 category, u8 byte, u32 mask)
 504 {
 505         struct i2c_client *client = v4l2_get_subdevdata(sd);
 506         struct device *cdev = &client->dev;
 507         u32 val = 0, i;
 508         int ret;
 509
 510         for (i = 0; i < M5MO_I2C_VERIFY; i++) {
 511                 ret = m5mo_readb(sd, category, byte, &val);
 512                 if (ret)
 513                         return ret;
 514                 if ((val & mask) == mask) {
 515                         dev_dbg(cdev, "busy: verified [c,b,v] "
 516                                         "[%02x, %02x, %02x] (try = %d)\n",
 517                                         category, byte, mask, i);
 518                         return 0;
 519                 }
 520                 /* If camera mode is not changed, wait 10ms more at least. */
 521                 msleep(10);
 522         }
 523
 524         return -EBUSY;
 525 }
 526
 527 static irqreturn_t m5mo_isp_isr(int irq, void *dev_id)
 528 {
 529         struct v4l2_subdev *sd = (struct v4l2_subdev *)dev_id;
 530         struct m5mo_state *state = to_state(sd);
 531
 532         state->isp.issued = 1;
 533         wake_up_interruptible(&state->isp.wait);
 534
 535         return IRQ_HANDLED;
 536 }
 537
 538 static u32 m5mo_wait(struct v4l2_subdev *sd, int cond, u32 timeout)
 539 {
 540         struct m5mo_state *state = to_state(sd);
 541         struct i2c_client *client = v4l2_get_subdevdata(sd);
 542         struct device *cdev = &client->dev;
 543         u32 reg;
 544         int ret;
 545
 546         if (wait_event_interruptible_timeout(state->isp.wait,
 547                                 is_issued(state),
 548                                 msecs_to_jiffies(timeout)) == 0)
 549                 return -ETIMEDOUT;
 550
 551         /* Disable Interrupt */
 552         ret = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_EN, M5MO_INT_NONE);
 553         if (ret)
 554                 return ret;
 555
 556         ret = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_FACTOR, &reg);
 557         if (ret)
 558                 return ret;
 559
 560         if ((reg == 0xff) || (reg == 0xfa)) {
 561                 dev_info(cdev, "*** error issued: ret %d, reg %x\n", ret, reg);
 562                 return -EAGAIN;
 563         }
 564
 565         state->isp.int_factor = reg;
 566         if (!is_interrupted(cond))
 567                 return -EINVAL;
 568
 569         state->isp.issued = 0;
 570
 571         dev_info(cdev, "*** issued: [%s - 0x%x]\n",
 572                 reg == M5MO_INT_MODE ? "INT_MODE" :
 573                 reg == M5MO_INT_AF ? "INT_AF" :
 574                 reg == M5MO_INT_CAPTURE ? "INT_CAPTURE" :
 575                 reg == M5MO_INT_SOUND ? "INT_SOUND" :
 576                 reg == M5MO_INT_ZOOM ? "INT_ZOOM" :
 577                 reg == M5MO_INT_FD ? "INT_FD" :
 578                 reg == M5MO_INT_LENS_INIT ? "INT_LENS_INIT" :
 579                 reg == (M5MO_INT_SOUND | M5MO_INT_CAPTURE) ? "INT_SOUND_CAPTURE" :
 580                 "NONE", reg);
 581
 582         return 0;
 583 }
 584
 585 static int m5mo_reg_mode(struct v4l2_subdev *sd, u32 mode)
 586 {
 587         int ret;
 588
 589         ret = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE, mode);
 590         if (!ret)
 591                 ret = m5mo_busy(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE, mode);
 592         return ret;
 593 }
 594
 595 static int m5mo_set_mode(struct v4l2_subdev *sd, u32 mode)
 596 {
 597         struct m5mo_state *state = to_state(sd);
 598         struct i2c_client *client = v4l2_get_subdevdata(sd);
 599         struct device *cdev = &client->dev;
 600         u32 old_mode;
 601         int err;
 602
 603         if (mode < M5MO_PARMSET_MODE && mode > M5MO_STILLCAP_MODE)
 604                 return -EINVAL;
 605
 606         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE, &old_mode);
 607         if (!err && old_mode == mode)
 608                 return 0;
 609         if (err)
 610                 return err;
 611
 612         switch (old_mode) {
 613         case M5MO_SYSINIT_MODE:
 614                 err = -EBUSY;
 615                 break;
 616         case M5MO_PARMSET_MODE:
 617                 err = m5mo_reg_mode(sd, M5MO_MONITOR_MODE);
 618                 if (mode == M5MO_STILLCAP_MODE)
 619                         err = m5mo_reg_mode(sd, M5MO_STILLCAP_MODE);
 620                 break;
 621         case M5MO_MONITOR_MODE:
 622                         err = m5mo_reg_mode(sd, mode);
 623                 break;
 624         case M5MO_STILLCAP_MODE:
 625                 err = m5mo_reg_mode(sd, M5MO_PARMSET_MODE);
 626                 if (mode == M5MO_MONITOR_MODE)
 627                         err = m5mo_reg_mode(sd, M5MO_MONITOR_MODE);
 628                 break;
 629         default:
 630                 dev_info(cdev, "@@@@@ mode: unknown, %d\n", old_mode);
 631                 err = -EINVAL;
 632         }
 633
 634         dev_info(cdev, "@@@@@ mode: Changed: %#x -> %#x, issued %d\n",
 635                         old_mode, mode, state->isp.issued);
 636         return err;
 637 }
 638
 639 /*
 640  * v4l2_subdev_core_ops
 641  */
 642 static int m5mo_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
 643 {
 644         int i;
 645
 646         for (i = 0; i < ARRAY_SIZE(m5mo_ctrls); i++) {
 647                 if (qc->id == m5mo_ctrls[i].id) {
 648                         qc->maximum = m5mo_ctrls[i].maximum;
 649                         qc->minimum = m5mo_ctrls[i].minimum;
 650                         qc->step = m5mo_ctrls[i].step;
 651                         qc->default_value = m5mo_ctrls[i].default_value;
 652                         return 0;
 653                 }
 654         }
 655         return -EINVAL;
 656 }
 657
 658 static int m5mo_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 659 {
 660         struct m5mo_state *state = to_state(sd);
 661         struct i2c_client *client = v4l2_get_subdevdata(sd);
 662         struct device *cdev = &client->dev;
 663         int err = 0;
 664
 665 #if 0
 666         qc.id = ctrl->id;
 667         err = m5mo_queryctrl(sd, &qc);
 668         if (err) {
 669                 dev_info(cdev, "g_ctrl: no CID[0x%08x] value[%d]. Just pass.\n",
 670                                 ctrl->id, ctrl->value);
 671                 return -ENOIOCTLCMD;
 672         }
 673 #endif
 674
 675         switch (ctrl->id) {
 676 #if 0
 677         case V4L2_CID_CAM_SENSOR_FW_VER:
 678                 dev_info(cdev, "FW ver [%s]\n", state->exif.unique_id);
 679                 break;
 680 #endif
 681         /* dependent on SENSOR itself */
 682         case V4L2_CID_CAMERA_SENSOR_MODE:
 683                 ctrl->value = 0;
 684                 break;
 685         case V4L2_CID_CAM_DR:
 686         case V4L2_CID_CAMERA_WDR:
 687                 ctrl->value = state->wdr;
 688                 break;
 689         case V4L2_CID_CAMERA_HDR:
 690                 ctrl->value = state->hdr;
 691                 break;
 692
 693         /* Flash : NONE */
 694         case V4L2_CID_CAMERA_FLASH_MODE:
 695                 ctrl->value = state->flash_mode;
 696                 break;
 697
 698         /* Exposure & Scenemode stuff(ISO, Metering, Saturation, etc) */
 699         case V4L2_CID_CAMERA_ISO:
 700                 ctrl->value = state->iso;
 701                 break;
 702         case V4L2_CID_CAMERA_METERING:
 703                 ctrl->value = state->metering;
 704                 break;
 705         case V4L2_CID_EXPOSURE:
 706                 ctrl->value = state->exposure;
 707                 break;
 708         case V4L2_CID_SATURATION:
 709                 ctrl->value = state->saturation;
 710                 break;
 711         case V4L2_CID_SHARPNESS:
 712                 ctrl->value = state->sharpness;
 713                 break;
 714         case V4L2_CID_WHITE_BALANCE_PRESET:
 715                 ctrl->value = state->wb_preset;
 716                 break;
 717         case V4L2_CID_COLORFX:
 718                 ctrl->value = state->colorfx;
 719                 break;
 720         case V4L2_CID_CAMERA_SCENE_MODE:
 721                 ctrl->value = state->scenemode;
 722                 break;
 723
 724         /* Zoom */
 725         case V4L2_CID_ZOOM_ABSOLUTE:
 726         case V4L2_CID_CAMERA_ZOOM:
 727                 ctrl->value = state->zoom;
 728                 break;
 729
 730         /* Focus */
 731         case V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT:
 732                 ctrl->value = state->focus.pos_x;
 733                 break;
 734         case V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP:
 735                 ctrl->value = state->focus.pos_y;
 736                 break;
 737         case V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH:
 738                 ctrl->value = state->focus.width;
 739                 break;
 740         case V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT:
 741                 ctrl->value = state->focus.height;
 742                 break;
 743         case V4L2_CID_FOCUS_AUTO_MODE:
 744                 if (state->focus.mode == V4L2_FOCUS_AUTO_MACRO)
 745                         ctrl->value = V4L2_FOCUS_AUTO_MACRO;
 746                 else if (state->focus.mode == V4L2_FOCUS_AUTO_CONTINUOUS)
 747                         ctrl->value = V4L2_FOCUS_AUTO_CONTINUOUS;
 748                 else if (state->focus.mode == V4L2_FOCUS_AUTO_FACE_DETECTION)
 749                         ctrl->value = V4L2_FOCUS_AUTO_FACE_DETECTION;
 750                 else if (state->focus.mode == V4L2_FOCUS_AUTO_RECTANGLE)
 751                         ctrl->value = V4L2_FOCUS_AUTO_RECTANGLE;
 752                 else
 753                         ctrl->value = V4L2_FOCUS_AUTO_NORMAL;
 754                 break;
 755
 756         /* Capture: JPEG */
 757         case V4L2_CID_CAM_JPEG_MAIN_SIZE:
 758                 ctrl->value = state->jpeg.main_size;
 759                 break;
 760         case V4L2_CID_CAM_JPEG_THUMB_SIZE:
 761                 ctrl->value = state->jpeg.thumb_size;
 762                 break;
 763         case V4L2_CID_CAM_JPEG_THUMB_OFFSET:
 764                 ctrl->value = state->jpeg.thumb_offset;
 765                 break;
 766         case V4L2_CID_CAM_JPEG_POSTVIEW_SIZE:
 767                 ctrl->value = (state->wide_res ? M5MO_POST_SIZE_WVGA : M5MO_POST_SIZE_VGA);
 768                 dev_info(cdev, "%s: Postview size : %d\n", __func__, ctrl->value);
 769                 break;
 770         case V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET:
 771                 ctrl->value = state->jpeg.postview_offset;
 772                 break;
 773         case V4L2_CID_CAM_JPEG_MEMSIZE:         /* Using on FIMC */
 774                 ctrl->value = M5MO_JPEG_MAXSIZE +
 775                         M5MO_THUMB_MAXSIZE + M5MO_POST_MAXSIZE;
 776                 break;
 777
 778         /* Capture: EXIF */
 779         case V4L2_CID_CAMERA_EXIF_EXPTIME:
 780                 ctrl->value = state->exif.exptime;
 781                 break;
 782         case V4L2_CID_CAMERA_EXIF_TV:
 783                 ctrl->value = state->exif.tv;
 784                 break;
 785         case V4L2_CID_CAMERA_EXIF_BV:
 786                 ctrl->value = state->exif.bv;
 787                 break;
 788         case V4L2_CID_CAMERA_EXIF_FLASH:
 789                 ctrl->value = state->exif.flash;
 790                 break;
 791         case V4L2_CID_CAMERA_EXIF_ISO:
 792                 ctrl->value = state->exif.iso;
 793                 break;
 794         case V4L2_CID_CAMERA_EXIF_EBV:
 795                 ctrl->value = state->exif.ebv;
 796                 break;
 797
 798         default:
 799                 dev_info(cdev, "g_ctrl: warnings!!! "
 800                                 "no CID[%s][0x%08x] PRIVATE[%d] val[%d]\n",
 801                                 v4l2_ctrl_get_name(ctrl->id), ctrl->id,
 802                                 ctrl->id - V4L2_CID_PRIVATE_BASE,
 803                                 ctrl->value);
 804                 return 0;
 805         }
 806
 807         dev_dbg(cdev, "g_ctrl: CID[%s][0x%08x] PRIVATE[%d] val[%d] ret[%d]\n",
 808                         v4l2_ctrl_get_name(ctrl->id), ctrl->id,
 809                         ctrl->id - V4L2_CID_PRIVATE_BASE,
 810                         ctrl->value, err);
 811
 812         return err;
 813 }
 814
 815 static int m5mo_set_af_softlanding(struct v4l2_subdev *sd)
 816 {
 817         struct m5mo_state *state = to_state(sd);
 818         struct i2c_client *client = v4l2_get_subdevdata(sd);
 819         struct device *cdev = &client->dev;
 820         u32 status = 0;
 821         int i, err = 0;
 822
 823         if (unlikely(state->isp.bad_fw)) {
 824                 dev_info(cdev, "\"Unknown\" state, please update F/W");
 825                 return -ENOSYS;
 826         }
 827
 828         err = m5mo_set_mode(sd, M5MO_MONITOR_MODE);
 829         if (!err)
 830                 err = m5mo_writeb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_MODE, 0x07);
 831         if (err)
 832                 return err;
 833
 834         for (i = M5MO_I2C_VERIFY; i; i--) {
 835                 err = m5mo_readb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_STATUS,
 836                                 &status);
 837                 if (err)
 838                         return err;
 839                 if ((status & 0x01) == 0x00)
 840                         break;
 841         }
 842
 843         if ((status & 0x01) != 0x00)
 844                 return -ETIMEDOUT;
 845
 846         return err;
 847 }
 848
 849 #if 0
 850 static int m5mo_dump_fw(struct v4l2_subdev *sd)
 851 {
 852         struct i2c_client *client = v4l2_get_subdevdata(sd);
 853         struct device *cdev = &client->dev;
 854         struct file *fp;
 855         mm_segment_t old_fs;
 856         u8 *buf, val;
 857         u32 addr, unit, count, intram_unit = 0x1000;
 858         int i, j, err;
 859
 860         old_fs = get_fs();
 861         set_fs(KERNEL_DS);
 862
 863         fp = filp_open(M5MO_FW_DUMP_PATH,
 864                 O_WRONLY|O_CREAT|O_TRUNC, S_IRUGO|S_IWUGO|S_IXUSR);
 865         if (IS_ERR(fp)) {
 866                 dev_info(cdev, "failed to open %s, err %ld\n",
 867                         M5MO_FW_DUMP_PATH, PTR_ERR(fp));
 868                 err = -ENOENT;
 869                 goto out0;
 870         }
 871
 872         buf = kmalloc(intram_unit, GFP_KERNEL);
 873         if (!buf) {
 874                 dev_info(cdev, "failed to allocate memory\n");
 875                 err = -ENOMEM;
 876                 goto out0;
 877         }
 878
 879         /* set pin */
 880         val = 0x7E;
 881         err = m5mo_mem_write(sd, 0x04, sizeof(val), 0x50000308, &val);
 882         if (err < 0)
 883                 return err;
 884
 885         addr = M5MO_FLASH_BASE_ADDR;
 886         unit = SZ_64K;
 887         count = 31;
 888         for (i = 0; i < count; i++) {
 889                 for (j = 0; j < unit; j += intram_unit) {
 890                         err = m5mo_mem_read(sd,
 891                                 intram_unit, addr + (i * unit) + j, buf);
 892                         if (err < 0) {
 893                                 dev_info(cdev, "i2c falied, err %d\n", err);
 894                                 goto out1;
 895                         }
 896                         vfs_write(fp, buf, intram_unit, &fp->f_pos);
 897                 }
 898         }
 899
 900         addr = M5MO_FLASH_BASE_ADDR + SZ_64K * count;
 901         unit = SZ_8K;
 902         count = 4;
 903         for (i = 0; i < count; i++) {
 904                 for (j = 0; j < unit; j += intram_unit) {
 905                         err = m5mo_mem_read(sd,
 906                                 intram_unit, addr + (i * unit) + j, buf);
 907                         if (err < 0) {
 908                                 dev_info(cdev, "i2c falied, err %d\n", err);
 909                                 goto out1;
 910                         }
 911                         vfs_write(fp, buf, intram_unit, &fp->f_pos);
 912                 }
 913         }
 914
 915 out1:
 916         kfree(buf);
 917 out0:
 918         if (!IS_ERR(fp))
 919                 filp_close(fp, current->files);
 920         set_fs(old_fs);
 921
 922         return err;
 923 }
 924
 925 static int m5mo_get_phone_fw_version(struct v4l2_subdev *sd,
 926         char *buf)
 927 {
 928         struct i2c_client *client = v4l2_get_subdevdata(sd);
 929         struct device *dev = &client->adapter->dev;
 930         struct device *cdev = &client->dev;
 931         u8 sensor_ver[M5MO_FW_VER_LEN] = {0, };
 932         const struct firmware *fentry;
 933         int err;
 934
 935 #ifdef SDCARD_FW
 936         struct file *fp;
 937         mm_segment_t old_fs;
 938         long nread;
 939         int fw_requested = 1;
 940
 941         old_fs = get_fs();
 942         set_fs(KERNEL_DS);
 943
 944         fp = filp_open(M5MO_FW_PATH, O_RDONLY, 0);
 945         if (IS_ERR(fp)) {
 946                 dev_dbg(cdev, "failed to open %s, err %ld\n",
 947                                 M5MO_FW_PATH, PTR_ERR(fp));
 948                 goto request_fw;
 949         }
 950
 951         fw_requested = 0;
 952         err = vfs_llseek(fp, M5MO_FW_VER_FILE_CUR, SEEK_SET);
 953         if (err < 0) {
 954                 dev_info(cdev, "failed to fseek, %d\n", err);
 955                 goto out;
 956         }
 957
 958         nread = vfs_read(fp, (char __user *)buf, M5MO_FW_VER_LEN, &fp->f_pos);
 959         if (nread != M5MO_FW_VER_LEN) {
 960                 dev_info(cdev, "failed to read firmware file, %ld Bytes\n", nread);
 961                 err = -EIO;
 962                 goto out;
 963         }
 964
 965 request_fw:
 966         if (fw_requested) {
 967                 set_fs(old_fs);
 968 #endif /* SDCARD_FW */
 969         m5mo_get_sensor_fw_version(sd, sensor_ver);
 970
 971         if (sensor_ver[0] == 'T')
 972                 err = request_firmware(&fentry, M5MOT_FW_REQUEST_PATH, dev);
 973         else
 974                 err = request_firmware(&fentry, M5MOO_FW_REQUEST_PATH, dev);
 975
 976         if (err != 0) {
 977                 dev_info(cdev, "request_firmware falied\n");
 978                 err = -EINVAL;
 979                 goto out;
 980         }
 981
 982         memcpy(buf, (u8 *)&fentry->data[M5MO_FW_VER_FILE_CUR], M5MO_FW_VER_LEN);
 983 #ifdef SDCARD_FW
 984         }
 985 #endif /* SDCARD_FW */
 986
 987 out:
 988 #ifdef SDCARD_FW
 989         if (!fw_requested) {
 990                 filp_close(fp, current->files);
 991                 set_fs(old_fs);
 992         }
 993 #endif  /* SDCARD_FW */
 994
 995         return 0;
 996 }
 997
 998 static int m5mo_check_fw(struct v4l2_subdev *sd)
 999 {
1000         struct m5mo_state *state = to_state(sd);
1001         struct i2c_client *client = v4l2_get_subdevdata(sd);
1002         struct device *cdev = &client->dev;
1003         u8 sensor_ver[M5MO_FW_VER_LEN] = "FAILED Fujitsu M5MOLS";
1004         u8 phone_ver[M5MO_FW_VER_LEN] = "FAILED Fujitsu M5MOLS";
1005         int af_cal_h = 0, af_cal_l = 0;
1006         int rg_cal_h = 0, rg_cal_l = 0;
1007         int bg_cal_h = 0, bg_cal_l = 0;
1008         int update_count = 0;
1009         int err;
1010
1011         /* F/W version */
1012         m5mo_get_phone_fw_version(sd, phone_ver);
1013
1014         if (state->isp.bad_fw)
1015                 goto out;
1016
1017         m5mo_get_sensor_fw_version(sd, sensor_ver);
1018
1019         err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH, M5MO_FLASH_CAM_START, 0x01);
1020         if (!err)
1021                 err = m5mo_wait(sd, M5MO_INT_MODE, M5MO_TIMEOUT);
1022         if (!err)
1023                 err = m5mo_readb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_CAL,
1024                                 &af_cal_l);
1025         if (!err)
1026                 err = m5mo_readb(sd, M5MO_CATEGORY_ADJST, M5MO_ADJST_AWB_RG_H,
1027                                 &rg_cal_h);
1028         if (!err)
1029                 err = m5mo_readb(sd, M5MO_CATEGORY_ADJST, M5MO_ADJST_AWB_RG_L,
1030                                 &rg_cal_l);
1031         if (!err)
1032                 err = m5mo_readb(sd, M5MO_CATEGORY_ADJST, M5MO_ADJST_AWB_BG_H,
1033                                 &bg_cal_h);
1034         if (!err)
1035                 err = m5mo_readb(sd, M5MO_CATEGORY_ADJST, M5MO_ADJST_AWB_BG_L,
1036                                 &bg_cal_l);
1037         if (err)
1038                 return err;
1039
1040 out:
1041         if (!state->fw_version) {
1042                 state->fw_version = kzalloc(50, GFP_KERNEL);
1043                 if (!state->fw_version) {
1044                         dev_info(cdev, "no memory for F/W version\n");
1045                         return -ENOMEM;
1046                 }
1047         }
1048
1049         sprintf(state->fw_version, "%s %s %d %x %x %x %x %x %x",
1050                 sensor_ver, phone_ver, update_count,
1051                 af_cal_h, af_cal_l, rg_cal_h, rg_cal_l, bg_cal_h, bg_cal_l);
1052
1053         return 0;
1054 }
1055 #endif
1056
1057 static int m5mo_get_sensor_fw_version(struct v4l2_subdev *sd,
1058         char *buf)
1059 {
1060         u8 val;
1061         int err;
1062
1063         /* set pin */
1064         val = 0x7E;
1065         err = m5mo_mem_write(sd, 0x04, sizeof(val), 0x50000308, &val);
1066         if (err >= 0)
1067                 err = m5mo_mem_read(sd, M5MO_FW_VER_LEN,
1068                         M5MO_FLASH_BASE_ADDR + M5MO_FW_VER_FILE_CUR, buf);
1069
1070         return 0;
1071 }
1072
1073 /* Control functions */
1074 static int m5mo_set_wdr(struct v4l2_subdev *sd, int value)
1075 {
1076         struct m5mo_state *state = to_state(sd);
1077         int err;
1078
1079         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_TONE_CTRL,
1080                         value == 1 ? 0x09 : 0x05);
1081         if (!err)
1082                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM, M5MO_CAPPARM_WDR_EN,
1083                                 value == 1 ? 0x01 : 0x00);
1084         if (!err)
1085                 state->wdr = value;
1086
1087         return err;
1088 }
1089
1090 static int m5mo_set_hdr(struct v4l2_subdev *sd, int value)
1091 {
1092         struct m5mo_state *state = to_state(sd);
1093         int err;
1094
1095         if (value < 0 && value > 2)
1096                 return -EINVAL;
1097
1098         if (!value) {
1099                 err = m5mo_set_mode(sd, M5MO_MONITOR_MODE);
1100                 if (!err)
1101                         state->hdr = value;
1102                 return err;
1103         }
1104
1105         err = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_ROOT_EN, 0x01);
1106         if (!err)
1107                 state->hdr = value;
1108
1109         return err;
1110 }
1111
1112 static int m5mo_set_flash(struct v4l2_subdev *sd, int value)
1113 {
1114         struct m5mo_state *state = to_state(sd);
1115         struct i2c_client *client = v4l2_get_subdevdata(sd);
1116         const struct m5mo_platform_data *pdata = client->dev.platform_data;
1117         struct device *dev = &client->dev;
1118         int err;
1119
1120         /*
1121          * In SLP Platform, the recording mode of M5MO itself is not used.
1122          * So, it is not needed not to set flash mode on recording.
1123          * Exactly, always LIGHT & FLASH register should be configured.
1124          */
1125         if (pdata->flash_power)
1126                 err = pdata->flash_power(value == FLASH_MODE_OFF ? 0 : 1, dev);
1127         if (!err)
1128                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
1129                                         M5MO_CAPPARM_LIGHT_CTRL,
1130                                         value == FLASH_MODE_AUTO ? 0x02 :
1131                                         value == FLASH_MODE_ON ? 0x01 :
1132                                         value == FLASH_MODE_TORCH ? 0x03 : 0x00);
1133         if (!err)
1134                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
1135                                         M5MO_CAPPARM_FLASH_CTRL,
1136                                         value == FLASH_MODE_AUTO ? 0x02 :
1137                                         value == FLASH_MODE_ON ? 0x01 : 0x00);
1138         if (!err)
1139                 state->flash_mode = value;
1140
1141         return err;
1142 }
1143
1144 static int m5mo_set_iso(struct v4l2_subdev *sd, int value)
1145 {
1146         struct m5mo_state *state = to_state(sd);
1147         int err;
1148         u32 iso[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
1149
1150         if (value == state->iso)
1151                 return 0;
1152
1153         err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_ISOSEL, iso[value]);
1154         if (!err)
1155                 state->iso = value;
1156
1157         return err;
1158 }
1159
1160 static int m5mo_set_metering(struct v4l2_subdev *sd, int value)
1161 {
1162         struct m5mo_state *state = to_state(sd);
1163         int err;
1164
1165         err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_MODE,
1166                         value == METERING_SPOT ? 0x06 :
1167                         value == METERING_MATRIX ? 0x01 : 0x03);
1168         if (!err)
1169                 state->metering = value;
1170
1171         return err;
1172 }
1173
1174 static int m5mo_set_exposure(struct v4l2_subdev *sd, int value)
1175 {
1176         struct m5mo_state *state = to_state(sd);
1177         int err;
1178         u32 exposure[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
1179
1180         if (value == state->exposure)
1181                 return 0;
1182
1183         /* FIXME: videodev2.h*/
1184         err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_INDEX,
1185                         exposure[value]);
1186         if (!err)
1187                 state->exposure = value;
1188
1189         return err;
1190 }
1191
1192 static int m5mo_set_saturation(struct v4l2_subdev *sd, int value)
1193 {
1194         struct m5mo_state *state = to_state(sd);
1195         int err;
1196         u32 saturation[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
1197
1198         if (value == state->saturation)
1199                 return 0;
1200
1201         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_CHROMA_LVL,
1202                         saturation[value]);
1203         if (!err)
1204                 state->saturation = value;
1205
1206         return err;
1207 }
1208
1209 static int m5mo_set_sharpness(struct v4l2_subdev *sd, int value)
1210 {
1211         struct m5mo_state *state = to_state(sd);
1212         int err;
1213         u32 sharpness[] = { 0x03, 0x04, 0x05, 0x06, 0x07 };
1214
1215         if (value == state->sharpness)
1216                 return 0;
1217
1218         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_EDGE_LVL,
1219                         sharpness[value]);
1220         if (!err)
1221                 state->sharpness = value;
1222
1223         return err;
1224 }
1225
1226 static int m5mo_set_whitebalance(struct v4l2_subdev *sd, int value)
1227 {
1228         struct m5mo_state *state = to_state(sd);
1229         int err;
1230
1231         if (value == state->wb_preset)
1232                 return 0;
1233
1234         err = m5mo_writeb(sd, M5MO_CATEGORY_WB, M5MO_WB_AWB_MODE,
1235                         value == WHITE_BALANCE_AUTO ? 0x01 : 0x02);
1236         if (!err)
1237                 err = m5mo_writeb(sd, M5MO_CATEGORY_WB, M5MO_WB_AWB_MANUAL,
1238                         value == WHITE_BALANCE_SUNNY ? 0x04 :
1239                         value == WHITE_BALANCE_CLOUDY ? 0x05 :
1240                         value == WHITE_BALANCE_FLUORESCENT ? 0x02 : 0x01);
1241         if (!err)
1242                 state->wb_preset = value;
1243
1244         return err;
1245 }
1246
1247 static int m5mo_set_effect(struct v4l2_subdev *sd, int value)
1248 {
1249         struct m5mo_state *state = to_state(sd);
1250         int on;
1251         int err;
1252         int retry = 5;
1253
1254 retry:
1255         switch (value) {
1256         case V4L2_COLORFX_NONE:
1257         case V4L2_COLORFX_BW:
1258         case V4L2_COLORFX_SEPIA:
1259                 /* in PARAMETER */
1260                 err = m5mo_readb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_EFFECT, &on);
1261                 if (!err && on)
1262                         err = m5mo_set_mode(sd, M5MO_PARMSET_MODE);
1263                 if (!err && on)
1264                         err = m5mo_writeb(sd, M5MO_CATEGORY_PARM,
1265                                         M5MO_PARM_EFFECT, 0);
1266                 if (!err && on)
1267                         err = m5mo_set_mode(sd, M5MO_MONITOR_MODE);
1268                 /* in MONITOR */
1269                 if (!err)
1270                         err = m5mo_writeb(sd, M5MO_CATEGORY_MON,
1271                                         M5MO_MON_COLOR_EFFECT,
1272                                         value == V4L2_COLORFX_NONE ? 0x00 : 0x01);
1273                 if (!err && value != V4L2_COLORFX_NONE)
1274                         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_CFIXB,
1275                                         value == V4L2_COLORFX_SEPIA ? 0xd8 : 0x00);
1276                 if (!err && value != V4L2_COLORFX_NONE)
1277                         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_CFIXR,
1278                                         value == V4L2_COLORFX_SEPIA ? 0x18 : 0x00);
1279                 break;
1280         case V4L2_COLORFX_NEGATIVE:
1281                 /* in MONITOR */
1282                 err = m5mo_readb(sd, M5MO_CATEGORY_MON, M5MO_MON_COLOR_EFFECT, &on);
1283                 if (!err && on)
1284                         err = m5mo_writeb(sd, M5MO_CATEGORY_MON,
1285                                         M5MO_MON_COLOR_EFFECT, 0);
1286                 /* in PARAMETER */
1287                 if (!err)
1288                         err = m5mo_set_mode(sd, M5MO_PARMSET_MODE);
1289                 if (!err)
1290                         err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_EFFECT,
1291                                 value == V4L2_COLORFX_NEGATIVE ? 0x01 : 0x08);
1292                 /* in MONITOR */
1293                 if (!err)
1294                         err = m5mo_set_mode(sd, M5MO_MONITOR_MODE);
1295                 break;
1296         default:
1297                 err = -EINVAL;
1298                 value = V4L2_COLORFX_NONE;
1299                 if (retry) {
1300                         retry--;
1301                         goto retry;
1302                 }
1303         }
1304         if (!err)
1305                 state->colorfx = value;
1306
1307         return err;
1308 }
1309
1310 static int m5mo_set_scene_mode(struct v4l2_subdev *sd, int value)
1311 {
1312         struct m5mo_state *state = to_state(sd);
1313         int err;
1314         int evp;
1315
1316         if (value == state->scenemode)
1317                 return 0;
1318
1319         /* EV-P */
1320         evp = value == SCENE_MODE_PORTRAIT ? 0x01 :
1321                 value == SCENE_MODE_LANDSCAPE ? 0x02 :
1322                 value == SCENE_MODE_SPORTS ? 0x03 :
1323                 value == SCENE_MODE_PARTY_INDOOR ? 0x04 :
1324                 value == SCENE_MODE_BEACH_SNOW ? 0x05 :
1325                 value == SCENE_MODE_SUNSET ? 0x06 :
1326                 value == SCENE_MODE_DUSK_DAWN ? 0x07 :
1327                 value == SCENE_MODE_FALL_COLOR ? 0x08 :
1328                 value == SCENE_MODE_NIGHTSHOT ? 0x09 :
1329                 value == SCENE_MODE_BACK_LIGHT ? 0x0a :
1330                 value == SCENE_MODE_FIREWORKS ? 0x0b :
1331                 value == SCENE_MODE_TEXT ? 0x0c :
1332                 value == SCENE_MODE_CANDLE_LIGHT ? 0x0d : 0x0;
1333
1334         err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_EP_MODE_MON, evp);
1335         if (!err)
1336                 err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_EP_MODE_CAP, evp);
1337         if (!err)
1338                 /* ISO */
1339                 err = m5mo_set_iso(sd, ISO_AUTO);
1340         if (!err)
1341                 /* EV Bias */
1342                 err = m5mo_set_exposure(sd,
1343                                 value == SCENE_MODE_BEACH_SNOW ? EV_PLUS_2 :
1344                                 EV_DEFAULT + 4);
1345         if (!err) {
1346                 /* AWB */
1347                 u32 awb = value == SCENE_MODE_SUNSET ? WHITE_BALANCE_SUNNY :
1348                         value == SCENE_MODE_DUSK_DAWN ? WHITE_BALANCE_FLUORESCENT :
1349                         value == SCENE_MODE_CANDLE_LIGHT ? WHITE_BALANCE_SUNNY :
1350                         WHITE_BALANCE_AUTO;
1351                 err = m5mo_set_whitebalance(sd, awb);
1352         }
1353         if (!err)
1354                 /* Chroma Saturation */
1355                 err = m5mo_set_saturation(sd,
1356                         value == SCENE_MODE_LANDSCAPE ||
1357                         value == SCENE_MODE_PARTY_INDOOR ||
1358                         value == SCENE_MODE_BEACH_SNOW ? SATURATION_PLUS_1 :
1359                         value == SCENE_MODE_FALL_COLOR ? SATURATION_PLUS_2 :
1360                         SATURATION_DEFAULT);
1361         if (!err)
1362                 /* Sharpness */
1363                 err = m5mo_set_sharpness(sd,
1364                         value == SCENE_MODE_PORTRAIT ? SHARPNESS_MINUS_1 :
1365                         value == SCENE_MODE_LANDSCAPE ? SHARPNESS_PLUS_1 :
1366                         value == SCENE_MODE_TEXT ? SHARPNESS_PLUS_2 :
1367                         SHARPNESS_DEFAULT);
1368         if (!err)
1369                 /* Emotional Color */
1370                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM, M5MO_CAPPARM_MCC_MODE,
1371                         value == SCENE_MODE_NONE ? 0x01 : 0x00);
1372         if (!err)
1373                 state->scenemode = value;
1374
1375         return err;
1376 }
1377
1378 static int m5mo_set_zoom(struct v4l2_subdev *sd, int value)
1379 {
1380         struct m5mo_state *state = to_state(sd);
1381         int err;
1382         int zoom[] = { 1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19,
1383                 20, 21, 22, 24, 25, 26, 28, 29, 30, 31, 32, 34, 35, 36, 38, 39 };
1384
1385         err = m5mo_writeb(sd, M5MO_CATEGORY_MON, M5MO_MON_ZOOM, zoom[value]);
1386         if (!err)
1387                 state->zoom = value;
1388
1389         return err;
1390 }
1391
1392 static int m5mo_set_lock(struct v4l2_subdev *sd, int value)
1393 {
1394         struct m5mo_state *state = to_state(sd);
1395         int ret;
1396
1397         if (value == state->focus.lock)
1398                 return 0;
1399
1400         ret = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_LOCK, value);
1401         if (!ret)
1402                 ret = m5mo_writeb(sd, M5MO_CATEGORY_WB, M5MO_AWB_LOCK, value);
1403         if (!ret)
1404                 state->focus.lock = value;
1405
1406         return ret;
1407 }
1408
1409 static u32 m5mo_get_af(struct v4l2_subdev *sd)
1410 {
1411         struct m5mo_state *state = to_state(sd);
1412         struct i2c_client *client = v4l2_get_subdevdata(sd);
1413         struct device *cdev = &client->dev;
1414         u32 reg;
1415         int ret;
1416
1417         ret = m5mo_readb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_STATUS, &reg);
1418         if (!ret && reg != M5MO_AF_STATUS_FAILED &&
1419                 reg != M5MO_AF_STATUS_MOVING &&
1420                 reg != M5MO_AF_STATUS_SUCCESS &&
1421                 reg != M5MO_AF_STATUS_IDLE &&
1422                 reg != M5MO_AF_STATUS_BUSY)
1423                 return -EINVAL;
1424
1425         state->focus.status = reg;
1426
1427         ret = reg == M5MO_AF_STATUS_MOVING ? -EBUSY :
1428                 reg == M5MO_AF_STATUS_SUCCESS ? 0 :
1429                 reg == M5MO_AF_STATUS_FAILED ? -EAGAIN :
1430                 reg == M5MO_AF_STATUS_IDLE ? 0 : -EBUSY;
1431
1432         if (reg == M5MO_AF_STATUS_SUCCESS){
1433                 dev_info(cdev, "@@@ AF status %s\n", "Success");
1434         }else if (reg == M5MO_AF_STATUS_FAILED){
1435                 dev_info(cdev, "@@@ AF status %s\n", "Failed");
1436         }
1437
1438         return ret;
1439 }
1440
1441 static int m5mo_set_af_start(struct v4l2_subdev *sd)
1442 {
1443         struct m5mo_state *state = to_state(sd);
1444         struct i2c_client *client = v4l2_get_subdevdata(sd);
1445         struct device *cdev = &client->dev;
1446         int err = 0;
1447
1448 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
1449         dev_notice(cdev, "PERFORM : AF start\n");
1450 #endif
1451         dev_info(cdev, "@@@ AF start\n");
1452
1453         if (!is_focus(V4L2_FOCUS_AUTO_CONTINUOUS)) {
1454                 if(state->focus.lock == 0)
1455                         err = m5mo_set_lock(sd, 1);     /* lock AE/AWB */
1456                 if (!err)                       /* Execute Lens */
1457                         err = m5mo_writeb(sd, M5MO_CATEGORY_LENS,
1458                                         M5MO_LENS_AF_START, 1);
1459         } else
1460                 err = m5mo_writeb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_START,
1461                                 0x02);
1462         if (err)
1463                 return err;
1464
1465         state->focus.focusing = true;
1466         state->focus.status = M5MO_AF_START;
1467
1468         return err;
1469 }
1470
1471 static int m5mo_set_af_stop(struct v4l2_subdev *sd)
1472 {
1473         struct m5mo_state *state = to_state(sd);
1474         struct i2c_client *client = v4l2_get_subdevdata(sd);
1475         struct device *cdev = &client->dev;
1476         u32 reg;
1477         int err;
1478
1479 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
1480         dev_notice(cdev, "PERFORM : AF stop\n");
1481 #endif
1482         dev_info(cdev, "@@@ AF stop\n");
1483
1484         if (!is_focus(V4L2_FOCUS_AUTO_CONTINUOUS)) {
1485                 /* Read lens status, and figure out */
1486                 err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_STATUS, &reg);
1487                 if (!err && reg == 0x03) {
1488                         /* Stop first */
1489                         err = m5mo_writeb(sd, M5MO_CATEGORY_LENS,
1490                                         M5MO_LENS_AF_START, 0x00);
1491                         /* Check FACE Detection or MONITOR mode */
1492                         if (!err)
1493                                 err = m5mo_busy(sd, M5MO_CATEGORY_SYS,
1494                                                 M5MO_SYS_STATUS,
1495                                                 is_focus(V4L2_FOCUS_AUTO_FACE_DETECTION) ?
1496                                                 0x04 : 0x02);
1497                         if (err) {
1498                                 dev_info(cdev, "@@@ Failed to wait changing[%s]\n",
1499                                                 is_focus(V4L2_FOCUS_AUTO_FACE_DETECTION) ?
1500                                                 "FACE detect" : "MONITOR mode");
1501                                 return err;
1502                         }
1503                 }
1504                 if(state->focus.lock == 1)
1505                         err = m5mo_set_lock(sd, 0);
1506         } else
1507                 err = m5mo_writeb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_START, 0x00);
1508         if (!err)
1509                 state->focus.status = M5MO_AF_STOP;
1510
1511         return err;
1512 }
1513
1514 static int m5mo_set_af_mode(struct v4l2_subdev *sd, int val)
1515 {
1516         struct m5mo_state *state = to_state(sd);
1517         struct i2c_client *client = v4l2_get_subdevdata(sd);
1518         struct device *cdev = &client->dev;
1519         int old_mode;
1520         int err;
1521
1522         dev_info(cdev, "@@@ AF mode %d\n", val);
1523
1524         if (val == state->focus.mode)
1525                 return 0;
1526
1527         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE, &old_mode);
1528         if (!err && old_mode != M5MO_MONITOR_MODE) {
1529                 state->focus.needed = true;
1530                 return 0;
1531         }
1532         if (!err)
1533                 err = m5mo_writeb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_MODE,
1534                         val == V4L2_FOCUS_AUTO_NORMAL ? 0x00 :
1535                         val == V4L2_FOCUS_AUTO_MACRO ? 0x01 :
1536                         val == V4L2_FOCUS_AUTO_CONTINUOUS ? 0x02 :
1537                         val == V4L2_FOCUS_AUTO_FACE_DETECTION ? 0x03 : 0x04);
1538         if (!err)
1539                 state->focus.mode = val;
1540
1541         return err;
1542 }
1543
1544 static int m5mo_read_exif_info(struct v4l2_subdev *sd,
1545                                u32 addr_num, u32 addr_den, u32 times,
1546                                u32 *value)
1547 {
1548         u32 num, den;
1549
1550         int ret = m5mo_readl(sd, M5MO_CATEGORY_EXIF, addr_num, &num);
1551         if (!ret)
1552                 ret = m5mo_readl(sd, M5MO_CATEGORY_EXIF, addr_den, &den);
1553         if (ret)
1554                 return ret;
1555
1556         *value = den == 0 ? 0 : num * times / den;
1557
1558         return ret;
1559 }
1560
1561 static int m5mo_get_exif(struct v4l2_subdev *sd)
1562 {
1563         struct m5mo_state *state = to_state(sd);
1564         u16 iso_std_values[] = {        /* standard values */
1565                 10, 12, 16, 20, 25, 32, 40, 50, 64, 80,
1566                 100, 125, 160, 200, 250, 320, 400, 500, 640, 800,
1567                 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000 };
1568         u16 iso_qtable[] = {            /* quantization table */
1569                 11, 14, 17, 22, 28, 35, 44, 56, 71, 89,
1570                 112, 141, 178, 224, 282, 356, 449, 565, 712, 890,
1571                 1122, 1414, 1782, 2245, 2828, 3564, 4490, 5657, 7127, 8909 };
1572         int num_flash, num_iso, i, err;
1573
1574         /* exposure time */
1575         err = m5mo_read_exif_info(sd,
1576                         M5MO_EXIF_EXPTIME_NUM, M5MO_EXIF_EXPTIME_DEN,
1577                         1000, &state->exif.exptime);
1578         if (!err)       /* shutter speed */
1579                 err = m5mo_read_exif_info(sd,
1580                                 M5MO_EXIF_TV_NUM, M5MO_EXIF_TV_DEN,
1581                                 M5MO_DEF_APEX_DEN, &state->exif.tv);
1582         if (!err)       /* brightness */
1583                 err = m5mo_read_exif_info(sd,
1584                                 M5MO_EXIF_BV_NUM, M5MO_EXIF_BV_DEN,
1585                                 M5MO_DEF_APEX_DEN, &state->exif.bv);
1586         if (!err)       /* exposure */
1587                 err = m5mo_read_exif_info(sd,
1588                                 M5MO_EXIF_EBV_NUM, M5MO_EXIF_EBV_DEN,
1589                                 M5MO_DEF_APEX_DEN, &state->exif.ebv);
1590         if (!err)       /* flash */
1591                 err = m5mo_readw(sd, M5MO_CATEGORY_EXIF, M5MO_EXIF_FLASH,
1592                                 &num_flash);
1593         if (!err)       /* iso */
1594                 err = m5mo_readw(sd, M5MO_CATEGORY_EXIF, M5MO_EXIF_ISO,
1595                                 &num_iso);
1596         if (!err) {
1597                 state->exif.flash = (u16)num_flash;
1598                 for (i = 0; i < sizeof(iso_qtable); i++) {
1599                         if (num_iso <= iso_qtable[i]) {
1600                                 state->exif.iso = iso_std_values[i];
1601                                 break;
1602                         }
1603                 }
1604                 err = 0;
1605         }
1606
1607         return err;
1608 }
1609
1610 static int m5mo_start_capture(struct v4l2_subdev *sd, int value)
1611 {
1612         struct m5mo_state *state = to_state(sd);
1613         struct i2c_client *client = v4l2_get_subdevdata(sd);
1614         struct device *cdev = &client->dev;
1615         int err = 0;
1616         int reg = 0;
1617
1618 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
1619         dev_notice(cdev, "PERFORM : Shutter release lag\n");
1620         dev_notice(cdev, "PERFORM : Capture start\n");
1621 #endif
1622         /* Clear Interrupt */
1623         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_FACTOR, &reg);
1624         if (err)
1625                 return err;
1626         /* Enable Necessary Interrupt only */
1627         err = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_EN, M5MO_INT_CAPTURE);
1628         if (err)
1629                 return err;
1630
1631         err = m5mo_writeb(sd, M5MO_CATEGORY_CAPCTRL, M5MO_CAPCTRL_FRM_SEL,
1632                         0x01);
1633 #ifdef M5MO_POSTVIEW_SUPPORT
1634         /* JPEG(with header) + ThumbnailJPEG */
1635         if (!err)
1636                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
1637                                 M5MO_CAPPARM_YUVOUT_MAIN, 0x21);
1638 #else
1639         /* JPEG(with header) + ThumbnailJPEG + PostviewYUV */
1640         if (!err)
1641                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
1642                                 M5MO_CAPPARM_YUVOUT_MAIN, 0x10);
1643 #endif
1644         if (!err)
1645                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPCTRL, M5MO_CAPCTRL_TRANSFER,
1646                                 0x01);
1647         if (!err)
1648                 err = m5mo_wait(sd, M5MO_INT_CAPTURE, M5MO_TIMEOUT);
1649         if (!err)
1650                 err = m5mo_readl(sd, M5MO_CATEGORY_CAPCTRL, M5MO_CAPCTRL_IMG_SIZE,
1651                                         &state->jpeg.main_size);
1652         dev_info(cdev, "%s: jpeg main size = %d\n", __func__, state->jpeg.main_size);
1653         if (!err)
1654                 err = m5mo_readl(sd, M5MO_CATEGORY_CAPCTRL, M5MO_CAPCTRL_THUMB_SIZE,
1655                                         &state->jpeg.thumb_size);
1656         dev_info(cdev, "%s: jpeg thumb size = %d\n", __func__, state->jpeg.thumb_size);
1657         if (!err)
1658                 err = m5mo_get_exif(sd);
1659         if (!err) {
1660                 /* succeeded capture, and get information */
1661                 state->jpeg.main_offset = 0;
1662                 state->jpeg.thumb_offset = M5MO_JPEG_MAXSIZE;
1663                 state->jpeg.postview_offset = M5MO_JPEG_MAXSIZE +
1664                         M5MO_THUMB_MAXSIZE;
1665
1666                 /* clear issued & unlock AE/AWB */
1667                 state->isp.issued = 0;
1668         }
1669
1670 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
1671         dev_notice(cdev, "PERFORM : Capture end\n");
1672 #endif
1673         return err;
1674 }
1675
1676 static int m5mo_set_jpeg_quality(struct v4l2_subdev *sd, int value)
1677 {
1678         struct m5mo_state *state = to_state(sd);
1679         int err;
1680
1681         err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM, M5MO_CAPPARM_JPEG_RATIO, 0x62);
1682         if (!err)
1683                 /* Normal 0x0a, Fine 0x05, Superfine 0x0 */
1684                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
1685                                 M5MO_CAPPARM_JPEG_RATIO_OFS,
1686                                 value <= 65 ? 0x0a :
1687                                 value > 65 && value <= 75 ? 0x05 : 0x0);
1688         if (!err)
1689                 state->jpeg.quality = value;
1690
1691         return err;
1692 }
1693
1694 #if 0           /* unused control functions */
1695 static int m5mo_set_antishake(struct v4l2_subdev *sd, int val)
1696 {
1697         int ahs, err;
1698
1699         ahs = (val == 1 ? 0x0E : 0x00);
1700
1701         err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_EP_MODE_MON, ahs);
1702         if (!err)
1703                 err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_EP_MODE_CAP, ahs);
1704
1705         return err;
1706 }
1707
1708 static int m5mo_set_face_beauty(struct v4l2_subdev *sd, int val)
1709 {
1710         struct m5mo_state *state = to_state(sd);
1711         int err;
1712
1713         err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM, M5MO_CAPPARM_AFB_CAP_EN,
1714                         val ? 0x01 : 0x00);
1715         if (!err)
1716                 state->beauty_mode = val;
1717
1718         return err;
1719 }
1720
1721 static int m5mo_set_touch_auto_focus(struct v4l2_subdev *sd, int val)
1722 {
1723         struct m5mo_state *state = to_state(sd);
1724         struct i2c_client *client = v4l2_get_subdevdata(sd);
1725         struct device *cdev = &client->dev;
1726         int err = 0;
1727
1728         dev_info(cdev, "@@@ AF(Touch) %s\n", val ? "on" : "off");
1729
1730         if (val) {
1731                 err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_RECTANGLE);
1732                 if (!err)
1733                         err = m5mo_writew(sd, M5MO_CATEGORY_LENS,
1734                                         M5MO_LENS_AF_TOUCH_POSX,
1735                                         state->focus.pos_x);
1736                 if (!err)
1737                         err = m5mo_writew(sd, M5MO_CATEGORY_LENS,
1738                                         M5MO_LENS_AF_TOUCH_POSY,
1739                                         state->focus.pos_y);
1740         }
1741         if (!err)
1742                 state->focus.touch = val;
1743
1744         return err;
1745 }
1746 #endif
1747
1748 static int m5mo_check_esd(struct v4l2_subdev *sd)
1749 {
1750         struct i2c_client *client = v4l2_get_subdevdata(sd);
1751         struct device *cdev = &client->dev;
1752         s32 val = 0;
1753         int err = 0;
1754
1755         /* check ISP */
1756         err = m5mo_readb(sd, M5MO_CATEGORY_TEST, M5MO_TEST_ISP_PROCESS, &val);
1757         if (err)
1758                 return err;
1759
1760         if (val != 0x80)
1761                 goto esd_occur;
1762         else {
1763                 err = m5mo_wait(sd, M5MO_INT_MODE, M5MO_ESD_TIMEOUT);
1764                 if (!err)
1765                         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_ESD_INT,
1766                                         &val);
1767                 if (!err && (val & M5MO_INT_ESD))
1768                         goto esd_occur;
1769         }
1770
1771         dev_info(cdev, "ESD is not detected\n");
1772
1773         return err;
1774
1775 esd_occur:
1776         dev_info(cdev, "ESD shock is detected\n");
1777         return -EIO;
1778 }
1779
1780 static int m5mo_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1781 {
1782         struct m5mo_state *state = to_state(sd);
1783         struct i2c_client *client = v4l2_get_subdevdata(sd);
1784         struct device *cdev = &client->dev;
1785         struct v4l2_queryctrl qc = { 0, };
1786         int value = ctrl->value;
1787         int err = 0;
1788
1789         if (unlikely(state->isp.bad_fw && ctrl->id != V4L2_CID_CAM_UPDATE_FW)) {
1790                 dev_err(cdev, "\"Unknown\" state, please update F/W");
1791                 return -ENOSYS;
1792         }
1793
1794         qc.id = ctrl->id;
1795         err = m5mo_queryctrl(sd, &qc);
1796         if (err) {
1797                 dev_info(cdev, "s_ctrl: no CID[0x%08x] value[%d]. Just pass.\n",
1798                                 ctrl->id, ctrl->value);
1799                 /*
1800                  * After optimizing CID from SLP Platform, alive return
1801                  * -ENOIOCTLCMD
1802                  */
1803 #if 0
1804                 return -ENOIOCTLCMD;*/
1805 #endif
1806         }
1807
1808         switch (ctrl->id) {
1809 #if 0
1810         case V4L2_CID_CAM_UPDATE_FW:
1811                 if (ctrl->value == FW_MODE_DUMP)
1812                         err = m5mo_dump_fw(sd);
1813                 else
1814                         err = m5mo_check_fw(sd);
1815                 break;
1816 #endif
1817         /* dependent on SENSOR itself */
1818         case V4L2_CID_CAMERA_SENSOR_MODE:
1819                 err = 0;        /* FIXME */
1820                 break;
1821         case V4L2_CID_CAM_DR:
1822         case V4L2_CID_CAMERA_WDR:
1823                 err = m5mo_set_wdr(sd, value);
1824                 break;
1825         case V4L2_CID_CAMERA_HDR:
1826                 err = m5mo_set_hdr(sd, value);
1827                 break;
1828
1829         /* Flash */
1830         case V4L2_CID_CAMERA_FLASH_MODE:
1831                 err = m5mo_set_flash(sd, value);
1832                 break;
1833
1834         /* Exposure & Scenemode stuff(ISO, Metering, Saturation, etc) */
1835         case V4L2_CID_CAMERA_ISO:
1836                 err = m5mo_set_iso(sd, value);
1837                 break;
1838         case V4L2_CID_CAMERA_METERING:
1839                 err = m5mo_set_metering(sd, value);
1840                 break;
1841         case V4L2_CID_EXPOSURE:
1842                 err = m5mo_set_exposure(sd, value);
1843                 break;
1844         case V4L2_CID_SATURATION:
1845                 err = m5mo_set_saturation(sd, value);
1846                 break;
1847         case V4L2_CID_SHARPNESS:
1848                 err = m5mo_set_sharpness(sd, value);
1849                 break;
1850         case V4L2_CID_WHITE_BALANCE_PRESET:
1851                 err = m5mo_set_whitebalance(sd, value);
1852                 break;
1853         case V4L2_CID_COLORFX:
1854                 err = m5mo_set_effect(sd, value);
1855                 break;
1856         case V4L2_CID_CAMERA_SCENE_MODE:
1857                 err = m5mo_set_scene_mode(sd, value);
1858                 break;
1859         /* Zoom */
1860         case V4L2_CID_ZOOM_ABSOLUTE:
1861         case V4L2_CID_CAMERA_ZOOM:
1862                 if (state->support_zoom == true) {
1863                         dev_info(cdev, "%s: zoom level %d\n", __func__, value);
1864                         err = m5mo_set_zoom(sd, value);
1865                 } else {
1866                         dev_info(cdev, "%s: This resulution is not support zoom\n", __func__);
1867                         return -EINVAL;
1868                 }
1869                 break;
1870         /* Focus */
1871         case V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT:
1872                 state->focus.pos_x = value;
1873                 break;
1874         case V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP:
1875                 state->focus.pos_y = value;
1876                 break;
1877         case V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH:
1878                 state->focus.width = value;
1879                 break;
1880         case V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT:
1881                 state->focus.height = value;
1882                 break;
1883         case V4L2_CID_FOCUS_AUTO_MODE:
1884                 if (value == V4L2_FOCUS_AUTO_MACRO)
1885                         err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_MACRO);
1886                 else if (value == V4L2_FOCUS_AUTO_CONTINUOUS)
1887                         err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_CONTINUOUS);
1888                 else if (value == V4L2_FOCUS_AUTO_FACE_DETECTION)
1889                         err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_FACE_DETECTION);
1890                 else if (value == V4L2_FOCUS_AUTO_RECTANGLE)
1891                         err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_RECTANGLE);
1892                 else    /* V4L2_FOCUS_AUTO_NORMAL */
1893                         err = m5mo_set_af_mode(sd, V4L2_FOCUS_AUTO_NORMAL);
1894                 break;
1895         case V4L2_CID_CAMERA_SET_AUTO_FOCUS:
1896                 /* Focus off */
1897                 if (!value) {
1898                         if (state->focus.focusing != true)
1899                                 break;
1900
1901                         err = m5mo_set_af_stop(sd);
1902                         if (!err)
1903                                 state->focus.focusing = false;
1904                         break;
1905                 }
1906
1907                 /* Focus on */
1908                 if (state->focus.focusing == false) {
1909                         err = m5mo_set_af_start(sd);
1910                         if (!err && !(is_focus(V4L2_FOCUS_AUTO_CONTINUOUS)))
1911                                 err = -EBUSY;
1912                 } else {
1913                         err = m5mo_get_af(sd);
1914                         if (err)
1915                                 return err;
1916                 }
1917                 break;
1918
1919         /* Capture */
1920         case V4L2_CID_CAMERA_CAPTURE:
1921                 err = m5mo_start_capture(sd, value);
1922                 break;
1923         case V4L2_CID_CAM_JPEG_QUALITY:
1924                 err = m5mo_set_jpeg_quality(sd, value);
1925                 break;
1926         case V4L2_CID_CAMERA_CHECK_ESD:
1927                 err = m5mo_check_esd(sd);
1928                 break;
1929
1930         default:
1931                 return 0;
1932         }
1933
1934         dev_dbg(cdev, "s_ctrl: CID[%s][0x%08x] PRIVATE[%d] val[%d] ret[%d]\n",
1935                         v4l2_ctrl_get_name(ctrl->id), ctrl->id,
1936                         ctrl->id - V4L2_CID_PRIVATE_BASE,
1937                         value, err);
1938         return err;
1939 }
1940
1941 static int m5mo_check_manufacturer_id(struct v4l2_subdev *sd)
1942 {
1943         struct i2c_client *client = v4l2_get_subdevdata(sd);
1944         struct device *cdev = &client->dev;
1945         u8 id;
1946         u32 addr[] = {0x1000AAAA, 0x10005554, 0x1000AAAA};
1947         u8 val[3][2] = {
1948                 [0] = {0x00, 0xAA},
1949                 [1] = {0x00, 0x55},
1950                 [2] = {0x00, 0x90},
1951         };
1952         u8 reset[] = {0x00, 0xF0};
1953         int i, err;
1954
1955         /* set manufacturer's ID read-mode */
1956         for (i = 0; i < 3; i++) {
1957                 err = m5mo_mem_write(sd, 0x06, 2, addr[i], val[i]);
1958                 if (err < 0)
1959                         return err;
1960         }
1961
1962         /* read manufacturer's ID */
1963         err = m5mo_mem_read(sd, sizeof(id), 0x10000001, &id);
1964         if (err >= 0)
1965                 /* reset manufacturer's ID read-mode */
1966                 err = m5mo_mem_write(sd, 0x06, sizeof(reset), 0x10000000, reset);
1967         if (err < 0)
1968                 return err;
1969
1970         dev_info(cdev, "%#x\n", id);
1971
1972         return id;
1973 }
1974
1975 static int m5mo_program_fw(struct v4l2_subdev *sd,
1976         u8 *buf, u32 addr, u32 unit, u32 count, u8 id)
1977 {
1978         struct i2c_client *client = v4l2_get_subdevdata(sd);
1979         struct device *cdev = &client->dev;
1980         u32 val;
1981         u32 intram_unit = SZ_4K;
1982         int i, j, retries, err = 0;
1983         int erase = 0x01;
1984         if (unit == SZ_64K && id != 0x01)
1985                 erase = 0x04;
1986
1987         for (i = 0; i < unit*count; i += unit) {
1988                 /* Set Flash ROM memory address */
1989                 err = m5mo_writel(sd, M5MO_CATEGORY_FLASH,
1990                         M5MO_FLASH_ADDR, addr + i);
1991                 if (err)
1992                         return err;
1993
1994                 /* Erase FLASH ROM entire memory */
1995                 err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH,
1996                         M5MO_FLASH_ERASE, erase);
1997                 if (err)
1998                         return err;
1999
2000                 /* Response while sector-erase is operating */
2001                 retries = 0;
2002                 do {
2003                         mdelay(50);
2004                         err = m5mo_readb(sd, M5MO_CATEGORY_FLASH,
2005                                 M5MO_FLASH_ERASE, &val);
2006                         if (err)
2007                                 return err;
2008
2009                 } while (val == erase && retries++ < M5MO_I2C_VERIFY);
2010
2011                 if (val != 0) {
2012                         dev_info(cdev, "failed to erase sector\n");
2013                         return -1;
2014                 }
2015
2016                 /* Set FLASH ROM programming size */
2017                 err = m5mo_writew(sd, M5MO_CATEGORY_FLASH, M5MO_FLASH_BYTE,
2018                         unit == SZ_64K ? 0 : unit);
2019                 if (err)
2020                         return err;
2021
2022                 /* Clear M-5MoLS internal RAM */
2023                 err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH,
2024                         M5MO_FLASH_RAM_CLEAR, 0x01);
2025                 if (err)
2026                         return err;
2027
2028                 /* Set Flash ROM programming address */
2029                 err = m5mo_writel(sd, M5MO_CATEGORY_FLASH,
2030                         M5MO_FLASH_ADDR, addr + i);
2031                 if (err)
2032                         return err;
2033
2034                 /* Send programmed firmware */
2035                 for (j = 0; j < unit; j += intram_unit) {
2036                         err = m5mo_mem_write(sd, 0x04, intram_unit,
2037                                 M5MO_INT_RAM_BASE_ADDR + j, buf + i + j);
2038                         if (err < 0)
2039                                 return err;
2040                         mdelay(10);
2041                 }
2042
2043                 /* Start Programming */
2044                 err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH, M5MO_FLASH_WR, 0x01);
2045                 if (err)
2046                         return err;
2047
2048                 /* Confirm programming has been completed */
2049                 retries = 0;
2050                 do {
2051                         mdelay(50);
2052                         err = m5mo_readb(sd, M5MO_CATEGORY_FLASH,
2053                                 M5MO_FLASH_WR, &val);
2054                         if (err)
2055                                 return err;
2056
2057                 } while (val && retries++ < M5MO_I2C_VERIFY);
2058
2059                 if (val != 0) {
2060                         dev_info(cdev, "failed to program\n");
2061                         return -1;
2062                 }
2063         }
2064
2065         return 0;
2066 }
2067
2068 static int m5mo_load_fw(struct v4l2_subdev *sd)
2069 {
2070         struct i2c_client *client = v4l2_get_subdevdata(sd);
2071         struct device *dev = &client->adapter->dev;
2072         struct device *cdev = &client->dev;
2073         const struct firmware *fentry;
2074         u8 sensor_ver[M5MO_FW_VER_LEN] = {0, };
2075         u8 *buf = NULL, val, id;
2076         int offset, err;
2077
2078 #ifdef SDCARD_FW
2079         struct file *fp;
2080         mm_segment_t old_fs;
2081         long fsize, nread;
2082         int fw_requested = 1;
2083
2084         old_fs = get_fs();
2085         set_fs(KERNEL_DS);
2086
2087         fp = filp_open(M5MO_FW_PATH, O_RDONLY, 0);
2088         if (IS_ERR(fp)) {
2089                 dev_err(cdev, "failed to open %s, err %ld\n",
2090                         M5MO_FW_PATH, PTR_ERR(fp));
2091                 goto request_fw;
2092         }
2093
2094         fw_requested = 0;
2095         fsize = fp->f_path.dentry->d_inode->i_size;
2096
2097         dev_info(cdev, "start, file path %s, size %ld Bytes\n",
2098                         M5MO_FW_PATH, fsize);
2099
2100         buf = vmalloc(fsize);
2101         if (!buf) {
2102                 dev_info(cdev, "failed to allocate memory\n");
2103                 err = -ENOMEM;
2104                 goto out;
2105         }
2106
2107         nread = vfs_read(fp, (char __user *)buf, fsize, &fp->f_pos);
2108         if (nread != fsize) {
2109                 dev_info(cdev, "failed to read firmware file, %ld Bytes\n", nread);
2110                 err = -EIO;
2111                 goto out;
2112         }
2113
2114 request_fw:
2115         if (fw_requested) {
2116                 set_fs(old_fs);
2117 #endif /* SDCARD_FW */
2118         m5mo_get_sensor_fw_version(sd, sensor_ver);
2119
2120         if (sensor_ver[0] == 'T')
2121                 err = request_firmware(&fentry, M5MOT_FW_REQUEST_PATH, dev);
2122         else
2123                 err = request_firmware(&fentry, M5MOO_FW_REQUEST_PATH, dev);
2124
2125         if (err != 0) {
2126                 dev_info(cdev, "request_firmware falied\n");
2127                         err = -EINVAL;
2128                         goto out;
2129         }
2130
2131         dev_info(cdev, "start, size %d Bytes\n", fentry->size);
2132         buf = (u8 *)fentry->data;
2133
2134 #ifdef SDCARD_FW
2135         }
2136 #endif /* SDCARD_FW */
2137
2138         /* set pin */
2139         val = 0x7E;
2140         err = m5mo_mem_write(sd, 0x04, sizeof(val), 0x50000308, &val);
2141         if (err < 0) {
2142                 dev_info(cdev, "i2c falied, err %d\n", err);
2143                 goto out;
2144         }
2145
2146         id = m5mo_check_manufacturer_id(sd);
2147         if (id < 0) {
2148                 dev_info(cdev, "i2c falied, err %d\n", id);
2149                 goto out;
2150         }
2151
2152         /* select flash memory */
2153         err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH,
2154                 M5MO_FLASH_SEL, id == 0x01 ? 0x00 : 0x01);
2155         if (err) {
2156                 dev_info(cdev, "i2c falied, err %d\n", err);
2157                 goto out;
2158         }
2159
2160         /* program FLSH ROM */
2161         err = m5mo_program_fw(sd, buf, M5MO_FLASH_BASE_ADDR, SZ_64K, 31, id);
2162         if (err < 0)
2163                 goto out;
2164
2165         offset = SZ_64K * 31;
2166         if (id == 0x01) {
2167                 err = m5mo_program_fw(sd,
2168                         buf + offset, M5MO_FLASH_BASE_ADDR + offset, SZ_8K, 4, id);
2169         } else {
2170                 err = m5mo_program_fw(sd,
2171                         buf + offset, M5MO_FLASH_BASE_ADDR + offset, SZ_4K, 8, id);
2172         }
2173
2174         dev_info(cdev, "end\n");
2175
2176 out:
2177 #ifdef SDCARD_FW
2178         if (!fw_requested) {
2179                 vfree(buf);
2180                 filp_close(fp, current->files);
2181                 set_fs(old_fs);
2182         }
2183 #endif  /* SDCARD_FW */
2184         return err;
2185 }
2186
2187 /*
2188  * v4l2_subdev_video_ops
2189  */
2190 static const struct m5mo_frmsizeenum *m5mo_get_frmsize
2191         (const struct m5mo_frmsizeenum *frmsizes, int num_entries, int index)
2192 {
2193         int i;
2194
2195         for (i = 0; i < num_entries; i++) {
2196                 if (frmsizes[i].index == index)
2197                         return &frmsizes[i];
2198         }
2199
2200         return NULL;
2201 }
2202
2203 static int m5mo_set_frmsize(struct v4l2_subdev *sd)
2204 {
2205         struct m5mo_state *state = to_state(sd);
2206         struct i2c_client *client = v4l2_get_subdevdata(sd);
2207         struct device *cdev = &client->dev;
2208         int err;
2209         u32 old_mode;
2210
2211         if (!is_format(V4L2_PIX_FMT_MODE_CAPTURE)) {
2212                 err = m5mo_set_mode(sd, M5MO_PARMSET_MODE);
2213                 if (!err)
2214                         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE,
2215                                         &old_mode);
2216                 if (!err)
2217                         err = m5mo_writeb(sd, M5MO_CATEGORY_PARM,
2218                                 M5MO_PARM_MON_SIZE, state->preview->reg_val);
2219                 if (!err && state->zoom) {
2220                         /*
2221                          * Zoom position returns to 1 when the monitor size
2222                          * is changed.
2223                          */
2224                         dev_info(cdev, "%s: zoom level %d\n", __func__, state->zoom);
2225                         err = m5mo_set_zoom(sd, state->zoom);
2226                 }
2227         } else
2228                 err = m5mo_writeb(sd, M5MO_CATEGORY_CAPPARM,
2229                         M5MO_CAPPARM_MAIN_IMG_SIZE, state->capture->reg_val);
2230         if (!err){
2231                 dev_info(cdev, "s_fmt: set_framesize %s %dx%d\n",
2232                         is_format(V4L2_PIX_FMT_MODE_CAPTURE) ?
2233                                 "CAPT" : "PREVIEW",
2234                         is_format(V4L2_PIX_FMT_MODE_CAPTURE) ?
2235                                 state->capture->width : state->preview->width,
2236                         is_format(V4L2_PIX_FMT_MODE_CAPTURE) ?
2237                                 state->capture->height : state->preview->height);
2238         }
2239
2240         return err;
2241 }
2242
2243 static int m5mo_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *ffmt)
2244 {
2245         struct m5mo_state *state = to_state(sd);
2246         struct i2c_client *client = v4l2_get_subdevdata(sd);
2247         struct device *cdev = &client->dev;
2248         const struct m5mo_frmsizeenum **frmsize;
2249         u32 width = ffmt->width;
2250         u32 height = ffmt->height;
2251         u32 tmp_width;
2252         u32 old_index;
2253         int i, num_entries;
2254         int err;
2255
2256 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2257         dev_notice(cdev, "PERFORM : S_FMT start\n");
2258 #endif
2259         if (unlikely(state->isp.bad_fw)) {
2260                 dev_info(cdev, "\"Unknown\" state, please update F/W");
2261                 return -ENOSYS;
2262         }
2263
2264         if (ffmt->width < ffmt->height) {
2265                 tmp_width = ffmt->height;
2266                 height = ffmt->width;
2267                 width = tmp_width;
2268         }
2269
2270         if (ffmt->colorspace == V4L2_COLORSPACE_JPEG) {
2271                 state->format_mode = V4L2_PIX_FMT_MODE_CAPTURE;
2272                 frmsize = &state->capture;
2273         } else {
2274                 state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW;
2275                 frmsize = &state->preview;
2276                 err = m5mo_set_mode(sd, M5MO_PARMSET_MODE);
2277                 if (err < 0)
2278                         return err;
2279         }
2280
2281         old_index = *frmsize ? (*frmsize)->index : -1;
2282         *frmsize = NULL;
2283
2284         if (!is_format(V4L2_PIX_FMT_MODE_CAPTURE)) {
2285                 num_entries = ARRAY_SIZE(preview_frmsizes);
2286                 for (i = 0; i < num_entries; i++) {
2287                         if (width == preview_frmsizes[i].width &&
2288                                 height == preview_frmsizes[i].height) {
2289                                 *frmsize = &preview_frmsizes[i];
2290                                 break;
2291                         }
2292                 }
2293                 if (preview_frmsizes[i].index == M5MO_PREVIEW_1080P)
2294                         state->support_zoom = false;
2295                 else
2296                         state->support_zoom = true;
2297         } else {
2298                 num_entries = ARRAY_SIZE(capture_frmsizes);
2299                 for (i = 0; i < num_entries; i++) {
2300                         if (width == capture_frmsizes[i].width &&
2301                                 height == capture_frmsizes[i].height) {
2302                                 *frmsize = &capture_frmsizes[i];
2303                                 break;
2304                         }
2305                 }
2306                 if (*frmsize != NULL) {
2307                 state->wide_res = capture_frmsizes[i].wide_res;
2308                 dev_info(cdev, "%s: capture size: width = %d, height = %d, wide_res = %d\n",
2309                                 __func__, width, height, state->wide_res);
2310                 } else {
2311                         dev_info(cdev, "%s: Not supported resolution. Set default\n", __func__);
2312                         state->wide_res = 0;
2313                 }
2314         }
2315
2316         if (*frmsize == NULL) {
2317                 dev_info(cdev, "s_fmt: invalid size %dx%d\n", width, height);
2318                 *frmsize = state->format_mode != V4L2_PIX_FMT_MODE_CAPTURE ?
2319                         m5mo_get_frmsize(preview_frmsizes, num_entries,
2320                                 M5MO_PREVIEW_VGA) :
2321                         m5mo_get_frmsize(capture_frmsizes, num_entries,
2322                                 M5MO_CAPTURE_3MP);
2323         }
2324
2325         dev_info(cdev, "s_fmt: %dx%d\n", (*frmsize)->width, (*frmsize)->height);
2326
2327         if (old_index != (*frmsize)->index)
2328                 m5mo_set_frmsize(sd);
2329
2330 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2331         dev_notice(cdev, "PERFORM : S_FMT end\n");
2332 #endif
2333         return 0;
2334 }
2335
2336 static int m5mo_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
2337 {
2338         struct m5mo_state *state = to_state(sd);
2339         struct i2c_client *client = v4l2_get_subdevdata(sd);
2340         struct device *cdev = &client->dev;
2341
2342         dev_info(cdev, "g_parm: FPS %d\n", state->fps);
2343         if(state->fps == 0){
2344         a->parm.capture.timeperframe.numerator = state->fps;
2345         a->parm.capture.timeperframe.denominator = 1;
2346         }else{
2347                 a->parm.capture.timeperframe.numerator = 1;
2348                 a->parm.capture.timeperframe.denominator = state->fps;
2349         }
2350
2351         return 0;
2352 }
2353
2354 #define M5MO_PARM_MON_FPS       0x02
2355
2356 static int m5mo_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
2357 {
2358         struct m5mo_state *state = to_state(sd);
2359         struct i2c_client *client = v4l2_get_subdevdata(sd);
2360         struct device *cdev = &client->dev;
2361         u32 denom = a->parm.capture.timeperframe.denominator;
2362         u32 numer = a->parm.capture.timeperframe.numerator;
2363         u32 fps, idx = 0;
2364
2365 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2366         dev_notice(cdev, "PERFORM : S_PARM start\n");
2367 #endif
2368         if (denom >= 1 && numer == 1) {
2369                 fps = denom / numer;
2370
2371                 /*
2372                  * supported fps : 8(7.5), 10, 12, 15, 20, 21, 22, 23, 24, 30
2373                  */
2374                 if (fps > 0 && fps <= 9){ fps = 8;  state->fps_reg = 0x06;}
2375                 else if (fps > 9 && fps <= 11){ fps = 10; state->fps_reg = 0x05;}
2376                 else if (fps > 10 && fps <= 14){ fps = 12; state->fps_reg = 0x04;}
2377                 else if (fps > 14 && fps <= 18){ fps = 15; state->fps_reg = 0x03;}
2378                 else if (fps > 18 && fps <= 20){ fps = 20; state->fps_reg = 0x08;}
2379                 else if (fps > 20 && fps <= 21){ fps = 21; state->fps_reg = 0x09;}
2380                 else if (fps > 21 && fps <= 22){ fps = 22; state->fps_reg = 0x0A;}
2381                 else if (fps > 22 && fps <= 23){ fps = 23; state->fps_reg = 0x0B;}
2382                 else if (fps > 23 && fps <= 27){ fps = 24; state->fps_reg = 0x07;}
2383                 else{fps = 30; state->fps_reg = 0x02;}
2384
2385         } else if (denom == 1 && numer == 0){
2386                 fps = 0;
2387         } else
2388                 return -EINVAL;         /* Wrong fps */
2389
2390         if (state->fps != fps) {
2391                 state->fps = fps;
2392                 state->need_setfps = true;
2393         }
2394
2395         dev_info(cdev, "s_parm: denom %d, numer %d, FPS idx %08x\n",
2396                         denom, numer, idx);
2397
2398 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2399         dev_notice(cdev, "PERFORM : S_PARM end\n");
2400 #endif
2401         return 0;
2402 }
2403
2404 static int m5mo_enum_framesizes(struct v4l2_subdev *sd,
2405                                 struct v4l2_frmsizeenum *fsize)
2406 {
2407         struct m5mo_state *state = to_state(sd);
2408         u32 err, old_mode;
2409
2410         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_MODE, &old_mode);
2411         if (err)
2412                 return err;
2413
2414         /*
2415          * The camera interface should read this value, this is the resolution
2416          * at which the sensor would provide framedata to the camera i/f
2417          * In case of image capture,
2418          * this returns the default camera resolution (VGA)
2419          */
2420         if (!is_format(V4L2_PIX_FMT_MODE_CAPTURE)) {
2421                 if (state->preview == NULL || state->preview->index < 0)
2422                         return -EINVAL;
2423
2424                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
2425                 fsize->discrete.width = state->preview->width;
2426                 fsize->discrete.height = state->preview->height;
2427         } else {
2428                 if (state->capture == NULL || state->capture->index < 0)
2429                         return -EINVAL;
2430
2431                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
2432                 fsize->discrete.width = state->capture->width;
2433                 fsize->discrete.height = state->capture->height;
2434         }
2435
2436         return 0;
2437 }
2438
2439 static int m5mo_s_stream_preview(struct v4l2_subdev *sd, int enable)
2440 {
2441         struct m5mo_state *state = to_state(sd);
2442         struct i2c_client *client = v4l2_get_subdevdata(sd);
2443         struct device *cdev = &client->dev;
2444         int err;
2445
2446 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2447         dev_notice(cdev, "PERFORM : Preview enable start.\n");
2448 #endif
2449         if (!enable){
2450 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2451                 dev_notice(cdev, "PERFORM : Preview disable\n");
2452 #endif
2453                 return 0;
2454         }
2455
2456         /*
2457          * Removed contents - no more needs.
2458          * VTmode : M5MO_CATEGORY_AE, M5MO_AE_EP_MODE_MON, 0x11
2459          * Dataline check mode : M5MO_CATEGORY_TEST,
2460          *                       M5MO_TEST_OUTPUT_YCO_TEST_DATA, 0x01
2461          */
2462         if (state->need_setfps == true) {
2463                 err = m5mo_set_mode(sd, M5MO_PARMSET_MODE);
2464                 if (!err) {
2465                         /*
2466                          * Changing Frame Rate is able to be only for MONITOR mode.
2467                          * Don't call for CAPTURE mode. The Capture outcome can be
2468                          * strange.
2469                          */
2470                         if (state->fps == 30) {
2471                                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_HDMOVIE, 0x01);
2472                         } else {
2473                                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_HDMOVIE, 0x00);
2474                                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_MON_FPS, state->fps_reg);
2475                         }
2476                 }
2477                 state->need_setfps = false;
2478         }
2479         if (!err){
2480                 if(state->focus.lock == 1)
2481                         err = m5mo_set_lock(sd, 0);
2482         }
2483
2484         if (!err && state->focus.needed) {
2485                 state->focus.needed = false;
2486
2487                 /* Set Normal AF Mode */
2488                 if (!is_focus(V4L2_FOCUS_AUTO_MACRO) &&
2489                                 !is_focus(V4L2_FOCUS_AUTO_CONTINUOUS) &&
2490                                 !is_focus(V4L2_FOCUS_AUTO_NORMAL))
2491                         return -EINVAL;
2492                 err = m5mo_writeb(sd, M5MO_CATEGORY_LENS, M5MO_LENS_AF_MODE,
2493                                 is_focus(V4L2_FOCUS_AUTO_MACRO) ? 0x01 :
2494                                 is_focus(V4L2_FOCUS_AUTO_CONTINUOUS) ? 0x02 :
2495                                 0x04);  /* default AUTO */
2496                 state->focus.mode =
2497                         is_focus(V4L2_FOCUS_AUTO_MACRO) ? V4L2_FOCUS_AUTO_MACRO :
2498                         is_focus(V4L2_FOCUS_AUTO_CONTINUOUS) ?
2499                         V4L2_FOCUS_AUTO_CONTINUOUS :
2500                         V4L2_FOCUS_AUTO_RECTANGLE;      /* default TOUCH(AUTO) */
2501                 state->focus.status = M5MO_AF_STOP;
2502         }
2503         if (!err)
2504                 err = m5mo_set_mode(sd, M5MO_MONITOR_MODE);
2505         if (err)
2506                 return err;
2507
2508 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2509         dev_notice(cdev, "PERFORM : Preview %s end\n", enable ? "enable" : "disable");
2510 #endif
2511         return 0;
2512 }
2513
2514 static int m5mo_s_stream_capture(struct v4l2_subdev *sd, int enable)
2515 {
2516         struct m5mo_state *state = to_state(sd);
2517         struct i2c_client *client = v4l2_get_subdevdata(sd);
2518         struct device *cdev = &client->dev;
2519         int err = 0;
2520         int reg = 0;
2521
2522 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2523         dev_notice(cdev, "PERFORM : Capture %s. mode change start\n", enable ? "enable" : "disable");
2524 #endif
2525         if (!enable)
2526                 return m5mo_set_mode(sd, M5MO_PARMSET_MODE);
2527
2528         /*
2529          * As support team, it must be changing to STILLCAP mode (streamon
2530          * subdev call) before MIPI setup in FIMC driver.
2531          */
2532         state->isp.issued = 0;          /* clear issued & lock AE/AWB */
2533
2534         /* Clear Interrupt */
2535         err = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_FACTOR, &reg);
2536         if (err)
2537                 return err;
2538         /* Enable Necessary Interrupt only */
2539         err = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_EN, M5MO_INT_CAPTURE);
2540         if (err)
2541                 return err;
2542
2543         err = m5mo_set_mode(sd, M5MO_STILLCAP_MODE);
2544         if (!err)
2545                 err = m5mo_wait(sd, M5MO_INT_CAPTURE, M5MO_TIMEOUT);
2546
2547 #if defined(CONFIG_VIDEO_M5MO_DEBUG)
2548         dev_notice(cdev, "PERFORM : Capture %s. mode change end\n", enable ? "enable" : "disable");
2549 #endif
2550         return err;
2551 }
2552
2553 static int m5mo_s_stream(struct v4l2_subdev *sd, int enable)
2554 {
2555         struct m5mo_state *state = to_state(sd);
2556         struct i2c_client *client = v4l2_get_subdevdata(sd);
2557         struct device *cdev = &client->dev;
2558         int err = -EINVAL;
2559
2560         if (unlikely(state->isp.bad_fw)) {
2561                 dev_info(cdev, "\"Unknown\" state, please update F/W");
2562                 return -ENOSYS;
2563         }
2564
2565         switch (enable) {
2566         case STREAM_MODE_CAM_ON:
2567         case STREAM_MODE_CAM_OFF:
2568                 switch (state->format_mode) {
2569                 case V4L2_PIX_FMT_MODE_CAPTURE:
2570                         dev_info(cdev, "s_stream: capture %s\n",
2571                                 enable == STREAM_MODE_CAM_ON ? "on" : "off");
2572                         err = m5mo_s_stream_capture(sd,
2573                                         enable == STREAM_MODE_CAM_ON);
2574                         break;
2575                 default:
2576                         dev_info(cdev, "s_stream: preview %s\n",
2577                                 enable == STREAM_MODE_CAM_ON ? "on" : "off");
2578                         err = m5mo_s_stream_preview(sd,
2579                                         enable == STREAM_MODE_CAM_ON);
2580                         break;
2581                 }
2582                 break;
2583
2584         default:
2585                 dev_info(cdev, "invalid stream option, %d\n", enable);
2586                 break;
2587         }
2588
2589         return err;
2590 }
2591
2592 static int m5mo_check_version(struct v4l2_subdev *sd)
2593 {
2594         struct m5mo_state *state = to_state(sd);
2595         struct i2c_client *client = v4l2_get_subdevdata(sd);
2596         struct device *cdev = &client->dev;
2597         int i, val;
2598         int ret;
2599
2600         for (i = 0; i < 6; i++) {
2601                 ret = m5mo_readb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_USER_VER, &val);
2602                 state->exif.unique_id[i] = (char)val;
2603         }
2604         state->exif.unique_id[i] = '\0';
2605
2606         dev_info(cdev, "*************************************\n");
2607         dev_info(cdev, "F/W Version: %s\n", state->exif.unique_id);
2608         dev_info(cdev, "Binary Released: %s %s\n", __DATE__, __TIME__);
2609         dev_info(cdev, "*************************************\n");
2610
2611         return ret;
2612 }
2613
2614 static int m5mo_init_param(struct v4l2_subdev *sd)
2615 {
2616         struct m5mo_state *state = to_state(sd);
2617         int err;
2618
2619         err = m5mo_writeb(sd, M5MO_CATEGORY_SYS, M5MO_SYS_INT_EN,
2620                 M5MO_INT_CAPTURE | M5MO_INT_SOUND);
2621         if (!err)
2622                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_OUT_SEL, 0x02);
2623         if (!err){
2624                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_MON_FPS, 0x01);
2625                 state->fps = 0;
2626         }
2627         if (!err)
2628                 err = m5mo_writel(sd, M5MO_CATEGORY_CAPPARM,
2629                                 M5MO_CAPPARM_THUMB_JPEG_MAX, M5MO_THUMB_MAXSIZE);
2630         if (!err)
2631                 err = m5mo_writeb(sd, M5MO_CATEGORY_FD, M5MO_FD_CTL, 0x0);
2632         if (!err)
2633                 err = m5mo_writeb(sd, M5MO_CATEGORY_PARM, M5MO_PARM_HDMOVIE, 0x00);
2634         if (!err)
2635                 err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_FLICKER, 0x02);
2636         if (!err)
2637                 err = m5mo_writeb(sd, M5MO_CATEGORY_AE, M5MO_AE_EV_BIAS, 0x1e);
2638         return err;
2639 }
2640
2641 static int m5mo_init(struct v4l2_subdev *sd, u32 val)
2642 {
2643         struct m5mo_state *state = to_state(sd);
2644         int err;
2645
2646         /* Default state values */
2647         state->preview = NULL;
2648         state->capture = NULL;
2649         state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW;
2650         state->isp.bad_fw = 0;
2651         state->fps = 0;                 /* auto */
2652
2653         /* Set default controls */
2654         memset(&state->focus, 0, sizeof(state->focus));
2655         memset(&state->jpeg, 0, sizeof(state->jpeg));
2656         memset(&state->exif, 0, sizeof(state->exif));
2657         state->flash_mode = FLASH_MODE_OFF;
2658         state->colorfx = V4L2_COLORFX_NONE;
2659         state->wdr = WDR_OFF;
2660         state->hdr = 0;
2661         state->iso = ISO_AUTO;
2662         state->metering = METERING_MATRIX;
2663         state->exposure = EV_DEFAULT + 4;
2664         state->saturation = SATURATION_DEFAULT;
2665         state->sharpness = SHARPNESS_DEFAULT;
2666         state->wb_preset = WHITE_BALANCE_AUTO;
2667         state->scenemode = SCENE_MODE_BASE;
2668         state->zoom = ZOOM_LEVEL_0;
2669         state->support_zoom = true;
2670         state->need_setfps = true;
2671
2672         /* start camera program(parallel FLASH ROM) */
2673         err = m5mo_writeb(sd, M5MO_CATEGORY_FLASH, M5MO_FLASH_CAM_START, 0x01);
2674         if (!err)
2675                 err = m5mo_wait(sd, M5MO_INT_MODE, M5MO_TIMEOUT);
2676         if (!err)
2677                 err = m5mo_check_version(sd);   /* check up F/W version */
2678         if (err)
2679                 return err;
2680
2681         return m5mo_init_param(sd);
2682 }
2683
2684 static int m5mo_s_power(struct v4l2_subdev *sd, int on)
2685 {
2686         struct i2c_client *client = v4l2_get_subdevdata(sd);
2687         const struct m5mo_platform_data *pdata = client->dev.platform_data;
2688         struct device *dev = &client->dev;
2689         struct m5mo_state *state = to_state(sd);
2690         int ret = 0;
2691
2692         if (on)
2693                 return 0;
2694
2695         /* Only when disable sensor */
2696         ret = m5mo_set_af_softlanding(sd);
2697         if (ret < 0)
2698                 return -EAGAIN;
2699         if (pdata->flash_power && state->flash_mode != FLASH_MODE_OFF)
2700                 ret = pdata->flash_power(0, dev);
2701         if (ret < 0)
2702                 return -EAGAIN;
2703
2704         return ret;
2705 }
2706
2707 static const struct v4l2_subdev_core_ops m5mo_core_ops = {
2708         .init = m5mo_init,              /* initializing API */
2709         .load_fw = m5mo_load_fw,
2710         .queryctrl = m5mo_queryctrl,
2711         .g_ctrl = m5mo_g_ctrl,
2712         .s_ctrl = m5mo_s_ctrl,
2713         .s_power = m5mo_s_power,        /* Used only when release subdev */
2714 };
2715
2716 static const struct v4l2_subdev_video_ops m5mo_video_ops = {
2717         .s_mbus_fmt = m5mo_s_fmt,
2718         .g_parm = m5mo_g_parm,
2719         .s_parm = m5mo_s_parm,
2720         .enum_framesizes = m5mo_enum_framesizes,
2721         .s_stream = m5mo_s_stream,
2722 };
2723
2724 static const struct v4l2_subdev_ops m5mo_ops = {
2725         .core = &m5mo_core_ops,
2726         .video = &m5mo_video_ops,
2727 };
2728
2729 static ssize_t m5mo_camera_type_show(struct device *dev,
2730         struct device_attribute *attr, char *buf)
2731 {
2732         char type[] = "SONY_M5MO_NONE";
2733
2734         return sprintf(buf, "%s\n", type);
2735 }
2736
2737 static ssize_t m5mo_camera_fw_show(struct device *dev,
2738         struct device_attribute *attr, char *buf)
2739 {
2740         struct i2c_client *client = to_i2c_client(dev);
2741         struct v4l2_subdev *sd = i2c_get_clientdata(client);
2742         struct m5mo_state *state = to_state(sd);
2743
2744         return sprintf(buf, "%s\n", state->fw_version);
2745 }
2746
2747 static DEVICE_ATTR(camera_type, S_IRUGO, m5mo_camera_type_show, NULL);
2748 static DEVICE_ATTR(camera_fw, S_IRUGO, m5mo_camera_fw_show, NULL);
2749
2750 #ifdef CONFIG_VIDEO_M5MO_I2C_DEBUG
2751 static ssize_t m5mo_i2c_debug_r(struct device *dev,
2752                                 struct device_attribute *attr,
2753                                 char *buf)
2754 {
2755         struct i2c_client *client = to_i2c_client(dev);
2756         struct v4l2_subdev *sd = i2c_get_clientdata(client);
2757         struct m5mo_state *state = to_state(sd);
2758         u32 value;
2759         int ret;
2760
2761         ret = m5mo_read(sd, 1, (u8)state->dbg.category,
2762                                 (u8)state->dbg.command, &value);
2763         if (!ret)
2764                 state->dbg.value = (u8)value;
2765
2766         return snprintf(buf, PAGE_SIZE, "%02x\n", state->dbg.value);
2767 }
2768
2769 static ssize_t m5mo_i2c_debug_w(struct device *dev,
2770                                 struct device_attribute *attr,
2771                                 char *buf, size_t count)
2772 {
2773         struct i2c_client *client = to_i2c_client(dev);
2774         struct v4l2_subdev *sd = i2c_get_clientdata(client);
2775         struct m5mo_state *state = to_state(sd);
2776         int category, command, value;
2777
2778         sscanf(buf, "%02x %02x %02x", &category, &command, &value);
2779         state->dbg.category = (u8)category;
2780         state->dbg.command = (u8)command;
2781         state->dbg.value = (u8)value;
2782
2783         m5mo_write(sd, 1, (u8)state->dbg.category,
2784                         (u8)state->dbg.command, (u8)state->dbg.value);
2785
2786         return strnlen(buf, PAGE_SIZE);
2787 }
2788
2789 static DEVICE_ATTR(i2c_debug, S_IRUGO | S_IWUGO,
2790                                         m5mo_i2c_debug_r, m5mo_i2c_debug_w);
2791 #endif  /* CONFIG_VIDEO_M5MO_I2C_DEBUG */
2792
2793 /*
2794  * m5mo_probe
2795  * Fetching platform data is being done with s_config subdev call.
2796  * In probe routine, we just register subdev device
2797  */
2798 static int __devinit m5mo_probe(struct i2c_client *client,
2799                          const struct i2c_device_id *id)
2800 {
2801         struct m5mo_state *state;
2802         struct device *cdev = &client->dev;
2803         struct v4l2_subdev *sd;
2804
2805         const struct m5mo_platform_data *pdata =
2806                 client->dev.platform_data;
2807         int err = 0;
2808
2809         state = kzalloc(sizeof(struct m5mo_state), GFP_KERNEL);
2810         if (state == NULL)
2811                 return -ENOMEM;
2812
2813         sd = &state->sd;
2814         strcpy(sd->name, M5MO_DRIVER_NAME);
2815
2816         /* Registering subdev */
2817         v4l2_i2c_subdev_init(sd, client, &m5mo_ops);
2818
2819         if (device_create_file(&client->dev, &dev_attr_camera_type) < 0) {
2820                 dev_info(cdev, "Failed to create device file, %s\n",
2821                         dev_attr_camera_type.attr.name);
2822         }
2823
2824         if (device_create_file(&client->dev, &dev_attr_camera_fw) < 0) {
2825                 dev_info(cdev, "Failed to create device file, %s\n",
2826                         dev_attr_camera_fw.attr.name);
2827         }
2828
2829 #ifdef CONFIG_VIDEO_M5MO_I2C_DEBUG
2830         if (device_create_file(&client->dev, &dev_attr_i2c_debug) < 0) {
2831                 dev_info(cdev, "Failed to create device file, %s\n",
2832                         dev_attr_i2c_debug.attr.name);
2833         }
2834 #endif
2835
2836         /* wait queue initialize */
2837         init_waitqueue_head(&state->isp.wait);
2838
2839         if (pdata->config_isp_irq)
2840                 pdata->config_isp_irq();
2841
2842         err = request_irq(pdata->irq,
2843                 m5mo_isp_isr, IRQF_TRIGGER_RISING, "m5mo isp", sd);
2844         if (err) {
2845                 dev_info(cdev, "failed to request irq\n");
2846                 return err;
2847         }
2848         state->isp.irq = pdata->irq;
2849         state->isp.issued = 0;
2850
2851         return 0;
2852 }
2853
2854 static int __devexit m5mo_remove(struct i2c_client *client)
2855 {
2856         struct v4l2_subdev *sd = i2c_get_clientdata(client);
2857         struct m5mo_state *state = to_state(sd);
2858         int ret = 0;
2859
2860 #ifdef CONFIG_VIDEO_M5MO_I2C_DEBUG
2861         device_remove_file(&client->dev, &dev_attr_i2c_debug);
2862 #endif
2863         device_remove_file(&client->dev, &dev_attr_camera_type);
2864         device_remove_file(&client->dev, &dev_attr_camera_fw);
2865
2866         if (state->isp.irq > 0)
2867                 free_irq(state->isp.irq, sd);
2868
2869         v4l2_device_unregister_subdev(sd);
2870
2871         kfree(state->fw_version);
2872         kfree(state);
2873
2874         return ret;
2875 }
2876
2877 static const struct i2c_device_id m5mo_id[] = {
2878         { M5MO_DRIVER_NAME, 0 },
2879         { }
2880 };
2881 MODULE_DEVICE_TABLE(i2c, m5mo_id);
2882
2883 static struct i2c_driver m5mo_i2c_driver = {
2884         .driver = {
2885                 .name   = M5MO_DRIVER_NAME,
2886         },
2887         .probe          = m5mo_probe,
2888         .remove         = __devexit_p(m5mo_remove),
2889         .id_table       = m5mo_id,
2890 };
2891
2892 static int __init m5mo_mod_init(void)
2893 {
2894         return i2c_add_driver(&m5mo_i2c_driver);
2895 }
2896
2897 static void __exit m5mo_mod_exit(void)
2898 {
2899         i2c_del_driver(&m5mo_i2c_driver);
2900 }
2901 module_init(m5mo_mod_init);
2902 module_exit(m5mo_mod_exit);
2903
2904
2905 MODULE_AUTHOR("Goeun Lee <ge.lee@samsung.com>");
2906 MODULE_DESCRIPTION("driver for Fusitju M5MO LS 8MP camera");
2907 MODULE_LICENSE("GPL");