root/drivers/media/platform/omap3isp/isph3a_af.c

DEFINITIONS

1. h3a_af_setup_regs
2. h3a_af_enable
3. h3a_af_busy
4. h3a_af_get_buf_size
5. h3a_af_validate_params
6. h3a_af_set_params
7. h3a_af_ioctl
8. omap3isp_h3a_af_init
9. omap3isp_h3a_af_cleanup

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * isph3a_af.c
   4  *
   5  * TI OMAP3 ISP - H3A AF 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 /* Linux specific include files */
  16 #include <linux/device.h>
  17 #include <linux/slab.h>
  18 
  19 #include "isp.h"
  20 #include "isph3a.h"
  21 #include "ispstat.h"
  22 
  23 #define IS_OUT_OF_BOUNDS(value, min, max)               \
  24         (((value) < (min)) || ((value) > (max)))
  25 
  26 static void h3a_af_setup_regs(struct ispstat *af, void *priv)
  27 {
  28         struct omap3isp_h3a_af_config *conf = priv;
  29         u32 pcr;
  30         u32 pax1;
  31         u32 pax2;
  32         u32 paxstart;
  33         u32 coef;
  34         u32 base_coef_set0;
  35         u32 base_coef_set1;
  36         int index;
  37 
  38         if (af->state == ISPSTAT_DISABLED)
  39                 return;
  40 
  41         isp_reg_writel(af->isp, af->active_buf->dma_addr, OMAP3_ISP_IOMEM_H3A,
  42                        ISPH3A_AFBUFST);
  43 
  44         if (!af->update)
  45                 return;
  46 
  47         /* Configure Hardware Registers */
  48         pax1 = ((conf->paxel.width >> 1) - 1) << AF_PAXW_SHIFT;
  49         /* Set height in AFPAX1 */
  50         pax1 |= (conf->paxel.height >> 1) - 1;
  51         isp_reg_writel(af->isp, pax1, OMAP3_ISP_IOMEM_H3A, ISPH3A_AFPAX1);
  52 
  53         /* Configure AFPAX2 Register */
  54         /* Set Line Increment in AFPAX2 Register */
  55         pax2 = ((conf->paxel.line_inc >> 1) - 1) << AF_LINE_INCR_SHIFT;
  56         /* Set Vertical Count */
  57         pax2 |= (conf->paxel.v_cnt - 1) << AF_VT_COUNT_SHIFT;
  58         /* Set Horizontal Count */
  59         pax2 |= (conf->paxel.h_cnt - 1);
  60         isp_reg_writel(af->isp, pax2, OMAP3_ISP_IOMEM_H3A, ISPH3A_AFPAX2);
  61 
  62         /* Configure PAXSTART Register */
  63         /*Configure Horizontal Start */
  64         paxstart = conf->paxel.h_start << AF_HZ_START_SHIFT;
  65         /* Configure Vertical Start */
  66         paxstart |= conf->paxel.v_start;
  67         isp_reg_writel(af->isp, paxstart, OMAP3_ISP_IOMEM_H3A,
  68                        ISPH3A_AFPAXSTART);
  69 
  70         /*SetIIRSH Register */
  71         isp_reg_writel(af->isp, conf->iir.h_start,
  72                        OMAP3_ISP_IOMEM_H3A, ISPH3A_AFIIRSH);
  73 
  74         base_coef_set0 = ISPH3A_AFCOEF010;
  75         base_coef_set1 = ISPH3A_AFCOEF110;
  76         for (index = 0; index <= 8; index += 2) {
  77                 /*Set IIR Filter0 Coefficients */
  78                 coef = 0;
  79                 coef |= conf->iir.coeff_set0[index];
  80                 coef |= conf->iir.coeff_set0[index + 1] <<
  81                         AF_COEF_SHIFT;
  82                 isp_reg_writel(af->isp, coef, OMAP3_ISP_IOMEM_H3A,
  83                                base_coef_set0);
  84                 base_coef_set0 += AFCOEF_OFFSET;
  85 
  86                 /*Set IIR Filter1 Coefficients */
  87                 coef = 0;
  88                 coef |= conf->iir.coeff_set1[index];
  89                 coef |= conf->iir.coeff_set1[index + 1] <<
  90                         AF_COEF_SHIFT;
  91                 isp_reg_writel(af->isp, coef, OMAP3_ISP_IOMEM_H3A,
  92                                base_coef_set1);
  93                 base_coef_set1 += AFCOEF_OFFSET;
  94         }
  95         /* set AFCOEF0010 Register */
  96         isp_reg_writel(af->isp, conf->iir.coeff_set0[10],
  97                        OMAP3_ISP_IOMEM_H3A, ISPH3A_AFCOEF0010);
  98         /* set AFCOEF1010 Register */
  99         isp_reg_writel(af->isp, conf->iir.coeff_set1[10],
 100                        OMAP3_ISP_IOMEM_H3A, ISPH3A_AFCOEF1010);
 101 
 102         /* PCR Register */
 103         /* Set RGB Position */
 104         pcr = conf->rgb_pos << AF_RGBPOS_SHIFT;
 105         /* Set Accumulator Mode */
 106         if (conf->fvmode == OMAP3ISP_AF_MODE_PEAK)
 107                 pcr |= AF_FVMODE;
 108         /* Set A-law */
 109         if (conf->alaw_enable)
 110                 pcr |= AF_ALAW_EN;
 111         /* HMF Configurations */
 112         if (conf->hmf.enable) {
 113                 /* Enable HMF */
 114                 pcr |= AF_MED_EN;
 115                 /* Set Median Threshold */
 116                 pcr |= conf->hmf.threshold << AF_MED_TH_SHIFT;
 117         }
 118         /* Set PCR Register */
 119         isp_reg_clr_set(af->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 120                         AF_PCR_MASK, pcr);
 121 
 122         af->update = 0;
 123         af->config_counter += af->inc_config;
 124         af->inc_config = 0;
 125         af->buf_size = conf->buf_size;
 126 }
 127 
 128 static void h3a_af_enable(struct ispstat *af, int enable)
 129 {
 130         if (enable) {
 131                 isp_reg_set(af->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 132                             ISPH3A_PCR_AF_EN);
 133                 omap3isp_subclk_enable(af->isp, OMAP3_ISP_SUBCLK_AF);
 134         } else {
 135                 isp_reg_clr(af->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 136                             ISPH3A_PCR_AF_EN);
 137                 omap3isp_subclk_disable(af->isp, OMAP3_ISP_SUBCLK_AF);
 138         }
 139 }
 140 
 141 static int h3a_af_busy(struct ispstat *af)
 142 {
 143         return isp_reg_readl(af->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR)
 144                                                 & ISPH3A_PCR_BUSYAF;
 145 }
 146 
 147 static u32 h3a_af_get_buf_size(struct omap3isp_h3a_af_config *conf)
 148 {
 149         return conf->paxel.h_cnt * conf->paxel.v_cnt * OMAP3ISP_AF_PAXEL_SIZE;
 150 }
 151 
 152 /* Function to check paxel parameters */
 153 static int h3a_af_validate_params(struct ispstat *af, void *new_conf)
 154 {
 155         struct omap3isp_h3a_af_config *user_cfg = new_conf;
 156         struct omap3isp_h3a_af_paxel *paxel_cfg = &user_cfg->paxel;
 157         struct omap3isp_h3a_af_iir *iir_cfg = &user_cfg->iir;
 158         int index;
 159         u32 buf_size;
 160 
 161         /* Check horizontal Count */
 162         if (IS_OUT_OF_BOUNDS(paxel_cfg->h_cnt,
 163                              OMAP3ISP_AF_PAXEL_HORIZONTAL_COUNT_MIN,
 164                              OMAP3ISP_AF_PAXEL_HORIZONTAL_COUNT_MAX))
 165                 return -EINVAL;
 166 
 167         /* Check Vertical Count */
 168         if (IS_OUT_OF_BOUNDS(paxel_cfg->v_cnt,
 169                              OMAP3ISP_AF_PAXEL_VERTICAL_COUNT_MIN,
 170                              OMAP3ISP_AF_PAXEL_VERTICAL_COUNT_MAX))
 171                 return -EINVAL;
 172 
 173         if (IS_OUT_OF_BOUNDS(paxel_cfg->height, OMAP3ISP_AF_PAXEL_HEIGHT_MIN,
 174                              OMAP3ISP_AF_PAXEL_HEIGHT_MAX) ||
 175             paxel_cfg->height % 2)
 176                 return -EINVAL;
 177 
 178         /* Check width */
 179         if (IS_OUT_OF_BOUNDS(paxel_cfg->width, OMAP3ISP_AF_PAXEL_WIDTH_MIN,
 180                              OMAP3ISP_AF_PAXEL_WIDTH_MAX) ||
 181             paxel_cfg->width % 2)
 182                 return -EINVAL;
 183 
 184         /* Check Line Increment */
 185         if (IS_OUT_OF_BOUNDS(paxel_cfg->line_inc,
 186                              OMAP3ISP_AF_PAXEL_INCREMENT_MIN,
 187                              OMAP3ISP_AF_PAXEL_INCREMENT_MAX) ||
 188             paxel_cfg->line_inc % 2)
 189                 return -EINVAL;
 190 
 191         /* Check Horizontal Start */
 192         if ((paxel_cfg->h_start < iir_cfg->h_start) ||
 193             IS_OUT_OF_BOUNDS(paxel_cfg->h_start,
 194                              OMAP3ISP_AF_PAXEL_HZSTART_MIN,
 195                              OMAP3ISP_AF_PAXEL_HZSTART_MAX))
 196                 return -EINVAL;
 197 
 198         /* Check IIR */
 199         for (index = 0; index < OMAP3ISP_AF_NUM_COEF; index++) {
 200                 if ((iir_cfg->coeff_set0[index]) > OMAP3ISP_AF_COEF_MAX)
 201                         return -EINVAL;
 202 
 203                 if ((iir_cfg->coeff_set1[index]) > OMAP3ISP_AF_COEF_MAX)
 204                         return -EINVAL;
 205         }
 206 
 207         if (IS_OUT_OF_BOUNDS(iir_cfg->h_start, OMAP3ISP_AF_IIRSH_MIN,
 208                              OMAP3ISP_AF_IIRSH_MAX))
 209                 return -EINVAL;
 210 
 211         /* Hack: If paxel size is 12, the 10th AF window may be corrupted */
 212         if ((paxel_cfg->h_cnt * paxel_cfg->v_cnt > 9) &&
 213             (paxel_cfg->width * paxel_cfg->height == 12))
 214                 return -EINVAL;
 215 
 216         buf_size = h3a_af_get_buf_size(user_cfg);
 217         if (buf_size > user_cfg->buf_size)
 218                 /* User buf_size request wasn't enough */
 219                 user_cfg->buf_size = buf_size;
 220         else if (user_cfg->buf_size > OMAP3ISP_AF_MAX_BUF_SIZE)
 221                 user_cfg->buf_size = OMAP3ISP_AF_MAX_BUF_SIZE;
 222 
 223         return 0;
 224 }
 225 
 226 /* Update local parameters */
 227 static void h3a_af_set_params(struct ispstat *af, void *new_conf)
 228 {
 229         struct omap3isp_h3a_af_config *user_cfg = new_conf;
 230         struct omap3isp_h3a_af_config *cur_cfg = af->priv;
 231         int update = 0;
 232         int index;
 233 
 234         /* alaw */
 235         if (cur_cfg->alaw_enable != user_cfg->alaw_enable) {
 236                 update = 1;
 237                 goto out;
 238         }
 239 
 240         /* hmf */
 241         if (cur_cfg->hmf.enable != user_cfg->hmf.enable) {
 242                 update = 1;
 243                 goto out;
 244         }
 245         if (cur_cfg->hmf.threshold != user_cfg->hmf.threshold) {
 246                 update = 1;
 247                 goto out;
 248         }
 249 
 250         /* rgbpos */
 251         if (cur_cfg->rgb_pos != user_cfg->rgb_pos) {
 252                 update = 1;
 253                 goto out;
 254         }
 255 
 256         /* iir */
 257         if (cur_cfg->iir.h_start != user_cfg->iir.h_start) {
 258                 update = 1;
 259                 goto out;
 260         }
 261         for (index = 0; index < OMAP3ISP_AF_NUM_COEF; index++) {
 262                 if (cur_cfg->iir.coeff_set0[index] !=
 263                                 user_cfg->iir.coeff_set0[index]) {
 264                         update = 1;
 265                         goto out;
 266                 }
 267                 if (cur_cfg->iir.coeff_set1[index] !=
 268                                 user_cfg->iir.coeff_set1[index]) {
 269                         update = 1;
 270                         goto out;
 271                 }
 272         }
 273 
 274         /* paxel */
 275         if ((cur_cfg->paxel.width != user_cfg->paxel.width) ||
 276             (cur_cfg->paxel.height != user_cfg->paxel.height) ||
 277             (cur_cfg->paxel.h_start != user_cfg->paxel.h_start) ||
 278             (cur_cfg->paxel.v_start != user_cfg->paxel.v_start) ||
 279             (cur_cfg->paxel.h_cnt != user_cfg->paxel.h_cnt) ||
 280             (cur_cfg->paxel.v_cnt != user_cfg->paxel.v_cnt) ||
 281             (cur_cfg->paxel.line_inc != user_cfg->paxel.line_inc)) {
 282                 update = 1;
 283                 goto out;
 284         }
 285 
 286         /* af_mode */
 287         if (cur_cfg->fvmode != user_cfg->fvmode)
 288                 update = 1;
 289 
 290 out:
 291         if (update || !af->configured) {
 292                 memcpy(cur_cfg, user_cfg, sizeof(*cur_cfg));
 293                 af->inc_config++;
 294                 af->update = 1;
 295                 /*
 296                  * User might be asked for a bigger buffer than necessary for
 297                  * this configuration. In order to return the right amount of
 298                  * data during buffer request, let's calculate the size here
 299                  * instead of stick with user_cfg->buf_size.
 300                  */
 301                 cur_cfg->buf_size = h3a_af_get_buf_size(cur_cfg);
 302         }
 303 }
 304 
 305 static long h3a_af_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 306 {
 307         struct ispstat *stat = v4l2_get_subdevdata(sd);
 308 
 309         switch (cmd) {
 310         case VIDIOC_OMAP3ISP_AF_CFG:
 311                 return omap3isp_stat_config(stat, arg);
 312         case VIDIOC_OMAP3ISP_STAT_REQ:
 313                 return omap3isp_stat_request_statistics(stat, arg);
 314         case VIDIOC_OMAP3ISP_STAT_REQ_TIME32:
 315                 return omap3isp_stat_request_statistics_time32(stat, arg);
 316         case VIDIOC_OMAP3ISP_STAT_EN: {
 317                 int *en = arg;
 318                 return omap3isp_stat_enable(stat, !!*en);
 319         }
 320         }
 321 
 322         return -ENOIOCTLCMD;
 323 
 324 }
 325 
 326 static const struct ispstat_ops h3a_af_ops = {
 327         .validate_params        = h3a_af_validate_params,
 328         .set_params             = h3a_af_set_params,
 329         .setup_regs             = h3a_af_setup_regs,
 330         .enable                 = h3a_af_enable,
 331         .busy                   = h3a_af_busy,
 332 };
 333 
 334 static const struct v4l2_subdev_core_ops h3a_af_subdev_core_ops = {
 335         .ioctl = h3a_af_ioctl,
 336         .subscribe_event = omap3isp_stat_subscribe_event,
 337         .unsubscribe_event = omap3isp_stat_unsubscribe_event,
 338 };
 339 
 340 static const struct v4l2_subdev_video_ops h3a_af_subdev_video_ops = {
 341         .s_stream = omap3isp_stat_s_stream,
 342 };
 343 
 344 static const struct v4l2_subdev_ops h3a_af_subdev_ops = {
 345         .core = &h3a_af_subdev_core_ops,
 346         .video = &h3a_af_subdev_video_ops,
 347 };
 348 
 349 /* Function to register the AF character device driver. */
 350 int omap3isp_h3a_af_init(struct isp_device *isp)
 351 {
 352         struct ispstat *af = &isp->isp_af;
 353         struct omap3isp_h3a_af_config *af_cfg;
 354         struct omap3isp_h3a_af_config *af_recover_cfg = NULL;
 355         int ret;
 356 
 357         af_cfg = kzalloc(sizeof(*af_cfg), GFP_KERNEL);
 358         if (af_cfg == NULL)
 359                 return -ENOMEM;
 360 
 361         af->ops = &h3a_af_ops;
 362         af->priv = af_cfg;
 363         af->event_type = V4L2_EVENT_OMAP3ISP_AF;
 364         af->isp = isp;
 365 
 366         /* Set recover state configuration */
 367         af_recover_cfg = kzalloc(sizeof(*af_recover_cfg), GFP_KERNEL);
 368         if (!af_recover_cfg) {
 369                 dev_err(af->isp->dev,
 370                         "AF: cannot allocate memory for recover configuration.\n");
 371                 ret = -ENOMEM;
 372                 goto err;
 373         }
 374 
 375         af_recover_cfg->paxel.h_start = OMAP3ISP_AF_PAXEL_HZSTART_MIN;
 376         af_recover_cfg->paxel.width = OMAP3ISP_AF_PAXEL_WIDTH_MIN;
 377         af_recover_cfg->paxel.height = OMAP3ISP_AF_PAXEL_HEIGHT_MIN;
 378         af_recover_cfg->paxel.h_cnt = OMAP3ISP_AF_PAXEL_HORIZONTAL_COUNT_MIN;
 379         af_recover_cfg->paxel.v_cnt = OMAP3ISP_AF_PAXEL_VERTICAL_COUNT_MIN;
 380         af_recover_cfg->paxel.line_inc = OMAP3ISP_AF_PAXEL_INCREMENT_MIN;
 381         if (h3a_af_validate_params(af, af_recover_cfg)) {
 382                 dev_err(af->isp->dev,
 383                         "AF: recover configuration is invalid.\n");
 384                 ret = -EINVAL;
 385                 goto err;
 386         }
 387 
 388         af_recover_cfg->buf_size = h3a_af_get_buf_size(af_recover_cfg);
 389         af->recover_priv = af_recover_cfg;
 390 
 391         ret = omap3isp_stat_init(af, "AF", &h3a_af_subdev_ops);
 392 
 393 err:
 394         if (ret) {
 395                 kfree(af_cfg);
 396                 kfree(af_recover_cfg);
 397         }
 398 
 399         return ret;
 400 }
 401 
 402 void omap3isp_h3a_af_cleanup(struct isp_device *isp)
 403 {
 404         omap3isp_stat_cleanup(&isp->isp_af);
 405 }