1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // peb2466.c -- Infineon PEB2466 ALSA SoC driver 4 // 5 // Copyright 2023 CS GROUP France 6 // 7 // Author: Herve Codina <herve.codina@bootlin.com> 8 9 #include <asm/unaligned.h> 10 #include <linux/clk.h> 11 #include <linux/firmware.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/gpio/driver.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/slab.h> 17 #include <linux/spi/spi.h> 18 #include <sound/pcm_params.h> 19 #include <sound/soc.h> 20 #include <sound/tlv.h> 21 22 #define PEB2466_NB_CHANNEL 4 23 24 struct peb2466_lookup { 25 u8 (*table)[4]; 26 unsigned int count; 27 }; 28 29 #define PEB2466_TLV_SIZE (sizeof((unsigned int []){TLV_DB_SCALE_ITEM(0, 0, 0)}) / \ 30 sizeof(unsigned int)) 31 32 struct peb2466_lkup_ctrl { 33 int reg; 34 unsigned int index; 35 const struct peb2466_lookup *lookup; 36 unsigned int tlv_array[PEB2466_TLV_SIZE]; 37 }; 38 39 struct peb2466 { 40 struct spi_device *spi; 41 struct clk *mclk; 42 struct gpio_desc *reset_gpio; 43 u8 spi_tx_buf[2 + 8]; /* Cannot use stack area for SPI (dma-safe memory) */ 44 u8 spi_rx_buf[2 + 8]; /* Cannot use stack area for SPI (dma-safe memory) */ 45 struct regmap *regmap; 46 struct { 47 struct peb2466_lookup ax_lookup; 48 struct peb2466_lookup ar_lookup; 49 struct peb2466_lkup_ctrl ax_lkup_ctrl; 50 struct peb2466_lkup_ctrl ar_lkup_ctrl; 51 unsigned int tg1_freq_item; 52 unsigned int tg2_freq_item; 53 } ch[PEB2466_NB_CHANNEL]; 54 int max_chan_playback; 55 int max_chan_capture; 56 struct { 57 struct gpio_chip gpio_chip; 58 struct mutex lock; 59 struct { 60 unsigned int xr0; 61 unsigned int xr1; 62 unsigned int xr2; 63 unsigned int xr3; 64 } cache; 65 } gpio; 66 }; 67 68 #define PEB2466_CMD_R (1 << 5) 69 #define PEB2466_CMD_W (0 << 5) 70 71 #define PEB2466_CMD_MASK 0x18 72 #define PEB2466_CMD_XOP 0x18 /* XOP is 0bxxx11xxx */ 73 #define PEB2466_CMD_SOP 0x10 /* SOP is 0bxxx10xxx */ 74 #define PEB2466_CMD_COP 0x00 /* COP is 0bxxx0xxxx, handle 0bxxx00xxx */ 75 #define PEB2466_CMD_COP1 0x08 /* COP is 0bxxx0xxxx, handle 0bxxx01xxx */ 76 77 #define PEB2466_MAKE_XOP(_lsel) (PEB2466_CMD_XOP | (_lsel)) 78 #define PEB2466_MAKE_SOP(_ad, _lsel) (PEB2466_CMD_SOP | ((_ad) << 6) | (_lsel)) 79 #define PEB2466_MAKE_COP(_ad, _code) (PEB2466_CMD_COP | ((_ad) << 6) | (_code)) 80 81 #define PEB2466_CR0(_ch) PEB2466_MAKE_SOP(_ch, 0x0) 82 #define PEB2466_CR0_TH (1 << 7) 83 #define PEB2466_CR0_IMR1 (1 << 6) 84 #define PEB2466_CR0_FRX (1 << 5) 85 #define PEB2466_CR0_FRR (1 << 4) 86 #define PEB2466_CR0_AX (1 << 3) 87 #define PEB2466_CR0_AR (1 << 2) 88 #define PEB2466_CR0_THSEL_MASK (0x3 << 0) 89 #define PEB2466_CR0_THSEL(_set) ((_set) << 0) 90 91 #define PEB2466_CR1(_ch) PEB2466_MAKE_SOP(_ch, 0x1) 92 #define PEB2466_CR1_ETG2 (1 << 7) 93 #define PEB2466_CR1_ETG1 (1 << 6) 94 #define PEB2466_CR1_PTG2 (1 << 5) 95 #define PEB2466_CR1_PTG1 (1 << 4) 96 #define PEB2466_CR1_LAW_MASK (1 << 3) 97 #define PEB2466_CR1_LAW_ALAW (0 << 3) 98 #define PEB2466_CR1_LAW_MULAW (1 << 3) 99 #define PEB2466_CR1_PU (1 << 0) 100 101 #define PEB2466_CR2(_ch) PEB2466_MAKE_SOP(_ch, 0x2) 102 #define PEB2466_CR3(_ch) PEB2466_MAKE_SOP(_ch, 0x3) 103 #define PEB2466_CR4(_ch) PEB2466_MAKE_SOP(_ch, 0x4) 104 #define PEB2466_CR5(_ch) PEB2466_MAKE_SOP(_ch, 0x5) 105 106 #define PEB2466_XR0 PEB2466_MAKE_XOP(0x0) 107 #define PEB2466_XR1 PEB2466_MAKE_XOP(0x1) 108 #define PEB2466_XR2 PEB2466_MAKE_XOP(0x2) 109 #define PEB2466_XR3 PEB2466_MAKE_XOP(0x3) 110 #define PEB2466_XR4 PEB2466_MAKE_XOP(0x4) 111 #define PEB2466_XR5 PEB2466_MAKE_XOP(0x5) 112 #define PEB2466_XR5_MCLK_1536 (0x0 << 6) 113 #define PEB2466_XR5_MCLK_2048 (0x1 << 6) 114 #define PEB2466_XR5_MCLK_4096 (0x2 << 6) 115 #define PEB2466_XR5_MCLK_8192 (0x3 << 6) 116 117 #define PEB2466_XR6 PEB2466_MAKE_XOP(0x6) 118 #define PEB2466_XR6_PCM_OFFSET(_off) ((_off) << 0) 119 120 #define PEB2466_XR7 PEB2466_MAKE_XOP(0x7) 121 122 #define PEB2466_TH_FILTER_P1(_ch) PEB2466_MAKE_COP(_ch, 0x0) 123 #define PEB2466_TH_FILTER_P2(_ch) PEB2466_MAKE_COP(_ch, 0x1) 124 #define PEB2466_TH_FILTER_P3(_ch) PEB2466_MAKE_COP(_ch, 0x2) 125 #define PEB2466_IMR1_FILTER_P1(_ch) PEB2466_MAKE_COP(_ch, 0x4) 126 #define PEB2466_IMR1_FILTER_P2(_ch) PEB2466_MAKE_COP(_ch, 0x5) 127 #define PEB2466_FRX_FILTER(_ch) PEB2466_MAKE_COP(_ch, 0x6) 128 #define PEB2466_FRR_FILTER(_ch) PEB2466_MAKE_COP(_ch, 0x7) 129 #define PEB2466_AX_FILTER(_ch) PEB2466_MAKE_COP(_ch, 0x8) 130 #define PEB2466_AR_FILTER(_ch) PEB2466_MAKE_COP(_ch, 0x9) 131 #define PEB2466_TG1(_ch) PEB2466_MAKE_COP(_ch, 0xc) 132 #define PEB2466_TG2(_ch) PEB2466_MAKE_COP(_ch, 0xd) 133 134 static int peb2466_write_byte(struct peb2466 *peb2466, u8 cmd, u8 val) 135 { 136 struct spi_transfer xfer = { 137 .tx_buf = &peb2466->spi_tx_buf, 138 .len = 2, 139 }; 140 141 peb2466->spi_tx_buf[0] = cmd | PEB2466_CMD_W; 142 peb2466->spi_tx_buf[1] = val; 143 144 dev_dbg(&peb2466->spi->dev, "write byte (cmd %02x) %02x\n", 145 peb2466->spi_tx_buf[0], peb2466->spi_tx_buf[1]); 146 147 return spi_sync_transfer(peb2466->spi, &xfer, 1); 148 } 149 150 static int peb2466_read_byte(struct peb2466 *peb2466, u8 cmd, u8 *val) 151 { 152 struct spi_transfer xfer = { 153 .tx_buf = &peb2466->spi_tx_buf, 154 .rx_buf = &peb2466->spi_rx_buf, 155 .len = 3, 156 }; 157 int ret; 158 159 peb2466->spi_tx_buf[0] = cmd | PEB2466_CMD_R; 160 161 ret = spi_sync_transfer(peb2466->spi, &xfer, 1); 162 if (ret) 163 return ret; 164 165 if (peb2466->spi_rx_buf[1] != 0x81) { 166 dev_err(&peb2466->spi->dev, 167 "spi xfer rd (cmd %02x) invalid ident byte (0x%02x)\n", 168 peb2466->spi_tx_buf[0], peb2466->spi_rx_buf[1]); 169 return -EILSEQ; 170 } 171 172 *val = peb2466->spi_rx_buf[2]; 173 174 dev_dbg(&peb2466->spi->dev, "read byte (cmd %02x) %02x\n", 175 peb2466->spi_tx_buf[0], *val); 176 177 return 0; 178 } 179 180 static int peb2466_write_buf(struct peb2466 *peb2466, u8 cmd, const u8 *buf, unsigned int len) 181 { 182 struct spi_transfer xfer = { 183 .tx_buf = &peb2466->spi_tx_buf, 184 .len = len + 1, 185 }; 186 187 if (len > 8) 188 return -EINVAL; 189 190 peb2466->spi_tx_buf[0] = cmd | PEB2466_CMD_W; 191 memcpy(&peb2466->spi_tx_buf[1], buf, len); 192 193 dev_dbg(&peb2466->spi->dev, "write buf (cmd %02x, %u) %*ph\n", 194 peb2466->spi_tx_buf[0], len, len, &peb2466->spi_tx_buf[1]); 195 196 return spi_sync_transfer(peb2466->spi, &xfer, 1); 197 } 198 199 static int peb2466_reg_write(void *context, unsigned int reg, unsigned int val) 200 { 201 struct peb2466 *peb2466 = context; 202 int ret; 203 204 /* 205 * Only XOP and SOP commands can be handled as registers. 206 * COP commands are handled using direct peb2466_write_buf() calls. 207 */ 208 switch (reg & PEB2466_CMD_MASK) { 209 case PEB2466_CMD_XOP: 210 case PEB2466_CMD_SOP: 211 ret = peb2466_write_byte(peb2466, reg, val); 212 break; 213 default: 214 dev_err(&peb2466->spi->dev, "Not a XOP or SOP command\n"); 215 ret = -EINVAL; 216 break; 217 } 218 return ret; 219 } 220 221 static int peb2466_reg_read(void *context, unsigned int reg, unsigned int *val) 222 { 223 struct peb2466 *peb2466 = context; 224 int ret; 225 u8 tmp; 226 227 /* Only XOP and SOP commands can be handled as registers */ 228 switch (reg & PEB2466_CMD_MASK) { 229 case PEB2466_CMD_XOP: 230 case PEB2466_CMD_SOP: 231 ret = peb2466_read_byte(peb2466, reg, &tmp); 232 *val = tmp; 233 break; 234 default: 235 dev_err(&peb2466->spi->dev, "Not a XOP or SOP command\n"); 236 ret = -EINVAL; 237 break; 238 } 239 return ret; 240 } 241 242 static const struct regmap_config peb2466_regmap_config = { 243 .reg_bits = 8, 244 .val_bits = 8, 245 .max_register = 0xFF, 246 .reg_write = peb2466_reg_write, 247 .reg_read = peb2466_reg_read, 248 .cache_type = REGCACHE_NONE, 249 }; 250 251 static int peb2466_lkup_ctrl_info(struct snd_kcontrol *kcontrol, 252 struct snd_ctl_elem_info *uinfo) 253 { 254 struct peb2466_lkup_ctrl *lkup_ctrl = 255 (struct peb2466_lkup_ctrl *)kcontrol->private_value; 256 257 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 258 uinfo->count = 1; 259 uinfo->value.integer.min = 0; 260 uinfo->value.integer.max = lkup_ctrl->lookup->count - 1; 261 return 0; 262 } 263 264 static int peb2466_lkup_ctrl_get(struct snd_kcontrol *kcontrol, 265 struct snd_ctl_elem_value *ucontrol) 266 { 267 struct peb2466_lkup_ctrl *lkup_ctrl = 268 (struct peb2466_lkup_ctrl *)kcontrol->private_value; 269 270 ucontrol->value.integer.value[0] = lkup_ctrl->index; 271 return 0; 272 } 273 274 static int peb2466_lkup_ctrl_put(struct snd_kcontrol *kcontrol, 275 struct snd_ctl_elem_value *ucontrol) 276 { 277 struct peb2466_lkup_ctrl *lkup_ctrl = 278 (struct peb2466_lkup_ctrl *)kcontrol->private_value; 279 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 280 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 281 unsigned int index; 282 int ret; 283 284 index = ucontrol->value.integer.value[0]; 285 if (index >= lkup_ctrl->lookup->count) 286 return -EINVAL; 287 288 if (index == lkup_ctrl->index) 289 return 0; 290 291 ret = peb2466_write_buf(peb2466, lkup_ctrl->reg, 292 lkup_ctrl->lookup->table[index], 4); 293 if (ret) 294 return ret; 295 296 lkup_ctrl->index = index; 297 return 1; /* The value changed */ 298 } 299 300 static int peb2466_add_lkup_ctrl(struct snd_soc_component *component, 301 struct peb2466_lkup_ctrl *lkup_ctrl, 302 const char *name, int min_val, int step) 303 { 304 DECLARE_TLV_DB_SCALE(tlv_array, min_val, step, 0); 305 struct snd_kcontrol_new control = {0}; 306 307 BUILD_BUG_ON(sizeof(lkup_ctrl->tlv_array) < sizeof(tlv_array)); 308 memcpy(lkup_ctrl->tlv_array, tlv_array, sizeof(tlv_array)); 309 310 control.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 311 control.name = name; 312 control.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | 313 SNDRV_CTL_ELEM_ACCESS_READWRITE; 314 control.tlv.p = lkup_ctrl->tlv_array; 315 control.info = peb2466_lkup_ctrl_info; 316 control.get = peb2466_lkup_ctrl_get; 317 control.put = peb2466_lkup_ctrl_put; 318 control.private_value = (unsigned long)lkup_ctrl; 319 320 return snd_soc_add_component_controls(component, &control, 1); 321 } 322 323 enum peb2466_tone_freq { 324 PEB2466_TONE_697HZ, 325 PEB2466_TONE_800HZ, 326 PEB2466_TONE_950HZ, 327 PEB2466_TONE_1000HZ, 328 PEB2466_TONE_1008HZ, 329 PEB2466_TONE_2000HZ, 330 }; 331 332 static const u8 peb2466_tone_lookup[][4] = { 333 [PEB2466_TONE_697HZ] = {0x0a, 0x33, 0x5a, 0x2c}, 334 [PEB2466_TONE_800HZ] = {0x12, 0xD6, 0x5a, 0xc0}, 335 [PEB2466_TONE_950HZ] = {0x1c, 0xf0, 0x5c, 0xc0}, 336 [PEB2466_TONE_1000HZ] = {0}, /* lookup value not used for 1000Hz */ 337 [PEB2466_TONE_1008HZ] = {0x1a, 0xae, 0x57, 0x70}, 338 [PEB2466_TONE_2000HZ] = {0x00, 0x80, 0x50, 0x09}, 339 }; 340 341 static const char * const peb2466_tone_freq_txt[] = { 342 [PEB2466_TONE_697HZ] = "697Hz", 343 [PEB2466_TONE_800HZ] = "800Hz", 344 [PEB2466_TONE_950HZ] = "950Hz", 345 [PEB2466_TONE_1000HZ] = "1000Hz", 346 [PEB2466_TONE_1008HZ] = "1008Hz", 347 [PEB2466_TONE_2000HZ] = "2000Hz" 348 }; 349 350 static const struct soc_enum peb2466_tg_freq[][2] = { 351 [0] = { 352 SOC_ENUM_SINGLE(PEB2466_TG1(0), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 353 peb2466_tone_freq_txt), 354 SOC_ENUM_SINGLE(PEB2466_TG2(0), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 355 peb2466_tone_freq_txt) 356 }, 357 [1] = { 358 SOC_ENUM_SINGLE(PEB2466_TG1(1), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 359 peb2466_tone_freq_txt), 360 SOC_ENUM_SINGLE(PEB2466_TG2(1), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 361 peb2466_tone_freq_txt) 362 }, 363 [2] = { 364 SOC_ENUM_SINGLE(PEB2466_TG1(2), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 365 peb2466_tone_freq_txt), 366 SOC_ENUM_SINGLE(PEB2466_TG2(2), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 367 peb2466_tone_freq_txt) 368 }, 369 [3] = { 370 SOC_ENUM_SINGLE(PEB2466_TG1(3), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 371 peb2466_tone_freq_txt), 372 SOC_ENUM_SINGLE(PEB2466_TG2(3), 0, ARRAY_SIZE(peb2466_tone_freq_txt), 373 peb2466_tone_freq_txt) 374 } 375 }; 376 377 static int peb2466_tg_freq_get(struct snd_kcontrol *kcontrol, 378 struct snd_ctl_elem_value *ucontrol) 379 { 380 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 381 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 382 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 383 384 switch (e->reg) { 385 case PEB2466_TG1(0): 386 ucontrol->value.enumerated.item[0] = peb2466->ch[0].tg1_freq_item; 387 break; 388 case PEB2466_TG2(0): 389 ucontrol->value.enumerated.item[0] = peb2466->ch[0].tg2_freq_item; 390 break; 391 case PEB2466_TG1(1): 392 ucontrol->value.enumerated.item[0] = peb2466->ch[1].tg1_freq_item; 393 break; 394 case PEB2466_TG2(1): 395 ucontrol->value.enumerated.item[0] = peb2466->ch[1].tg2_freq_item; 396 break; 397 case PEB2466_TG1(2): 398 ucontrol->value.enumerated.item[0] = peb2466->ch[2].tg1_freq_item; 399 break; 400 case PEB2466_TG2(2): 401 ucontrol->value.enumerated.item[0] = peb2466->ch[2].tg2_freq_item; 402 break; 403 case PEB2466_TG1(3): 404 ucontrol->value.enumerated.item[0] = peb2466->ch[3].tg1_freq_item; 405 break; 406 case PEB2466_TG2(3): 407 ucontrol->value.enumerated.item[0] = peb2466->ch[3].tg2_freq_item; 408 break; 409 default: 410 return -EINVAL; 411 } 412 return 0; 413 } 414 415 static int peb2466_tg_freq_put(struct snd_kcontrol *kcontrol, 416 struct snd_ctl_elem_value *ucontrol) 417 { 418 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 419 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 420 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 421 unsigned int *tg_freq_item; 422 u8 cr1_reg, cr1_mask; 423 unsigned int index; 424 int ret; 425 426 index = ucontrol->value.enumerated.item[0]; 427 428 if (index >= ARRAY_SIZE(peb2466_tone_lookup)) 429 return -EINVAL; 430 431 switch (e->reg) { 432 case PEB2466_TG1(0): 433 tg_freq_item = &peb2466->ch[0].tg1_freq_item; 434 cr1_reg = PEB2466_CR1(0); 435 cr1_mask = PEB2466_CR1_PTG1; 436 break; 437 case PEB2466_TG2(0): 438 tg_freq_item = &peb2466->ch[0].tg2_freq_item; 439 cr1_reg = PEB2466_CR1(0); 440 cr1_mask = PEB2466_CR1_PTG2; 441 break; 442 case PEB2466_TG1(1): 443 tg_freq_item = &peb2466->ch[1].tg1_freq_item; 444 cr1_reg = PEB2466_CR1(1); 445 cr1_mask = PEB2466_CR1_PTG1; 446 break; 447 case PEB2466_TG2(1): 448 tg_freq_item = &peb2466->ch[1].tg2_freq_item; 449 cr1_reg = PEB2466_CR1(1); 450 cr1_mask = PEB2466_CR1_PTG2; 451 break; 452 case PEB2466_TG1(2): 453 tg_freq_item = &peb2466->ch[2].tg1_freq_item; 454 cr1_reg = PEB2466_CR1(2); 455 cr1_mask = PEB2466_CR1_PTG1; 456 break; 457 case PEB2466_TG2(2): 458 tg_freq_item = &peb2466->ch[2].tg2_freq_item; 459 cr1_reg = PEB2466_CR1(2); 460 cr1_mask = PEB2466_CR1_PTG2; 461 break; 462 case PEB2466_TG1(3): 463 tg_freq_item = &peb2466->ch[3].tg1_freq_item; 464 cr1_reg = PEB2466_CR1(3); 465 cr1_mask = PEB2466_CR1_PTG1; 466 break; 467 case PEB2466_TG2(3): 468 tg_freq_item = &peb2466->ch[3].tg2_freq_item; 469 cr1_reg = PEB2466_CR1(3); 470 cr1_mask = PEB2466_CR1_PTG2; 471 break; 472 default: 473 return -EINVAL; 474 } 475 476 if (index == *tg_freq_item) 477 return 0; 478 479 if (index == PEB2466_TONE_1000HZ) { 480 ret = regmap_update_bits(peb2466->regmap, cr1_reg, cr1_mask, 0); 481 if (ret) 482 return ret; 483 } else { 484 ret = peb2466_write_buf(peb2466, e->reg, peb2466_tone_lookup[index], 4); 485 if (ret) 486 return ret; 487 ret = regmap_update_bits(peb2466->regmap, cr1_reg, cr1_mask, cr1_mask); 488 if (ret) 489 return ret; 490 } 491 492 *tg_freq_item = index; 493 return 1; /* The value changed */ 494 } 495 496 static const struct snd_kcontrol_new peb2466_ch0_out_mix_controls[] = { 497 SOC_DAPM_SINGLE("TG1 Switch", PEB2466_CR1(0), 6, 1, 0), 498 SOC_DAPM_SINGLE("TG2 Switch", PEB2466_CR1(0), 7, 1, 0), 499 SOC_DAPM_SINGLE("Voice Switch", PEB2466_CR2(0), 0, 1, 0) 500 }; 501 502 static const struct snd_kcontrol_new peb2466_ch1_out_mix_controls[] = { 503 SOC_DAPM_SINGLE("TG1 Switch", PEB2466_CR1(1), 6, 1, 0), 504 SOC_DAPM_SINGLE("TG2 Switch", PEB2466_CR1(1), 7, 1, 0), 505 SOC_DAPM_SINGLE("Voice Switch", PEB2466_CR2(1), 0, 1, 0) 506 }; 507 508 static const struct snd_kcontrol_new peb2466_ch2_out_mix_controls[] = { 509 SOC_DAPM_SINGLE("TG1 Switch", PEB2466_CR1(2), 6, 1, 0), 510 SOC_DAPM_SINGLE("TG2 Switch", PEB2466_CR1(2), 7, 1, 0), 511 SOC_DAPM_SINGLE("Voice Switch", PEB2466_CR2(2), 0, 1, 0) 512 }; 513 514 static const struct snd_kcontrol_new peb2466_ch3_out_mix_controls[] = { 515 SOC_DAPM_SINGLE("TG1 Switch", PEB2466_CR1(3), 6, 1, 0), 516 SOC_DAPM_SINGLE("TG2 Switch", PEB2466_CR1(3), 7, 1, 0), 517 SOC_DAPM_SINGLE("Voice Switch", PEB2466_CR2(3), 0, 1, 0) 518 }; 519 520 static const struct snd_kcontrol_new peb2466_controls[] = { 521 /* Attenuators */ 522 SOC_SINGLE("DAC0 -6dB Playback Switch", PEB2466_CR3(0), 2, 1, 0), 523 SOC_SINGLE("DAC1 -6dB Playback Switch", PEB2466_CR3(1), 2, 1, 0), 524 SOC_SINGLE("DAC2 -6dB Playback Switch", PEB2466_CR3(2), 2, 1, 0), 525 SOC_SINGLE("DAC3 -6dB Playback Switch", PEB2466_CR3(3), 2, 1, 0), 526 527 /* Amplifiers */ 528 SOC_SINGLE("ADC0 +6dB Capture Switch", PEB2466_CR3(0), 3, 1, 0), 529 SOC_SINGLE("ADC1 +6dB Capture Switch", PEB2466_CR3(1), 3, 1, 0), 530 SOC_SINGLE("ADC2 +6dB Capture Switch", PEB2466_CR3(2), 3, 1, 0), 531 SOC_SINGLE("ADC3 +6dB Capture Switch", PEB2466_CR3(3), 3, 1, 0), 532 533 /* Tone generators */ 534 SOC_ENUM_EXT("DAC0 TG1 Freq", peb2466_tg_freq[0][0], 535 peb2466_tg_freq_get, peb2466_tg_freq_put), 536 SOC_ENUM_EXT("DAC1 TG1 Freq", peb2466_tg_freq[1][0], 537 peb2466_tg_freq_get, peb2466_tg_freq_put), 538 SOC_ENUM_EXT("DAC2 TG1 Freq", peb2466_tg_freq[2][0], 539 peb2466_tg_freq_get, peb2466_tg_freq_put), 540 SOC_ENUM_EXT("DAC3 TG1 Freq", peb2466_tg_freq[3][0], 541 peb2466_tg_freq_get, peb2466_tg_freq_put), 542 543 SOC_ENUM_EXT("DAC0 TG2 Freq", peb2466_tg_freq[0][1], 544 peb2466_tg_freq_get, peb2466_tg_freq_put), 545 SOC_ENUM_EXT("DAC1 TG2 Freq", peb2466_tg_freq[1][1], 546 peb2466_tg_freq_get, peb2466_tg_freq_put), 547 SOC_ENUM_EXT("DAC2 TG2 Freq", peb2466_tg_freq[2][1], 548 peb2466_tg_freq_get, peb2466_tg_freq_put), 549 SOC_ENUM_EXT("DAC3 TG2 Freq", peb2466_tg_freq[3][1], 550 peb2466_tg_freq_get, peb2466_tg_freq_put), 551 }; 552 553 static const struct snd_soc_dapm_widget peb2466_dapm_widgets[] = { 554 SND_SOC_DAPM_SUPPLY("CH0 PWR", PEB2466_CR1(0), 0, 0, NULL, 0), 555 SND_SOC_DAPM_SUPPLY("CH1 PWR", PEB2466_CR1(1), 0, 0, NULL, 0), 556 SND_SOC_DAPM_SUPPLY("CH2 PWR", PEB2466_CR1(2), 0, 0, NULL, 0), 557 SND_SOC_DAPM_SUPPLY("CH3 PWR", PEB2466_CR1(3), 0, 0, NULL, 0), 558 559 SND_SOC_DAPM_DAC("CH0 DIN", "Playback", SND_SOC_NOPM, 0, 0), 560 SND_SOC_DAPM_DAC("CH1 DIN", "Playback", SND_SOC_NOPM, 0, 0), 561 SND_SOC_DAPM_DAC("CH2 DIN", "Playback", SND_SOC_NOPM, 0, 0), 562 SND_SOC_DAPM_DAC("CH3 DIN", "Playback", SND_SOC_NOPM, 0, 0), 563 564 SND_SOC_DAPM_SIGGEN("CH0 TG1"), 565 SND_SOC_DAPM_SIGGEN("CH1 TG1"), 566 SND_SOC_DAPM_SIGGEN("CH2 TG1"), 567 SND_SOC_DAPM_SIGGEN("CH3 TG1"), 568 569 SND_SOC_DAPM_SIGGEN("CH0 TG2"), 570 SND_SOC_DAPM_SIGGEN("CH1 TG2"), 571 SND_SOC_DAPM_SIGGEN("CH2 TG2"), 572 SND_SOC_DAPM_SIGGEN("CH3 TG2"), 573 574 SND_SOC_DAPM_MIXER("DAC0 Mixer", SND_SOC_NOPM, 0, 0, 575 peb2466_ch0_out_mix_controls, 576 ARRAY_SIZE(peb2466_ch0_out_mix_controls)), 577 SND_SOC_DAPM_MIXER("DAC1 Mixer", SND_SOC_NOPM, 0, 0, 578 peb2466_ch1_out_mix_controls, 579 ARRAY_SIZE(peb2466_ch1_out_mix_controls)), 580 SND_SOC_DAPM_MIXER("DAC2 Mixer", SND_SOC_NOPM, 0, 0, 581 peb2466_ch2_out_mix_controls, 582 ARRAY_SIZE(peb2466_ch2_out_mix_controls)), 583 SND_SOC_DAPM_MIXER("DAC3 Mixer", SND_SOC_NOPM, 0, 0, 584 peb2466_ch3_out_mix_controls, 585 ARRAY_SIZE(peb2466_ch3_out_mix_controls)), 586 587 SND_SOC_DAPM_PGA("DAC0 PGA", SND_SOC_NOPM, 0, 0, NULL, 0), 588 SND_SOC_DAPM_PGA("DAC1 PGA", SND_SOC_NOPM, 0, 0, NULL, 0), 589 SND_SOC_DAPM_PGA("DAC2 PGA", SND_SOC_NOPM, 0, 0, NULL, 0), 590 SND_SOC_DAPM_PGA("DAC3 PGA", SND_SOC_NOPM, 0, 0, NULL, 0), 591 592 SND_SOC_DAPM_OUTPUT("OUT0"), 593 SND_SOC_DAPM_OUTPUT("OUT1"), 594 SND_SOC_DAPM_OUTPUT("OUT2"), 595 SND_SOC_DAPM_OUTPUT("OUT3"), 596 597 SND_SOC_DAPM_INPUT("IN0"), 598 SND_SOC_DAPM_INPUT("IN1"), 599 SND_SOC_DAPM_INPUT("IN2"), 600 SND_SOC_DAPM_INPUT("IN3"), 601 602 SND_SOC_DAPM_DAC("ADC0", "Capture", SND_SOC_NOPM, 0, 0), 603 SND_SOC_DAPM_DAC("ADC1", "Capture", SND_SOC_NOPM, 0, 0), 604 SND_SOC_DAPM_DAC("ADC2", "Capture", SND_SOC_NOPM, 0, 0), 605 SND_SOC_DAPM_DAC("ADC3", "Capture", SND_SOC_NOPM, 0, 0), 606 }; 607 608 static const struct snd_soc_dapm_route peb2466_dapm_routes[] = { 609 { "CH0 DIN", NULL, "CH0 PWR" }, 610 { "CH1 DIN", NULL, "CH1 PWR" }, 611 { "CH2 DIN", NULL, "CH2 PWR" }, 612 { "CH3 DIN", NULL, "CH3 PWR" }, 613 614 { "CH0 TG1", NULL, "CH0 PWR" }, 615 { "CH1 TG1", NULL, "CH1 PWR" }, 616 { "CH2 TG1", NULL, "CH2 PWR" }, 617 { "CH3 TG1", NULL, "CH3 PWR" }, 618 619 { "CH0 TG2", NULL, "CH0 PWR" }, 620 { "CH1 TG2", NULL, "CH1 PWR" }, 621 { "CH2 TG2", NULL, "CH2 PWR" }, 622 { "CH3 TG2", NULL, "CH3 PWR" }, 623 624 { "DAC0 Mixer", "TG1 Switch", "CH0 TG1" }, 625 { "DAC0 Mixer", "TG2 Switch", "CH0 TG2" }, 626 { "DAC0 Mixer", "Voice Switch", "CH0 DIN" }, 627 { "DAC0 Mixer", NULL, "CH0 DIN" }, 628 629 { "DAC1 Mixer", "TG1 Switch", "CH1 TG1" }, 630 { "DAC1 Mixer", "TG2 Switch", "CH1 TG2" }, 631 { "DAC1 Mixer", "Voice Switch", "CH1 DIN" }, 632 { "DAC1 Mixer", NULL, "CH1 DIN" }, 633 634 { "DAC2 Mixer", "TG1 Switch", "CH2 TG1" }, 635 { "DAC2 Mixer", "TG2 Switch", "CH2 TG2" }, 636 { "DAC2 Mixer", "Voice Switch", "CH2 DIN" }, 637 { "DAC2 Mixer", NULL, "CH2 DIN" }, 638 639 { "DAC3 Mixer", "TG1 Switch", "CH3 TG1" }, 640 { "DAC3 Mixer", "TG2 Switch", "CH3 TG2" }, 641 { "DAC3 Mixer", "Voice Switch", "CH3 DIN" }, 642 { "DAC3 Mixer", NULL, "CH3 DIN" }, 643 644 { "DAC0 PGA", NULL, "DAC0 Mixer" }, 645 { "DAC1 PGA", NULL, "DAC1 Mixer" }, 646 { "DAC2 PGA", NULL, "DAC2 Mixer" }, 647 { "DAC3 PGA", NULL, "DAC3 Mixer" }, 648 649 { "OUT0", NULL, "DAC0 PGA" }, 650 { "OUT1", NULL, "DAC1 PGA" }, 651 { "OUT2", NULL, "DAC2 PGA" }, 652 { "OUT3", NULL, "DAC3 PGA" }, 653 654 { "ADC0", NULL, "IN0" }, 655 { "ADC1", NULL, "IN1" }, 656 { "ADC2", NULL, "IN2" }, 657 { "ADC3", NULL, "IN3" }, 658 659 { "ADC0", NULL, "CH0 PWR" }, 660 { "ADC1", NULL, "CH1 PWR" }, 661 { "ADC2", NULL, "CH2 PWR" }, 662 { "ADC3", NULL, "CH3 PWR" }, 663 }; 664 665 static int peb2466_dai_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, 666 unsigned int rx_mask, int slots, int width) 667 { 668 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(dai->component); 669 unsigned int chan; 670 unsigned int mask; 671 u8 slot; 672 int ret; 673 674 switch (width) { 675 case 0: 676 /* Not set -> default 8 */ 677 case 8: 678 break; 679 default: 680 dev_err(dai->dev, "tdm slot width %d not supported\n", width); 681 return -EINVAL; 682 } 683 684 mask = tx_mask; 685 slot = 0; 686 chan = 0; 687 while (mask && chan < PEB2466_NB_CHANNEL) { 688 if (mask & 0x1) { 689 ret = regmap_write(peb2466->regmap, PEB2466_CR5(chan), slot); 690 if (ret) { 691 dev_err(dai->dev, "chan %d set tx tdm slot failed (%d)\n", 692 chan, ret); 693 return ret; 694 } 695 chan++; 696 } 697 mask >>= 1; 698 slot++; 699 } 700 if (mask) { 701 dev_err(dai->dev, "too much tx slots defined (mask = 0x%x) support max %d\n", 702 tx_mask, PEB2466_NB_CHANNEL); 703 return -EINVAL; 704 } 705 peb2466->max_chan_playback = chan; 706 707 mask = rx_mask; 708 slot = 0; 709 chan = 0; 710 while (mask && chan < PEB2466_NB_CHANNEL) { 711 if (mask & 0x1) { 712 ret = regmap_write(peb2466->regmap, PEB2466_CR4(chan), slot); 713 if (ret) { 714 dev_err(dai->dev, "chan %d set rx tdm slot failed (%d)\n", 715 chan, ret); 716 return ret; 717 } 718 chan++; 719 } 720 mask >>= 1; 721 slot++; 722 } 723 if (mask) { 724 dev_err(dai->dev, "too much rx slots defined (mask = 0x%x) support max %d\n", 725 rx_mask, PEB2466_NB_CHANNEL); 726 return -EINVAL; 727 } 728 peb2466->max_chan_capture = chan; 729 730 return 0; 731 } 732 733 static int peb2466_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 734 { 735 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(dai->component); 736 u8 xr6; 737 738 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 739 case SND_SOC_DAIFMT_DSP_A: 740 xr6 = PEB2466_XR6_PCM_OFFSET(1); 741 break; 742 case SND_SOC_DAIFMT_DSP_B: 743 xr6 = PEB2466_XR6_PCM_OFFSET(0); 744 break; 745 default: 746 dev_err(dai->dev, "Unsupported format 0x%x\n", 747 fmt & SND_SOC_DAIFMT_FORMAT_MASK); 748 return -EINVAL; 749 } 750 return regmap_write(peb2466->regmap, PEB2466_XR6, xr6); 751 } 752 753 static int peb2466_dai_hw_params(struct snd_pcm_substream *substream, 754 struct snd_pcm_hw_params *params, 755 struct snd_soc_dai *dai) 756 { 757 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(dai->component); 758 unsigned int ch; 759 int ret; 760 u8 cr1; 761 762 switch (params_format(params)) { 763 case SNDRV_PCM_FORMAT_MU_LAW: 764 cr1 = PEB2466_CR1_LAW_MULAW; 765 break; 766 case SNDRV_PCM_FORMAT_A_LAW: 767 cr1 = PEB2466_CR1_LAW_ALAW; 768 break; 769 default: 770 dev_err(&peb2466->spi->dev, "Unsupported format 0x%x\n", 771 params_format(params)); 772 return -EINVAL; 773 } 774 775 for (ch = 0; ch < PEB2466_NB_CHANNEL; ch++) { 776 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR1(ch), 777 PEB2466_CR1_LAW_MASK, cr1); 778 if (ret) 779 return ret; 780 } 781 782 return 0; 783 } 784 785 static const unsigned int peb2466_sample_bits[] = {8}; 786 787 static struct snd_pcm_hw_constraint_list peb2466_sample_bits_constr = { 788 .list = peb2466_sample_bits, 789 .count = ARRAY_SIZE(peb2466_sample_bits), 790 }; 791 792 static int peb2466_dai_startup(struct snd_pcm_substream *substream, 793 struct snd_soc_dai *dai) 794 { 795 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(dai->component); 796 unsigned int max_ch; 797 int ret; 798 799 max_ch = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? 800 peb2466->max_chan_playback : peb2466->max_chan_capture; 801 802 /* 803 * Disable stream support (min = 0, max = 0) if no timeslots were 804 * configured. 805 */ 806 ret = snd_pcm_hw_constraint_minmax(substream->runtime, 807 SNDRV_PCM_HW_PARAM_CHANNELS, 808 max_ch ? 1 : 0, max_ch); 809 if (ret < 0) 810 return ret; 811 812 return snd_pcm_hw_constraint_list(substream->runtime, 0, 813 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 814 &peb2466_sample_bits_constr); 815 } 816 817 static u64 peb2466_dai_formats[] = { 818 SND_SOC_POSSIBLE_DAIFMT_DSP_A | 819 SND_SOC_POSSIBLE_DAIFMT_DSP_B, 820 }; 821 822 static const struct snd_soc_dai_ops peb2466_dai_ops = { 823 .startup = peb2466_dai_startup, 824 .hw_params = peb2466_dai_hw_params, 825 .set_tdm_slot = peb2466_dai_set_tdm_slot, 826 .set_fmt = peb2466_dai_set_fmt, 827 .auto_selectable_formats = peb2466_dai_formats, 828 .num_auto_selectable_formats = ARRAY_SIZE(peb2466_dai_formats), 829 }; 830 831 static struct snd_soc_dai_driver peb2466_dai_driver = { 832 .name = "peb2466", 833 .playback = { 834 .stream_name = "Playback", 835 .channels_min = 1, 836 .channels_max = PEB2466_NB_CHANNEL, 837 .rates = SNDRV_PCM_RATE_8000, 838 .formats = SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW, 839 }, 840 .capture = { 841 .stream_name = "Capture", 842 .channels_min = 1, 843 .channels_max = PEB2466_NB_CHANNEL, 844 .rates = SNDRV_PCM_RATE_8000, 845 .formats = SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW, 846 }, 847 .ops = &peb2466_dai_ops, 848 }; 849 850 static int peb2466_reset_audio(struct peb2466 *peb2466) 851 { 852 static const struct reg_sequence reg_reset[] = { 853 { .reg = PEB2466_XR6, .def = 0x00 }, 854 855 { .reg = PEB2466_CR5(0), .def = 0x00 }, 856 { .reg = PEB2466_CR4(0), .def = 0x00 }, 857 { .reg = PEB2466_CR3(0), .def = 0x00 }, 858 { .reg = PEB2466_CR2(0), .def = 0x00 }, 859 { .reg = PEB2466_CR1(0), .def = 0x00 }, 860 { .reg = PEB2466_CR0(0), .def = PEB2466_CR0_IMR1 }, 861 862 { .reg = PEB2466_CR5(1), .def = 0x00 }, 863 { .reg = PEB2466_CR4(1), .def = 0x00 }, 864 { .reg = PEB2466_CR3(1), .def = 0x00 }, 865 { .reg = PEB2466_CR2(1), .def = 0x00 }, 866 { .reg = PEB2466_CR1(1), .def = 0x00 }, 867 { .reg = PEB2466_CR0(1), .def = PEB2466_CR0_IMR1 }, 868 869 { .reg = PEB2466_CR5(2), .def = 0x00 }, 870 { .reg = PEB2466_CR4(2), .def = 0x00 }, 871 { .reg = PEB2466_CR3(2), .def = 0x00 }, 872 { .reg = PEB2466_CR2(2), .def = 0x00 }, 873 { .reg = PEB2466_CR1(2), .def = 0x00 }, 874 { .reg = PEB2466_CR0(2), .def = PEB2466_CR0_IMR1 }, 875 876 { .reg = PEB2466_CR5(3), .def = 0x00 }, 877 { .reg = PEB2466_CR4(3), .def = 0x00 }, 878 { .reg = PEB2466_CR3(3), .def = 0x00 }, 879 { .reg = PEB2466_CR2(3), .def = 0x00 }, 880 { .reg = PEB2466_CR1(3), .def = 0x00 }, 881 { .reg = PEB2466_CR0(3), .def = PEB2466_CR0_IMR1 }, 882 }; 883 static const u8 imr1_p1[8] = {0x00, 0x90, 0x09, 0x00, 0x90, 0x09, 0x00, 0x00}; 884 static const u8 imr1_p2[8] = {0x7F, 0xFF, 0x00, 0x00, 0x90, 0x14, 0x40, 0x08}; 885 static const u8 zero[8] = {0}; 886 int ret; 887 int i; 888 889 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 890 peb2466->ch[i].tg1_freq_item = PEB2466_TONE_1000HZ; 891 peb2466->ch[i].tg2_freq_item = PEB2466_TONE_1000HZ; 892 893 /* 894 * Even if not used, disabling IM/R1 filter is not recommended. 895 * Instead, we must configure it with default coefficients and 896 * enable it. 897 * The filter will be enabled right after (in the following 898 * regmap_multi_reg_write() call). 899 */ 900 ret = peb2466_write_buf(peb2466, PEB2466_IMR1_FILTER_P1(i), imr1_p1, 8); 901 if (ret) 902 return ret; 903 ret = peb2466_write_buf(peb2466, PEB2466_IMR1_FILTER_P2(i), imr1_p2, 8); 904 if (ret) 905 return ret; 906 907 /* Set all other filters coefficients to zero */ 908 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P1(i), zero, 8); 909 if (ret) 910 return ret; 911 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P2(i), zero, 8); 912 if (ret) 913 return ret; 914 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P3(i), zero, 8); 915 if (ret) 916 return ret; 917 ret = peb2466_write_buf(peb2466, PEB2466_FRX_FILTER(i), zero, 8); 918 if (ret) 919 return ret; 920 ret = peb2466_write_buf(peb2466, PEB2466_FRR_FILTER(i), zero, 8); 921 if (ret) 922 return ret; 923 ret = peb2466_write_buf(peb2466, PEB2466_AX_FILTER(i), zero, 4); 924 if (ret) 925 return ret; 926 ret = peb2466_write_buf(peb2466, PEB2466_AR_FILTER(i), zero, 4); 927 if (ret) 928 return ret; 929 } 930 931 return regmap_multi_reg_write(peb2466->regmap, reg_reset, ARRAY_SIZE(reg_reset)); 932 } 933 934 static int peb2466_fw_parse_thfilter(struct snd_soc_component *component, 935 u16 tag, u32 lng, const u8 *data) 936 { 937 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 938 u8 mask; 939 int ret; 940 int i; 941 942 dev_info(component->dev, "fw TH filter: mask %x, %*phN\n", *data, 943 lng - 1, data + 1); 944 945 /* 946 * TH_FILTER TLV data: 947 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 948 * - @1 8 bytes: TH-Filter coefficients part1 949 * - @9 8 bytes: TH-Filter coefficients part2 950 * - @17 8 bytes: TH-Filter coefficients part3 951 */ 952 mask = *data; 953 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 954 if (!(mask & (1 << i))) 955 continue; 956 957 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 958 PEB2466_CR0_TH, 0); 959 if (ret) 960 return ret; 961 962 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P1(i), data + 1, 8); 963 if (ret) 964 return ret; 965 966 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P2(i), data + 9, 8); 967 if (ret) 968 return ret; 969 970 ret = peb2466_write_buf(peb2466, PEB2466_TH_FILTER_P3(i), data + 17, 8); 971 if (ret) 972 return ret; 973 974 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 975 PEB2466_CR0_TH | PEB2466_CR0_THSEL_MASK, 976 PEB2466_CR0_TH | PEB2466_CR0_THSEL(i)); 977 if (ret) 978 return ret; 979 } 980 return 0; 981 } 982 983 static int peb2466_fw_parse_imr1filter(struct snd_soc_component *component, 984 u16 tag, u32 lng, const u8 *data) 985 { 986 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 987 u8 mask; 988 int ret; 989 int i; 990 991 dev_info(component->dev, "fw IM/R1 filter: mask %x, %*phN\n", *data, 992 lng - 1, data + 1); 993 994 /* 995 * IMR1_FILTER TLV data: 996 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 997 * - @1 8 bytes: IM/R1-Filter coefficients part1 998 * - @9 8 bytes: IM/R1-Filter coefficients part2 999 */ 1000 mask = *data; 1001 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1002 if (!(mask & (1 << i))) 1003 continue; 1004 1005 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1006 PEB2466_CR0_IMR1, 0); 1007 if (ret) 1008 return ret; 1009 1010 ret = peb2466_write_buf(peb2466, PEB2466_IMR1_FILTER_P1(i), data + 1, 8); 1011 if (ret) 1012 return ret; 1013 1014 ret = peb2466_write_buf(peb2466, PEB2466_IMR1_FILTER_P2(i), data + 9, 8); 1015 if (ret) 1016 return ret; 1017 1018 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1019 PEB2466_CR0_IMR1, PEB2466_CR0_IMR1); 1020 if (ret) 1021 return ret; 1022 } 1023 return 0; 1024 } 1025 1026 static int peb2466_fw_parse_frxfilter(struct snd_soc_component *component, 1027 u16 tag, u32 lng, const u8 *data) 1028 { 1029 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1030 u8 mask; 1031 int ret; 1032 int i; 1033 1034 dev_info(component->dev, "fw FRX filter: mask %x, %*phN\n", *data, 1035 lng - 1, data + 1); 1036 1037 /* 1038 * FRX_FILTER TLV data: 1039 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1040 * - @1 8 bytes: FRX-Filter coefficients 1041 */ 1042 mask = *data; 1043 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1044 if (!(mask & (1 << i))) 1045 continue; 1046 1047 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1048 PEB2466_CR0_FRX, 0); 1049 if (ret) 1050 return ret; 1051 1052 ret = peb2466_write_buf(peb2466, PEB2466_FRX_FILTER(i), data + 1, 8); 1053 if (ret) 1054 return ret; 1055 1056 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1057 PEB2466_CR0_FRX, PEB2466_CR0_FRX); 1058 if (ret) 1059 return ret; 1060 } 1061 return 0; 1062 } 1063 1064 static int peb2466_fw_parse_frrfilter(struct snd_soc_component *component, 1065 u16 tag, u32 lng, const u8 *data) 1066 { 1067 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1068 u8 mask; 1069 int ret; 1070 int i; 1071 1072 dev_info(component->dev, "fw FRR filter: mask %x, %*phN\n", *data, 1073 lng - 1, data + 1); 1074 1075 /* 1076 * FRR_FILTER TLV data: 1077 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1078 * - @1 8 bytes: FRR-Filter coefficients 1079 */ 1080 mask = *data; 1081 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1082 if (!(mask & (1 << i))) 1083 continue; 1084 1085 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1086 PEB2466_CR0_FRR, 0); 1087 if (ret) 1088 return ret; 1089 1090 ret = peb2466_write_buf(peb2466, PEB2466_FRR_FILTER(i), data + 1, 8); 1091 if (ret) 1092 return ret; 1093 1094 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1095 PEB2466_CR0_FRR, PEB2466_CR0_FRR); 1096 if (ret) 1097 return ret; 1098 } 1099 return 0; 1100 } 1101 1102 static int peb2466_fw_parse_axfilter(struct snd_soc_component *component, 1103 u16 tag, u32 lng, const u8 *data) 1104 { 1105 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1106 u8 mask; 1107 int ret; 1108 int i; 1109 1110 dev_info(component->dev, "fw AX filter: mask %x, %*phN\n", *data, 1111 lng - 1, data + 1); 1112 1113 /* 1114 * AX_FILTER TLV data: 1115 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1116 * - @1 4 bytes: AX-Filter coefficients 1117 */ 1118 mask = *data; 1119 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1120 if (!(mask & (1 << i))) 1121 continue; 1122 1123 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1124 PEB2466_CR0_AX, 0); 1125 if (ret) 1126 return ret; 1127 1128 ret = peb2466_write_buf(peb2466, PEB2466_AX_FILTER(i), data + 1, 4); 1129 if (ret) 1130 return ret; 1131 1132 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1133 PEB2466_CR0_AX, PEB2466_CR0_AX); 1134 if (ret) 1135 return ret; 1136 } 1137 return 0; 1138 } 1139 1140 static int peb2466_fw_parse_arfilter(struct snd_soc_component *component, 1141 u16 tag, u32 lng, const u8 *data) 1142 { 1143 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1144 u8 mask; 1145 int ret; 1146 int i; 1147 1148 dev_info(component->dev, "fw AR filter: mask %x, %*phN\n", *data, 1149 lng - 1, data + 1); 1150 1151 /* 1152 * AR_FILTER TLV data: 1153 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1154 * - @1 4 bytes: AR-Filter coefficients 1155 */ 1156 mask = *data; 1157 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1158 if (!(mask & (1 << i))) 1159 continue; 1160 1161 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1162 PEB2466_CR0_AR, 0); 1163 if (ret) 1164 return ret; 1165 1166 ret = peb2466_write_buf(peb2466, PEB2466_AR_FILTER(i), data + 1, 4); 1167 if (ret) 1168 return ret; 1169 1170 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1171 PEB2466_CR0_AR, PEB2466_CR0_AR); 1172 if (ret) 1173 return ret; 1174 } 1175 return 0; 1176 } 1177 1178 static const char * const peb2466_ax_ctrl_names[] = { 1179 "ADC0 Capture Volume", 1180 "ADC1 Capture Volume", 1181 "ADC2 Capture Volume", 1182 "ADC3 Capture Volume", 1183 }; 1184 1185 static int peb2466_fw_parse_axtable(struct snd_soc_component *component, 1186 u16 tag, u32 lng, const u8 *data) 1187 { 1188 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1189 struct peb2466_lkup_ctrl *lkup_ctrl; 1190 struct peb2466_lookup *lookup; 1191 u8 (*table)[4]; 1192 u32 table_size; 1193 u32 init_index; 1194 s32 min_val; 1195 s32 step; 1196 u8 mask; 1197 int ret; 1198 int i; 1199 1200 /* 1201 * AX_TABLE TLV data: 1202 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1203 * - @1 32bits signed: Min table value in centi dB (MinVal) 1204 * ie -300 means -3.0 dB 1205 * - @5 32bits signed: Step from on item to other item in centi dB (Step) 1206 * ie 25 means 0.25 dB) 1207 * - @9 32bits unsigned: Item index in the table to use for the initial 1208 * value 1209 * - @13 N*4 bytes: Table composed of 4 bytes items. 1210 * Each item correspond to an AX filter value. 1211 * 1212 * The conversion from raw value item in the table to/from the value in 1213 * dB is: Raw value at index i <-> (MinVal + i * Step) in centi dB. 1214 */ 1215 1216 /* Check Lng and extract the table size. */ 1217 if (lng < 13 || ((lng - 13) % 4)) { 1218 dev_err(component->dev, "fw AX table lng %u invalid\n", lng); 1219 return -EINVAL; 1220 } 1221 table_size = lng - 13; 1222 1223 min_val = get_unaligned_be32(data + 1); 1224 step = get_unaligned_be32(data + 5); 1225 init_index = get_unaligned_be32(data + 9); 1226 if (init_index >= (table_size / 4)) { 1227 dev_err(component->dev, "fw AX table index %u out of table[%u]\n", 1228 init_index, table_size / 4); 1229 return -EINVAL; 1230 } 1231 1232 dev_info(component->dev, 1233 "fw AX table: mask %x, min %d, step %d, %u items, tbl[%u] %*phN\n", 1234 *data, min_val, step, table_size / 4, init_index, 1235 4, data + 13 + (init_index * 4)); 1236 1237 BUILD_BUG_ON(sizeof(*table) != 4); 1238 table = devm_kzalloc(&peb2466->spi->dev, table_size, GFP_KERNEL); 1239 if (!table) 1240 return -ENOMEM; 1241 memcpy(table, data + 13, table_size); 1242 1243 mask = *data; 1244 BUILD_BUG_ON(ARRAY_SIZE(peb2466_ax_ctrl_names) != ARRAY_SIZE(peb2466->ch)); 1245 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1246 if (!(mask & (1 << i))) 1247 continue; 1248 1249 lookup = &peb2466->ch[i].ax_lookup; 1250 lookup->table = table; 1251 lookup->count = table_size / 4; 1252 1253 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1254 PEB2466_CR0_AX, 0); 1255 if (ret) 1256 return ret; 1257 1258 ret = peb2466_write_buf(peb2466, PEB2466_AX_FILTER(i), 1259 lookup->table[init_index], 4); 1260 if (ret) 1261 return ret; 1262 1263 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1264 PEB2466_CR0_AX, PEB2466_CR0_AX); 1265 if (ret) 1266 return ret; 1267 1268 lkup_ctrl = &peb2466->ch[i].ax_lkup_ctrl; 1269 lkup_ctrl->lookup = lookup; 1270 lkup_ctrl->reg = PEB2466_AX_FILTER(i); 1271 lkup_ctrl->index = init_index; 1272 1273 ret = peb2466_add_lkup_ctrl(component, lkup_ctrl, 1274 peb2466_ax_ctrl_names[i], 1275 min_val, step); 1276 if (ret) 1277 return ret; 1278 } 1279 return 0; 1280 } 1281 1282 static const char * const peb2466_ar_ctrl_names[] = { 1283 "DAC0 Playback Volume", 1284 "DAC1 Playback Volume", 1285 "DAC2 Playback Volume", 1286 "DAC3 Playback Volume", 1287 }; 1288 1289 static int peb2466_fw_parse_artable(struct snd_soc_component *component, 1290 u16 tag, u32 lng, const u8 *data) 1291 { 1292 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1293 struct peb2466_lkup_ctrl *lkup_ctrl; 1294 struct peb2466_lookup *lookup; 1295 u8 (*table)[4]; 1296 u32 table_size; 1297 u32 init_index; 1298 s32 min_val; 1299 s32 step; 1300 u8 mask; 1301 int ret; 1302 int i; 1303 1304 /* 1305 * AR_TABLE TLV data: 1306 * - @0 1 byte: Chan mask (bit set means related channel is concerned) 1307 * - @1 32bits signed: Min table value in centi dB (MinVal) 1308 * ie -300 means -3.0 dB 1309 * - @5 32bits signed: Step from on item to other item in centi dB (Step) 1310 * ie 25 means 0.25 dB) 1311 * - @9 32bits unsigned: Item index in the table to use for the initial 1312 * value 1313 * - @13 N*4 bytes: Table composed of 4 bytes items. 1314 * Each item correspond to an AR filter value. 1315 * 1316 * The conversion from raw value item in the table to/from the value in 1317 * dB is: Raw value at index i <-> (MinVal + i * Step) in centi dB. 1318 */ 1319 1320 /* Check Lng and extract the table size. */ 1321 if (lng < 13 || ((lng - 13) % 4)) { 1322 dev_err(component->dev, "fw AR table lng %u invalid\n", lng); 1323 return -EINVAL; 1324 } 1325 table_size = lng - 13; 1326 1327 min_val = get_unaligned_be32(data + 1); 1328 step = get_unaligned_be32(data + 5); 1329 init_index = get_unaligned_be32(data + 9); 1330 if (init_index >= (table_size / 4)) { 1331 dev_err(component->dev, "fw AR table index %u out of table[%u]\n", 1332 init_index, table_size / 4); 1333 return -EINVAL; 1334 } 1335 1336 dev_info(component->dev, 1337 "fw AR table: mask %x, min %d, step %d, %u items, tbl[%u] %*phN\n", 1338 *data, min_val, step, table_size / 4, init_index, 1339 4, data + 13 + (init_index * 4)); 1340 1341 BUILD_BUG_ON(sizeof(*table) != 4); 1342 table = devm_kzalloc(&peb2466->spi->dev, table_size, GFP_KERNEL); 1343 if (!table) 1344 return -ENOMEM; 1345 memcpy(table, data + 13, table_size); 1346 1347 mask = *data; 1348 BUILD_BUG_ON(ARRAY_SIZE(peb2466_ar_ctrl_names) != ARRAY_SIZE(peb2466->ch)); 1349 for (i = 0; i < ARRAY_SIZE(peb2466->ch); i++) { 1350 if (!(mask & (1 << i))) 1351 continue; 1352 1353 lookup = &peb2466->ch[i].ar_lookup; 1354 lookup->table = table; 1355 lookup->count = table_size / 4; 1356 1357 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1358 PEB2466_CR0_AR, 0); 1359 if (ret) 1360 return ret; 1361 1362 ret = peb2466_write_buf(peb2466, PEB2466_AR_FILTER(i), 1363 lookup->table[init_index], 4); 1364 if (ret) 1365 return ret; 1366 1367 ret = regmap_update_bits(peb2466->regmap, PEB2466_CR0(i), 1368 PEB2466_CR0_AR, PEB2466_CR0_AR); 1369 if (ret) 1370 return ret; 1371 1372 lkup_ctrl = &peb2466->ch[i].ar_lkup_ctrl; 1373 lkup_ctrl->lookup = lookup; 1374 lkup_ctrl->reg = PEB2466_AR_FILTER(i); 1375 lkup_ctrl->index = init_index; 1376 1377 ret = peb2466_add_lkup_ctrl(component, lkup_ctrl, 1378 peb2466_ar_ctrl_names[i], 1379 min_val, step); 1380 if (ret) 1381 return ret; 1382 } 1383 return 0; 1384 } 1385 1386 struct peb2466_fw_tag_def { 1387 u16 tag; 1388 u32 lng_min; 1389 u32 lng_max; 1390 int (*parse)(struct snd_soc_component *component, 1391 u16 tag, u32 lng, const u8 *data); 1392 }; 1393 1394 #define PEB2466_TAG_DEF_LNG_EQ(__tag, __lng, __parse) { \ 1395 .tag = __tag, \ 1396 .lng_min = __lng, \ 1397 .lng_max = __lng, \ 1398 .parse = __parse, \ 1399 } 1400 1401 #define PEB2466_TAG_DEF_LNG_MIN(__tag, __lng_min, __parse) { \ 1402 .tag = __tag, \ 1403 .lng_min = __lng_min, \ 1404 .lng_max = U32_MAX, \ 1405 .parse = __parse, \ 1406 } 1407 1408 static const struct peb2466_fw_tag_def peb2466_fw_tag_defs[] = { 1409 /* TH FILTER */ 1410 PEB2466_TAG_DEF_LNG_EQ(0x0001, 1 + 3 * 8, peb2466_fw_parse_thfilter), 1411 /* IMR1 FILTER */ 1412 PEB2466_TAG_DEF_LNG_EQ(0x0002, 1 + 2 * 8, peb2466_fw_parse_imr1filter), 1413 /* FRX FILTER */ 1414 PEB2466_TAG_DEF_LNG_EQ(0x0003, 1 + 8, peb2466_fw_parse_frxfilter), 1415 /* FRR FILTER */ 1416 PEB2466_TAG_DEF_LNG_EQ(0x0004, 1 + 8, peb2466_fw_parse_frrfilter), 1417 /* AX FILTER */ 1418 PEB2466_TAG_DEF_LNG_EQ(0x0005, 1 + 4, peb2466_fw_parse_axfilter), 1419 /* AR FILTER */ 1420 PEB2466_TAG_DEF_LNG_EQ(0x0006, 1 + 4, peb2466_fw_parse_arfilter), 1421 /* AX TABLE */ 1422 PEB2466_TAG_DEF_LNG_MIN(0x0105, 1 + 3 * 4, peb2466_fw_parse_axtable), 1423 /* AR TABLE */ 1424 PEB2466_TAG_DEF_LNG_MIN(0x0106, 1 + 3 * 4, peb2466_fw_parse_artable), 1425 }; 1426 1427 static const struct peb2466_fw_tag_def *peb2466_fw_get_tag_def(u16 tag) 1428 { 1429 int i; 1430 1431 for (i = 0; i < ARRAY_SIZE(peb2466_fw_tag_defs); i++) { 1432 if (peb2466_fw_tag_defs[i].tag == tag) 1433 return &peb2466_fw_tag_defs[i]; 1434 } 1435 return NULL; 1436 } 1437 1438 static int peb2466_fw_parse(struct snd_soc_component *component, 1439 const u8 *data, size_t size) 1440 { 1441 const struct peb2466_fw_tag_def *tag_def; 1442 size_t left; 1443 const u8 *buf; 1444 u16 val16; 1445 u16 tag; 1446 u32 lng; 1447 int ret; 1448 1449 /* 1450 * Coefficients firmware binary structure (16bits and 32bits are 1451 * big-endian values). 1452 * 1453 * @0, 16bits: Magic (0x2466) 1454 * @2, 16bits: Version (0x0100 for version 1.0) 1455 * @4, 2+4+N bytes: TLV block 1456 * @4+(2+4+N) bytes: Next TLV block 1457 * ... 1458 * 1459 * Detail of a TLV block: 1460 * @0, 16bits: Tag 1461 * @2, 32bits: Lng 1462 * @6, lng bytes: Data 1463 * 1464 * The detail the Data for a given TLV Tag is provided in the related 1465 * parser. 1466 */ 1467 1468 left = size; 1469 buf = data; 1470 1471 if (left < 4) { 1472 dev_err(component->dev, "fw size %zu, exp at least 4\n", left); 1473 return -EINVAL; 1474 } 1475 1476 /* Check magic */ 1477 val16 = get_unaligned_be16(buf); 1478 if (val16 != 0x2466) { 1479 dev_err(component->dev, "fw magic 0x%04x exp 0x2466\n", val16); 1480 return -EINVAL; 1481 } 1482 buf += 2; 1483 left -= 2; 1484 1485 /* Check version */ 1486 val16 = get_unaligned_be16(buf); 1487 if (val16 != 0x0100) { 1488 dev_err(component->dev, "fw magic 0x%04x exp 0x0100\n", val16); 1489 return -EINVAL; 1490 } 1491 buf += 2; 1492 left -= 2; 1493 1494 while (left) { 1495 if (left < 6) { 1496 dev_err(component->dev, "fw %td/%zu left %zu, exp at least 6\n", 1497 buf - data, size, left); 1498 return -EINVAL; 1499 } 1500 /* Check tag and lng */ 1501 tag = get_unaligned_be16(buf); 1502 lng = get_unaligned_be32(buf + 2); 1503 tag_def = peb2466_fw_get_tag_def(tag); 1504 if (!tag_def) { 1505 dev_err(component->dev, "fw %td/%zu tag 0x%04x unknown\n", 1506 buf - data, size, tag); 1507 return -EINVAL; 1508 } 1509 if (lng < tag_def->lng_min || lng > tag_def->lng_max) { 1510 dev_err(component->dev, "fw %td/%zu tag 0x%04x lng %u, exp [%u;%u]\n", 1511 buf - data, size, tag, lng, tag_def->lng_min, tag_def->lng_max); 1512 return -EINVAL; 1513 } 1514 buf += 6; 1515 left -= 6; 1516 if (left < lng) { 1517 dev_err(component->dev, "fw %td/%zu tag 0x%04x lng %u, left %zu\n", 1518 buf - data, size, tag, lng, left); 1519 return -EINVAL; 1520 } 1521 1522 /* TLV block is valid -> parse the data part */ 1523 ret = tag_def->parse(component, tag, lng, buf); 1524 if (ret) { 1525 dev_err(component->dev, "fw %td/%zu tag 0x%04x lng %u parse failed\n", 1526 buf - data, size, tag, lng); 1527 return ret; 1528 } 1529 1530 buf += lng; 1531 left -= lng; 1532 } 1533 return 0; 1534 } 1535 1536 static int peb2466_load_coeffs(struct snd_soc_component *component, const char *fw_name) 1537 { 1538 const struct firmware *fw; 1539 int ret; 1540 1541 ret = request_firmware(&fw, fw_name, component->dev); 1542 if (ret) 1543 return ret; 1544 1545 ret = peb2466_fw_parse(component, fw->data, fw->size); 1546 release_firmware(fw); 1547 1548 return ret; 1549 } 1550 1551 static int peb2466_component_probe(struct snd_soc_component *component) 1552 { 1553 struct peb2466 *peb2466 = snd_soc_component_get_drvdata(component); 1554 const char *firmware_name; 1555 int ret; 1556 1557 /* reset peb2466 audio part */ 1558 ret = peb2466_reset_audio(peb2466); 1559 if (ret) 1560 return ret; 1561 1562 ret = of_property_read_string(peb2466->spi->dev.of_node, 1563 "firmware-name", &firmware_name); 1564 if (ret) 1565 return (ret == -EINVAL) ? 0 : ret; 1566 1567 return peb2466_load_coeffs(component, firmware_name); 1568 } 1569 1570 static const struct snd_soc_component_driver peb2466_component_driver = { 1571 .probe = peb2466_component_probe, 1572 .controls = peb2466_controls, 1573 .num_controls = ARRAY_SIZE(peb2466_controls), 1574 .dapm_widgets = peb2466_dapm_widgets, 1575 .num_dapm_widgets = ARRAY_SIZE(peb2466_dapm_widgets), 1576 .dapm_routes = peb2466_dapm_routes, 1577 .num_dapm_routes = ARRAY_SIZE(peb2466_dapm_routes), 1578 .endianness = 1, 1579 }; 1580 1581 /* 1582 * The mapping used for the relationship between the gpio offset and the 1583 * physical pin is the following: 1584 * 1585 * offset pin 1586 * 0 SI1_0 1587 * 1 SI1_1 1588 * 2 SI2_0 1589 * 3 SI2_1 1590 * 4 SI3_0 1591 * 5 SI3_1 1592 * 6 SI4_0 1593 * 7 SI4_1 1594 * 8 SO1_0 1595 * 9 SO1_1 1596 * 10 SO2_0 1597 * 11 SO2_1 1598 * 12 SO3_0 1599 * 13 SO3_1 1600 * 14 SO4_0 1601 * 15 SO4_1 1602 * 16 SB1_0 1603 * 17 SB1_1 1604 * 18 SB2_0 1605 * 19 SB2_1 1606 * 20 SB3_0 1607 * 21 SB3_1 1608 * 22 SB4_0 1609 * 23 SB4_1 1610 * 24 SB1_2 1611 * 25 SB2_2 1612 * 26 SB3_2 1613 * 27 SB4_2 1614 */ 1615 1616 static int peb2466_chip_gpio_offset_to_data_regmask(unsigned int offset, 1617 unsigned int *xr_reg, 1618 unsigned int *mask) 1619 { 1620 if (offset < 16) { 1621 /* 1622 * SIx_{0,1} and SOx_{0,1} 1623 * Read accesses read SIx_{0,1} values 1624 * Write accesses write SOx_{0,1} values 1625 */ 1626 *xr_reg = PEB2466_XR0; 1627 *mask = (1 << (offset % 8)); 1628 return 0; 1629 } 1630 if (offset < 24) { 1631 /* SBx_{0,1} */ 1632 *xr_reg = PEB2466_XR1; 1633 *mask = (1 << (offset - 16)); 1634 return 0; 1635 } 1636 if (offset < 28) { 1637 /* SBx_2 */ 1638 *xr_reg = PEB2466_XR3; 1639 *mask = (1 << (offset - 24 + 4)); 1640 return 0; 1641 } 1642 return -EINVAL; 1643 } 1644 1645 static int peb2466_chip_gpio_offset_to_dir_regmask(unsigned int offset, 1646 unsigned int *xr_reg, 1647 unsigned int *mask) 1648 { 1649 if (offset < 16) { 1650 /* Direction cannot be changed for these GPIOs */ 1651 return -EINVAL; 1652 } 1653 if (offset < 24) { 1654 *xr_reg = PEB2466_XR2; 1655 *mask = (1 << (offset - 16)); 1656 return 0; 1657 } 1658 if (offset < 28) { 1659 *xr_reg = PEB2466_XR3; 1660 *mask = (1 << (offset - 24)); 1661 return 0; 1662 } 1663 return -EINVAL; 1664 } 1665 1666 static unsigned int *peb2466_chip_gpio_get_cache(struct peb2466 *peb2466, 1667 unsigned int xr_reg) 1668 { 1669 unsigned int *cache; 1670 1671 switch (xr_reg) { 1672 case PEB2466_XR0: 1673 cache = &peb2466->gpio.cache.xr0; 1674 break; 1675 case PEB2466_XR1: 1676 cache = &peb2466->gpio.cache.xr1; 1677 break; 1678 case PEB2466_XR2: 1679 cache = &peb2466->gpio.cache.xr2; 1680 break; 1681 case PEB2466_XR3: 1682 cache = &peb2466->gpio.cache.xr3; 1683 break; 1684 default: 1685 cache = NULL; 1686 break; 1687 } 1688 return cache; 1689 } 1690 1691 static int peb2466_chip_gpio_update_bits(struct peb2466 *peb2466, unsigned int xr_reg, 1692 unsigned int mask, unsigned int val) 1693 { 1694 unsigned int tmp; 1695 unsigned int *cache; 1696 int ret; 1697 1698 /* 1699 * Read and write accesses use different peb2466 internal signals (input 1700 * signals on reads and output signals on writes). regmap_update_bits 1701 * cannot be used to read/modify/write the value. 1702 * So, a specific cache value is used. 1703 */ 1704 1705 mutex_lock(&peb2466->gpio.lock); 1706 1707 cache = peb2466_chip_gpio_get_cache(peb2466, xr_reg); 1708 if (!cache) { 1709 ret = -EINVAL; 1710 goto end; 1711 } 1712 1713 tmp = *cache; 1714 tmp &= ~mask; 1715 tmp |= val; 1716 1717 ret = regmap_write(peb2466->regmap, xr_reg, tmp); 1718 if (ret) 1719 goto end; 1720 1721 *cache = tmp; 1722 ret = 0; 1723 1724 end: 1725 mutex_unlock(&peb2466->gpio.lock); 1726 return ret; 1727 } 1728 1729 static void peb2466_chip_gpio_set(struct gpio_chip *c, unsigned int offset, int val) 1730 { 1731 struct peb2466 *peb2466 = gpiochip_get_data(c); 1732 unsigned int xr_reg; 1733 unsigned int mask; 1734 int ret; 1735 1736 if (offset < 8) { 1737 /* 1738 * SIx_{0,1} signals cannot be set and writing the related 1739 * register will change the SOx_{0,1} signals 1740 */ 1741 dev_warn(&peb2466->spi->dev, "cannot set gpio %d (read-only)\n", 1742 offset); 1743 return; 1744 } 1745 1746 ret = peb2466_chip_gpio_offset_to_data_regmask(offset, &xr_reg, &mask); 1747 if (ret) { 1748 dev_err(&peb2466->spi->dev, "cannot set gpio %d (%d)\n", 1749 offset, ret); 1750 return; 1751 } 1752 1753 ret = peb2466_chip_gpio_update_bits(peb2466, xr_reg, mask, val ? mask : 0); 1754 if (ret) { 1755 dev_err(&peb2466->spi->dev, "set gpio %d (0x%x, 0x%x) failed (%d)\n", 1756 offset, xr_reg, mask, ret); 1757 } 1758 } 1759 1760 static int peb2466_chip_gpio_get(struct gpio_chip *c, unsigned int offset) 1761 { 1762 struct peb2466 *peb2466 = gpiochip_get_data(c); 1763 bool use_cache = false; 1764 unsigned int *cache; 1765 unsigned int xr_reg; 1766 unsigned int mask; 1767 unsigned int val; 1768 int ret; 1769 1770 if (offset >= 8 && offset < 16) { 1771 /* 1772 * SOx_{0,1} signals cannot be read. Reading the related 1773 * register will read the SIx_{0,1} signals. 1774 * Use the cache to get value; 1775 */ 1776 use_cache = true; 1777 } 1778 1779 ret = peb2466_chip_gpio_offset_to_data_regmask(offset, &xr_reg, &mask); 1780 if (ret) { 1781 dev_err(&peb2466->spi->dev, "cannot get gpio %d (%d)\n", 1782 offset, ret); 1783 return -EINVAL; 1784 } 1785 1786 if (use_cache) { 1787 cache = peb2466_chip_gpio_get_cache(peb2466, xr_reg); 1788 if (!cache) 1789 return -EINVAL; 1790 val = *cache; 1791 } else { 1792 ret = regmap_read(peb2466->regmap, xr_reg, &val); 1793 if (ret) { 1794 dev_err(&peb2466->spi->dev, "get gpio %d (0x%x, 0x%x) failed (%d)\n", 1795 offset, xr_reg, mask, ret); 1796 return ret; 1797 } 1798 } 1799 1800 return !!(val & mask); 1801 } 1802 1803 static int peb2466_chip_get_direction(struct gpio_chip *c, unsigned int offset) 1804 { 1805 struct peb2466 *peb2466 = gpiochip_get_data(c); 1806 unsigned int xr_reg; 1807 unsigned int mask; 1808 unsigned int val; 1809 int ret; 1810 1811 if (offset < 8) { 1812 /* SIx_{0,1} */ 1813 return GPIO_LINE_DIRECTION_IN; 1814 } 1815 if (offset < 16) { 1816 /* SOx_{0,1} */ 1817 return GPIO_LINE_DIRECTION_OUT; 1818 } 1819 1820 ret = peb2466_chip_gpio_offset_to_dir_regmask(offset, &xr_reg, &mask); 1821 if (ret) { 1822 dev_err(&peb2466->spi->dev, "cannot get gpio %d direction (%d)\n", 1823 offset, ret); 1824 return ret; 1825 } 1826 1827 ret = regmap_read(peb2466->regmap, xr_reg, &val); 1828 if (ret) { 1829 dev_err(&peb2466->spi->dev, "get dir gpio %d (0x%x, 0x%x) failed (%d)\n", 1830 offset, xr_reg, mask, ret); 1831 return ret; 1832 } 1833 1834 return val & mask ? GPIO_LINE_DIRECTION_OUT : GPIO_LINE_DIRECTION_IN; 1835 } 1836 1837 static int peb2466_chip_direction_input(struct gpio_chip *c, unsigned int offset) 1838 { 1839 struct peb2466 *peb2466 = gpiochip_get_data(c); 1840 unsigned int xr_reg; 1841 unsigned int mask; 1842 int ret; 1843 1844 if (offset < 8) { 1845 /* SIx_{0,1} */ 1846 return 0; 1847 } 1848 if (offset < 16) { 1849 /* SOx_{0,1} */ 1850 return -EINVAL; 1851 } 1852 1853 ret = peb2466_chip_gpio_offset_to_dir_regmask(offset, &xr_reg, &mask); 1854 if (ret) { 1855 dev_err(&peb2466->spi->dev, "cannot set gpio %d direction (%d)\n", 1856 offset, ret); 1857 return ret; 1858 } 1859 1860 ret = peb2466_chip_gpio_update_bits(peb2466, xr_reg, mask, 0); 1861 if (ret) { 1862 dev_err(&peb2466->spi->dev, "Set dir in gpio %d (0x%x, 0x%x) failed (%d)\n", 1863 offset, xr_reg, mask, ret); 1864 return ret; 1865 } 1866 1867 return 0; 1868 } 1869 1870 static int peb2466_chip_direction_output(struct gpio_chip *c, unsigned int offset, int val) 1871 { 1872 struct peb2466 *peb2466 = gpiochip_get_data(c); 1873 unsigned int xr_reg; 1874 unsigned int mask; 1875 int ret; 1876 1877 if (offset < 8) { 1878 /* SIx_{0,1} */ 1879 return -EINVAL; 1880 } 1881 1882 peb2466_chip_gpio_set(c, offset, val); 1883 1884 if (offset < 16) { 1885 /* SOx_{0,1} */ 1886 return 0; 1887 } 1888 1889 ret = peb2466_chip_gpio_offset_to_dir_regmask(offset, &xr_reg, &mask); 1890 if (ret) { 1891 dev_err(&peb2466->spi->dev, "cannot set gpio %d direction (%d)\n", 1892 offset, ret); 1893 return ret; 1894 } 1895 1896 ret = peb2466_chip_gpio_update_bits(peb2466, xr_reg, mask, mask); 1897 if (ret) { 1898 dev_err(&peb2466->spi->dev, "Set dir in gpio %d (0x%x, 0x%x) failed (%d)\n", 1899 offset, xr_reg, mask, ret); 1900 return ret; 1901 } 1902 1903 return 0; 1904 } 1905 1906 static int peb2466_reset_gpio(struct peb2466 *peb2466) 1907 { 1908 static const struct reg_sequence reg_reset[] = { 1909 /* Output pins at 0, input/output pins as input */ 1910 { .reg = PEB2466_XR0, .def = 0 }, 1911 { .reg = PEB2466_XR1, .def = 0 }, 1912 { .reg = PEB2466_XR2, .def = 0 }, 1913 { .reg = PEB2466_XR3, .def = 0 }, 1914 }; 1915 1916 peb2466->gpio.cache.xr0 = 0; 1917 peb2466->gpio.cache.xr1 = 0; 1918 peb2466->gpio.cache.xr2 = 0; 1919 peb2466->gpio.cache.xr3 = 0; 1920 1921 return regmap_multi_reg_write(peb2466->regmap, reg_reset, ARRAY_SIZE(reg_reset)); 1922 } 1923 1924 static int peb2466_gpio_init(struct peb2466 *peb2466) 1925 { 1926 int ret; 1927 1928 mutex_init(&peb2466->gpio.lock); 1929 1930 ret = peb2466_reset_gpio(peb2466); 1931 if (ret) 1932 return ret; 1933 1934 peb2466->gpio.gpio_chip.owner = THIS_MODULE; 1935 peb2466->gpio.gpio_chip.label = dev_name(&peb2466->spi->dev); 1936 peb2466->gpio.gpio_chip.parent = &peb2466->spi->dev; 1937 peb2466->gpio.gpio_chip.base = -1; 1938 peb2466->gpio.gpio_chip.ngpio = 28; 1939 peb2466->gpio.gpio_chip.get_direction = peb2466_chip_get_direction; 1940 peb2466->gpio.gpio_chip.direction_input = peb2466_chip_direction_input; 1941 peb2466->gpio.gpio_chip.direction_output = peb2466_chip_direction_output; 1942 peb2466->gpio.gpio_chip.get = peb2466_chip_gpio_get; 1943 peb2466->gpio.gpio_chip.set = peb2466_chip_gpio_set; 1944 peb2466->gpio.gpio_chip.can_sleep = true; 1945 1946 return devm_gpiochip_add_data(&peb2466->spi->dev, &peb2466->gpio.gpio_chip, 1947 peb2466); 1948 } 1949 1950 static int peb2466_spi_probe(struct spi_device *spi) 1951 { 1952 struct peb2466 *peb2466; 1953 unsigned long mclk_rate; 1954 int ret; 1955 u8 xr5; 1956 1957 spi->bits_per_word = 8; 1958 ret = spi_setup(spi); 1959 if (ret < 0) 1960 return ret; 1961 1962 peb2466 = devm_kzalloc(&spi->dev, sizeof(*peb2466), GFP_KERNEL); 1963 if (!peb2466) 1964 return -ENOMEM; 1965 1966 peb2466->spi = spi; 1967 1968 peb2466->regmap = devm_regmap_init(&peb2466->spi->dev, NULL, peb2466, 1969 &peb2466_regmap_config); 1970 if (IS_ERR(peb2466->regmap)) 1971 return PTR_ERR(peb2466->regmap); 1972 1973 peb2466->reset_gpio = devm_gpiod_get_optional(&peb2466->spi->dev, 1974 "reset", GPIOD_OUT_LOW); 1975 if (IS_ERR(peb2466->reset_gpio)) 1976 return PTR_ERR(peb2466->reset_gpio); 1977 1978 peb2466->mclk = devm_clk_get(&peb2466->spi->dev, "mclk"); 1979 if (IS_ERR(peb2466->mclk)) 1980 return PTR_ERR(peb2466->mclk); 1981 ret = clk_prepare_enable(peb2466->mclk); 1982 if (ret) 1983 return ret; 1984 1985 if (peb2466->reset_gpio) { 1986 gpiod_set_value_cansleep(peb2466->reset_gpio, 1); 1987 udelay(4); 1988 gpiod_set_value_cansleep(peb2466->reset_gpio, 0); 1989 udelay(4); 1990 } 1991 1992 spi_set_drvdata(spi, peb2466); 1993 1994 mclk_rate = clk_get_rate(peb2466->mclk); 1995 switch (mclk_rate) { 1996 case 1536000: 1997 xr5 = PEB2466_XR5_MCLK_1536; 1998 break; 1999 case 2048000: 2000 xr5 = PEB2466_XR5_MCLK_2048; 2001 break; 2002 case 4096000: 2003 xr5 = PEB2466_XR5_MCLK_4096; 2004 break; 2005 case 8192000: 2006 xr5 = PEB2466_XR5_MCLK_8192; 2007 break; 2008 default: 2009 dev_err(&peb2466->spi->dev, "Unsupported clock rate %lu\n", 2010 mclk_rate); 2011 ret = -EINVAL; 2012 goto failed; 2013 } 2014 ret = regmap_write(peb2466->regmap, PEB2466_XR5, xr5); 2015 if (ret) { 2016 dev_err(&peb2466->spi->dev, "Setting MCLK failed (%d)\n", ret); 2017 goto failed; 2018 } 2019 2020 ret = devm_snd_soc_register_component(&spi->dev, &peb2466_component_driver, 2021 &peb2466_dai_driver, 1); 2022 if (ret) 2023 goto failed; 2024 2025 if (IS_ENABLED(CONFIG_GPIOLIB)) { 2026 ret = peb2466_gpio_init(peb2466); 2027 if (ret) 2028 goto failed; 2029 } 2030 2031 return 0; 2032 2033 failed: 2034 clk_disable_unprepare(peb2466->mclk); 2035 return ret; 2036 } 2037 2038 static void peb2466_spi_remove(struct spi_device *spi) 2039 { 2040 struct peb2466 *peb2466 = spi_get_drvdata(spi); 2041 2042 clk_disable_unprepare(peb2466->mclk); 2043 } 2044 2045 static const struct of_device_id peb2466_of_match[] = { 2046 { .compatible = "infineon,peb2466", }, 2047 { } 2048 }; 2049 MODULE_DEVICE_TABLE(of, peb2466_of_match); 2050 2051 static const struct spi_device_id peb2466_id_table[] = { 2052 { "peb2466", 0 }, 2053 { } 2054 }; 2055 MODULE_DEVICE_TABLE(spi, peb2466_id_table); 2056 2057 static struct spi_driver peb2466_spi_driver = { 2058 .driver = { 2059 .name = "peb2466", 2060 .of_match_table = peb2466_of_match, 2061 }, 2062 .id_table = peb2466_id_table, 2063 .probe = peb2466_spi_probe, 2064 .remove = peb2466_spi_remove, 2065 }; 2066 2067 module_spi_driver(peb2466_spi_driver); 2068 2069 MODULE_AUTHOR("Herve Codina <herve.codina@bootlin.com>"); 2070 MODULE_DESCRIPTION("PEB2466 ALSA SoC driver"); 2071 MODULE_LICENSE("GPL"); 2072