2 * Driver for DBRI sound chip found on Sparcs.
3 * Copyright (C) 2004, 2005 Martin Habets (mhabets@users.sourceforge.net)
5 * Converted to ring buffered version by Krzysztof Helt (krzysztof.h1@wp.pl)
7 * Based entirely upon drivers/sbus/audio/dbri.c which is:
8 * Copyright (C) 1997 Rudolf Koenig (rfkoenig@immd4.informatik.uni-erlangen.de)
9 * Copyright (C) 1998, 1999 Brent Baccala (baccala@freesoft.org)
11 * This is the lowlevel driver for the DBRI & MMCODEC duo used for ISDN & AUDIO
12 * on Sun SPARCstation 10, 20, LX and Voyager models.
14 * - DBRI: AT&T T5900FX Dual Basic Rates ISDN Interface. It is a 32 channel
15 * data time multiplexer with ISDN support (aka T7259)
16 * Interfaces: SBus,ISDN NT & TE, CHI, 4 bits parallel.
17 * CHI: (spelled ki) Concentration Highway Interface (AT&T or Intel bus ?).
19 * - "STP 4000SBus Dual Basic Rate ISDN (DBRI) Tranceiver" from
20 * Sparc Technology Business (courtesy of Sun Support)
21 * - Data sheet of the T7903, a newer but very similar ISA bus equivalent
22 * available from the Lucent (formarly AT&T microelectronics) home
24 * - http://www.freesoft.org/Linux/DBRI/
25 * - MMCODEC: Crystal Semiconductor CS4215 16 bit Multimedia Audio Codec
26 * Interfaces: CHI, Audio In & Out, 2 bits parallel
27 * Documentation: from the Crystal Semiconductor home page.
29 * The DBRI is a 32 pipe machine, each pipe can transfer some bits between
30 * memory and a serial device (long pipes, nr 0-15) or between two serial
31 * devices (short pipes, nr 16-31), or simply send a fixed data to a serial
32 * device (short pipes).
33 * A timeslot defines the bit-offset and nr of bits read from a serial device.
34 * The timeslots are linked to 6 circular lists, one for each direction for
35 * each serial device (NT,TE,CHI). A timeslot is associated to 1 or 2 pipes
36 * (the second one is a monitor/tee pipe, valid only for serial input).
38 * The mmcodec is connected via the CHI bus and needs the data & some
39 * parameters (volume, output selection) timemultiplexed in 8 byte
40 * chunks. It also has a control mode, which serves for audio format setting.
42 * Looking at the CS4215 data sheet it is easy to set up 2 or 4 codecs on
43 * the same CHI bus, so I thought perhaps it is possible to use the onboard
44 * & the speakerbox codec simultanously, giving 2 (not very independent :-)
45 * audio devices. But the SUN HW group decided against it, at least on my
46 * LX the speakerbox connector has at least 1 pin missing and 1 wrongly
49 * I've tried to stick to the following function naming conventions:
51 * cs4215_* CS4215 codec specific stuff
52 * dbri_* DBRI high-level stuff
53 * other DBRI low-level stuff
56 #include <sound/driver.h>
57 #include <linux/interrupt.h>
58 #include <linux/delay.h>
60 #include <sound/core.h>
61 #include <sound/pcm.h>
62 #include <sound/pcm_params.h>
63 #include <sound/info.h>
64 #include <sound/control.h>
65 #include <sound/initval.h>
70 #include <asm/atomic.h>
72 MODULE_AUTHOR("Rudolf Koenig, Brent Baccala and Martin Habets");
73 MODULE_DESCRIPTION("Sun DBRI");
74 MODULE_LICENSE("GPL");
75 MODULE_SUPPORTED_DEVICE("{{Sun,DBRI}}");
77 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
78 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
79 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
81 module_param_array(index, int, NULL, 0444);
82 MODULE_PARM_DESC(index, "Index value for Sun DBRI soundcard.");
83 module_param_array(id, charp, NULL, 0444);
84 MODULE_PARM_DESC(id, "ID string for Sun DBRI soundcard.");
85 module_param_array(enable, bool, NULL, 0444);
86 MODULE_PARM_DESC(enable, "Enable Sun DBRI soundcard.");
97 static int dbri_debug;
98 module_param(dbri_debug, int, 0644);
99 MODULE_PARM_DESC(dbri_debug, "Debug value for Sun DBRI soundcard.");
102 static char *cmds[] = {
103 "WAIT", "PAUSE", "JUMP", "IIQ", "REX", "SDP", "CDP", "DTS",
104 "SSP", "CHI", "NT", "TE", "CDEC", "TEST", "CDM", "RESRV"
107 #define dprintk(a, x...) if(dbri_debug & a) printk(KERN_DEBUG x)
110 #define dprintk(a, x...)
112 #endif /* DBRI_DEBUG */
114 #define DBRI_CMD(cmd, intr, value) ((cmd << 28) | \
118 /***************************************************************************
119 CS4215 specific definitions and structures
120 ****************************************************************************/
123 __u8 data[4]; /* Data mode: Time slots 5-8 */
124 __u8 ctrl[4]; /* Ctrl mode: Time slots 1-4 */
126 __u8 offset; /* Bit offset from frame sync to time slot 1 */
127 volatile __u32 status;
128 volatile __u32 version;
129 __u8 precision; /* In bits, either 8 or 16 */
130 __u8 channels; /* 1 or 2 */
137 /* Time Slot 1, Status register */
138 #define CS4215_CLB (1<<2) /* Control Latch Bit */
139 #define CS4215_OLB (1<<3) /* 1: line: 2.0V, speaker 4V */
140 /* 0: line: 2.8V, speaker 8V */
141 #define CS4215_MLB (1<<4) /* 1: Microphone: 20dB gain disabled */
142 #define CS4215_RSRVD_1 (1<<5)
144 /* Time Slot 2, Data Format Register */
145 #define CS4215_DFR_LINEAR16 0
146 #define CS4215_DFR_ULAW 1
147 #define CS4215_DFR_ALAW 2
148 #define CS4215_DFR_LINEAR8 3
149 #define CS4215_DFR_STEREO (1<<2)
155 { 8000, (1 << 4), (0 << 3) },
156 { 16000, (1 << 4), (1 << 3) },
157 { 27429, (1 << 4), (2 << 3) }, /* Actually 24428.57 */
158 { 32000, (1 << 4), (3 << 3) },
159 /* { NA, (1 << 4), (4 << 3) }, */
160 /* { NA, (1 << 4), (5 << 3) }, */
161 { 48000, (1 << 4), (6 << 3) },
162 { 9600, (1 << 4), (7 << 3) },
163 { 5513, (2 << 4), (0 << 3) }, /* Actually 5512.5 */
164 { 11025, (2 << 4), (1 << 3) },
165 { 18900, (2 << 4), (2 << 3) },
166 { 22050, (2 << 4), (3 << 3) },
167 { 37800, (2 << 4), (4 << 3) },
168 { 44100, (2 << 4), (5 << 3) },
169 { 33075, (2 << 4), (6 << 3) },
170 { 6615, (2 << 4), (7 << 3) },
174 #define CS4215_HPF (1<<7) /* High Pass Filter, 1: Enabled */
176 #define CS4215_12_MASK 0xfcbf /* Mask off reserved bits in slot 1 & 2 */
178 /* Time Slot 3, Serial Port Control register */
179 #define CS4215_XEN (1<<0) /* 0: Enable serial output */
180 #define CS4215_XCLK (1<<1) /* 1: Master mode: Generate SCLK */
181 #define CS4215_BSEL_64 (0<<2) /* Bitrate: 64 bits per frame */
182 #define CS4215_BSEL_128 (1<<2)
183 #define CS4215_BSEL_256 (2<<2)
184 #define CS4215_MCK_MAST (0<<4) /* Master clock */
185 #define CS4215_MCK_XTL1 (1<<4) /* 24.576 MHz clock source */
186 #define CS4215_MCK_XTL2 (2<<4) /* 16.9344 MHz clock source */
187 #define CS4215_MCK_CLK1 (3<<4) /* Clockin, 256 x Fs */
188 #define CS4215_MCK_CLK2 (4<<4) /* Clockin, see DFR */
190 /* Time Slot 4, Test Register */
191 #define CS4215_DAD (1<<0) /* 0:Digital-Dig loop, 1:Dig-Analog-Dig loop */
192 #define CS4215_ENL (1<<1) /* Enable Loopback Testing */
194 /* Time Slot 5, Parallel Port Register */
195 /* Read only here and the same as the in data mode */
197 /* Time Slot 6, Reserved */
199 /* Time Slot 7, Version Register */
200 #define CS4215_VERSION_MASK 0xf /* Known versions 0/C, 1/D, 2/E */
202 /* Time Slot 8, Reserved */
207 /* Time Slot 1-2: Left Channel Data, 2-3: Right Channel Data */
209 /* Time Slot 5, Output Setting */
210 #define CS4215_LO(v) v /* Left Output Attenuation 0x3f: -94.5 dB */
211 #define CS4215_LE (1<<6) /* Line Out Enable */
212 #define CS4215_HE (1<<7) /* Headphone Enable */
214 /* Time Slot 6, Output Setting */
215 #define CS4215_RO(v) v /* Right Output Attenuation 0x3f: -94.5 dB */
216 #define CS4215_SE (1<<6) /* Speaker Enable */
217 #define CS4215_ADI (1<<7) /* A/D Data Invalid: Busy in calibration */
219 /* Time Slot 7, Input Setting */
220 #define CS4215_LG(v) v /* Left Gain Setting 0xf: 22.5 dB */
221 #define CS4215_IS (1<<4) /* Input Select: 1=Microphone, 0=Line */
222 #define CS4215_OVR (1<<5) /* 1: Overrange condition occurred */
223 #define CS4215_PIO0 (1<<6) /* Parallel I/O 0 */
224 #define CS4215_PIO1 (1<<7)
226 /* Time Slot 8, Input Setting */
227 #define CS4215_RG(v) v /* Right Gain Setting 0xf: 22.5 dB */
228 #define CS4215_MA(v) (v<<4) /* Monitor Path Attenuation 0xf: mute */
230 /***************************************************************************
231 DBRI specific definitions and structures
232 ****************************************************************************/
234 /* DBRI main registers */
235 #define REG0 0x00UL /* Status and Control */
236 #define REG1 0x04UL /* Mode and Interrupt */
237 #define REG2 0x08UL /* Parallel IO */
238 #define REG3 0x0cUL /* Test */
239 #define REG8 0x20UL /* Command Queue Pointer */
240 #define REG9 0x24UL /* Interrupt Queue Pointer */
242 #define DBRI_NO_CMDS 64
243 #define DBRI_INT_BLK 64
244 #define DBRI_NO_DESCS 64
245 #define DBRI_NO_PIPES 32
246 #define DBRI_MAX_PIPE (DBRI_NO_PIPES - 1)
250 #define DBRI_NO_STREAMS 2
252 /* One transmit/receive descriptor */
253 /* When ba != 0 descriptor is used */
255 volatile __u32 word1;
256 __u32 ba; /* Transmit/Receive Buffer Address */
257 __u32 nda; /* Next Descriptor Address */
258 volatile __u32 word4;
261 /* This structure is in a DMA region where it can accessed by both
262 * the CPU and the DBRI
265 s32 cmd[DBRI_NO_CMDS]; /* Place for commands */
266 volatile s32 intr[DBRI_INT_BLK]; /* Interrupt field */
267 struct dbri_mem desc[DBRI_NO_DESCS]; /* Xmit/receive descriptors */
270 #define dbri_dma_off(member, elem) \
271 ((u32)(unsigned long) \
272 (&(((struct dbri_dma *)0)->member[elem])))
274 enum in_or_out { PIPEinput, PIPEoutput };
277 u32 sdp; /* SDP command word */
278 int nextpipe; /* Next pipe in linked list */
279 int length; /* Length of timeslot (bits) */
280 int first_desc; /* Index of first descriptor */
281 int desc; /* Index of active descriptor */
282 volatile __u32 *recv_fixed_ptr; /* Ptr to receive fixed data */
285 /* Per stream (playback or record) information */
286 struct dbri_streaminfo {
287 struct snd_pcm_substream *substream;
288 u32 dvma_buffer; /* Device view of Alsa DMA buffer */
289 int size; /* Size of DMA buffer */
290 size_t offset; /* offset in user buffer */
291 int pipe; /* Data pipe used */
292 int left_gain; /* mixer elements */
296 /* This structure holds the information for both chips (DBRI & CS4215) */
298 struct snd_card *card; /* ALSA card */
300 int regs_size, irq; /* Needed for unload */
301 struct sbus_dev *sdev; /* SBUS device info */
304 struct dbri_dma *dma; /* Pointer to our DMA block */
305 u32 dma_dvma; /* DBRI visible DMA address */
307 void __iomem *regs; /* dbri HW regs */
308 int dbri_irqp; /* intr queue pointer */
310 struct dbri_pipe pipes[DBRI_NO_PIPES]; /* DBRI's 32 data pipes */
311 int next_desc[DBRI_NO_DESCS]; /* Index of next desc, or -1 */
312 spinlock_t cmdlock; /* Protects cmd queue accesses */
313 s32 *cmdptr; /* Pointer to the last queued cmd */
317 struct cs4215 mm; /* mmcodec special info */
318 /* per stream (playback/record) info */
319 struct dbri_streaminfo stream_info[DBRI_NO_STREAMS];
321 struct snd_dbri *next;
324 #define DBRI_MAX_VOLUME 63 /* Output volume */
325 #define DBRI_MAX_GAIN 15 /* Input gain */
327 /* DBRI Reg0 - Status Control Register - defines. (Page 17) */
328 #define D_P (1<<15) /* Program command & queue pointer valid */
329 #define D_G (1<<14) /* Allow 4-Word SBus Burst */
330 #define D_S (1<<13) /* Allow 16-Word SBus Burst */
331 #define D_E (1<<12) /* Allow 8-Word SBus Burst */
332 #define D_X (1<<7) /* Sanity Timer Disable */
333 #define D_T (1<<6) /* Permit activation of the TE interface */
334 #define D_N (1<<5) /* Permit activation of the NT interface */
335 #define D_C (1<<4) /* Permit activation of the CHI interface */
336 #define D_F (1<<3) /* Force Sanity Timer Time-Out */
337 #define D_D (1<<2) /* Disable Master Mode */
338 #define D_H (1<<1) /* Halt for Analysis */
339 #define D_R (1<<0) /* Soft Reset */
341 /* DBRI Reg1 - Mode and Interrupt Register - defines. (Page 18) */
342 #define D_LITTLE_END (1<<8) /* Byte Order */
343 #define D_BIG_END (0<<8) /* Byte Order */
344 #define D_MRR (1<<4) /* Multiple Error Ack on SBus (readonly) */
345 #define D_MLE (1<<3) /* Multiple Late Error on SBus (readonly) */
346 #define D_LBG (1<<2) /* Lost Bus Grant on SBus (readonly) */
347 #define D_MBE (1<<1) /* Burst Error on SBus (readonly) */
348 #define D_IR (1<<0) /* Interrupt Indicator (readonly) */
350 /* DBRI Reg2 - Parallel IO Register - defines. (Page 18) */
351 #define D_ENPIO3 (1<<7) /* Enable Pin 3 */
352 #define D_ENPIO2 (1<<6) /* Enable Pin 2 */
353 #define D_ENPIO1 (1<<5) /* Enable Pin 1 */
354 #define D_ENPIO0 (1<<4) /* Enable Pin 0 */
355 #define D_ENPIO (0xf0) /* Enable all the pins */
356 #define D_PIO3 (1<<3) /* Pin 3: 1: Data mode, 0: Ctrl mode */
357 #define D_PIO2 (1<<2) /* Pin 2: 1: Onboard PDN */
358 #define D_PIO1 (1<<1) /* Pin 1: 0: Reset */
359 #define D_PIO0 (1<<0) /* Pin 0: 1: Speakerbox PDN */
361 /* DBRI Commands (Page 20) */
362 #define D_WAIT 0x0 /* Stop execution */
363 #define D_PAUSE 0x1 /* Flush long pipes */
364 #define D_JUMP 0x2 /* New command queue */
365 #define D_IIQ 0x3 /* Initialize Interrupt Queue */
366 #define D_REX 0x4 /* Report command execution via interrupt */
367 #define D_SDP 0x5 /* Setup Data Pipe */
368 #define D_CDP 0x6 /* Continue Data Pipe (reread NULL Pointer) */
369 #define D_DTS 0x7 /* Define Time Slot */
370 #define D_SSP 0x8 /* Set short Data Pipe */
371 #define D_CHI 0x9 /* Set CHI Global Mode */
372 #define D_NT 0xa /* NT Command */
373 #define D_TE 0xb /* TE Command */
374 #define D_CDEC 0xc /* Codec setup */
375 #define D_TEST 0xd /* No comment */
376 #define D_CDM 0xe /* CHI Data mode command */
378 /* Special bits for some commands */
379 #define D_PIPE(v) ((v)<<0) /* Pipe Nr: 0-15 long, 16-21 short */
381 /* Setup Data Pipe */
383 #define D_SDP_2SAME (1<<18) /* Report 2nd time in a row value rcvd */
384 #define D_SDP_CHANGE (2<<18) /* Report any changes */
385 #define D_SDP_EVERY (3<<18) /* Report any changes */
386 #define D_SDP_EOL (1<<17) /* EOL interrupt enable */
387 #define D_SDP_IDLE (1<<16) /* HDLC idle interrupt enable */
390 #define D_SDP_MEM (0<<13) /* To/from memory */
391 #define D_SDP_HDLC (2<<13)
392 #define D_SDP_HDLC_D (3<<13) /* D Channel (prio control) */
393 #define D_SDP_SER (4<<13) /* Serial to serial */
394 #define D_SDP_FIXED (6<<13) /* Short only */
395 #define D_SDP_MODE(v) ((v)&(7<<13))
397 #define D_SDP_TO_SER (1<<12) /* Direction */
398 #define D_SDP_FROM_SER (0<<12) /* Direction */
399 #define D_SDP_MSB (1<<11) /* Bit order within Byte */
400 #define D_SDP_LSB (0<<11) /* Bit order within Byte */
401 #define D_SDP_P (1<<10) /* Pointer Valid */
402 #define D_SDP_A (1<<8) /* Abort */
403 #define D_SDP_C (1<<7) /* Clear */
405 /* Define Time Slot */
406 #define D_DTS_VI (1<<17) /* Valid Input Time-Slot Descriptor */
407 #define D_DTS_VO (1<<16) /* Valid Output Time-Slot Descriptor */
408 #define D_DTS_INS (1<<15) /* Insert Time Slot */
409 #define D_DTS_DEL (0<<15) /* Delete Time Slot */
410 #define D_DTS_PRVIN(v) ((v)<<10) /* Previous In Pipe */
411 #define D_DTS_PRVOUT(v) ((v)<<5) /* Previous Out Pipe */
413 /* Time Slot defines */
414 #define D_TS_LEN(v) ((v)<<24) /* Number of bits in this time slot */
415 #define D_TS_CYCLE(v) ((v)<<14) /* Bit Count at start of TS */
416 #define D_TS_DI (1<<13) /* Data Invert */
417 #define D_TS_1CHANNEL (0<<10) /* Single Channel / Normal mode */
418 #define D_TS_MONITOR (2<<10) /* Monitor pipe */
419 #define D_TS_NONCONTIG (3<<10) /* Non contiguous mode */
420 #define D_TS_ANCHOR (7<<10) /* Starting short pipes */
421 #define D_TS_MON(v) ((v)<<5) /* Monitor Pipe */
422 #define D_TS_NEXT(v) ((v)<<0) /* Pipe Nr: 0-15 long, 16-21 short */
424 /* Concentration Highway Interface Modes */
425 #define D_CHI_CHICM(v) ((v)<<16) /* Clock mode */
426 #define D_CHI_IR (1<<15) /* Immediate Interrupt Report */
427 #define D_CHI_EN (1<<14) /* CHIL Interrupt enabled */
428 #define D_CHI_OD (1<<13) /* Open Drain Enable */
429 #define D_CHI_FE (1<<12) /* Sample CHIFS on Rising Frame Edge */
430 #define D_CHI_FD (1<<11) /* Frame Drive */
431 #define D_CHI_BPF(v) ((v)<<0) /* Bits per Frame */
433 /* NT: These are here for completeness */
434 #define D_NT_FBIT (1<<17) /* Frame Bit */
435 #define D_NT_NBF (1<<16) /* Number of bad frames to loose framing */
436 #define D_NT_IRM_IMM (1<<15) /* Interrupt Report & Mask: Immediate */
437 #define D_NT_IRM_EN (1<<14) /* Interrupt Report & Mask: Enable */
438 #define D_NT_ISNT (1<<13) /* Configfure interface as NT */
439 #define D_NT_FT (1<<12) /* Fixed Timing */
440 #define D_NT_EZ (1<<11) /* Echo Channel is Zeros */
441 #define D_NT_IFA (1<<10) /* Inhibit Final Activation */
442 #define D_NT_ACT (1<<9) /* Activate Interface */
443 #define D_NT_MFE (1<<8) /* Multiframe Enable */
444 #define D_NT_RLB(v) ((v)<<5) /* Remote Loopback */
445 #define D_NT_LLB(v) ((v)<<2) /* Local Loopback */
446 #define D_NT_FACT (1<<1) /* Force Activation */
447 #define D_NT_ABV (1<<0) /* Activate Bipolar Violation */
450 #define D_CDEC_CK(v) ((v)<<24) /* Clock Select */
451 #define D_CDEC_FED(v) ((v)<<12) /* FSCOD Falling Edge Delay */
452 #define D_CDEC_RED(v) ((v)<<0) /* FSCOD Rising Edge Delay */
455 #define D_TEST_RAM(v) ((v)<<16) /* RAM Pointer */
456 #define D_TEST_SIZE(v) ((v)<<11) /* */
457 #define D_TEST_ROMONOFF 0x5 /* Toggle ROM opcode monitor on/off */
458 #define D_TEST_PROC 0x6 /* MicroProcessor test */
459 #define D_TEST_SER 0x7 /* Serial-Controller test */
460 #define D_TEST_RAMREAD 0x8 /* Copy from Ram to system memory */
461 #define D_TEST_RAMWRITE 0x9 /* Copy into Ram from system memory */
462 #define D_TEST_RAMBIST 0xa /* RAM Built-In Self Test */
463 #define D_TEST_MCBIST 0xb /* Microcontroller Built-In Self Test */
464 #define D_TEST_DUMP 0xe /* ROM Dump */
467 #define D_CDM_THI (1<<8) /* Transmit Data on CHIDR Pin */
468 #define D_CDM_RHI (1<<7) /* Receive Data on CHIDX Pin */
469 #define D_CDM_RCE (1<<6) /* Receive on Rising Edge of CHICK */
470 #define D_CDM_XCE (1<<2) /* Transmit Data on Rising Edge of CHICK */
471 #define D_CDM_XEN (1<<1) /* Transmit Highway Enable */
472 #define D_CDM_REN (1<<0) /* Receive Highway Enable */
475 #define D_INTR_BRDY 1 /* Buffer Ready for processing */
476 #define D_INTR_MINT 2 /* Marked Interrupt in RD/TD */
477 #define D_INTR_IBEG 3 /* Flag to idle transition detected (HDLC) */
478 #define D_INTR_IEND 4 /* Idle to flag transition detected (HDLC) */
479 #define D_INTR_EOL 5 /* End of List */
480 #define D_INTR_CMDI 6 /* Command has bean read */
481 #define D_INTR_XCMP 8 /* Transmission of frame complete */
482 #define D_INTR_SBRI 9 /* BRI status change info */
483 #define D_INTR_FXDT 10 /* Fixed data change */
484 #define D_INTR_CHIL 11 /* CHI lost frame sync (channel 36 only) */
485 #define D_INTR_COLL 11 /* Unrecoverable D-Channel collision */
486 #define D_INTR_DBYT 12 /* Dropped by frame slip */
487 #define D_INTR_RBYT 13 /* Repeated by frame slip */
488 #define D_INTR_LINT 14 /* Lost Interrupt */
489 #define D_INTR_UNDR 15 /* DMA underrun */
493 #define D_INTR_CHI 36
494 #define D_INTR_CMD 38
496 #define D_INTR_GETCHAN(v) (((v)>>24) & 0x3f)
497 #define D_INTR_GETCODE(v) (((v)>>20) & 0xf)
498 #define D_INTR_GETCMD(v) (((v)>>16) & 0xf)
499 #define D_INTR_GETVAL(v) ((v) & 0xffff)
500 #define D_INTR_GETRVAL(v) ((v) & 0xfffff)
502 #define D_P_0 0 /* TE receive anchor */
503 #define D_P_1 1 /* TE transmit anchor */
504 #define D_P_2 2 /* NT transmit anchor */
505 #define D_P_3 3 /* NT receive anchor */
506 #define D_P_4 4 /* CHI send data */
507 #define D_P_5 5 /* CHI receive data */
508 #define D_P_6 6 /* */
509 #define D_P_7 7 /* */
510 #define D_P_8 8 /* */
511 #define D_P_9 9 /* */
512 #define D_P_10 10 /* */
513 #define D_P_11 11 /* */
514 #define D_P_12 12 /* */
515 #define D_P_13 13 /* */
516 #define D_P_14 14 /* */
517 #define D_P_15 15 /* */
518 #define D_P_16 16 /* CHI anchor pipe */
519 #define D_P_17 17 /* CHI send */
520 #define D_P_18 18 /* CHI receive */
521 #define D_P_19 19 /* CHI receive */
522 #define D_P_20 20 /* CHI receive */
523 #define D_P_21 21 /* */
524 #define D_P_22 22 /* */
525 #define D_P_23 23 /* */
526 #define D_P_24 24 /* */
527 #define D_P_25 25 /* */
528 #define D_P_26 26 /* */
529 #define D_P_27 27 /* */
530 #define D_P_28 28 /* */
531 #define D_P_29 29 /* */
532 #define D_P_30 30 /* */
533 #define D_P_31 31 /* */
535 /* Transmit descriptor defines */
536 #define DBRI_TD_F (1<<31) /* End of Frame */
537 #define DBRI_TD_D (1<<30) /* Do not append CRC */
538 #define DBRI_TD_CNT(v) ((v)<<16) /* Number of valid bytes in the buffer */
539 #define DBRI_TD_B (1<<15) /* Final interrupt */
540 #define DBRI_TD_M (1<<14) /* Marker interrupt */
541 #define DBRI_TD_I (1<<13) /* Transmit Idle Characters */
542 #define DBRI_TD_FCNT(v) (v) /* Flag Count */
543 #define DBRI_TD_UNR (1<<3) /* Underrun: transmitter is out of data */
544 #define DBRI_TD_ABT (1<<2) /* Abort: frame aborted */
545 #define DBRI_TD_TBC (1<<0) /* Transmit buffer Complete */
546 #define DBRI_TD_STATUS(v) ((v)&0xff) /* Transmit status */
547 /* Maximum buffer size per TD: almost 8Kb */
548 #define DBRI_TD_MAXCNT ((1 << 13) - 4)
550 /* Receive descriptor defines */
551 #define DBRI_RD_F (1<<31) /* End of Frame */
552 #define DBRI_RD_C (1<<30) /* Completed buffer */
553 #define DBRI_RD_B (1<<15) /* Final interrupt */
554 #define DBRI_RD_M (1<<14) /* Marker interrupt */
555 #define DBRI_RD_BCNT(v) (v) /* Buffer size */
556 #define DBRI_RD_CRC (1<<7) /* 0: CRC is correct */
557 #define DBRI_RD_BBC (1<<6) /* 1: Bad Byte received */
558 #define DBRI_RD_ABT (1<<5) /* Abort: frame aborted */
559 #define DBRI_RD_OVRN (1<<3) /* Overrun: data lost */
560 #define DBRI_RD_STATUS(v) ((v)&0xff) /* Receive status */
561 #define DBRI_RD_CNT(v) (((v)>>16)&0x1fff) /* Valid bytes in the buffer */
563 /* stream_info[] access */
564 /* Translate the ALSA direction into the array index */
565 #define DBRI_STREAMNO(substream) \
566 (substream->stream == \
567 SNDRV_PCM_STREAM_PLAYBACK? DBRI_PLAY: DBRI_REC)
569 /* Return a pointer to dbri_streaminfo */
570 #define DBRI_STREAM(dbri, substream) &dbri->stream_info[DBRI_STREAMNO(substream)]
572 static struct snd_dbri *dbri_list; /* All DBRI devices */
575 * Short data pipes transmit LSB first. The CS4215 receives MSB first. Grrr.
576 * So we have to reverse the bits. Note: not all bit lengths are supported
578 static __u32 reverse_bytes(__u32 b, int len)
582 b = ((b & 0xffff0000) >> 16) | ((b & 0x0000ffff) << 16);
584 b = ((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8);
586 b = ((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4);
588 b = ((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2);
590 b = ((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1);
595 printk(KERN_ERR "DBRI reverse_bytes: unsupported length\n");
602 ****************************************************************************
603 ************** DBRI initialization and command synchronization *************
604 ****************************************************************************
606 Commands are sent to the DBRI by building a list of them in memory,
607 then writing the address of the first list item to DBRI register 8.
608 The list is terminated with a WAIT command, which generates a
609 CPU interrupt to signal completion.
611 Since the DBRI can run in parallel with the CPU, several means of
612 synchronization present themselves. The method implemented here is only
613 to use the dbri_cmdwait() to wait for execution of batch of sent commands.
615 A circular command buffer is used here. A new command is being added
616 while other can be executed. The scheme works by adding two WAIT commands
617 after each sent batch of commands. When the next batch is prepared it is
618 added after the WAIT commands then the WAITs are replaced with single JUMP
619 command to the new batch. The the DBRI is forced to reread the last WAIT
620 command (replaced by the JUMP by then). If the DBRI is still executing
621 previous commands the request to reread the WAIT command is ignored.
623 Every time a routine wants to write commands to the DBRI, it must
624 first call dbri_cmdlock() and get pointer to a free space in
625 dbri->dma->cmd buffer. After this, the commands can be written to
626 the buffer, and dbri_cmdsend() is called with the final pointer value
627 to send them to the DBRI.
631 static void dbri_process_interrupt_buffer(struct snd_dbri * dbri);
635 * Wait for the current command string to execute
637 static void dbri_cmdwait(struct snd_dbri *dbri)
639 int maxloops = MAXLOOPS;
641 /* Delay if previous commands are still being processed */
642 while ((--maxloops) > 0 && (sbus_readl(dbri->regs + REG0) & D_P))
643 msleep_interruptible(1);
646 printk(KERN_ERR "DBRI: Chip never completed command buffer\n");
648 dprintk(D_CMD, "Chip completed command buffer (%d)\n",
649 MAXLOOPS - maxloops - 1);
653 * Lock the command queue and returns pointer to a space for len cmd words
654 * It locks the cmdlock spinlock.
656 static s32 *dbri_cmdlock(struct snd_dbri * dbri, int len)
658 /* Space for 2 WAIT cmds (replaced later by 1 JUMP cmd) */
660 spin_lock(&dbri->cmdlock);
661 if (dbri->cmdptr - dbri->dma->cmd + len < DBRI_NO_CMDS - 2)
662 return dbri->cmdptr + 2;
663 else if (len < sbus_readl(dbri->regs + REG8) - dbri->dma_dvma)
664 return dbri->dma->cmd;
666 printk(KERN_ERR "DBRI: no space for commands.");
672 * Send prepared cmd string. It works by writting a JMP cmd into
673 * the last WAIT cmd and force DBRI to reread the cmd.
674 * The JMP cmd points to the new cmd string.
675 * It also releases the cmdlock spinlock.
677 static void dbri_cmdsend(struct snd_dbri * dbri, s32 * cmd,int len)
681 static int wait_id = 0;
684 wait_id &= 0xffff; /* restrict it to a 16 bit counter. */
685 *(cmd) = DBRI_CMD(D_WAIT, 1, wait_id);
686 *(cmd+1) = DBRI_CMD(D_WAIT, 1, wait_id);
688 /* Replace the last command with JUMP */
689 addr = dbri->dma_dvma + (cmd - len - dbri->dma->cmd) * sizeof(s32);
690 *(dbri->cmdptr+1) = addr;
691 *(dbri->cmdptr) = DBRI_CMD(D_JUMP, 0, 0);
694 if (cmd > dbri->cmdptr )
695 for (ptr = dbri->cmdptr; ptr < cmd+2; ptr++) {
696 dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr);
700 dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr);
701 ptr = dbri->cmdptr+1;
702 dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr);
703 for (ptr = dbri->dma->cmd; ptr < cmd+2; ptr++) {
704 dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr);
709 /* Reread the last command */
710 tmp = sbus_readl(dbri->regs + REG0);
712 sbus_writel(tmp, dbri->regs + REG0);
715 spin_unlock(&dbri->cmdlock);
718 /* Lock must be held when calling this */
719 static void dbri_reset(struct snd_dbri * dbri)
724 dprintk(D_GEN, "reset 0:%x 2:%x 8:%x 9:%x\n",
725 sbus_readl(dbri->regs + REG0),
726 sbus_readl(dbri->regs + REG2),
727 sbus_readl(dbri->regs + REG8), sbus_readl(dbri->regs + REG9));
729 sbus_writel(D_R, dbri->regs + REG0); /* Soft Reset */
730 for (i = 0; (sbus_readl(dbri->regs + REG0) & D_R) && i < 64; i++)
733 /* A brute approach - DBRI falls back to working burst size by itself
734 * On SS20 D_S does not work, so do not try so high. */
735 tmp = sbus_readl(dbri->regs + REG0);
738 sbus_writel(tmp, dbri->regs + REG0);
741 /* Lock must not be held before calling this */
742 static void dbri_initialize(struct snd_dbri * dbri)
749 spin_lock_irqsave(&dbri->lock, flags);
753 /* Initialize pipes */
754 for (n = 0; n < DBRI_NO_PIPES; n++)
755 dbri->pipes[n].desc = dbri->pipes[n].first_desc = -1;
757 spin_lock_init(&dbri->cmdlock);
759 * Initialize the interrupt ringbuffer.
761 dma_addr = dbri->dma_dvma + dbri_dma_off(intr, 0);
762 dbri->dma->intr[0] = dma_addr;
765 * Set up the interrupt queue
767 spin_lock(&dbri->cmdlock);
768 cmd = dbri->cmdptr = dbri->dma->cmd;
769 *(cmd++) = DBRI_CMD(D_IIQ, 0, 0);
771 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
773 *(cmd++) = DBRI_CMD(D_WAIT, 1, 0);
774 *(cmd++) = DBRI_CMD(D_WAIT, 1, 0);
775 dma_addr = dbri->dma_dvma + dbri_dma_off(cmd, 0);
776 sbus_writel(dma_addr, dbri->regs + REG8);
777 spin_unlock(&dbri->cmdlock);
780 spin_unlock_irqrestore(&dbri->lock, flags);
784 ****************************************************************************
785 ************************** DBRI data pipe management ***********************
786 ****************************************************************************
788 While DBRI control functions use the command and interrupt buffers, the
789 main data path takes the form of data pipes, which can be short (command
790 and interrupt driven), or long (attached to DMA buffers). These functions
791 provide a rudimentary means of setting up and managing the DBRI's pipes,
792 but the calling functions have to make sure they respect the pipes' linked
793 list ordering, among other things. The transmit and receive functions
794 here interface closely with the transmit and receive interrupt code.
797 static int pipe_active(struct snd_dbri * dbri, int pipe)
799 return ((pipe >= 0) && (dbri->pipes[pipe].desc != -1));
802 /* reset_pipe(dbri, pipe)
804 * Called on an in-use pipe to clear anything being transmitted or received
805 * Lock must be held before calling this.
807 static void reset_pipe(struct snd_dbri * dbri, int pipe)
813 if (pipe < 0 || pipe > DBRI_MAX_PIPE) {
814 printk(KERN_ERR "DBRI: reset_pipe called with illegal pipe number\n");
818 sdp = dbri->pipes[pipe].sdp;
820 printk(KERN_ERR "DBRI: reset_pipe called on uninitialized pipe\n");
824 cmd = dbri_cmdlock(dbri, 3);
825 *(cmd++) = DBRI_CMD(D_SDP, 0, sdp | D_SDP_C | D_SDP_P);
827 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
828 dbri_cmdsend(dbri, cmd, 3);
830 desc = dbri->pipes[pipe].first_desc;
833 dbri->dma->desc[desc].nda = dbri->dma->desc[desc].ba = 0;
834 desc = dbri->next_desc[desc];
835 } while (desc != -1 && desc != dbri->pipes[pipe].first_desc);
837 dbri->pipes[pipe].desc = -1;
838 dbri->pipes[pipe].first_desc = -1;
841 static void setup_pipe(struct snd_dbri * dbri, int pipe, int sdp)
843 if (pipe < 0 || pipe > DBRI_MAX_PIPE) {
844 printk(KERN_ERR "DBRI: setup_pipe called with illegal pipe number\n");
848 if ((sdp & 0xf800) != sdp) {
849 printk(KERN_ERR "DBRI: setup_pipe called with strange SDP value\n");
853 /* If this is a fixed receive pipe, arrange for an interrupt
854 * every time its data changes
856 if (D_SDP_MODE(sdp) == D_SDP_FIXED && !(sdp & D_SDP_TO_SER))
860 dbri->pipes[pipe].sdp = sdp;
861 dbri->pipes[pipe].desc = -1;
862 dbri->pipes[pipe].first_desc = -1;
864 reset_pipe(dbri, pipe);
867 static void link_time_slot(struct snd_dbri * dbri, int pipe,
868 int prevpipe, int nextpipe,
869 int length, int cycle)
874 if (pipe < 0 || pipe > DBRI_MAX_PIPE
875 || prevpipe < 0 || prevpipe > DBRI_MAX_PIPE
876 || nextpipe < 0 || nextpipe > DBRI_MAX_PIPE) {
878 "DBRI: link_time_slot called with illegal pipe number\n");
882 if (dbri->pipes[pipe].sdp == 0
883 || dbri->pipes[prevpipe].sdp == 0
884 || dbri->pipes[nextpipe].sdp == 0) {
885 printk(KERN_ERR "DBRI: link_time_slot called on uninitialized pipe\n");
889 dbri->pipes[prevpipe].nextpipe = pipe;
890 dbri->pipes[pipe].nextpipe = nextpipe;
891 dbri->pipes[pipe].length = length;
893 cmd = dbri_cmdlock(dbri, 4);
895 if (dbri->pipes[pipe].sdp & D_SDP_TO_SER) {
896 /* Deal with CHI special case:
897 * "If transmission on edges 0 or 1 is desired, then cycle n
898 * (where n = # of bit times per frame...) must be used."
899 * - DBRI data sheet, page 11
901 if (prevpipe == 16 && cycle == 0)
902 cycle = dbri->chi_bpf;
904 val = D_DTS_VO | D_DTS_INS | D_DTS_PRVOUT(prevpipe) | pipe;
905 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
908 D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe);
910 val = D_DTS_VI | D_DTS_INS | D_DTS_PRVIN(prevpipe) | pipe;
911 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
913 D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe);
916 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
918 dbri_cmdsend(dbri, cmd, 4);
921 static void unlink_time_slot(struct snd_dbri * dbri, int pipe,
922 enum in_or_out direction, int prevpipe,
928 if (pipe < 0 || pipe > DBRI_MAX_PIPE
929 || prevpipe < 0 || prevpipe > DBRI_MAX_PIPE
930 || nextpipe < 0 || nextpipe > DBRI_MAX_PIPE) {
932 "DBRI: unlink_time_slot called with illegal pipe number\n");
936 cmd = dbri_cmdlock(dbri, 4);
938 if (direction == PIPEinput) {
939 val = D_DTS_VI | D_DTS_DEL | D_DTS_PRVIN(prevpipe) | pipe;
940 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
941 *(cmd++) = D_TS_NEXT(nextpipe);
944 val = D_DTS_VO | D_DTS_DEL | D_DTS_PRVOUT(prevpipe) | pipe;
945 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
947 *(cmd++) = D_TS_NEXT(nextpipe);
949 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
951 dbri_cmdsend(dbri, cmd, 4);
954 /* xmit_fixed() / recv_fixed()
956 * Transmit/receive data on a "fixed" pipe - i.e, one whose contents are not
957 * expected to change much, and which we don't need to buffer.
958 * The DBRI only interrupts us when the data changes (receive pipes),
959 * or only changes the data when this function is called (transmit pipes).
960 * Only short pipes (numbers 16-31) can be used in fixed data mode.
962 * These function operate on a 32-bit field, no matter how large
963 * the actual time slot is. The interrupt handler takes care of bit
964 * ordering and alignment. An 8-bit time slot will always end up
965 * in the low-order 8 bits, filled either MSB-first or LSB-first,
966 * depending on the settings passed to setup_pipe()
968 static void xmit_fixed(struct snd_dbri * dbri, int pipe, unsigned int data)
972 if (pipe < 16 || pipe > DBRI_MAX_PIPE) {
973 printk(KERN_ERR "DBRI: xmit_fixed: Illegal pipe number\n");
977 if (D_SDP_MODE(dbri->pipes[pipe].sdp) == 0) {
978 printk(KERN_ERR "DBRI: xmit_fixed: Uninitialized pipe %d\n", pipe);
982 if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) {
983 printk(KERN_ERR "DBRI: xmit_fixed: Non-fixed pipe %d\n", pipe);
987 if (!(dbri->pipes[pipe].sdp & D_SDP_TO_SER)) {
988 printk(KERN_ERR "DBRI: xmit_fixed: Called on receive pipe %d\n", pipe);
992 /* DBRI short pipes always transmit LSB first */
994 if (dbri->pipes[pipe].sdp & D_SDP_MSB)
995 data = reverse_bytes(data, dbri->pipes[pipe].length);
997 cmd = dbri_cmdlock(dbri, 3);
999 *(cmd++) = DBRI_CMD(D_SSP, 0, pipe);
1001 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
1003 dbri_cmdsend(dbri, cmd, 3);
1007 static void recv_fixed(struct snd_dbri * dbri, int pipe, volatile __u32 * ptr)
1009 if (pipe < 16 || pipe > DBRI_MAX_PIPE) {
1010 printk(KERN_ERR "DBRI: recv_fixed called with illegal pipe number\n");
1014 if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) {
1015 printk(KERN_ERR "DBRI: recv_fixed called on non-fixed pipe %d\n", pipe);
1019 if (dbri->pipes[pipe].sdp & D_SDP_TO_SER) {
1020 printk(KERN_ERR "DBRI: recv_fixed called on transmit pipe %d\n", pipe);
1024 dbri->pipes[pipe].recv_fixed_ptr = ptr;
1029 * Setup transmit/receive data on a "long" pipe - i.e, one associated
1030 * with a DMA buffer.
1032 * Only pipe numbers 0-15 can be used in this mode.
1034 * This function takes a stream number pointing to a data buffer,
1035 * and work by building chains of descriptors which identify the
1036 * data buffers. Buffers too large for a single descriptor will
1037 * be spread across multiple descriptors.
1039 * All descriptors create a ring buffer.
1041 static int setup_descs(struct snd_dbri * dbri, int streamno, unsigned int period)
1043 struct dbri_streaminfo *info = &dbri->stream_info[streamno];
1047 int first_desc = -1;
1050 if (info->pipe < 0 || info->pipe > 15) {
1051 printk(KERN_ERR "DBRI: setup_descs: Illegal pipe number\n");
1055 if (dbri->pipes[info->pipe].sdp == 0) {
1056 printk(KERN_ERR "DBRI: setup_descs: Uninitialized pipe %d\n",
1061 dvma_buffer = info->dvma_buffer;
1064 if (streamno == DBRI_PLAY) {
1065 if (!(dbri->pipes[info->pipe].sdp & D_SDP_TO_SER)) {
1066 printk(KERN_ERR "DBRI: setup_descs: Called on receive pipe %d\n",
1071 if (dbri->pipes[info->pipe].sdp & D_SDP_TO_SER) {
1073 "DBRI: setup_descs: Called on transmit pipe %d\n",
1077 /* Should be able to queue multiple buffers to receive on a pipe */
1078 if (pipe_active(dbri, info->pipe)) {
1079 printk(KERN_ERR "DBRI: recv_on_pipe: Called on active pipe %d\n",
1084 /* Make sure buffer size is multiple of four */
1091 for (; desc < DBRI_NO_DESCS; desc++) {
1092 if (!dbri->dma->desc[desc].ba)
1095 if (desc == DBRI_NO_DESCS) {
1096 printk(KERN_ERR "DBRI: setup_descs: No descriptors\n");
1100 if (len > DBRI_TD_MAXCNT)
1101 mylen = DBRI_TD_MAXCNT; /* 8KB - 4 */
1108 dbri->next_desc[desc] = -1;
1109 dbri->dma->desc[desc].ba = dvma_buffer;
1110 dbri->dma->desc[desc].nda = 0;
1112 if (streamno == DBRI_PLAY) {
1113 dbri->dma->desc[desc].word1 = DBRI_TD_CNT(mylen);
1114 dbri->dma->desc[desc].word4 = 0;
1115 dbri->dma->desc[desc].word1 |=
1116 DBRI_TD_F | DBRI_TD_B;
1118 dbri->dma->desc[desc].word1 = 0;
1119 dbri->dma->desc[desc].word4 =
1120 DBRI_RD_B | DBRI_RD_BCNT(mylen);
1123 if (first_desc == -1)
1126 dbri->next_desc[last_desc] = desc;
1127 dbri->dma->desc[last_desc].nda =
1128 dbri->dma_dvma + dbri_dma_off(desc, desc);
1132 dvma_buffer += mylen;
1136 if (first_desc == -1 || last_desc == -1) {
1137 printk(KERN_ERR "DBRI: setup_descs: Not enough descriptors available\n");
1141 if (streamno == DBRI_PLAY) {
1142 dbri->dma->desc[last_desc].word1 |=
1143 DBRI_TD_F | DBRI_TD_B;
1144 dbri->dma->desc[last_desc].nda =
1145 dbri->dma_dvma + dbri_dma_off(desc, first_desc);
1146 dbri->next_desc[last_desc] = first_desc;
1148 dbri->pipes[info->pipe].first_desc = first_desc;
1149 dbri->pipes[info->pipe].desc = first_desc;
1152 for (desc = first_desc; desc != -1; ) {
1153 dprintk(D_DESC, "DESC %d: %08x %08x %08x %08x\n",
1155 dbri->dma->desc[desc].word1,
1156 dbri->dma->desc[desc].ba,
1157 dbri->dma->desc[desc].nda, dbri->dma->desc[desc].word4);
1158 desc = dbri->next_desc[desc];
1159 if ( desc == first_desc )
1167 ****************************************************************************
1168 ************************** DBRI - CHI interface ****************************
1169 ****************************************************************************
1171 The CHI is a four-wire (clock, frame sync, data in, data out) time-division
1172 multiplexed serial interface which the DBRI can operate in either master
1173 (give clock/frame sync) or slave (take clock/frame sync) mode.
1177 enum master_or_slave { CHImaster, CHIslave };
1179 static void reset_chi(struct snd_dbri * dbri, enum master_or_slave master_or_slave,
1185 /* Set CHI Anchor: Pipe 16 */
1187 cmd = dbri_cmdlock(dbri, 4);
1188 val = D_DTS_VO | D_DTS_VI | D_DTS_INS
1189 | D_DTS_PRVIN(16) | D_PIPE(16) | D_DTS_PRVOUT(16);
1190 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
1191 *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16);
1192 *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16);
1193 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
1194 dbri_cmdsend(dbri, cmd, 4);
1196 dbri->pipes[16].sdp = 1;
1197 dbri->pipes[16].nextpipe = 16;
1199 cmd = dbri_cmdlock(dbri, 4);
1201 if (master_or_slave == CHIslave) {
1202 /* Setup DBRI for CHI Slave - receive clock, frame sync (FS)
1204 * CHICM = 0 (slave mode, 8 kHz frame rate)
1205 * IR = give immediate CHI status interrupt
1206 * EN = give CHI status interrupt upon change
1208 *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(0));
1210 /* Setup DBRI for CHI Master - generate clock, FS
1212 * BPF = bits per 8 kHz frame
1213 * 12.288 MHz / CHICM_divisor = clock rate
1214 * FD = 1 - drive CHIFS on rising edge of CHICK
1216 int clockrate = bits_per_frame * 8;
1217 int divisor = 12288 / clockrate;
1219 if (divisor > 255 || divisor * clockrate != 12288)
1220 printk(KERN_ERR "DBRI: illegal bits_per_frame in setup_chi\n");
1222 *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(divisor) | D_CHI_FD
1223 | D_CHI_BPF(bits_per_frame));
1226 dbri->chi_bpf = bits_per_frame;
1230 * RCE = 0 - receive on falling edge of CHICK
1231 * XCE = 1 - transmit on rising edge of CHICK
1232 * XEN = 1 - enable transmitter
1233 * REN = 1 - enable receiver
1236 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
1237 *(cmd++) = DBRI_CMD(D_CDM, 0, D_CDM_XCE | D_CDM_XEN | D_CDM_REN);
1238 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
1240 dbri_cmdsend(dbri, cmd, 4);
1244 ****************************************************************************
1245 *********************** CS4215 audio codec management **********************
1246 ****************************************************************************
1248 In the standard SPARC audio configuration, the CS4215 codec is attached
1249 to the DBRI via the CHI interface and few of the DBRI's PIO pins.
1252 static void cs4215_setup_pipes(struct snd_dbri * dbri)
1256 * Pipe 4: Send timeslots 1-4 (audio data)
1257 * Pipe 20: Send timeslots 5-8 (part of ctrl data)
1258 * Pipe 6: Receive timeslots 1-4 (audio data)
1259 * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via
1260 * interrupt, and the rest of the data (slot 5 and 8) is
1261 * not relevant for us (only for doublechecking).
1264 * Pipe 17: Send timeslots 1-4 (slots 5-8 are readonly)
1265 * Pipe 18: Receive timeslot 1 (clb).
1266 * Pipe 19: Receive timeslot 7 (version).
1269 setup_pipe(dbri, 4, D_SDP_MEM | D_SDP_TO_SER | D_SDP_MSB);
1270 setup_pipe(dbri, 20, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB);
1271 setup_pipe(dbri, 6, D_SDP_MEM | D_SDP_FROM_SER | D_SDP_MSB);
1272 setup_pipe(dbri, 21, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1274 setup_pipe(dbri, 17, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB);
1275 setup_pipe(dbri, 18, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1276 setup_pipe(dbri, 19, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1281 static int cs4215_init_data(struct cs4215 *mm)
1284 * No action, memory resetting only.
1286 * Data Time Slot 5-8
1287 * Speaker,Line and Headphone enable. Gain set to the half.
1290 mm->data[0] = CS4215_LO(0x20) | CS4215_HE | CS4215_LE;
1291 mm->data[1] = CS4215_RO(0x20) | CS4215_SE;
1292 mm->data[2] = CS4215_LG(0x8) | CS4215_IS | CS4215_PIO0 | CS4215_PIO1;
1293 mm->data[3] = CS4215_RG(0x8) | CS4215_MA(0xf);
1296 * Control Time Slot 1-4
1297 * 0: Default I/O voltage scale
1298 * 1: 8 bit ulaw, 8kHz, mono, high pass filter disabled
1299 * 2: Serial enable, CHI master, 128 bits per frame, clock 1
1302 mm->ctrl[0] = CS4215_RSRVD_1 | CS4215_MLB;
1303 mm->ctrl[1] = CS4215_DFR_ULAW | CS4215_FREQ[0].csval;
1304 mm->ctrl[2] = CS4215_XCLK | CS4215_BSEL_128 | CS4215_FREQ[0].xtal;
1309 mm->precision = 8; /* For ULAW */
1315 static void cs4215_setdata(struct snd_dbri * dbri, int muted)
1318 dbri->mm.data[0] |= 63;
1319 dbri->mm.data[1] |= 63;
1320 dbri->mm.data[2] &= ~15;
1321 dbri->mm.data[3] &= ~15;
1323 /* Start by setting the playback attenuation. */
1324 struct dbri_streaminfo *info = &dbri->stream_info[DBRI_PLAY];
1325 int left_gain = info->left_gain & 0x3f;
1326 int right_gain = info->right_gain & 0x3f;
1328 dbri->mm.data[0] &= ~0x3f; /* Reset the volume bits */
1329 dbri->mm.data[1] &= ~0x3f;
1330 dbri->mm.data[0] |= (DBRI_MAX_VOLUME - left_gain);
1331 dbri->mm.data[1] |= (DBRI_MAX_VOLUME - right_gain);
1333 /* Now set the recording gain. */
1334 info = &dbri->stream_info[DBRI_REC];
1335 left_gain = info->left_gain & 0xf;
1336 right_gain = info->right_gain & 0xf;
1337 dbri->mm.data[2] |= CS4215_LG(left_gain);
1338 dbri->mm.data[3] |= CS4215_RG(right_gain);
1341 xmit_fixed(dbri, 20, *(int *)dbri->mm.data);
1345 * Set the CS4215 to data mode.
1347 static void cs4215_open(struct snd_dbri * dbri)
1352 dprintk(D_MM, "cs4215_open: %d channels, %d bits\n",
1353 dbri->mm.channels, dbri->mm.precision);
1355 /* Temporarily mute outputs, and wait 1/8000 sec (125 us)
1356 * to make sure this takes. This avoids clicking noises.
1359 cs4215_setdata(dbri, 1);
1364 * Pipe 4: Send timeslots 1-4 (audio data)
1365 * Pipe 20: Send timeslots 5-8 (part of ctrl data)
1366 * Pipe 6: Receive timeslots 1-4 (audio data)
1367 * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via
1368 * interrupt, and the rest of the data (slot 5 and 8) is
1369 * not relevant for us (only for doublechecking).
1371 * Just like in control mode, the time slots are all offset by eight
1372 * bits. The CS4215, it seems, observes TSIN (the delayed signal)
1373 * even if it's the CHI master. Don't ask me...
1375 tmp = sbus_readl(dbri->regs + REG0);
1376 tmp &= ~(D_C); /* Disable CHI */
1377 sbus_writel(tmp, dbri->regs + REG0);
1379 /* Switch CS4215 to data mode - set PIO3 to 1 */
1380 sbus_writel(D_ENPIO | D_PIO1 | D_PIO3 |
1381 (dbri->mm.onboard ? D_PIO0 : D_PIO2), dbri->regs + REG2);
1383 reset_chi(dbri, CHIslave, 128);
1385 /* Note: this next doesn't work for 8-bit stereo, because the two
1386 * channels would be on timeslots 1 and 3, with 2 and 4 idle.
1387 * (See CS4215 datasheet Fig 15)
1389 * DBRI non-contiguous mode would be required to make this work.
1391 data_width = dbri->mm.channels * dbri->mm.precision;
1393 link_time_slot(dbri, 4, 16, 16, data_width, dbri->mm.offset);
1394 link_time_slot(dbri, 20, 4, 16, 32, dbri->mm.offset + 32);
1395 link_time_slot(dbri, 6, 16, 16, data_width, dbri->mm.offset);
1396 link_time_slot(dbri, 21, 6, 16, 16, dbri->mm.offset + 40);
1398 /* FIXME: enable CHI after _setdata? */
1399 tmp = sbus_readl(dbri->regs + REG0);
1400 tmp |= D_C; /* Enable CHI */
1401 sbus_writel(tmp, dbri->regs + REG0);
1403 cs4215_setdata(dbri, 0);
1407 * Send the control information (i.e. audio format)
1409 static int cs4215_setctrl(struct snd_dbri * dbri)
1414 /* FIXME - let the CPU do something useful during these delays */
1416 /* Temporarily mute outputs, and wait 1/8000 sec (125 us)
1417 * to make sure this takes. This avoids clicking noises.
1419 cs4215_setdata(dbri, 1);
1423 * Enable Control mode: Set DBRI's PIO3 (4215's D/~C) to 0, then wait
1424 * 12 cycles <= 12/(5512.5*64) sec = 34.01 usec
1426 val = D_ENPIO | D_PIO1 | (dbri->mm.onboard ? D_PIO0 : D_PIO2);
1427 sbus_writel(val, dbri->regs + REG2);
1428 dprintk(D_MM, "cs4215_setctrl: reg2=0x%x\n", val);
1431 /* In Control mode, the CS4215 is a slave device, so the DBRI must
1432 * operate as CHI master, supplying clocking and frame synchronization.
1434 * In Data mode, however, the CS4215 must be CHI master to insure
1435 * that its data stream is synchronous with its codec.
1437 * The upshot of all this? We start by putting the DBRI into master
1438 * mode, program the CS4215 in Control mode, then switch the CS4215
1439 * into Data mode and put the DBRI into slave mode. Various timing
1440 * requirements must be observed along the way.
1442 * Oh, and one more thing, on a SPARCStation 20 (and maybe
1443 * others?), the addressing of the CS4215's time slots is
1444 * offset by eight bits, so we add eight to all the "cycle"
1445 * values in the Define Time Slot (DTS) commands. This is
1446 * done in hardware by a TI 248 that delays the DBRI->4215
1447 * frame sync signal by eight clock cycles. Anybody know why?
1449 tmp = sbus_readl(dbri->regs + REG0);
1450 tmp &= ~D_C; /* Disable CHI */
1451 sbus_writel(tmp, dbri->regs + REG0);
1453 reset_chi(dbri, CHImaster, 128);
1457 * Pipe 17: Send timeslots 1-4 (slots 5-8 are readonly)
1458 * Pipe 18: Receive timeslot 1 (clb).
1459 * Pipe 19: Receive timeslot 7 (version).
1462 link_time_slot(dbri, 17, 16, 16, 32, dbri->mm.offset);
1463 link_time_slot(dbri, 18, 16, 16, 8, dbri->mm.offset);
1464 link_time_slot(dbri, 19, 18, 16, 8, dbri->mm.offset + 48);
1466 /* Wait for the chip to echo back CLB (Control Latch Bit) as zero */
1467 dbri->mm.ctrl[0] &= ~CS4215_CLB;
1468 xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl);
1470 tmp = sbus_readl(dbri->regs + REG0);
1471 tmp |= D_C; /* Enable CHI */
1472 sbus_writel(tmp, dbri->regs + REG0);
1474 for (i = 10; ((dbri->mm.status & 0xe4) != 0x20); --i) {
1475 msleep_interruptible(1);
1478 dprintk(D_MM, "CS4215 didn't respond to CLB (0x%02x)\n",
1483 /* Disable changes to our copy of the version number, as we are about
1484 * to leave control mode.
1486 recv_fixed(dbri, 19, NULL);
1488 /* Terminate CS4215 control mode - data sheet says
1489 * "Set CLB=1 and send two more frames of valid control info"
1491 dbri->mm.ctrl[0] |= CS4215_CLB;
1492 xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl);
1494 /* Two frames of control info @ 8kHz frame rate = 250 us delay */
1497 cs4215_setdata(dbri, 0);
1503 * Setup the codec with the sampling rate, audio format and number of
1505 * As part of the process we resend the settings for the data
1506 * timeslots as well.
1508 static int cs4215_prepare(struct snd_dbri * dbri, unsigned int rate,
1509 snd_pcm_format_t format, unsigned int channels)
1514 /* Lookup index for this rate */
1515 for (freq_idx = 0; CS4215_FREQ[freq_idx].freq != 0; freq_idx++) {
1516 if (CS4215_FREQ[freq_idx].freq == rate)
1519 if (CS4215_FREQ[freq_idx].freq != rate) {
1520 printk(KERN_WARNING "DBRI: Unsupported rate %d Hz\n", rate);
1525 case SNDRV_PCM_FORMAT_MU_LAW:
1526 dbri->mm.ctrl[1] = CS4215_DFR_ULAW;
1527 dbri->mm.precision = 8;
1529 case SNDRV_PCM_FORMAT_A_LAW:
1530 dbri->mm.ctrl[1] = CS4215_DFR_ALAW;
1531 dbri->mm.precision = 8;
1533 case SNDRV_PCM_FORMAT_U8:
1534 dbri->mm.ctrl[1] = CS4215_DFR_LINEAR8;
1535 dbri->mm.precision = 8;
1537 case SNDRV_PCM_FORMAT_S16_BE:
1538 dbri->mm.ctrl[1] = CS4215_DFR_LINEAR16;
1539 dbri->mm.precision = 16;
1542 printk(KERN_WARNING "DBRI: Unsupported format %d\n", format);
1546 /* Add rate parameters */
1547 dbri->mm.ctrl[1] |= CS4215_FREQ[freq_idx].csval;
1548 dbri->mm.ctrl[2] = CS4215_XCLK |
1549 CS4215_BSEL_128 | CS4215_FREQ[freq_idx].xtal;
1551 dbri->mm.channels = channels;
1552 /* Stereo bit: 8 bit stereo not working yet. */
1553 if ((channels > 1) && (dbri->mm.precision == 16))
1554 dbri->mm.ctrl[1] |= CS4215_DFR_STEREO;
1556 ret = cs4215_setctrl(dbri);
1558 cs4215_open(dbri); /* set codec to data mode */
1566 static int cs4215_init(struct snd_dbri * dbri)
1568 u32 reg2 = sbus_readl(dbri->regs + REG2);
1569 dprintk(D_MM, "cs4215_init: reg2=0x%x\n", reg2);
1571 /* Look for the cs4215 chips */
1572 if (reg2 & D_PIO2) {
1573 dprintk(D_MM, "Onboard CS4215 detected\n");
1574 dbri->mm.onboard = 1;
1576 if (reg2 & D_PIO0) {
1577 dprintk(D_MM, "Speakerbox detected\n");
1578 dbri->mm.onboard = 0;
1580 if (reg2 & D_PIO2) {
1581 printk(KERN_INFO "DBRI: Using speakerbox / "
1582 "ignoring onboard mmcodec.\n");
1583 sbus_writel(D_ENPIO2, dbri->regs + REG2);
1587 if (!(reg2 & (D_PIO0 | D_PIO2))) {
1588 printk(KERN_ERR "DBRI: no mmcodec found.\n");
1592 cs4215_setup_pipes(dbri);
1593 cs4215_init_data(&dbri->mm);
1595 /* Enable capture of the status & version timeslots. */
1596 recv_fixed(dbri, 18, &dbri->mm.status);
1597 recv_fixed(dbri, 19, &dbri->mm.version);
1599 dbri->mm.offset = dbri->mm.onboard ? 0 : 8;
1600 if (cs4215_setctrl(dbri) == -1 || dbri->mm.version == 0xff) {
1601 dprintk(D_MM, "CS4215 failed probe at offset %d\n",
1605 dprintk(D_MM, "Found CS4215 at offset %d\n", dbri->mm.offset);
1611 ****************************************************************************
1612 *************************** DBRI interrupt handler *************************
1613 ****************************************************************************
1615 The DBRI communicates with the CPU mainly via a circular interrupt
1616 buffer. When an interrupt is signaled, the CPU walks through the
1617 buffer and calls dbri_process_one_interrupt() for each interrupt word.
1618 Complicated interrupts are handled by dedicated functions (which
1619 appear first in this file). Any pending interrupts can be serviced by
1620 calling dbri_process_interrupt_buffer(), which works even if the CPU's
1621 interrupts are disabled.
1627 * Transmit the current TD's for recording/playing, if needed.
1628 * For playback, ALSA has filled the DMA memory with new data (we hope).
1630 static void xmit_descs(struct snd_dbri *dbri)
1632 struct dbri_streaminfo *info;
1634 unsigned long flags;
1638 return; /* Disabled */
1640 /* First check the recording stream for buffer overflow */
1641 info = &dbri->stream_info[DBRI_REC];
1642 spin_lock_irqsave(&dbri->lock, flags);
1644 if (info->pipe >= 0) {
1645 first_td = dbri->pipes[info->pipe].first_desc;
1647 dprintk(D_DESC, "xmit_descs rec @ TD %d\n", first_td);
1649 /* Stream could be closed by the time we run. */
1654 cmd = dbri_cmdlock(dbri, 2);
1655 *(cmd++) = DBRI_CMD(D_SDP, 0,
1656 dbri->pipes[info->pipe].sdp
1657 | D_SDP_P | D_SDP_EVERY | D_SDP_C);
1658 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, first_td);
1659 dbri_cmdsend(dbri, cmd, 2);
1661 /* Reset our admin of the pipe & bytes read. */
1662 dbri->pipes[info->pipe].desc = first_td;
1666 spin_unlock_irqrestore(&dbri->lock, flags);
1668 /* Now check the playback stream for buffer underflow */
1669 info = &dbri->stream_info[DBRI_PLAY];
1670 spin_lock_irqsave(&dbri->lock, flags);
1672 if (info->pipe >= 0) {
1673 first_td = dbri->pipes[info->pipe].first_desc;
1675 dprintk(D_DESC, "xmit_descs play @ TD %d\n", first_td);
1677 /* Stream could be closed by the time we run. */
1678 if (first_td >= 0) {
1679 cmd = dbri_cmdlock(dbri, 2);
1680 *(cmd++) = DBRI_CMD(D_SDP, 0,
1681 dbri->pipes[info->pipe].sdp
1682 | D_SDP_P | D_SDP_EVERY | D_SDP_C);
1683 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, first_td);
1684 dbri_cmdsend(dbri, cmd, 2);
1686 /* Reset our admin of the pipe & bytes written. */
1687 dbri->pipes[info->pipe].desc = first_td;
1690 spin_unlock_irqrestore(&dbri->lock, flags);
1693 /* transmission_complete_intr()
1695 * Called by main interrupt handler when DBRI signals transmission complete
1696 * on a pipe (interrupt triggered by the B bit in a transmit descriptor).
1698 * Walks through the pipe's list of transmit buffer descriptors and marks
1699 * them as available. Stops when the first descriptor is found without
1700 * TBC (Transmit Buffer Complete) set, or we've run through them all.
1702 * The DMA buffers are not released, but re-used. Since the transmit buffer
1703 * descriptors are not clobbered, they can be re-submitted as is. This is
1704 * done by the xmit_descs() tasklet above since that could take longer.
1707 static void transmission_complete_intr(struct snd_dbri * dbri, int pipe)
1709 struct dbri_streaminfo *info;
1713 info = &dbri->stream_info[DBRI_PLAY];
1715 td = dbri->pipes[pipe].desc;
1717 if (td >= DBRI_NO_DESCS) {
1718 printk(KERN_ERR "DBRI: invalid td on pipe %d\n", pipe);
1722 status = DBRI_TD_STATUS(dbri->dma->desc[td].word4);
1723 if (!(status & DBRI_TD_TBC)) {
1727 dprintk(D_INT, "TD %d, status 0x%02x\n", td, status);
1729 dbri->dma->desc[td].word4 = 0; /* Reset it for next time. */
1730 info->offset += DBRI_RD_CNT(dbri->dma->desc[td].word1);
1732 td = dbri->next_desc[td];
1733 dbri->pipes[pipe].desc = td;
1737 if (spin_is_locked(&dbri->lock)) {
1738 spin_unlock(&dbri->lock);
1739 snd_pcm_period_elapsed(info->substream);
1740 spin_lock(&dbri->lock);
1742 snd_pcm_period_elapsed(info->substream);
1745 static void reception_complete_intr(struct snd_dbri * dbri, int pipe)
1747 struct dbri_streaminfo *info;
1748 int rd = dbri->pipes[pipe].desc;
1751 if (rd < 0 || rd >= DBRI_NO_DESCS) {
1752 printk(KERN_ERR "DBRI: invalid rd on pipe %d\n", pipe);
1756 dbri->dma->desc[rd].ba = 0;
1757 dbri->pipes[pipe].desc = dbri->next_desc[rd];
1758 status = dbri->dma->desc[rd].word1;
1759 dbri->dma->desc[rd].word1 = 0; /* Reset it for next time. */
1761 info = &dbri->stream_info[DBRI_REC];
1762 info->offset += DBRI_RD_CNT(status);
1764 /* FIXME: Check status */
1766 dprintk(D_INT, "Recv RD %d, status 0x%02x, len %d\n",
1767 rd, DBRI_RD_STATUS(status), DBRI_RD_CNT(status));
1769 /* On the last TD, transmit them all again. */
1771 if (dbri->next_desc[rd] == -1) {
1772 if (info->left > info->size) {
1774 "%d bytes recorded in %d size buffer.\n",
1775 info->left, info->size);
1777 tasklet_schedule(&xmit_descs_task);
1782 if (spin_is_locked(&dbri->lock)) {
1783 spin_unlock(&dbri->lock);
1784 snd_pcm_period_elapsed(info->substream);
1785 spin_lock(&dbri->lock);
1787 snd_pcm_period_elapsed(info->substream);
1790 static void dbri_process_one_interrupt(struct snd_dbri * dbri, int x)
1792 int val = D_INTR_GETVAL(x);
1793 int channel = D_INTR_GETCHAN(x);
1794 int command = D_INTR_GETCMD(x);
1795 int code = D_INTR_GETCODE(x);
1797 int rval = D_INTR_GETRVAL(x);
1800 if (channel == D_INTR_CMD) {
1801 dprintk(D_CMD, "INTR: Command: %-5s Value:%d\n",
1802 cmds[command], val);
1804 dprintk(D_INT, "INTR: Chan:%d Code:%d Val:%#x\n",
1805 channel, code, rval);
1810 if (command != D_WAIT)
1811 printk(KERN_ERR "DBRI: Command read interrupt\n");
1814 reception_complete_intr(dbri, channel);
1818 transmission_complete_intr(dbri, channel);
1821 /* UNDR - Transmission underrun
1822 * resend SDP command with clear pipe bit (C) set
1825 /* FIXME: do something useful in case of underrun */
1826 printk(KERN_ERR "DBRI: Underrun error\n");
1830 int td = dbri->pipes[pipe].desc;
1832 dbri->dma->desc[td].word4 = 0;
1833 cmd = dbri_cmdlock(dbri, NoGetLock);
1834 *(cmd++) = DBRI_CMD(D_SDP, 0,
1835 dbri->pipes[pipe].sdp
1836 | D_SDP_P | D_SDP_C | D_SDP_2SAME);
1837 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, td);
1838 dbri_cmdsend(dbri, cmd);
1843 /* FXDT - Fixed data change */
1844 if (dbri->pipes[channel].sdp & D_SDP_MSB)
1845 val = reverse_bytes(val, dbri->pipes[channel].length);
1847 if (dbri->pipes[channel].recv_fixed_ptr)
1848 *(dbri->pipes[channel].recv_fixed_ptr) = val;
1851 if (channel != D_INTR_CMD)
1853 "DBRI: Ignored Interrupt: %d (0x%x)\n", code, x);
1857 /* dbri_process_interrupt_buffer advances through the DBRI's interrupt
1858 * buffer until it finds a zero word (indicating nothing more to do
1859 * right now). Non-zero words require processing and are handed off
1860 * to dbri_process_one_interrupt AFTER advancing the pointer.
1862 static void dbri_process_interrupt_buffer(struct snd_dbri * dbri)
1866 while ((x = dbri->dma->intr[dbri->dbri_irqp]) != 0) {
1867 dbri->dma->intr[dbri->dbri_irqp] = 0;
1869 if (dbri->dbri_irqp == DBRI_INT_BLK)
1870 dbri->dbri_irqp = 1;
1872 dbri_process_one_interrupt(dbri, x);
1876 static irqreturn_t snd_dbri_interrupt(int irq, void *dev_id,
1877 struct pt_regs *regs)
1879 struct snd_dbri *dbri = dev_id;
1880 static int errcnt = 0;
1885 spin_lock(&dbri->lock);
1888 * Read it, so the interrupt goes away.
1890 x = sbus_readl(dbri->regs + REG1);
1892 if (x & (D_MRR | D_MLE | D_LBG | D_MBE)) {
1897 "DBRI: Multiple Error Ack on SBus reg1=0x%x\n",
1901 "DBRI: Multiple Late Error on SBus reg1=0x%x\n",
1905 "DBRI: Lost Bus Grant on SBus reg1=0x%x\n", x);
1908 "DBRI: Burst Error on SBus reg1=0x%x\n", x);
1910 /* Some of these SBus errors cause the chip's SBus circuitry
1911 * to be disabled, so just re-enable and try to keep going.
1913 * The only one I've seen is MRR, which will be triggered
1914 * if you let a transmit pipe underrun, then try to CDP it.
1916 * If these things persist, we reset the chip.
1918 if ((++errcnt) % 10 == 0) {
1919 dprintk(D_INT, "Interrupt errors exceeded.\n");
1922 tmp = sbus_readl(dbri->regs + REG0);
1924 sbus_writel(tmp, dbri->regs + REG0);
1928 dbri_process_interrupt_buffer(dbri);
1930 spin_unlock(&dbri->lock);
1935 /****************************************************************************
1937 ****************************************************************************/
1938 static struct snd_pcm_hardware snd_dbri_pcm_hw = {
1939 .info = (SNDRV_PCM_INFO_MMAP |
1940 SNDRV_PCM_INFO_INTERLEAVED |
1941 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1942 SNDRV_PCM_INFO_MMAP_VALID),
1943 .formats = SNDRV_PCM_FMTBIT_MU_LAW |
1944 SNDRV_PCM_FMTBIT_A_LAW |
1945 SNDRV_PCM_FMTBIT_U8 |
1946 SNDRV_PCM_FMTBIT_S16_BE,
1947 .rates = SNDRV_PCM_RATE_8000_48000,
1952 .buffer_bytes_max = (64 * 1024),
1953 .period_bytes_min = 1,
1954 .period_bytes_max = DBRI_TD_MAXCNT,
1956 .periods_max = 1024,
1959 static int snd_dbri_open(struct snd_pcm_substream *substream)
1961 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
1962 struct snd_pcm_runtime *runtime = substream->runtime;
1963 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
1964 unsigned long flags;
1966 dprintk(D_USR, "open audio output.\n");
1967 runtime->hw = snd_dbri_pcm_hw;
1969 spin_lock_irqsave(&dbri->lock, flags);
1970 info->substream = substream;
1972 info->dvma_buffer = 0;
1974 spin_unlock_irqrestore(&dbri->lock, flags);
1981 static int snd_dbri_close(struct snd_pcm_substream *substream)
1983 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
1984 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
1986 dprintk(D_USR, "close audio output.\n");
1987 info->substream = NULL;
1993 static int snd_dbri_hw_params(struct snd_pcm_substream *substream,
1994 struct snd_pcm_hw_params *hw_params)
1996 struct snd_pcm_runtime *runtime = substream->runtime;
1997 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
1998 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
2002 /* set sampling rate, audio format and number of channels */
2003 ret = cs4215_prepare(dbri, params_rate(hw_params),
2004 params_format(hw_params),
2005 params_channels(hw_params));
2009 if ((ret = snd_pcm_lib_malloc_pages(substream,
2010 params_buffer_bytes(hw_params))) < 0) {
2011 printk(KERN_ERR "malloc_pages failed with %d\n", ret);
2015 /* hw_params can get called multiple times. Only map the DMA once.
2017 if (info->dvma_buffer == 0) {
2018 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2019 direction = SBUS_DMA_TODEVICE;
2021 direction = SBUS_DMA_FROMDEVICE;
2023 info->dvma_buffer = sbus_map_single(dbri->sdev,
2025 params_buffer_bytes(hw_params),
2029 direction = params_buffer_bytes(hw_params);
2030 dprintk(D_USR, "hw_params: %d bytes, dvma=%x\n",
2031 direction, info->dvma_buffer);
2035 static int snd_dbri_hw_free(struct snd_pcm_substream *substream)
2037 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
2038 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
2040 dprintk(D_USR, "hw_free.\n");
2042 /* hw_free can get called multiple times. Only unmap the DMA once.
2044 if (info->dvma_buffer) {
2045 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2046 direction = SBUS_DMA_TODEVICE;
2048 direction = SBUS_DMA_FROMDEVICE;
2050 sbus_unmap_single(dbri->sdev, info->dvma_buffer,
2051 substream->runtime->buffer_size, direction);
2052 info->dvma_buffer = 0;
2056 return snd_pcm_lib_free_pages(substream);
2059 static int snd_dbri_prepare(struct snd_pcm_substream *substream)
2061 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
2062 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
2063 struct snd_pcm_runtime *runtime = substream->runtime;
2066 info->size = snd_pcm_lib_buffer_bytes(substream);
2067 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2068 info->pipe = 4; /* Send pipe */
2070 info->pipe = 6; /* Receive pipe */
2072 spin_lock_irq(&dbri->lock);
2074 /* Setup the all the transmit/receive desciptors to cover the
2077 ret = setup_descs(dbri, DBRI_STREAMNO(substream),
2078 snd_pcm_lib_period_bytes(substream));
2080 runtime->stop_threshold = DBRI_TD_MAXCNT / runtime->channels;
2082 spin_unlock_irq(&dbri->lock);
2084 dprintk(D_USR, "prepare audio output. %d bytes\n", info->size);
2088 static int snd_dbri_trigger(struct snd_pcm_substream *substream, int cmd)
2090 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
2091 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
2095 case SNDRV_PCM_TRIGGER_START:
2096 dprintk(D_USR, "start audio, period is %d bytes\n",
2097 (int)snd_pcm_lib_period_bytes(substream));
2098 /* Re-submit the TDs. */
2101 case SNDRV_PCM_TRIGGER_STOP:
2102 dprintk(D_USR, "stop audio.\n");
2103 reset_pipe(dbri, info->pipe);
2112 static snd_pcm_uframes_t snd_dbri_pointer(struct snd_pcm_substream *substream)
2114 struct snd_dbri *dbri = snd_pcm_substream_chip(substream);
2115 struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream);
2116 snd_pcm_uframes_t ret;
2118 ret = bytes_to_frames(substream->runtime, info->offset)
2119 % substream->runtime->buffer_size;
2120 dprintk(D_USR, "I/O pointer: %ld frames of %ld.\n",
2121 ret, substream->runtime->buffer_size);
2125 static struct snd_pcm_ops snd_dbri_ops = {
2126 .open = snd_dbri_open,
2127 .close = snd_dbri_close,
2128 .ioctl = snd_pcm_lib_ioctl,
2129 .hw_params = snd_dbri_hw_params,
2130 .hw_free = snd_dbri_hw_free,
2131 .prepare = snd_dbri_prepare,
2132 .trigger = snd_dbri_trigger,
2133 .pointer = snd_dbri_pointer,
2136 static int __devinit snd_dbri_pcm(struct snd_dbri * dbri)
2138 struct snd_pcm *pcm;
2141 if ((err = snd_pcm_new(dbri->card,
2142 /* ID */ "sun_dbri",
2144 /* playback count */ 1,
2145 /* capture count */ 1, &pcm)) < 0)
2147 snd_assert(pcm != NULL, return -EINVAL);
2149 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_dbri_ops);
2150 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_dbri_ops);
2152 pcm->private_data = dbri;
2153 pcm->info_flags = 0;
2154 strcpy(pcm->name, dbri->card->shortname);
2156 if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm,
2157 SNDRV_DMA_TYPE_CONTINUOUS,
2158 snd_dma_continuous_data(GFP_KERNEL),
2159 64 * 1024, 64 * 1024)) < 0) {
2166 /*****************************************************************************
2168 *****************************************************************************/
2170 static int snd_cs4215_info_volume(struct snd_kcontrol *kcontrol,
2171 struct snd_ctl_elem_info *uinfo)
2173 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2175 uinfo->value.integer.min = 0;
2176 if (kcontrol->private_value == DBRI_PLAY) {
2177 uinfo->value.integer.max = DBRI_MAX_VOLUME;
2179 uinfo->value.integer.max = DBRI_MAX_GAIN;
2184 static int snd_cs4215_get_volume(struct snd_kcontrol *kcontrol,
2185 struct snd_ctl_elem_value *ucontrol)
2187 struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol);
2188 struct dbri_streaminfo *info;
2189 snd_assert(dbri != NULL, return -EINVAL);
2190 info = &dbri->stream_info[kcontrol->private_value];
2191 snd_assert(info != NULL, return -EINVAL);
2193 ucontrol->value.integer.value[0] = info->left_gain;
2194 ucontrol->value.integer.value[1] = info->right_gain;
2198 static int snd_cs4215_put_volume(struct snd_kcontrol *kcontrol,
2199 struct snd_ctl_elem_value *ucontrol)
2201 struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol);
2202 struct dbri_streaminfo *info = &dbri->stream_info[kcontrol->private_value];
2203 unsigned long flags;
2206 if (info->left_gain != ucontrol->value.integer.value[0]) {
2207 info->left_gain = ucontrol->value.integer.value[0];
2210 if (info->right_gain != ucontrol->value.integer.value[1]) {
2211 info->right_gain = ucontrol->value.integer.value[1];
2215 /* First mute outputs, and wait 1/8000 sec (125 us)
2216 * to make sure this takes. This avoids clicking noises.
2218 spin_lock_irqsave(&dbri->lock, flags);
2220 cs4215_setdata(dbri, 1);
2222 cs4215_setdata(dbri, 0);
2224 spin_unlock_irqrestore(&dbri->lock, flags);
2229 static int snd_cs4215_info_single(struct snd_kcontrol *kcontrol,
2230 struct snd_ctl_elem_info *uinfo)
2232 int mask = (kcontrol->private_value >> 16) & 0xff;
2234 uinfo->type = (mask == 1) ?
2235 SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2237 uinfo->value.integer.min = 0;
2238 uinfo->value.integer.max = mask;
2242 static int snd_cs4215_get_single(struct snd_kcontrol *kcontrol,
2243 struct snd_ctl_elem_value *ucontrol)
2245 struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol);
2246 int elem = kcontrol->private_value & 0xff;
2247 int shift = (kcontrol->private_value >> 8) & 0xff;
2248 int mask = (kcontrol->private_value >> 16) & 0xff;
2249 int invert = (kcontrol->private_value >> 24) & 1;
2250 snd_assert(dbri != NULL, return -EINVAL);
2253 ucontrol->value.integer.value[0] =
2254 (dbri->mm.data[elem] >> shift) & mask;
2256 ucontrol->value.integer.value[0] =
2257 (dbri->mm.ctrl[elem - 4] >> shift) & mask;
2261 ucontrol->value.integer.value[0] =
2262 mask - ucontrol->value.integer.value[0];
2267 static int snd_cs4215_put_single(struct snd_kcontrol *kcontrol,
2268 struct snd_ctl_elem_value *ucontrol)
2270 struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol);
2271 unsigned long flags;
2272 int elem = kcontrol->private_value & 0xff;
2273 int shift = (kcontrol->private_value >> 8) & 0xff;
2274 int mask = (kcontrol->private_value >> 16) & 0xff;
2275 int invert = (kcontrol->private_value >> 24) & 1;
2278 snd_assert(dbri != NULL, return -EINVAL);
2280 val = (ucontrol->value.integer.value[0] & mask);
2286 dbri->mm.data[elem] = (dbri->mm.data[elem] &
2287 ~(mask << shift)) | val;
2288 changed = (val != dbri->mm.data[elem]);
2290 dbri->mm.ctrl[elem - 4] = (dbri->mm.ctrl[elem - 4] &
2291 ~(mask << shift)) | val;
2292 changed = (val != dbri->mm.ctrl[elem - 4]);
2295 dprintk(D_GEN, "put_single: mask=0x%x, changed=%d, "
2296 "mixer-value=%ld, mm-value=0x%x\n",
2297 mask, changed, ucontrol->value.integer.value[0],
2298 dbri->mm.data[elem & 3]);
2301 /* First mute outputs, and wait 1/8000 sec (125 us)
2302 * to make sure this takes. This avoids clicking noises.
2304 spin_lock_irqsave(&dbri->lock, flags);
2306 cs4215_setdata(dbri, 1);
2308 cs4215_setdata(dbri, 0);
2310 spin_unlock_irqrestore(&dbri->lock, flags);
2315 /* Entries 0-3 map to the 4 data timeslots, entries 4-7 map to the 4 control
2316 timeslots. Shift is the bit offset in the timeslot, mask defines the
2317 number of bits. invert is a boolean for use with attenuation.
2319 #define CS4215_SINGLE(xname, entry, shift, mask, invert) \
2320 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
2321 .info = snd_cs4215_info_single, \
2322 .get = snd_cs4215_get_single, .put = snd_cs4215_put_single, \
2323 .private_value = entry | (shift << 8) | (mask << 16) | (invert << 24) },
2325 static struct snd_kcontrol_new dbri_controls[] __devinitdata = {
2327 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2328 .name = "Playback Volume",
2329 .info = snd_cs4215_info_volume,
2330 .get = snd_cs4215_get_volume,
2331 .put = snd_cs4215_put_volume,
2332 .private_value = DBRI_PLAY,
2334 CS4215_SINGLE("Headphone switch", 0, 7, 1, 0)
2335 CS4215_SINGLE("Line out switch", 0, 6, 1, 0)
2336 CS4215_SINGLE("Speaker switch", 1, 6, 1, 0)
2338 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2339 .name = "Capture Volume",
2340 .info = snd_cs4215_info_volume,
2341 .get = snd_cs4215_get_volume,
2342 .put = snd_cs4215_put_volume,
2343 .private_value = DBRI_REC,
2345 /* FIXME: mic/line switch */
2346 CS4215_SINGLE("Line in switch", 2, 4, 1, 0)
2347 CS4215_SINGLE("High Pass Filter switch", 5, 7, 1, 0)
2348 CS4215_SINGLE("Monitor Volume", 3, 4, 0xf, 1)
2349 CS4215_SINGLE("Mic boost", 4, 4, 1, 1)
2352 #define NUM_CS4215_CONTROLS (sizeof(dbri_controls)/sizeof(struct snd_kcontrol_new))
2354 static int __init snd_dbri_mixer(struct snd_dbri * dbri)
2356 struct snd_card *card;
2359 snd_assert(dbri != NULL && dbri->card != NULL, return -EINVAL);
2362 strcpy(card->mixername, card->shortname);
2364 for (idx = 0; idx < NUM_CS4215_CONTROLS; idx++) {
2365 if ((err = snd_ctl_add(card,
2366 snd_ctl_new1(&dbri_controls[idx], dbri))) < 0)
2370 for (idx = DBRI_REC; idx < DBRI_NO_STREAMS; idx++) {
2371 dbri->stream_info[idx].left_gain = 0;
2372 dbri->stream_info[idx].right_gain = 0;
2378 /****************************************************************************
2380 ****************************************************************************/
2381 static void dbri_regs_read(struct snd_info_entry * entry, struct snd_info_buffer *buffer)
2383 struct snd_dbri *dbri = entry->private_data;
2385 snd_iprintf(buffer, "REG0: 0x%x\n", sbus_readl(dbri->regs + REG0));
2386 snd_iprintf(buffer, "REG2: 0x%x\n", sbus_readl(dbri->regs + REG2));
2387 snd_iprintf(buffer, "REG8: 0x%x\n", sbus_readl(dbri->regs + REG8));
2388 snd_iprintf(buffer, "REG9: 0x%x\n", sbus_readl(dbri->regs + REG9));
2392 static void dbri_debug_read(struct snd_info_entry * entry,
2393 struct snd_info_buffer *buffer)
2395 struct snd_dbri *dbri = entry->private_data;
2397 snd_iprintf(buffer, "debug=%d\n", dbri_debug);
2399 for (pipe = 0; pipe < 32; pipe++) {
2400 if (pipe_active(dbri, pipe)) {
2401 struct dbri_pipe *pptr = &dbri->pipes[pipe];
2403 "Pipe %d: %s SDP=0x%x desc=%d, "
2406 ((pptr->sdp & D_SDP_TO_SER) ? "output" : "input"),
2407 pptr->sdp, pptr->desc,
2408 pptr->length, pptr->nextpipe);
2414 void snd_dbri_proc(struct snd_dbri * dbri)
2416 struct snd_info_entry *entry;
2418 if (! snd_card_proc_new(dbri->card, "regs", &entry))
2419 snd_info_set_text_ops(entry, dbri, dbri_regs_read);
2422 if (! snd_card_proc_new(dbri->card, "debug", &entry)) {
2423 snd_info_set_text_ops(entry, dbri, dbri_debug_read);
2424 entry->mode = S_IFREG | S_IRUGO; /* Readable only. */
2430 ****************************************************************************
2431 **************************** Initialization ********************************
2432 ****************************************************************************
2434 static void snd_dbri_free(struct snd_dbri * dbri);
2436 static int __init snd_dbri_create(struct snd_card *card,
2437 struct sbus_dev *sdev,
2438 struct linux_prom_irqs *irq, int dev)
2440 struct snd_dbri *dbri = card->private_data;
2443 spin_lock_init(&dbri->lock);
2446 dbri->irq = irq->pri;
2448 dbri->dma = sbus_alloc_consistent(sdev, sizeof(struct dbri_dma),
2450 memset((void *)dbri->dma, 0, sizeof(struct dbri_dma));
2452 dprintk(D_GEN, "DMA Cmd Block 0x%p (0x%08x)\n",
2453 dbri->dma, dbri->dma_dvma);
2455 /* Map the registers into memory. */
2456 dbri->regs_size = sdev->reg_addrs[0].reg_size;
2457 dbri->regs = sbus_ioremap(&sdev->resource[0], 0,
2458 dbri->regs_size, "DBRI Registers");
2460 printk(KERN_ERR "DBRI: could not allocate registers\n");
2461 sbus_free_consistent(sdev, sizeof(struct dbri_dma),
2462 (void *)dbri->dma, dbri->dma_dvma);
2466 err = request_irq(dbri->irq, snd_dbri_interrupt, IRQF_SHARED,
2467 "DBRI audio", dbri);
2469 printk(KERN_ERR "DBRI: Can't get irq %d\n", dbri->irq);
2470 sbus_iounmap(dbri->regs, dbri->regs_size);
2471 sbus_free_consistent(sdev, sizeof(struct dbri_dma),
2472 (void *)dbri->dma, dbri->dma_dvma);
2476 /* Do low level initialization of the DBRI and CS4215 chips */
2477 dbri_initialize(dbri);
2478 err = cs4215_init(dbri);
2480 snd_dbri_free(dbri);
2484 dbri->next = dbri_list;
2490 static void snd_dbri_free(struct snd_dbri * dbri)
2492 dprintk(D_GEN, "snd_dbri_free\n");
2496 free_irq(dbri->irq, dbri);
2499 sbus_iounmap(dbri->regs, dbri->regs_size);
2502 sbus_free_consistent(dbri->sdev, sizeof(struct dbri_dma),
2503 (void *)dbri->dma, dbri->dma_dvma);
2506 static int __init dbri_attach(int prom_node, struct sbus_dev *sdev)
2508 struct snd_dbri *dbri;
2509 struct linux_prom_irqs irq;
2510 struct resource *rp;
2511 struct snd_card *card;
2515 if (sdev->prom_name[9] < 'e') {
2516 printk(KERN_ERR "DBRI: unsupported chip version %c found.\n",
2517 sdev->prom_name[9]);
2521 if (dev >= SNDRV_CARDS)
2528 err = prom_getproperty(prom_node, "intr", (char *)&irq, sizeof(irq));
2530 printk(KERN_ERR "DBRI-%d: Firmware node lacks IRQ property.\n", dev);
2534 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
2535 sizeof(struct snd_dbri));
2539 strcpy(card->driver, "DBRI");
2540 strcpy(card->shortname, "Sun DBRI");
2541 rp = &sdev->resource[0];
2542 sprintf(card->longname, "%s at 0x%02lx:0x%016Lx, irq %d",
2544 rp->flags & 0xffL, (unsigned long long)rp->start, irq.pri);
2546 if ((err = snd_dbri_create(card, sdev, &irq, dev)) < 0) {
2547 snd_card_free(card);
2551 dbri = card->private_data;
2552 if ((err = snd_dbri_pcm(dbri)) < 0)
2555 if ((err = snd_dbri_mixer(dbri)) < 0)
2558 /* /proc file handling */
2559 snd_dbri_proc(dbri);
2561 if ((err = snd_card_register(card)) < 0)
2564 printk(KERN_INFO "audio%d at %p (irq %d) is DBRI(%c)+CS4215(%d)\n",
2566 dbri->irq, sdev->prom_name[9], dbri->mm.version);
2572 snd_dbri_free(dbri);
2573 snd_card_free(card);
2577 /* Probe for the dbri chip and then attach the driver. */
2578 static int __init dbri_init(void)
2580 struct sbus_bus *sbus;
2581 struct sbus_dev *sdev;
2584 /* Probe each SBUS for the DBRI chip(s). */
2585 for_all_sbusdev(sdev, sbus) {
2587 * The version is coded in the last character
2589 if (!strncmp(sdev->prom_name, "SUNW,DBRI", 9)) {
2590 dprintk(D_GEN, "DBRI: Found %s in SBUS slot %d\n",
2591 sdev->prom_name, sdev->slot);
2593 if (dbri_attach(sdev->prom_node, sdev) == 0)
2598 return (found > 0) ? 0 : -EIO;
2601 static void __exit dbri_exit(void)
2603 struct snd_dbri *this = dbri_list;
2605 while (this != NULL) {
2606 struct snd_dbri *next = this->next;
2607 struct snd_card *card = this->card;
2609 snd_dbri_free(this);
2610 snd_card_free(card);
2616 module_init(dbri_init);
2617 module_exit(dbri_exit);