git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tcm825x.c

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