drivers/staging/media/imx/imx6-mipi-csi2.c

   1 /*
   2  * MIPI CSI-2 Receiver Subdev for Freescale i.MX6 SOC.
   3  *
   4  * Copyright (c) 2012-2017 Mentor Graphics Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11 #include <linux/clk.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/iopoll.h>
  15 #include <linux/irq.h>
  16 #include <linux/module.h>
  17 #include <linux/of_graph.h>
  18 #include <linux/platform_device.h>
  19 #include <media/v4l2-device.h>
  20 #include <media/v4l2-fwnode.h>
  21 #include <media/v4l2-subdev.h>
  22 #include "imx-media.h"
  23
  24 /*
  25  * there must be 5 pads: 1 input pad from sensor, and
  26  * the 4 virtual channel output pads
  27  */
  28 #define CSI2_SINK_PAD       0
  29 #define CSI2_NUM_SINK_PADS  1
  30 #define CSI2_NUM_SRC_PADS   4
  31 #define CSI2_NUM_PADS       5
  32
  33 /*
  34  * The default maximum bit-rate per lane in Mbps, if the
  35  * source subdev does not provide V4L2_CID_LINK_FREQ.
  36  */
  37 #define CSI2_DEFAULT_MAX_MBPS 849
  38
  39 struct csi2_dev {
  40         struct device          *dev;
  41         struct v4l2_subdev      sd;
  42         struct media_pad       pad[CSI2_NUM_PADS];
  43         struct clk             *dphy_clk;
  44         struct clk             *pllref_clk;
  45         struct clk             *pix_clk; /* what is this? */
  46         void __iomem           *base;
  47         struct v4l2_fwnode_bus_mipi_csi2 bus;
  48
  49         /* lock to protect all members below */
  50         struct mutex lock;
  51
  52         struct v4l2_mbus_framefmt format_mbus;
  53
  54         int                     stream_count;
  55         struct v4l2_subdev      *src_sd;
  56         bool                    sink_linked[CSI2_NUM_SRC_PADS];
  57 };
  58
  59 #define DEVICE_NAME "imx6-mipi-csi2"
  60
  61 /* Register offsets */
  62 #define CSI2_VERSION            0x000
  63 #define CSI2_N_LANES            0x004
  64 #define CSI2_PHY_SHUTDOWNZ      0x008
  65 #define CSI2_DPHY_RSTZ          0x00c
  66 #define CSI2_RESETN             0x010
  67 #define CSI2_PHY_STATE          0x014
  68 #define PHY_STOPSTATEDATA_BIT   4
  69 #define PHY_STOPSTATEDATA(n)    BIT(PHY_STOPSTATEDATA_BIT + (n))
  70 #define PHY_RXCLKACTIVEHS       BIT(8)
  71 #define PHY_RXULPSCLKNOT        BIT(9)
  72 #define PHY_STOPSTATECLK        BIT(10)
  73 #define CSI2_DATA_IDS_1         0x018
  74 #define CSI2_DATA_IDS_2         0x01c
  75 #define CSI2_ERR1               0x020
  76 #define CSI2_ERR2               0x024
  77 #define CSI2_MSK1               0x028
  78 #define CSI2_MSK2               0x02c
  79 #define CSI2_PHY_TST_CTRL0      0x030
  80 #define PHY_TESTCLR             BIT(0)
  81 #define PHY_TESTCLK             BIT(1)
  82 #define CSI2_PHY_TST_CTRL1      0x034
  83 #define PHY_TESTEN              BIT(16)
  84 /*
  85  * i.MX CSI2IPU Gasket registers follow. The CSI2IPU gasket is
  86  * not part of the MIPI CSI-2 core, but its registers fall in the
  87  * same register map range.
  88  */
  89 #define CSI2IPU_GASKET          0xf00
  90 #define CSI2IPU_YUV422_YUYV     BIT(2)
  91
  92 static inline struct csi2_dev *sd_to_dev(struct v4l2_subdev *sdev)
  93 {
  94         return container_of(sdev, struct csi2_dev, sd);
  95 }
  96
  97 /*
  98  * The required sequence of MIPI CSI-2 startup as specified in the i.MX6
  99  * reference manual is as follows:
 100  *
 101  * 1. Deassert presetn signal (global reset).
 102  *        It's not clear what this "global reset" signal is (maybe APB
 103  *        global reset), but in any case this step would be probably
 104  *        be carried out during driver load in csi2_probe().
 105  *
 106  * 2. Configure MIPI Camera Sensor to put all Tx lanes in LP-11 state.
 107  *        This must be carried out by the MIPI sensor's s_power(ON) subdev
 108  *        op.
 109  *
 110  * 3. D-PHY initialization.
 111  * 4. CSI2 Controller programming (Set N_LANES, deassert PHY_SHUTDOWNZ,
 112  *    deassert PHY_RSTZ, deassert CSI2_RESETN).
 113  * 5. Read the PHY status register (PHY_STATE) to confirm that all data and
 114  *    clock lanes of the D-PHY are in LP-11 state.
 115  * 6. Configure the MIPI Camera Sensor to start transmitting a clock on the
 116  *    D-PHY clock lane.
 117  * 7. CSI2 Controller programming - Read the PHY status register (PHY_STATE)
 118  *    to confirm that the D-PHY is receiving a clock on the D-PHY clock lane.
 119  *
 120  * All steps 3 through 7 are carried out by csi2_s_stream(ON) here. Step
 121  * 6 is accomplished by calling the source subdev's s_stream(ON) between
 122  * steps 5 and 7.
 123  */
 124
 125 static void csi2_enable(struct csi2_dev *csi2, bool enable)
 126 {
 127         if (enable) {
 128                 writel(0x1, csi2->base + CSI2_PHY_SHUTDOWNZ);
 129                 writel(0x1, csi2->base + CSI2_DPHY_RSTZ);
 130                 writel(0x1, csi2->base + CSI2_RESETN);
 131         } else {
 132                 writel(0x0, csi2->base + CSI2_PHY_SHUTDOWNZ);
 133                 writel(0x0, csi2->base + CSI2_DPHY_RSTZ);
 134                 writel(0x0, csi2->base + CSI2_RESETN);
 135         }
 136 }
 137
 138 static void csi2_set_lanes(struct csi2_dev *csi2)
 139 {
 140         int lanes = csi2->bus.num_data_lanes;
 141
 142         writel(lanes - 1, csi2->base + CSI2_N_LANES);
 143 }
 144
 145 static void dw_mipi_csi2_phy_write(struct csi2_dev *csi2,
 146                                    u32 test_code, u32 test_data)
 147 {
 148         /* Clear PHY test interface */
 149         writel(PHY_TESTCLR, csi2->base + CSI2_PHY_TST_CTRL0);
 150         writel(0x0, csi2->base + CSI2_PHY_TST_CTRL1);
 151         writel(0x0, csi2->base + CSI2_PHY_TST_CTRL0);
 152
 153         /* Raise test interface strobe signal */
 154         writel(PHY_TESTCLK, csi2->base + CSI2_PHY_TST_CTRL0);
 155
 156         /* Configure address write on falling edge and lower strobe signal */
 157         writel(PHY_TESTEN | test_code, csi2->base + CSI2_PHY_TST_CTRL1);
 158         writel(0x0, csi2->base + CSI2_PHY_TST_CTRL0);
 159
 160         /* Configure data write on rising edge and raise strobe signal */
 161         writel(test_data, csi2->base + CSI2_PHY_TST_CTRL1);
 162         writel(PHY_TESTCLK, csi2->base + CSI2_PHY_TST_CTRL0);
 163
 164         /* Clear strobe signal */
 165         writel(0x0, csi2->base + CSI2_PHY_TST_CTRL0);
 166 }
 167
 168 /*
 169  * This table is based on the table documented at
 170  * https://community.nxp.com/docs/DOC-94312. It assumes
 171  * a 27MHz D-PHY pll reference clock.
 172  */
 173 static const struct {
 174         u32 max_mbps;
 175         u32 hsfreqrange_sel;
 176 } hsfreq_map[] = {
 177         { 90, 0x00}, {100, 0x20}, {110, 0x40}, {125, 0x02},
 178         {140, 0x22}, {150, 0x42}, {160, 0x04}, {180, 0x24},
 179         {200, 0x44}, {210, 0x06}, {240, 0x26}, {250, 0x46},
 180         {270, 0x08}, {300, 0x28}, {330, 0x48}, {360, 0x2a},
 181         {400, 0x4a}, {450, 0x0c}, {500, 0x2c}, {550, 0x0e},
 182         {600, 0x2e}, {650, 0x10}, {700, 0x30}, {750, 0x12},
 183         {800, 0x32}, {850, 0x14}, {900, 0x34}, {950, 0x54},
 184         {1000, 0x74},
 185 };
 186
 187 static int max_mbps_to_hsfreqrange_sel(u32 max_mbps)
 188 {
 189         int i;
 190
 191         for (i = 0; i < ARRAY_SIZE(hsfreq_map); i++)
 192                 if (hsfreq_map[i].max_mbps > max_mbps)
 193                         return hsfreq_map[i].hsfreqrange_sel;
 194
 195         return -EINVAL;
 196 }
 197
 198 static int csi2_dphy_init(struct csi2_dev *csi2)
 199 {
 200         struct v4l2_ctrl *ctrl;
 201         u32 mbps_per_lane;
 202         int sel;
 203
 204         ctrl = v4l2_ctrl_find(csi2->src_sd->ctrl_handler,
 205                               V4L2_CID_LINK_FREQ);
 206         if (!ctrl)
 207                 mbps_per_lane = CSI2_DEFAULT_MAX_MBPS;
 208         else
 209                 mbps_per_lane = DIV_ROUND_UP_ULL(2 * ctrl->qmenu_int[ctrl->val],
 210                                                  USEC_PER_SEC);
 211
 212         sel = max_mbps_to_hsfreqrange_sel(mbps_per_lane);
 213         if (sel < 0)
 214                 return sel;
 215
 216         dw_mipi_csi2_phy_write(csi2, 0x44, sel);
 217
 218         return 0;
 219 }
 220
 221 /*
 222  * Waits for ultra-low-power state on D-PHY clock lane. This is currently
 223  * unused and may not be needed at all, but keep around just in case.
 224  */
 225 static int __maybe_unused csi2_dphy_wait_ulp(struct csi2_dev *csi2)
 226 {
 227         u32 reg;
 228         int ret;
 229
 230         /* wait for ULP on clock lane */
 231         ret = readl_poll_timeout(csi2->base + CSI2_PHY_STATE, reg,
 232                                  !(reg & PHY_RXULPSCLKNOT), 0, 500000);
 233         if (ret) {
 234                 v4l2_err(&csi2->sd, "ULP timeout, phy_state = 0x%08x\n", reg);
 235                 return ret;
 236         }
 237
 238         /* wait until no errors on bus */
 239         ret = readl_poll_timeout(csi2->base + CSI2_ERR1, reg,
 240                                  reg == 0x0, 0, 500000);
 241         if (ret) {
 242                 v4l2_err(&csi2->sd, "stable bus timeout, err1 = 0x%08x\n", reg);
 243                 return ret;
 244         }
 245
 246         return 0;
 247 }
 248
 249 /* Waits for low-power LP-11 state on data and clock lanes. */
 250 static int csi2_dphy_wait_stopstate(struct csi2_dev *csi2)
 251 {
 252         u32 mask, reg;
 253         int ret;
 254
 255         mask = PHY_STOPSTATECLK |
 256                 ((csi2->bus.num_data_lanes - 1) << PHY_STOPSTATEDATA_BIT);
 257
 258         ret = readl_poll_timeout(csi2->base + CSI2_PHY_STATE, reg,
 259                                  (reg & mask) == mask, 0, 500000);
 260         if (ret) {
 261                 v4l2_err(&csi2->sd, "LP-11 timeout, phy_state = 0x%08x\n", reg);
 262                 return ret;
 263         }
 264
 265         return 0;
 266 }
 267
 268 /* Wait for active clock on the clock lane. */
 269 static int csi2_dphy_wait_clock_lane(struct csi2_dev *csi2)
 270 {
 271         u32 reg;
 272         int ret;
 273
 274         ret = readl_poll_timeout(csi2->base + CSI2_PHY_STATE, reg,
 275                                  (reg & PHY_RXCLKACTIVEHS), 0, 500000);
 276         if (ret) {
 277                 v4l2_err(&csi2->sd, "clock lane timeout, phy_state = 0x%08x\n",
 278                          reg);
 279                 return ret;
 280         }
 281
 282         return 0;
 283 }
 284
 285 /* Setup the i.MX CSI2IPU Gasket */
 286 static void csi2ipu_gasket_init(struct csi2_dev *csi2)
 287 {
 288         u32 reg = 0;
 289
 290         switch (csi2->format_mbus.code) {
 291         case MEDIA_BUS_FMT_YUYV8_2X8:
 292         case MEDIA_BUS_FMT_YUYV8_1X16:
 293                 reg = CSI2IPU_YUV422_YUYV;
 294                 break;
 295         default:
 296                 break;
 297         }
 298
 299         writel(reg, csi2->base + CSI2IPU_GASKET);
 300 }
 301
 302 static int csi2_start(struct csi2_dev *csi2)
 303 {
 304         int ret;
 305
 306         ret = clk_prepare_enable(csi2->pix_clk);
 307         if (ret)
 308                 return ret;
 309
 310         /* setup the gasket */
 311         csi2ipu_gasket_init(csi2);
 312
 313         /* Step 3 */
 314         ret = csi2_dphy_init(csi2);
 315         if (ret)
 316                 goto err_disable_clk;
 317
 318         /* Step 4 */
 319         csi2_set_lanes(csi2);
 320         csi2_enable(csi2, true);
 321
 322         /* Step 5 */
 323         ret = csi2_dphy_wait_stopstate(csi2);
 324         if (ret)
 325                 goto err_assert_reset;
 326
 327         /* Step 6 */
 328         ret = v4l2_subdev_call(csi2->src_sd, video, s_stream, 1);
 329         ret = (ret && ret != -ENOIOCTLCMD) ? ret : 0;
 330         if (ret)
 331                 goto err_assert_reset;
 332
 333         /* Step 7 */
 334         ret = csi2_dphy_wait_clock_lane(csi2);
 335         if (ret)
 336                 goto err_stop_upstream;
 337
 338         return 0;
 339
 340 err_stop_upstream:
 341         v4l2_subdev_call(csi2->src_sd, video, s_stream, 0);
 342 err_assert_reset:
 343         csi2_enable(csi2, false);
 344 err_disable_clk:
 345         clk_disable_unprepare(csi2->pix_clk);
 346         return ret;
 347 }
 348
 349 static void csi2_stop(struct csi2_dev *csi2)
 350 {
 351         /* stop upstream */
 352         v4l2_subdev_call(csi2->src_sd, video, s_stream, 0);
 353
 354         csi2_enable(csi2, false);
 355         clk_disable_unprepare(csi2->pix_clk);
 356 }
 357
 358 /*
 359  * V4L2 subdev operations.
 360  */
 361
 362 static int csi2_s_stream(struct v4l2_subdev *sd, int enable)
 363 {
 364         struct csi2_dev *csi2 = sd_to_dev(sd);
 365         int i, ret = 0;
 366
 367         mutex_lock(&csi2->lock);
 368
 369         if (!csi2->src_sd) {
 370                 ret = -EPIPE;
 371                 goto out;
 372         }
 373
 374         for (i = 0; i < CSI2_NUM_SRC_PADS; i++) {
 375                 if (csi2->sink_linked[i])
 376                         break;
 377         }
 378         if (i >= CSI2_NUM_SRC_PADS) {
 379                 ret = -EPIPE;
 380                 goto out;
 381         }
 382
 383         /*
 384          * enable/disable streaming only if stream_count is
 385          * going from 0 to 1 / 1 to 0.
 386          */
 387         if (csi2->stream_count != !enable)
 388                 goto update_count;
 389
 390         dev_dbg(csi2->dev, "stream %s\n", enable ? "ON" : "OFF");
 391         if (enable)
 392                 ret = csi2_start(csi2);
 393         else
 394                 csi2_stop(csi2);
 395         if (ret)
 396                 goto out;
 397
 398 update_count:
 399         csi2->stream_count += enable ? 1 : -1;
 400         if (csi2->stream_count < 0)
 401                 csi2->stream_count = 0;
 402 out:
 403         mutex_unlock(&csi2->lock);
 404         return ret;
 405 }
 406
 407 static int csi2_link_setup(struct media_entity *entity,
 408                            const struct media_pad *local,
 409                            const struct media_pad *remote, u32 flags)
 410 {
 411         struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
 412         struct csi2_dev *csi2 = sd_to_dev(sd);
 413         struct v4l2_subdev *remote_sd;
 414         int ret = 0;
 415
 416         dev_dbg(csi2->dev, "link setup %s -> %s", remote->entity->name,
 417                 local->entity->name);
 418
 419         remote_sd = media_entity_to_v4l2_subdev(remote->entity);
 420
 421         mutex_lock(&csi2->lock);
 422
 423         if (local->flags & MEDIA_PAD_FL_SOURCE) {
 424                 if (flags & MEDIA_LNK_FL_ENABLED) {
 425                         if (csi2->sink_linked[local->index - 1]) {
 426                                 ret = -EBUSY;
 427                                 goto out;
 428                         }
 429                         csi2->sink_linked[local->index - 1] = true;
 430                 } else {
 431                         csi2->sink_linked[local->index - 1] = false;
 432                 }
 433         } else {
 434                 if (flags & MEDIA_LNK_FL_ENABLED) {
 435                         if (csi2->src_sd) {
 436                                 ret = -EBUSY;
 437                                 goto out;
 438                         }
 439                         csi2->src_sd = remote_sd;
 440                 } else {
 441                         csi2->src_sd = NULL;
 442                 }
 443         }
 444
 445 out:
 446         mutex_unlock(&csi2->lock);
 447         return ret;
 448 }
 449
 450 static int csi2_get_fmt(struct v4l2_subdev *sd,
 451                         struct v4l2_subdev_pad_config *cfg,
 452                         struct v4l2_subdev_format *sdformat)
 453 {
 454         struct csi2_dev *csi2 = sd_to_dev(sd);
 455         struct v4l2_mbus_framefmt *fmt;
 456
 457         mutex_lock(&csi2->lock);
 458
 459         if (sdformat->which == V4L2_SUBDEV_FORMAT_TRY)
 460                 fmt = v4l2_subdev_get_try_format(&csi2->sd, cfg,
 461                                                  sdformat->pad);
 462         else
 463                 fmt = &csi2->format_mbus;
 464
 465         sdformat->format = *fmt;
 466
 467         mutex_unlock(&csi2->lock);
 468
 469         return 0;
 470 }
 471
 472 static int csi2_set_fmt(struct v4l2_subdev *sd,
 473                         struct v4l2_subdev_pad_config *cfg,
 474                         struct v4l2_subdev_format *sdformat)
 475 {
 476         struct csi2_dev *csi2 = sd_to_dev(sd);
 477         int ret = 0;
 478
 479         if (sdformat->pad >= CSI2_NUM_PADS)
 480                 return -EINVAL;
 481
 482         mutex_lock(&csi2->lock);
 483
 484         if (csi2->stream_count > 0) {
 485                 ret = -EBUSY;
 486                 goto out;
 487         }
 488
 489         /* Output pads mirror active input pad, no limits on input pads */
 490         if (sdformat->pad != CSI2_SINK_PAD)
 491                 sdformat->format = csi2->format_mbus;
 492
 493         if (sdformat->which == V4L2_SUBDEV_FORMAT_TRY)
 494                 cfg->try_fmt = sdformat->format;
 495         else
 496                 csi2->format_mbus = sdformat->format;
 497 out:
 498         mutex_unlock(&csi2->lock);
 499         return ret;
 500 }
 501
 502 /*
 503  * retrieve our pads parsed from the OF graph by the media device
 504  */
 505 static int csi2_registered(struct v4l2_subdev *sd)
 506 {
 507         struct csi2_dev *csi2 = sd_to_dev(sd);
 508         int i, ret;
 509
 510         for (i = 0; i < CSI2_NUM_PADS; i++) {
 511                 csi2->pad[i].flags = (i == CSI2_SINK_PAD) ?
 512                 MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
 513         }
 514
 515         /* set a default mbus format  */
 516         ret = imx_media_init_mbus_fmt(&csi2->format_mbus,
 517                                       640, 480, 0, V4L2_FIELD_NONE, NULL);
 518         if (ret)
 519                 return ret;
 520
 521         return media_entity_pads_init(&sd->entity, CSI2_NUM_PADS, csi2->pad);
 522 }
 523
 524 static const struct media_entity_operations csi2_entity_ops = {
 525         .link_setup = csi2_link_setup,
 526         .link_validate = v4l2_subdev_link_validate,
 527 };
 528
 529 static const struct v4l2_subdev_video_ops csi2_video_ops = {
 530         .s_stream = csi2_s_stream,
 531 };
 532
 533 static const struct v4l2_subdev_pad_ops csi2_pad_ops = {
 534         .get_fmt = csi2_get_fmt,
 535         .set_fmt = csi2_set_fmt,
 536 };
 537
 538 static const struct v4l2_subdev_ops csi2_subdev_ops = {
 539         .video = &csi2_video_ops,
 540         .pad = &csi2_pad_ops,
 541 };
 542
 543 static const struct v4l2_subdev_internal_ops csi2_internal_ops = {
 544         .registered = csi2_registered,
 545 };
 546
 547 static int csi2_parse_endpoints(struct csi2_dev *csi2)
 548 {
 549         struct device_node *node = csi2->dev->of_node;
 550         struct device_node *epnode;
 551         struct v4l2_fwnode_endpoint ep;
 552
 553         epnode = of_graph_get_endpoint_by_regs(node, 0, -1);
 554         if (!epnode) {
 555                 v4l2_err(&csi2->sd, "failed to get sink endpoint node\n");
 556                 return -EINVAL;
 557         }
 558
 559         v4l2_fwnode_endpoint_parse(of_fwnode_handle(epnode), &ep);
 560         of_node_put(epnode);
 561
 562         if (ep.bus_type != V4L2_MBUS_CSI2) {
 563                 v4l2_err(&csi2->sd, "invalid bus type, must be MIPI CSI2\n");
 564                 return -EINVAL;
 565         }
 566
 567         csi2->bus = ep.bus.mipi_csi2;
 568
 569         dev_dbg(csi2->dev, "data lanes: %d\n", csi2->bus.num_data_lanes);
 570         dev_dbg(csi2->dev, "flags: 0x%08x\n", csi2->bus.flags);
 571         return 0;
 572 }
 573
 574 static int csi2_probe(struct platform_device *pdev)
 575 {
 576         struct csi2_dev *csi2;
 577         struct resource *res;
 578         int ret;
 579
 580         csi2 = devm_kzalloc(&pdev->dev, sizeof(*csi2), GFP_KERNEL);
 581         if (!csi2)
 582                 return -ENOMEM;
 583
 584         csi2->dev = &pdev->dev;
 585
 586         v4l2_subdev_init(&csi2->sd, &csi2_subdev_ops);
 587         v4l2_set_subdevdata(&csi2->sd, &pdev->dev);
 588         csi2->sd.internal_ops = &csi2_internal_ops;
 589         csi2->sd.entity.ops = &csi2_entity_ops;
 590         csi2->sd.dev = &pdev->dev;
 591         csi2->sd.owner = THIS_MODULE;
 592         csi2->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
 593         strcpy(csi2->sd.name, DEVICE_NAME);
 594         csi2->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE;
 595         csi2->sd.grp_id = IMX_MEDIA_GRP_ID_CSI2;
 596
 597         ret = csi2_parse_endpoints(csi2);
 598         if (ret)
 599                 return ret;
 600
 601         csi2->pllref_clk = devm_clk_get(&pdev->dev, "ref");
 602         if (IS_ERR(csi2->pllref_clk)) {
 603                 v4l2_err(&csi2->sd, "failed to get pll reference clock\n");
 604                 ret = PTR_ERR(csi2->pllref_clk);
 605                 return ret;
 606         }
 607
 608         csi2->dphy_clk = devm_clk_get(&pdev->dev, "dphy");
 609         if (IS_ERR(csi2->dphy_clk)) {
 610                 v4l2_err(&csi2->sd, "failed to get dphy clock\n");
 611                 ret = PTR_ERR(csi2->dphy_clk);
 612                 return ret;
 613         }
 614
 615         csi2->pix_clk = devm_clk_get(&pdev->dev, "pix");
 616         if (IS_ERR(csi2->pix_clk)) {
 617                 v4l2_err(&csi2->sd, "failed to get pixel clock\n");
 618                 ret = PTR_ERR(csi2->pix_clk);
 619                 return ret;
 620         }
 621
 622         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 623         if (!res) {
 624                 v4l2_err(&csi2->sd, "failed to get platform resources\n");
 625                 return -ENODEV;
 626         }
 627
 628         csi2->base = devm_ioremap(&pdev->dev, res->start, PAGE_SIZE);
 629         if (!csi2->base) {
 630                 v4l2_err(&csi2->sd, "failed to map CSI-2 registers\n");
 631                 return -ENOMEM;
 632         }
 633
 634         mutex_init(&csi2->lock);
 635
 636         ret = clk_prepare_enable(csi2->pllref_clk);
 637         if (ret) {
 638                 v4l2_err(&csi2->sd, "failed to enable pllref_clk\n");
 639                 goto rmmutex;
 640         }
 641
 642         ret = clk_prepare_enable(csi2->dphy_clk);
 643         if (ret) {
 644                 v4l2_err(&csi2->sd, "failed to enable dphy_clk\n");
 645                 goto pllref_off;
 646         }
 647
 648         platform_set_drvdata(pdev, &csi2->sd);
 649
 650         ret = v4l2_async_register_subdev(&csi2->sd);
 651         if (ret)
 652                 goto dphy_off;
 653
 654         return 0;
 655
 656 dphy_off:
 657         clk_disable_unprepare(csi2->dphy_clk);
 658 pllref_off:
 659         clk_disable_unprepare(csi2->pllref_clk);
 660 rmmutex:
 661         mutex_destroy(&csi2->lock);
 662         return ret;
 663 }
 664
 665 static int csi2_remove(struct platform_device *pdev)
 666 {
 667         struct v4l2_subdev *sd = platform_get_drvdata(pdev);
 668         struct csi2_dev *csi2 = sd_to_dev(sd);
 669
 670         v4l2_async_unregister_subdev(sd);
 671         clk_disable_unprepare(csi2->dphy_clk);
 672         clk_disable_unprepare(csi2->pllref_clk);
 673         mutex_destroy(&csi2->lock);
 674         media_entity_cleanup(&sd->entity);
 675
 676         return 0;
 677 }
 678
 679 static const struct of_device_id csi2_dt_ids[] = {
 680         { .compatible = "fsl,imx6-mipi-csi2", },
 681         { /* sentinel */ }
 682 };
 683 MODULE_DEVICE_TABLE(of, csi2_dt_ids);
 684
 685 static struct platform_driver csi2_driver = {
 686         .driver = {
 687                 .name = DEVICE_NAME,
 688                 .of_match_table = csi2_dt_ids,
 689         },
 690         .probe = csi2_probe,
 691         .remove = csi2_remove,
 692 };
 693
 694 module_platform_driver(csi2_driver);
 695
 696 MODULE_DESCRIPTION("i.MX5/6 MIPI CSI-2 Receiver driver");
 697 MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");
 698 MODULE_LICENSE("GPL");