drivers/media/video/sr200pc20m.c

   1 /*
   2  * Driver for SR200PC20M from Samsung Electronics
   3  *
   4  * Copyright (c) 2011, Samsung Electronics. All rights reserved
   5  * Author: dongseong.lim
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * for more details.
  15  */
  16
  17 #include <linux/i2c.h>
  18 #include <linux/delay.h>
  19 #include <linux/version.h>
  20 #include <linux/vmalloc.h>
  21 #include <media/v4l2-device.h>
  22 #include <media/v4l2-subdev.h>
  23 #ifdef CONFIG_VIDEO_SAMSUNG_V4L2
  24 #include <linux/videodev2_exynos_camera.h>
  25 #endif
  26 #include <media/sr200pc20m_platform.h>
  27 #include "sr200pc20m.h"
  28
  29 extern struct class *camera_class;
  30 struct device *sr200pc20m_dev;
  31
  32 static const struct sr200pc20m_fps sr200pc20m_framerates[] = {
  33         {I_FPS_0, FRAME_RATE_AUTO},
  34         {I_FPS_7, FRAME_RATE_7},
  35         {I_FPS_10, 10},
  36         {I_FPS_12, 12},
  37         {I_FPS_15, FRAME_RATE_15},
  38         {I_FPS_25, FRAME_RATE_25},
  39 };
  40
  41 static const struct sr200pc20m_regs reg_datas = {
  42         .ev = {
  43                SR200PC20M_REGSET(GET_EV_INDEX(EV_MINUS_4),
  44                                  front_ev_minus_4_regs),
  45                SR200PC20M_REGSET(GET_EV_INDEX(EV_MINUS_3),
  46                                  front_ev_minus_3_regs),
  47                SR200PC20M_REGSET(GET_EV_INDEX(EV_MINUS_2),
  48                                  front_ev_minus_2_regs),
  49                SR200PC20M_REGSET(GET_EV_INDEX(EV_MINUS_1),
  50                                  front_ev_minus_1_regs),
  51                SR200PC20M_REGSET(GET_EV_INDEX(EV_DEFAULT),
  52                                  front_ev_default_regs),
  53                SR200PC20M_REGSET(GET_EV_INDEX(EV_PLUS_1), front_ev_plus_1_regs),
  54                SR200PC20M_REGSET(GET_EV_INDEX(EV_PLUS_2), front_ev_plus_2_regs),
  55                SR200PC20M_REGSET(GET_EV_INDEX(EV_PLUS_3), front_ev_plus_3_regs),
  56                SR200PC20M_REGSET(GET_EV_INDEX(EV_PLUS_4), front_ev_plus_4_regs),
  57                },
  58         .blur = {
  59                  SR200PC20M_REGSET(BLUR_LEVEL_0, front_vt_pretty_default),
  60                  SR200PC20M_REGSET(BLUR_LEVEL_1, front_vt_pretty_1),
  61                  SR200PC20M_REGSET(BLUR_LEVEL_2, front_vt_pretty_2),
  62                  SR200PC20M_REGSET(BLUR_LEVEL_3, front_vt_pretty_3),
  63                  },
  64         .fps = {
  65                 SR200PC20M_REGSET(I_FPS_0, front_fps_auto_regs),
  66                 SR200PC20M_REGSET(I_FPS_7, front_fps_7_regs),
  67                 SR200PC20M_REGSET(I_FPS_10, front_fps_10_regs),
  68                 SR200PC20M_REGSET(I_FPS_15, front_fps_15_regs),
  69                 SR200PC20M_REGSET(I_FPS_25, front_fps_24_regs),
  70                 },
  71         .preview_start = SR200PC20M_REGSET_TABLE(front_preview_camera_regs),
  72         .capture_start = SR200PC20M_REGSET_TABLE(front_snapshot_normal_regs),
  73         .init = SR200PC20M_REGSET_TABLE(front_init_regs),
  74         .init_vt = SR200PC20M_REGSET_TABLE(front_init_vt_regs),
  75         .init_recording = SR200PC20M_REGSET_TABLE(front_init_recording_regs),
  76         .dtp_on = SR200PC20M_REGSET_TABLE(front_pattern_on_regs),
  77         .dtp_off = SR200PC20M_REGSET_TABLE(front_pattern_off_regs),
  78 };
  79
  80 #ifdef CONFIG_LOAD_FILE
  81 static int loadFile(void)
  82 {
  83         struct file *fp = NULL;
  84         struct test *nextBuf = NULL;
  85
  86         u8 *nBuf = NULL;
  87         size_t file_size = 0, max_size = 0, testBuf_size = 0;
  88         ssize_t nread = 0;
  89         s32 check = 0, starCheck = 0;
  90         s32 tmp_large_file = 0;
  91         s32 i = 0;
  92         int ret = 0;
  93         loff_t pos;
  94
  95         mm_segment_t fs = get_fs();
  96         set_fs(get_ds());
  97
  98         BUG_ON(testBuf);
  99
 100         fp = filp_open(TUNING_FILE_PATH, O_RDONLY, 0);
 101         if (IS_ERR(fp)) {
 102                 cam_err("file open error\n");
 103                 return PTR_ERR(fp);
 104         }
 105
 106         file_size = (size_t) fp->f_path.dentry->d_inode->i_size;
 107         max_size = file_size;
 108
 109         cam_dbg("file_size = %d\n", file_size);
 110
 111         nBuf = kmalloc(file_size, GFP_ATOMIC);
 112         if (nBuf == NULL) {
 113                 cam_dbg("Fail to 1st get memory\n");
 114                 nBuf = vmalloc(file_size);
 115                 if (nBuf == NULL) {
 116                         cam_err("ERR: nBuf Out of Memory\n");
 117                         ret = -ENOMEM;
 118                         goto error_out;
 119                 }
 120                 tmp_large_file = 1;
 121         }
 122
 123         testBuf_size = sizeof(struct test) * file_size;
 124         if (tmp_large_file) {
 125                 testBuf = (struct test *)vmalloc(testBuf_size);
 126                 large_file = 1;
 127         } else {
 128                 testBuf = kmalloc(testBuf_size, GFP_ATOMIC);
 129                 if (testBuf == NULL) {
 130                         cam_dbg("Fail to get mem(%d bytes)\n", testBuf_size);
 131                         testBuf = (struct test *)vmalloc(testBuf_size);
 132                         large_file = 1;
 133                 }
 134         }
 135         if (testBuf == NULL) {
 136                 cam_err("ERR: Out of Memory\n");
 137                 ret = -ENOMEM;
 138                 goto error_out;
 139         }
 140
 141         pos = 0;
 142         memset(nBuf, 0, file_size);
 143         memset(testBuf, 0, file_size * sizeof(struct test));
 144
 145         nread = vfs_read(fp, (char __user *)nBuf, file_size, &pos);
 146         if (nread != file_size) {
 147                 cam_err("failed to read file ret = %d\n", nread);
 148                 ret = -1;
 149                 goto error_out;
 150         }
 151
 152         set_fs(fs);
 153
 154         i = max_size;
 155
 156         printk("i = %d\n", i);
 157
 158         while (i) {
 159                 testBuf[max_size - i].data = *nBuf;
 160                 if (i != 1) {
 161                         testBuf[max_size - i].nextBuf =
 162                             &testBuf[max_size - i + 1];
 163                 } else {
 164                         testBuf[max_size - i].nextBuf = NULL;
 165                         break;
 166                 }
 167                 i--;
 168                 nBuf++;
 169         }
 170
 171         i = max_size;
 172         nextBuf = &testBuf[0];
 173
 174 #if 1
 175         while (i - 1) {
 176                 if (!check && !starCheck) {
 177                         if (testBuf[max_size - i].data == '/') {
 178                                 if (testBuf[max_size - i].nextBuf != NULL) {
 179                                         if (testBuf[max_size - i].nextBuf->data
 180                                             == '/') {
 181                                                 check = 1; /* when find '//' */
 182                                                 i--;
 183                                         } else if (testBuf[max_size - i].
 184                                                    nextBuf->data == '*') {
 185                                                 starCheck = 1; /* when find '/ *' */
 186                                                 i--;
 187                                         }
 188                                 } else
 189                                         break;
 190                         }
 191                         if (!check && !starCheck) {
 192                                 /* ignore '\t' */
 193                                 if (testBuf[max_size - i].data != '\t') {
 194                                         nextBuf->nextBuf =
 195                                             &testBuf[max_size - i];
 196                                         nextBuf = &testBuf[max_size - i];
 197                                 }
 198                         }
 199                 } else if (check && !starCheck) {
 200                         if (testBuf[max_size - i].data == '/') {
 201                                 if (testBuf[max_size - i].nextBuf != NULL) {
 202                                         if (testBuf[max_size - i].nextBuf->
 203                                             data == '*') {
 204                                                 starCheck = 1; /* when find '/ *' */
 205                                                 check = 0;
 206                                                 i--;
 207                                         }
 208                                 } else
 209                                         break;
 210                         }
 211
 212                         /* when find '\n' */
 213                         if (testBuf[max_size - i].data == '\n' && check) {
 214                                 check = 0;
 215                                 nextBuf->nextBuf = &testBuf[max_size - i];
 216                                 nextBuf = &testBuf[max_size - i];
 217                         }
 218
 219                 } else if (!check && starCheck) {
 220                         if (testBuf[max_size - i].data == '*') {
 221                                 if (testBuf[max_size - i].nextBuf != NULL) {
 222                                         if (testBuf[max_size - i].nextBuf->
 223                                             data == '/') {
 224                                                 starCheck = 0; /* when find '* /' */
 225                                                 i--;
 226                                         }
 227                                 } else
 228                                         break;
 229                         }
 230                 }
 231
 232                 i--;
 233
 234                 if (i < 2) {
 235                         nextBuf = NULL;
 236                         break;
 237                 }
 238
 239                 if (testBuf[max_size - i].nextBuf == NULL) {
 240                         nextBuf = NULL;
 241                         break;
 242                 }
 243         }
 244 #endif
 245
 246 #if 0
 247         printk("i = %d\n", i);
 248         nextBuf = &testBuf[0];
 249         while (1) {
 250                 printk("sdfdsf\n");
 251                 if (nextBuf->nextBuf == NULL)
 252                         break;
 253                 printk("%c", nextBuf->data);
 254                 nextBuf = nextBuf->nextBuf;
 255         }
 256 #endif
 257
 258  error_out:
 259
 260         if (nBuf)
 261                 tmp_large_file ? vfree(nBuf) : kfree(nBuf);
 262         if (fp)
 263                 filp_close(fp, current->files);
 264         return ret;
 265 }
 266 #endif
 267
 268 static int __used sr200pc20m_i2c_read_byte(struct i2c_client *client,
 269                                            u16 subaddr, u16 *data)
 270 {
 271         u8 buf[2] = { 0, };
 272         struct i2c_msg msg = { client->addr, 0, 1, buf };
 273         int err = 0;
 274
 275         if (unlikely(!client->adapter)) {
 276                 cam_err("%s: ERROR, can't search i2c client adapter\n",
 277                         __func__);
 278                 return -ENODEV;
 279         }
 280
 281         buf[0] = (u8) subaddr;
 282
 283         err = i2c_transfer(client->adapter, &msg, 1);
 284         if (unlikely(err < 0)) {
 285                 cam_err("%s: ERROR, failed to write %d register\n",
 286                         __func__, subaddr);
 287                 return -EIO;
 288         }
 289
 290         msg.flags = I2C_M_RD;
 291         msg.len = 1;
 292
 293         err = i2c_transfer(client->adapter, &msg, 1);
 294         if (unlikely(err < 0)) {
 295                 cam_err("%s: ERROR, failed to read %d register\n",
 296                         __func__, subaddr);
 297                 return -EIO;
 298         }
 299
 300         *(u8 *) data = buf[0];
 301
 302         return 0;
 303 }
 304
 305 static int __used sr200pc20m_i2c_write_byte(struct i2c_client *client,
 306                                             u16 subaddr, u16 data)
 307 {
 308         u8 buf[2] = { 0, };
 309         struct i2c_msg msg = { client->addr, 0, 2, buf };
 310         int err = 0;
 311
 312         if (unlikely(!client->adapter)) {
 313                 cam_err("%s: ERROR, can't search i2c client adapter\n",
 314                         __func__);
 315                 return -ENODEV;
 316         }
 317
 318         buf[0] = subaddr & 0xFF;
 319         buf[1] = data & 0xFF;
 320
 321         err = i2c_transfer(client->adapter, &msg, 1);
 322
 323         return (err == 1) ? 0 : -EIO;
 324 }
 325
 326 static int __used sr200pc20m_i2c_read_word(struct i2c_client *client,
 327                                            u16 subaddr, u16 *data)
 328 {
 329         u8 buf[4];
 330         struct i2c_msg msg = { client->addr, 0, 2, buf };
 331         int err = 0;
 332
 333         if (unlikely(!client->adapter)) {
 334                 cam_err("%s: ERROR, can't search i2c client adapter\n",
 335                         __func__);
 336                 return -ENODEV;
 337         }
 338
 339         buf[0] = subaddr >> 8;
 340         buf[1] = subaddr & 0xff;
 341
 342         err = i2c_transfer(client->adapter, &msg, 1);
 343         if (unlikely(err < 0)) {
 344                 cam_err("%s: ERROR, failed to write %d register\n",
 345                         __func__, subaddr);
 346                 return -EIO;
 347         }
 348
 349         msg.flags = I2C_M_RD;
 350         msg.len = 2;
 351
 352         err = i2c_transfer(client->adapter, &msg, 1);
 353         if (unlikely(err < 0)) {
 354                 cam_err("%s: ERROR, failed to read %d register\n",
 355                         __func__, subaddr);
 356                 return -EIO;
 357         }
 358
 359         *data = ((buf[0] << 8) | buf[1]);
 360
 361         return 0;
 362 }
 363
 364 static int __used sr200pc20m_i2c_write_word(struct i2c_client *client,
 365                                             u16 subaddr, u16 data)
 366 {
 367         u8 buf[4];
 368         struct i2c_msg msg = { client->addr, 0, 4, buf };
 369         int err = 0;
 370
 371         if (unlikely(!client->adapter)) {
 372                 cam_err("%s: ERROR, can't search i2c client adapter\n",
 373                         __func__);
 374                 return -ENODEV;
 375         }
 376
 377         buf[0] = subaddr >> 8;
 378         buf[1] = subaddr & 0xFF;
 379         buf[2] = data >> 8;
 380         buf[3] = data & 0xFF;
 381
 382         err = i2c_transfer(client->adapter, &msg, 1);
 383
 384         return (err == 1) ? 0 : -EIO;
 385 }
 386
 387 static int sr200pc20m_i2c_set_data_burst(struct v4l2_subdev *sd,
 388                                          const regs_short_t reg_buffer[],
 389                                          u32 num_of_regs)
 390 {
 391         struct i2c_client *client = v4l2_get_subdevdata(sd);
 392         u16 subaddr, data_value;
 393         int i, err = 0;
 394
 395         for (i = 0; i < num_of_regs; i++) {
 396                 subaddr = reg_buffer[i].subaddr;
 397                 data_value = reg_buffer[i].value;
 398
 399                 switch (subaddr) {
 400                 case DELAY_SEQ:
 401                         debug_msleep(sd, data_value * 10);
 402                         break;
 403                 default:
 404                         err =
 405                             sr200pc20m_i2c_write_byte(client, subaddr,
 406                                                       data_value);
 407                         if (unlikely(err < 0)) {
 408                                 cam_err("%s: ERROR, failed to"
 409                                         "write reg(0x%02X, 0x%02X).err=%d\n",
 410                                         __func__, subaddr, data_value, err);
 411                                 return -EIO;
 412                         }
 413                         break;
 414                 }
 415         }
 416
 417         return 0;
 418 }
 419
 420 #ifdef CONFIG_LOAD_FILE
 421 static int sr200pc20m_write_regs_from_sd(struct v4l2_subdev *sd, u8 s_name[])
 422 {
 423
 424         struct i2c_client *client = v4l2_get_subdevdata(sd);
 425         struct test *tempData = NULL;
 426
 427         int ret = -EAGAIN;
 428         regs_short_t temp;
 429         u32 delay = 0;
 430         u8 data[11];
 431         s32 searched = 0, pair_cnt = 0, brace_cnt = 0;
 432         size_t size = strlen(s_name);
 433         s32 i;
 434
 435         cam_trace("E size = %d, string = %s\n", size, s_name);
 436         tempData = &testBuf[0];
 437         while (!searched) {
 438                 searched = 1;
 439                 for (i = 0; i < size; i++) {
 440                         if (tempData->data != s_name[i]) {
 441                                 searched = 0;
 442                                 break;
 443                         }
 444                         tempData = tempData->nextBuf;
 445                 }
 446                 tempData = tempData->nextBuf;
 447         }
 448         /* structure is get.. */
 449
 450         while (1) {
 451                 if (tempData->data == '{') {
 452                         dbg_setfile("%s: found big_brace start\n", __func__);
 453                         tempData = tempData->nextBuf;
 454                         break;
 455                 } else
 456                         tempData = tempData->nextBuf;
 457         }
 458
 459         while (1) {
 460                 while (1) {
 461                         if (tempData->data == '{') {
 462                                 /* dbg_setfile("%s: found small_brace start\n", __func__); */
 463                                 tempData = tempData->nextBuf;
 464                                 break;
 465                         } else if (tempData->data == '}') {
 466                                 dbg_setfile("%s: found big_brace end\n",
 467                                             __func__);
 468                                 return 0;
 469                         } else
 470                                 tempData = tempData->nextBuf;
 471                 }
 472
 473                 searched = 0;
 474                 pair_cnt = 0;
 475                 while (1) {
 476                         if (tempData->data == 'x') {
 477                                 /* get 10 strings. */
 478                                 data[0] = '0';
 479                                 for (i = 1; i < 4; i++) {
 480                                         data[i] = tempData->data;
 481                                         tempData = tempData->nextBuf;
 482                                 }
 483                                 data[i] = '\0';
 484                                 /* dbg_setfile("read HEX: %s\n", data); */
 485                                 if (pair_cnt == 0) {
 486                                         temp.subaddr =
 487                                             simple_strtoul(data, NULL, 16);
 488                                         pair_cnt++;
 489                                 } else if (pair_cnt == 1) {
 490                                         temp.value =
 491                                             simple_strtoul(data, NULL, 16);
 492                                         pair_cnt++;
 493                                 }
 494                         } else if (tempData->data == '}') {
 495                                 /* dbg_setfile("%s: found small_brace end\n", __func__); */
 496                                 tempData = tempData->nextBuf;
 497                                 /* searched = 1; */
 498                                 break;
 499                         } else
 500                                 tempData = tempData->nextBuf;
 501
 502                         if (tempData->nextBuf == NULL)
 503                                 return -1;
 504                 }
 505
 506                 if (searched)
 507                         break;
 508
 509                 if ((temp.subaddr & 0xFF) == 0xFF) {
 510                         delay = (temp.value & 0xFF) * 10;
 511                         debug_msleep(sd, delay);
 512                         continue;
 513                 }
 514
 515                 /* cam_err("Write: 0x%02X, 0x%02X\n",
 516                    (u8)(temp.subaddr), (u8)(temp.value)); */
 517                 ret =
 518                     sr200pc20m_i2c_write_byte(client, temp.subaddr, temp.value);
 519
 520                 /* In error circumstances */
 521                 /* Give second shot */
 522                 if (unlikely(ret)) {
 523                         dev_info(&client->dev,
 524                                  "sr200pc20m i2c retry one more time\n");
 525                         ret =
 526                             sr200pc20m_i2c_write_byte(client, temp.subaddr,
 527                                                       temp.value);
 528
 529                         /* Give it one more shot */
 530                         if (unlikely(ret)) {
 531                                 dev_info(&client->dev,
 532                                          "sr200pc20m i2c retry twice\n");
 533                                 ret =
 534                                     sr200pc20m_i2c_write_byte(client,
 535                                                               temp.subaddr,
 536                                                               temp.value);
 537                         }
 538                 }
 539         }
 540
 541         return ret;
 542 }
 543 #endif
 544
 545 static int sr200pc20m_set_from_table(struct v4l2_subdev *sd,
 546                                      const char *setting_name,
 547                                      const struct sr200pc20m_regset_table
 548                                      *table, int table_size, int index)
 549 {
 550         int err = 0;
 551
 552         /* cam_dbg("%s: set %s index %d\n",
 553            __func__, setting_name, index); */
 554         if ((index < 0) || (index >= table_size)) {
 555                 cam_err("%s: ERROR, index(%d) out of range[0:%d]"
 556                         "for table for %s\n", __func__, index,
 557                         table_size, setting_name);
 558                 return -EINVAL;
 559         }
 560
 561         table += index;
 562         if (unlikely(!table->reg)) {
 563                 cam_err("%s: ERROR, reg = NULL\n", __func__);
 564                 return -EFAULT;
 565         }
 566 #ifdef CONFIG_LOAD_FILE
 567         cam_dbg("%s: \"%s\", reg_name=%s\n", __func__, setting_name,
 568                 table->name);
 569         return sr200pc20m_write_regs_from_sd(sd, table->name);
 570 #else
 571         err = sr200pc20m_i2c_set_data_burst(sd, table->reg, table->array_size);
 572         if (unlikely(err < 0)) {
 573                 cam_err("%s: ERROR, fail to write regs(%s), err=%d\n",
 574                         __func__, setting_name, err);
 575                 return -EIO;
 576         }
 577
 578         return 0;
 579 #endif
 580 }
 581
 582 static inline int sr200pc20m_get_iso(struct v4l2_subdev *sd, u16 * iso)
 583 {
 584         struct i2c_client *client = v4l2_get_subdevdata(sd);
 585         /* u16 iso_gain_table[] = {10, 18, 23, 28};
 586            u16 iso_table[] = {0, 50, 100, 200, 400}; */
 587         u16 read_value = 0, gain = 0;
 588
 589         sr200pc20m_i2c_write_byte(client, 0x03, 0x20);
 590         sr200pc20m_i2c_read_byte(client, 0xb0, &read_value);
 591         gain = (read_value * 100 / 32) + 50;
 592
 593         if (read_value < 125)
 594                 *iso = 50;
 595         else if (read_value < 175)
 596                 *iso = 100;
 597         else if (read_value < 250)
 598                 *iso = 200;
 599         else if (read_value < 375)
 600                 *iso = 400;
 601         else if (read_value < 550)
 602                 *iso = 800;
 603         else
 604                 *iso = 1600;
 605
 606         cam_dbg("gain=%d, ISO=%d\n", gain, *iso);
 607
 608         return 0;
 609 }
 610
 611 static int sr200pc20m_get_expousretime(struct v4l2_subdev *sd, u32 * exp_time)
 612 {
 613         struct i2c_client *client = v4l2_get_subdevdata(sd);
 614         u16 read_value = 0;
 615         u32 cintr = 0;
 616
 617         sr200pc20m_i2c_write_byte(client, 0x03, 0x20);
 618         sr200pc20m_i2c_read_byte(client, 0x80, &read_value);
 619         cintr = read_value << 19;
 620         sr200pc20m_i2c_read_byte(client, 0x81, &read_value);
 621         cintr |= read_value << 11;
 622         sr200pc20m_i2c_read_byte(client, 0x82, &read_value);
 623         cintr |= read_value << 3;
 624
 625         *exp_time = cintr / 24; /* us */
 626
 627         return 0;
 628 }
 629
 630 static int sr200pc20m_get_exif(struct v4l2_subdev *sd)
 631 {
 632         struct sr200pc20m_state *state = to_state(sd);
 633         u32 exposure_time = 0;
 634
 635         /* Get exposure-time */
 636         state->exif.exp_time_den = 0;
 637         sr200pc20m_get_expousretime(sd, &exposure_time);
 638         state->exif.exp_time_den = 1000000 / exposure_time;
 639         cam_dbg("exposure time=%dus\n", exposure_time);
 640
 641         /* Get ISO */
 642         state->exif.iso = 0;
 643         sr200pc20m_get_iso(sd, &state->exif.iso);
 644
 645         cam_dbg("get_exif: exp_time_den=%d, ISO=%d\n",
 646                 state->exif.exp_time_den, state->exif.iso);
 647         return 0;
 648 }
 649
 650 #ifdef SUPPORT_FACTORY_TEST
 651 static int sr200pc20m_check_dataline(struct v4l2_subdev *sd, s32 val)
 652 {
 653         struct sr200pc20m_state *state = to_state(sd);
 654         int err = -EIO;
 655
 656         if (state->pdata->is_mipi)
 657                 return 0;
 658
 659         cam_info("DTP %s\n", val ? "ON" : "OFF");
 660
 661         if (val)
 662                 err = sr200pc20m_set_from_table(sd, "dtp_on",
 663                                                 &state->regs->dtp_on, 1, 0);
 664         else
 665                 err = sr200pc20m_set_from_table(sd, "dtp_off",
 666                                                 &state->regs->dtp_off, 1, 0);
 667
 668         CHECK_ERR_MSG(err, "fail to DTP setting\n");
 669         return 0;
 670 }
 671 #endif
 672
 673 static int sr200pc20m_check_sensor_status(struct v4l2_subdev *sd)
 674 {
 675
 676         /*struct i2c_client *client = v4l2_get_subdevdata(sd); */
 677         /*u16 val_1 = 0, val_2 = 0;
 678            int err = -EINVAL; */
 679
 680 #if 1                           /* DSLIM */
 681         cam_warn("check_sensor_status: WARNING, Not implemented!!\n\n");
 682         return 0;
 683 #else
 684
 685         err = sr200pc20m_read_reg(sd, 0x7000, 0x0132, &val_1);
 686         CHECK_ERR(err);
 687         err = sr200pc20m_read_reg(sd, 0xD000, 0x1002, &val_2);
 688         CHECK_ERR(err);
 689
 690         cam_dbg("read val1=0x%x, val2=0x%x\n", val_1, val_2);
 691
 692         if ((val_1 != 0xAAAA) || (val_2 != 0))
 693                 goto error_occur;
 694
 695         cam_info("Sensor ESD Check: not detected\n");
 696         return 0;
 697 #endif
 698  error_occur:
 699         cam_err("%s: ERROR, ESD Shock detected!\n\n", __func__);
 700         return -ERESTART;
 701 }
 702
 703 static inline int sr200pc20m_check_esd(struct v4l2_subdev *sd)
 704 {
 705         int err = -EINVAL;
 706
 707         err = sr200pc20m_check_sensor_status(sd);
 708         CHECK_ERR(err);
 709
 710         return 0;
 711 }
 712
 713 static int sr200pc20m_set_preview_start(struct v4l2_subdev *sd)
 714 {
 715         struct sr200pc20m_state *state = to_state(sd);
 716         int err = -EINVAL;
 717
 718         if (state->first_preview) {
 719                 state->first_preview = 0;
 720 #ifdef SUPPORT_FACTORY_TEST
 721                 if (state->check_dataline) {
 722                         err = sr200pc20m_check_dataline(sd, 1);
 723                         CHECK_ERR(err);
 724                 }
 725 #endif
 726                 return 0;
 727         }
 728
 729         cam_info("set_preview_start\n");
 730
 731         err = sr200pc20m_set_from_table(sd, "preview_start",
 732                                         &state->regs->preview_start, 1, 0);
 733         CHECK_ERR_MSG(err, "fail to make preview\n")
 734
 735             return 0;
 736 }
 737
 738 static int sr200pc20m_set_capture_start(struct v4l2_subdev *sd)
 739 {
 740         struct sr200pc20m_state *state = to_state(sd);
 741         int err = -EINVAL;
 742
 743         cam_info("set_capture_start\n");
 744
 745         err = sr200pc20m_set_from_table(sd, "capture_start",
 746                                         &state->regs->capture_start, 1, 0);
 747         CHECK_ERR_MSG(err, "failed to make capture\n");
 748
 749         sr200pc20m_get_exif(sd);
 750
 751         return err;
 752 }
 753
 754 static int sr200pc20m_set_sensor_mode(struct v4l2_subdev *sd, s32 val)
 755 {
 756         struct sr200pc20m_state *state = to_state(sd);
 757
 758         switch (val) {
 759         case SENSOR_MOVIE:
 760                 if (state->vt_mode) {
 761                         state->sensor_mode = SENSOR_CAMERA;
 762                         cam_warn("%s: WARNING, Not support movie in vt mode\n",
 763                                  __func__);
 764                         break;
 765                 }
 766                 /* We do not break. */
 767         case SENSOR_CAMERA:
 768                 state->sensor_mode = val;
 769                 break;
 770         default:
 771                 cam_err("%s: ERROR: Not support mode.(%d)\n", __func__, val);
 772                 return -EINVAL;
 773         }
 774
 775         return 0;
 776 }
 777
 778 static int sr200pc20m_init_regs(struct v4l2_subdev *sd)
 779 {
 780         struct sr200pc20m_state *state = to_state(sd);
 781         struct i2c_client *client = v4l2_get_subdevdata(sd);
 782         u16 read_value = 0;
 783         int err = -ENODEV;
 784
 785         err = sr200pc20m_i2c_write_byte(client, 0x03, 0x00);
 786         if (unlikely(err < 0))
 787                 return -ENODEV;
 788
 789         sr200pc20m_i2c_read_byte(client, 0x04, &read_value);
 790         if (likely(read_value == SR200PC20M_CHIP_ID))
 791                 cam_info("Sensor ChipID: 0x%02X\n", SR200PC20M_CHIP_ID);
 792         else
 793                 cam_info("Sensor ChipID: 0x%02X, unknown chipID\n", read_value);
 794
 795         state->regs = &reg_datas;
 796
 797         return 0;
 798 }
 799
 800 static int sr200pc20m_enum_framesizes(struct v4l2_subdev *sd,
 801                                       struct v4l2_frmsizeenum *fsize)
 802 {
 803         struct sr200pc20m_state *state = to_state(sd);
 804
 805         cam_trace("E\n");
 806
 807         /*
 808          * Return the actual output settings programmed to the camera
 809          */
 810         if (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE) {
 811                 fsize->discrete.width = state->capture_frmsizes.width;
 812                 fsize->discrete.height = state->capture_frmsizes.height;
 813         } else {
 814                 fsize->discrete.width = state->preview_frmsizes.width;
 815                 fsize->discrete.height = state->preview_frmsizes.height;
 816         }
 817
 818         cam_info("enum_framesizes: width - %d , height - %d\n",
 819                  fsize->discrete.width, fsize->discrete.height);
 820
 821         return 0;
 822 }
 823
 824 static int sr200pc20m_s_mbus_fmt(struct v4l2_subdev *sd,
 825                                  struct v4l2_mbus_framefmt *fmt)
 826 {
 827         struct sr200pc20m_state *state = to_state(sd);
 828         u32 *width = NULL, *height = NULL;
 829
 830         cam_trace("E\n");
 831         /*
 832          * Just copying the requested format as of now.
 833          * We need to check here what are the formats the camera support, and
 834          * set the most appropriate one according to the request from FIMC
 835          */
 836 #ifdef NEW_CAM_DRV
 837         v4l2_fill_pix_format(&state->req_fmt, fmt);
 838         state->req_fmt.priv = fmt->field;
 839 #else
 840         memcpy(&state->req_fmt, &fmt->fmt.pix, sizeof(fmt->fmt.pix));
 841 #endif
 842
 843         switch (state->req_fmt.priv) {
 844         case V4L2_PIX_FMT_MODE_PREVIEW:
 845                 width = &state->preview_frmsizes.width;
 846                 height = &state->preview_frmsizes.height;
 847                 break;
 848
 849         case V4L2_PIX_FMT_MODE_CAPTURE:
 850                 width = &state->capture_frmsizes.width;
 851                 height = &state->capture_frmsizes.height;
 852                 break;
 853
 854         default:
 855                 cam_err("%s: ERROR, inavlid FMT Mode(%d)\n",
 856                         __func__, state->req_fmt.priv);
 857                 return -EINVAL;
 858         }
 859
 860         if ((*width != state->req_fmt.width) ||
 861             (*height != state->req_fmt.height)) {
 862                 cam_err("%s: ERROR, Invalid size. width= %d, height= %d\n",
 863                         __func__, state->req_fmt.width, state->req_fmt.height);
 864         }
 865
 866         return 0;
 867 }
 868
 869 static int sr200pc20m_set_frame_rate(struct v4l2_subdev *sd, s32 fps)
 870 {
 871         struct sr200pc20m_state *state = to_state(sd);
 872         int err = -EIO;
 873         int i = 0, fps_index = -1;
 874
 875         cam_info("set frame rate %d\n", fps);
 876
 877         for (i = 0; i < ARRAY_SIZE(sr200pc20m_framerates); i++) {
 878                 if (fps == sr200pc20m_framerates[i].fps) {
 879                         fps_index = sr200pc20m_framerates[i].index;
 880                         state->fps = fps;
 881                         state->req_fps = -1;
 882                         break;
 883                 }
 884         }
 885
 886         if (unlikely(fps_index < 0)) {
 887                 cam_err("%s: WARNING, Not supported FPS(%d)\n", __func__, fps);
 888                 return 0;
 889         }
 890
 891         if (state->sensor_mode != SENSOR_MOVIE) {
 892                 err = sr200pc20m_set_from_table(sd, "fps", state->regs->fps,
 893                                                 ARRAY_SIZE(state->regs->fps),
 894                                                 fps_index);
 895                 CHECK_ERR_MSG(err, "fail to set framerate\n")
 896         }
 897
 898         return 0;
 899 }
 900
 901 static int sr200pc20m_g_parm(struct v4l2_subdev *sd,
 902                              struct v4l2_streamparm *parms)
 903 {
 904         int err = 0;
 905
 906         cam_trace("E\n");
 907
 908         return err;
 909 }
 910
 911 static int sr200pc20m_s_parm(struct v4l2_subdev *sd,
 912                              struct v4l2_streamparm *parms)
 913 {
 914         int err = 0;
 915         struct sr200pc20m_state *state = to_state(sd);
 916
 917         state->req_fps = parms->parm.capture.timeperframe.denominator /
 918             parms->parm.capture.timeperframe.numerator;
 919
 920         cam_dbg("s_parm fps=%d, req_fps=%d\n", state->fps, state->req_fps);
 921
 922         if ((state->req_fps < 0) || (state->req_fps > 30)) {
 923                 cam_err("%s: ERROR, invalid frame rate %d. we'll set to %d\n",
 924                         __func__, state->req_fps, DEFAULT_FPS);
 925                 state->req_fps = DEFAULT_FPS;
 926         }
 927
 928         if (state->initialized) {
 929                 err = sr200pc20m_set_frame_rate(sd, state->req_fps);
 930                 CHECK_ERR(err);
 931         }
 932
 933         return 0;
 934 }
 935
 936 static int sr200pc20m_wait_steamoff(struct v4l2_subdev *sd)
 937 {
 938         struct sr200pc20m_state *state = to_state(sd);
 939         struct sr200pc20m_stream_time *stream_time = &state->stream_time;
 940         s32 elapsed_msec = 0;
 941
 942         cam_trace("E\n");
 943
 944         if (unlikely(!(state->pdata->is_mipi & state->need_wait_streamoff)))
 945                 return 0;
 946
 947         do_gettimeofday(&stream_time->curr_time);
 948
 949         elapsed_msec = GET_ELAPSED_TIME(stream_time->curr_time,
 950                                         stream_time->before_time) / 1000;
 951
 952         if (state->pdata->streamoff_delay > elapsed_msec) {
 953                 cam_info("stream-off: %dms + %dms\n", elapsed_msec,
 954                          state->pdata->streamoff_delay - elapsed_msec);
 955                 debug_msleep(sd, state->pdata->streamoff_delay - elapsed_msec);
 956         } else
 957                 cam_info("stream-off: %dms\n", elapsed_msec);
 958
 959         state->need_wait_streamoff = 0;
 960
 961         return 0;
 962 }
 963
 964 static int sr200pc20m_control_stream(struct v4l2_subdev *sd, u32 cmd)
 965 {
 966         struct sr200pc20m_state *state = to_state(sd);
 967         int err = -EINVAL;
 968
 969         if (unlikely(cmd != STREAM_STOP))
 970                 return 0;
 971
 972         cam_info("STREAM STOP!!\n");
 973         err = 0;
 974         CHECK_ERR_MSG(err, "failed to stop stream\n");
 975
 976 #ifdef CONFIG_VIDEO_IMPROVE_STREAMOFF
 977         do_gettimeofday(&state->stream_time.before_time);
 978         state->need_wait_streamoff = 1;
 979 #else
 980         debug_msleep(sd, state->pdata->streamoff_delay);
 981 #endif
 982         return 0;
 983 }
 984
 985 static int sr200pc20m_init(struct v4l2_subdev *sd, u32 val)
 986 {
 987         struct sr200pc20m_state *state = to_state(sd);
 988         int err = -EINVAL;
 989
 990         cam_trace("E\n");
 991
 992         err = sr200pc20m_init_regs(sd);
 993         CHECK_ERR_MSG(err, "failed to indentify sensor chip\n");
 994
 995         /* set initial regster value */
 996         if (state->sensor_mode == SENSOR_CAMERA) {
 997                 if (!state->vt_mode) {
 998                         cam_info("load camera common setting\n");
 999                         err = sr200pc20m_set_from_table(sd, "init",
1000                                                         &state->regs->init, 1,
1001                                                         0);
1002                 } else {
1003                         cam_info("load camera WIFI VT call setting\n");
1004                         err = sr200pc20m_set_from_table(sd, "init_vt",
1005                                                         &state->regs->init_vt,
1006                                                         1, 0);
1007                 }
1008         } else {
1009                 cam_info("load recording setting\n");
1010                 err = sr200pc20m_set_from_table(sd, "init_recording",
1011                                                 &state->regs->init_recording, 1,
1012                                                 0);
1013         }
1014         CHECK_ERR_MSG(err, "failed to initialize camera device\n");
1015
1016         state->first_preview = 1;
1017         state->initialized = 1;
1018
1019         if (state->req_fps >= 0) {
1020                 err = sr200pc20m_set_frame_rate(sd, state->req_fps);
1021                 CHECK_ERR(err);
1022         }
1023
1024         return 0;
1025 }
1026
1027 /*
1028  * s_config subdev ops
1029  * With camera device, we need to re-initialize
1030  * every single opening time therefor,
1031  * it is not necessary to be initialized on probe time.
1032  * except for version checking
1033  * NOTE: version checking is optional
1034  */
1035 static int sr200pc20m_s_config(struct v4l2_subdev *sd,
1036                                int irq, void *platform_data)
1037 {
1038         struct sr200pc20m_state *state = to_state(sd);
1039 #ifdef CONFIG_LOAD_FILE
1040         int err = 0;
1041 #endif
1042
1043         if (!platform_data) {
1044                 cam_err("%s: ERROR, no platform data\n", __func__);
1045                 return -ENODEV;
1046         }
1047         state->pdata = platform_data;
1048         state->dbg_level = &state->pdata->dbg_level;
1049
1050         state->initialized = 0;
1051         state->fps = 0;
1052         state->req_fps = -1;
1053         state->sensor_mode = SENSOR_CAMERA;
1054
1055         /*
1056          * Assign default format and resolution
1057          * Use configured default information in platform data
1058          * or without them, use default information in driver
1059          */
1060         if (!(state->pdata->default_width && state->pdata->default_height)) {
1061                 state->default_frmsizes.width = DEFAULT_PREVIEW_WIDTH;
1062                 state->default_frmsizes.height = DEFAULT_PREVIEW_HEIGHT;
1063         } else {
1064                 state->default_frmsizes.width = state->pdata->default_width;
1065                 state->default_frmsizes.height = state->pdata->default_height;
1066         }
1067
1068         state->preview_frmsizes.width = state->default_frmsizes.width;
1069         state->preview_frmsizes.height = state->default_frmsizes.height;
1070         state->capture_frmsizes.width = DEFAULT_CAPTURE_WIDTH;
1071         state->capture_frmsizes.height = DEFAULT_CAPTURE_HEIGHT;
1072
1073         cam_dbg("Default preview_width: %d , preview_height: %d, "
1074                 "capture_width: %d, capture_height: %d",
1075                 state->preview_frmsizes.width, state->preview_frmsizes.height,
1076                 state->capture_frmsizes.width, state->capture_frmsizes.height);
1077
1078         state->req_fmt.width = state->preview_frmsizes.width;
1079         state->req_fmt.height = state->preview_frmsizes.height;
1080         if (!state->pdata->pixelformat)
1081                 state->req_fmt.pixelformat = DEFAULT_FMT;
1082         else
1083                 state->req_fmt.pixelformat = state->pdata->pixelformat;
1084
1085 #ifdef CONFIG_LOAD_FILE
1086         err = loadFile();
1087         CHECK_ERR_MSG(err, "failed to load file ERR=%d\n", err)
1088 #endif
1089             return 0;
1090 }
1091
1092 static int sr200pc20m_s_stream(struct v4l2_subdev *sd, int enable)
1093 {
1094         struct sr200pc20m_state *state = to_state(sd);
1095         int err = 0;
1096
1097         cam_info("s_stream: mode = %d\n", enable);
1098
1099         switch (enable) {
1100         case STREAM_MODE_CAM_OFF:
1101                 if (state->sensor_mode == SENSOR_CAMERA) {
1102 #ifdef SUPPORT_FACTORY_TEST
1103                         if (state->check_dataline)
1104                                 err = sr200pc20m_check_dataline(sd, 0);
1105                         else
1106 #endif
1107                         if (state->pdata->is_mipi)
1108                                 err = sr200pc20m_control_stream(sd,
1109                                                                 STREAM_STOP);
1110                 }
1111                 break;
1112
1113         case STREAM_MODE_CAM_ON:
1114                 if ((state->sensor_mode == SENSOR_CAMERA)
1115                     && (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE))
1116                         err = sr200pc20m_set_capture_start(sd);
1117                 else
1118                         err = sr200pc20m_set_preview_start(sd);
1119                 break;
1120
1121         case STREAM_MODE_MOVIE_ON:
1122                 cam_dbg("%s: do nothing(movie on)!!\n", __func__);
1123                 break;
1124
1125         case STREAM_MODE_MOVIE_OFF:
1126                 cam_dbg("%s: do nothing(movie off)!!\n", __func__);
1127                 break;
1128
1129 #ifdef CONFIG_VIDEO_IMPROVE_STREAMOFF
1130         case STREAM_MODE_WAIT_OFF:
1131                 err = sr200pc20m_wait_steamoff(sd);
1132                 break;
1133 #endif
1134         default:
1135                 cam_err("%s: ERROR, Invalid stream mode %d\n",
1136                         __func__, enable);
1137                 err = -EINVAL;
1138                 break;
1139         }
1140
1141         CHECK_ERR_MSG(err, "stream on(off) fail")
1142
1143             return 0;
1144 }
1145
1146 static int sr200pc20m_set_exposure(struct v4l2_subdev *sd, s32 val)
1147 {
1148         struct sr200pc20m_state *state = to_state(sd);
1149         int err = -EINVAL;
1150
1151         cam_info("set_exposure: val=%d\n", val);
1152
1153 #ifdef SUPPORT_FACTORY_TEST
1154         if (state->check_dataline)
1155                 return 0;
1156 #endif
1157         if ((val < EV_MINUS_4) || (val >= EV_MAX_V4L2)) {
1158                 cam_err("%s: ERROR, invalid value(%d)\n", __func__, val);
1159                 return -EINVAL;
1160         }
1161
1162         err = sr200pc20m_set_from_table(sd, "ev", state->regs->ev,
1163                                         ARRAY_SIZE(state->regs->ev),
1164                                         GET_EV_INDEX(val));
1165         CHECK_ERR_MSG(err, "i2c_write for set brightness\n")
1166
1167             return 0;
1168 }
1169
1170 static int sr200pc20m_set_blur(struct v4l2_subdev *sd, s32 val)
1171 {
1172         struct sr200pc20m_state *state = to_state(sd);
1173         int err = -EINVAL;
1174
1175         cam_info("set_blur: val=%d\n", val);
1176
1177 #ifdef SUPPORT_FACTORY_TEST
1178         if (state->check_dataline)
1179                 return 0;
1180 #endif
1181         if (unlikely(val < BLUR_LEVEL_0 || val >= BLUR_LEVEL_MAX)) {
1182                 cam_err("%s: ERROR, invalid blur(%d)\n", __func__, val);
1183                 return -EINVAL;
1184         }
1185
1186         err = sr200pc20m_set_from_table(sd, "blur", state->regs->blur,
1187                                         ARRAY_SIZE(state->regs->blur), val);
1188         CHECK_ERR_MSG(err, "i2c_write for set blur\n")
1189
1190             return 0;
1191 }
1192
1193 static int sr200pc20m_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1194 {
1195         struct sr200pc20m_state *state = to_state(sd);
1196         int err = 0;
1197
1198         cam_dbg("g_ctrl: id = %d\n", ctrl->id - V4L2_CID_PRIVATE_BASE);
1199
1200         mutex_lock(&state->ctrl_lock);
1201
1202         switch (ctrl->id) {
1203         case V4L2_CID_CAMERA_EXIF_EXPTIME:
1204                 ctrl->value = state->exif.exp_time_den;
1205                 break;
1206
1207         case V4L2_CID_CAMERA_EXIF_ISO:
1208                 ctrl->value = state->exif.iso;
1209                 break;
1210
1211         default:
1212                 cam_err("%s: ERROR, no such control id %d\n",
1213                         __func__, ctrl->id - V4L2_CID_PRIVATE_BASE);
1214                 break;
1215         }
1216
1217         mutex_unlock(&state->ctrl_lock);
1218
1219         return err;
1220 }
1221
1222 static int sr200pc20m_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1223 {
1224         struct sr200pc20m_state *state = to_state(sd);
1225         int err = 0;
1226
1227         cam_dbg("s_ctrl: id = %d, value=%d\n",
1228                 ctrl->id - V4L2_CID_PRIVATE_BASE, ctrl->value);
1229
1230         if ((ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE)
1231             && (ctrl->id != V4L2_CID_CAMERA_SENSOR_MODE)
1232             && ((ctrl->id != V4L2_CID_CAMERA_VT_MODE))
1233             && (!state->initialized)) {
1234                 cam_warn("%s: WARNING, camera not initialized\n", __func__);
1235                 return 0;
1236         }
1237
1238         mutex_lock(&state->ctrl_lock);
1239
1240         switch (ctrl->id) {
1241         case V4L2_CID_CAMERA_BRIGHTNESS:
1242                 err = sr200pc20m_set_exposure(sd, ctrl->value);
1243                 cam_dbg("V4L2_CID_CAMERA_BRIGHTNESS [%d]\n", ctrl->value);
1244                 break;
1245
1246         case V4L2_CID_CAMERA_VGA_BLUR:
1247                 err = sr200pc20m_set_blur(sd, ctrl->value);
1248                 cam_dbg("V4L2_CID_CAMERA_VGA_BLUR [%d]\n", ctrl->value);
1249                 break;
1250
1251         case V4L2_CID_CAMERA_VT_MODE:
1252                 state->vt_mode = ctrl->value;
1253                 break;
1254
1255         case V4L2_CID_CAMERA_SENSOR_MODE:
1256                 err = sr200pc20m_set_sensor_mode(sd, ctrl->value);
1257                 cam_dbg("sensor_mode = %d\n", ctrl->value);
1258                 break;
1259
1260         case V4L2_CID_CAMERA_CHECK_ESD:
1261                 err = sr200pc20m_check_esd(sd);
1262                 break;
1263
1264 #ifdef SUPPORT_FACTORY_TEST
1265         case V4L2_CID_CAMERA_CHECK_DATALINE:
1266                 state->check_dataline = ctrl->value;
1267                 cam_dbg("check_dataline = %d\n", state->check_dataline);
1268                 err = 0;
1269                 break;
1270 #endif
1271         default:
1272                 cam_err("%s: ERROR, not supported ctrl-ID(%d)\n",
1273                         __func__, ctrl->id - V4L2_CID_PRIVATE_BASE);
1274                 /* no errors return. */
1275                 break;
1276         }
1277
1278         mutex_unlock(&state->ctrl_lock);
1279
1280         cam_trace("X\n");
1281         return 0;
1282 }
1283
1284 static const struct v4l2_subdev_core_ops sr200pc20m_core_ops = {
1285         .init = sr200pc20m_init,        /* initializing API */
1286         .g_ctrl = sr200pc20m_g_ctrl,
1287         .s_ctrl = sr200pc20m_s_ctrl,
1288 };
1289
1290 static const struct v4l2_subdev_video_ops sr200pc20m_video_ops = {
1291         /*.s_crystal_freq = sr200pc20m_s_crystal_freq, */
1292         .s_mbus_fmt = sr200pc20m_s_mbus_fmt,
1293         .s_stream = sr200pc20m_s_stream,
1294         .enum_framesizes = sr200pc20m_enum_framesizes,
1295         /*.enum_frameintervals = sr200pc20m_enum_frameintervals, */
1296         /* .enum_mbus_fmt = sr200pc20m_enum_mbus_fmt, */
1297         /*.enum_fmt = sr200pc20m_enum_fmt, */
1298         .g_parm = sr200pc20m_g_parm,
1299         .s_parm = sr200pc20m_s_parm,
1300 };
1301
1302 static const struct v4l2_subdev_ops sr200pc20m_ops = {
1303         .core = &sr200pc20m_core_ops,
1304         .video = &sr200pc20m_video_ops,
1305 };
1306
1307 ssize_t sr200pc20m_camera_type_show(struct device *dev,
1308                                     struct device_attribute *attr, char *buf)
1309 {
1310         struct sr200pc20m_state *state = dev_get_drvdata(dev);
1311
1312         char *cam_type;
1313         cam_info("%s\n", __func__);
1314
1315         cam_type = "SF_SR200OC20M";
1316
1317         return sprintf(buf, "%s\n", cam_type);
1318 }
1319
1320 static DEVICE_ATTR(front_camtype, S_IRUGO, sr200pc20m_camera_type_show, NULL);
1321
1322 /*
1323  * sr200pc20m_probe
1324  * Fetching platform data is being done with s_config subdev call.
1325  * In probe routine, we just register subdev device
1326  */
1327 static int sr200pc20m_probe(struct i2c_client *client,
1328                             const struct i2c_device_id *id)
1329 {
1330         struct sr200pc20m_state *state = NULL;
1331         struct v4l2_subdev *sd = NULL;
1332         int err = -EINVAL;
1333
1334         state = kzalloc(sizeof(struct sr200pc20m_state), GFP_KERNEL);
1335         CHECK_ERR_COND_MSG(!state, -ENOMEM, "fail to get memory(state)\n");
1336
1337         mutex_init(&state->ctrl_lock);
1338
1339         sd = &state->sd;
1340         strcpy(sd->name, SR200PC20M_DRIVER_NAME);
1341
1342         /* Registering subdev */
1343         v4l2_i2c_subdev_init(sd, client, &sr200pc20m_ops);
1344
1345         err = sr200pc20m_s_config(sd, 0, client->dev.platform_data);
1346         CHECK_ERR_MSG(err, "fail to s_config\n");
1347
1348         printk(KERN_DEBUG "%s %s: driver probed!!\n",
1349                dev_driver_string(&client->dev), dev_name(&client->dev));
1350         return 0;
1351 }
1352
1353 static int sr200pc20m_remove(struct i2c_client *client)
1354 {
1355         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1356         struct sr200pc20m_state *state = to_state(sd);
1357
1358         cam_trace("E\n");
1359
1360         state->initialized = 0;
1361
1362         v4l2_device_unregister_subdev(sd);
1363         kfree(state);
1364
1365 #ifdef CONFIG_LOAD_FILE
1366         if (testBuf) {
1367                 large_file ? vfree(testBuf) : kfree(testBuf);
1368                 large_file = 0;
1369                 testBuf = NULL;
1370         }
1371 #endif
1372
1373         printk(KERN_DEBUG "%s %s: driver removed!!\n",
1374                dev_driver_string(&client->dev), dev_name(&client->dev));
1375         return 0;
1376 }
1377
1378 static const struct i2c_device_id sr200pc20m_id[] = {
1379         {SR200PC20M_DRIVER_NAME, 0},
1380         {},
1381 };
1382
1383 MODULE_DEVICE_TABLE(i2c, sr200pc20m_id);
1384
1385 static struct i2c_driver sr200pc20m_i2c_driver = {
1386         .driver.name = SR200PC20M_DRIVER_NAME,
1387         .probe = sr200pc20m_probe,
1388         .remove = sr200pc20m_remove,
1389         .id_table = sr200pc20m_id,
1390 };
1391
1392 static int __init sr200pc20m_mod_init(void)
1393 {
1394
1395         if (!sr200pc20m_dev) {
1396                 sr200pc20m_dev =
1397                     device_create(camera_class, NULL, 0, NULL, "front");
1398                 if (IS_ERR(sr200pc20m_dev)) {
1399                         cam_err("failed to create device m5mo_dev!\n");
1400                         return 0;
1401                 }
1402                 if (device_create_file
1403                     (sr200pc20m_dev, &dev_attr_front_camtype) < 0) {
1404                         cam_err("failed to create device file, %s\n",
1405                                 dev_attr_front_camtype.attr.name);
1406                 }
1407         }
1408
1409         pr_info("%s: %s called\n", __func__, SR200PC20M_DRIVER_NAME);
1410         return i2c_add_driver(&sr200pc20m_i2c_driver);
1411 }
1412
1413 static void __exit sr200pc20m_mod_exit(void)
1414 {
1415         pr_info("%s: %s called\n", __func__, SR200PC20M_DRIVER_NAME);
1416         i2c_del_driver(&sr200pc20m_i2c_driver);
1417         if (camera_class)
1418                 class_destroy(camera_class);
1419 }
1420
1421 module_init(sr200pc20m_mod_init);
1422 module_exit(sr200pc20m_mod_exit);
1423
1424 MODULE_DESCRIPTION("SR200PC20M ISP driver");
1425 MODULE_AUTHOR("DongSeong Lim<dongseong.lim@samsung.com>");
1426 MODULE_AUTHOR("Roen Lee<doo.hwan.lee@samsung.com>");
1427 MODULE_LICENSE("GPL");