.. | .. |
---|
6 | 6 | #include <linux/of_platform.h> |
---|
7 | 7 | #include <linux/slab.h> |
---|
8 | 8 | #include "dev.h" |
---|
| 9 | +#include "hw.h" |
---|
9 | 10 | #include "isp_ispp.h" |
---|
10 | 11 | #include "regs.h" |
---|
11 | 12 | |
---|
.. | .. |
---|
18 | 19 | *flag = SW_REG_CACHE; |
---|
19 | 20 | if (dev->hw_dev->is_single || is_direct) { |
---|
20 | 21 | *flag = SW_REG_CACHE_SYNC; |
---|
| 22 | + if (dev->isp_ver == ISP_V32 && reg <= 0x200) |
---|
| 23 | + rv1106_sdmmc_get_lock(); |
---|
21 | 24 | writel(val, dev->hw_dev->base_addr + reg); |
---|
| 25 | + if (dev->isp_ver == ISP_V32 && reg <= 0x200) |
---|
| 26 | + rv1106_sdmmc_put_lock(); |
---|
| 27 | + } |
---|
| 28 | +} |
---|
| 29 | + |
---|
| 30 | +void rkisp_next_write(struct rkisp_device *dev, u32 reg, u32 val, bool is_direct) |
---|
| 31 | +{ |
---|
| 32 | + u32 offset = RKISP_ISP_SW_MAX_SIZE + reg; |
---|
| 33 | + u32 *mem = dev->sw_base_addr + offset; |
---|
| 34 | + u32 *flag = dev->sw_base_addr + offset + RKISP_ISP_SW_REG_SIZE; |
---|
| 35 | + |
---|
| 36 | + *mem = val; |
---|
| 37 | + *flag = SW_REG_CACHE; |
---|
| 38 | + if (dev->hw_dev->is_single || is_direct) { |
---|
| 39 | + *flag = SW_REG_CACHE_SYNC; |
---|
| 40 | + if (dev->hw_dev->unite == ISP_UNITE_ONE) |
---|
| 41 | + return; |
---|
| 42 | + writel(val, dev->hw_dev->base_next_addr + reg); |
---|
22 | 43 | } |
---|
23 | 44 | } |
---|
24 | 45 | |
---|
.. | .. |
---|
33 | 54 | return val; |
---|
34 | 55 | } |
---|
35 | 56 | |
---|
36 | | -u32 rkisp_read_reg_cache(struct rkisp_device *dev, u32 reg) |
---|
| 57 | +u32 rkisp_next_read(struct rkisp_device *dev, u32 reg, bool is_direct) |
---|
37 | 58 | { |
---|
38 | | - return *(u32 *)(dev->sw_base_addr + reg); |
---|
| 59 | + u32 val; |
---|
| 60 | + |
---|
| 61 | + if (dev->hw_dev->is_single || is_direct) |
---|
| 62 | + val = readl(dev->hw_dev->base_next_addr + reg); |
---|
| 63 | + else |
---|
| 64 | + val = *(u32 *)(dev->sw_base_addr + RKISP_ISP_SW_MAX_SIZE + reg); |
---|
| 65 | + return val; |
---|
39 | 66 | } |
---|
40 | 67 | |
---|
41 | 68 | void rkisp_set_bits(struct rkisp_device *dev, u32 reg, u32 mask, u32 val, bool is_direct) |
---|
.. | .. |
---|
45 | 72 | rkisp_write(dev, reg, val | tmp, is_direct); |
---|
46 | 73 | } |
---|
47 | 74 | |
---|
| 75 | +void rkisp_next_set_bits(struct rkisp_device *dev, u32 reg, u32 mask, u32 val, bool is_direct) |
---|
| 76 | +{ |
---|
| 77 | + u32 tmp = rkisp_next_read(dev, reg, is_direct) & ~mask; |
---|
| 78 | + |
---|
| 79 | + rkisp_next_write(dev, reg, val | tmp, is_direct); |
---|
| 80 | +} |
---|
| 81 | + |
---|
48 | 82 | void rkisp_clear_bits(struct rkisp_device *dev, u32 reg, u32 mask, bool is_direct) |
---|
49 | 83 | { |
---|
50 | 84 | u32 tmp = rkisp_read(dev, reg, is_direct); |
---|
.. | .. |
---|
52 | 86 | rkisp_write(dev, reg, tmp & ~mask, is_direct); |
---|
53 | 87 | } |
---|
54 | 88 | |
---|
| 89 | +void rkisp_next_clear_bits(struct rkisp_device *dev, u32 reg, u32 mask, bool is_direct) |
---|
| 90 | +{ |
---|
| 91 | + u32 tmp = rkisp_next_read(dev, reg, is_direct); |
---|
| 92 | + |
---|
| 93 | + rkisp_next_write(dev, reg, tmp & ~mask, is_direct); |
---|
| 94 | +} |
---|
| 95 | + |
---|
| 96 | +void rkisp_write_reg_cache(struct rkisp_device *dev, u32 reg, u32 val) |
---|
| 97 | +{ |
---|
| 98 | + u32 *mem = dev->sw_base_addr + reg; |
---|
| 99 | + |
---|
| 100 | + *mem = val; |
---|
| 101 | +} |
---|
| 102 | + |
---|
| 103 | +void rkisp_next_write_reg_cache(struct rkisp_device *dev, u32 reg, u32 val) |
---|
| 104 | +{ |
---|
| 105 | + u32 offset = RKISP_ISP_SW_MAX_SIZE + reg; |
---|
| 106 | + u32 *mem = dev->sw_base_addr + offset; |
---|
| 107 | + |
---|
| 108 | + *mem = val; |
---|
| 109 | +} |
---|
| 110 | + |
---|
| 111 | +u32 rkisp_read_reg_cache(struct rkisp_device *dev, u32 reg) |
---|
| 112 | +{ |
---|
| 113 | + return *(u32 *)(dev->sw_base_addr + reg); |
---|
| 114 | +} |
---|
| 115 | + |
---|
| 116 | +u32 rkisp_next_read_reg_cache(struct rkisp_device *dev, u32 reg) |
---|
| 117 | +{ |
---|
| 118 | + return *(u32 *)(dev->sw_base_addr + RKISP_ISP_SW_MAX_SIZE + reg); |
---|
| 119 | +} |
---|
| 120 | + |
---|
| 121 | +void rkisp_set_reg_cache_bits(struct rkisp_device *dev, u32 reg, u32 mask, u32 val) |
---|
| 122 | +{ |
---|
| 123 | + u32 tmp = rkisp_read_reg_cache(dev, reg) & ~mask; |
---|
| 124 | + |
---|
| 125 | + rkisp_write_reg_cache(dev, reg, val | tmp); |
---|
| 126 | +} |
---|
| 127 | + |
---|
| 128 | +void rkisp_next_set_reg_cache_bits(struct rkisp_device *dev, u32 reg, u32 mask, u32 val) |
---|
| 129 | +{ |
---|
| 130 | + u32 tmp = rkisp_next_read_reg_cache(dev, reg) & ~mask; |
---|
| 131 | + |
---|
| 132 | + rkisp_next_write_reg_cache(dev, reg, val | tmp); |
---|
| 133 | +} |
---|
| 134 | + |
---|
| 135 | +void rkisp_clear_reg_cache_bits(struct rkisp_device *dev, u32 reg, u32 mask) |
---|
| 136 | +{ |
---|
| 137 | + u32 tmp = rkisp_read_reg_cache(dev, reg); |
---|
| 138 | + |
---|
| 139 | + rkisp_write_reg_cache(dev, reg, tmp & ~mask); |
---|
| 140 | +} |
---|
| 141 | + |
---|
| 142 | +void rkisp_next_clear_reg_cache_bits(struct rkisp_device *dev, u32 reg, u32 mask) |
---|
| 143 | +{ |
---|
| 144 | + u32 tmp = rkisp_next_read_reg_cache(dev, reg); |
---|
| 145 | + |
---|
| 146 | + rkisp_next_write_reg_cache(dev, reg, tmp & ~mask); |
---|
| 147 | +} |
---|
| 148 | + |
---|
55 | 149 | void rkisp_update_regs(struct rkisp_device *dev, u32 start, u32 end) |
---|
56 | 150 | { |
---|
57 | | - void __iomem *base = dev->hw_dev->base_addr; |
---|
| 151 | + struct rkisp_hw_dev *hw = dev->hw_dev; |
---|
| 152 | + void __iomem *base = hw->base_addr; |
---|
58 | 153 | u32 i; |
---|
59 | 154 | |
---|
60 | 155 | if (end > RKISP_ISP_SW_REG_SIZE - 4) { |
---|
.. | .. |
---|
65 | 160 | u32 *val = dev->sw_base_addr + i; |
---|
66 | 161 | u32 *flag = dev->sw_base_addr + i + RKISP_ISP_SW_REG_SIZE; |
---|
67 | 162 | |
---|
68 | | - if (*flag == SW_REG_CACHE) |
---|
| 163 | + if (dev->procfs.mode & RKISP_PROCFS_FIL_SW) { |
---|
| 164 | + if (!((i >= ISP3X_ISP_ACQ_H_OFFS && i <= ISP3X_ISP_ACQ_V_SIZE) || |
---|
| 165 | + (i >= ISP3X_ISP_OUT_H_OFFS && i <= ISP3X_ISP_OUT_V_SIZE) || |
---|
| 166 | + (i >= ISP3X_DUAL_CROP_BASE && i < ISP3X_DUAL_CROP_FBC_V_SIZE_SHD) || |
---|
| 167 | + (i >= ISP3X_MAIN_RESIZE_BASE && i < ISP3X_CSI2RX_VERSION) || |
---|
| 168 | + (i >= CIF_ISP_IS_BASE && i < CIF_ISP_IS_V_SIZE_SHD))) |
---|
| 169 | + continue; |
---|
| 170 | + } |
---|
| 171 | + |
---|
| 172 | + if (hw->unite == ISP_UNITE_ONE && dev->unite_index == ISP_UNITE_RIGHT) { |
---|
| 173 | + val = dev->sw_base_addr + i + RKISP_ISP_SW_MAX_SIZE; |
---|
| 174 | + flag = dev->sw_base_addr + i + RKISP_ISP_SW_MAX_SIZE + RKISP_ISP_SW_REG_SIZE; |
---|
| 175 | + } |
---|
| 176 | + |
---|
| 177 | + if (*flag == SW_REG_CACHE) { |
---|
| 178 | + if ((i == ISP3X_MAIN_RESIZE_CTRL || |
---|
| 179 | + i == ISP32_BP_RESIZE_CTRL || |
---|
| 180 | + i == ISP3X_SELF_RESIZE_CTRL) && *val == 0) |
---|
| 181 | + *val = CIF_RSZ_CTRL_CFG_UPD; |
---|
69 | 182 | writel(*val, base + i); |
---|
| 183 | + if (hw->unite == ISP_UNITE_TWO) { |
---|
| 184 | + val = dev->sw_base_addr + i + RKISP_ISP_SW_MAX_SIZE; |
---|
| 185 | + if ((i == ISP3X_MAIN_RESIZE_CTRL || |
---|
| 186 | + i == ISP32_BP_RESIZE_CTRL || |
---|
| 187 | + i == ISP3X_SELF_RESIZE_CTRL) && *val == 0) |
---|
| 188 | + *val = CIF_RSZ_CTRL_CFG_UPD; |
---|
| 189 | + writel(*val, hw->base_next_addr + i); |
---|
| 190 | + } |
---|
| 191 | + } |
---|
70 | 192 | } |
---|
71 | 193 | } |
---|
72 | 194 | |
---|
.. | .. |
---|
78 | 200 | struct sg_table *sg_tbl; |
---|
79 | 201 | void *mem_priv; |
---|
80 | 202 | int ret = 0; |
---|
| 203 | + |
---|
| 204 | + mutex_lock(&dev->buf_lock); |
---|
81 | 205 | |
---|
82 | 206 | if (!buf->size) { |
---|
83 | 207 | ret = -EINVAL; |
---|
.. | .. |
---|
119 | 243 | v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev, |
---|
120 | 244 | "%s buf:0x%x~0x%x size:%d\n", __func__, |
---|
121 | 245 | (u32)buf->dma_addr, (u32)buf->dma_addr + buf->size, buf->size); |
---|
| 246 | + mutex_unlock(&dev->buf_lock); |
---|
122 | 247 | return ret; |
---|
123 | 248 | err: |
---|
| 249 | + mutex_unlock(&dev->buf_lock); |
---|
124 | 250 | dev_err(dev->dev, "%s failed ret:%d\n", __func__, ret); |
---|
125 | 251 | return ret; |
---|
126 | 252 | } |
---|
.. | .. |
---|
130 | 256 | { |
---|
131 | 257 | const struct vb2_mem_ops *g_ops = dev->hw_dev->mem_ops; |
---|
132 | 258 | |
---|
| 259 | + mutex_lock(&dev->buf_lock); |
---|
133 | 260 | if (buf && buf->mem_priv) { |
---|
134 | 261 | v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev, |
---|
135 | 262 | "%s buf:0x%x~0x%x\n", __func__, |
---|
.. | .. |
---|
145 | 272 | buf->is_need_vaddr = false; |
---|
146 | 273 | buf->is_need_dmafd = false; |
---|
147 | 274 | } |
---|
| 275 | + mutex_unlock(&dev->buf_lock); |
---|
148 | 276 | } |
---|
149 | 277 | |
---|
150 | 278 | void rkisp_prepare_buffer(struct rkisp_device *dev, |
---|
.. | .. |
---|
190 | 318 | return -EINVAL; |
---|
191 | 319 | } |
---|
192 | 320 | |
---|
193 | | - if (hw->dev_num) |
---|
194 | | - hw->is_single = false; |
---|
| 321 | + if (hw->dev_num >= DEV_MAX) { |
---|
| 322 | + dev_err(isp->dev, "failed attach isp hw, max dev:%d\n", DEV_MAX); |
---|
| 323 | + return -EINVAL; |
---|
| 324 | + } |
---|
| 325 | + |
---|
195 | 326 | isp->dev_id = hw->dev_num; |
---|
196 | 327 | hw->isp[hw->dev_num] = isp; |
---|
197 | 328 | hw->dev_num++; |
---|
.. | .. |
---|
269 | 400 | struct rkisp_dummy_buffer *dummy_buf = &hw->dummy_buf; |
---|
270 | 401 | struct rkisp_stream *stream; |
---|
271 | 402 | struct rkisp_device *isp; |
---|
272 | | - u32 i, j, size = 0; |
---|
| 403 | + u32 i, j, val, size = 0; |
---|
273 | 404 | int ret = 0; |
---|
274 | 405 | |
---|
275 | 406 | if (dummy_buf->mem_priv) |
---|
.. | .. |
---|
279 | 410 | size = hw->max_in.w * hw->max_in.h * 2; |
---|
280 | 411 | for (i = 0; i < hw->dev_num; i++) { |
---|
281 | 412 | isp = hw->isp[i]; |
---|
| 413 | + if (!isp || (isp && !isp->is_hw_link)) |
---|
| 414 | + continue; |
---|
282 | 415 | for (j = 0; j < RKISP_MAX_STREAM; j++) { |
---|
283 | 416 | stream = &isp->cap_dev.stream[j]; |
---|
284 | 417 | if (!stream->linked) |
---|
285 | 418 | continue; |
---|
286 | | - size = max(size, |
---|
287 | | - stream->out_fmt.plane_fmt[0].bytesperline * |
---|
288 | | - stream->out_fmt.height); |
---|
| 419 | + val = stream->out_isp_fmt.fmt_type == FMT_FBC ? |
---|
| 420 | + stream->out_fmt.plane_fmt[1].sizeimage : |
---|
| 421 | + stream->out_fmt.plane_fmt[0].bytesperline * |
---|
| 422 | + stream->out_fmt.height; |
---|
| 423 | + size = max(size, val); |
---|
289 | 424 | } |
---|
290 | 425 | } |
---|
291 | 426 | if (size == 0) |
---|
.. | .. |
---|
321 | 456 | else |
---|
322 | 457 | rkisp_free_buffer(dev, &hw->dummy_buf); |
---|
323 | 458 | } |
---|
| 459 | + |
---|
| 460 | +u64 rkisp_time_get_ns(struct rkisp_device *dev) |
---|
| 461 | +{ |
---|
| 462 | + u64 ns; |
---|
| 463 | + |
---|
| 464 | + if (dev->isp_ver == ISP_V32) |
---|
| 465 | + ns = ktime_get_boottime_ns(); |
---|
| 466 | + else |
---|
| 467 | + ns = ktime_get_ns(); |
---|
| 468 | + return ns; |
---|
| 469 | +} |
---|