1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 4 * Universal interface for Audio Codec '97 5 * 6 * For more details look to AC '97 component specification revision 2.2 7 * by Intel Corporation (http://developer.intel.com) and to datasheets 8 * for specific codecs. 9 */ 10 11 #include <linux/delay.h> 12 #include <linux/init.h> 13 #include <linux/slab.h> 14 #include <linux/mutex.h> 15 #include <linux/export.h> 16 17 #include <sound/core.h> 18 #include <sound/pcm.h> 19 #include <sound/control.h> 20 #include <sound/ac97_codec.h> 21 #include <sound/asoundef.h> 22 #include "ac97_id.h" 23 #include "ac97_local.h" 24 25 /* 26 * PCM support 27 */ 28 29 static const unsigned char rate_reg_tables[2][4][9] = { 30 { 31 /* standard rates */ 32 { 33 /* 3&4 front, 7&8 rear, 6&9 center/lfe */ 34 AC97_PCM_FRONT_DAC_RATE, /* slot 3 */ 35 AC97_PCM_FRONT_DAC_RATE, /* slot 4 */ 36 0xff, /* slot 5 */ 37 AC97_PCM_LFE_DAC_RATE, /* slot 6 */ 38 AC97_PCM_SURR_DAC_RATE, /* slot 7 */ 39 AC97_PCM_SURR_DAC_RATE, /* slot 8 */ 40 AC97_PCM_LFE_DAC_RATE, /* slot 9 */ 41 0xff, /* slot 10 */ 42 0xff, /* slot 11 */ 43 }, 44 { 45 /* 7&8 front, 6&9 rear, 10&11 center/lfe */ 46 0xff, /* slot 3 */ 47 0xff, /* slot 4 */ 48 0xff, /* slot 5 */ 49 AC97_PCM_SURR_DAC_RATE, /* slot 6 */ 50 AC97_PCM_FRONT_DAC_RATE, /* slot 7 */ 51 AC97_PCM_FRONT_DAC_RATE, /* slot 8 */ 52 AC97_PCM_SURR_DAC_RATE, /* slot 9 */ 53 AC97_PCM_LFE_DAC_RATE, /* slot 10 */ 54 AC97_PCM_LFE_DAC_RATE, /* slot 11 */ 55 }, 56 { 57 /* 6&9 front, 10&11 rear, 3&4 center/lfe */ 58 AC97_PCM_LFE_DAC_RATE, /* slot 3 */ 59 AC97_PCM_LFE_DAC_RATE, /* slot 4 */ 60 0xff, /* slot 5 */ 61 AC97_PCM_FRONT_DAC_RATE, /* slot 6 */ 62 0xff, /* slot 7 */ 63 0xff, /* slot 8 */ 64 AC97_PCM_FRONT_DAC_RATE, /* slot 9 */ 65 AC97_PCM_SURR_DAC_RATE, /* slot 10 */ 66 AC97_PCM_SURR_DAC_RATE, /* slot 11 */ 67 }, 68 { 69 /* 10&11 front, 3&4 rear, 7&8 center/lfe */ 70 AC97_PCM_SURR_DAC_RATE, /* slot 3 */ 71 AC97_PCM_SURR_DAC_RATE, /* slot 4 */ 72 0xff, /* slot 5 */ 73 0xff, /* slot 6 */ 74 AC97_PCM_LFE_DAC_RATE, /* slot 7 */ 75 AC97_PCM_LFE_DAC_RATE, /* slot 8 */ 76 0xff, /* slot 9 */ 77 AC97_PCM_FRONT_DAC_RATE, /* slot 10 */ 78 AC97_PCM_FRONT_DAC_RATE, /* slot 11 */ 79 }, 80 }, 81 { 82 /* double rates */ 83 { 84 /* 3&4 front, 7&8 front (t+1) */ 85 AC97_PCM_FRONT_DAC_RATE, /* slot 3 */ 86 AC97_PCM_FRONT_DAC_RATE, /* slot 4 */ 87 0xff, /* slot 5 */ 88 0xff, /* slot 6 */ 89 AC97_PCM_FRONT_DAC_RATE, /* slot 7 */ 90 AC97_PCM_FRONT_DAC_RATE, /* slot 8 */ 91 0xff, /* slot 9 */ 92 0xff, /* slot 10 */ 93 0xff, /* slot 11 */ 94 }, 95 { 96 /* not specified in the specification */ 97 0xff, /* slot 3 */ 98 0xff, /* slot 4 */ 99 0xff, /* slot 5 */ 100 0xff, /* slot 6 */ 101 0xff, /* slot 7 */ 102 0xff, /* slot 8 */ 103 0xff, /* slot 9 */ 104 0xff, /* slot 10 */ 105 0xff, /* slot 11 */ 106 }, 107 { 108 0xff, /* slot 3 */ 109 0xff, /* slot 4 */ 110 0xff, /* slot 5 */ 111 0xff, /* slot 6 */ 112 0xff, /* slot 7 */ 113 0xff, /* slot 8 */ 114 0xff, /* slot 9 */ 115 0xff, /* slot 10 */ 116 0xff, /* slot 11 */ 117 }, 118 { 119 0xff, /* slot 3 */ 120 0xff, /* slot 4 */ 121 0xff, /* slot 5 */ 122 0xff, /* slot 6 */ 123 0xff, /* slot 7 */ 124 0xff, /* slot 8 */ 125 0xff, /* slot 9 */ 126 0xff, /* slot 10 */ 127 0xff, /* slot 11 */ 128 } 129 }}; 130 131 /* FIXME: more various mappings for ADC? */ 132 static const unsigned char rate_cregs[9] = { 133 AC97_PCM_LR_ADC_RATE, /* 3 */ 134 AC97_PCM_LR_ADC_RATE, /* 4 */ 135 0xff, /* 5 */ 136 AC97_PCM_MIC_ADC_RATE, /* 6 */ 137 0xff, /* 7 */ 138 0xff, /* 8 */ 139 0xff, /* 9 */ 140 0xff, /* 10 */ 141 0xff, /* 11 */ 142 }; 143 144 static unsigned char get_slot_reg(struct ac97_pcm *pcm, unsigned short cidx, 145 unsigned short slot, int dbl) 146 { 147 if (slot < 3) 148 return 0xff; 149 if (slot > 11) 150 return 0xff; 151 if (pcm->spdif) 152 return AC97_SPDIF; /* pseudo register */ 153 if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK) 154 return rate_reg_tables[dbl][pcm->r[dbl].rate_table[cidx]][slot - 3]; 155 else 156 return rate_cregs[slot - 3]; 157 } 158 159 static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate) 160 { 161 unsigned short old, bits, reg, mask; 162 unsigned int sbits; 163 164 if (! (ac97->ext_id & AC97_EI_SPDIF)) 165 return -ENODEV; 166 167 /* TODO: double rate support */ 168 if (ac97->flags & AC97_CS_SPDIF) { 169 switch (rate) { 170 case 48000: bits = 0; break; 171 case 44100: bits = 1 << AC97_SC_SPSR_SHIFT; break; 172 default: /* invalid - disable output */ 173 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); 174 return -EINVAL; 175 } 176 reg = AC97_CSR_SPDIF; 177 mask = 1 << AC97_SC_SPSR_SHIFT; 178 } else { 179 if (ac97->id == AC97_ID_CM9739 && rate != 48000) { 180 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); 181 return -EINVAL; 182 } 183 switch (rate) { 184 case 44100: bits = AC97_SC_SPSR_44K; break; 185 case 48000: bits = AC97_SC_SPSR_48K; break; 186 case 32000: bits = AC97_SC_SPSR_32K; break; 187 default: /* invalid - disable output */ 188 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); 189 return -EINVAL; 190 } 191 reg = AC97_SPDIF; 192 mask = AC97_SC_SPSR_MASK; 193 } 194 195 guard(mutex)(&ac97->reg_mutex); 196 old = snd_ac97_read(ac97, reg) & mask; 197 if (old != bits) { 198 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); 199 snd_ac97_update_bits_nolock(ac97, reg, mask, bits); 200 /* update the internal spdif bits */ 201 sbits = ac97->spdif_status; 202 if (sbits & IEC958_AES0_PROFESSIONAL) { 203 sbits &= ~IEC958_AES0_PRO_FS; 204 switch (rate) { 205 case 44100: sbits |= IEC958_AES0_PRO_FS_44100; break; 206 case 48000: sbits |= IEC958_AES0_PRO_FS_48000; break; 207 case 32000: sbits |= IEC958_AES0_PRO_FS_32000; break; 208 } 209 } else { 210 sbits &= ~(IEC958_AES3_CON_FS << 24); 211 switch (rate) { 212 case 44100: sbits |= IEC958_AES3_CON_FS_44100<<24; break; 213 case 48000: sbits |= IEC958_AES3_CON_FS_48000<<24; break; 214 case 32000: sbits |= IEC958_AES3_CON_FS_32000<<24; break; 215 } 216 } 217 ac97->spdif_status = sbits; 218 } 219 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); 220 return 0; 221 } 222 223 /** 224 * snd_ac97_set_rate - change the rate of the given input/output. 225 * @ac97: the ac97 instance 226 * @reg: the register to change 227 * @rate: the sample rate to set 228 * 229 * Changes the rate of the given input/output on the codec. 230 * If the codec doesn't support VAR, the rate must be 48000 (except 231 * for SPDIF). 232 * 233 * The valid registers are AC97_PCM_MIC_ADC_RATE, 234 * AC97_PCM_FRONT_DAC_RATE, AC97_PCM_LR_ADC_RATE. 235 * AC97_PCM_SURR_DAC_RATE and AC97_PCM_LFE_DAC_RATE are accepted 236 * if the codec supports them. 237 * AC97_SPDIF is accepted as a pseudo register to modify the SPDIF 238 * status bits. 239 * 240 * Return: Zero if successful, or a negative error code on failure. 241 */ 242 int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate) 243 { 244 int dbl; 245 unsigned int tmp; 246 247 dbl = rate > 48000; 248 if (dbl) { 249 if (!(ac97->flags & AC97_DOUBLE_RATE)) 250 return -EINVAL; 251 if (reg != AC97_PCM_FRONT_DAC_RATE) 252 return -EINVAL; 253 } 254 255 snd_ac97_update_power(ac97, reg, 1); 256 switch (reg) { 257 case AC97_PCM_MIC_ADC_RATE: 258 if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRM) == 0) /* MIC VRA */ 259 if (rate != 48000) 260 return -EINVAL; 261 break; 262 case AC97_PCM_FRONT_DAC_RATE: 263 case AC97_PCM_LR_ADC_RATE: 264 if ((ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_VRA) == 0) /* VRA */ 265 if (rate != 48000 && rate != 96000) 266 return -EINVAL; 267 break; 268 case AC97_PCM_SURR_DAC_RATE: 269 if (! (ac97->scaps & AC97_SCAP_SURROUND_DAC)) 270 return -EINVAL; 271 break; 272 case AC97_PCM_LFE_DAC_RATE: 273 if (! (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)) 274 return -EINVAL; 275 break; 276 case AC97_SPDIF: 277 /* special case */ 278 return set_spdif_rate(ac97, rate); 279 default: 280 return -EINVAL; 281 } 282 if (dbl) 283 rate /= 2; 284 tmp = (rate * ac97->bus->clock) / 48000; 285 if (tmp > 65535) 286 return -EINVAL; 287 if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE) 288 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, 289 AC97_EA_DRA, dbl ? AC97_EA_DRA : 0); 290 snd_ac97_update(ac97, reg, tmp & 0xffff); 291 snd_ac97_read(ac97, reg); 292 if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE) { 293 /* Intel controllers require double rate data to be put in 294 * slots 7+8 295 */ 296 snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, 297 AC97_GP_DRSS_MASK, 298 dbl ? AC97_GP_DRSS_78 : 0); 299 snd_ac97_read(ac97, AC97_GENERAL_PURPOSE); 300 } 301 return 0; 302 } 303 304 EXPORT_SYMBOL(snd_ac97_set_rate); 305 306 static unsigned short get_pslots(struct snd_ac97 *ac97, unsigned char *rate_table, unsigned short *spdif_slots) 307 { 308 if (!ac97_is_audio(ac97)) 309 return 0; 310 if (ac97_is_rev22(ac97) || ac97_can_amap(ac97)) { 311 unsigned short slots = 0; 312 if (ac97_is_rev22(ac97)) { 313 /* Note: it's simply emulation of AMAP behaviour */ 314 u16 es; 315 es = ac97->regs[AC97_EXTENDED_ID] &= ~AC97_EI_DACS_SLOT_MASK; 316 switch (ac97->addr) { 317 case 1: 318 case 2: es |= (1<<AC97_EI_DACS_SLOT_SHIFT); break; 319 case 3: es |= (2<<AC97_EI_DACS_SLOT_SHIFT); break; 320 } 321 snd_ac97_write_cache(ac97, AC97_EXTENDED_ID, es); 322 } 323 switch (ac97->addr) { 324 case 0: 325 slots |= (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT); 326 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) 327 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT); 328 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) 329 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE); 330 if (ac97->ext_id & AC97_EI_SPDIF) { 331 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC)) 332 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT); 333 else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)) 334 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1); 335 else 336 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2); 337 } 338 *rate_table = 0; 339 break; 340 case 1: 341 case 2: 342 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT); 343 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) 344 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE); 345 if (ac97->ext_id & AC97_EI_SPDIF) { 346 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC)) 347 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1); 348 else 349 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2); 350 } 351 *rate_table = 1; 352 break; 353 case 3: 354 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE); 355 if (ac97->ext_id & AC97_EI_SPDIF) 356 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2); 357 *rate_table = 2; 358 break; 359 } 360 return slots; 361 } else { 362 unsigned short slots; 363 slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT); 364 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) 365 slots |= (1<<AC97_SLOT_PCM_SLEFT)|(1<<AC97_SLOT_PCM_SRIGHT); 366 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) 367 slots |= (1<<AC97_SLOT_PCM_CENTER)|(1<<AC97_SLOT_LFE); 368 if (ac97->ext_id & AC97_EI_SPDIF) { 369 if (!(ac97->scaps & AC97_SCAP_SURROUND_DAC)) 370 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT)|(1<<AC97_SLOT_SPDIF_RIGHT); 371 else if (!(ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)) 372 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT1)|(1<<AC97_SLOT_SPDIF_RIGHT1); 373 else 374 *spdif_slots = (1<<AC97_SLOT_SPDIF_LEFT2)|(1<<AC97_SLOT_SPDIF_RIGHT2); 375 } 376 *rate_table = 0; 377 return slots; 378 } 379 } 380 381 static unsigned short get_cslots(struct snd_ac97 *ac97) 382 { 383 unsigned short slots; 384 385 if (!ac97_is_audio(ac97)) 386 return 0; 387 slots = (1<<AC97_SLOT_PCM_LEFT)|(1<<AC97_SLOT_PCM_RIGHT); 388 slots |= (1<<AC97_SLOT_MIC); 389 return slots; 390 } 391 392 static unsigned int get_rates(struct ac97_pcm *pcm, unsigned int cidx, unsigned short slots, int dbl) 393 { 394 int i, idx; 395 unsigned int rates = ~0; 396 unsigned char reg; 397 398 for (i = 3; i < 12; i++) { 399 if (!(slots & (1 << i))) 400 continue; 401 reg = get_slot_reg(pcm, cidx, i, dbl); 402 switch (reg) { 403 case AC97_PCM_FRONT_DAC_RATE: idx = AC97_RATES_FRONT_DAC; break; 404 case AC97_PCM_SURR_DAC_RATE: idx = AC97_RATES_SURR_DAC; break; 405 case AC97_PCM_LFE_DAC_RATE: idx = AC97_RATES_LFE_DAC; break; 406 case AC97_PCM_LR_ADC_RATE: idx = AC97_RATES_ADC; break; 407 case AC97_PCM_MIC_ADC_RATE: idx = AC97_RATES_MIC_ADC; break; 408 default: idx = AC97_RATES_SPDIF; break; 409 } 410 rates &= pcm->r[dbl].codec[cidx]->rates[idx]; 411 } 412 if (!dbl) 413 rates &= ~(SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 | 414 SNDRV_PCM_RATE_96000); 415 return rates; 416 } 417 418 /** 419 * snd_ac97_pcm_assign - assign AC97 slots to given PCM streams 420 * @bus: the ac97 bus instance 421 * @pcms_count: count of PCMs to be assigned 422 * @pcms: PCMs to be assigned 423 * 424 * It assigns available AC97 slots for given PCMs. If none or only 425 * some slots are available, pcm->xxx.slots and pcm->xxx.rslots[] members 426 * are reduced and might be zero. 427 * 428 * Return: Zero if successful, or a negative error code on failure. 429 */ 430 int snd_ac97_pcm_assign(struct snd_ac97_bus *bus, 431 unsigned short pcms_count, 432 const struct ac97_pcm *pcms) 433 { 434 int i, j, k; 435 const struct ac97_pcm *pcm; 436 struct ac97_pcm *rpcms, *rpcm; 437 unsigned short avail_slots[2][4]; 438 unsigned char rate_table[2][4]; 439 unsigned short tmp, slots; 440 unsigned short spdif_slots[4]; 441 unsigned int rates; 442 struct snd_ac97 *codec; 443 444 rpcms = kcalloc(pcms_count, sizeof(struct ac97_pcm), GFP_KERNEL); 445 if (rpcms == NULL) 446 return -ENOMEM; 447 memset(avail_slots, 0, sizeof(avail_slots)); 448 memset(rate_table, 0, sizeof(rate_table)); 449 memset(spdif_slots, 0, sizeof(spdif_slots)); 450 for (i = 0; i < 4; i++) { 451 codec = bus->codec[i]; 452 if (!codec) 453 continue; 454 avail_slots[0][i] = get_pslots(codec, &rate_table[0][i], &spdif_slots[i]); 455 avail_slots[1][i] = get_cslots(codec); 456 if (!(codec->scaps & AC97_SCAP_INDEP_SDIN)) { 457 for (j = 0; j < i; j++) { 458 if (bus->codec[j]) 459 avail_slots[1][i] &= ~avail_slots[1][j]; 460 } 461 } 462 } 463 /* first step - exclusive devices */ 464 for (i = 0; i < pcms_count; i++) { 465 pcm = &pcms[i]; 466 rpcm = &rpcms[i]; 467 /* low-level driver thinks that it's more clever */ 468 if (pcm->copy_flag) { 469 *rpcm = *pcm; 470 continue; 471 } 472 rpcm->stream = pcm->stream; 473 rpcm->exclusive = pcm->exclusive; 474 rpcm->spdif = pcm->spdif; 475 rpcm->private_value = pcm->private_value; 476 rpcm->bus = bus; 477 rpcm->rates = ~0; 478 slots = pcm->r[0].slots; 479 for (j = 0; j < 4 && slots; j++) { 480 if (!bus->codec[j]) 481 continue; 482 rates = ~0; 483 if (pcm->spdif && pcm->stream == 0) 484 tmp = spdif_slots[j]; 485 else 486 tmp = avail_slots[pcm->stream][j]; 487 if (pcm->exclusive) { 488 /* exclusive access */ 489 tmp &= slots; 490 for (k = 0; k < i; k++) { 491 if (rpcm->stream == rpcms[k].stream) 492 tmp &= ~rpcms[k].r[0].rslots[j]; 493 } 494 } else { 495 /* non-exclusive access */ 496 tmp &= pcm->r[0].slots; 497 } 498 if (tmp) { 499 rpcm->r[0].rslots[j] = tmp; 500 rpcm->r[0].codec[j] = bus->codec[j]; 501 rpcm->r[0].rate_table[j] = rate_table[pcm->stream][j]; 502 if (bus->no_vra) 503 rates = SNDRV_PCM_RATE_48000; 504 else 505 rates = get_rates(rpcm, j, tmp, 0); 506 if (pcm->exclusive) 507 avail_slots[pcm->stream][j] &= ~tmp; 508 } 509 slots &= ~tmp; 510 rpcm->r[0].slots |= tmp; 511 rpcm->rates &= rates; 512 } 513 /* for double rate, we check the first codec only */ 514 if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK && 515 bus->codec[0] && (bus->codec[0]->flags & AC97_DOUBLE_RATE) && 516 rate_table[pcm->stream][0] == 0) { 517 tmp = (1<<AC97_SLOT_PCM_LEFT) | (1<<AC97_SLOT_PCM_RIGHT) | 518 (1<<AC97_SLOT_PCM_LEFT_0) | (1<<AC97_SLOT_PCM_RIGHT_0); 519 if ((tmp & pcm->r[1].slots) == tmp) { 520 rpcm->r[1].slots = tmp; 521 rpcm->r[1].rslots[0] = tmp; 522 rpcm->r[1].rate_table[0] = 0; 523 rpcm->r[1].codec[0] = bus->codec[0]; 524 if (pcm->exclusive) 525 avail_slots[pcm->stream][0] &= ~tmp; 526 if (bus->no_vra) 527 rates = SNDRV_PCM_RATE_96000; 528 else 529 rates = get_rates(rpcm, 0, tmp, 1); 530 rpcm->rates |= rates; 531 } 532 } 533 if (rpcm->rates == ~0) 534 rpcm->rates = 0; /* not used */ 535 } 536 bus->pcms_count = pcms_count; 537 bus->pcms = rpcms; 538 return 0; 539 } 540 541 EXPORT_SYMBOL(snd_ac97_pcm_assign); 542 543 /** 544 * snd_ac97_pcm_open - opens the given AC97 pcm 545 * @pcm: the ac97 pcm instance 546 * @rate: rate in Hz, if codec does not support VRA, this value must be 48000Hz 547 * @cfg: output stream characteristics 548 * @slots: a subset of allocated slots (snd_ac97_pcm_assign) for this pcm 549 * 550 * It locks the specified slots and sets the given rate to AC97 registers. 551 * 552 * Return: Zero if successful, or a negative error code on failure. 553 */ 554 int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate, 555 enum ac97_pcm_cfg cfg, unsigned short slots) 556 { 557 struct snd_ac97_bus *bus; 558 int i, cidx, r, ok_flag; 559 unsigned int reg_ok[4] = {0,0,0,0}; 560 unsigned char reg; 561 int err = 0; 562 563 r = rate > 48000; 564 bus = pcm->bus; 565 if (cfg == AC97_PCM_CFG_SPDIF) { 566 for (cidx = 0; cidx < 4; cidx++) 567 if (bus->codec[cidx] && (bus->codec[cidx]->ext_id & AC97_EI_SPDIF)) { 568 err = set_spdif_rate(bus->codec[cidx], rate); 569 if (err < 0) 570 return err; 571 } 572 } 573 scoped_guard(spinlock_irq, &pcm->bus->bus_lock) { 574 for (i = 3; i < 12; i++) { 575 if (!(slots & (1 << i))) 576 continue; 577 ok_flag = 0; 578 for (cidx = 0; cidx < 4; cidx++) { 579 if (bus->used_slots[pcm->stream][cidx] & (1 << i)) { 580 err = -EBUSY; 581 goto error; 582 } 583 if (pcm->r[r].rslots[cidx] & (1 << i)) { 584 bus->used_slots[pcm->stream][cidx] |= (1 << i); 585 ok_flag++; 586 } 587 } 588 if (!ok_flag) { 589 dev_err(bus->card->dev, 590 "cannot find configuration for AC97 slot %i\n", 591 i); 592 err = -EAGAIN; 593 goto error; 594 } 595 } 596 pcm->cur_dbl = r; 597 } 598 for (i = 3; i < 12; i++) { 599 if (!(slots & (1 << i))) 600 continue; 601 for (cidx = 0; cidx < 4; cidx++) { 602 if (pcm->r[r].rslots[cidx] & (1 << i)) { 603 reg = get_slot_reg(pcm, cidx, i, r); 604 if (reg == 0xff) { 605 dev_err(bus->card->dev, 606 "invalid AC97 slot %i?\n", i); 607 continue; 608 } 609 if (reg_ok[cidx] & (1 << (reg - AC97_PCM_FRONT_DAC_RATE))) 610 continue; 611 dev_dbg(bus->card->dev, 612 "setting ac97 reg 0x%x to rate %d\n", 613 reg, rate); 614 err = snd_ac97_set_rate(pcm->r[r].codec[cidx], reg, rate); 615 if (err < 0) 616 dev_err(bus->card->dev, 617 "error in snd_ac97_set_rate: cidx=%d, reg=0x%x, rate=%d, err=%d\n", 618 cidx, reg, rate, err); 619 else 620 reg_ok[cidx] |= (1 << (reg - AC97_PCM_FRONT_DAC_RATE)); 621 } 622 } 623 } 624 pcm->aslots = slots; 625 return 0; 626 627 error: 628 pcm->aslots = slots; 629 snd_ac97_pcm_close(pcm); 630 return err; 631 } 632 633 EXPORT_SYMBOL(snd_ac97_pcm_open); 634 635 /** 636 * snd_ac97_pcm_close - closes the given AC97 pcm 637 * @pcm: the ac97 pcm instance 638 * 639 * It frees the locked AC97 slots. 640 * 641 * Return: Zero. 642 */ 643 int snd_ac97_pcm_close(struct ac97_pcm *pcm) 644 { 645 struct snd_ac97_bus *bus; 646 unsigned short slots = pcm->aslots; 647 int i, cidx; 648 649 #ifdef CONFIG_SND_AC97_POWER_SAVE 650 int r = pcm->cur_dbl; 651 for (i = 3; i < 12; i++) { 652 if (!(slots & (1 << i))) 653 continue; 654 for (cidx = 0; cidx < 4; cidx++) { 655 if (pcm->r[r].rslots[cidx] & (1 << i)) { 656 int reg = get_slot_reg(pcm, cidx, i, r); 657 snd_ac97_update_power(pcm->r[r].codec[cidx], 658 reg, 0); 659 } 660 } 661 } 662 #endif 663 664 bus = pcm->bus; 665 guard(spinlock_irq)(&pcm->bus->bus_lock); 666 for (i = 3; i < 12; i++) { 667 if (!(slots & (1 << i))) 668 continue; 669 for (cidx = 0; cidx < 4; cidx++) 670 bus->used_slots[pcm->stream][cidx] &= ~(1 << i); 671 } 672 pcm->aslots = 0; 673 pcm->cur_dbl = 0; 674 return 0; 675 } 676 677 EXPORT_SYMBOL(snd_ac97_pcm_close); 678 679 static int double_rate_hw_constraint_rate(struct snd_pcm_hw_params *params, 680 struct snd_pcm_hw_rule *rule) 681 { 682 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 683 if (channels->min > 2) { 684 static const struct snd_interval single_rates = { 685 .min = 1, 686 .max = 48000, 687 }; 688 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 689 return snd_interval_refine(rate, &single_rates); 690 } 691 return 0; 692 } 693 694 static int double_rate_hw_constraint_channels(struct snd_pcm_hw_params *params, 695 struct snd_pcm_hw_rule *rule) 696 { 697 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 698 if (rate->min > 48000) { 699 static const struct snd_interval double_rate_channels = { 700 .min = 2, 701 .max = 2, 702 }; 703 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 704 return snd_interval_refine(channels, &double_rate_channels); 705 } 706 return 0; 707 } 708 709 /** 710 * snd_ac97_pcm_double_rate_rules - set double rate constraints 711 * @runtime: the runtime of the ac97 front playback pcm 712 * 713 * Installs the hardware constraint rules to prevent using double rates and 714 * more than two channels at the same time. 715 * 716 * Return: Zero if successful, or a negative error code on failure. 717 */ 718 int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime) 719 { 720 int err; 721 722 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 723 double_rate_hw_constraint_rate, NULL, 724 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 725 if (err < 0) 726 return err; 727 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 728 double_rate_hw_constraint_channels, NULL, 729 SNDRV_PCM_HW_PARAM_RATE, -1); 730 return err; 731 } 732 733 EXPORT_SYMBOL(snd_ac97_pcm_double_rate_rules); 734