drivers/media/i2c/max2175.c

   1 /*
   2  * Maxim Integrated MAX2175 RF to Bits tuner driver
   3  *
   4  * This driver & most of the hard coded values are based on the reference
   5  * application delivered by Maxim for this device.
   6  *
   7  * Copyright (C) 2016 Maxim Integrated Products
   8  * Copyright (C) 2017 Renesas Electronics Corporation
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2
  12  * as published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #include <linux/clk.h>
  21 #include <linux/delay.h>
  22 #include <linux/errno.h>
  23 #include <linux/i2c.h>
  24 #include <linux/kernel.h>
  25 #include <linux/math64.h>
  26 #include <linux/max2175.h>
  27 #include <linux/module.h>
  28 #include <linux/of.h>
  29 #include <linux/regmap.h>
  30 #include <linux/slab.h>
  31 #include <media/v4l2-ctrls.h>
  32 #include <media/v4l2-device.h>
  33
  34 #include "max2175.h"
  35
  36 #define DRIVER_NAME "max2175"
  37
  38 #define mxm_dbg(ctx, fmt, arg...) dev_dbg(&ctx->client->dev, fmt, ## arg)
  39 #define mxm_err(ctx, fmt, arg...) dev_err(&ctx->client->dev, fmt, ## arg)
  40
  41 /* Rx mode */
  42 struct max2175_rxmode {
  43         enum max2175_band band;         /* Associated band */
  44         u32 freq;                       /* Default freq in Hz */
  45         u8 i2s_word_size;               /* Bit value */
  46 };
  47
  48 /* Register map to define preset values */
  49 struct max2175_reg_map {
  50         u8 idx;                         /* Register index */
  51         u8 val;                         /* Register value */
  52 };
  53
  54 static const struct max2175_rxmode eu_rx_modes[] = {
  55         /* EU modes */
  56         [MAX2175_EU_FM_1_2] = { MAX2175_BAND_FM, 98256000, 1 },
  57         [MAX2175_DAB_1_2]   = { MAX2175_BAND_VHF, 182640000, 0 },
  58 };
  59
  60 static const struct max2175_rxmode na_rx_modes[] = {
  61         /* NA modes */
  62         [MAX2175_NA_FM_1_0] = { MAX2175_BAND_FM, 98255520, 1 },
  63         [MAX2175_NA_FM_2_0] = { MAX2175_BAND_FM, 98255520, 6 },
  64 };
  65
  66 /*
  67  * Preset values:
  68  * Based on Maxim MAX2175 Register Table revision: 130p10
  69  */
  70 static const u8 full_fm_eu_1p0[] = {
  71         0x15, 0x04, 0xb8, 0xe3, 0x35, 0x18, 0x7c, 0x00,
  72         0x00, 0x7d, 0x40, 0x08, 0x70, 0x7a, 0x88, 0x91,
  73         0x61, 0x61, 0x61, 0x61, 0x5a, 0x0f, 0x34, 0x1c,
  74         0x14, 0x88, 0x33, 0x02, 0x00, 0x09, 0x00, 0x65,
  75         0x9f, 0x2b, 0x80, 0x00, 0x95, 0x05, 0x2c, 0x00,
  76         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
  77         0x4a, 0x08, 0xa8, 0x0e, 0x0e, 0x2f, 0x7e, 0x00,
  78         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  79         0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5e, 0xa9,
  80         0xae, 0xbb, 0x57, 0x18, 0x3b, 0x03, 0x3b, 0x64,
  81         0x40, 0x60, 0x00, 0x2a, 0xbf, 0x3f, 0xff, 0x9f,
  82         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
  83         0xff, 0xfc, 0xef, 0x1c, 0x40, 0x00, 0x00, 0x02,
  84         0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
  85         0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0x40, 0x00,
  86         0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00,
  87         0x00, 0x47, 0x00, 0x00, 0x11, 0x3f, 0x22, 0x00,
  88         0xf1, 0x00, 0x41, 0x03, 0xb0, 0x00, 0x00, 0x00,
  89         0x1b,
  90 };
  91
  92 static const u8 full_fm_na_1p0[] = {
  93         0x13, 0x08, 0x8d, 0xc0, 0x35, 0x18, 0x7d, 0x3f,
  94         0x7d, 0x75, 0x40, 0x08, 0x70, 0x7a, 0x88, 0x91,
  95         0x61, 0x61, 0x61, 0x61, 0x5c, 0x0f, 0x34, 0x1c,
  96         0x14, 0x88, 0x33, 0x02, 0x00, 0x01, 0x00, 0x65,
  97         0x9f, 0x2b, 0x80, 0x00, 0x95, 0x05, 0x2c, 0x00,
  98         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
  99         0x4a, 0x08, 0xa8, 0x0e, 0x0e, 0xaf, 0x7e, 0x00,
 100         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 101         0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5e, 0xa9,
 102         0xae, 0xbb, 0x57, 0x18, 0x3b, 0x03, 0x3b, 0x64,
 103         0x40, 0x60, 0x00, 0x2a, 0xbf, 0x3f, 0xff, 0x9f,
 104         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
 105         0xff, 0xfc, 0xef, 0x1c, 0x40, 0x00, 0x00, 0x02,
 106         0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
 107         0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x40, 0x00,
 108         0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00,
 109         0x00, 0x35, 0x00, 0x00, 0x11, 0x3f, 0x22, 0x00,
 110         0xf1, 0x00, 0x41, 0x03, 0xb0, 0x00, 0x00, 0x00,
 111         0x1b,
 112 };
 113
 114 /* DAB1.2 settings */
 115 static const struct max2175_reg_map dab12_map[] = {
 116         { 0x01, 0x13 }, { 0x02, 0x0d }, { 0x03, 0x15 }, { 0x04, 0x55 },
 117         { 0x05, 0x0a }, { 0x06, 0xa0 }, { 0x07, 0x40 }, { 0x08, 0x00 },
 118         { 0x09, 0x00 }, { 0x0a, 0x7d }, { 0x0b, 0x4a }, { 0x0c, 0x28 },
 119         { 0x0e, 0x43 }, { 0x0f, 0xb5 }, { 0x10, 0x31 }, { 0x11, 0x9e },
 120         { 0x12, 0x68 }, { 0x13, 0x9e }, { 0x14, 0x68 }, { 0x15, 0x58 },
 121         { 0x16, 0x2f }, { 0x17, 0x3f }, { 0x18, 0x40 }, { 0x1a, 0x88 },
 122         { 0x1b, 0xaa }, { 0x1c, 0x9a }, { 0x1d, 0x00 }, { 0x1e, 0x00 },
 123         { 0x23, 0x80 }, { 0x24, 0x00 }, { 0x25, 0x00 }, { 0x26, 0x00 },
 124         { 0x27, 0x00 }, { 0x32, 0x08 }, { 0x33, 0xf8 }, { 0x36, 0x2d },
 125         { 0x37, 0x7e }, { 0x55, 0xaf }, { 0x56, 0x3f }, { 0x57, 0xf8 },
 126         { 0x58, 0x99 }, { 0x76, 0x00 }, { 0x77, 0x00 }, { 0x78, 0x02 },
 127         { 0x79, 0x40 }, { 0x82, 0x00 }, { 0x83, 0x00 }, { 0x85, 0x00 },
 128         { 0x86, 0x20 },
 129 };
 130
 131 /* EU FM 1.2 settings */
 132 static const struct max2175_reg_map fmeu1p2_map[] = {
 133         { 0x01, 0x15 }, { 0x02, 0x04 }, { 0x03, 0xb8 }, { 0x04, 0xe3 },
 134         { 0x05, 0x35 }, { 0x06, 0x18 }, { 0x07, 0x7c }, { 0x08, 0x00 },
 135         { 0x09, 0x00 }, { 0x0a, 0x73 }, { 0x0b, 0x40 }, { 0x0c, 0x08 },
 136         { 0x0e, 0x7a }, { 0x0f, 0x88 }, { 0x10, 0x91 }, { 0x11, 0x61 },
 137         { 0x12, 0x61 }, { 0x13, 0x61 }, { 0x14, 0x61 }, { 0x15, 0x5a },
 138         { 0x16, 0x0f }, { 0x17, 0x34 }, { 0x18, 0x1c }, { 0x1a, 0x88 },
 139         { 0x1b, 0x33 }, { 0x1c, 0x02 }, { 0x1d, 0x00 }, { 0x1e, 0x01 },
 140         { 0x23, 0x80 }, { 0x24, 0x00 }, { 0x25, 0x95 }, { 0x26, 0x05 },
 141         { 0x27, 0x2c }, { 0x32, 0x08 }, { 0x33, 0xa8 }, { 0x36, 0x2f },
 142         { 0x37, 0x7e }, { 0x55, 0xbf }, { 0x56, 0x3f }, { 0x57, 0xff },
 143         { 0x58, 0x9f }, { 0x76, 0xac }, { 0x77, 0x40 }, { 0x78, 0x00 },
 144         { 0x79, 0x00 }, { 0x82, 0x47 }, { 0x83, 0x00 }, { 0x85, 0x11 },
 145         { 0x86, 0x3f },
 146 };
 147
 148 /* FM NA 1.0 settings */
 149 static const struct max2175_reg_map fmna1p0_map[] = {
 150         { 0x01, 0x13 }, { 0x02, 0x08 }, { 0x03, 0x8d }, { 0x04, 0xc0 },
 151         { 0x05, 0x35 }, { 0x06, 0x18 }, { 0x07, 0x7d }, { 0x08, 0x3f },
 152         { 0x09, 0x7d }, { 0x0a, 0x75 }, { 0x0b, 0x40 }, { 0x0c, 0x08 },
 153         { 0x0e, 0x7a }, { 0x0f, 0x88 }, { 0x10, 0x91 }, { 0x11, 0x61 },
 154         { 0x12, 0x61 }, { 0x13, 0x61 }, { 0x14, 0x61 }, { 0x15, 0x5c },
 155         { 0x16, 0x0f }, { 0x17, 0x34 }, { 0x18, 0x1c }, { 0x1a, 0x88 },
 156         { 0x1b, 0x33 }, { 0x1c, 0x02 }, { 0x1d, 0x00 }, { 0x1e, 0x01 },
 157         { 0x23, 0x80 }, { 0x24, 0x00 }, { 0x25, 0x95 }, { 0x26, 0x05 },
 158         { 0x27, 0x2c }, { 0x32, 0x08 }, { 0x33, 0xa8 }, { 0x36, 0xaf },
 159         { 0x37, 0x7e }, { 0x55, 0xbf }, { 0x56, 0x3f }, { 0x57, 0xff },
 160         { 0x58, 0x9f }, { 0x76, 0xa6 }, { 0x77, 0x40 }, { 0x78, 0x00 },
 161         { 0x79, 0x00 }, { 0x82, 0x35 }, { 0x83, 0x00 }, { 0x85, 0x11 },
 162         { 0x86, 0x3f },
 163 };
 164
 165 /* FM NA 2.0 settings */
 166 static const struct max2175_reg_map fmna2p0_map[] = {
 167         { 0x01, 0x13 }, { 0x02, 0x08 }, { 0x03, 0x8d }, { 0x04, 0xc0 },
 168         { 0x05, 0x35 }, { 0x06, 0x18 }, { 0x07, 0x7c }, { 0x08, 0x54 },
 169         { 0x09, 0xa7 }, { 0x0a, 0x55 }, { 0x0b, 0x42 }, { 0x0c, 0x48 },
 170         { 0x0e, 0x7a }, { 0x0f, 0x88 }, { 0x10, 0x91 }, { 0x11, 0x61 },
 171         { 0x12, 0x61 }, { 0x13, 0x61 }, { 0x14, 0x61 }, { 0x15, 0x5c },
 172         { 0x16, 0x0f }, { 0x17, 0x34 }, { 0x18, 0x1c }, { 0x1a, 0x88 },
 173         { 0x1b, 0x33 }, { 0x1c, 0x02 }, { 0x1d, 0x00 }, { 0x1e, 0x01 },
 174         { 0x23, 0x80 }, { 0x24, 0x00 }, { 0x25, 0x95 }, { 0x26, 0x05 },
 175         { 0x27, 0x2c }, { 0x32, 0x08 }, { 0x33, 0xa8 }, { 0x36, 0xaf },
 176         { 0x37, 0x7e }, { 0x55, 0xbf }, { 0x56, 0x3f }, { 0x57, 0xff },
 177         { 0x58, 0x9f }, { 0x76, 0xac }, { 0x77, 0xc0 }, { 0x78, 0x00 },
 178         { 0x79, 0x00 }, { 0x82, 0x6b }, { 0x83, 0x00 }, { 0x85, 0x11 },
 179         { 0x86, 0x3f },
 180 };
 181
 182 static const u16 ch_coeff_dab1[] = {
 183         0x001c, 0x0007, 0xffcd, 0x0056, 0xffa4, 0x0033, 0x0027, 0xff61,
 184         0x010e, 0xfec0, 0x0106, 0xffb8, 0xff1c, 0x023c, 0xfcb2, 0x039b,
 185         0xfd4e, 0x0055, 0x036a, 0xf7de, 0x0d21, 0xee72, 0x1499, 0x6a51,
 186 };
 187
 188 static const u16 ch_coeff_fmeu[] = {
 189         0x0000, 0xffff, 0x0001, 0x0002, 0xfffa, 0xffff, 0x0015, 0xffec,
 190         0xffde, 0x0054, 0xfff9, 0xff52, 0x00b8, 0x00a2, 0xfe0a, 0x00af,
 191         0x02e3, 0xfc14, 0xfe89, 0x089d, 0xfa2e, 0xf30f, 0x25be, 0x4eb6,
 192 };
 193
 194 static const u16 eq_coeff_fmeu1_ra02_m6db[] = {
 195         0x0040, 0xffc6, 0xfffa, 0x002c, 0x000d, 0xff90, 0x0037, 0x006e,
 196         0xffc0, 0xff5b, 0x006a, 0x00f0, 0xff57, 0xfe94, 0x0112, 0x0252,
 197         0xfe0c, 0xfc6a, 0x0385, 0x0553, 0xfa49, 0xf789, 0x0b91, 0x1a10,
 198 };
 199
 200 static const u16 ch_coeff_fmna[] = {
 201         0x0001, 0x0003, 0xfffe, 0xfff4, 0x0000, 0x001f, 0x000c, 0xffbc,
 202         0xffd3, 0x007d, 0x0075, 0xff33, 0xff01, 0x0131, 0x01ef, 0xfe60,
 203         0xfc7a, 0x020e, 0x0656, 0xfd94, 0xf395, 0x02ab, 0x2857, 0x3d3f,
 204 };
 205
 206 static const u16 eq_coeff_fmna1_ra02_m6db[] = {
 207         0xfff1, 0xffe1, 0xffef, 0x000e, 0x0030, 0x002f, 0xfff6, 0xffa7,
 208         0xff9d, 0x000a, 0x00a2, 0x00b5, 0xffea, 0xfed9, 0xfec5, 0x003d,
 209         0x0217, 0x021b, 0xff5a, 0xfc2b, 0xfcbd, 0x02c4, 0x0ac3, 0x0e85,
 210 };
 211
 212 static const u8 adc_presets[2][23] = {
 213         {
 214                 0x83, 0x00, 0xcf, 0xb4, 0x0f, 0x2c, 0x0c, 0x49,
 215                 0x00, 0x00, 0x00, 0x8c, 0x02, 0x02, 0x00, 0x04,
 216                 0xec, 0x82, 0x4b, 0xcc, 0x01, 0x88, 0x0c,
 217         },
 218         {
 219                 0x83, 0x00, 0xcf, 0xb4, 0x0f, 0x2c, 0x0c, 0x49,
 220                 0x00, 0x00, 0x00, 0x8c, 0x02, 0x20, 0x33, 0x8c,
 221                 0x57, 0xd7, 0x59, 0xb7, 0x65, 0x0e, 0x0c,
 222         },
 223 };
 224
 225 /* Tuner bands */
 226 static const struct v4l2_frequency_band eu_bands_rf = {
 227         .tuner = 0,
 228         .type = V4L2_TUNER_RF,
 229         .index = 0,
 230         .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
 231         .rangelow   = 65000000,
 232         .rangehigh  = 240000000,
 233 };
 234
 235 static const struct v4l2_frequency_band na_bands_rf = {
 236         .tuner = 0,
 237         .type = V4L2_TUNER_RF,
 238         .index = 0,
 239         .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
 240         .rangelow   = 65000000,
 241         .rangehigh  = 108000000,
 242 };
 243
 244 /* Regmap settings */
 245 static const struct regmap_range max2175_regmap_volatile_range[] = {
 246         regmap_reg_range(0x30, 0x35),
 247         regmap_reg_range(0x3a, 0x45),
 248         regmap_reg_range(0x59, 0x5e),
 249         regmap_reg_range(0x73, 0x75),
 250 };
 251
 252 static const struct regmap_access_table max2175_volatile_regs = {
 253         .yes_ranges = max2175_regmap_volatile_range,
 254         .n_yes_ranges = ARRAY_SIZE(max2175_regmap_volatile_range),
 255 };
 256
 257 static const struct reg_default max2175_reg_defaults[] = {
 258         { 0x00, 0x07},
 259 };
 260
 261 static const struct regmap_config max2175_regmap_config = {
 262         .reg_bits = 8,
 263         .val_bits = 8,
 264         .max_register = 0xff,
 265         .reg_defaults = max2175_reg_defaults,
 266         .num_reg_defaults = ARRAY_SIZE(max2175_reg_defaults),
 267         .volatile_table = &max2175_volatile_regs,
 268         .cache_type = REGCACHE_FLAT,
 269 };
 270
 271 struct max2175 {
 272         struct v4l2_subdev sd;          /* Sub-device */
 273         struct i2c_client *client;      /* I2C client */
 274
 275         /* Controls */
 276         struct v4l2_ctrl_handler ctrl_hdl;
 277         struct v4l2_ctrl *lna_gain;     /* LNA gain value */
 278         struct v4l2_ctrl *if_gain;      /* I/F gain value */
 279         struct v4l2_ctrl *pll_lock;     /* PLL lock */
 280         struct v4l2_ctrl *i2s_en;       /* I2S output enable */
 281         struct v4l2_ctrl *hsls;         /* High-side/Low-side polarity */
 282         struct v4l2_ctrl *rx_mode;      /* Receive mode */
 283
 284         /* Regmap */
 285         struct regmap *regmap;
 286
 287         /* Cached configuration */
 288         u32 freq;                       /* Tuned freq In Hz */
 289         const struct max2175_rxmode *rx_modes;          /* EU or NA modes */
 290         const struct v4l2_frequency_band *bands_rf;     /* EU or NA bands */
 291
 292         /* Device settings */
 293         unsigned long xtal_freq;        /* Ref Oscillator freq in Hz */
 294         u32 decim_ratio;
 295         bool master;                    /* Master/Slave */
 296         bool am_hiz;                    /* AM Hi-Z filter */
 297
 298         /* ROM values */
 299         u8 rom_bbf_bw_am;
 300         u8 rom_bbf_bw_fm;
 301         u8 rom_bbf_bw_dab;
 302
 303         /* Driver private variables */
 304         bool mode_resolved;             /* Flag to sanity check settings */
 305 };
 306
 307 static inline struct max2175 *max2175_from_sd(struct v4l2_subdev *sd)
 308 {
 309         return container_of(sd, struct max2175, sd);
 310 }
 311
 312 static inline struct max2175 *max2175_from_ctrl_hdl(struct v4l2_ctrl_handler *h)
 313 {
 314         return container_of(h, struct max2175, ctrl_hdl);
 315 }
 316
 317 /* Get bitval of a given val */
 318 static inline u8 max2175_get_bitval(u8 val, u8 msb, u8 lsb)
 319 {
 320         return (val & GENMASK(msb, lsb)) >> lsb;
 321 }
 322
 323 /* Read/Write bit(s) on top of regmap */
 324 static int max2175_read(struct max2175 *ctx, u8 idx, u8 *val)
 325 {
 326         u32 regval;
 327         int ret;
 328
 329         ret = regmap_read(ctx->regmap, idx, &regval);
 330         if (ret)
 331                 mxm_err(ctx, "read ret(%d): idx 0x%02x\n", ret, idx);
 332         else
 333                 *val = regval;
 334
 335         return ret;
 336 }
 337
 338 static int max2175_write(struct max2175 *ctx, u8 idx, u8 val)
 339 {
 340         int ret;
 341
 342         ret = regmap_write(ctx->regmap, idx, val);
 343         if (ret)
 344                 mxm_err(ctx, "write ret(%d): idx 0x%02x val 0x%02x\n",
 345                         ret, idx, val);
 346
 347         return ret;
 348 }
 349
 350 static u8 max2175_read_bits(struct max2175 *ctx, u8 idx, u8 msb, u8 lsb)
 351 {
 352         u8 val;
 353
 354         if (max2175_read(ctx, idx, &val))
 355                 return 0;
 356
 357         return max2175_get_bitval(val, msb, lsb);
 358 }
 359
 360 static int max2175_write_bits(struct max2175 *ctx, u8 idx,
 361                              u8 msb, u8 lsb, u8 newval)
 362 {
 363         int ret = regmap_update_bits(ctx->regmap, idx, GENMASK(msb, lsb),
 364                                      newval << lsb);
 365
 366         if (ret)
 367                 mxm_err(ctx, "wbits ret(%d): idx 0x%02x\n", ret, idx);
 368
 369         return ret;
 370 }
 371
 372 static int max2175_write_bit(struct max2175 *ctx, u8 idx, u8 bit, u8 newval)
 373 {
 374         return max2175_write_bits(ctx, idx, bit, bit, newval);
 375 }
 376
 377 /* Checks expected pattern every msec until timeout */
 378 static int max2175_poll_timeout(struct max2175 *ctx, u8 idx, u8 msb, u8 lsb,
 379                                 u8 exp_bitval, u32 timeout_us)
 380 {
 381         unsigned int val;
 382
 383         return regmap_read_poll_timeout(ctx->regmap, idx, val,
 384                         (max2175_get_bitval(val, msb, lsb) == exp_bitval),
 385                         1000, timeout_us);
 386 }
 387
 388 static int max2175_poll_csm_ready(struct max2175 *ctx)
 389 {
 390         int ret;
 391
 392         ret = max2175_poll_timeout(ctx, 69, 1, 1, 0, 50000);
 393         if (ret)
 394                 mxm_err(ctx, "csm not ready\n");
 395
 396         return ret;
 397 }
 398
 399 #define MAX2175_IS_BAND_AM(ctx)         \
 400         (max2175_read_bits(ctx, 5, 1, 0) == MAX2175_BAND_AM)
 401
 402 #define MAX2175_IS_BAND_VHF(ctx)        \
 403         (max2175_read_bits(ctx, 5, 1, 0) == MAX2175_BAND_VHF)
 404
 405 #define MAX2175_IS_FM_MODE(ctx)         \
 406         (max2175_read_bits(ctx, 12, 5, 4) == 0)
 407
 408 #define MAX2175_IS_FMHD_MODE(ctx)       \
 409         (max2175_read_bits(ctx, 12, 5, 4) == 1)
 410
 411 #define MAX2175_IS_DAB_MODE(ctx)        \
 412         (max2175_read_bits(ctx, 12, 5, 4) == 2)
 413
 414 static int max2175_band_from_freq(u32 freq)
 415 {
 416         if (freq >= 144000 && freq <= 26100000)
 417                 return MAX2175_BAND_AM;
 418         else if (freq >= 65000000 && freq <= 108000000)
 419                 return MAX2175_BAND_FM;
 420
 421         return MAX2175_BAND_VHF;
 422 }
 423
 424 static void max2175_i2s_enable(struct max2175 *ctx, bool enable)
 425 {
 426         if (enable)
 427                 /* Stuff bits are zeroed */
 428                 max2175_write_bits(ctx, 104, 3, 0, 2);
 429         else
 430                 /* Keep SCK alive */
 431                 max2175_write_bits(ctx, 104, 3, 0, 9);
 432         mxm_dbg(ctx, "i2s %sabled\n", enable ? "en" : "dis");
 433 }
 434
 435 static void max2175_set_filter_coeffs(struct max2175 *ctx, u8 m_sel,
 436                                       u8 bank, const u16 *coeffs)
 437 {
 438         unsigned int i;
 439         u8 coeff_addr, upper_address = 24;
 440
 441         mxm_dbg(ctx, "set_filter_coeffs: m_sel %d bank %d\n", m_sel, bank);
 442         max2175_write_bits(ctx, 114, 5, 4, m_sel);
 443
 444         if (m_sel == 2)
 445                 upper_address = 12;
 446
 447         for (i = 0; i < upper_address; i++) {
 448                 coeff_addr = i + bank * 24;
 449                 max2175_write(ctx, 115, coeffs[i] >> 8);
 450                 max2175_write(ctx, 116, coeffs[i]);
 451                 max2175_write(ctx, 117, coeff_addr | 1 << 7);
 452         }
 453         max2175_write_bit(ctx, 117, 7, 0);
 454 }
 455
 456 static void max2175_load_fmeu_1p2(struct max2175 *ctx)
 457 {
 458         unsigned int i;
 459
 460         for (i = 0; i < ARRAY_SIZE(fmeu1p2_map); i++)
 461                 max2175_write(ctx, fmeu1p2_map[i].idx, fmeu1p2_map[i].val);
 462
 463         ctx->decim_ratio = 36;
 464
 465         /* Load the Channel Filter Coefficients into channel filter bank #2 */
 466         max2175_set_filter_coeffs(ctx, MAX2175_CH_MSEL, 0, ch_coeff_fmeu);
 467         max2175_set_filter_coeffs(ctx, MAX2175_EQ_MSEL, 0,
 468                                   eq_coeff_fmeu1_ra02_m6db);
 469 }
 470
 471 static void max2175_load_dab_1p2(struct max2175 *ctx)
 472 {
 473         unsigned int i;
 474
 475         for (i = 0; i < ARRAY_SIZE(dab12_map); i++)
 476                 max2175_write(ctx, dab12_map[i].idx, dab12_map[i].val);
 477
 478         ctx->decim_ratio = 1;
 479
 480         /* Load the Channel Filter Coefficients into channel filter bank #2 */
 481         max2175_set_filter_coeffs(ctx, MAX2175_CH_MSEL, 2, ch_coeff_dab1);
 482 }
 483
 484 static void max2175_load_fmna_1p0(struct max2175 *ctx)
 485 {
 486         unsigned int i;
 487
 488         for (i = 0; i < ARRAY_SIZE(fmna1p0_map); i++)
 489                 max2175_write(ctx, fmna1p0_map[i].idx, fmna1p0_map[i].val);
 490 }
 491
 492 static void max2175_load_fmna_2p0(struct max2175 *ctx)
 493 {
 494         unsigned int i;
 495
 496         for (i = 0; i < ARRAY_SIZE(fmna2p0_map); i++)
 497                 max2175_write(ctx, fmna2p0_map[i].idx, fmna2p0_map[i].val);
 498 }
 499
 500 static void max2175_set_bbfilter(struct max2175 *ctx)
 501 {
 502         if (MAX2175_IS_BAND_AM(ctx)) {
 503                 max2175_write_bits(ctx, 12, 3, 0, ctx->rom_bbf_bw_am);
 504                 mxm_dbg(ctx, "set_bbfilter AM: rom %d\n", ctx->rom_bbf_bw_am);
 505         } else if (MAX2175_IS_DAB_MODE(ctx)) {
 506                 max2175_write_bits(ctx, 12, 3, 0, ctx->rom_bbf_bw_dab);
 507                 mxm_dbg(ctx, "set_bbfilter DAB: rom %d\n", ctx->rom_bbf_bw_dab);
 508         } else {
 509                 max2175_write_bits(ctx, 12, 3, 0, ctx->rom_bbf_bw_fm);
 510                 mxm_dbg(ctx, "set_bbfilter FM: rom %d\n", ctx->rom_bbf_bw_fm);
 511         }
 512 }
 513
 514 static int max2175_set_csm_mode(struct max2175 *ctx,
 515                           enum max2175_csm_mode new_mode)
 516 {
 517         int ret = max2175_poll_csm_ready(ctx);
 518
 519         if (ret)
 520                 return ret;
 521
 522         max2175_write_bits(ctx, 0, 2, 0, new_mode);
 523         mxm_dbg(ctx, "set csm new mode %d\n", new_mode);
 524
 525         /* Wait for a fixed settle down time depending on new mode */
 526         switch (new_mode) {
 527         case MAX2175_PRESET_TUNE:
 528                 usleep_range(51100, 51500);     /* 51.1ms */
 529                 break;
 530         /*
 531          * Other mode switches need different sleep values depending on band &
 532          * mode
 533          */
 534         default:
 535                 break;
 536         }
 537
 538         return max2175_poll_csm_ready(ctx);
 539 }
 540
 541 static int max2175_csm_action(struct max2175 *ctx,
 542                               enum max2175_csm_mode action)
 543 {
 544         int ret;
 545
 546         mxm_dbg(ctx, "csm_action: %d\n", action);
 547
 548         /* Other actions can be added in future when needed */
 549         ret = max2175_set_csm_mode(ctx, MAX2175_LOAD_TO_BUFFER);
 550         if (ret)
 551                 return ret;
 552
 553         return max2175_set_csm_mode(ctx, MAX2175_PRESET_TUNE);
 554 }
 555
 556 static int max2175_set_lo_freq(struct max2175 *ctx, u32 lo_freq)
 557 {
 558         u8 lo_mult, loband_bits = 0, vcodiv_bits = 0;
 559         u32 int_desired, frac_desired;
 560         enum max2175_band band;
 561         int ret;
 562
 563         band = max2175_read_bits(ctx, 5, 1, 0);
 564         switch (band) {
 565         case MAX2175_BAND_AM:
 566                 lo_mult = 16;
 567                 break;
 568         case MAX2175_BAND_FM:
 569                 if (lo_freq <= 74700000) {
 570                         lo_mult = 16;
 571                 } else if (lo_freq > 74700000 && lo_freq <= 110000000) {
 572                         loband_bits = 1;
 573                         lo_mult = 8;
 574                 } else {
 575                         loband_bits = 1;
 576                         vcodiv_bits = 3;
 577                         lo_mult = 8;
 578                 }
 579                 break;
 580         case MAX2175_BAND_VHF:
 581                 if (lo_freq <= 210000000)
 582                         vcodiv_bits = 2;
 583                 else
 584                         vcodiv_bits = 1;
 585
 586                 loband_bits = 2;
 587                 lo_mult = 4;
 588                 break;
 589         default:
 590                 loband_bits = 3;
 591                 vcodiv_bits = 2;
 592                 lo_mult = 2;
 593                 break;
 594         }
 595
 596         if (band == MAX2175_BAND_L)
 597                 lo_freq /= lo_mult;
 598         else
 599                 lo_freq *= lo_mult;
 600
 601         int_desired = lo_freq / ctx->xtal_freq;
 602         frac_desired = div_u64((u64)(lo_freq % ctx->xtal_freq) << 20,
 603                                ctx->xtal_freq);
 604
 605         /* Check CSM is not busy */
 606         ret = max2175_poll_csm_ready(ctx);
 607         if (ret)
 608                 return ret;
 609
 610         mxm_dbg(ctx, "lo_mult %u int %u  frac %u\n",
 611                 lo_mult, int_desired, frac_desired);
 612
 613         /* Write the calculated values to the appropriate registers */
 614         max2175_write(ctx, 1, int_desired);
 615         max2175_write_bits(ctx, 2, 3, 0, (frac_desired >> 16) & 0xf);
 616         max2175_write(ctx, 3, frac_desired >> 8);
 617         max2175_write(ctx, 4, frac_desired);
 618         max2175_write_bits(ctx, 5, 3, 2, loband_bits);
 619         max2175_write_bits(ctx, 6, 7, 6, vcodiv_bits);
 620
 621         return ret;
 622 }
 623
 624 /*
 625  * Helper similar to DIV_ROUND_CLOSEST but an inline function that accepts s64
 626  * dividend and s32 divisor
 627  */
 628 static inline s64 max2175_round_closest(s64 dividend, s32 divisor)
 629 {
 630         if ((dividend > 0 && divisor > 0) || (dividend < 0 && divisor < 0))
 631                 return div_s64(dividend + divisor / 2, divisor);
 632
 633         return div_s64(dividend - divisor / 2, divisor);
 634 }
 635
 636 static int max2175_set_nco_freq(struct max2175 *ctx, s32 nco_freq)
 637 {
 638         s32 clock_rate = ctx->xtal_freq / ctx->decim_ratio;
 639         u32 nco_reg, abs_nco_freq = abs(nco_freq);
 640         s64 nco_val_desired;
 641         int ret;
 642
 643         if (abs_nco_freq < clock_rate / 2) {
 644                 nco_val_desired = 2 * nco_freq;
 645         } else {
 646                 nco_val_desired = 2LL * (clock_rate - abs_nco_freq);
 647                 if (nco_freq < 0)
 648                         nco_val_desired = -nco_val_desired;
 649         }
 650
 651         nco_reg = max2175_round_closest(nco_val_desired << 20, clock_rate);
 652
 653         if (nco_freq < 0)
 654                 nco_reg += 0x200000;
 655
 656         /* Check CSM is not busy */
 657         ret = max2175_poll_csm_ready(ctx);
 658         if (ret)
 659                 return ret;
 660
 661         mxm_dbg(ctx, "freq %d desired %lld reg %u\n",
 662                 nco_freq, nco_val_desired, nco_reg);
 663
 664         /* Write the calculated values to the appropriate registers */
 665         max2175_write_bits(ctx, 7, 4, 0, (nco_reg >> 16) & 0x1f);
 666         max2175_write(ctx, 8, nco_reg >> 8);
 667         max2175_write(ctx, 9, nco_reg);
 668
 669         return ret;
 670 }
 671
 672 static int max2175_set_rf_freq_non_am_bands(struct max2175 *ctx, u64 freq,
 673                                             u32 lo_pos)
 674 {
 675         s64 adj_freq, low_if_freq;
 676         int ret;
 677
 678         mxm_dbg(ctx, "rf_freq: non AM bands\n");
 679
 680         if (MAX2175_IS_FM_MODE(ctx))
 681                 low_if_freq = 128000;
 682         else if (MAX2175_IS_FMHD_MODE(ctx))
 683                 low_if_freq = 228000;
 684         else
 685                 return max2175_set_lo_freq(ctx, freq);
 686
 687         if (MAX2175_IS_BAND_VHF(ctx) == (lo_pos == MAX2175_LO_ABOVE_DESIRED))
 688                 adj_freq = freq + low_if_freq;
 689         else
 690                 adj_freq = freq - low_if_freq;
 691
 692         ret = max2175_set_lo_freq(ctx, adj_freq);
 693         if (ret)
 694                 return ret;
 695
 696         return max2175_set_nco_freq(ctx, -low_if_freq);
 697 }
 698
 699 static int max2175_set_rf_freq(struct max2175 *ctx, u64 freq, u32 lo_pos)
 700 {
 701         int ret;
 702
 703         if (MAX2175_IS_BAND_AM(ctx))
 704                 ret = max2175_set_nco_freq(ctx, freq);
 705         else
 706                 ret = max2175_set_rf_freq_non_am_bands(ctx, freq, lo_pos);
 707
 708         mxm_dbg(ctx, "set_rf_freq: ret %d freq %llu\n", ret, freq);
 709
 710         return ret;
 711 }
 712
 713 static int max2175_tune_rf_freq(struct max2175 *ctx, u64 freq, u32 hsls)
 714 {
 715         int ret;
 716
 717         ret = max2175_set_rf_freq(ctx, freq, hsls);
 718         if (ret)
 719                 return ret;
 720
 721         ret = max2175_csm_action(ctx, MAX2175_BUFFER_PLUS_PRESET_TUNE);
 722         if (ret)
 723                 return ret;
 724
 725         mxm_dbg(ctx, "tune_rf_freq: old %u new %llu\n", ctx->freq, freq);
 726         ctx->freq = freq;
 727
 728         return ret;
 729 }
 730
 731 static void max2175_set_hsls(struct max2175 *ctx, u32 lo_pos)
 732 {
 733         mxm_dbg(ctx, "set_hsls: lo_pos %u\n", lo_pos);
 734
 735         if ((lo_pos == MAX2175_LO_BELOW_DESIRED) == MAX2175_IS_BAND_VHF(ctx))
 736                 max2175_write_bit(ctx, 5, 4, 1);
 737         else
 738                 max2175_write_bit(ctx, 5, 4, 0);
 739 }
 740
 741 static void max2175_set_eu_rx_mode(struct max2175 *ctx, u32 rx_mode)
 742 {
 743         switch (rx_mode) {
 744         case MAX2175_EU_FM_1_2:
 745                 max2175_load_fmeu_1p2(ctx);
 746                 break;
 747
 748         case MAX2175_DAB_1_2:
 749                 max2175_load_dab_1p2(ctx);
 750                 break;
 751         }
 752         /* Master is the default setting */
 753         if (!ctx->master)
 754                 max2175_write_bit(ctx, 30, 7, 1);
 755 }
 756
 757 static void max2175_set_na_rx_mode(struct max2175 *ctx, u32 rx_mode)
 758 {
 759         switch (rx_mode) {
 760         case MAX2175_NA_FM_1_0:
 761                 max2175_load_fmna_1p0(ctx);
 762                 break;
 763         case MAX2175_NA_FM_2_0:
 764                 max2175_load_fmna_2p0(ctx);
 765                 break;
 766         }
 767         /* Master is the default setting */
 768         if (!ctx->master)
 769                 max2175_write_bit(ctx, 30, 7, 1);
 770
 771         ctx->decim_ratio = 27;
 772
 773         /* Load the Channel Filter Coefficients into channel filter bank #2 */
 774         max2175_set_filter_coeffs(ctx, MAX2175_CH_MSEL, 0, ch_coeff_fmna);
 775         max2175_set_filter_coeffs(ctx, MAX2175_EQ_MSEL, 0,
 776                                   eq_coeff_fmna1_ra02_m6db);
 777 }
 778
 779 static int max2175_set_rx_mode(struct max2175 *ctx, u32 rx_mode)
 780 {
 781         mxm_dbg(ctx, "set_rx_mode: %u am_hiz %u\n", rx_mode, ctx->am_hiz);
 782         if (ctx->xtal_freq == MAX2175_EU_XTAL_FREQ)
 783                 max2175_set_eu_rx_mode(ctx, rx_mode);
 784         else
 785                 max2175_set_na_rx_mode(ctx, rx_mode);
 786
 787         if (ctx->am_hiz) {
 788                 mxm_dbg(ctx, "setting AM HiZ related config\n");
 789                 max2175_write_bit(ctx, 50, 5, 1);
 790                 max2175_write_bit(ctx, 90, 7, 1);
 791                 max2175_write_bits(ctx, 73, 1, 0, 2);
 792                 max2175_write_bits(ctx, 80, 5, 0, 33);
 793         }
 794
 795         /* Load BB filter trim values saved in ROM */
 796         max2175_set_bbfilter(ctx);
 797
 798         /* Set HSLS */
 799         max2175_set_hsls(ctx, ctx->hsls->cur.val);
 800
 801         /* Use i2s enable settings */
 802         max2175_i2s_enable(ctx, ctx->i2s_en->cur.val);
 803
 804         ctx->mode_resolved = true;
 805
 806         return 0;
 807 }
 808
 809 static int max2175_rx_mode_from_freq(struct max2175 *ctx, u32 freq, u32 *mode)
 810 {
 811         unsigned int i;
 812         int band = max2175_band_from_freq(freq);
 813
 814         /* Pick the first match always */
 815         for (i = 0; i <= ctx->rx_mode->maximum; i++) {
 816                 if (ctx->rx_modes[i].band == band) {
 817                         *mode = i;
 818                         mxm_dbg(ctx, "rx_mode_from_freq: freq %u mode %d\n",
 819                                 freq, *mode);
 820                         return 0;
 821                 }
 822         }
 823
 824         return -EINVAL;
 825 }
 826
 827 static bool max2175_freq_rx_mode_valid(struct max2175 *ctx,
 828                                          u32 mode, u32 freq)
 829 {
 830         int band = max2175_band_from_freq(freq);
 831
 832         return (ctx->rx_modes[mode].band == band);
 833 }
 834
 835 static void max2175_load_adc_presets(struct max2175 *ctx)
 836 {
 837         unsigned int i, j;
 838
 839         for (i = 0; i < ARRAY_SIZE(adc_presets); i++)
 840                 for (j = 0; j < ARRAY_SIZE(adc_presets[0]); j++)
 841                         max2175_write(ctx, 146 + j + i * 55, adc_presets[i][j]);
 842 }
 843
 844 static int max2175_init_power_manager(struct max2175 *ctx)
 845 {
 846         int ret;
 847
 848         /* Execute on-chip power-up/calibration */
 849         max2175_write_bit(ctx, 99, 2, 0);
 850         usleep_range(1000, 1500);
 851         max2175_write_bit(ctx, 99, 2, 1);
 852
 853         /* Wait for the power manager to finish. */
 854         ret = max2175_poll_timeout(ctx, 69, 7, 7, 1, 50000);
 855         if (ret)
 856                 mxm_err(ctx, "init pm failed\n");
 857
 858         return ret;
 859 }
 860
 861 static int max2175_recalibrate_adc(struct max2175 *ctx)
 862 {
 863         int ret;
 864
 865         /* ADC Re-calibration */
 866         max2175_write(ctx, 150, 0xff);
 867         max2175_write(ctx, 205, 0xff);
 868         max2175_write(ctx, 147, 0x20);
 869         max2175_write(ctx, 147, 0x00);
 870         max2175_write(ctx, 202, 0x20);
 871         max2175_write(ctx, 202, 0x00);
 872
 873         ret = max2175_poll_timeout(ctx, 69, 4, 3, 3, 50000);
 874         if (ret)
 875                 mxm_err(ctx, "adc recalibration failed\n");
 876
 877         return ret;
 878 }
 879
 880 static u8 max2175_read_rom(struct max2175 *ctx, u8 row)
 881 {
 882         u8 data = 0;
 883
 884         max2175_write_bit(ctx, 56, 4, 0);
 885         max2175_write_bits(ctx, 56, 3, 0, row);
 886
 887         usleep_range(2000, 2500);
 888         max2175_read(ctx, 58, &data);
 889
 890         max2175_write_bits(ctx, 56, 3, 0, 0);
 891
 892         mxm_dbg(ctx, "read_rom: row %d data 0x%02x\n", row, data);
 893
 894         return data;
 895 }
 896
 897 static void max2175_load_from_rom(struct max2175 *ctx)
 898 {
 899         u8 data = 0;
 900
 901         data = max2175_read_rom(ctx, 0);
 902         ctx->rom_bbf_bw_am = data & 0x0f;
 903         max2175_write_bits(ctx, 81, 3, 0, data >> 4);
 904
 905         data = max2175_read_rom(ctx, 1);
 906         ctx->rom_bbf_bw_fm = data & 0x0f;
 907         ctx->rom_bbf_bw_dab = data >> 4;
 908
 909         data = max2175_read_rom(ctx, 2);
 910         max2175_write_bits(ctx, 82, 4, 0, data & 0x1f);
 911         max2175_write_bits(ctx, 82, 7, 5, data >> 5);
 912
 913         data = max2175_read_rom(ctx, 3);
 914         if (ctx->am_hiz) {
 915                 data &= 0x0f;
 916                 data |= (max2175_read_rom(ctx, 7) & 0x40) >> 2;
 917                 if (!data)
 918                         data |= 2;
 919         } else {
 920                 data = (data & 0xf0) >> 4;
 921                 data |= (max2175_read_rom(ctx, 7) & 0x80) >> 3;
 922                 if (!data)
 923                         data |= 30;
 924         }
 925         max2175_write_bits(ctx, 80, 5, 0, data + 31);
 926
 927         data = max2175_read_rom(ctx, 6);
 928         max2175_write_bits(ctx, 81, 7, 6, data >> 6);
 929 }
 930
 931 static void max2175_load_full_fm_eu_1p0(struct max2175 *ctx)
 932 {
 933         unsigned int i;
 934
 935         for (i = 0; i < ARRAY_SIZE(full_fm_eu_1p0); i++)
 936                 max2175_write(ctx, i + 1, full_fm_eu_1p0[i]);
 937
 938         usleep_range(5000, 5500);
 939         ctx->decim_ratio = 36;
 940 }
 941
 942 static void max2175_load_full_fm_na_1p0(struct max2175 *ctx)
 943 {
 944         unsigned int i;
 945
 946         for (i = 0; i < ARRAY_SIZE(full_fm_na_1p0); i++)
 947                 max2175_write(ctx, i + 1, full_fm_na_1p0[i]);
 948
 949         usleep_range(5000, 5500);
 950         ctx->decim_ratio = 27;
 951 }
 952
 953 static int max2175_core_init(struct max2175 *ctx, u32 refout_bits)
 954 {
 955         int ret;
 956
 957         /* MAX2175 uses 36.864MHz clock for EU & 40.154MHz for NA region */
 958         if (ctx->xtal_freq == MAX2175_EU_XTAL_FREQ)
 959                 max2175_load_full_fm_eu_1p0(ctx);
 960         else
 961                 max2175_load_full_fm_na_1p0(ctx);
 962
 963         /* The default settings assume master */
 964         if (!ctx->master)
 965                 max2175_write_bit(ctx, 30, 7, 1);
 966
 967         mxm_dbg(ctx, "refout_bits %u\n", refout_bits);
 968
 969         /* Set REFOUT */
 970         max2175_write_bits(ctx, 56, 7, 5, refout_bits);
 971
 972         /* ADC Reset */
 973         max2175_write_bit(ctx, 99, 1, 0);
 974         usleep_range(1000, 1500);
 975         max2175_write_bit(ctx, 99, 1, 1);
 976
 977         /* Load ADC preset values */
 978         max2175_load_adc_presets(ctx);
 979
 980         /* Initialize the power management state machine */
 981         ret = max2175_init_power_manager(ctx);
 982         if (ret)
 983                 return ret;
 984
 985         /* Recalibrate ADC */
 986         ret = max2175_recalibrate_adc(ctx);
 987         if (ret)
 988                 return ret;
 989
 990         /* Load ROM values to appropriate registers */
 991         max2175_load_from_rom(ctx);
 992
 993         if (ctx->xtal_freq == MAX2175_EU_XTAL_FREQ) {
 994                 /* Load FIR coefficients into bank 0 */
 995                 max2175_set_filter_coeffs(ctx, MAX2175_CH_MSEL, 0,
 996                                           ch_coeff_fmeu);
 997                 max2175_set_filter_coeffs(ctx, MAX2175_EQ_MSEL, 0,
 998                                           eq_coeff_fmeu1_ra02_m6db);
 999         } else {
1000                 /* Load FIR coefficients into bank 0 */
1001                 max2175_set_filter_coeffs(ctx, MAX2175_CH_MSEL, 0,
1002                                           ch_coeff_fmna);
1003                 max2175_set_filter_coeffs(ctx, MAX2175_EQ_MSEL, 0,
1004                                           eq_coeff_fmna1_ra02_m6db);
1005         }
1006         mxm_dbg(ctx, "core initialized\n");
1007
1008         return 0;
1009 }
1010
1011 static void max2175_s_ctrl_rx_mode(struct max2175 *ctx, u32 rx_mode)
1012 {
1013         /* Load mode. Range check already done */
1014         max2175_set_rx_mode(ctx, rx_mode);
1015
1016         mxm_dbg(ctx, "s_ctrl_rx_mode: %u curr freq %u\n", rx_mode, ctx->freq);
1017
1018         /* Check if current freq valid for mode & update */
1019         if (max2175_freq_rx_mode_valid(ctx, rx_mode, ctx->freq))
1020                 max2175_tune_rf_freq(ctx, ctx->freq, ctx->hsls->cur.val);
1021         else
1022                 /* Use default freq of mode if current freq is not valid */
1023                 max2175_tune_rf_freq(ctx, ctx->rx_modes[rx_mode].freq,
1024                                      ctx->hsls->cur.val);
1025 }
1026
1027 static int max2175_s_ctrl(struct v4l2_ctrl *ctrl)
1028 {
1029         struct max2175 *ctx = max2175_from_ctrl_hdl(ctrl->handler);
1030
1031         mxm_dbg(ctx, "s_ctrl: id 0x%x, val %u\n", ctrl->id, ctrl->val);
1032         switch (ctrl->id) {
1033         case V4L2_CID_MAX2175_I2S_ENABLE:
1034                 max2175_i2s_enable(ctx, ctrl->val);
1035                 break;
1036         case V4L2_CID_MAX2175_HSLS:
1037                 max2175_set_hsls(ctx, ctrl->val);
1038                 break;
1039         case V4L2_CID_MAX2175_RX_MODE:
1040                 max2175_s_ctrl_rx_mode(ctx, ctrl->val);
1041                 break;
1042         }
1043
1044         return 0;
1045 }
1046
1047 static u32 max2175_get_lna_gain(struct max2175 *ctx)
1048 {
1049         enum max2175_band band = max2175_read_bits(ctx, 5, 1, 0);
1050
1051         switch (band) {
1052         case MAX2175_BAND_AM:
1053                 return max2175_read_bits(ctx, 51, 3, 0);
1054         case MAX2175_BAND_FM:
1055                 return max2175_read_bits(ctx, 50, 3, 0);
1056         case MAX2175_BAND_VHF:
1057                 return max2175_read_bits(ctx, 52, 5, 0);
1058         default:
1059                 return 0;
1060         }
1061 }
1062
1063 static int max2175_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1064 {
1065         struct max2175 *ctx = max2175_from_ctrl_hdl(ctrl->handler);
1066
1067         switch (ctrl->id) {
1068         case V4L2_CID_RF_TUNER_LNA_GAIN:
1069                 ctrl->val = max2175_get_lna_gain(ctx);
1070                 break;
1071         case V4L2_CID_RF_TUNER_IF_GAIN:
1072                 ctrl->val = max2175_read_bits(ctx, 49, 4, 0);
1073                 break;
1074         case V4L2_CID_RF_TUNER_PLL_LOCK:
1075                 ctrl->val = (max2175_read_bits(ctx, 60, 7, 6) == 3);
1076                 break;
1077         }
1078
1079         return 0;
1080 };
1081
1082 static int max2175_set_freq_and_mode(struct max2175 *ctx, u32 freq)
1083 {
1084         u32 rx_mode;
1085         int ret;
1086
1087         /* Get band from frequency */
1088         ret = max2175_rx_mode_from_freq(ctx, freq, &rx_mode);
1089         if (ret)
1090                 return ret;
1091
1092         mxm_dbg(ctx, "set_freq_and_mode: freq %u rx_mode %d\n", freq, rx_mode);
1093
1094         /* Load mode */
1095         max2175_set_rx_mode(ctx, rx_mode);
1096         ctx->rx_mode->cur.val = rx_mode;
1097
1098         /* Tune to the new freq given */
1099         return max2175_tune_rf_freq(ctx, freq, ctx->hsls->cur.val);
1100 }
1101
1102 static int max2175_s_frequency(struct v4l2_subdev *sd,
1103                                const struct v4l2_frequency *vf)
1104 {
1105         struct max2175 *ctx = max2175_from_sd(sd);
1106         u32 freq;
1107         int ret = 0;
1108
1109         mxm_dbg(ctx, "s_freq: new %u curr %u, mode_resolved %d\n",
1110                 vf->frequency, ctx->freq, ctx->mode_resolved);
1111
1112         if (vf->tuner != 0)
1113                 return -EINVAL;
1114
1115         freq = clamp(vf->frequency, ctx->bands_rf->rangelow,
1116                      ctx->bands_rf->rangehigh);
1117
1118         /* Check new freq valid for rx_mode if already resolved */
1119         if (ctx->mode_resolved &&
1120             max2175_freq_rx_mode_valid(ctx, ctx->rx_mode->cur.val, freq))
1121                 ret = max2175_tune_rf_freq(ctx, freq, ctx->hsls->cur.val);
1122         else
1123                 /* Find default rx_mode for freq and tune to it */
1124                 ret = max2175_set_freq_and_mode(ctx, freq);
1125
1126         mxm_dbg(ctx, "s_freq: ret %d curr %u mode_resolved %d mode %u\n",
1127                 ret, ctx->freq, ctx->mode_resolved, ctx->rx_mode->cur.val);
1128
1129         return ret;
1130 }
1131
1132 static int max2175_g_frequency(struct v4l2_subdev *sd,
1133                                struct v4l2_frequency *vf)
1134 {
1135         struct max2175 *ctx = max2175_from_sd(sd);
1136         int ret = 0;
1137
1138         if (vf->tuner != 0)
1139                 return -EINVAL;
1140
1141         /* RF freq */
1142         vf->type = V4L2_TUNER_RF;
1143         vf->frequency = ctx->freq;
1144
1145         return ret;
1146 }
1147
1148 static int max2175_enum_freq_bands(struct v4l2_subdev *sd,
1149                             struct v4l2_frequency_band *band)
1150 {
1151         struct max2175 *ctx = max2175_from_sd(sd);
1152
1153         if (band->tuner != 0 || band->index != 0)
1154                 return -EINVAL;
1155
1156         *band = *ctx->bands_rf;
1157
1158         return 0;
1159 }
1160
1161 static int max2175_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1162 {
1163         struct max2175 *ctx = max2175_from_sd(sd);
1164
1165         if (vt->index > 0)
1166                 return -EINVAL;
1167
1168         strlcpy(vt->name, "RF", sizeof(vt->name));
1169         vt->type = V4L2_TUNER_RF;
1170         vt->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1171         vt->rangelow = ctx->bands_rf->rangelow;
1172         vt->rangehigh = ctx->bands_rf->rangehigh;
1173
1174         return 0;
1175 }
1176
1177 static int max2175_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1178 {
1179         /* Check tuner index is valid */
1180         if (vt->index > 0)
1181                 return -EINVAL;
1182
1183         return 0;
1184 }
1185
1186 static const struct v4l2_subdev_tuner_ops max2175_tuner_ops = {
1187         .s_frequency = max2175_s_frequency,
1188         .g_frequency = max2175_g_frequency,
1189         .enum_freq_bands = max2175_enum_freq_bands,
1190         .g_tuner = max2175_g_tuner,
1191         .s_tuner = max2175_s_tuner,
1192 };
1193
1194 static const struct v4l2_subdev_ops max2175_ops = {
1195         .tuner = &max2175_tuner_ops,
1196 };
1197
1198 static const struct v4l2_ctrl_ops max2175_ctrl_ops = {
1199         .s_ctrl = max2175_s_ctrl,
1200         .g_volatile_ctrl = max2175_g_volatile_ctrl,
1201 };
1202
1203 /*
1204  * I2S output enable/disable configuration. This is a private control.
1205  * Refer to Documentation/media/v4l-drivers/max2175.rst for more details.
1206  */
1207 static const struct v4l2_ctrl_config max2175_i2s_en = {
1208         .ops = &max2175_ctrl_ops,
1209         .id = V4L2_CID_MAX2175_I2S_ENABLE,
1210         .name = "I2S Enable",
1211         .type = V4L2_CTRL_TYPE_BOOLEAN,
1212         .min = 0,
1213         .max = 1,
1214         .step = 1,
1215         .def = 1,
1216         .is_private = 1,
1217 };
1218
1219 /*
1220  * HSLS value control LO freq adjacent location configuration.
1221  * Refer to Documentation/media/v4l-drivers/max2175.rst for more details.
1222  */
1223 static const struct v4l2_ctrl_config max2175_hsls = {
1224         .ops = &max2175_ctrl_ops,
1225         .id = V4L2_CID_MAX2175_HSLS,
1226         .name = "HSLS Above/Below Desired",
1227         .type = V4L2_CTRL_TYPE_BOOLEAN,
1228         .min = 0,
1229         .max = 1,
1230         .step = 1,
1231         .def = 1,
1232 };
1233
1234 /*
1235  * Rx modes below are a set of preset configurations that decides the tuner's
1236  * sck and sample rate of transmission. They are separate for EU & NA regions.
1237  * Refer to Documentation/media/v4l-drivers/max2175.rst for more details.
1238  */
1239 static const char * const max2175_ctrl_eu_rx_modes[] = {
1240         [MAX2175_EU_FM_1_2]     = "EU FM 1.2",
1241         [MAX2175_DAB_1_2]       = "DAB 1.2",
1242 };
1243
1244 static const char * const max2175_ctrl_na_rx_modes[] = {
1245         [MAX2175_NA_FM_1_0]     = "NA FM 1.0",
1246         [MAX2175_NA_FM_2_0]     = "NA FM 2.0",
1247 };
1248
1249 static const struct v4l2_ctrl_config max2175_eu_rx_mode = {
1250         .ops = &max2175_ctrl_ops,
1251         .id = V4L2_CID_MAX2175_RX_MODE,
1252         .name = "RX Mode",
1253         .type = V4L2_CTRL_TYPE_MENU,
1254         .max = ARRAY_SIZE(max2175_ctrl_eu_rx_modes) - 1,
1255         .def = 0,
1256         .qmenu = max2175_ctrl_eu_rx_modes,
1257 };
1258
1259 static const struct v4l2_ctrl_config max2175_na_rx_mode = {
1260         .ops = &max2175_ctrl_ops,
1261         .id = V4L2_CID_MAX2175_RX_MODE,
1262         .name = "RX Mode",
1263         .type = V4L2_CTRL_TYPE_MENU,
1264         .max = ARRAY_SIZE(max2175_ctrl_na_rx_modes) - 1,
1265         .def = 0,
1266         .qmenu = max2175_ctrl_na_rx_modes,
1267 };
1268
1269 static int max2175_refout_load_to_bits(struct i2c_client *client, u32 load,
1270                                        u32 *bits)
1271 {
1272         if (load <= 40)
1273                 *bits = load / 10;
1274         else if (load >= 60 && load <= 70)
1275                 *bits = load / 10 - 1;
1276         else
1277                 return -EINVAL;
1278
1279         return 0;
1280 }
1281
1282 static int max2175_probe(struct i2c_client *client,
1283                         const struct i2c_device_id *id)
1284 {
1285         bool master = true, am_hiz = false;
1286         u32 refout_load, refout_bits = 0;       /* REFOUT disabled */
1287         struct v4l2_ctrl_handler *hdl;
1288         struct fwnode_handle *fwnode;
1289         struct device_node *np;
1290         struct v4l2_subdev *sd;
1291         struct regmap *regmap;
1292         struct max2175 *ctx;
1293         struct clk *clk;
1294         int ret;
1295
1296         /* Parse DT properties */
1297         np = of_parse_phandle(client->dev.of_node, "maxim,master", 0);
1298         if (np) {
1299                 master = false;                 /* Slave tuner */
1300                 of_node_put(np);
1301         }
1302
1303         fwnode = of_fwnode_handle(client->dev.of_node);
1304         if (fwnode_property_present(fwnode, "maxim,am-hiz-filter"))
1305                 am_hiz = true;
1306
1307         if (!fwnode_property_read_u32(fwnode, "maxim,refout-load",
1308                                       &refout_load)) {
1309                 ret = max2175_refout_load_to_bits(client, refout_load,
1310                                                   &refout_bits);
1311                 if (ret) {
1312                         dev_err(&client->dev, "invalid refout_load %u\n",
1313                                 refout_load);
1314                         return -EINVAL;
1315                 }
1316         }
1317
1318         clk = devm_clk_get(&client->dev, NULL);
1319         if (IS_ERR(clk)) {
1320                 ret = PTR_ERR(clk);
1321                 dev_err(&client->dev, "cannot get clock %d\n", ret);
1322                 return ret;
1323         }
1324
1325         regmap = devm_regmap_init_i2c(client, &max2175_regmap_config);
1326         if (IS_ERR(regmap)) {
1327                 ret = PTR_ERR(regmap);
1328                 dev_err(&client->dev, "regmap init failed %d\n", ret);
1329                 return -ENODEV;
1330         }
1331
1332         /* Alloc tuner context */
1333         ctx = devm_kzalloc(&client->dev, sizeof(*ctx), GFP_KERNEL);
1334         if (ctx == NULL)
1335                 return -ENOMEM;
1336
1337         sd = &ctx->sd;
1338         ctx->master = master;
1339         ctx->am_hiz = am_hiz;
1340         ctx->mode_resolved = false;
1341         ctx->regmap = regmap;
1342         ctx->xtal_freq = clk_get_rate(clk);
1343         dev_info(&client->dev, "xtal freq %luHz\n", ctx->xtal_freq);
1344
1345         v4l2_i2c_subdev_init(sd, client, &max2175_ops);
1346         ctx->client = client;
1347
1348         sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1349
1350         /* Controls */
1351         hdl = &ctx->ctrl_hdl;
1352         ret = v4l2_ctrl_handler_init(hdl, 7);
1353         if (ret)
1354                 return ret;
1355
1356         ctx->lna_gain = v4l2_ctrl_new_std(hdl, &max2175_ctrl_ops,
1357                                           V4L2_CID_RF_TUNER_LNA_GAIN,
1358                                           0, 63, 1, 0);
1359         ctx->lna_gain->flags |= (V4L2_CTRL_FLAG_VOLATILE |
1360                                  V4L2_CTRL_FLAG_READ_ONLY);
1361         ctx->if_gain = v4l2_ctrl_new_std(hdl, &max2175_ctrl_ops,
1362                                          V4L2_CID_RF_TUNER_IF_GAIN,
1363                                          0, 31, 1, 0);
1364         ctx->if_gain->flags |= (V4L2_CTRL_FLAG_VOLATILE |
1365                                 V4L2_CTRL_FLAG_READ_ONLY);
1366         ctx->pll_lock = v4l2_ctrl_new_std(hdl, &max2175_ctrl_ops,
1367                                           V4L2_CID_RF_TUNER_PLL_LOCK,
1368                                           0, 1, 1, 0);
1369         ctx->pll_lock->flags |= (V4L2_CTRL_FLAG_VOLATILE |
1370                                  V4L2_CTRL_FLAG_READ_ONLY);
1371         ctx->i2s_en = v4l2_ctrl_new_custom(hdl, &max2175_i2s_en, NULL);
1372         ctx->hsls = v4l2_ctrl_new_custom(hdl, &max2175_hsls, NULL);
1373
1374         if (ctx->xtal_freq == MAX2175_EU_XTAL_FREQ) {
1375                 ctx->rx_mode = v4l2_ctrl_new_custom(hdl,
1376                                                     &max2175_eu_rx_mode, NULL);
1377                 ctx->rx_modes = eu_rx_modes;
1378                 ctx->bands_rf = &eu_bands_rf;
1379         } else {
1380                 ctx->rx_mode = v4l2_ctrl_new_custom(hdl,
1381                                                     &max2175_na_rx_mode, NULL);
1382                 ctx->rx_modes = na_rx_modes;
1383                 ctx->bands_rf = &na_bands_rf;
1384         }
1385         ctx->sd.ctrl_handler = &ctx->ctrl_hdl;
1386
1387         /* Set the defaults */
1388         ctx->freq = ctx->bands_rf->rangelow;
1389
1390         /* Register subdev */
1391         ret = v4l2_async_register_subdev(sd);
1392         if (ret) {
1393                 dev_err(&client->dev, "register subdev failed\n");
1394                 goto err_reg;
1395         }
1396
1397         /* Initialize device */
1398         ret = max2175_core_init(ctx, refout_bits);
1399         if (ret)
1400                 goto err_init;
1401
1402         ret = v4l2_ctrl_handler_setup(hdl);
1403         if (ret)
1404                 goto err_init;
1405
1406         return 0;
1407
1408 err_init:
1409         v4l2_async_unregister_subdev(sd);
1410 err_reg:
1411         v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
1412
1413         return ret;
1414 }
1415
1416 static int max2175_remove(struct i2c_client *client)
1417 {
1418         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1419         struct max2175 *ctx = max2175_from_sd(sd);
1420
1421         v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
1422         v4l2_async_unregister_subdev(sd);
1423
1424         return 0;
1425 }
1426
1427 static const struct i2c_device_id max2175_id[] = {
1428         { DRIVER_NAME, 0},
1429         {},
1430 };
1431 MODULE_DEVICE_TABLE(i2c, max2175_id);
1432
1433 static const struct of_device_id max2175_of_ids[] = {
1434         { .compatible = "maxim,max2175", },
1435         { }
1436 };
1437 MODULE_DEVICE_TABLE(of, max2175_of_ids);
1438
1439 static struct i2c_driver max2175_driver = {
1440         .driver = {
1441                 .name   = DRIVER_NAME,
1442                 .of_match_table = max2175_of_ids,
1443         },
1444         .probe          = max2175_probe,
1445         .remove         = max2175_remove,
1446         .id_table       = max2175_id,
1447 };
1448
1449 module_i2c_driver(max2175_driver);
1450
1451 MODULE_DESCRIPTION("Maxim MAX2175 RF to Bits tuner driver");
1452 MODULE_LICENSE("GPL v2");
1453 MODULE_AUTHOR("Ramesh Shanmugasundaram <ramesh.shanmugasundaram@bp.renesas.com>");