drivers/staging/media/omap24xx/tcm825x.c

   1 /*
   2  * drivers/media/i2c/tcm825x.c
   3  *
   4  * TCM825X camera sensor driver.
   5  *
   6  * Copyright (C) 2007 Nokia Corporation.
   7  *
   8  * Contact: Sakari Ailus <sakari.ailus@nokia.com>
   9  *
  10  * Based on code from David Cohen <david.cohen@indt.org.br>
  11  *
  12  * This driver was based on ov9640 sensor driver from MontaVista
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * version 2 as published by the Free Software Foundation.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  26  * 02110-1301 USA
  27  */
  28
  29 #include <linux/i2c.h>
  30 #include <linux/module.h>
  31 #include "v4l2-int-device.h"
  32
  33 #include "tcm825x.h"
  34
  35 /*
  36  * The sensor has two fps modes: the lower one just gives half the fps
  37  * at the same xclk than the high one.
  38  */
  39 #define MAX_FPS 30
  40 #define MIN_FPS 8
  41 #define MAX_HALF_FPS (MAX_FPS / 2)
  42 #define HIGH_FPS_MODE_LOWER_LIMIT 14
  43 #define DEFAULT_FPS MAX_HALF_FPS
  44
  45 struct tcm825x_sensor {
  46         const struct tcm825x_platform_data *platform_data;
  47         struct v4l2_int_device *v4l2_int_device;
  48         struct i2c_client *i2c_client;
  49         struct v4l2_pix_format pix;
  50         struct v4l2_fract timeperframe;
  51 };
  52
  53 /* list of image formats supported by TCM825X sensor */
  54 static const struct v4l2_fmtdesc tcm825x_formats[] = {
  55         {
  56                 .description = "YUYV (YUV 4:2:2), packed",
  57                 .pixelformat = V4L2_PIX_FMT_UYVY,
  58         }, {
  59                 /* Note:  V4L2 defines RGB565 as:
  60                  *
  61                  *      Byte 0                    Byte 1
  62                  *      g2 g1 g0 r4 r3 r2 r1 r0   b4 b3 b2 b1 b0 g5 g4 g3
  63                  *
  64                  * We interpret RGB565 as:
  65                  *
  66                  *      Byte 0                    Byte 1
  67                  *      g2 g1 g0 b4 b3 b2 b1 b0   r4 r3 r2 r1 r0 g5 g4 g3
  68                  */
  69                 .description = "RGB565, le",
  70                 .pixelformat = V4L2_PIX_FMT_RGB565,
  71         },
  72 };
  73
  74 #define TCM825X_NUM_CAPTURE_FORMATS     ARRAY_SIZE(tcm825x_formats)
  75
  76 /*
  77  * TCM825X register configuration for all combinations of pixel format and
  78  * image size
  79  */
  80 static const struct tcm825x_reg subqcif =       { 0x20, TCM825X_PICSIZ };
  81 static const struct tcm825x_reg qcif    =       { 0x18, TCM825X_PICSIZ };
  82 static const struct tcm825x_reg cif     =       { 0x14, TCM825X_PICSIZ };
  83 static const struct tcm825x_reg qqvga   =       { 0x0c, TCM825X_PICSIZ };
  84 static const struct tcm825x_reg qvga    =       { 0x04, TCM825X_PICSIZ };
  85 static const struct tcm825x_reg vga     =       { 0x00, TCM825X_PICSIZ };
  86
  87 static const struct tcm825x_reg yuv422  =       { 0x00, TCM825X_PICFMT };
  88 static const struct tcm825x_reg rgb565  =       { 0x02, TCM825X_PICFMT };
  89
  90 /* Our own specific controls */
  91 #define V4L2_CID_ALC                            V4L2_CID_PRIVATE_BASE
  92 #define V4L2_CID_H_EDGE_EN                      (V4L2_CID_PRIVATE_BASE + 1)
  93 #define V4L2_CID_V_EDGE_EN                      (V4L2_CID_PRIVATE_BASE + 2)
  94 #define V4L2_CID_LENS                           (V4L2_CID_PRIVATE_BASE + 3)
  95 #define V4L2_CID_MAX_EXPOSURE_TIME              (V4L2_CID_PRIVATE_BASE + 4)
  96 #define V4L2_CID_LAST_PRIV                      V4L2_CID_MAX_EXPOSURE_TIME
  97
  98 /*  Video controls  */
  99 static struct vcontrol {
 100         struct v4l2_queryctrl qc;
 101         u16 reg;
 102         u16 start_bit;
 103 } video_control[] = {
 104         {
 105                 {
 106                         .id = V4L2_CID_GAIN,
 107                         .type = V4L2_CTRL_TYPE_INTEGER,
 108                         .name = "Gain",
 109                         .minimum = 0,
 110                         .maximum = 63,
 111                         .step = 1,
 112                 },
 113                 .reg = TCM825X_AG,
 114                 .start_bit = 0,
 115         },
 116         {
 117                 {
 118                         .id = V4L2_CID_RED_BALANCE,
 119                         .type = V4L2_CTRL_TYPE_INTEGER,
 120                         .name = "Red Balance",
 121                         .minimum = 0,
 122                         .maximum = 255,
 123                         .step = 1,
 124                 },
 125                 .reg = TCM825X_MRG,
 126                 .start_bit = 0,
 127         },
 128         {
 129                 {
 130                         .id = V4L2_CID_BLUE_BALANCE,
 131                         .type = V4L2_CTRL_TYPE_INTEGER,
 132                         .name = "Blue Balance",
 133                         .minimum = 0,
 134                         .maximum = 255,
 135                         .step = 1,
 136                 },
 137                 .reg = TCM825X_MBG,
 138                 .start_bit = 0,
 139         },
 140         {
 141                 {
 142                         .id = V4L2_CID_AUTO_WHITE_BALANCE,
 143                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 144                         .name = "Auto White Balance",
 145                         .minimum = 0,
 146                         .maximum = 1,
 147                         .step = 0,
 148                 },
 149                 .reg = TCM825X_AWBSW,
 150                 .start_bit = 7,
 151         },
 152         {
 153                 {
 154                         .id = V4L2_CID_EXPOSURE,
 155                         .type = V4L2_CTRL_TYPE_INTEGER,
 156                         .name = "Exposure Time",
 157                         .minimum = 0,
 158                         .maximum = 0x1fff,
 159                         .step = 1,
 160                 },
 161                 .reg = TCM825X_ESRSPD_U,
 162                 .start_bit = 0,
 163         },
 164         {
 165                 {
 166                         .id = V4L2_CID_HFLIP,
 167                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 168                         .name = "Mirror Image",
 169                         .minimum = 0,
 170                         .maximum = 1,
 171                         .step = 0,
 172                 },
 173                 .reg = TCM825X_H_INV,
 174                 .start_bit = 6,
 175         },
 176         {
 177                 {
 178                         .id = V4L2_CID_VFLIP,
 179                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 180                         .name = "Vertical Flip",
 181                         .minimum = 0,
 182                         .maximum = 1,
 183                         .step = 0,
 184                 },
 185                 .reg = TCM825X_V_INV,
 186                 .start_bit = 7,
 187         },
 188         /* Private controls */
 189         {
 190                 {
 191                         .id = V4L2_CID_ALC,
 192                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 193                         .name = "Auto Luminance Control",
 194                         .minimum = 0,
 195                         .maximum = 1,
 196                         .step = 0,
 197                 },
 198                 .reg = TCM825X_ALCSW,
 199                 .start_bit = 7,
 200         },
 201         {
 202                 {
 203                         .id = V4L2_CID_H_EDGE_EN,
 204                         .type = V4L2_CTRL_TYPE_INTEGER,
 205                         .name = "Horizontal Edge Enhancement",
 206                         .minimum = 0,
 207                         .maximum = 0xff,
 208                         .step = 1,
 209                 },
 210                 .reg = TCM825X_HDTG,
 211                 .start_bit = 0,
 212         },
 213         {
 214                 {
 215                         .id = V4L2_CID_V_EDGE_EN,
 216                         .type = V4L2_CTRL_TYPE_INTEGER,
 217                         .name = "Vertical Edge Enhancement",
 218                         .minimum = 0,
 219                         .maximum = 0xff,
 220                         .step = 1,
 221                 },
 222                 .reg = TCM825X_VDTG,
 223                 .start_bit = 0,
 224         },
 225         {
 226                 {
 227                         .id = V4L2_CID_LENS,
 228                         .type = V4L2_CTRL_TYPE_INTEGER,
 229                         .name = "Lens Shading Compensation",
 230                         .minimum = 0,
 231                         .maximum = 0x3f,
 232                         .step = 1,
 233                 },
 234                 .reg = TCM825X_LENS,
 235                 .start_bit = 0,
 236         },
 237         {
 238                 {
 239                         .id = V4L2_CID_MAX_EXPOSURE_TIME,
 240                         .type = V4L2_CTRL_TYPE_INTEGER,
 241                         .name = "Maximum Exposure Time",
 242                         .minimum = 0,
 243                         .maximum = 0x3,
 244                         .step = 1,
 245                 },
 246                 .reg = TCM825X_ESRLIM,
 247                 .start_bit = 5,
 248         },
 249 };
 250
 251
 252 static const struct tcm825x_reg *tcm825x_siz_reg[NUM_IMAGE_SIZES] = {
 253         &subqcif, &qqvga, &qcif, &qvga, &cif, &vga };
 254
 255 static const struct tcm825x_reg *tcm825x_fmt_reg[NUM_PIXEL_FORMATS] = {
 256         &yuv422, &rgb565 };
 257
 258 /*
 259  * Read a value from a register in an TCM825X sensor device.  The value is
 260  * returned in 'val'.
 261  * Returns zero if successful, or non-zero otherwise.
 262  */
 263 static int tcm825x_read_reg(struct i2c_client *client, int reg)
 264 {
 265         int err;
 266         struct i2c_msg msg[2];
 267         u8 reg_buf, data_buf = 0;
 268
 269         if (!client->adapter)
 270                 return -ENODEV;
 271
 272         msg[0].addr = client->addr;
 273         msg[0].flags = 0;
 274         msg[0].len = 1;
 275         msg[0].buf = &reg_buf;
 276         msg[1].addr = client->addr;
 277         msg[1].flags = I2C_M_RD;
 278         msg[1].len = 1;
 279         msg[1].buf = &data_buf;
 280
 281         reg_buf = reg;
 282
 283         err = i2c_transfer(client->adapter, msg, 2);
 284         if (err < 0)
 285                 return err;
 286         return data_buf;
 287 }
 288
 289 /*
 290  * Write a value to a register in an TCM825X sensor device.
 291  * Returns zero if successful, or non-zero otherwise.
 292  */
 293 static int tcm825x_write_reg(struct i2c_client *client, u8 reg, u8 val)
 294 {
 295         int err;
 296         struct i2c_msg msg[1];
 297         unsigned char data[2];
 298
 299         if (!client->adapter)
 300                 return -ENODEV;
 301
 302         msg->addr = client->addr;
 303         msg->flags = 0;
 304         msg->len = 2;
 305         msg->buf = data;
 306         data[0] = reg;
 307         data[1] = val;
 308         err = i2c_transfer(client->adapter, msg, 1);
 309         if (err >= 0)
 310                 return 0;
 311         return err;
 312 }
 313
 314 static int __tcm825x_write_reg_mask(struct i2c_client *client,
 315                                     u8 reg, u8 val, u8 mask)
 316 {
 317         int rc;
 318
 319         /* need to do read - modify - write */
 320         rc = tcm825x_read_reg(client, reg);
 321         if (rc < 0)
 322                 return rc;
 323
 324         rc &= (~mask);  /* Clear the masked bits */
 325         val &= mask;    /* Enforce mask on value */
 326         val |= rc;
 327
 328         /* write the new value to the register */
 329         rc = tcm825x_write_reg(client, reg, val);
 330         if (rc)
 331                 return rc;
 332
 333         return 0;
 334 }
 335
 336 #define tcm825x_write_reg_mask(client, regmask, val)                    \
 337         __tcm825x_write_reg_mask(client, TCM825X_ADDR((regmask)), val,  \
 338                                  TCM825X_MASK((regmask)))
 339
 340
 341 /*
 342  * Initialize a list of TCM825X registers.
 343  * The list of registers is terminated by the pair of values
 344  * { TCM825X_REG_TERM, TCM825X_VAL_TERM }.
 345  * Returns zero if successful, or non-zero otherwise.
 346  */
 347 static int tcm825x_write_default_regs(struct i2c_client *client,
 348                                       const struct tcm825x_reg *reglist)
 349 {
 350         int err;
 351         const struct tcm825x_reg *next = reglist;
 352
 353         while (!((next->reg == TCM825X_REG_TERM)
 354                  && (next->val == TCM825X_VAL_TERM))) {
 355                 err = tcm825x_write_reg(client, next->reg, next->val);
 356                 if (err) {
 357                         dev_err(&client->dev, "register writing failed\n");
 358                         return err;
 359                 }
 360                 next++;
 361         }
 362
 363         return 0;
 364 }
 365
 366 static struct vcontrol *find_vctrl(int id)
 367 {
 368         int i;
 369
 370         if (id < V4L2_CID_BASE)
 371                 return NULL;
 372
 373         for (i = 0; i < ARRAY_SIZE(video_control); i++)
 374                 if (video_control[i].qc.id == id)
 375                         return &video_control[i];
 376
 377         return NULL;
 378 }
 379
 380 /*
 381  * Find the best match for a requested image capture size.  The best match
 382  * is chosen as the nearest match that has the same number or fewer pixels
 383  * as the requested size, or the smallest image size if the requested size
 384  * has fewer pixels than the smallest image.
 385  */
 386 static enum image_size tcm825x_find_size(struct v4l2_int_device *s,
 387                                          unsigned int width,
 388                                          unsigned int height)
 389 {
 390         enum image_size isize;
 391         unsigned long pixels = width * height;
 392         struct tcm825x_sensor *sensor = s->priv;
 393
 394         for (isize = subQCIF; isize < VGA; isize++) {
 395                 if (tcm825x_sizes[isize + 1].height
 396                     * tcm825x_sizes[isize + 1].width > pixels) {
 397                         dev_dbg(&sensor->i2c_client->dev, "size %d\n", isize);
 398
 399                         return isize;
 400                 }
 401         }
 402
 403         dev_dbg(&sensor->i2c_client->dev, "format default VGA\n");
 404
 405         return VGA;
 406 }
 407
 408 /*
 409  * Configure the TCM825X for current image size, pixel format, and
 410  * frame period. fper is the frame period (in seconds) expressed as a
 411  * fraction. Returns zero if successful, or non-zero otherwise. The
 412  * actual frame period is returned in fper.
 413  */
 414 static int tcm825x_configure(struct v4l2_int_device *s)
 415 {
 416         struct tcm825x_sensor *sensor = s->priv;
 417         struct v4l2_pix_format *pix = &sensor->pix;
 418         enum image_size isize = tcm825x_find_size(s, pix->width, pix->height);
 419         struct v4l2_fract *fper = &sensor->timeperframe;
 420         enum pixel_format pfmt;
 421         int err;
 422         u32 tgt_fps;
 423         u8 val;
 424
 425         /* common register initialization */
 426         err = tcm825x_write_default_regs(
 427                 sensor->i2c_client, sensor->platform_data->default_regs());
 428         if (err)
 429                 return err;
 430
 431         /* configure image size */
 432         val = tcm825x_siz_reg[isize]->val;
 433         dev_dbg(&sensor->i2c_client->dev,
 434                 "configuring image size %d\n", isize);
 435         err = tcm825x_write_reg_mask(sensor->i2c_client,
 436                                      tcm825x_siz_reg[isize]->reg, val);
 437         if (err)
 438                 return err;
 439
 440         /* configure pixel format */
 441         switch (pix->pixelformat) {
 442         default:
 443         case V4L2_PIX_FMT_RGB565:
 444                 pfmt = RGB565;
 445                 break;
 446         case V4L2_PIX_FMT_UYVY:
 447                 pfmt = YUV422;
 448                 break;
 449         }
 450
 451         dev_dbg(&sensor->i2c_client->dev,
 452                 "configuring pixel format %d\n", pfmt);
 453         val = tcm825x_fmt_reg[pfmt]->val;
 454
 455         err = tcm825x_write_reg_mask(sensor->i2c_client,
 456                                      tcm825x_fmt_reg[pfmt]->reg, val);
 457         if (err)
 458                 return err;
 459
 460         /*
 461          * For frame rate < 15, the FPS reg (addr 0x02, bit 7) must be
 462          * set. Frame rate will be halved from the normal.
 463          */
 464         tgt_fps = fper->denominator / fper->numerator;
 465         if (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) {
 466                 val = tcm825x_read_reg(sensor->i2c_client, 0x02);
 467                 val |= 0x80;
 468                 tcm825x_write_reg(sensor->i2c_client, 0x02, val);
 469         }
 470
 471         return 0;
 472 }
 473
 474 static int ioctl_queryctrl(struct v4l2_int_device *s,
 475                                 struct v4l2_queryctrl *qc)
 476 {
 477         struct vcontrol *control;
 478
 479         control = find_vctrl(qc->id);
 480
 481         if (control == NULL)
 482                 return -EINVAL;
 483
 484         *qc = control->qc;
 485
 486         return 0;
 487 }
 488
 489 static int ioctl_g_ctrl(struct v4l2_int_device *s,
 490                              struct v4l2_control *vc)
 491 {
 492         struct tcm825x_sensor *sensor = s->priv;
 493         struct i2c_client *client = sensor->i2c_client;
 494         int val, r;
 495         struct vcontrol *lvc;
 496
 497         /* exposure time is special, spread across 2 registers */
 498         if (vc->id == V4L2_CID_EXPOSURE) {
 499                 int val_lower, val_upper;
 500
 501                 val_upper = tcm825x_read_reg(client,
 502                                              TCM825X_ADDR(TCM825X_ESRSPD_U));
 503                 if (val_upper < 0)
 504                         return val_upper;
 505                 val_lower = tcm825x_read_reg(client,
 506                                              TCM825X_ADDR(TCM825X_ESRSPD_L));
 507                 if (val_lower < 0)
 508                         return val_lower;
 509
 510                 vc->value = ((val_upper & 0x1f) << 8) | (val_lower);
 511                 return 0;
 512         }
 513
 514         lvc = find_vctrl(vc->id);
 515         if (lvc == NULL)
 516                 return -EINVAL;
 517
 518         r = tcm825x_read_reg(client, TCM825X_ADDR(lvc->reg));
 519         if (r < 0)
 520                 return r;
 521         val = r & TCM825X_MASK(lvc->reg);
 522         val >>= lvc->start_bit;
 523
 524         if (val < 0)
 525                 return val;
 526
 527         if (vc->id == V4L2_CID_HFLIP || vc->id == V4L2_CID_VFLIP)
 528                 val ^= sensor->platform_data->is_upside_down();
 529
 530         vc->value = val;
 531         return 0;
 532 }
 533
 534 static int ioctl_s_ctrl(struct v4l2_int_device *s,
 535                              struct v4l2_control *vc)
 536 {
 537         struct tcm825x_sensor *sensor = s->priv;
 538         struct i2c_client *client = sensor->i2c_client;
 539         struct vcontrol *lvc;
 540         int val = vc->value;
 541
 542         /* exposure time is special, spread across 2 registers */
 543         if (vc->id == V4L2_CID_EXPOSURE) {
 544                 int val_lower, val_upper;
 545                 val_lower = val & TCM825X_MASK(TCM825X_ESRSPD_L);
 546                 val_upper = (val >> 8) & TCM825X_MASK(TCM825X_ESRSPD_U);
 547
 548                 if (tcm825x_write_reg_mask(client,
 549                                            TCM825X_ESRSPD_U, val_upper))
 550                         return -EIO;
 551
 552                 if (tcm825x_write_reg_mask(client,
 553                                            TCM825X_ESRSPD_L, val_lower))
 554                         return -EIO;
 555
 556                 return 0;
 557         }
 558
 559         lvc = find_vctrl(vc->id);
 560         if (lvc == NULL)
 561                 return -EINVAL;
 562
 563         if (vc->id == V4L2_CID_HFLIP || vc->id == V4L2_CID_VFLIP)
 564                 val ^= sensor->platform_data->is_upside_down();
 565
 566         val = val << lvc->start_bit;
 567         if (tcm825x_write_reg_mask(client, lvc->reg, val))
 568                 return -EIO;
 569
 570         return 0;
 571 }
 572
 573 static int ioctl_enum_fmt_cap(struct v4l2_int_device *s,
 574                                    struct v4l2_fmtdesc *fmt)
 575 {
 576         int index = fmt->index;
 577
 578         switch (fmt->type) {
 579         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 580                 if (index >= TCM825X_NUM_CAPTURE_FORMATS)
 581                         return -EINVAL;
 582                 break;
 583
 584         default:
 585                 return -EINVAL;
 586         }
 587
 588         fmt->flags = tcm825x_formats[index].flags;
 589         strlcpy(fmt->description, tcm825x_formats[index].description,
 590                 sizeof(fmt->description));
 591         fmt->pixelformat = tcm825x_formats[index].pixelformat;
 592
 593         return 0;
 594 }
 595
 596 static int ioctl_try_fmt_cap(struct v4l2_int_device *s,
 597                              struct v4l2_format *f)
 598 {
 599         struct tcm825x_sensor *sensor = s->priv;
 600         enum image_size isize;
 601         int ifmt;
 602         struct v4l2_pix_format *pix = &f->fmt.pix;
 603
 604         isize = tcm825x_find_size(s, pix->width, pix->height);
 605         dev_dbg(&sensor->i2c_client->dev, "isize = %d num_capture = %lu\n",
 606                 isize, (unsigned long)TCM825X_NUM_CAPTURE_FORMATS);
 607
 608         pix->width = tcm825x_sizes[isize].width;
 609         pix->height = tcm825x_sizes[isize].height;
 610
 611         for (ifmt = 0; ifmt < TCM825X_NUM_CAPTURE_FORMATS; ifmt++)
 612                 if (pix->pixelformat == tcm825x_formats[ifmt].pixelformat)
 613                         break;
 614
 615         if (ifmt == TCM825X_NUM_CAPTURE_FORMATS)
 616                 ifmt = 0;       /* Default = YUV 4:2:2 */
 617
 618         pix->pixelformat = tcm825x_formats[ifmt].pixelformat;
 619         pix->field = V4L2_FIELD_NONE;
 620         pix->bytesperline = pix->width * TCM825X_BYTES_PER_PIXEL;
 621         pix->sizeimage = pix->bytesperline * pix->height;
 622         pix->priv = 0;
 623         dev_dbg(&sensor->i2c_client->dev, "format = 0x%08x\n",
 624                 pix->pixelformat);
 625
 626         switch (pix->pixelformat) {
 627         case V4L2_PIX_FMT_UYVY:
 628         default:
 629                 pix->colorspace = V4L2_COLORSPACE_JPEG;
 630                 break;
 631         case V4L2_PIX_FMT_RGB565:
 632                 pix->colorspace = V4L2_COLORSPACE_SRGB;
 633                 break;
 634         }
 635
 636         return 0;
 637 }
 638
 639 static int ioctl_s_fmt_cap(struct v4l2_int_device *s,
 640                                 struct v4l2_format *f)
 641 {
 642         struct tcm825x_sensor *sensor = s->priv;
 643         struct v4l2_pix_format *pix = &f->fmt.pix;
 644         int rval;
 645
 646         rval = ioctl_try_fmt_cap(s, f);
 647         if (rval)
 648                 return rval;
 649
 650         rval = tcm825x_configure(s);
 651
 652         sensor->pix = *pix;
 653
 654         return rval;
 655 }
 656
 657 static int ioctl_g_fmt_cap(struct v4l2_int_device *s,
 658                                 struct v4l2_format *f)
 659 {
 660         struct tcm825x_sensor *sensor = s->priv;
 661
 662         f->fmt.pix = sensor->pix;
 663
 664         return 0;
 665 }
 666
 667 static int ioctl_g_parm(struct v4l2_int_device *s,
 668                              struct v4l2_streamparm *a)
 669 {
 670         struct tcm825x_sensor *sensor = s->priv;
 671         struct v4l2_captureparm *cparm = &a->parm.capture;
 672
 673         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 674                 return -EINVAL;
 675
 676         memset(a, 0, sizeof(*a));
 677         a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 678
 679         cparm->capability = V4L2_CAP_TIMEPERFRAME;
 680         cparm->timeperframe = sensor->timeperframe;
 681
 682         return 0;
 683 }
 684
 685 static int ioctl_s_parm(struct v4l2_int_device *s,
 686                              struct v4l2_streamparm *a)
 687 {
 688         struct tcm825x_sensor *sensor = s->priv;
 689         struct v4l2_fract *timeperframe = &a->parm.capture.timeperframe;
 690         u32 tgt_fps;    /* target frames per secound */
 691         int rval;
 692
 693         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 694                 return -EINVAL;
 695
 696         if ((timeperframe->numerator == 0)
 697             || (timeperframe->denominator == 0)) {
 698                 timeperframe->denominator = DEFAULT_FPS;
 699                 timeperframe->numerator = 1;
 700         }
 701
 702         tgt_fps = timeperframe->denominator / timeperframe->numerator;
 703
 704         if (tgt_fps > MAX_FPS) {
 705                 timeperframe->denominator = MAX_FPS;
 706                 timeperframe->numerator = 1;
 707         } else if (tgt_fps < MIN_FPS) {
 708                 timeperframe->denominator = MIN_FPS;
 709                 timeperframe->numerator = 1;
 710         }
 711
 712         sensor->timeperframe = *timeperframe;
 713
 714         rval = tcm825x_configure(s);
 715
 716         return rval;
 717 }
 718
 719 static int ioctl_s_power(struct v4l2_int_device *s, int on)
 720 {
 721         struct tcm825x_sensor *sensor = s->priv;
 722
 723         return sensor->platform_data->power_set(on);
 724 }
 725
 726 /*
 727  * Given the image capture format in pix, the nominal frame period in
 728  * timeperframe, calculate the required xclk frequency.
 729  *
 730  * TCM825X input frequency characteristics are:
 731  *     Minimum 11.9 MHz, Typical 24.57 MHz and maximum 25/27 MHz
 732  */
 733
 734 static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p)
 735 {
 736         struct tcm825x_sensor *sensor = s->priv;
 737         struct v4l2_fract *timeperframe = &sensor->timeperframe;
 738         u32 tgt_xclk;   /* target xclk */
 739         u32 tgt_fps;    /* target frames per secound */
 740         int rval;
 741
 742         rval = sensor->platform_data->ifparm(p);
 743         if (rval)
 744                 return rval;
 745
 746         tgt_fps = timeperframe->denominator / timeperframe->numerator;
 747
 748         tgt_xclk = (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) ?
 749                 (2457 * tgt_fps) / MAX_HALF_FPS :
 750                 (2457 * tgt_fps) / MAX_FPS;
 751         tgt_xclk *= 10000;
 752
 753         tgt_xclk = min(tgt_xclk, (u32)TCM825X_XCLK_MAX);
 754         tgt_xclk = max(tgt_xclk, (u32)TCM825X_XCLK_MIN);
 755
 756         p->u.bt656.clock_curr = tgt_xclk;
 757
 758         return 0;
 759 }
 760
 761 static int ioctl_g_needs_reset(struct v4l2_int_device *s, void *buf)
 762 {
 763         struct tcm825x_sensor *sensor = s->priv;
 764
 765         return sensor->platform_data->needs_reset(s, buf, &sensor->pix);
 766 }
 767
 768 static int ioctl_reset(struct v4l2_int_device *s)
 769 {
 770         return -EBUSY;
 771 }
 772
 773 static int ioctl_init(struct v4l2_int_device *s)
 774 {
 775         return tcm825x_configure(s);
 776 }
 777
 778 static int ioctl_dev_exit(struct v4l2_int_device *s)
 779 {
 780         return 0;
 781 }
 782
 783 static int ioctl_dev_init(struct v4l2_int_device *s)
 784 {
 785         struct tcm825x_sensor *sensor = s->priv;
 786         int r;
 787
 788         r = tcm825x_read_reg(sensor->i2c_client, 0x01);
 789         if (r < 0)
 790                 return r;
 791         if (r == 0) {
 792                 dev_err(&sensor->i2c_client->dev, "device not detected\n");
 793                 return -EIO;
 794         }
 795         return 0;
 796 }
 797
 798 static struct v4l2_int_ioctl_desc tcm825x_ioctl_desc[] = {
 799         { vidioc_int_dev_init_num,
 800           (v4l2_int_ioctl_func *)ioctl_dev_init },
 801         { vidioc_int_dev_exit_num,
 802           (v4l2_int_ioctl_func *)ioctl_dev_exit },
 803         { vidioc_int_s_power_num,
 804           (v4l2_int_ioctl_func *)ioctl_s_power },
 805         { vidioc_int_g_ifparm_num,
 806           (v4l2_int_ioctl_func *)ioctl_g_ifparm },
 807         { vidioc_int_g_needs_reset_num,
 808           (v4l2_int_ioctl_func *)ioctl_g_needs_reset },
 809         { vidioc_int_reset_num,
 810           (v4l2_int_ioctl_func *)ioctl_reset },
 811         { vidioc_int_init_num,
 812           (v4l2_int_ioctl_func *)ioctl_init },
 813         { vidioc_int_enum_fmt_cap_num,
 814           (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap },
 815         { vidioc_int_try_fmt_cap_num,
 816           (v4l2_int_ioctl_func *)ioctl_try_fmt_cap },
 817         { vidioc_int_g_fmt_cap_num,
 818           (v4l2_int_ioctl_func *)ioctl_g_fmt_cap },
 819         { vidioc_int_s_fmt_cap_num,
 820           (v4l2_int_ioctl_func *)ioctl_s_fmt_cap },
 821         { vidioc_int_g_parm_num,
 822           (v4l2_int_ioctl_func *)ioctl_g_parm },
 823         { vidioc_int_s_parm_num,
 824           (v4l2_int_ioctl_func *)ioctl_s_parm },
 825         { vidioc_int_queryctrl_num,
 826           (v4l2_int_ioctl_func *)ioctl_queryctrl },
 827         { vidioc_int_g_ctrl_num,
 828           (v4l2_int_ioctl_func *)ioctl_g_ctrl },
 829         { vidioc_int_s_ctrl_num,
 830           (v4l2_int_ioctl_func *)ioctl_s_ctrl },
 831 };
 832
 833 static struct v4l2_int_slave tcm825x_slave = {
 834         .ioctls = tcm825x_ioctl_desc,
 835         .num_ioctls = ARRAY_SIZE(tcm825x_ioctl_desc),
 836 };
 837
 838 static struct tcm825x_sensor tcm825x;
 839
 840 static struct v4l2_int_device tcm825x_int_device = {
 841         .module = THIS_MODULE,
 842         .name = TCM825X_NAME,
 843         .priv = &tcm825x,
 844         .type = v4l2_int_type_slave,
 845         .u = {
 846                 .slave = &tcm825x_slave,
 847         },
 848 };
 849
 850 static int tcm825x_probe(struct i2c_client *client,
 851                          const struct i2c_device_id *did)
 852 {
 853         struct tcm825x_sensor *sensor = &tcm825x;
 854
 855         if (i2c_get_clientdata(client))
 856                 return -EBUSY;
 857
 858         sensor->platform_data = client->dev.platform_data;
 859
 860         if (sensor->platform_data == NULL
 861             || !sensor->platform_data->is_okay())
 862                 return -ENODEV;
 863
 864         sensor->v4l2_int_device = &tcm825x_int_device;
 865
 866         sensor->i2c_client = client;
 867         i2c_set_clientdata(client, sensor);
 868
 869         /* Make the default capture format QVGA RGB565 */
 870         sensor->pix.width = tcm825x_sizes[QVGA].width;
 871         sensor->pix.height = tcm825x_sizes[QVGA].height;
 872         sensor->pix.pixelformat = V4L2_PIX_FMT_RGB565;
 873
 874         return v4l2_int_device_register(sensor->v4l2_int_device);
 875 }
 876
 877 static int tcm825x_remove(struct i2c_client *client)
 878 {
 879         struct tcm825x_sensor *sensor = i2c_get_clientdata(client);
 880
 881         if (!client->adapter)
 882                 return -ENODEV; /* our client isn't attached */
 883
 884         v4l2_int_device_unregister(sensor->v4l2_int_device);
 885
 886         return 0;
 887 }
 888
 889 static const struct i2c_device_id tcm825x_id[] = {
 890         { "tcm825x", 0 },
 891         { }
 892 };
 893 MODULE_DEVICE_TABLE(i2c, tcm825x_id);
 894
 895 static struct i2c_driver tcm825x_i2c_driver = {
 896         .driver = {
 897                 .name = TCM825X_NAME,
 898         },
 899         .probe  = tcm825x_probe,
 900         .remove = tcm825x_remove,
 901         .id_table = tcm825x_id,
 902 };
 903
 904 static struct tcm825x_sensor tcm825x = {
 905         .timeperframe = {
 906                 .numerator   = 1,
 907                 .denominator = DEFAULT_FPS,
 908         },
 909 };
 910
 911 static int __init tcm825x_init(void)
 912 {
 913         int rval;
 914
 915         rval = i2c_add_driver(&tcm825x_i2c_driver);
 916         if (rval)
 917                 printk(KERN_INFO "%s: failed registering " TCM825X_NAME "\n",
 918                        __func__);
 919
 920         return rval;
 921 }
 922
 923 static void __exit tcm825x_exit(void)
 924 {
 925         i2c_del_driver(&tcm825x_i2c_driver);
 926 }
 927
 928 /*
 929  * FIXME: Menelaus isn't ready (?) at module_init stage, so use
 930  * late_initcall for now.
 931  */
 932 late_initcall(tcm825x_init);
 933 module_exit(tcm825x_exit);
 934
 935 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
 936 MODULE_DESCRIPTION("TCM825x camera sensor driver");
 937 MODULE_LICENSE("GPL");