drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2011-2018 Magewell Electronics Co., Ltd. (Nanjing)
   4  * All rights reserved.
   5  * Author: Yong Deng <yong.deng@magewell.com>
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/delay.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/err.h>
  12 #include <linux/fs.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/io.h>
  15 #include <linux/ioctl.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/of_device.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/regmap.h>
  22 #include <linux/reset.h>
  23 #include <linux/sched.h>
  24 #include <linux/sizes.h>
  25 #include <linux/slab.h>
  26
  27 #include "sun6i_csi.h"
  28 #include "sun6i_csi_reg.h"
  29
  30 #define MODULE_NAME     "sun6i-csi"
  31
  32 struct sun6i_csi_dev {
  33         struct sun6i_csi                csi;
  34         struct device                   *dev;
  35
  36         struct regmap                   *regmap;
  37         struct clk                      *clk_mod;
  38         struct clk                      *clk_ram;
  39         struct reset_control            *rstc_bus;
  40
  41         int                             planar_offset[3];
  42 };
  43
  44 static inline struct sun6i_csi_dev *sun6i_csi_to_dev(struct sun6i_csi *csi)
  45 {
  46         return container_of(csi, struct sun6i_csi_dev, csi);
  47 }
  48
  49 /* TODO add 10&12 bit YUV, RGB support */
  50 bool sun6i_csi_is_format_supported(struct sun6i_csi *csi,
  51                                    u32 pixformat, u32 mbus_code)
  52 {
  53         struct sun6i_csi_dev *sdev = sun6i_csi_to_dev(csi);
  54
  55         /*
  56          * Some video receivers have the ability to be compatible with
  57          * 8bit and 16bit bus width.
  58          * Identify the media bus format from device tree.
  59          */
  60         if ((sdev->csi.v4l2_ep.bus_type == V4L2_MBUS_PARALLEL
  61              || sdev->csi.v4l2_ep.bus_type == V4L2_MBUS_BT656)
  62              && sdev->csi.v4l2_ep.bus.parallel.bus_width == 16) {
  63                 switch (pixformat) {
  64                 case V4L2_PIX_FMT_HM12:
  65                 case V4L2_PIX_FMT_NV12:
  66                 case V4L2_PIX_FMT_NV21:
  67                 case V4L2_PIX_FMT_NV16:
  68                 case V4L2_PIX_FMT_NV61:
  69                 case V4L2_PIX_FMT_YUV420:
  70                 case V4L2_PIX_FMT_YVU420:
  71                 case V4L2_PIX_FMT_YUV422P:
  72                         switch (mbus_code) {
  73                         case MEDIA_BUS_FMT_UYVY8_1X16:
  74                         case MEDIA_BUS_FMT_VYUY8_1X16:
  75                         case MEDIA_BUS_FMT_YUYV8_1X16:
  76                         case MEDIA_BUS_FMT_YVYU8_1X16:
  77                                 return true;
  78                         default:
  79                                 dev_dbg(sdev->dev, "Unsupported mbus code: 0x%x\n",
  80                                         mbus_code);
  81                                 break;
  82                         }
  83                         break;
  84                 default:
  85                         dev_dbg(sdev->dev, "Unsupported pixformat: 0x%x\n",
  86                                 pixformat);
  87                         break;
  88                 }
  89                 return false;
  90         }
  91
  92         switch (pixformat) {
  93         case V4L2_PIX_FMT_SBGGR8:
  94                 return (mbus_code == MEDIA_BUS_FMT_SBGGR8_1X8);
  95         case V4L2_PIX_FMT_SGBRG8:
  96                 return (mbus_code == MEDIA_BUS_FMT_SGBRG8_1X8);
  97         case V4L2_PIX_FMT_SGRBG8:
  98                 return (mbus_code == MEDIA_BUS_FMT_SGRBG8_1X8);
  99         case V4L2_PIX_FMT_SRGGB8:
 100                 return (mbus_code == MEDIA_BUS_FMT_SRGGB8_1X8);
 101         case V4L2_PIX_FMT_SBGGR10:
 102                 return (mbus_code == MEDIA_BUS_FMT_SBGGR10_1X10);
 103         case V4L2_PIX_FMT_SGBRG10:
 104                 return (mbus_code == MEDIA_BUS_FMT_SGBRG10_1X10);
 105         case V4L2_PIX_FMT_SGRBG10:
 106                 return (mbus_code == MEDIA_BUS_FMT_SGRBG10_1X10);
 107         case V4L2_PIX_FMT_SRGGB10:
 108                 return (mbus_code == MEDIA_BUS_FMT_SRGGB10_1X10);
 109         case V4L2_PIX_FMT_SBGGR12:
 110                 return (mbus_code == MEDIA_BUS_FMT_SBGGR12_1X12);
 111         case V4L2_PIX_FMT_SGBRG12:
 112                 return (mbus_code == MEDIA_BUS_FMT_SGBRG12_1X12);
 113         case V4L2_PIX_FMT_SGRBG12:
 114                 return (mbus_code == MEDIA_BUS_FMT_SGRBG12_1X12);
 115         case V4L2_PIX_FMT_SRGGB12:
 116                 return (mbus_code == MEDIA_BUS_FMT_SRGGB12_1X12);
 117
 118         case V4L2_PIX_FMT_YUYV:
 119                 return (mbus_code == MEDIA_BUS_FMT_YUYV8_2X8);
 120         case V4L2_PIX_FMT_YVYU:
 121                 return (mbus_code == MEDIA_BUS_FMT_YVYU8_2X8);
 122         case V4L2_PIX_FMT_UYVY:
 123                 return (mbus_code == MEDIA_BUS_FMT_UYVY8_2X8);
 124         case V4L2_PIX_FMT_VYUY:
 125                 return (mbus_code == MEDIA_BUS_FMT_VYUY8_2X8);
 126
 127         case V4L2_PIX_FMT_HM12:
 128         case V4L2_PIX_FMT_NV12:
 129         case V4L2_PIX_FMT_NV21:
 130         case V4L2_PIX_FMT_NV16:
 131         case V4L2_PIX_FMT_NV61:
 132         case V4L2_PIX_FMT_YUV420:
 133         case V4L2_PIX_FMT_YVU420:
 134         case V4L2_PIX_FMT_YUV422P:
 135                 switch (mbus_code) {
 136                 case MEDIA_BUS_FMT_UYVY8_2X8:
 137                 case MEDIA_BUS_FMT_VYUY8_2X8:
 138                 case MEDIA_BUS_FMT_YUYV8_2X8:
 139                 case MEDIA_BUS_FMT_YVYU8_2X8:
 140                         return true;
 141                 default:
 142                         dev_dbg(sdev->dev, "Unsupported mbus code: 0x%x\n",
 143                                 mbus_code);
 144                         break;
 145                 }
 146                 break;
 147
 148         case V4L2_PIX_FMT_RGB565:
 149                 return (mbus_code == MEDIA_BUS_FMT_RGB565_2X8_LE);
 150         case V4L2_PIX_FMT_RGB565X:
 151                 return (mbus_code == MEDIA_BUS_FMT_RGB565_2X8_BE);
 152
 153         default:
 154                 dev_dbg(sdev->dev, "Unsupported pixformat: 0x%x\n", pixformat);
 155                 break;
 156         }
 157
 158         return false;
 159 }
 160
 161 int sun6i_csi_set_power(struct sun6i_csi *csi, bool enable)
 162 {
 163         struct sun6i_csi_dev *sdev = sun6i_csi_to_dev(csi);
 164         struct device *dev = sdev->dev;
 165         struct regmap *regmap = sdev->regmap;
 166         int ret;
 167
 168         if (!enable) {
 169                 regmap_update_bits(regmap, CSI_EN_REG, CSI_EN_CSI_EN, 0);
 170
 171                 clk_disable_unprepare(sdev->clk_ram);
 172                 if (of_device_is_compatible(dev->of_node,
 173                                             "allwinner,sun50i-a64-csi"))
 174                         clk_rate_exclusive_put(sdev->clk_mod);
 175                 clk_disable_unprepare(sdev->clk_mod);
 176                 reset_control_assert(sdev->rstc_bus);
 177                 return 0;
 178         }
 179
 180         ret = clk_prepare_enable(sdev->clk_mod);
 181         if (ret) {
 182                 dev_err(sdev->dev, "Enable csi clk err %d\n", ret);
 183                 return ret;
 184         }
 185
 186         if (of_device_is_compatible(dev->of_node, "allwinner,sun50i-a64-csi"))
 187                 clk_set_rate_exclusive(sdev->clk_mod, 300000000);
 188
 189         ret = clk_prepare_enable(sdev->clk_ram);
 190         if (ret) {
 191                 dev_err(sdev->dev, "Enable clk_dram_csi clk err %d\n", ret);
 192                 goto clk_mod_disable;
 193         }
 194
 195         ret = reset_control_deassert(sdev->rstc_bus);
 196         if (ret) {
 197                 dev_err(sdev->dev, "reset err %d\n", ret);
 198                 goto clk_ram_disable;
 199         }
 200
 201         regmap_update_bits(regmap, CSI_EN_REG, CSI_EN_CSI_EN, CSI_EN_CSI_EN);
 202
 203         return 0;
 204
 205 clk_ram_disable:
 206         clk_disable_unprepare(sdev->clk_ram);
 207 clk_mod_disable:
 208         if (of_device_is_compatible(dev->of_node, "allwinner,sun50i-a64-csi"))
 209                 clk_rate_exclusive_put(sdev->clk_mod);
 210         clk_disable_unprepare(sdev->clk_mod);
 211         return ret;
 212 }
 213
 214 static enum csi_input_fmt get_csi_input_format(struct sun6i_csi_dev *sdev,
 215                                                u32 mbus_code, u32 pixformat)
 216 {
 217         /* non-YUV */
 218         if ((mbus_code & 0xF000) != 0x2000)
 219                 return CSI_INPUT_FORMAT_RAW;
 220
 221         switch (pixformat) {
 222         case V4L2_PIX_FMT_YUYV:
 223         case V4L2_PIX_FMT_YVYU:
 224         case V4L2_PIX_FMT_UYVY:
 225         case V4L2_PIX_FMT_VYUY:
 226                 return CSI_INPUT_FORMAT_RAW;
 227         default:
 228                 break;
 229         }
 230
 231         /* not support YUV420 input format yet */
 232         dev_dbg(sdev->dev, "Select YUV422 as default input format of CSI.\n");
 233         return CSI_INPUT_FORMAT_YUV422;
 234 }
 235
 236 static enum csi_output_fmt get_csi_output_format(struct sun6i_csi_dev *sdev,
 237                                                  u32 pixformat, u32 field)
 238 {
 239         bool buf_interlaced = false;
 240
 241         if (field == V4L2_FIELD_INTERLACED
 242             || field == V4L2_FIELD_INTERLACED_TB
 243             || field == V4L2_FIELD_INTERLACED_BT)
 244                 buf_interlaced = true;
 245
 246         switch (pixformat) {
 247         case V4L2_PIX_FMT_SBGGR8:
 248         case V4L2_PIX_FMT_SGBRG8:
 249         case V4L2_PIX_FMT_SGRBG8:
 250         case V4L2_PIX_FMT_SRGGB8:
 251                 return buf_interlaced ? CSI_FRAME_RAW_8 : CSI_FIELD_RAW_8;
 252         case V4L2_PIX_FMT_SBGGR10:
 253         case V4L2_PIX_FMT_SGBRG10:
 254         case V4L2_PIX_FMT_SGRBG10:
 255         case V4L2_PIX_FMT_SRGGB10:
 256                 return buf_interlaced ? CSI_FRAME_RAW_10 : CSI_FIELD_RAW_10;
 257         case V4L2_PIX_FMT_SBGGR12:
 258         case V4L2_PIX_FMT_SGBRG12:
 259         case V4L2_PIX_FMT_SGRBG12:
 260         case V4L2_PIX_FMT_SRGGB12:
 261                 return buf_interlaced ? CSI_FRAME_RAW_12 : CSI_FIELD_RAW_12;
 262
 263         case V4L2_PIX_FMT_YUYV:
 264         case V4L2_PIX_FMT_YVYU:
 265         case V4L2_PIX_FMT_UYVY:
 266         case V4L2_PIX_FMT_VYUY:
 267                 return buf_interlaced ? CSI_FRAME_RAW_8 : CSI_FIELD_RAW_8;
 268
 269         case V4L2_PIX_FMT_HM12:
 270                 return buf_interlaced ? CSI_FRAME_MB_YUV420 :
 271                                         CSI_FIELD_MB_YUV420;
 272         case V4L2_PIX_FMT_NV12:
 273         case V4L2_PIX_FMT_NV21:
 274                 return buf_interlaced ? CSI_FRAME_UV_CB_YUV420 :
 275                                         CSI_FIELD_UV_CB_YUV420;
 276         case V4L2_PIX_FMT_YUV420:
 277         case V4L2_PIX_FMT_YVU420:
 278                 return buf_interlaced ? CSI_FRAME_PLANAR_YUV420 :
 279                                         CSI_FIELD_PLANAR_YUV420;
 280         case V4L2_PIX_FMT_NV16:
 281         case V4L2_PIX_FMT_NV61:
 282                 return buf_interlaced ? CSI_FRAME_UV_CB_YUV422 :
 283                                         CSI_FIELD_UV_CB_YUV422;
 284         case V4L2_PIX_FMT_YUV422P:
 285                 return buf_interlaced ? CSI_FRAME_PLANAR_YUV422 :
 286                                         CSI_FIELD_PLANAR_YUV422;
 287
 288         case V4L2_PIX_FMT_RGB565:
 289         case V4L2_PIX_FMT_RGB565X:
 290                 return buf_interlaced ? CSI_FRAME_RGB565 : CSI_FIELD_RGB565;
 291
 292         default:
 293                 dev_warn(sdev->dev, "Unsupported pixformat: 0x%x\n", pixformat);
 294                 break;
 295         }
 296
 297         return CSI_FIELD_RAW_8;
 298 }
 299
 300 static enum csi_input_seq get_csi_input_seq(struct sun6i_csi_dev *sdev,
 301                                             u32 mbus_code, u32 pixformat)
 302 {
 303         /* Input sequence does not apply to non-YUV formats */
 304         if ((mbus_code & 0xF000) != 0x2000)
 305                 return 0;
 306
 307         switch (pixformat) {
 308         case V4L2_PIX_FMT_HM12:
 309         case V4L2_PIX_FMT_NV12:
 310         case V4L2_PIX_FMT_NV16:
 311         case V4L2_PIX_FMT_YUV420:
 312         case V4L2_PIX_FMT_YUV422P:
 313                 switch (mbus_code) {
 314                 case MEDIA_BUS_FMT_UYVY8_2X8:
 315                 case MEDIA_BUS_FMT_UYVY8_1X16:
 316                         return CSI_INPUT_SEQ_UYVY;
 317                 case MEDIA_BUS_FMT_VYUY8_2X8:
 318                 case MEDIA_BUS_FMT_VYUY8_1X16:
 319                         return CSI_INPUT_SEQ_VYUY;
 320                 case MEDIA_BUS_FMT_YUYV8_2X8:
 321                 case MEDIA_BUS_FMT_YUYV8_1X16:
 322                         return CSI_INPUT_SEQ_YUYV;
 323                 case MEDIA_BUS_FMT_YVYU8_1X16:
 324                 case MEDIA_BUS_FMT_YVYU8_2X8:
 325                         return CSI_INPUT_SEQ_YVYU;
 326                 default:
 327                         dev_warn(sdev->dev, "Unsupported mbus code: 0x%x\n",
 328                                  mbus_code);
 329                         break;
 330                 }
 331                 break;
 332         case V4L2_PIX_FMT_NV21:
 333         case V4L2_PIX_FMT_NV61:
 334         case V4L2_PIX_FMT_YVU420:
 335                 switch (mbus_code) {
 336                 case MEDIA_BUS_FMT_UYVY8_2X8:
 337                 case MEDIA_BUS_FMT_UYVY8_1X16:
 338                         return CSI_INPUT_SEQ_VYUY;
 339                 case MEDIA_BUS_FMT_VYUY8_2X8:
 340                 case MEDIA_BUS_FMT_VYUY8_1X16:
 341                         return CSI_INPUT_SEQ_UYVY;
 342                 case MEDIA_BUS_FMT_YUYV8_2X8:
 343                 case MEDIA_BUS_FMT_YUYV8_1X16:
 344                         return CSI_INPUT_SEQ_YVYU;
 345                 case MEDIA_BUS_FMT_YVYU8_1X16:
 346                 case MEDIA_BUS_FMT_YVYU8_2X8:
 347                         return CSI_INPUT_SEQ_YUYV;
 348                 default:
 349                         dev_warn(sdev->dev, "Unsupported mbus code: 0x%x\n",
 350                                  mbus_code);
 351                         break;
 352                 }
 353                 break;
 354
 355         case V4L2_PIX_FMT_YUYV:
 356                 return CSI_INPUT_SEQ_YUYV;
 357
 358         default:
 359                 dev_warn(sdev->dev, "Unsupported pixformat: 0x%x, defaulting to YUYV\n",
 360                          pixformat);
 361                 break;
 362         }
 363
 364         return CSI_INPUT_SEQ_YUYV;
 365 }
 366
 367 static void sun6i_csi_setup_bus(struct sun6i_csi_dev *sdev)
 368 {
 369         struct v4l2_fwnode_endpoint *endpoint = &sdev->csi.v4l2_ep;
 370         struct sun6i_csi *csi = &sdev->csi;
 371         unsigned char bus_width;
 372         u32 flags;
 373         u32 cfg;
 374         bool input_interlaced = false;
 375
 376         if (csi->config.field == V4L2_FIELD_INTERLACED
 377             || csi->config.field == V4L2_FIELD_INTERLACED_TB
 378             || csi->config.field == V4L2_FIELD_INTERLACED_BT)
 379                 input_interlaced = true;
 380
 381         bus_width = endpoint->bus.parallel.bus_width;
 382
 383         regmap_read(sdev->regmap, CSI_IF_CFG_REG, &cfg);
 384
 385         cfg &= ~(CSI_IF_CFG_CSI_IF_MASK | CSI_IF_CFG_MIPI_IF_MASK |
 386                  CSI_IF_CFG_IF_DATA_WIDTH_MASK |
 387                  CSI_IF_CFG_CLK_POL_MASK | CSI_IF_CFG_VREF_POL_MASK |
 388                  CSI_IF_CFG_HREF_POL_MASK | CSI_IF_CFG_FIELD_MASK |
 389                  CSI_IF_CFG_SRC_TYPE_MASK);
 390
 391         if (input_interlaced)
 392                 cfg |= CSI_IF_CFG_SRC_TYPE_INTERLACED;
 393         else
 394                 cfg |= CSI_IF_CFG_SRC_TYPE_PROGRESSED;
 395
 396         switch (endpoint->bus_type) {
 397         case V4L2_MBUS_PARALLEL:
 398                 cfg |= CSI_IF_CFG_MIPI_IF_CSI;
 399
 400                 flags = endpoint->bus.parallel.flags;
 401
 402                 cfg |= (bus_width == 16) ? CSI_IF_CFG_CSI_IF_YUV422_16BIT :
 403                                            CSI_IF_CFG_CSI_IF_YUV422_INTLV;
 404
 405                 if (flags & V4L2_MBUS_FIELD_EVEN_LOW)
 406                         cfg |= CSI_IF_CFG_FIELD_POSITIVE;
 407
 408                 if (flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
 409                         cfg |= CSI_IF_CFG_VREF_POL_POSITIVE;
 410                 if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
 411                         cfg |= CSI_IF_CFG_HREF_POL_POSITIVE;
 412
 413                 if (flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
 414                         cfg |= CSI_IF_CFG_CLK_POL_FALLING_EDGE;
 415                 break;
 416         case V4L2_MBUS_BT656:
 417                 cfg |= CSI_IF_CFG_MIPI_IF_CSI;
 418
 419                 flags = endpoint->bus.parallel.flags;
 420
 421                 cfg |= (bus_width == 16) ? CSI_IF_CFG_CSI_IF_BT1120 :
 422                                            CSI_IF_CFG_CSI_IF_BT656;
 423
 424                 if (flags & V4L2_MBUS_FIELD_EVEN_LOW)
 425                         cfg |= CSI_IF_CFG_FIELD_POSITIVE;
 426
 427                 if (flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)
 428                         cfg |= CSI_IF_CFG_CLK_POL_FALLING_EDGE;
 429                 break;
 430         default:
 431                 dev_warn(sdev->dev, "Unsupported bus type: %d\n",
 432                          endpoint->bus_type);
 433                 break;
 434         }
 435
 436         switch (bus_width) {
 437         case 8:
 438                 cfg |= CSI_IF_CFG_IF_DATA_WIDTH_8BIT;
 439                 break;
 440         case 10:
 441                 cfg |= CSI_IF_CFG_IF_DATA_WIDTH_10BIT;
 442                 break;
 443         case 12:
 444                 cfg |= CSI_IF_CFG_IF_DATA_WIDTH_12BIT;
 445                 break;
 446         case 16: /* No need to configure DATA_WIDTH for 16bit */
 447                 break;
 448         default:
 449                 dev_warn(sdev->dev, "Unsupported bus width: %u\n", bus_width);
 450                 break;
 451         }
 452
 453         regmap_write(sdev->regmap, CSI_IF_CFG_REG, cfg);
 454 }
 455
 456 static void sun6i_csi_set_format(struct sun6i_csi_dev *sdev)
 457 {
 458         struct sun6i_csi *csi = &sdev->csi;
 459         u32 cfg;
 460         u32 val;
 461
 462         regmap_read(sdev->regmap, CSI_CH_CFG_REG, &cfg);
 463
 464         cfg &= ~(CSI_CH_CFG_INPUT_FMT_MASK |
 465                  CSI_CH_CFG_OUTPUT_FMT_MASK | CSI_CH_CFG_VFLIP_EN |
 466                  CSI_CH_CFG_HFLIP_EN | CSI_CH_CFG_FIELD_SEL_MASK |
 467                  CSI_CH_CFG_INPUT_SEQ_MASK);
 468
 469         val = get_csi_input_format(sdev, csi->config.code,
 470                                    csi->config.pixelformat);
 471         cfg |= CSI_CH_CFG_INPUT_FMT(val);
 472
 473         val = get_csi_output_format(sdev, csi->config.pixelformat,
 474                                     csi->config.field);
 475         cfg |= CSI_CH_CFG_OUTPUT_FMT(val);
 476
 477         val = get_csi_input_seq(sdev, csi->config.code,
 478                                 csi->config.pixelformat);
 479         cfg |= CSI_CH_CFG_INPUT_SEQ(val);
 480
 481         if (csi->config.field == V4L2_FIELD_TOP)
 482                 cfg |= CSI_CH_CFG_FIELD_SEL_FIELD0;
 483         else if (csi->config.field == V4L2_FIELD_BOTTOM)
 484                 cfg |= CSI_CH_CFG_FIELD_SEL_FIELD1;
 485         else
 486                 cfg |= CSI_CH_CFG_FIELD_SEL_BOTH;
 487
 488         regmap_write(sdev->regmap, CSI_CH_CFG_REG, cfg);
 489 }
 490
 491 static void sun6i_csi_set_window(struct sun6i_csi_dev *sdev)
 492 {
 493         struct sun6i_csi_config *config = &sdev->csi.config;
 494         u32 bytesperline_y;
 495         u32 bytesperline_c;
 496         int *planar_offset = sdev->planar_offset;
 497         u32 width = config->width;
 498         u32 height = config->height;
 499         u32 hor_len = width;
 500
 501         switch (config->pixelformat) {
 502         case V4L2_PIX_FMT_YUYV:
 503         case V4L2_PIX_FMT_YVYU:
 504         case V4L2_PIX_FMT_UYVY:
 505         case V4L2_PIX_FMT_VYUY:
 506                 dev_dbg(sdev->dev,
 507                         "Horizontal length should be 2 times of width for packed YUV formats!\n");
 508                 hor_len = width * 2;
 509                 break;
 510         default:
 511                 break;
 512         }
 513
 514         regmap_write(sdev->regmap, CSI_CH_HSIZE_REG,
 515                      CSI_CH_HSIZE_HOR_LEN(hor_len) |
 516                      CSI_CH_HSIZE_HOR_START(0));
 517         regmap_write(sdev->regmap, CSI_CH_VSIZE_REG,
 518                      CSI_CH_VSIZE_VER_LEN(height) |
 519                      CSI_CH_VSIZE_VER_START(0));
 520
 521         planar_offset[0] = 0;
 522         switch (config->pixelformat) {
 523         case V4L2_PIX_FMT_HM12:
 524         case V4L2_PIX_FMT_NV12:
 525         case V4L2_PIX_FMT_NV21:
 526         case V4L2_PIX_FMT_NV16:
 527         case V4L2_PIX_FMT_NV61:
 528                 bytesperline_y = width;
 529                 bytesperline_c = width;
 530                 planar_offset[1] = bytesperline_y * height;
 531                 planar_offset[2] = -1;
 532                 break;
 533         case V4L2_PIX_FMT_YUV420:
 534         case V4L2_PIX_FMT_YVU420:
 535                 bytesperline_y = width;
 536                 bytesperline_c = width / 2;
 537                 planar_offset[1] = bytesperline_y * height;
 538                 planar_offset[2] = planar_offset[1] +
 539                                 bytesperline_c * height / 2;
 540                 break;
 541         case V4L2_PIX_FMT_YUV422P:
 542                 bytesperline_y = width;
 543                 bytesperline_c = width / 2;
 544                 planar_offset[1] = bytesperline_y * height;
 545                 planar_offset[2] = planar_offset[1] +
 546                                 bytesperline_c * height;
 547                 break;
 548         default: /* raw */
 549                 dev_dbg(sdev->dev,
 550                         "Calculating pixelformat(0x%x)'s bytesperline as a packed format\n",
 551                         config->pixelformat);
 552                 bytesperline_y = (sun6i_csi_get_bpp(config->pixelformat) *
 553                                   config->width) / 8;
 554                 bytesperline_c = 0;
 555                 planar_offset[1] = -1;
 556                 planar_offset[2] = -1;
 557                 break;
 558         }
 559
 560         regmap_write(sdev->regmap, CSI_CH_BUF_LEN_REG,
 561                      CSI_CH_BUF_LEN_BUF_LEN_C(bytesperline_c) |
 562                      CSI_CH_BUF_LEN_BUF_LEN_Y(bytesperline_y));
 563 }
 564
 565 int sun6i_csi_update_config(struct sun6i_csi *csi,
 566                             struct sun6i_csi_config *config)
 567 {
 568         struct sun6i_csi_dev *sdev = sun6i_csi_to_dev(csi);
 569
 570         if (!config)
 571                 return -EINVAL;
 572
 573         memcpy(&csi->config, config, sizeof(csi->config));
 574
 575         sun6i_csi_setup_bus(sdev);
 576         sun6i_csi_set_format(sdev);
 577         sun6i_csi_set_window(sdev);
 578
 579         return 0;
 580 }
 581
 582 void sun6i_csi_update_buf_addr(struct sun6i_csi *csi, dma_addr_t addr)
 583 {
 584         struct sun6i_csi_dev *sdev = sun6i_csi_to_dev(csi);
 585
 586         regmap_write(sdev->regmap, CSI_CH_F0_BUFA_REG,
 587                      (addr + sdev->planar_offset[0]) >> 2);
 588         if (sdev->planar_offset[1] != -1)
 589                 regmap_write(sdev->regmap, CSI_CH_F1_BUFA_REG,
 590                              (addr + sdev->planar_offset[1]) >> 2);
 591         if (sdev->planar_offset[2] != -1)
 592                 regmap_write(sdev->regmap, CSI_CH_F2_BUFA_REG,
 593                              (addr + sdev->planar_offset[2]) >> 2);
 594 }
 595
 596 void sun6i_csi_set_stream(struct sun6i_csi *csi, bool enable)
 597 {
 598         struct sun6i_csi_dev *sdev = sun6i_csi_to_dev(csi);
 599         struct regmap *regmap = sdev->regmap;
 600
 601         if (!enable) {
 602                 regmap_update_bits(regmap, CSI_CAP_REG, CSI_CAP_CH0_VCAP_ON, 0);
 603                 regmap_write(regmap, CSI_CH_INT_EN_REG, 0);
 604                 return;
 605         }
 606
 607         regmap_write(regmap, CSI_CH_INT_STA_REG, 0xFF);
 608         regmap_write(regmap, CSI_CH_INT_EN_REG,
 609                      CSI_CH_INT_EN_HB_OF_INT_EN |
 610                      CSI_CH_INT_EN_FIFO2_OF_INT_EN |
 611                      CSI_CH_INT_EN_FIFO1_OF_INT_EN |
 612                      CSI_CH_INT_EN_FIFO0_OF_INT_EN |
 613                      CSI_CH_INT_EN_FD_INT_EN |
 614                      CSI_CH_INT_EN_CD_INT_EN);
 615
 616         regmap_update_bits(regmap, CSI_CAP_REG, CSI_CAP_CH0_VCAP_ON,
 617                            CSI_CAP_CH0_VCAP_ON);
 618 }
 619
 620 /* -----------------------------------------------------------------------------
 621  * Media Controller and V4L2
 622  */
 623 static int sun6i_csi_link_entity(struct sun6i_csi *csi,
 624                                  struct media_entity *entity,
 625                                  struct fwnode_handle *fwnode)
 626 {
 627         struct media_entity *sink;
 628         struct media_pad *sink_pad;
 629         int src_pad_index;
 630         int ret;
 631
 632         ret = media_entity_get_fwnode_pad(entity, fwnode, MEDIA_PAD_FL_SOURCE);
 633         if (ret < 0) {
 634                 dev_err(csi->dev, "%s: no source pad in external entity %s\n",
 635                         __func__, entity->name);
 636                 return -EINVAL;
 637         }
 638
 639         src_pad_index = ret;
 640
 641         sink = &csi->video.vdev.entity;
 642         sink_pad = &csi->video.pad;
 643
 644         dev_dbg(csi->dev, "creating %s:%u -> %s:%u link\n",
 645                 entity->name, src_pad_index, sink->name, sink_pad->index);
 646         ret = media_create_pad_link(entity, src_pad_index, sink,
 647                                     sink_pad->index,
 648                                     MEDIA_LNK_FL_ENABLED |
 649                                     MEDIA_LNK_FL_IMMUTABLE);
 650         if (ret < 0) {
 651                 dev_err(csi->dev, "failed to create %s:%u -> %s:%u link\n",
 652                         entity->name, src_pad_index,
 653                         sink->name, sink_pad->index);
 654                 return ret;
 655         }
 656
 657         return 0;
 658 }
 659
 660 static int sun6i_subdev_notify_complete(struct v4l2_async_notifier *notifier)
 661 {
 662         struct sun6i_csi *csi = container_of(notifier, struct sun6i_csi,
 663                                              notifier);
 664         struct v4l2_device *v4l2_dev = &csi->v4l2_dev;
 665         struct v4l2_subdev *sd;
 666         int ret;
 667
 668         dev_dbg(csi->dev, "notify complete, all subdevs registered\n");
 669
 670         sd = list_first_entry(&v4l2_dev->subdevs, struct v4l2_subdev, list);
 671         if (!sd)
 672                 return -EINVAL;
 673
 674         ret = sun6i_csi_link_entity(csi, &sd->entity, sd->fwnode);
 675         if (ret < 0)
 676                 return ret;
 677
 678         ret = v4l2_device_register_subdev_nodes(&csi->v4l2_dev);
 679         if (ret < 0)
 680                 return ret;
 681
 682         return media_device_register(&csi->media_dev);
 683 }
 684
 685 static const struct v4l2_async_notifier_operations sun6i_csi_async_ops = {
 686         .complete = sun6i_subdev_notify_complete,
 687 };
 688
 689 static int sun6i_csi_fwnode_parse(struct device *dev,
 690                                   struct v4l2_fwnode_endpoint *vep,
 691                                   struct v4l2_async_subdev *asd)
 692 {
 693         struct sun6i_csi *csi = dev_get_drvdata(dev);
 694
 695         if (vep->base.port || vep->base.id) {
 696                 dev_warn(dev, "Only support a single port with one endpoint\n");
 697                 return -ENOTCONN;
 698         }
 699
 700         switch (vep->bus_type) {
 701         case V4L2_MBUS_PARALLEL:
 702         case V4L2_MBUS_BT656:
 703                 csi->v4l2_ep = *vep;
 704                 return 0;
 705         default:
 706                 dev_err(dev, "Unsupported media bus type\n");
 707                 return -ENOTCONN;
 708         }
 709 }
 710
 711 static void sun6i_csi_v4l2_cleanup(struct sun6i_csi *csi)
 712 {
 713         media_device_unregister(&csi->media_dev);
 714         v4l2_async_notifier_unregister(&csi->notifier);
 715         v4l2_async_notifier_cleanup(&csi->notifier);
 716         sun6i_video_cleanup(&csi->video);
 717         v4l2_device_unregister(&csi->v4l2_dev);
 718         v4l2_ctrl_handler_free(&csi->ctrl_handler);
 719         media_device_cleanup(&csi->media_dev);
 720 }
 721
 722 static int sun6i_csi_v4l2_init(struct sun6i_csi *csi)
 723 {
 724         int ret;
 725
 726         csi->media_dev.dev = csi->dev;
 727         strscpy(csi->media_dev.model, "Allwinner Video Capture Device",
 728                 sizeof(csi->media_dev.model));
 729         csi->media_dev.hw_revision = 0;
 730
 731         media_device_init(&csi->media_dev);
 732         v4l2_async_notifier_init(&csi->notifier);
 733
 734         ret = v4l2_ctrl_handler_init(&csi->ctrl_handler, 0);
 735         if (ret) {
 736                 dev_err(csi->dev, "V4L2 controls handler init failed (%d)\n",
 737                         ret);
 738                 goto clean_media;
 739         }
 740
 741         csi->v4l2_dev.mdev = &csi->media_dev;
 742         csi->v4l2_dev.ctrl_handler = &csi->ctrl_handler;
 743         ret = v4l2_device_register(csi->dev, &csi->v4l2_dev);
 744         if (ret) {
 745                 dev_err(csi->dev, "V4L2 device registration failed (%d)\n",
 746                         ret);
 747                 goto free_ctrl;
 748         }
 749
 750         ret = sun6i_video_init(&csi->video, csi, "sun6i-csi");
 751         if (ret)
 752                 goto unreg_v4l2;
 753
 754         ret = v4l2_async_notifier_parse_fwnode_endpoints(csi->dev,
 755                                                          &csi->notifier,
 756                                                          sizeof(struct v4l2_async_subdev),
 757                                                          sun6i_csi_fwnode_parse);
 758         if (ret)
 759                 goto clean_video;
 760
 761         csi->notifier.ops = &sun6i_csi_async_ops;
 762
 763         ret = v4l2_async_notifier_register(&csi->v4l2_dev, &csi->notifier);
 764         if (ret) {
 765                 dev_err(csi->dev, "notifier registration failed\n");
 766                 goto clean_video;
 767         }
 768
 769         return 0;
 770
 771 clean_video:
 772         sun6i_video_cleanup(&csi->video);
 773 unreg_v4l2:
 774         v4l2_device_unregister(&csi->v4l2_dev);
 775 free_ctrl:
 776         v4l2_ctrl_handler_free(&csi->ctrl_handler);
 777 clean_media:
 778         v4l2_async_notifier_cleanup(&csi->notifier);
 779         media_device_cleanup(&csi->media_dev);
 780
 781         return ret;
 782 }
 783
 784 /* -----------------------------------------------------------------------------
 785  * Resources and IRQ
 786  */
 787 static irqreturn_t sun6i_csi_isr(int irq, void *dev_id)
 788 {
 789         struct sun6i_csi_dev *sdev = (struct sun6i_csi_dev *)dev_id;
 790         struct regmap *regmap = sdev->regmap;
 791         u32 status;
 792
 793         regmap_read(regmap, CSI_CH_INT_STA_REG, &status);
 794
 795         if (!(status & 0xFF))
 796                 return IRQ_NONE;
 797
 798         if ((status & CSI_CH_INT_STA_FIFO0_OF_PD) ||
 799             (status & CSI_CH_INT_STA_FIFO1_OF_PD) ||
 800             (status & CSI_CH_INT_STA_FIFO2_OF_PD) ||
 801             (status & CSI_CH_INT_STA_HB_OF_PD)) {
 802                 regmap_write(regmap, CSI_CH_INT_STA_REG, status);
 803                 regmap_update_bits(regmap, CSI_EN_REG, CSI_EN_CSI_EN, 0);
 804                 regmap_update_bits(regmap, CSI_EN_REG, CSI_EN_CSI_EN,
 805                                    CSI_EN_CSI_EN);
 806                 return IRQ_HANDLED;
 807         }
 808
 809         if (status & CSI_CH_INT_STA_FD_PD)
 810                 sun6i_video_frame_done(&sdev->csi.video);
 811
 812         regmap_write(regmap, CSI_CH_INT_STA_REG, status);
 813
 814         return IRQ_HANDLED;
 815 }
 816
 817 static const struct regmap_config sun6i_csi_regmap_config = {
 818         .reg_bits       = 32,
 819         .reg_stride     = 4,
 820         .val_bits       = 32,
 821         .max_register   = 0x9c,
 822 };
 823
 824 static int sun6i_csi_resource_request(struct sun6i_csi_dev *sdev,
 825                                       struct platform_device *pdev)
 826 {
 827         struct resource *res;
 828         void __iomem *io_base;
 829         int ret;
 830         int irq;
 831
 832         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 833         io_base = devm_ioremap_resource(&pdev->dev, res);
 834         if (IS_ERR(io_base))
 835                 return PTR_ERR(io_base);
 836
 837         sdev->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "bus", io_base,
 838                                                  &sun6i_csi_regmap_config);
 839         if (IS_ERR(sdev->regmap)) {
 840                 dev_err(&pdev->dev, "Failed to init register map\n");
 841                 return PTR_ERR(sdev->regmap);
 842         }
 843
 844         sdev->clk_mod = devm_clk_get(&pdev->dev, "mod");
 845         if (IS_ERR(sdev->clk_mod)) {
 846                 dev_err(&pdev->dev, "Unable to acquire csi clock\n");
 847                 return PTR_ERR(sdev->clk_mod);
 848         }
 849
 850         sdev->clk_ram = devm_clk_get(&pdev->dev, "ram");
 851         if (IS_ERR(sdev->clk_ram)) {
 852                 dev_err(&pdev->dev, "Unable to acquire dram-csi clock\n");
 853                 return PTR_ERR(sdev->clk_ram);
 854         }
 855
 856         sdev->rstc_bus = devm_reset_control_get_shared(&pdev->dev, NULL);
 857         if (IS_ERR(sdev->rstc_bus)) {
 858                 dev_err(&pdev->dev, "Cannot get reset controller\n");
 859                 return PTR_ERR(sdev->rstc_bus);
 860         }
 861
 862         irq = platform_get_irq(pdev, 0);
 863         if (irq < 0) {
 864                 dev_err(&pdev->dev, "No csi IRQ specified\n");
 865                 ret = -ENXIO;
 866                 return ret;
 867         }
 868
 869         ret = devm_request_irq(&pdev->dev, irq, sun6i_csi_isr, 0, MODULE_NAME,
 870                                sdev);
 871         if (ret) {
 872                 dev_err(&pdev->dev, "Cannot request csi IRQ\n");
 873                 return ret;
 874         }
 875
 876         return 0;
 877 }
 878
 879 /*
 880  * PHYS_OFFSET isn't available on all architectures. In order to
 881  * accommodate for COMPILE_TEST, let's define it to something dumb.
 882  */
 883 #if defined(CONFIG_COMPILE_TEST) && !defined(PHYS_OFFSET)
 884 #define PHYS_OFFSET 0
 885 #endif
 886
 887 static int sun6i_csi_probe(struct platform_device *pdev)
 888 {
 889         struct sun6i_csi_dev *sdev;
 890         int ret;
 891
 892         sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
 893         if (!sdev)
 894                 return -ENOMEM;
 895
 896         sdev->dev = &pdev->dev;
 897         /* The DMA bus has the memory mapped at 0 */
 898         sdev->dev->dma_pfn_offset = PHYS_OFFSET >> PAGE_SHIFT;
 899
 900         ret = sun6i_csi_resource_request(sdev, pdev);
 901         if (ret)
 902                 return ret;
 903
 904         platform_set_drvdata(pdev, sdev);
 905
 906         sdev->csi.dev = &pdev->dev;
 907         return sun6i_csi_v4l2_init(&sdev->csi);
 908 }
 909
 910 static int sun6i_csi_remove(struct platform_device *pdev)
 911 {
 912         struct sun6i_csi_dev *sdev = platform_get_drvdata(pdev);
 913
 914         sun6i_csi_v4l2_cleanup(&sdev->csi);
 915
 916         return 0;
 917 }
 918
 919 static const struct of_device_id sun6i_csi_of_match[] = {
 920         { .compatible = "allwinner,sun6i-a31-csi", },
 921         { .compatible = "allwinner,sun8i-h3-csi", },
 922         { .compatible = "allwinner,sun8i-v3s-csi", },
 923         { .compatible = "allwinner,sun50i-a64-csi", },
 924         {},
 925 };
 926 MODULE_DEVICE_TABLE(of, sun6i_csi_of_match);
 927
 928 static struct platform_driver sun6i_csi_platform_driver = {
 929         .probe = sun6i_csi_probe,
 930         .remove = sun6i_csi_remove,
 931         .driver = {
 932                 .name = MODULE_NAME,
 933                 .of_match_table = of_match_ptr(sun6i_csi_of_match),
 934         },
 935 };
 936 module_platform_driver(sun6i_csi_platform_driver);
 937
 938 MODULE_DESCRIPTION("Allwinner V3s Camera Sensor Interface driver");
 939 MODULE_AUTHOR("Yong Deng <yong.deng@magewell.com>");
 940 MODULE_LICENSE("GPL");