1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * isph3a.c
4  *
5  * TI OMAP3 ISP - H3A module
6  *
7  * Copyright (C) 2010 Nokia Corporation
8  * Copyright (C) 2009 Texas Instruments, Inc.
9  *
10  * Contacts: David Cohen <dacohen@gmail.com>
11  *	     Laurent Pinchart <laurent.pinchart@ideasonboard.com>
12  *	     Sakari Ailus <sakari.ailus@iki.fi>
13  */
14 
15 #include <linux/slab.h>
16 #include <linux/uaccess.h>
17 
18 #include "isp.h"
19 #include "isph3a.h"
20 #include "ispstat.h"
21 
22 /*
23  * h3a_aewb_update_regs - Helper function to update h3a registers.
24  */
25 static void h3a_aewb_setup_regs(struct ispstat *aewb, void *priv)
26 {
27 	struct omap3isp_h3a_aewb_config *conf = priv;
28 	u32 pcr;
29 	u32 win1;
30 	u32 start;
31 	u32 blk;
32 	u32 subwin;
33 
34 	if (aewb->state == ISPSTAT_DISABLED)
35 		return;
36 
37 	isp_reg_writel(aewb->isp, aewb->active_buf->dma_addr,
38 		       OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWBUFST);
39 
40 	if (!aewb->update)
41 		return;
42 
43 	/* Converting config metadata into reg values */
44 	pcr = conf->saturation_limit << ISPH3A_PCR_AEW_AVE2LMT_SHIFT;
45 	pcr |= !!conf->alaw_enable << ISPH3A_PCR_AEW_ALAW_EN_SHIFT;
46 
47 	win1 = ((conf->win_height >> 1) - 1) << ISPH3A_AEWWIN1_WINH_SHIFT;
48 	win1 |= ((conf->win_width >> 1) - 1) << ISPH3A_AEWWIN1_WINW_SHIFT;
49 	win1 |= (conf->ver_win_count - 1) << ISPH3A_AEWWIN1_WINVC_SHIFT;
50 	win1 |= (conf->hor_win_count - 1) << ISPH3A_AEWWIN1_WINHC_SHIFT;
51 
52 	start = conf->hor_win_start << ISPH3A_AEWINSTART_WINSH_SHIFT;
53 	start |= conf->ver_win_start << ISPH3A_AEWINSTART_WINSV_SHIFT;
54 
55 	blk = conf->blk_ver_win_start << ISPH3A_AEWINBLK_WINSV_SHIFT;
56 	blk |= ((conf->blk_win_height >> 1) - 1) << ISPH3A_AEWINBLK_WINH_SHIFT;
57 
58 	subwin = ((conf->subsample_ver_inc >> 1) - 1) <<
59 		 ISPH3A_AEWSUBWIN_AEWINCV_SHIFT;
60 	subwin |= ((conf->subsample_hor_inc >> 1) - 1) <<
61 		  ISPH3A_AEWSUBWIN_AEWINCH_SHIFT;
62 
63 	isp_reg_writel(aewb->isp, win1, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWWIN1);
64 	isp_reg_writel(aewb->isp, start, OMAP3_ISP_IOMEM_H3A,
65 		       ISPH3A_AEWINSTART);
66 	isp_reg_writel(aewb->isp, blk, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWINBLK);
67 	isp_reg_writel(aewb->isp, subwin, OMAP3_ISP_IOMEM_H3A,
68 		       ISPH3A_AEWSUBWIN);
69 	isp_reg_clr_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
70 			ISPH3A_PCR_AEW_MASK, pcr);
71 
72 	aewb->update = 0;
73 	aewb->config_counter += aewb->inc_config;
74 	aewb->inc_config = 0;
75 	aewb->buf_size = conf->buf_size;
76 }
77 
78 static void h3a_aewb_enable(struct ispstat *aewb, int enable)
79 {
80 	if (enable) {
81 		isp_reg_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
82 			    ISPH3A_PCR_AEW_EN);
83 		omap3isp_subclk_enable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
84 	} else {
85 		isp_reg_clr(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
86 			    ISPH3A_PCR_AEW_EN);
87 		omap3isp_subclk_disable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
88 	}
89 }
90 
91 static int h3a_aewb_busy(struct ispstat *aewb)
92 {
93 	return isp_reg_readl(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR)
94 						& ISPH3A_PCR_BUSYAEAWB;
95 }
96 
97 static u32 h3a_aewb_get_buf_size(struct omap3isp_h3a_aewb_config *conf)
98 {
99 	/* Number of configured windows + extra row for black data */
100 	u32 win_count = (conf->ver_win_count + 1) * conf->hor_win_count;
101 
102 	/*
103 	 * Unsaturated block counts for each 8 windows.
104 	 * 1 extra for the last (win_count % 8) windows if win_count is not
105 	 * divisible by 8.
106 	 */
107 	win_count += (win_count + 7) / 8;
108 
109 	return win_count * AEWB_PACKET_SIZE;
110 }
111 
112 static int h3a_aewb_validate_params(struct ispstat *aewb, void *new_conf)
113 {
114 	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
115 	u32 buf_size;
116 
117 	if (unlikely(user_cfg->saturation_limit >
118 		     OMAP3ISP_AEWB_MAX_SATURATION_LIM))
119 		return -EINVAL;
120 
121 	if (unlikely(user_cfg->win_height < OMAP3ISP_AEWB_MIN_WIN_H ||
122 		     user_cfg->win_height > OMAP3ISP_AEWB_MAX_WIN_H ||
123 		     user_cfg->win_height & 0x01))
124 		return -EINVAL;
125 
126 	if (unlikely(user_cfg->win_width < OMAP3ISP_AEWB_MIN_WIN_W ||
127 		     user_cfg->win_width > OMAP3ISP_AEWB_MAX_WIN_W ||
128 		     user_cfg->win_width & 0x01))
129 		return -EINVAL;
130 
131 	if (unlikely(user_cfg->ver_win_count < OMAP3ISP_AEWB_MIN_WINVC ||
132 		     user_cfg->ver_win_count > OMAP3ISP_AEWB_MAX_WINVC))
133 		return -EINVAL;
134 
135 	if (unlikely(user_cfg->hor_win_count < OMAP3ISP_AEWB_MIN_WINHC ||
136 		     user_cfg->hor_win_count > OMAP3ISP_AEWB_MAX_WINHC))
137 		return -EINVAL;
138 
139 	if (unlikely(user_cfg->ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
140 		return -EINVAL;
141 
142 	if (unlikely(user_cfg->hor_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
143 		return -EINVAL;
144 
145 	if (unlikely(user_cfg->blk_ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
146 		return -EINVAL;
147 
148 	if (unlikely(user_cfg->blk_win_height < OMAP3ISP_AEWB_MIN_WIN_H ||
149 		     user_cfg->blk_win_height > OMAP3ISP_AEWB_MAX_WIN_H ||
150 		     user_cfg->blk_win_height & 0x01))
151 		return -EINVAL;
152 
153 	if (unlikely(user_cfg->subsample_ver_inc < OMAP3ISP_AEWB_MIN_SUB_INC ||
154 		     user_cfg->subsample_ver_inc > OMAP3ISP_AEWB_MAX_SUB_INC ||
155 		     user_cfg->subsample_ver_inc & 0x01))
156 		return -EINVAL;
157 
158 	if (unlikely(user_cfg->subsample_hor_inc < OMAP3ISP_AEWB_MIN_SUB_INC ||
159 		     user_cfg->subsample_hor_inc > OMAP3ISP_AEWB_MAX_SUB_INC ||
160 		     user_cfg->subsample_hor_inc & 0x01))
161 		return -EINVAL;
162 
163 	buf_size = h3a_aewb_get_buf_size(user_cfg);
164 	if (buf_size > user_cfg->buf_size)
165 		user_cfg->buf_size = buf_size;
166 	else if (user_cfg->buf_size > OMAP3ISP_AEWB_MAX_BUF_SIZE)
167 		user_cfg->buf_size = OMAP3ISP_AEWB_MAX_BUF_SIZE;
168 
169 	return 0;
170 }
171 
172 /*
173  * h3a_aewb_set_params - Helper function to check & store user given params.
174  * @new_conf: Pointer to AE and AWB parameters struct.
175  *
176  * As most of them are busy-lock registers, need to wait until AEW_BUSY = 0 to
177  * program them during ISR.
178  */
179 static void h3a_aewb_set_params(struct ispstat *aewb, void *new_conf)
180 {
181 	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
182 	struct omap3isp_h3a_aewb_config *cur_cfg = aewb->priv;
183 	int update = 0;
184 
185 	if (cur_cfg->saturation_limit != user_cfg->saturation_limit) {
186 		cur_cfg->saturation_limit = user_cfg->saturation_limit;
187 		update = 1;
188 	}
189 	if (cur_cfg->alaw_enable != user_cfg->alaw_enable) {
190 		cur_cfg->alaw_enable = user_cfg->alaw_enable;
191 		update = 1;
192 	}
193 	if (cur_cfg->win_height != user_cfg->win_height) {
194 		cur_cfg->win_height = user_cfg->win_height;
195 		update = 1;
196 	}
197 	if (cur_cfg->win_width != user_cfg->win_width) {
198 		cur_cfg->win_width = user_cfg->win_width;
199 		update = 1;
200 	}
201 	if (cur_cfg->ver_win_count != user_cfg->ver_win_count) {
202 		cur_cfg->ver_win_count = user_cfg->ver_win_count;
203 		update = 1;
204 	}
205 	if (cur_cfg->hor_win_count != user_cfg->hor_win_count) {
206 		cur_cfg->hor_win_count = user_cfg->hor_win_count;
207 		update = 1;
208 	}
209 	if (cur_cfg->ver_win_start != user_cfg->ver_win_start) {
210 		cur_cfg->ver_win_start = user_cfg->ver_win_start;
211 		update = 1;
212 	}
213 	if (cur_cfg->hor_win_start != user_cfg->hor_win_start) {
214 		cur_cfg->hor_win_start = user_cfg->hor_win_start;
215 		update = 1;
216 	}
217 	if (cur_cfg->blk_ver_win_start != user_cfg->blk_ver_win_start) {
218 		cur_cfg->blk_ver_win_start = user_cfg->blk_ver_win_start;
219 		update = 1;
220 	}
221 	if (cur_cfg->blk_win_height != user_cfg->blk_win_height) {
222 		cur_cfg->blk_win_height = user_cfg->blk_win_height;
223 		update = 1;
224 	}
225 	if (cur_cfg->subsample_ver_inc != user_cfg->subsample_ver_inc) {
226 		cur_cfg->subsample_ver_inc = user_cfg->subsample_ver_inc;
227 		update = 1;
228 	}
229 	if (cur_cfg->subsample_hor_inc != user_cfg->subsample_hor_inc) {
230 		cur_cfg->subsample_hor_inc = user_cfg->subsample_hor_inc;
231 		update = 1;
232 	}
233 
234 	if (update || !aewb->configured) {
235 		aewb->inc_config++;
236 		aewb->update = 1;
237 		cur_cfg->buf_size = h3a_aewb_get_buf_size(cur_cfg);
238 	}
239 }
240 
241 static long h3a_aewb_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
242 {
243 	struct ispstat *stat = v4l2_get_subdevdata(sd);
244 
245 	switch (cmd) {
246 	case VIDIOC_OMAP3ISP_AEWB_CFG:
247 		return omap3isp_stat_config(stat, arg);
248 	case VIDIOC_OMAP3ISP_STAT_REQ:
249 		return omap3isp_stat_request_statistics(stat, arg);
250 	case VIDIOC_OMAP3ISP_STAT_REQ_TIME32:
251 		return omap3isp_stat_request_statistics_time32(stat, arg);
252 	case VIDIOC_OMAP3ISP_STAT_EN: {
253 		unsigned long *en = arg;
254 		return omap3isp_stat_enable(stat, !!*en);
255 	}
256 	}
257 
258 	return -ENOIOCTLCMD;
259 }
260 
261 static const struct ispstat_ops h3a_aewb_ops = {
262 	.validate_params	= h3a_aewb_validate_params,
263 	.set_params		= h3a_aewb_set_params,
264 	.setup_regs		= h3a_aewb_setup_regs,
265 	.enable			= h3a_aewb_enable,
266 	.busy			= h3a_aewb_busy,
267 };
268 
269 static const struct v4l2_subdev_core_ops h3a_aewb_subdev_core_ops = {
270 	.ioctl = h3a_aewb_ioctl,
271 	.subscribe_event = omap3isp_stat_subscribe_event,
272 	.unsubscribe_event = omap3isp_stat_unsubscribe_event,
273 };
274 
275 static const struct v4l2_subdev_video_ops h3a_aewb_subdev_video_ops = {
276 	.s_stream = omap3isp_stat_s_stream,
277 };
278 
279 static const struct v4l2_subdev_ops h3a_aewb_subdev_ops = {
280 	.core = &h3a_aewb_subdev_core_ops,
281 	.video = &h3a_aewb_subdev_video_ops,
282 };
283 
284 /*
285  * omap3isp_h3a_aewb_init - Module Initialisation.
286  */
287 int omap3isp_h3a_aewb_init(struct isp_device *isp)
288 {
289 	struct ispstat *aewb = &isp->isp_aewb;
290 	struct omap3isp_h3a_aewb_config *aewb_cfg;
291 	struct omap3isp_h3a_aewb_config *aewb_recover_cfg = NULL;
292 	int ret;
293 
294 	aewb_cfg = kzalloc(sizeof(*aewb_cfg), GFP_KERNEL);
295 	if (!aewb_cfg)
296 		return -ENOMEM;
297 
298 	aewb->ops = &h3a_aewb_ops;
299 	aewb->priv = aewb_cfg;
300 	aewb->event_type = V4L2_EVENT_OMAP3ISP_AEWB;
301 	aewb->isp = isp;
302 
303 	/* Set recover state configuration */
304 	aewb_recover_cfg = kzalloc(sizeof(*aewb_recover_cfg), GFP_KERNEL);
305 	if (!aewb_recover_cfg) {
306 		dev_err(aewb->isp->dev,
307 			"AEWB: cannot allocate memory for recover configuration.\n");
308 		ret = -ENOMEM;
309 		goto err;
310 	}
311 
312 	aewb_recover_cfg->saturation_limit = OMAP3ISP_AEWB_MAX_SATURATION_LIM;
313 	aewb_recover_cfg->win_height = OMAP3ISP_AEWB_MIN_WIN_H;
314 	aewb_recover_cfg->win_width = OMAP3ISP_AEWB_MIN_WIN_W;
315 	aewb_recover_cfg->ver_win_count = OMAP3ISP_AEWB_MIN_WINVC;
316 	aewb_recover_cfg->hor_win_count = OMAP3ISP_AEWB_MIN_WINHC;
317 	aewb_recover_cfg->blk_ver_win_start = aewb_recover_cfg->ver_win_start +
318 		aewb_recover_cfg->win_height * aewb_recover_cfg->ver_win_count;
319 	aewb_recover_cfg->blk_win_height = OMAP3ISP_AEWB_MIN_WIN_H;
320 	aewb_recover_cfg->subsample_ver_inc = OMAP3ISP_AEWB_MIN_SUB_INC;
321 	aewb_recover_cfg->subsample_hor_inc = OMAP3ISP_AEWB_MIN_SUB_INC;
322 
323 	if (h3a_aewb_validate_params(aewb, aewb_recover_cfg)) {
324 		dev_err(aewb->isp->dev,
325 			"AEWB: recover configuration is invalid.\n");
326 		ret = -EINVAL;
327 		goto err;
328 	}
329 
330 	aewb_recover_cfg->buf_size = h3a_aewb_get_buf_size(aewb_recover_cfg);
331 	aewb->recover_priv = aewb_recover_cfg;
332 
333 	ret = omap3isp_stat_init(aewb, "AEWB", &h3a_aewb_subdev_ops);
334 
335 err:
336 	if (ret) {
337 		kfree(aewb_cfg);
338 		kfree(aewb_recover_cfg);
339 	}
340 
341 	return ret;
342 }
343 
344 /*
345  * omap3isp_h3a_aewb_cleanup - Module exit.
346  */
347 void omap3isp_h3a_aewb_cleanup(struct isp_device *isp)
348 {
349 	omap3isp_stat_cleanup(&isp->isp_aewb);
350 }
351