1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for Digigram pcxhr compatible soundcards 4 * 5 * low level interface with interrupt and message handling implementation 6 * 7 * Copyright (c) 2004 by Digigram <alsa@digigram.com> 8 */ 9 10 #include <linux/delay.h> 11 #include <linux/firmware.h> 12 #include <linux/interrupt.h> 13 #include <linux/pci.h> 14 #include <linux/io.h> 15 #include <sound/core.h> 16 #include "pcxhr.h" 17 #include "pcxhr_mixer.h" 18 #include "pcxhr_hwdep.h" 19 #include "pcxhr_core.h" 20 21 22 /* registers used on the PLX (port 1) */ 23 #define PCXHR_PLX_OFFSET_MIN 0x40 24 #define PCXHR_PLX_MBOX0 0x40 25 #define PCXHR_PLX_MBOX1 0x44 26 #define PCXHR_PLX_MBOX2 0x48 27 #define PCXHR_PLX_MBOX3 0x4C 28 #define PCXHR_PLX_MBOX4 0x50 29 #define PCXHR_PLX_MBOX5 0x54 30 #define PCXHR_PLX_MBOX6 0x58 31 #define PCXHR_PLX_MBOX7 0x5C 32 #define PCXHR_PLX_L2PCIDB 0x64 33 #define PCXHR_PLX_IRQCS 0x68 34 #define PCXHR_PLX_CHIPSC 0x6C 35 36 /* registers used on the DSP (port 2) */ 37 #define PCXHR_DSP_ICR 0x00 38 #define PCXHR_DSP_CVR 0x04 39 #define PCXHR_DSP_ISR 0x08 40 #define PCXHR_DSP_IVR 0x0C 41 #define PCXHR_DSP_RXH 0x14 42 #define PCXHR_DSP_TXH 0x14 43 #define PCXHR_DSP_RXM 0x18 44 #define PCXHR_DSP_TXM 0x18 45 #define PCXHR_DSP_RXL 0x1C 46 #define PCXHR_DSP_TXL 0x1C 47 #define PCXHR_DSP_RESET 0x20 48 #define PCXHR_DSP_OFFSET_MAX 0x20 49 50 /* access to the card */ 51 #define PCXHR_PLX 1 52 #define PCXHR_DSP 2 53 54 #if (PCXHR_DSP_OFFSET_MAX > PCXHR_PLX_OFFSET_MIN) 55 #error PCXHR_REG_TO_PORT(x) 56 #else 57 #define PCXHR_REG_TO_PORT(x) ((x)>PCXHR_DSP_OFFSET_MAX ? PCXHR_PLX : PCXHR_DSP) 58 #endif 59 #define PCXHR_INPB(mgr,x) inb((mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) 60 #define PCXHR_INPL(mgr,x) inl((mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) 61 #define PCXHR_OUTPB(mgr,x,data) outb((data), (mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) 62 #define PCXHR_OUTPL(mgr,x,data) outl((data), (mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) 63 /* attention : access the PCXHR_DSP_* registers with inb and outb only ! */ 64 65 /* params used with PCXHR_PLX_MBOX0 */ 66 #define PCXHR_MBOX0_HF5 (1 << 0) 67 #define PCXHR_MBOX0_HF4 (1 << 1) 68 #define PCXHR_MBOX0_BOOT_HERE (1 << 23) 69 /* params used with PCXHR_PLX_IRQCS */ 70 #define PCXHR_IRQCS_ENABLE_PCIIRQ (1 << 8) 71 #define PCXHR_IRQCS_ENABLE_PCIDB (1 << 9) 72 #define PCXHR_IRQCS_ACTIVE_PCIDB (1 << 13) 73 /* params used with PCXHR_PLX_CHIPSC */ 74 #define PCXHR_CHIPSC_INIT_VALUE 0x100D767E 75 #define PCXHR_CHIPSC_RESET_XILINX (1 << 16) 76 #define PCXHR_CHIPSC_GPI_USERI (1 << 17) 77 #define PCXHR_CHIPSC_DATA_CLK (1 << 24) 78 #define PCXHR_CHIPSC_DATA_IN (1 << 26) 79 80 /* params used with PCXHR_DSP_ICR */ 81 #define PCXHR_ICR_HI08_RREQ 0x01 82 #define PCXHR_ICR_HI08_TREQ 0x02 83 #define PCXHR_ICR_HI08_HDRQ 0x04 84 #define PCXHR_ICR_HI08_HF0 0x08 85 #define PCXHR_ICR_HI08_HF1 0x10 86 #define PCXHR_ICR_HI08_HLEND 0x20 87 #define PCXHR_ICR_HI08_INIT 0x80 88 /* params used with PCXHR_DSP_CVR */ 89 #define PCXHR_CVR_HI08_HC 0x80 90 /* params used with PCXHR_DSP_ISR */ 91 #define PCXHR_ISR_HI08_RXDF 0x01 92 #define PCXHR_ISR_HI08_TXDE 0x02 93 #define PCXHR_ISR_HI08_TRDY 0x04 94 #define PCXHR_ISR_HI08_ERR 0x08 95 #define PCXHR_ISR_HI08_CHK 0x10 96 #define PCXHR_ISR_HI08_HREQ 0x80 97 98 99 /* constants used for delay in msec */ 100 #define PCXHR_WAIT_DEFAULT 2 101 #define PCXHR_WAIT_IT 25 102 #define PCXHR_WAIT_IT_EXTRA 65 103 104 /* 105 * pcxhr_check_reg_bit - wait for the specified bit is set/reset on a register 106 * @reg: register to check 107 * @mask: bit mask 108 * @bit: resultant bit to be checked 109 * @time: time-out of loop in msec 110 * 111 * returns zero if a bit matches, or a negative error code. 112 */ 113 static int pcxhr_check_reg_bit(struct pcxhr_mgr *mgr, unsigned int reg, 114 unsigned char mask, unsigned char bit, int time, 115 unsigned char* read) 116 { 117 int i = 0; 118 unsigned long end_time = jiffies + (time * HZ + 999) / 1000; 119 do { 120 *read = PCXHR_INPB(mgr, reg); 121 if ((*read & mask) == bit) { 122 if (i > 100) 123 dev_dbg(&mgr->pci->dev, 124 "ATTENTION! check_reg(%x) loopcount=%d\n", 125 reg, i); 126 return 0; 127 } 128 i++; 129 } while (time_after_eq(end_time, jiffies)); 130 dev_err(&mgr->pci->dev, 131 "pcxhr_check_reg_bit: timeout, reg=%x, mask=0x%x, val=%x\n", 132 reg, mask, *read); 133 return -EIO; 134 } 135 136 /* constants used with pcxhr_check_reg_bit() */ 137 #define PCXHR_TIMEOUT_DSP 200 138 139 140 #define PCXHR_MASK_EXTRA_INFO 0x0000FE 141 #define PCXHR_MASK_IT_HF0 0x000100 142 #define PCXHR_MASK_IT_HF1 0x000200 143 #define PCXHR_MASK_IT_NO_HF0_HF1 0x000400 144 #define PCXHR_MASK_IT_MANAGE_HF5 0x000800 145 #define PCXHR_MASK_IT_WAIT 0x010000 146 #define PCXHR_MASK_IT_WAIT_EXTRA 0x020000 147 148 #define PCXHR_IT_SEND_BYTE_XILINX (0x0000003C | PCXHR_MASK_IT_HF0) 149 #define PCXHR_IT_TEST_XILINX (0x0000003C | PCXHR_MASK_IT_HF1 | \ 150 PCXHR_MASK_IT_MANAGE_HF5) 151 #define PCXHR_IT_DOWNLOAD_BOOT (0x0000000C | PCXHR_MASK_IT_HF1 | \ 152 PCXHR_MASK_IT_MANAGE_HF5 | \ 153 PCXHR_MASK_IT_WAIT) 154 #define PCXHR_IT_RESET_BOARD_FUNC (0x0000000C | PCXHR_MASK_IT_HF0 | \ 155 PCXHR_MASK_IT_MANAGE_HF5 | \ 156 PCXHR_MASK_IT_WAIT_EXTRA) 157 #define PCXHR_IT_DOWNLOAD_DSP (0x0000000C | \ 158 PCXHR_MASK_IT_MANAGE_HF5 | \ 159 PCXHR_MASK_IT_WAIT) 160 #define PCXHR_IT_DEBUG (0x0000005A | PCXHR_MASK_IT_NO_HF0_HF1) 161 #define PCXHR_IT_RESET_SEMAPHORE (0x0000005C | PCXHR_MASK_IT_NO_HF0_HF1) 162 #define PCXHR_IT_MESSAGE (0x00000074 | PCXHR_MASK_IT_NO_HF0_HF1) 163 #define PCXHR_IT_RESET_CHK (0x00000076 | PCXHR_MASK_IT_NO_HF0_HF1) 164 #define PCXHR_IT_UPDATE_RBUFFER (0x00000078 | PCXHR_MASK_IT_NO_HF0_HF1) 165 166 static int pcxhr_send_it_dsp(struct pcxhr_mgr *mgr, 167 unsigned int itdsp, int atomic) 168 { 169 int err; 170 unsigned char reg; 171 172 if (itdsp & PCXHR_MASK_IT_MANAGE_HF5) { 173 /* clear hf5 bit */ 174 PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, 175 PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & 176 ~PCXHR_MBOX0_HF5); 177 } 178 if ((itdsp & PCXHR_MASK_IT_NO_HF0_HF1) == 0) { 179 reg = (PCXHR_ICR_HI08_RREQ | 180 PCXHR_ICR_HI08_TREQ | 181 PCXHR_ICR_HI08_HDRQ); 182 if (itdsp & PCXHR_MASK_IT_HF0) 183 reg |= PCXHR_ICR_HI08_HF0; 184 if (itdsp & PCXHR_MASK_IT_HF1) 185 reg |= PCXHR_ICR_HI08_HF1; 186 PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); 187 } 188 reg = (unsigned char)(((itdsp & PCXHR_MASK_EXTRA_INFO) >> 1) | 189 PCXHR_CVR_HI08_HC); 190 PCXHR_OUTPB(mgr, PCXHR_DSP_CVR, reg); 191 if (itdsp & PCXHR_MASK_IT_WAIT) { 192 if (atomic) 193 mdelay(PCXHR_WAIT_IT); 194 else 195 msleep(PCXHR_WAIT_IT); 196 } 197 if (itdsp & PCXHR_MASK_IT_WAIT_EXTRA) { 198 if (atomic) 199 mdelay(PCXHR_WAIT_IT_EXTRA); 200 else 201 msleep(PCXHR_WAIT_IT); 202 } 203 /* wait for CVR_HI08_HC == 0 */ 204 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_CVR, PCXHR_CVR_HI08_HC, 0, 205 PCXHR_TIMEOUT_DSP, ®); 206 if (err) { 207 dev_err(&mgr->pci->dev, "pcxhr_send_it_dsp : TIMEOUT CVR\n"); 208 return err; 209 } 210 if (itdsp & PCXHR_MASK_IT_MANAGE_HF5) { 211 /* wait for hf5 bit */ 212 err = pcxhr_check_reg_bit(mgr, PCXHR_PLX_MBOX0, 213 PCXHR_MBOX0_HF5, 214 PCXHR_MBOX0_HF5, 215 PCXHR_TIMEOUT_DSP, 216 ®); 217 if (err) { 218 dev_err(&mgr->pci->dev, 219 "pcxhr_send_it_dsp : TIMEOUT HF5\n"); 220 return err; 221 } 222 } 223 return 0; /* retry not handled here */ 224 } 225 226 void pcxhr_reset_xilinx_com(struct pcxhr_mgr *mgr) 227 { 228 /* reset second xilinx */ 229 PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, 230 PCXHR_CHIPSC_INIT_VALUE & ~PCXHR_CHIPSC_RESET_XILINX); 231 } 232 233 static void pcxhr_enable_irq(struct pcxhr_mgr *mgr, int enable) 234 { 235 unsigned int reg = PCXHR_INPL(mgr, PCXHR_PLX_IRQCS); 236 /* enable/disable interrupts */ 237 if (enable) 238 reg |= (PCXHR_IRQCS_ENABLE_PCIIRQ | PCXHR_IRQCS_ENABLE_PCIDB); 239 else 240 reg &= ~(PCXHR_IRQCS_ENABLE_PCIIRQ | PCXHR_IRQCS_ENABLE_PCIDB); 241 PCXHR_OUTPL(mgr, PCXHR_PLX_IRQCS, reg); 242 } 243 244 void pcxhr_reset_dsp(struct pcxhr_mgr *mgr) 245 { 246 /* disable interrupts */ 247 pcxhr_enable_irq(mgr, 0); 248 249 /* let's reset the DSP */ 250 PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, 0); 251 msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ 252 PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, 3); 253 msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ 254 255 /* reset mailbox */ 256 PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, 0); 257 } 258 259 void pcxhr_enable_dsp(struct pcxhr_mgr *mgr) 260 { 261 /* enable interrupts */ 262 pcxhr_enable_irq(mgr, 1); 263 } 264 265 /* 266 * load the xilinx image 267 */ 268 int pcxhr_load_xilinx_binary(struct pcxhr_mgr *mgr, 269 const struct firmware *xilinx, int second) 270 { 271 unsigned int i; 272 unsigned int chipsc; 273 unsigned char data; 274 unsigned char mask; 275 const unsigned char *image; 276 277 /* test first xilinx */ 278 chipsc = PCXHR_INPL(mgr, PCXHR_PLX_CHIPSC); 279 /* REV01 cards do not support the PCXHR_CHIPSC_GPI_USERI bit anymore */ 280 /* this bit will always be 1; 281 * no possibility to test presence of first xilinx 282 */ 283 if(second) { 284 if ((chipsc & PCXHR_CHIPSC_GPI_USERI) == 0) { 285 dev_err(&mgr->pci->dev, "error loading first xilinx\n"); 286 return -EINVAL; 287 } 288 /* activate second xilinx */ 289 chipsc |= PCXHR_CHIPSC_RESET_XILINX; 290 PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); 291 msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ 292 } 293 image = xilinx->data; 294 for (i = 0; i < xilinx->size; i++, image++) { 295 data = *image; 296 mask = 0x80; 297 while (mask) { 298 chipsc &= ~(PCXHR_CHIPSC_DATA_CLK | 299 PCXHR_CHIPSC_DATA_IN); 300 if (data & mask) 301 chipsc |= PCXHR_CHIPSC_DATA_IN; 302 PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); 303 chipsc |= PCXHR_CHIPSC_DATA_CLK; 304 PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); 305 mask >>= 1; 306 } 307 /* don't take too much time in this loop... */ 308 cond_resched(); 309 } 310 chipsc &= ~(PCXHR_CHIPSC_DATA_CLK | PCXHR_CHIPSC_DATA_IN); 311 PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); 312 /* wait 2 msec (time to boot the xilinx before any access) */ 313 msleep( PCXHR_WAIT_DEFAULT ); 314 return 0; 315 } 316 317 /* 318 * send an executable file to the DSP 319 */ 320 static int pcxhr_download_dsp(struct pcxhr_mgr *mgr, const struct firmware *dsp) 321 { 322 int err; 323 unsigned int i; 324 unsigned int len; 325 const unsigned char *data; 326 unsigned char dummy; 327 /* check the length of boot image */ 328 if (dsp->size <= 0) 329 return -EINVAL; 330 if (dsp->size % 3) 331 return -EINVAL; 332 if (snd_BUG_ON(!dsp->data)) 333 return -EINVAL; 334 /* transfert data buffer from PC to DSP */ 335 for (i = 0; i < dsp->size; i += 3) { 336 data = dsp->data + i; 337 if (i == 0) { 338 /* test data header consistency */ 339 len = (unsigned int)((data[0]<<16) + 340 (data[1]<<8) + 341 data[2]); 342 if (len && (dsp->size != (len + 2) * 3)) 343 return -EINVAL; 344 } 345 /* wait DSP ready for new transfer */ 346 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 347 PCXHR_ISR_HI08_TRDY, 348 PCXHR_ISR_HI08_TRDY, 349 PCXHR_TIMEOUT_DSP, &dummy); 350 if (err) { 351 dev_err(&mgr->pci->dev, 352 "dsp loading error at position %d\n", i); 353 return err; 354 } 355 /* send host data */ 356 PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, data[0]); 357 PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, data[1]); 358 PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, data[2]); 359 360 /* don't take too much time in this loop... */ 361 cond_resched(); 362 } 363 /* give some time to boot the DSP */ 364 msleep(PCXHR_WAIT_DEFAULT); 365 return 0; 366 } 367 368 /* 369 * load the eeprom image 370 */ 371 int pcxhr_load_eeprom_binary(struct pcxhr_mgr *mgr, 372 const struct firmware *eeprom) 373 { 374 int err; 375 unsigned char reg; 376 377 /* init value of the ICR register */ 378 reg = PCXHR_ICR_HI08_RREQ | PCXHR_ICR_HI08_TREQ | PCXHR_ICR_HI08_HDRQ; 379 if (PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & PCXHR_MBOX0_BOOT_HERE) { 380 /* no need to load the eeprom binary, 381 * but init the HI08 interface 382 */ 383 PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg | PCXHR_ICR_HI08_INIT); 384 msleep(PCXHR_WAIT_DEFAULT); 385 PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); 386 msleep(PCXHR_WAIT_DEFAULT); 387 dev_dbg(&mgr->pci->dev, "no need to load eeprom boot\n"); 388 return 0; 389 } 390 PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); 391 392 err = pcxhr_download_dsp(mgr, eeprom); 393 if (err) 394 return err; 395 /* wait for chk bit */ 396 return pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, 397 PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); 398 } 399 400 /* 401 * load the boot image 402 */ 403 int pcxhr_load_boot_binary(struct pcxhr_mgr *mgr, const struct firmware *boot) 404 { 405 int err; 406 unsigned int physaddr = mgr->hostport.addr; 407 unsigned char dummy; 408 409 /* send the hostport address to the DSP (only the upper 24 bit !) */ 410 if (snd_BUG_ON(physaddr & 0xff)) 411 return -EINVAL; 412 PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX1, (physaddr >> 8)); 413 414 err = pcxhr_send_it_dsp(mgr, PCXHR_IT_DOWNLOAD_BOOT, 0); 415 if (err) 416 return err; 417 /* clear hf5 bit */ 418 PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, 419 PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & ~PCXHR_MBOX0_HF5); 420 421 err = pcxhr_download_dsp(mgr, boot); 422 if (err) 423 return err; 424 /* wait for hf5 bit */ 425 return pcxhr_check_reg_bit(mgr, PCXHR_PLX_MBOX0, PCXHR_MBOX0_HF5, 426 PCXHR_MBOX0_HF5, PCXHR_TIMEOUT_DSP, &dummy); 427 } 428 429 /* 430 * load the final dsp image 431 */ 432 int pcxhr_load_dsp_binary(struct pcxhr_mgr *mgr, const struct firmware *dsp) 433 { 434 int err; 435 unsigned char dummy; 436 err = pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_BOARD_FUNC, 0); 437 if (err) 438 return err; 439 err = pcxhr_send_it_dsp(mgr, PCXHR_IT_DOWNLOAD_DSP, 0); 440 if (err) 441 return err; 442 err = pcxhr_download_dsp(mgr, dsp); 443 if (err) 444 return err; 445 /* wait for chk bit */ 446 return pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 447 PCXHR_ISR_HI08_CHK, 448 PCXHR_ISR_HI08_CHK, 449 PCXHR_TIMEOUT_DSP, &dummy); 450 } 451 452 453 struct pcxhr_cmd_info { 454 u32 opcode; /* command word */ 455 u16 st_length; /* status length */ 456 u16 st_type; /* status type (RMH_SSIZE_XXX) */ 457 }; 458 459 /* RMH status type */ 460 enum { 461 RMH_SSIZE_FIXED = 0, /* status size fix (st_length = 0..x) */ 462 RMH_SSIZE_ARG = 1, /* status size given in the LSB byte */ 463 RMH_SSIZE_MASK = 2, /* status size given in bitmask */ 464 }; 465 466 /* 467 * Array of DSP commands 468 */ 469 static const struct pcxhr_cmd_info pcxhr_dsp_cmds[] = { 470 [CMD_VERSION] = { 0x010000, 1, RMH_SSIZE_FIXED }, 471 [CMD_SUPPORTED] = { 0x020000, 4, RMH_SSIZE_FIXED }, 472 [CMD_TEST_IT] = { 0x040000, 1, RMH_SSIZE_FIXED }, 473 [CMD_SEND_IRQA] = { 0x070001, 0, RMH_SSIZE_FIXED }, 474 [CMD_ACCESS_IO_WRITE] = { 0x090000, 1, RMH_SSIZE_ARG }, 475 [CMD_ACCESS_IO_READ] = { 0x094000, 1, RMH_SSIZE_ARG }, 476 [CMD_ASYNC] = { 0x0a0000, 1, RMH_SSIZE_ARG }, 477 [CMD_MODIFY_CLOCK] = { 0x0d0000, 0, RMH_SSIZE_FIXED }, 478 [CMD_RESYNC_AUDIO_INPUTS] = { 0x0e0000, 0, RMH_SSIZE_FIXED }, 479 [CMD_GET_DSP_RESOURCES] = { 0x100000, 4, RMH_SSIZE_FIXED }, 480 [CMD_SET_TIMER_INTERRUPT] = { 0x110000, 0, RMH_SSIZE_FIXED }, 481 [CMD_RES_PIPE] = { 0x400000, 0, RMH_SSIZE_FIXED }, 482 [CMD_FREE_PIPE] = { 0x410000, 0, RMH_SSIZE_FIXED }, 483 [CMD_CONF_PIPE] = { 0x422101, 0, RMH_SSIZE_FIXED }, 484 [CMD_STOP_PIPE] = { 0x470004, 0, RMH_SSIZE_FIXED }, 485 [CMD_PIPE_SAMPLE_COUNT] = { 0x49a000, 2, RMH_SSIZE_FIXED }, 486 [CMD_CAN_START_PIPE] = { 0x4b0000, 1, RMH_SSIZE_FIXED }, 487 [CMD_START_STREAM] = { 0x802000, 0, RMH_SSIZE_FIXED }, 488 [CMD_STREAM_OUT_LEVEL_ADJUST] = { 0x822000, 0, RMH_SSIZE_FIXED }, 489 [CMD_STOP_STREAM] = { 0x832000, 0, RMH_SSIZE_FIXED }, 490 [CMD_UPDATE_R_BUFFERS] = { 0x840000, 0, RMH_SSIZE_FIXED }, 491 [CMD_FORMAT_STREAM_OUT] = { 0x860000, 0, RMH_SSIZE_FIXED }, 492 [CMD_FORMAT_STREAM_IN] = { 0x870000, 0, RMH_SSIZE_FIXED }, 493 [CMD_STREAM_SAMPLE_COUNT] = { 0x902000, 2, RMH_SSIZE_FIXED }, 494 [CMD_AUDIO_LEVEL_ADJUST] = { 0xc22000, 0, RMH_SSIZE_FIXED }, 495 [CMD_GET_TIME_CODE] = { 0x060000, 5, RMH_SSIZE_FIXED }, 496 [CMD_MANAGE_SIGNAL] = { 0x0f0000, 0, RMH_SSIZE_FIXED }, 497 }; 498 499 #ifdef CONFIG_SND_DEBUG_VERBOSE 500 static const char * const cmd_names[] = { 501 [CMD_VERSION] = "CMD_VERSION", 502 [CMD_SUPPORTED] = "CMD_SUPPORTED", 503 [CMD_TEST_IT] = "CMD_TEST_IT", 504 [CMD_SEND_IRQA] = "CMD_SEND_IRQA", 505 [CMD_ACCESS_IO_WRITE] = "CMD_ACCESS_IO_WRITE", 506 [CMD_ACCESS_IO_READ] = "CMD_ACCESS_IO_READ", 507 [CMD_ASYNC] = "CMD_ASYNC", 508 [CMD_MODIFY_CLOCK] = "CMD_MODIFY_CLOCK", 509 [CMD_RESYNC_AUDIO_INPUTS] = "CMD_RESYNC_AUDIO_INPUTS", 510 [CMD_GET_DSP_RESOURCES] = "CMD_GET_DSP_RESOURCES", 511 [CMD_SET_TIMER_INTERRUPT] = "CMD_SET_TIMER_INTERRUPT", 512 [CMD_RES_PIPE] = "CMD_RES_PIPE", 513 [CMD_FREE_PIPE] = "CMD_FREE_PIPE", 514 [CMD_CONF_PIPE] = "CMD_CONF_PIPE", 515 [CMD_STOP_PIPE] = "CMD_STOP_PIPE", 516 [CMD_PIPE_SAMPLE_COUNT] = "CMD_PIPE_SAMPLE_COUNT", 517 [CMD_CAN_START_PIPE] = "CMD_CAN_START_PIPE", 518 [CMD_START_STREAM] = "CMD_START_STREAM", 519 [CMD_STREAM_OUT_LEVEL_ADJUST] = "CMD_STREAM_OUT_LEVEL_ADJUST", 520 [CMD_STOP_STREAM] = "CMD_STOP_STREAM", 521 [CMD_UPDATE_R_BUFFERS] = "CMD_UPDATE_R_BUFFERS", 522 [CMD_FORMAT_STREAM_OUT] = "CMD_FORMAT_STREAM_OUT", 523 [CMD_FORMAT_STREAM_IN] = "CMD_FORMAT_STREAM_IN", 524 [CMD_STREAM_SAMPLE_COUNT] = "CMD_STREAM_SAMPLE_COUNT", 525 [CMD_AUDIO_LEVEL_ADJUST] = "CMD_AUDIO_LEVEL_ADJUST", 526 [CMD_GET_TIME_CODE] = "CMD_GET_TIME_CODE", 527 [CMD_MANAGE_SIGNAL] = "CMD_MANAGE_SIGNAL", 528 }; 529 #endif 530 531 532 static int pcxhr_read_rmh_status(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) 533 { 534 int err; 535 int i; 536 u32 data; 537 u32 size_mask; 538 unsigned char reg; 539 int max_stat_len; 540 541 if (rmh->stat_len < PCXHR_SIZE_MAX_STATUS) 542 max_stat_len = PCXHR_SIZE_MAX_STATUS; 543 else max_stat_len = rmh->stat_len; 544 545 for (i = 0; i < rmh->stat_len; i++) { 546 /* wait for receiver full */ 547 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 548 PCXHR_ISR_HI08_RXDF, 549 PCXHR_ISR_HI08_RXDF, 550 PCXHR_TIMEOUT_DSP, ®); 551 if (err) { 552 dev_err(&mgr->pci->dev, 553 "ERROR RMH stat: ISR:RXDF=1 (ISR = %x; i=%d )\n", 554 reg, i); 555 return err; 556 } 557 /* read data */ 558 data = PCXHR_INPB(mgr, PCXHR_DSP_TXH) << 16; 559 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXM) << 8; 560 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXL); 561 562 /* need to update rmh->stat_len on the fly ?? */ 563 if (!i) { 564 if (rmh->dsp_stat != RMH_SSIZE_FIXED) { 565 if (rmh->dsp_stat == RMH_SSIZE_ARG) { 566 rmh->stat_len = (data & 0x0000ff) + 1; 567 data &= 0xffff00; 568 } else { 569 /* rmh->dsp_stat == RMH_SSIZE_MASK */ 570 rmh->stat_len = 1; 571 size_mask = data; 572 while (size_mask) { 573 if (size_mask & 1) 574 rmh->stat_len++; 575 size_mask >>= 1; 576 } 577 } 578 } 579 } 580 #ifdef CONFIG_SND_DEBUG_VERBOSE 581 if (rmh->cmd_idx < CMD_LAST_INDEX) 582 dev_dbg(&mgr->pci->dev, " stat[%d]=%x\n", i, data); 583 #endif 584 if (i < max_stat_len) 585 rmh->stat[i] = data; 586 } 587 if (rmh->stat_len > max_stat_len) { 588 dev_dbg(&mgr->pci->dev, "PCXHR : rmh->stat_len=%x too big\n", 589 rmh->stat_len); 590 rmh->stat_len = max_stat_len; 591 } 592 return 0; 593 } 594 595 static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) 596 { 597 int err; 598 int i; 599 u32 data; 600 unsigned char reg; 601 602 if (snd_BUG_ON(rmh->cmd_len >= PCXHR_SIZE_MAX_CMD)) 603 return -EINVAL; 604 err = pcxhr_send_it_dsp(mgr, PCXHR_IT_MESSAGE, 1); 605 if (err) { 606 dev_err(&mgr->pci->dev, 607 "pcxhr_send_message : ED_DSP_CRASHED\n"); 608 return err; 609 } 610 /* wait for chk bit */ 611 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, 612 PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); 613 if (err) 614 return err; 615 /* reset irq chk */ 616 err = pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_CHK, 1); 617 if (err) 618 return err; 619 /* wait for chk bit == 0*/ 620 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, 0, 621 PCXHR_TIMEOUT_DSP, ®); 622 if (err) 623 return err; 624 625 data = rmh->cmd[0]; 626 627 if (rmh->cmd_len > 1) 628 data |= 0x008000; /* MASK_MORE_THAN_1_WORD_COMMAND */ 629 else 630 data &= 0xff7fff; /* MASK_1_WORD_COMMAND */ 631 #ifdef CONFIG_SND_DEBUG_VERBOSE 632 if (rmh->cmd_idx < CMD_LAST_INDEX) 633 dev_dbg(&mgr->pci->dev, "MSG cmd[0]=%x (%s)\n", 634 data, cmd_names[rmh->cmd_idx]); 635 #endif 636 637 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_TRDY, 638 PCXHR_ISR_HI08_TRDY, PCXHR_TIMEOUT_DSP, ®); 639 if (err) 640 return err; 641 PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); 642 PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); 643 PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); 644 645 if (rmh->cmd_len > 1) { 646 /* send length */ 647 data = rmh->cmd_len - 1; 648 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 649 PCXHR_ISR_HI08_TRDY, 650 PCXHR_ISR_HI08_TRDY, 651 PCXHR_TIMEOUT_DSP, ®); 652 if (err) 653 return err; 654 PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); 655 PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); 656 PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); 657 658 for (i=1; i < rmh->cmd_len; i++) { 659 /* send other words */ 660 data = rmh->cmd[i]; 661 #ifdef CONFIG_SND_DEBUG_VERBOSE 662 if (rmh->cmd_idx < CMD_LAST_INDEX) 663 dev_dbg(&mgr->pci->dev, 664 " cmd[%d]=%x\n", i, data); 665 #endif 666 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 667 PCXHR_ISR_HI08_TRDY, 668 PCXHR_ISR_HI08_TRDY, 669 PCXHR_TIMEOUT_DSP, ®); 670 if (err) 671 return err; 672 PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); 673 PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); 674 PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); 675 } 676 } 677 /* wait for chk bit */ 678 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, 679 PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); 680 if (err) 681 return err; 682 /* test status ISR */ 683 if (reg & PCXHR_ISR_HI08_ERR) { 684 /* ERROR, wait for receiver full */ 685 err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, 686 PCXHR_ISR_HI08_RXDF, 687 PCXHR_ISR_HI08_RXDF, 688 PCXHR_TIMEOUT_DSP, ®); 689 if (err) { 690 dev_err(&mgr->pci->dev, 691 "ERROR RMH: ISR:RXDF=1 (ISR = %x)\n", reg); 692 return err; 693 } 694 /* read error code */ 695 data = PCXHR_INPB(mgr, PCXHR_DSP_TXH) << 16; 696 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXM) << 8; 697 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXL); 698 dev_err(&mgr->pci->dev, "ERROR RMH(%d): 0x%x\n", 699 rmh->cmd_idx, data); 700 err = -EINVAL; 701 } else { 702 /* read the response data */ 703 err = pcxhr_read_rmh_status(mgr, rmh); 704 } 705 /* reset semaphore */ 706 if (pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_SEMAPHORE, 1) < 0) 707 return -EIO; 708 return err; 709 } 710 711 712 /** 713 * pcxhr_init_rmh - initialize the RMH instance 714 * @rmh: the rmh pointer to be initialized 715 * @cmd: the rmh command to be set 716 */ 717 void pcxhr_init_rmh(struct pcxhr_rmh *rmh, int cmd) 718 { 719 if (snd_BUG_ON(cmd >= CMD_LAST_INDEX)) 720 return; 721 rmh->cmd[0] = pcxhr_dsp_cmds[cmd].opcode; 722 rmh->cmd_len = 1; 723 rmh->stat_len = pcxhr_dsp_cmds[cmd].st_length; 724 rmh->dsp_stat = pcxhr_dsp_cmds[cmd].st_type; 725 rmh->cmd_idx = cmd; 726 } 727 728 729 void pcxhr_set_pipe_cmd_params(struct pcxhr_rmh *rmh, int capture, 730 unsigned int param1, unsigned int param2, 731 unsigned int param3) 732 { 733 snd_BUG_ON(param1 > MASK_FIRST_FIELD); 734 if (capture) 735 rmh->cmd[0] |= 0x800; /* COMMAND_RECORD_MASK */ 736 if (param1) 737 rmh->cmd[0] |= (param1 << FIELD_SIZE); 738 if (param2) { 739 snd_BUG_ON(param2 > MASK_FIRST_FIELD); 740 rmh->cmd[0] |= param2; 741 } 742 if(param3) { 743 snd_BUG_ON(param3 > MASK_DSP_WORD); 744 rmh->cmd[1] = param3; 745 rmh->cmd_len = 2; 746 } 747 } 748 749 /* 750 * pcxhr_send_msg - send a DSP message with spinlock 751 * @rmh: the rmh record to send and receive 752 * 753 * returns 0 if successful, or a negative error code. 754 */ 755 int pcxhr_send_msg(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) 756 { 757 guard(mutex)(&mgr->msg_lock); 758 return pcxhr_send_msg_nolock(mgr, rmh); 759 } 760 761 static inline int pcxhr_pipes_running(struct pcxhr_mgr *mgr) 762 { 763 int start_mask = PCXHR_INPL(mgr, PCXHR_PLX_MBOX2); 764 /* least segnificant 12 bits are the pipe states 765 * for the playback audios 766 * next 12 bits are the pipe states for the capture audios 767 * (PCXHR_PIPE_STATE_CAPTURE_OFFSET) 768 */ 769 start_mask &= 0xffffff; 770 dev_dbg(&mgr->pci->dev, "CMD_PIPE_STATE MBOX2=0x%06x\n", start_mask); 771 return start_mask; 772 } 773 774 #define PCXHR_PIPE_STATE_CAPTURE_OFFSET 12 775 #define MAX_WAIT_FOR_DSP 20 776 777 static int pcxhr_prepair_pipe_start(struct pcxhr_mgr *mgr, 778 int audio_mask, int *retry) 779 { 780 struct pcxhr_rmh rmh; 781 int err; 782 int audio = 0; 783 784 *retry = 0; 785 while (audio_mask) { 786 if (audio_mask & 1) { 787 pcxhr_init_rmh(&rmh, CMD_CAN_START_PIPE); 788 if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) { 789 /* can start playback pipe */ 790 pcxhr_set_pipe_cmd_params(&rmh, 0, audio, 0, 0); 791 } else { 792 /* can start capture pipe */ 793 pcxhr_set_pipe_cmd_params(&rmh, 1, audio - 794 PCXHR_PIPE_STATE_CAPTURE_OFFSET, 795 0, 0); 796 } 797 err = pcxhr_send_msg(mgr, &rmh); 798 if (err) { 799 dev_err(&mgr->pci->dev, 800 "error pipe start " 801 "(CMD_CAN_START_PIPE) err=%x!\n", 802 err); 803 return err; 804 } 805 /* if the pipe couldn't be prepaired for start, 806 * retry it later 807 */ 808 if (rmh.stat[0] == 0) 809 *retry |= (1<<audio); 810 } 811 audio_mask>>=1; 812 audio++; 813 } 814 return 0; 815 } 816 817 static int pcxhr_stop_pipes(struct pcxhr_mgr *mgr, int audio_mask) 818 { 819 struct pcxhr_rmh rmh; 820 int err; 821 int audio = 0; 822 823 while (audio_mask) { 824 if (audio_mask & 1) { 825 pcxhr_init_rmh(&rmh, CMD_STOP_PIPE); 826 if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) { 827 /* stop playback pipe */ 828 pcxhr_set_pipe_cmd_params(&rmh, 0, audio, 0, 0); 829 } else { 830 /* stop capture pipe */ 831 pcxhr_set_pipe_cmd_params(&rmh, 1, audio - 832 PCXHR_PIPE_STATE_CAPTURE_OFFSET, 833 0, 0); 834 } 835 err = pcxhr_send_msg(mgr, &rmh); 836 if (err) { 837 dev_err(&mgr->pci->dev, 838 "error pipe stop " 839 "(CMD_STOP_PIPE) err=%x!\n", err); 840 return err; 841 } 842 } 843 audio_mask>>=1; 844 audio++; 845 } 846 return 0; 847 } 848 849 static int pcxhr_toggle_pipes(struct pcxhr_mgr *mgr, int audio_mask) 850 { 851 struct pcxhr_rmh rmh; 852 int err; 853 int audio = 0; 854 855 while (audio_mask) { 856 if (audio_mask & 1) { 857 pcxhr_init_rmh(&rmh, CMD_CONF_PIPE); 858 if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) 859 pcxhr_set_pipe_cmd_params(&rmh, 0, 0, 0, 860 1 << audio); 861 else 862 pcxhr_set_pipe_cmd_params(&rmh, 1, 0, 0, 863 1 << (audio - PCXHR_PIPE_STATE_CAPTURE_OFFSET)); 864 err = pcxhr_send_msg(mgr, &rmh); 865 if (err) { 866 dev_err(&mgr->pci->dev, 867 "error pipe start " 868 "(CMD_CONF_PIPE) err=%x!\n", err); 869 return err; 870 } 871 } 872 audio_mask>>=1; 873 audio++; 874 } 875 /* now fire the interrupt on the card */ 876 pcxhr_init_rmh(&rmh, CMD_SEND_IRQA); 877 err = pcxhr_send_msg(mgr, &rmh); 878 if (err) { 879 dev_err(&mgr->pci->dev, 880 "error pipe start (CMD_SEND_IRQA) err=%x!\n", 881 err); 882 return err; 883 } 884 return 0; 885 } 886 887 888 889 int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask, 890 int capture_mask, int start) 891 { 892 int state, i, err; 893 int audio_mask; 894 895 #ifdef CONFIG_SND_DEBUG_VERBOSE 896 ktime_t start_time, stop_time, diff_time; 897 898 start_time = ktime_get(); 899 #endif 900 audio_mask = (playback_mask | 901 (capture_mask << PCXHR_PIPE_STATE_CAPTURE_OFFSET)); 902 /* current pipe state (playback + record) */ 903 state = pcxhr_pipes_running(mgr); 904 dev_dbg(&mgr->pci->dev, 905 "pcxhr_set_pipe_state %s (mask %x current %x)\n", 906 start ? "START" : "STOP", audio_mask, state); 907 if (start) { 908 /* start only pipes that are not yet started */ 909 audio_mask &= ~state; 910 state = audio_mask; 911 for (i = 0; i < MAX_WAIT_FOR_DSP; i++) { 912 err = pcxhr_prepair_pipe_start(mgr, state, &state); 913 if (err) 914 return err; 915 if (state == 0) 916 break; /* success, all pipes prepaired */ 917 mdelay(1); /* wait 1 millisecond and retry */ 918 } 919 } else { 920 audio_mask &= state; /* stop only pipes that are started */ 921 } 922 if (audio_mask == 0) 923 return 0; 924 925 err = pcxhr_toggle_pipes(mgr, audio_mask); 926 if (err) 927 return err; 928 929 i = 0; 930 while (1) { 931 state = pcxhr_pipes_running(mgr); 932 /* have all pipes the new state ? */ 933 if ((state & audio_mask) == (start ? audio_mask : 0)) 934 break; 935 if (++i >= MAX_WAIT_FOR_DSP * 100) { 936 dev_err(&mgr->pci->dev, "error pipe start/stop\n"); 937 return -EBUSY; 938 } 939 udelay(10); /* wait 10 microseconds */ 940 } 941 if (!start) { 942 err = pcxhr_stop_pipes(mgr, audio_mask); 943 if (err) 944 return err; 945 } 946 #ifdef CONFIG_SND_DEBUG_VERBOSE 947 stop_time = ktime_get(); 948 diff_time = ktime_sub(stop_time, start_time); 949 dev_dbg(&mgr->pci->dev, "***SET PIPE STATE*** TIME = %ld (err = %x)\n", 950 (long)(ktime_to_ns(diff_time)), err); 951 #endif 952 return 0; 953 } 954 955 int pcxhr_write_io_num_reg_cont(struct pcxhr_mgr *mgr, unsigned int mask, 956 unsigned int value, int *changed) 957 { 958 struct pcxhr_rmh rmh; 959 int err; 960 961 guard(mutex)(&mgr->msg_lock); 962 if ((mgr->io_num_reg_cont & mask) == value) { 963 dev_dbg(&mgr->pci->dev, 964 "IO_NUM_REG_CONT mask %x already is set to %x\n", 965 mask, value); 966 if (changed) 967 *changed = 0; 968 return 0; /* already programmed */ 969 } 970 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); 971 rmh.cmd[0] |= IO_NUM_REG_CONT; 972 rmh.cmd[1] = mask; 973 rmh.cmd[2] = value; 974 rmh.cmd_len = 3; 975 err = pcxhr_send_msg_nolock(mgr, &rmh); 976 if (err == 0) { 977 mgr->io_num_reg_cont &= ~mask; 978 mgr->io_num_reg_cont |= value; 979 if (changed) 980 *changed = 1; 981 } 982 return err; 983 } 984 985 #define PCXHR_IRQ_TIMER 0x000300 986 #define PCXHR_IRQ_FREQ_CHANGE 0x000800 987 #define PCXHR_IRQ_TIME_CODE 0x001000 988 #define PCXHR_IRQ_NOTIFY 0x002000 989 #define PCXHR_IRQ_ASYNC 0x008000 990 #define PCXHR_IRQ_MASK 0x00bb00 991 #define PCXHR_FATAL_DSP_ERR 0xff0000 992 993 enum pcxhr_async_err_src { 994 PCXHR_ERR_PIPE, 995 PCXHR_ERR_STREAM, 996 PCXHR_ERR_AUDIO 997 }; 998 999 static int pcxhr_handle_async_err(struct pcxhr_mgr *mgr, u32 err, 1000 enum pcxhr_async_err_src err_src, int pipe, 1001 int is_capture) 1002 { 1003 static const char * const err_src_name[] = { 1004 [PCXHR_ERR_PIPE] = "Pipe", 1005 [PCXHR_ERR_STREAM] = "Stream", 1006 [PCXHR_ERR_AUDIO] = "Audio" 1007 }; 1008 1009 if (err & 0xfff) 1010 err &= 0xfff; 1011 else 1012 err = ((err >> 12) & 0xfff); 1013 if (!err) 1014 return 0; 1015 dev_dbg(&mgr->pci->dev, "CMD_ASYNC : Error %s %s Pipe %d err=%x\n", 1016 err_src_name[err_src], 1017 is_capture ? "Record" : "Play", pipe, err); 1018 if (err == 0xe01) 1019 mgr->async_err_stream_xrun++; 1020 else if (err == 0xe10) 1021 mgr->async_err_pipe_xrun++; 1022 else 1023 mgr->async_err_other_last = (int)err; 1024 return 1; 1025 } 1026 1027 1028 static void pcxhr_msg_thread(struct pcxhr_mgr *mgr) 1029 { 1030 struct pcxhr_rmh *prmh = mgr->prmh; 1031 int err; 1032 int i, j; 1033 1034 if (mgr->src_it_dsp & PCXHR_IRQ_FREQ_CHANGE) 1035 dev_dbg(&mgr->pci->dev, 1036 "PCXHR_IRQ_FREQ_CHANGE event occurred\n"); 1037 if (mgr->src_it_dsp & PCXHR_IRQ_TIME_CODE) 1038 dev_dbg(&mgr->pci->dev, 1039 "PCXHR_IRQ_TIME_CODE event occurred\n"); 1040 if (mgr->src_it_dsp & PCXHR_IRQ_NOTIFY) 1041 dev_dbg(&mgr->pci->dev, 1042 "PCXHR_IRQ_NOTIFY event occurred\n"); 1043 if (mgr->src_it_dsp & (PCXHR_IRQ_FREQ_CHANGE | PCXHR_IRQ_TIME_CODE)) { 1044 /* clear events FREQ_CHANGE and TIME_CODE */ 1045 pcxhr_init_rmh(prmh, CMD_TEST_IT); 1046 err = pcxhr_send_msg(mgr, prmh); 1047 dev_dbg(&mgr->pci->dev, "CMD_TEST_IT : err=%x, stat=%x\n", 1048 err, prmh->stat[0]); 1049 } 1050 if (mgr->src_it_dsp & PCXHR_IRQ_ASYNC) { 1051 dev_dbg(&mgr->pci->dev, 1052 "PCXHR_IRQ_ASYNC event occurred\n"); 1053 1054 pcxhr_init_rmh(prmh, CMD_ASYNC); 1055 prmh->cmd[0] |= 1; /* add SEL_ASYNC_EVENTS */ 1056 /* this is the only one extra long response command */ 1057 prmh->stat_len = PCXHR_SIZE_MAX_LONG_STATUS; 1058 err = pcxhr_send_msg(mgr, prmh); 1059 if (err) 1060 dev_err(&mgr->pci->dev, "ERROR pcxhr_msg_thread=%x;\n", 1061 err); 1062 i = 1; 1063 while (i < prmh->stat_len) { 1064 int nb_audio = ((prmh->stat[i] >> FIELD_SIZE) & 1065 MASK_FIRST_FIELD); 1066 int nb_stream = ((prmh->stat[i] >> (2*FIELD_SIZE)) & 1067 MASK_FIRST_FIELD); 1068 int pipe = prmh->stat[i] & MASK_FIRST_FIELD; 1069 int is_capture = prmh->stat[i] & 0x400000; 1070 u32 err2; 1071 1072 if (prmh->stat[i] & 0x800000) { /* if BIT_END */ 1073 dev_dbg(&mgr->pci->dev, 1074 "TASKLET : End%sPipe %d\n", 1075 is_capture ? "Record" : "Play", 1076 pipe); 1077 } 1078 i++; 1079 err2 = prmh->stat[i] ? prmh->stat[i] : prmh->stat[i+1]; 1080 if (err2) 1081 pcxhr_handle_async_err(mgr, err2, 1082 PCXHR_ERR_PIPE, 1083 pipe, is_capture); 1084 i += 2; 1085 for (j = 0; j < nb_stream; j++) { 1086 err2 = prmh->stat[i] ? 1087 prmh->stat[i] : prmh->stat[i+1]; 1088 if (err2) 1089 pcxhr_handle_async_err(mgr, err2, 1090 PCXHR_ERR_STREAM, 1091 pipe, 1092 is_capture); 1093 i += 2; 1094 } 1095 for (j = 0; j < nb_audio; j++) { 1096 err2 = prmh->stat[i] ? 1097 prmh->stat[i] : prmh->stat[i+1]; 1098 if (err2) 1099 pcxhr_handle_async_err(mgr, err2, 1100 PCXHR_ERR_AUDIO, 1101 pipe, 1102 is_capture); 1103 i += 2; 1104 } 1105 } 1106 } 1107 } 1108 1109 static u_int64_t pcxhr_stream_read_position(struct pcxhr_mgr *mgr, 1110 struct pcxhr_stream *stream) 1111 { 1112 u_int64_t hw_sample_count; 1113 struct pcxhr_rmh rmh; 1114 int err, stream_mask; 1115 1116 stream_mask = stream->pipe->is_capture ? 1 : 1<<stream->substream->number; 1117 1118 /* get sample count for one stream */ 1119 pcxhr_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT); 1120 pcxhr_set_pipe_cmd_params(&rmh, stream->pipe->is_capture, 1121 stream->pipe->first_audio, 0, stream_mask); 1122 /* rmh.stat_len = 2; */ /* 2 resp data for each stream of the pipe */ 1123 1124 err = pcxhr_send_msg(mgr, &rmh); 1125 if (err) 1126 return 0; 1127 1128 hw_sample_count = ((u_int64_t)rmh.stat[0]) << 24; 1129 hw_sample_count += (u_int64_t)rmh.stat[1]; 1130 1131 dev_dbg(&mgr->pci->dev, 1132 "stream %c%d : abs samples real(%llu) timer(%llu)\n", 1133 stream->pipe->is_capture ? 'C' : 'P', 1134 stream->substream->number, 1135 hw_sample_count, 1136 stream->timer_abs_periods + stream->timer_period_frag + 1137 mgr->granularity); 1138 return hw_sample_count; 1139 } 1140 1141 static void pcxhr_update_timer_pos(struct pcxhr_mgr *mgr, 1142 struct pcxhr_stream *stream, 1143 int samples_to_add) 1144 { 1145 if (stream->substream && 1146 (stream->status == PCXHR_STREAM_STATUS_RUNNING)) { 1147 u_int64_t new_sample_count; 1148 int elapsed = 0; 1149 int hardware_read = 0; 1150 struct snd_pcm_runtime *runtime = stream->substream->runtime; 1151 1152 if (samples_to_add < 0) { 1153 stream->timer_is_synced = 0; 1154 /* add default if no hardware_read possible */ 1155 samples_to_add = mgr->granularity; 1156 } 1157 1158 if (!stream->timer_is_synced) { 1159 if ((stream->timer_abs_periods != 0) || 1160 ((stream->timer_period_frag + samples_to_add) >= 1161 runtime->period_size)) { 1162 new_sample_count = 1163 pcxhr_stream_read_position(mgr, stream); 1164 hardware_read = 1; 1165 if (new_sample_count >= mgr->granularity) { 1166 /* sub security offset because of 1167 * jitter and finer granularity of 1168 * dsp time (MBOX4) 1169 */ 1170 new_sample_count -= mgr->granularity; 1171 stream->timer_is_synced = 1; 1172 } 1173 } 1174 } 1175 if (!hardware_read) { 1176 /* if we didn't try to sync the position, increment it 1177 * by PCXHR_GRANULARITY every timer interrupt 1178 */ 1179 new_sample_count = stream->timer_abs_periods + 1180 stream->timer_period_frag + samples_to_add; 1181 } 1182 while (1) { 1183 u_int64_t new_elapse_pos = stream->timer_abs_periods + 1184 runtime->period_size; 1185 if (new_elapse_pos > new_sample_count) 1186 break; 1187 elapsed = 1; 1188 stream->timer_buf_periods++; 1189 if (stream->timer_buf_periods >= runtime->periods) 1190 stream->timer_buf_periods = 0; 1191 stream->timer_abs_periods = new_elapse_pos; 1192 } 1193 if (new_sample_count >= stream->timer_abs_periods) { 1194 stream->timer_period_frag = 1195 (u_int32_t)(new_sample_count - 1196 stream->timer_abs_periods); 1197 } else { 1198 dev_err(&mgr->pci->dev, 1199 "ERROR new_sample_count too small ??? %ld\n", 1200 (long unsigned int)new_sample_count); 1201 } 1202 1203 if (elapsed) { 1204 mutex_unlock(&mgr->lock); 1205 snd_pcm_period_elapsed(stream->substream); 1206 mutex_lock(&mgr->lock); 1207 } 1208 } 1209 } 1210 1211 irqreturn_t pcxhr_interrupt(int irq, void *dev_id) 1212 { 1213 struct pcxhr_mgr *mgr = dev_id; 1214 unsigned int reg; 1215 bool wake_thread = false; 1216 1217 reg = PCXHR_INPL(mgr, PCXHR_PLX_IRQCS); 1218 if (! (reg & PCXHR_IRQCS_ACTIVE_PCIDB)) { 1219 /* this device did not cause the interrupt */ 1220 return IRQ_NONE; 1221 } 1222 1223 /* clear interrupt */ 1224 reg = PCXHR_INPL(mgr, PCXHR_PLX_L2PCIDB); 1225 PCXHR_OUTPL(mgr, PCXHR_PLX_L2PCIDB, reg); 1226 1227 /* timer irq occurred */ 1228 if (reg & PCXHR_IRQ_TIMER) { 1229 int timer_toggle = reg & PCXHR_IRQ_TIMER; 1230 if (timer_toggle == mgr->timer_toggle) { 1231 dev_dbg(&mgr->pci->dev, "ERROR TIMER TOGGLE\n"); 1232 mgr->dsp_time_err++; 1233 } 1234 1235 mgr->timer_toggle = timer_toggle; 1236 mgr->src_it_dsp = reg; 1237 wake_thread = true; 1238 } 1239 1240 /* other irq's handled in the thread */ 1241 if (reg & PCXHR_IRQ_MASK) { 1242 if (reg & PCXHR_IRQ_ASYNC) { 1243 /* as we didn't request any async notifications, 1244 * some kind of xrun error will probably occurred 1245 */ 1246 /* better resynchronize all streams next interrupt : */ 1247 mgr->dsp_time_last = PCXHR_DSP_TIME_INVALID; 1248 } 1249 mgr->src_it_dsp = reg; 1250 wake_thread = true; 1251 } 1252 #ifdef CONFIG_SND_DEBUG_VERBOSE 1253 if (reg & PCXHR_FATAL_DSP_ERR) 1254 dev_dbg(&mgr->pci->dev, "FATAL DSP ERROR : %x\n", reg); 1255 #endif 1256 1257 return wake_thread ? IRQ_WAKE_THREAD : IRQ_HANDLED; 1258 } 1259 1260 irqreturn_t pcxhr_threaded_irq(int irq, void *dev_id) 1261 { 1262 struct pcxhr_mgr *mgr = dev_id; 1263 int i, j; 1264 struct snd_pcxhr *chip; 1265 1266 guard(mutex)(&mgr->lock); 1267 if (mgr->src_it_dsp & PCXHR_IRQ_TIMER) { 1268 /* is a 24 bit counter */ 1269 int dsp_time_new = 1270 PCXHR_INPL(mgr, PCXHR_PLX_MBOX4) & PCXHR_DSP_TIME_MASK; 1271 int dsp_time_diff = dsp_time_new - mgr->dsp_time_last; 1272 1273 if ((dsp_time_diff < 0) && 1274 (mgr->dsp_time_last != PCXHR_DSP_TIME_INVALID)) { 1275 /* handle dsp counter wraparound without resync */ 1276 int tmp_diff = dsp_time_diff + PCXHR_DSP_TIME_MASK + 1; 1277 dev_dbg(&mgr->pci->dev, 1278 "WARNING DSP timestamp old(%d) new(%d)", 1279 mgr->dsp_time_last, dsp_time_new); 1280 if (tmp_diff > 0 && tmp_diff <= (2*mgr->granularity)) { 1281 dev_dbg(&mgr->pci->dev, 1282 "-> timestamp wraparound OK: " 1283 "diff=%d\n", tmp_diff); 1284 dsp_time_diff = tmp_diff; 1285 } else { 1286 dev_dbg(&mgr->pci->dev, 1287 "-> resynchronize all streams\n"); 1288 mgr->dsp_time_err++; 1289 } 1290 } 1291 #ifdef CONFIG_SND_DEBUG_VERBOSE 1292 if (dsp_time_diff == 0) 1293 dev_dbg(&mgr->pci->dev, 1294 "ERROR DSP TIME NO DIFF time(%d)\n", 1295 dsp_time_new); 1296 else if (dsp_time_diff >= (2*mgr->granularity)) 1297 dev_dbg(&mgr->pci->dev, 1298 "ERROR DSP TIME TOO BIG old(%d) add(%d)\n", 1299 mgr->dsp_time_last, 1300 dsp_time_new - mgr->dsp_time_last); 1301 else if (dsp_time_diff % mgr->granularity) 1302 dev_dbg(&mgr->pci->dev, 1303 "ERROR DSP TIME increased by %d\n", 1304 dsp_time_diff); 1305 #endif 1306 mgr->dsp_time_last = dsp_time_new; 1307 1308 for (i = 0; i < mgr->num_cards; i++) { 1309 chip = mgr->chip[i]; 1310 for (j = 0; j < chip->nb_streams_capt; j++) 1311 pcxhr_update_timer_pos(mgr, 1312 &chip->capture_stream[j], 1313 dsp_time_diff); 1314 } 1315 for (i = 0; i < mgr->num_cards; i++) { 1316 chip = mgr->chip[i]; 1317 for (j = 0; j < chip->nb_streams_play; j++) 1318 pcxhr_update_timer_pos(mgr, 1319 &chip->playback_stream[j], 1320 dsp_time_diff); 1321 } 1322 } 1323 1324 pcxhr_msg_thread(mgr); 1325 return IRQ_HANDLED; 1326 } 1327