projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge refs/heads/devtree from rsync://oak/kernels/iseries/work/.git
[deliverable/linux.git] / sound / sparc / dbri.c
1 /*
2 * Driver for DBRI sound chip found on Sparcs.
3 * Copyright (C) 2004, 2005 Martin Habets (mhabets@users.sourceforge.net)
4 *
5 * Based entirely upon drivers/sbus/audio/dbri.c which is:
6 * Copyright (C) 1997 Rudolf Koenig (rfkoenig@immd4.informatik.uni-erlangen.de)
7 * Copyright (C) 1998, 1999 Brent Baccala (baccala@freesoft.org)
8 *
9 * This is the lowlevel driver for the DBRI & MMCODEC duo used for ISDN & AUDIO
10 * on Sun SPARCstation 10, 20, LX and Voyager models.
11 *
12 * - DBRI: AT&T T5900FX Dual Basic Rates ISDN Interface. It is a 32 channel
13 * data time multiplexer with ISDN support (aka T7259)
14 * Interfaces: SBus,ISDN NT & TE, CHI, 4 bits parallel.
15 * CHI: (spelled ki) Concentration Highway Interface (AT&T or Intel bus ?).
16 * Documentation:
17 * - "STP 4000SBus Dual Basic Rate ISDN (DBRI) Tranceiver" from
18 * Sparc Technology Business (courtesy of Sun Support)
19 * - Data sheet of the T7903, a newer but very similar ISA bus equivalent
20 * available from the Lucent (formarly AT&T microelectronics) home
21 * page.
22 * - http://www.freesoft.org/Linux/DBRI/
23 * - MMCODEC: Crystal Semiconductor CS4215 16 bit Multimedia Audio Codec
24 * Interfaces: CHI, Audio In & Out, 2 bits parallel
25 * Documentation: from the Crystal Semiconductor home page.
26 *
27 * The DBRI is a 32 pipe machine, each pipe can transfer some bits between
28 * memory and a serial device (long pipes, nr 0-15) or between two serial
29 * devices (short pipes, nr 16-31), or simply send a fixed data to a serial
30 * device (short pipes).
31 * A timeslot defines the bit-offset and nr of bits read from a serial device.
32 * The timeslots are linked to 6 circular lists, one for each direction for
33 * each serial device (NT,TE,CHI). A timeslot is associated to 1 or 2 pipes
34 * (the second one is a monitor/tee pipe, valid only for serial input).
35 *
36 * The mmcodec is connected via the CHI bus and needs the data & some
37 * parameters (volume, balance, output selection) timemultiplexed in 8 byte
38 * chunks. It also has a control mode, which serves for audio format setting.
39 *
40 * Looking at the CS4215 data sheet it is easy to set up 2 or 4 codecs on
41 * the same CHI bus, so I thought perhaps it is possible to use the onboard
42 * & the speakerbox codec simultanously, giving 2 (not very independent :-)
43 * audio devices. But the SUN HW group decided against it, at least on my
44 * LX the speakerbox connector has at least 1 pin missing and 1 wrongly
45 * connected.
46 *
47 * I've tried to stick to the following function naming conventions:
48 * snd_* ALSA stuff
49 * cs4215_* CS4215 codec specfic stuff
50 * dbri_* DBRI high-level stuff
51 * other DBRI low-level stuff
52 */
53
54 #include <sound/driver.h>
55 #include <linux/interrupt.h>
56 #include <linux/delay.h>
57
58 #include <sound/core.h>
59 #include <sound/pcm.h>
60 #include <sound/pcm_params.h>
61 #include <sound/info.h>
62 #include <sound/control.h>
63 #include <sound/initval.h>
64
65 #include <asm/irq.h>
66 #include <asm/io.h>
67 #include <asm/sbus.h>
68 #include <asm/atomic.h>
69
70 MODULE_AUTHOR("Rudolf Koenig, Brent Baccala and Martin Habets");
71 MODULE_DESCRIPTION("Sun DBRI");
72 MODULE_LICENSE("GPL");
73 MODULE_SUPPORTED_DEVICE("{{Sun,DBRI}}");
74
75 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
76 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
77 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
78
79 module_param_array(index, int, NULL, 0444);
80 MODULE_PARM_DESC(index, "Index value for Sun DBRI soundcard.");
81 module_param_array(id, charp, NULL, 0444);
82 MODULE_PARM_DESC(id, "ID string for Sun DBRI soundcard.");
83 module_param_array(enable, bool, NULL, 0444);
84 MODULE_PARM_DESC(enable, "Enable Sun DBRI soundcard.");
85
86 #define DBRI_DEBUG
87
88 #define D_INT (1<<0)
89 #define D_GEN (1<<1)
90 #define D_CMD (1<<2)
91 #define D_MM (1<<3)
92 #define D_USR (1<<4)
93 #define D_DESC (1<<5)
94
95 static int dbri_debug = 0;
96 module_param(dbri_debug, int, 0644);
97 MODULE_PARM_DESC(dbri_debug, "Debug value for Sun DBRI soundcard.");
98
99 #ifdef DBRI_DEBUG
100 static char *cmds[] = {
101 "WAIT", "PAUSE", "JUMP", "IIQ", "REX", "SDP", "CDP", "DTS",
102 "SSP", "CHI", "NT", "TE", "CDEC", "TEST", "CDM", "RESRV"
103 };
104
105 #define dprintk(a, x...) if(dbri_debug & a) printk(KERN_DEBUG x)
106
107 #define DBRI_CMD(cmd, intr, value) ((cmd << 28) | \
108 (1 << 27) | \
109 value)
110 #else
111 #define dprintk(a, x...)
112
113 #define DBRI_CMD(cmd, intr, value) ((cmd << 28) | \
114 (intr << 27) | \
115 value)
116 #endif /* DBRI_DEBUG */
117
118 /***************************************************************************
119 CS4215 specific definitions and structures
120 ****************************************************************************/
121
122 struct cs4215 {
123 __u8 data[4]; /* Data mode: Time slots 5-8 */
124 __u8 ctrl[4]; /* Ctrl mode: Time slots 1-4 */
125 __u8 onboard;
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 */
131 };
132
133 /*
134 * Control mode first
135 */
136
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)
143
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)
150 static struct {
151 unsigned short freq;
152 unsigned char xtal;
153 unsigned char csval;
154 } CS4215_FREQ[] = {
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) },
171 { 0, 0, 0}
172 };
173
174 #define CS4215_HPF (1<<7) /* High Pass Filter, 1: Enabled */
175
176 #define CS4215_12_MASK 0xfcbf /* Mask off reserved bits in slot 1 & 2 */
177
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 */
189
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 */
193
194 /* Time Slot 5, Parallel Port Register */
195 /* Read only here and the same as the in data mode */
196
197 /* Time Slot 6, Reserved */
198
199 /* Time Slot 7, Version Register */
200 #define CS4215_VERSION_MASK 0xf /* Known versions 0/C, 1/D, 2/E */
201
202 /* Time Slot 8, Reserved */
203
204 /*
205 * Data mode
206 */
207 /* Time Slot 1-2: Left Channel Data, 2-3: Right Channel Data */
208
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 */
213
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 */
218
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)
225
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 */
229
230 /***************************************************************************
231 DBRI specific definitions and structures
232 ****************************************************************************/
233
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 */
241
242 #define DBRI_NO_CMDS 64
243 #define DBRI_NO_INTS 1 /* Note: the value of this define was
244 * originally 2. The ringbuffer to store
245 * interrupts in dma is currently broken.
246 * This is a temporary fix until the ringbuffer
247 * is fixed.
248 */
249 #define DBRI_INT_BLK 64
250 #define DBRI_NO_DESCS 64
251 #define DBRI_NO_PIPES 32
252
253 #define DBRI_MM_ONB 1
254 #define DBRI_MM_SB 2
255
256 #define DBRI_REC 0
257 #define DBRI_PLAY 1
258 #define DBRI_NO_STREAMS 2
259
260 /* One transmit/receive descriptor */
261 struct dbri_mem {
262 volatile __u32 word1;
263 volatile __u32 ba; /* Transmit/Receive Buffer Address */
264 volatile __u32 nda; /* Next Descriptor Address */
265 volatile __u32 word4;
266 };
267
268 /* This structure is in a DMA region where it can accessed by both
269 * the CPU and the DBRI
270 */
271 struct dbri_dma {
272 volatile s32 cmd[DBRI_NO_CMDS]; /* Place for commands */
273 volatile s32 intr[DBRI_NO_INTS * DBRI_INT_BLK]; /* Interrupt field */
274 struct dbri_mem desc[DBRI_NO_DESCS]; /* Xmit/receive descriptors */
275 };
276
277 #define dbri_dma_off(member, elem) \
278 ((u32)(unsigned long) \
279 (&(((struct dbri_dma *)0)->member[elem])))
280
281 enum in_or_out { PIPEinput, PIPEoutput };
282
283 struct dbri_pipe {
284 u32 sdp; /* SDP command word */
285 enum in_or_out direction;
286 int nextpipe; /* Next pipe in linked list */
287 int prevpipe;
288 int cycle; /* Offset of timeslot (bits) */
289 int length; /* Length of timeslot (bits) */
290 int first_desc; /* Index of first descriptor */
291 int desc; /* Index of active descriptor */
292 volatile __u32 *recv_fixed_ptr; /* Ptr to receive fixed data */
293 };
294
295 struct dbri_desc {
296 int inuse; /* Boolean flag */
297 int next; /* Index of next desc, or -1 */
298 unsigned int len;
299 };
300
301 /* Per stream (playback or record) information */
302 typedef struct dbri_streaminfo {
303 snd_pcm_substream_t *substream;
304 u32 dvma_buffer; /* Device view of Alsa DMA buffer */
305 int left; /* # of bytes left in DMA buffer */
306 int size; /* Size of DMA buffer */
307 size_t offset; /* offset in user buffer */
308 int pipe; /* Data pipe used */
309 int left_gain; /* mixer elements */
310 int right_gain;
311 int balance;
312 } dbri_streaminfo_t;
313
314 /* This structure holds the information for both chips (DBRI & CS4215) */
315 typedef struct snd_dbri {
316 snd_card_t *card; /* ALSA card */
317 snd_pcm_t *pcm;
318
319 int regs_size, irq; /* Needed for unload */
320 struct sbus_dev *sdev; /* SBUS device info */
321 spinlock_t lock;
322
323 volatile struct dbri_dma *dma; /* Pointer to our DMA block */
324 u32 dma_dvma; /* DBRI visible DMA address */
325
326 void __iomem *regs; /* dbri HW regs */
327 int dbri_version; /* 'e' and up is OK */
328 int dbri_irqp; /* intr queue pointer */
329 int wait_send; /* sequence of command buffers send */
330 int wait_ackd; /* sequence of command buffers acknowledged */
331
332 struct dbri_pipe pipes[DBRI_NO_PIPES]; /* DBRI's 32 data pipes */
333 struct dbri_desc descs[DBRI_NO_DESCS];
334
335 int chi_in_pipe;
336 int chi_out_pipe;
337 int chi_bpf;
338
339 struct cs4215 mm; /* mmcodec special info */
340 /* per stream (playback/record) info */
341 struct dbri_streaminfo stream_info[DBRI_NO_STREAMS];
342
343 struct snd_dbri *next;
344 } snd_dbri_t;
345
346 /* Needed for the ALSA macros to work */
347 #define chip_t snd_dbri_t
348
349 #define DBRI_MAX_VOLUME 63 /* Output volume */
350 #define DBRI_MAX_GAIN 15 /* Input gain */
351 #define DBRI_RIGHT_BALANCE 255
352 #define DBRI_MID_BALANCE (DBRI_RIGHT_BALANCE >> 1)
353
354 /* DBRI Reg0 - Status Control Register - defines. (Page 17) */
355 #define D_P (1<<15) /* Program command & queue pointer valid */
356 #define D_G (1<<14) /* Allow 4-Word SBus Burst */
357 #define D_S (1<<13) /* Allow 16-Word SBus Burst */
358 #define D_E (1<<12) /* Allow 8-Word SBus Burst */
359 #define D_X (1<<7) /* Sanity Timer Disable */
360 #define D_T (1<<6) /* Permit activation of the TE interface */
361 #define D_N (1<<5) /* Permit activation of the NT interface */
362 #define D_C (1<<4) /* Permit activation of the CHI interface */
363 #define D_F (1<<3) /* Force Sanity Timer Time-Out */
364 #define D_D (1<<2) /* Disable Master Mode */
365 #define D_H (1<<1) /* Halt for Analysis */
366 #define D_R (1<<0) /* Soft Reset */
367
368 /* DBRI Reg1 - Mode and Interrupt Register - defines. (Page 18) */
369 #define D_LITTLE_END (1<<8) /* Byte Order */
370 #define D_BIG_END (0<<8) /* Byte Order */
371 #define D_MRR (1<<4) /* Multiple Error Ack on SBus (readonly) */
372 #define D_MLE (1<<3) /* Multiple Late Error on SBus (readonly) */
373 #define D_LBG (1<<2) /* Lost Bus Grant on SBus (readonly) */
374 #define D_MBE (1<<1) /* Burst Error on SBus (readonly) */
375 #define D_IR (1<<0) /* Interrupt Indicator (readonly) */
376
377 /* DBRI Reg2 - Parallel IO Register - defines. (Page 18) */
378 #define D_ENPIO3 (1<<7) /* Enable Pin 3 */
379 #define D_ENPIO2 (1<<6) /* Enable Pin 2 */
380 #define D_ENPIO1 (1<<5) /* Enable Pin 1 */
381 #define D_ENPIO0 (1<<4) /* Enable Pin 0 */
382 #define D_ENPIO (0xf0) /* Enable all the pins */
383 #define D_PIO3 (1<<3) /* Pin 3: 1: Data mode, 0: Ctrl mode */
384 #define D_PIO2 (1<<2) /* Pin 2: 1: Onboard PDN */
385 #define D_PIO1 (1<<1) /* Pin 1: 0: Reset */
386 #define D_PIO0 (1<<0) /* Pin 0: 1: Speakerbox PDN */
387
388 /* DBRI Commands (Page 20) */
389 #define D_WAIT 0x0 /* Stop execution */
390 #define D_PAUSE 0x1 /* Flush long pipes */
391 #define D_JUMP 0x2 /* New command queue */
392 #define D_IIQ 0x3 /* Initialize Interrupt Queue */
393 #define D_REX 0x4 /* Report command execution via interrupt */
394 #define D_SDP 0x5 /* Setup Data Pipe */
395 #define D_CDP 0x6 /* Continue Data Pipe (reread NULL Pointer) */
396 #define D_DTS 0x7 /* Define Time Slot */
397 #define D_SSP 0x8 /* Set short Data Pipe */
398 #define D_CHI 0x9 /* Set CHI Global Mode */
399 #define D_NT 0xa /* NT Command */
400 #define D_TE 0xb /* TE Command */
401 #define D_CDEC 0xc /* Codec setup */
402 #define D_TEST 0xd /* No comment */
403 #define D_CDM 0xe /* CHI Data mode command */
404
405 /* Special bits for some commands */
406 #define D_PIPE(v) ((v)<<0) /* Pipe Nr: 0-15 long, 16-21 short */
407
408 /* Setup Data Pipe */
409 /* IRM */
410 #define D_SDP_2SAME (1<<18) /* Report 2nd time in a row value rcvd */
411 #define D_SDP_CHANGE (2<<18) /* Report any changes */
412 #define D_SDP_EVERY (3<<18) /* Report any changes */
413 #define D_SDP_EOL (1<<17) /* EOL interrupt enable */
414 #define D_SDP_IDLE (1<<16) /* HDLC idle interrupt enable */
415
416 /* Pipe data MODE */
417 #define D_SDP_MEM (0<<13) /* To/from memory */
418 #define D_SDP_HDLC (2<<13)
419 #define D_SDP_HDLC_D (3<<13) /* D Channel (prio control) */
420 #define D_SDP_SER (4<<13) /* Serial to serial */
421 #define D_SDP_FIXED (6<<13) /* Short only */
422 #define D_SDP_MODE(v) ((v)&(7<<13))
423
424 #define D_SDP_TO_SER (1<<12) /* Direction */
425 #define D_SDP_FROM_SER (0<<12) /* Direction */
426 #define D_SDP_MSB (1<<11) /* Bit order within Byte */
427 #define D_SDP_LSB (0<<11) /* Bit order within Byte */
428 #define D_SDP_P (1<<10) /* Pointer Valid */
429 #define D_SDP_A (1<<8) /* Abort */
430 #define D_SDP_C (1<<7) /* Clear */
431
432 /* Define Time Slot */
433 #define D_DTS_VI (1<<17) /* Valid Input Time-Slot Descriptor */
434 #define D_DTS_VO (1<<16) /* Valid Output Time-Slot Descriptor */
435 #define D_DTS_INS (1<<15) /* Insert Time Slot */
436 #define D_DTS_DEL (0<<15) /* Delete Time Slot */
437 #define D_DTS_PRVIN(v) ((v)<<10) /* Previous In Pipe */
438 #define D_DTS_PRVOUT(v) ((v)<<5) /* Previous Out Pipe */
439
440 /* Time Slot defines */
441 #define D_TS_LEN(v) ((v)<<24) /* Number of bits in this time slot */
442 #define D_TS_CYCLE(v) ((v)<<14) /* Bit Count at start of TS */
443 #define D_TS_DI (1<<13) /* Data Invert */
444 #define D_TS_1CHANNEL (0<<10) /* Single Channel / Normal mode */
445 #define D_TS_MONITOR (2<<10) /* Monitor pipe */
446 #define D_TS_NONCONTIG (3<<10) /* Non contiguous mode */
447 #define D_TS_ANCHOR (7<<10) /* Starting short pipes */
448 #define D_TS_MON(v) ((v)<<5) /* Monitor Pipe */
449 #define D_TS_NEXT(v) ((v)<<0) /* Pipe Nr: 0-15 long, 16-21 short */
450
451 /* Concentration Highway Interface Modes */
452 #define D_CHI_CHICM(v) ((v)<<16) /* Clock mode */
453 #define D_CHI_IR (1<<15) /* Immediate Interrupt Report */
454 #define D_CHI_EN (1<<14) /* CHIL Interrupt enabled */
455 #define D_CHI_OD (1<<13) /* Open Drain Enable */
456 #define D_CHI_FE (1<<12) /* Sample CHIFS on Rising Frame Edge */
457 #define D_CHI_FD (1<<11) /* Frame Drive */
458 #define D_CHI_BPF(v) ((v)<<0) /* Bits per Frame */
459
460 /* NT: These are here for completeness */
461 #define D_NT_FBIT (1<<17) /* Frame Bit */
462 #define D_NT_NBF (1<<16) /* Number of bad frames to loose framing */
463 #define D_NT_IRM_IMM (1<<15) /* Interrupt Report & Mask: Immediate */
464 #define D_NT_IRM_EN (1<<14) /* Interrupt Report & Mask: Enable */
465 #define D_NT_ISNT (1<<13) /* Configfure interface as NT */
466 #define D_NT_FT (1<<12) /* Fixed Timing */
467 #define D_NT_EZ (1<<11) /* Echo Channel is Zeros */
468 #define D_NT_IFA (1<<10) /* Inhibit Final Activation */
469 #define D_NT_ACT (1<<9) /* Activate Interface */
470 #define D_NT_MFE (1<<8) /* Multiframe Enable */
471 #define D_NT_RLB(v) ((v)<<5) /* Remote Loopback */
472 #define D_NT_LLB(v) ((v)<<2) /* Local Loopback */
473 #define D_NT_FACT (1<<1) /* Force Activation */
474 #define D_NT_ABV (1<<0) /* Activate Bipolar Violation */
475
476 /* Codec Setup */
477 #define D_CDEC_CK(v) ((v)<<24) /* Clock Select */
478 #define D_CDEC_FED(v) ((v)<<12) /* FSCOD Falling Edge Delay */
479 #define D_CDEC_RED(v) ((v)<<0) /* FSCOD Rising Edge Delay */
480
481 /* Test */
482 #define D_TEST_RAM(v) ((v)<<16) /* RAM Pointer */
483 #define D_TEST_SIZE(v) ((v)<<11) /* */
484 #define D_TEST_ROMONOFF 0x5 /* Toggle ROM opcode monitor on/off */
485 #define D_TEST_PROC 0x6 /* MicroProcessor test */
486 #define D_TEST_SER 0x7 /* Serial-Controller test */
487 #define D_TEST_RAMREAD 0x8 /* Copy from Ram to system memory */
488 #define D_TEST_RAMWRITE 0x9 /* Copy into Ram from system memory */
489 #define D_TEST_RAMBIST 0xa /* RAM Built-In Self Test */
490 #define D_TEST_MCBIST 0xb /* Microcontroller Built-In Self Test */
491 #define D_TEST_DUMP 0xe /* ROM Dump */
492
493 /* CHI Data Mode */
494 #define D_CDM_THI (1<<8) /* Transmit Data on CHIDR Pin */
495 #define D_CDM_RHI (1<<7) /* Receive Data on CHIDX Pin */
496 #define D_CDM_RCE (1<<6) /* Receive on Rising Edge of CHICK */
497 #define D_CDM_XCE (1<<2) /* Transmit Data on Rising Edge of CHICK */
498 #define D_CDM_XEN (1<<1) /* Transmit Highway Enable */
499 #define D_CDM_REN (1<<0) /* Receive Highway Enable */
500
501 /* The Interrupts */
502 #define D_INTR_BRDY 1 /* Buffer Ready for processing */
503 #define D_INTR_MINT 2 /* Marked Interrupt in RD/TD */
504 #define D_INTR_IBEG 3 /* Flag to idle transition detected (HDLC) */
505 #define D_INTR_IEND 4 /* Idle to flag transition detected (HDLC) */
506 #define D_INTR_EOL 5 /* End of List */
507 #define D_INTR_CMDI 6 /* Command has bean read */
508 #define D_INTR_XCMP 8 /* Transmission of frame complete */
509 #define D_INTR_SBRI 9 /* BRI status change info */
510 #define D_INTR_FXDT 10 /* Fixed data change */
511 #define D_INTR_CHIL 11 /* CHI lost frame sync (channel 36 only) */
512 #define D_INTR_COLL 11 /* Unrecoverable D-Channel collision */
513 #define D_INTR_DBYT 12 /* Dropped by frame slip */
514 #define D_INTR_RBYT 13 /* Repeated by frame slip */
515 #define D_INTR_LINT 14 /* Lost Interrupt */
516 #define D_INTR_UNDR 15 /* DMA underrun */
517
518 #define D_INTR_TE 32
519 #define D_INTR_NT 34
520 #define D_INTR_CHI 36
521 #define D_INTR_CMD 38
522
523 #define D_INTR_GETCHAN(v) (((v)>>24) & 0x3f)
524 #define D_INTR_GETCODE(v) (((v)>>20) & 0xf)
525 #define D_INTR_GETCMD(v) (((v)>>16) & 0xf)
526 #define D_INTR_GETVAL(v) ((v) & 0xffff)
527 #define D_INTR_GETRVAL(v) ((v) & 0xfffff)
528
529 #define D_P_0 0 /* TE receive anchor */
530 #define D_P_1 1 /* TE transmit anchor */
531 #define D_P_2 2 /* NT transmit anchor */
532 #define D_P_3 3 /* NT receive anchor */
533 #define D_P_4 4 /* CHI send data */
534 #define D_P_5 5 /* CHI receive data */
535 #define D_P_6 6 /* */
536 #define D_P_7 7 /* */
537 #define D_P_8 8 /* */
538 #define D_P_9 9 /* */
539 #define D_P_10 10 /* */
540 #define D_P_11 11 /* */
541 #define D_P_12 12 /* */
542 #define D_P_13 13 /* */
543 #define D_P_14 14 /* */
544 #define D_P_15 15 /* */
545 #define D_P_16 16 /* CHI anchor pipe */
546 #define D_P_17 17 /* CHI send */
547 #define D_P_18 18 /* CHI receive */
548 #define D_P_19 19 /* CHI receive */
549 #define D_P_20 20 /* CHI receive */
550 #define D_P_21 21 /* */
551 #define D_P_22 22 /* */
552 #define D_P_23 23 /* */
553 #define D_P_24 24 /* */
554 #define D_P_25 25 /* */
555 #define D_P_26 26 /* */
556 #define D_P_27 27 /* */
557 #define D_P_28 28 /* */
558 #define D_P_29 29 /* */
559 #define D_P_30 30 /* */
560 #define D_P_31 31 /* */
561
562 /* Transmit descriptor defines */
563 #define DBRI_TD_F (1<<31) /* End of Frame */
564 #define DBRI_TD_D (1<<30) /* Do not append CRC */
565 #define DBRI_TD_CNT(v) ((v)<<16) /* Number of valid bytes in the buffer */
566 #define DBRI_TD_B (1<<15) /* Final interrupt */
567 #define DBRI_TD_M (1<<14) /* Marker interrupt */
568 #define DBRI_TD_I (1<<13) /* Transmit Idle Characters */
569 #define DBRI_TD_FCNT(v) (v) /* Flag Count */
570 #define DBRI_TD_UNR (1<<3) /* Underrun: transmitter is out of data */
571 #define DBRI_TD_ABT (1<<2) /* Abort: frame aborted */
572 #define DBRI_TD_TBC (1<<0) /* Transmit buffer Complete */
573 #define DBRI_TD_STATUS(v) ((v)&0xff) /* Transmit status */
574 /* Maximum buffer size per TD: almost 8Kb */
575 #define DBRI_TD_MAXCNT ((1 << 13) - 1)
576
577 /* Receive descriptor defines */
578 #define DBRI_RD_F (1<<31) /* End of Frame */
579 #define DBRI_RD_C (1<<30) /* Completed buffer */
580 #define DBRI_RD_B (1<<15) /* Final interrupt */
581 #define DBRI_RD_M (1<<14) /* Marker interrupt */
582 #define DBRI_RD_BCNT(v) (v) /* Buffer size */
583 #define DBRI_RD_CRC (1<<7) /* 0: CRC is correct */
584 #define DBRI_RD_BBC (1<<6) /* 1: Bad Byte received */
585 #define DBRI_RD_ABT (1<<5) /* Abort: frame aborted */
586 #define DBRI_RD_OVRN (1<<3) /* Overrun: data lost */
587 #define DBRI_RD_STATUS(v) ((v)&0xff) /* Receive status */
588 #define DBRI_RD_CNT(v) (((v)>>16)&0x1fff) /* Valid bytes in the buffer */
589
590 /* stream_info[] access */
591 /* Translate the ALSA direction into the array index */
592 #define DBRI_STREAMNO(substream) \
593 (substream->stream == \
594 SNDRV_PCM_STREAM_PLAYBACK? DBRI_PLAY: DBRI_REC)
595
596 /* Return a pointer to dbri_streaminfo */
597 #define DBRI_STREAM(dbri, substream) &dbri->stream_info[DBRI_STREAMNO(substream)]
598
599 static snd_dbri_t *dbri_list = NULL; /* All DBRI devices */
600
601 /*
602 * Short data pipes transmit LSB first. The CS4215 receives MSB first. Grrr.
603 * So we have to reverse the bits. Note: not all bit lengths are supported
604 */
605 static __u32 reverse_bytes(__u32 b, int len)
606 {
607 switch (len) {
608 case 32:
609 b = ((b & 0xffff0000) >> 16) | ((b & 0x0000ffff) << 16);
610 case 16:
611 b = ((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8);
612 case 8:
613 b = ((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4);
614 case 4:
615 b = ((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2);
616 case 2:
617 b = ((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1);
618 case 1:
619 case 0:
620 break;
621 default:
622 printk(KERN_ERR "DBRI reverse_bytes: unsupported length\n");
623 };
624
625 return b;
626 }
627
628 /*
629 ****************************************************************************
630 ************** DBRI initialization and command synchronization *************
631 ****************************************************************************
632
633 Commands are sent to the DBRI by building a list of them in memory,
634 then writing the address of the first list item to DBRI register 8.
635 The list is terminated with a WAIT command, which generates a
636 CPU interrupt to signal completion.
637
638 Since the DBRI can run in parallel with the CPU, several means of
639 synchronization present themselves. The method implemented here is close
640 to the original scheme (Rudolf's), and uses 2 counters (wait_send and
641 wait_ackd) to synchronize the command buffer between the CPU and the DBRI.
642
643 A more sophisticated scheme might involve a circular command buffer
644 or an array of command buffers. A routine could fill one with
645 commands and link it onto a list. When a interrupt signaled
646 completion of the current command buffer, look on the list for
647 the next one.
648
649 Every time a routine wants to write commands to the DBRI, it must
650 first call dbri_cmdlock() and get an initial pointer into dbri->dma->cmd
651 in return. dbri_cmdlock() will block if the previous commands have not
652 been completed yet. After this the commands can be written to the buffer,
653 and dbri_cmdsend() is called with the final pointer value to send them
654 to the DBRI.
655
656 */
657
658 static void dbri_process_interrupt_buffer(snd_dbri_t * dbri);
659
660 enum dbri_lock_t { NoGetLock, GetLock };
661 #define MAXLOOPS 10
662
663 static volatile s32 *dbri_cmdlock(snd_dbri_t * dbri, enum dbri_lock_t get)
664 {
665 int maxloops = MAXLOOPS;
666
667 #ifndef SMP
668 if ((get == GetLock) && spin_is_locked(&dbri->lock)) {
669 printk(KERN_ERR "DBRI: cmdlock called while in spinlock.");
670 }
671 #endif
672
673 /* Delay if previous commands are still being processed */
674 while ((--maxloops) > 0 && (dbri->wait_send != dbri->wait_ackd)) {
675 msleep_interruptible(1);
676 /* If dbri_cmdlock() got called from inside the
677 * interrupt handler, this will do the processing.
678 */
679 dbri_process_interrupt_buffer(dbri);
680 }
681 if (maxloops == 0) {
682 printk(KERN_ERR "DBRI: Chip never completed command buffer %d\n",
683 dbri->wait_send);
684 } else {
685 dprintk(D_CMD, "Chip completed command buffer (%d)\n",
686 MAXLOOPS - maxloops - 1);
687 }
688
689 /*if (get == GetLock) spin_lock(&dbri->lock); */
690 return &dbri->dma->cmd[0];
691 }
692
693 static void dbri_cmdsend(snd_dbri_t * dbri, volatile s32 * cmd)
694 {
695 volatile s32 *ptr;
696 u32 reg;
697
698 for (ptr = &dbri->dma->cmd[0]; ptr < cmd; ptr++) {
699 dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr);
700 }
701
702 if ((cmd - &dbri->dma->cmd[0]) >= DBRI_NO_CMDS - 1) {
703 printk(KERN_ERR "DBRI: Command buffer overflow! (bug in driver)\n");
704 /* Ignore the last part. */
705 cmd = &dbri->dma->cmd[DBRI_NO_CMDS - 3];
706 }
707
708 dbri->wait_send++;
709 dbri->wait_send &= 0xffff; /* restrict it to a 16 bit counter. */
710 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
711 *(cmd++) = DBRI_CMD(D_WAIT, 1, dbri->wait_send);
712
713 /* Set command pointer and signal it is valid. */
714 sbus_writel(dbri->dma_dvma, dbri->regs + REG8);
715 reg = sbus_readl(dbri->regs + REG0);
716 reg |= D_P;
717 sbus_writel(reg, dbri->regs + REG0);
718
719 /*spin_unlock(&dbri->lock); */
720 }
721
722 /* Lock must be held when calling this */
723 static void dbri_reset(snd_dbri_t * dbri)
724 {
725 int i;
726
727 dprintk(D_GEN, "reset 0:%x 2:%x 8:%x 9:%x\n",
728 sbus_readl(dbri->regs + REG0),
729 sbus_readl(dbri->regs + REG2),
730 sbus_readl(dbri->regs + REG8), sbus_readl(dbri->regs + REG9));
731
732 sbus_writel(D_R, dbri->regs + REG0); /* Soft Reset */
733 for (i = 0; (sbus_readl(dbri->regs + REG0) & D_R) && i < 64; i++)
734 udelay(10);
735 }
736
737 /* Lock must not be held before calling this */
738 static void dbri_initialize(snd_dbri_t * dbri)
739 {
740 volatile s32 *cmd;
741 u32 dma_addr, tmp;
742 unsigned long flags;
743 int n;
744
745 spin_lock_irqsave(&dbri->lock, flags);
746
747 dbri_reset(dbri);
748
749 cmd = dbri_cmdlock(dbri, NoGetLock);
750 dprintk(D_GEN, "init: cmd: %p, int: %p\n",
751 &dbri->dma->cmd[0], &dbri->dma->intr[0]);
752
753 /*
754 * Initialize the interrupt ringbuffer.
755 */
756 for (n = 0; n < DBRI_NO_INTS - 1; n++) {
757 dma_addr = dbri->dma_dvma;
758 dma_addr += dbri_dma_off(intr, ((n + 1) & DBRI_INT_BLK));
759 dbri->dma->intr[n * DBRI_INT_BLK] = dma_addr;
760 }
761 dma_addr = dbri->dma_dvma + dbri_dma_off(intr, 0);
762 dbri->dma->intr[n * DBRI_INT_BLK] = dma_addr;
763 dbri->dbri_irqp = 1;
764
765 /* Initialize pipes */
766 for (n = 0; n < DBRI_NO_PIPES; n++)
767 dbri->pipes[n].desc = dbri->pipes[n].first_desc = -1;
768
769 /* A brute approach - DBRI falls back to working burst size by itself
770 * On SS20 D_S does not work, so do not try so high. */
771 tmp = sbus_readl(dbri->regs + REG0);
772 tmp |= D_G | D_E;
773 tmp &= ~D_S;
774 sbus_writel(tmp, dbri->regs + REG0);
775
776 /*
777 * Set up the interrupt queue
778 */
779 dma_addr = dbri->dma_dvma + dbri_dma_off(intr, 0);
780 *(cmd++) = DBRI_CMD(D_IIQ, 0, 0);
781 *(cmd++) = dma_addr;
782
783 dbri_cmdsend(dbri, cmd);
784 spin_unlock_irqrestore(&dbri->lock, flags);
785 }
786
787 /*
788 ****************************************************************************
789 ************************** DBRI data pipe management ***********************
790 ****************************************************************************
791
792 While DBRI control functions use the command and interrupt buffers, the
793 main data path takes the form of data pipes, which can be short (command
794 and interrupt driven), or long (attached to DMA buffers). These functions
795 provide a rudimentary means of setting up and managing the DBRI's pipes,
796 but the calling functions have to make sure they respect the pipes' linked
797 list ordering, among other things. The transmit and receive functions
798 here interface closely with the transmit and receive interrupt code.
799
800 */
801 static int pipe_active(snd_dbri_t * dbri, int pipe)
802 {
803 return ((pipe >= 0) && (dbri->pipes[pipe].desc != -1));
804 }
805
806 /* reset_pipe(dbri, pipe)
807 *
808 * Called on an in-use pipe to clear anything being transmitted or received
809 * Lock must be held before calling this.
810 */
811 static void reset_pipe(snd_dbri_t * dbri, int pipe)
812 {
813 int sdp;
814 int desc;
815 volatile int *cmd;
816
817 if (pipe < 0 || pipe > 31) {
818 printk(KERN_ERR "DBRI: reset_pipe called with illegal pipe number\n");
819 return;
820 }
821
822 sdp = dbri->pipes[pipe].sdp;
823 if (sdp == 0) {
824 printk(KERN_ERR "DBRI: reset_pipe called on uninitialized pipe\n");
825 return;
826 }
827
828 cmd = dbri_cmdlock(dbri, NoGetLock);
829 *(cmd++) = DBRI_CMD(D_SDP, 0, sdp | D_SDP_C | D_SDP_P);
830 *(cmd++) = 0;
831 dbri_cmdsend(dbri, cmd);
832
833 desc = dbri->pipes[pipe].first_desc;
834 while (desc != -1) {
835 dbri->descs[desc].inuse = 0;
836 desc = dbri->descs[desc].next;
837 }
838
839 dbri->pipes[pipe].desc = -1;
840 dbri->pipes[pipe].first_desc = -1;
841 }
842
843 /* FIXME: direction as an argument? */
844 static void setup_pipe(snd_dbri_t * dbri, int pipe, int sdp)
845 {
846 if (pipe < 0 || pipe > 31) {
847 printk(KERN_ERR "DBRI: setup_pipe called with illegal pipe number\n");
848 return;
849 }
850
851 if ((sdp & 0xf800) != sdp) {
852 printk(KERN_ERR "DBRI: setup_pipe called with strange SDP value\n");
853 /* sdp &= 0xf800; */
854 }
855
856 /* If this is a fixed receive pipe, arrange for an interrupt
857 * every time its data changes
858 */
859 if (D_SDP_MODE(sdp) == D_SDP_FIXED && !(sdp & D_SDP_TO_SER))
860 sdp |= D_SDP_CHANGE;
861
862 sdp |= D_PIPE(pipe);
863 dbri->pipes[pipe].sdp = sdp;
864 dbri->pipes[pipe].desc = -1;
865 dbri->pipes[pipe].first_desc = -1;
866 if (sdp & D_SDP_TO_SER)
867 dbri->pipes[pipe].direction = PIPEoutput;
868 else
869 dbri->pipes[pipe].direction = PIPEinput;
870
871 reset_pipe(dbri, pipe);
872 }
873
874 /* FIXME: direction not needed */
875 static void link_time_slot(snd_dbri_t * dbri, int pipe,
876 enum in_or_out direction, int basepipe,
877 int length, int cycle)
878 {
879 volatile s32 *cmd;
880 int val;
881 int prevpipe;
882 int nextpipe;
883
884 if (pipe < 0 || pipe > 31 || basepipe < 0 || basepipe > 31) {
885 printk(KERN_ERR
886 "DBRI: link_time_slot called with illegal pipe number\n");
887 return;
888 }
889
890 if (dbri->pipes[pipe].sdp == 0 || dbri->pipes[basepipe].sdp == 0) {
891 printk(KERN_ERR "DBRI: link_time_slot called on uninitialized pipe\n");
892 return;
893 }
894
895 /* Deal with CHI special case:
896 * "If transmission on edges 0 or 1 is desired, then cycle n
897 * (where n = # of bit times per frame...) must be used."
898 * - DBRI data sheet, page 11
899 */
900 if (basepipe == 16 && direction == PIPEoutput && cycle == 0)
901 cycle = dbri->chi_bpf;
902
903 if (basepipe == pipe) {
904 prevpipe = pipe;
905 nextpipe = pipe;
906 } else {
907 /* We're not initializing a new linked list (basepipe != pipe),
908 * so run through the linked list and find where this pipe
909 * should be sloted in, based on its cycle. CHI confuses
910 * things a bit, since it has a single anchor for both its
911 * transmit and receive lists.
912 */
913 if (basepipe == 16) {
914 if (direction == PIPEinput) {
915 prevpipe = dbri->chi_in_pipe;
916 } else {
917 prevpipe = dbri->chi_out_pipe;
918 }
919 } else {
920 prevpipe = basepipe;
921 }
922
923 nextpipe = dbri->pipes[prevpipe].nextpipe;
924
925 while (dbri->pipes[nextpipe].cycle < cycle
926 && dbri->pipes[nextpipe].nextpipe != basepipe) {
927 prevpipe = nextpipe;
928 nextpipe = dbri->pipes[nextpipe].nextpipe;
929 }
930 }
931
932 if (prevpipe == 16) {
933 if (direction == PIPEinput) {
934 dbri->chi_in_pipe = pipe;
935 } else {
936 dbri->chi_out_pipe = pipe;
937 }
938 } else {
939 dbri->pipes[prevpipe].nextpipe = pipe;
940 }
941
942 dbri->pipes[pipe].nextpipe = nextpipe;
943 dbri->pipes[pipe].cycle = cycle;
944 dbri->pipes[pipe].length = length;
945
946 cmd = dbri_cmdlock(dbri, NoGetLock);
947
948 if (direction == PIPEinput) {
949 val = D_DTS_VI | D_DTS_INS | D_DTS_PRVIN(prevpipe) | pipe;
950 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
951 *(cmd++) =
952 D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe);
953 *(cmd++) = 0;
954 } else {
955 val = D_DTS_VO | D_DTS_INS | D_DTS_PRVOUT(prevpipe) | pipe;
956 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
957 *(cmd++) = 0;
958 *(cmd++) =
959 D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe);
960 }
961
962 dbri_cmdsend(dbri, cmd);
963 }
964
965 static void unlink_time_slot(snd_dbri_t * dbri, int pipe,
966 enum in_or_out direction, int prevpipe,
967 int nextpipe)
968 {
969 volatile s32 *cmd;
970 int val;
971
972 if (pipe < 0 || pipe > 31 || prevpipe < 0 || prevpipe > 31) {
973 printk(KERN_ERR
974 "DBRI: unlink_time_slot called with illegal pipe number\n");
975 return;
976 }
977
978 cmd = dbri_cmdlock(dbri, NoGetLock);
979
980 if (direction == PIPEinput) {
981 val = D_DTS_VI | D_DTS_DEL | D_DTS_PRVIN(prevpipe) | pipe;
982 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
983 *(cmd++) = D_TS_NEXT(nextpipe);
984 *(cmd++) = 0;
985 } else {
986 val = D_DTS_VO | D_DTS_DEL | D_DTS_PRVOUT(prevpipe) | pipe;
987 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
988 *(cmd++) = 0;
989 *(cmd++) = D_TS_NEXT(nextpipe);
990 }
991
992 dbri_cmdsend(dbri, cmd);
993 }
994
995 /* xmit_fixed() / recv_fixed()
996 *
997 * Transmit/receive data on a "fixed" pipe - i.e, one whose contents are not
998 * expected to change much, and which we don't need to buffer.
999 * The DBRI only interrupts us when the data changes (receive pipes),
1000 * or only changes the data when this function is called (transmit pipes).
1001 * Only short pipes (numbers 16-31) can be used in fixed data mode.
1002 *
1003 * These function operate on a 32-bit field, no matter how large
1004 * the actual time slot is. The interrupt handler takes care of bit
1005 * ordering and alignment. An 8-bit time slot will always end up
1006 * in the low-order 8 bits, filled either MSB-first or LSB-first,
1007 * depending on the settings passed to setup_pipe()
1008 */
1009 static void xmit_fixed(snd_dbri_t * dbri, int pipe, unsigned int data)
1010 {
1011 volatile s32 *cmd;
1012
1013 if (pipe < 16 || pipe > 31) {
1014 printk(KERN_ERR "DBRI: xmit_fixed: Illegal pipe number\n");
1015 return;
1016 }
1017
1018 if (D_SDP_MODE(dbri->pipes[pipe].sdp) == 0) {
1019 printk(KERN_ERR "DBRI: xmit_fixed: Uninitialized pipe %d\n", pipe);
1020 return;
1021 }
1022
1023 if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) {
1024 printk(KERN_ERR "DBRI: xmit_fixed: Non-fixed pipe %d\n", pipe);
1025 return;
1026 }
1027
1028 if (!(dbri->pipes[pipe].sdp & D_SDP_TO_SER)) {
1029 printk(KERN_ERR "DBRI: xmit_fixed: Called on receive pipe %d\n", pipe);
1030 return;
1031 }
1032
1033 /* DBRI short pipes always transmit LSB first */
1034
1035 if (dbri->pipes[pipe].sdp & D_SDP_MSB)
1036 data = reverse_bytes(data, dbri->pipes[pipe].length);
1037
1038 cmd = dbri_cmdlock(dbri, GetLock);
1039
1040 *(cmd++) = DBRI_CMD(D_SSP, 0, pipe);
1041 *(cmd++) = data;
1042
1043 dbri_cmdsend(dbri, cmd);
1044 }
1045
1046 static void recv_fixed(snd_dbri_t * dbri, int pipe, volatile __u32 * ptr)
1047 {
1048 if (pipe < 16 || pipe > 31) {
1049 printk(KERN_ERR "DBRI: recv_fixed called with illegal pipe number\n");
1050 return;
1051 }
1052
1053 if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) {
1054 printk(KERN_ERR "DBRI: recv_fixed called on non-fixed pipe %d\n", pipe);
1055 return;
1056 }
1057
1058 if (dbri->pipes[pipe].sdp & D_SDP_TO_SER) {
1059 printk(KERN_ERR "DBRI: recv_fixed called on transmit pipe %d\n", pipe);
1060 return;
1061 }
1062
1063 dbri->pipes[pipe].recv_fixed_ptr = ptr;
1064 }
1065
1066 /* setup_descs()
1067 *
1068 * Setup transmit/receive data on a "long" pipe - i.e, one associated
1069 * with a DMA buffer.
1070 *
1071 * Only pipe numbers 0-15 can be used in this mode.
1072 *
1073 * This function takes a stream number pointing to a data buffer,
1074 * and work by building chains of descriptors which identify the
1075 * data buffers. Buffers too large for a single descriptor will
1076 * be spread across multiple descriptors.
1077 */
1078 static int setup_descs(snd_dbri_t * dbri, int streamno, unsigned int period)
1079 {
1080 dbri_streaminfo_t *info = &dbri->stream_info[streamno];
1081 __u32 dvma_buffer;
1082 int desc = 0;
1083 int len;
1084 int first_desc = -1;
1085 int last_desc = -1;
1086
1087 if (info->pipe < 0 || info->pipe > 15) {
1088 printk(KERN_ERR "DBRI: setup_descs: Illegal pipe number\n");
1089 return -2;
1090 }
1091
1092 if (dbri->pipes[info->pipe].sdp == 0) {
1093 printk(KERN_ERR "DBRI: setup_descs: Uninitialized pipe %d\n",
1094 info->pipe);
1095 return -2;
1096 }
1097
1098 dvma_buffer = info->dvma_buffer;
1099 len = info->size;
1100
1101 if (streamno == DBRI_PLAY) {
1102 if (!(dbri->pipes[info->pipe].sdp & D_SDP_TO_SER)) {
1103 printk(KERN_ERR "DBRI: setup_descs: Called on receive pipe %d\n",
1104 info->pipe);
1105 return -2;
1106 }
1107 } else {
1108 if (dbri->pipes[info->pipe].sdp & D_SDP_TO_SER) {
1109 printk(KERN_ERR
1110 "DBRI: setup_descs: Called on transmit pipe %d\n",
1111 info->pipe);
1112 return -2;
1113 }
1114 /* Should be able to queue multiple buffers to receive on a pipe */
1115 if (pipe_active(dbri, info->pipe)) {
1116 printk(KERN_ERR "DBRI: recv_on_pipe: Called on active pipe %d\n",
1117 info->pipe);
1118 return -2;
1119 }
1120
1121 /* Make sure buffer size is multiple of four */
1122 len &= ~3;
1123 }
1124
1125 while (len > 0) {
1126 int mylen;
1127
1128 for (; desc < DBRI_NO_DESCS; desc++) {
1129 if (!dbri->descs[desc].inuse)
1130 break;
1131 }
1132 if (desc == DBRI_NO_DESCS) {
1133 printk(KERN_ERR "DBRI: setup_descs: No descriptors\n");
1134 return -1;
1135 }
1136
1137 if (len > DBRI_TD_MAXCNT) {
1138 mylen = DBRI_TD_MAXCNT; /* 8KB - 1 */
1139 } else {
1140 mylen = len;
1141 }
1142 if (mylen > period) {
1143 mylen = period;
1144 }
1145
1146 dbri->descs[desc].inuse = 1;
1147 dbri->descs[desc].next = -1;
1148 dbri->dma->desc[desc].ba = dvma_buffer;
1149 dbri->dma->desc[desc].nda = 0;
1150
1151 if (streamno == DBRI_PLAY) {
1152 dbri->descs[desc].len = mylen;
1153 dbri->dma->desc[desc].word1 = DBRI_TD_CNT(mylen);
1154 dbri->dma->desc[desc].word4 = 0;
1155 if (first_desc != -1)
1156 dbri->dma->desc[desc].word1 |= DBRI_TD_M;
1157 } else {
1158 dbri->descs[desc].len = 0;
1159 dbri->dma->desc[desc].word1 = 0;
1160 dbri->dma->desc[desc].word4 =
1161 DBRI_RD_B | DBRI_RD_BCNT(mylen);
1162 }
1163
1164 if (first_desc == -1) {
1165 first_desc = desc;
1166 } else {
1167 dbri->descs[last_desc].next = desc;
1168 dbri->dma->desc[last_desc].nda =
1169 dbri->dma_dvma + dbri_dma_off(desc, desc);
1170 }
1171
1172 last_desc = desc;
1173 dvma_buffer += mylen;
1174 len -= mylen;
1175 }
1176
1177 if (first_desc == -1 || last_desc == -1) {
1178 printk(KERN_ERR "DBRI: setup_descs: Not enough descriptors available\n");
1179 return -1;
1180 }
1181
1182 dbri->dma->desc[last_desc].word1 &= ~DBRI_TD_M;
1183 if (streamno == DBRI_PLAY) {
1184 dbri->dma->desc[last_desc].word1 |=
1185 DBRI_TD_I | DBRI_TD_F | DBRI_TD_B;
1186 }
1187 dbri->pipes[info->pipe].first_desc = first_desc;
1188 dbri->pipes[info->pipe].desc = first_desc;
1189
1190 for (desc = first_desc; desc != -1; desc = dbri->descs[desc].next) {
1191 dprintk(D_DESC, "DESC %d: %08x %08x %08x %08x\n",
1192 desc,
1193 dbri->dma->desc[desc].word1,
1194 dbri->dma->desc[desc].ba,
1195 dbri->dma->desc[desc].nda, dbri->dma->desc[desc].word4);
1196 }
1197 return 0;
1198 }
1199
1200 /*
1201 ****************************************************************************
1202 ************************** DBRI - CHI interface ****************************
1203 ****************************************************************************
1204
1205 The CHI is a four-wire (clock, frame sync, data in, data out) time-division
1206 multiplexed serial interface which the DBRI can operate in either master
1207 (give clock/frame sync) or slave (take clock/frame sync) mode.
1208
1209 */
1210
1211 enum master_or_slave { CHImaster, CHIslave };
1212
1213 static void reset_chi(snd_dbri_t * dbri, enum master_or_slave master_or_slave,
1214 int bits_per_frame)
1215 {
1216 volatile s32 *cmd;
1217 int val;
1218 static int chi_initialized = 0; /* FIXME: mutex? */
1219
1220 if (!chi_initialized) {
1221
1222 cmd = dbri_cmdlock(dbri, GetLock);
1223
1224 /* Set CHI Anchor: Pipe 16 */
1225
1226 val = D_DTS_VI | D_DTS_INS | D_DTS_PRVIN(16) | D_PIPE(16);
1227 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
1228 *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16);
1229 *(cmd++) = 0;
1230
1231 val = D_DTS_VO | D_DTS_INS | D_DTS_PRVOUT(16) | D_PIPE(16);
1232 *(cmd++) = DBRI_CMD(D_DTS, 0, val);
1233 *(cmd++) = 0;
1234 *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16);
1235
1236 dbri->pipes[16].sdp = 1;
1237 dbri->pipes[16].nextpipe = 16;
1238 dbri->chi_in_pipe = 16;
1239 dbri->chi_out_pipe = 16;
1240
1241 #if 0
1242 chi_initialized++;
1243 #endif
1244 } else {
1245 int pipe;
1246
1247 for (pipe = dbri->chi_in_pipe;
1248 pipe != 16; pipe = dbri->pipes[pipe].nextpipe) {
1249 unlink_time_slot(dbri, pipe, PIPEinput,
1250 16, dbri->pipes[pipe].nextpipe);
1251 }
1252 for (pipe = dbri->chi_out_pipe;
1253 pipe != 16; pipe = dbri->pipes[pipe].nextpipe) {
1254 unlink_time_slot(dbri, pipe, PIPEoutput,
1255 16, dbri->pipes[pipe].nextpipe);
1256 }
1257
1258 dbri->chi_in_pipe = 16;
1259 dbri->chi_out_pipe = 16;
1260
1261 cmd = dbri_cmdlock(dbri, GetLock);
1262 }
1263
1264 if (master_or_slave == CHIslave) {
1265 /* Setup DBRI for CHI Slave - receive clock, frame sync (FS)
1266 *
1267 * CHICM = 0 (slave mode, 8 kHz frame rate)
1268 * IR = give immediate CHI status interrupt
1269 * EN = give CHI status interrupt upon change
1270 */
1271 *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(0));
1272 } else {
1273 /* Setup DBRI for CHI Master - generate clock, FS
1274 *
1275 * BPF = bits per 8 kHz frame
1276 * 12.288 MHz / CHICM_divisor = clock rate
1277 * FD = 1 - drive CHIFS on rising edge of CHICK
1278 */
1279 int clockrate = bits_per_frame * 8;
1280 int divisor = 12288 / clockrate;
1281
1282 if (divisor > 255 || divisor * clockrate != 12288)
1283 printk(KERN_ERR "DBRI: illegal bits_per_frame in setup_chi\n");
1284
1285 *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(divisor) | D_CHI_FD
1286 | D_CHI_BPF(bits_per_frame));
1287 }
1288
1289 dbri->chi_bpf = bits_per_frame;
1290
1291 /* CHI Data Mode
1292 *
1293 * RCE = 0 - receive on falling edge of CHICK
1294 * XCE = 1 - transmit on rising edge of CHICK
1295 * XEN = 1 - enable transmitter
1296 * REN = 1 - enable receiver
1297 */
1298
1299 *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0);
1300 *(cmd++) = DBRI_CMD(D_CDM, 0, D_CDM_XCE | D_CDM_XEN | D_CDM_REN);
1301
1302 dbri_cmdsend(dbri, cmd);
1303 }
1304
1305 /*
1306 ****************************************************************************
1307 *********************** CS4215 audio codec management **********************
1308 ****************************************************************************
1309
1310 In the standard SPARC audio configuration, the CS4215 codec is attached
1311 to the DBRI via the CHI interface and few of the DBRI's PIO pins.
1312
1313 */
1314 static void cs4215_setup_pipes(snd_dbri_t * dbri)
1315 {
1316 /*
1317 * Data mode:
1318 * Pipe 4: Send timeslots 1-4 (audio data)
1319 * Pipe 20: Send timeslots 5-8 (part of ctrl data)
1320 * Pipe 6: Receive timeslots 1-4 (audio data)
1321 * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via
1322 * interrupt, and the rest of the data (slot 5 and 8) is
1323 * not relevant for us (only for doublechecking).
1324 *
1325 * Control mode:
1326 * Pipe 17: Send timeslots 1-4 (slots 5-8 are readonly)
1327 * Pipe 18: Receive timeslot 1 (clb).
1328 * Pipe 19: Receive timeslot 7 (version).
1329 */
1330
1331 setup_pipe(dbri, 4, D_SDP_MEM | D_SDP_TO_SER | D_SDP_MSB);
1332 setup_pipe(dbri, 20, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB);
1333 setup_pipe(dbri, 6, D_SDP_MEM | D_SDP_FROM_SER | D_SDP_MSB);
1334 setup_pipe(dbri, 21, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1335
1336 setup_pipe(dbri, 17, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB);
1337 setup_pipe(dbri, 18, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1338 setup_pipe(dbri, 19, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB);
1339 }
1340
1341 static int cs4215_init_data(struct cs4215 *mm)
1342 {
1343 /*
1344 * No action, memory resetting only.
1345 *
1346 * Data Time Slot 5-8
1347 * Speaker,Line and Headphone enable. Gain set to the half.
1348 * Input is mike.
1349 */
1350 mm->data[0] = CS4215_LO(0x20) | CS4215_HE | CS4215_LE;
1351 mm->data[1] = CS4215_RO(0x20) | CS4215_SE;
1352 mm->data[2] = CS4215_LG(0x8) | CS4215_IS | CS4215_PIO0 | CS4215_PIO1;
1353 mm->data[3] = CS4215_RG(0x8) | CS4215_MA(0xf);
1354
1355 /*
1356 * Control Time Slot 1-4
1357 * 0: Default I/O voltage scale
1358 * 1: 8 bit ulaw, 8kHz, mono, high pass filter disabled
1359 * 2: Serial enable, CHI master, 128 bits per frame, clock 1
1360 * 3: Tests disabled
1361 */
1362 mm->ctrl[0] = CS4215_RSRVD_1 | CS4215_MLB;
1363 mm->ctrl[1] = CS4215_DFR_ULAW | CS4215_FREQ[0].csval;
1364 mm->ctrl[2] = CS4215_XCLK | CS4215_BSEL_128 | CS4215_FREQ[0].xtal;
1365 mm->ctrl[3] = 0;
1366
1367 mm->status = 0;
1368 mm->version = 0xff;
1369 mm->precision = 8; /* For ULAW */
1370 mm->channels = 2;
1371
1372 return 0;
1373 }
1374
1375 static void cs4215_setdata(snd_dbri_t * dbri, int muted)
1376 {
1377 if (muted) {
1378 dbri->mm.data[0] |= 63;
1379 dbri->mm.data[1] |= 63;
1380 dbri->mm.data[2] &= ~15;
1381 dbri->mm.data[3] &= ~15;
1382 } else {
1383 /* Start by setting the playback attenuation. */
1384 dbri_streaminfo_t *info = &dbri->stream_info[DBRI_PLAY];
1385 int left_gain = info->left_gain % 64;
1386 int right_gain = info->right_gain % 64;
1387
1388 if (info->balance < DBRI_MID_BALANCE) {
1389 right_gain *= info->balance;
1390 right_gain /= DBRI_MID_BALANCE;
1391 } else {
1392 left_gain *= DBRI_RIGHT_BALANCE - info->balance;
1393 left_gain /= DBRI_MID_BALANCE;
1394 }
1395
1396 dbri->mm.data[0] &= ~0x3f; /* Reset the volume bits */
1397 dbri->mm.data[1] &= ~0x3f;
1398 dbri->mm.data[0] |= (DBRI_MAX_VOLUME - left_gain);
1399 dbri->mm.data[1] |= (DBRI_MAX_VOLUME - right_gain);
1400
1401 /* Now set the recording gain. */
1402 info = &dbri->stream_info[DBRI_REC];
1403 left_gain = info->left_gain % 16;
1404 right_gain = info->right_gain % 16;
1405 dbri->mm.data[2] |= CS4215_LG(left_gain);
1406 dbri->mm.data[3] |= CS4215_RG(right_gain);
1407 }
1408
1409 xmit_fixed(dbri, 20, *(int *)dbri->mm.data);
1410 }
1411
1412 /*
1413 * Set the CS4215 to data mode.
1414 */
1415 static void cs4215_open(snd_dbri_t * dbri)
1416 {
1417 int data_width;
1418 u32 tmp;
1419
1420 dprintk(D_MM, "cs4215_open: %d channels, %d bits\n",
1421 dbri->mm.channels, dbri->mm.precision);
1422
1423 /* Temporarily mute outputs, and wait 1/8000 sec (125 us)
1424 * to make sure this takes. This avoids clicking noises.
1425 */
1426
1427 cs4215_setdata(dbri, 1);
1428 udelay(125);
1429
1430 /*
1431 * Data mode:
1432 * Pipe 4: Send timeslots 1-4 (audio data)
1433 * Pipe 20: Send timeslots 5-8 (part of ctrl data)
1434 * Pipe 6: Receive timeslots 1-4 (audio data)
1435 * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via
1436 * interrupt, and the rest of the data (slot 5 and 8) is
1437 * not relevant for us (only for doublechecking).
1438 *
1439 * Just like in control mode, the time slots are all offset by eight
1440 * bits. The CS4215, it seems, observes TSIN (the delayed signal)
1441 * even if it's the CHI master. Don't ask me...
1442 */
1443 tmp = sbus_readl(dbri->regs + REG0);
1444 tmp &= ~(D_C); /* Disable CHI */
1445 sbus_writel(tmp, dbri->regs + REG0);
1446
1447 /* Switch CS4215 to data mode - set PIO3 to 1 */
1448 sbus_writel(D_ENPIO | D_PIO1 | D_PIO3 |
1449 (dbri->mm.onboard ? D_PIO0 : D_PIO2), dbri->regs + REG2);
1450
1451 reset_chi(dbri, CHIslave, 128);
1452
1453 /* Note: this next doesn't work for 8-bit stereo, because the two
1454 * channels would be on timeslots 1 and 3, with 2 and 4 idle.
1455 * (See CS4215 datasheet Fig 15)
1456 *
1457 * DBRI non-contiguous mode would be required to make this work.
1458 */
1459 data_width = dbri->mm.channels * dbri->mm.precision;
1460
1461 link_time_slot(dbri, 20, PIPEoutput, 16, 32, dbri->mm.offset + 32);
1462 link_time_slot(dbri, 4, PIPEoutput, 16, data_width, dbri->mm.offset);
1463 link_time_slot(dbri, 6, PIPEinput, 16, data_width, dbri->mm.offset);
1464 link_time_slot(dbri, 21, PIPEinput, 16, 16, dbri->mm.offset + 40);
1465
1466 /* FIXME: enable CHI after _setdata? */
1467 tmp = sbus_readl(dbri->regs + REG0);
1468 tmp |= D_C; /* Enable CHI */
1469 sbus_writel(tmp, dbri->regs + REG0);
1470
1471 cs4215_setdata(dbri, 0);
1472 }
1473
1474 /*
1475 * Send the control information (i.e. audio format)
1476 */
1477 static int cs4215_setctrl(snd_dbri_t * dbri)
1478 {
1479 int i, val;
1480 u32 tmp;
1481
1482 /* FIXME - let the CPU do something useful during these delays */
1483
1484 /* Temporarily mute outputs, and wait 1/8000 sec (125 us)
1485 * to make sure this takes. This avoids clicking noises.
1486 */
1487 cs4215_setdata(dbri, 1);
1488 udelay(125);
1489
1490 /*
1491 * Enable Control mode: Set DBRI's PIO3 (4215's D/~C) to 0, then wait
1492 * 12 cycles <= 12/(5512.5*64) sec = 34.01 usec
1493 */
1494 val = D_ENPIO | D_PIO1 | (dbri->mm.onboard ? D_PIO0 : D_PIO2);
1495 sbus_writel(val, dbri->regs + REG2);
1496 dprintk(D_MM, "cs4215_setctrl: reg2=0x%x\n", val);
1497 udelay(34);
1498
1499 /* In Control mode, the CS4215 is a slave device, so the DBRI must
1500 * operate as CHI master, supplying clocking and frame synchronization.
1501 *
1502 * In Data mode, however, the CS4215 must be CHI master to insure
1503 * that its data stream is synchronous with its codec.
1504 *
1505 * The upshot of all this? We start by putting the DBRI into master
1506 * mode, program the CS4215 in Control mode, then switch the CS4215
1507 * into Data mode and put the DBRI into slave mode. Various timing
1508 * requirements must be observed along the way.
1509 *
1510 * Oh, and one more thing, on a SPARCStation 20 (and maybe
1511 * others?), the addressing of the CS4215's time slots is
1512 * offset by eight bits, so we add eight to all the "cycle"
1513 * values in the Define Time Slot (DTS) commands. This is
1514 * done in hardware by a TI 248 that delays the DBRI->4215
1515 * frame sync signal by eight clock cycles. Anybody know why?
1516 */
1517 tmp = sbus_readl(dbri->regs + REG0);
1518 tmp &= ~D_C; /* Disable CHI */
1519 sbus_writel(tmp, dbri->regs + REG0);
1520
1521 reset_chi(dbri, CHImaster, 128);
1522
1523 /*
1524 * Control mode:
1525 * Pipe 17: Send timeslots 1-4 (slots 5-8 are readonly)
1526 * Pipe 18: Receive timeslot 1 (clb).
1527 * Pipe 19: Receive timeslot 7 (version).
1528 */
1529
1530 link_time_slot(dbri, 17, PIPEoutput, 16, 32, dbri->mm.offset);
1531 link_time_slot(dbri, 18, PIPEinput, 16, 8, dbri->mm.offset);
1532 link_time_slot(dbri, 19, PIPEinput, 16, 8, dbri->mm.offset + 48);
1533
1534 /* Wait for the chip to echo back CLB (Control Latch Bit) as zero */
1535 dbri->mm.ctrl[0] &= ~CS4215_CLB;
1536 xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl);
1537
1538 tmp = sbus_readl(dbri->regs + REG0);
1539 tmp |= D_C; /* Enable CHI */
1540 sbus_writel(tmp, dbri->regs + REG0);
1541
1542 for (i = 10; ((dbri->mm.status & 0xe4) != 0x20); --i) {
1543 msleep_interruptible(1);
1544 }
1545 if (i == 0) {
1546 dprintk(D_MM, "CS4215 didn't respond to CLB (0x%02x)\n",
1547 dbri->mm.status);
1548 return -1;
1549 }
1550
1551 /* Disable changes to our copy of the version number, as we are about
1552 * to leave control mode.
1553 */
1554 recv_fixed(dbri, 19, NULL);
1555
1556 /* Terminate CS4215 control mode - data sheet says
1557 * "Set CLB=1 and send two more frames of valid control info"
1558 */
1559 dbri->mm.ctrl[0] |= CS4215_CLB;
1560 xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl);
1561
1562 /* Two frames of control info @ 8kHz frame rate = 250 us delay */
1563 udelay(250);
1564
1565 cs4215_setdata(dbri, 0);
1566
1567 return 0;
1568 }
1569
1570 /*
1571 * Setup the codec with the sampling rate, audio format and number of
1572 * channels.
1573 * As part of the process we resend the settings for the data
1574 * timeslots as well.
1575 */
1576 static int cs4215_prepare(snd_dbri_t * dbri, unsigned int rate,
1577 snd_pcm_format_t format, unsigned int channels)
1578 {
1579 int freq_idx;
1580 int ret = 0;
1581
1582 /* Lookup index for this rate */
1583 for (freq_idx = 0; CS4215_FREQ[freq_idx].freq != 0; freq_idx++) {
1584 if (CS4215_FREQ[freq_idx].freq == rate)
1585 break;
1586 }
1587 if (CS4215_FREQ[freq_idx].freq != rate) {
1588 printk(KERN_WARNING "DBRI: Unsupported rate %d Hz\n", rate);
1589 return -1;
1590 }
1591
1592 switch (format) {
1593 case SNDRV_PCM_FORMAT_MU_LAW:
1594 dbri->mm.ctrl[1] = CS4215_DFR_ULAW;
1595 dbri->mm.precision = 8;
1596 break;
1597 case SNDRV_PCM_FORMAT_A_LAW:
1598 dbri->mm.ctrl[1] = CS4215_DFR_ALAW;
1599 dbri->mm.precision = 8;
1600 break;
1601 case SNDRV_PCM_FORMAT_U8:
1602 dbri->mm.ctrl[1] = CS4215_DFR_LINEAR8;
1603 dbri->mm.precision = 8;
1604 break;
1605 case SNDRV_PCM_FORMAT_S16_BE:
1606 dbri->mm.ctrl[1] = CS4215_DFR_LINEAR16;
1607 dbri->mm.precision = 16;
1608 break;
1609 default:
1610 printk(KERN_WARNING "DBRI: Unsupported format %d\n", format);
1611 return -1;
1612 }
1613
1614 /* Add rate parameters */
1615 dbri->mm.ctrl[1] |= CS4215_FREQ[freq_idx].csval;
1616 dbri->mm.ctrl[2] = CS4215_XCLK |
1617 CS4215_BSEL_128 | CS4215_FREQ[freq_idx].xtal;
1618
1619 dbri->mm.channels = channels;
1620 /* Stereo bit: 8 bit stereo not working yet. */
1621 if ((channels > 1) && (dbri->mm.precision == 16))
1622 dbri->mm.ctrl[1] |= CS4215_DFR_STEREO;
1623
1624 ret = cs4215_setctrl(dbri);
1625 if (ret == 0)
1626 cs4215_open(dbri); /* set codec to data mode */
1627
1628 return ret;
1629 }
1630
1631 /*
1632 *
1633 */
1634 static int cs4215_init(snd_dbri_t * dbri)
1635 {
1636 u32 reg2 = sbus_readl(dbri->regs + REG2);
1637 dprintk(D_MM, "cs4215_init: reg2=0x%x\n", reg2);
1638
1639 /* Look for the cs4215 chips */
1640 if (reg2 & D_PIO2) {
1641 dprintk(D_MM, "Onboard CS4215 detected\n");
1642 dbri->mm.onboard = 1;
1643 }
1644 if (reg2 & D_PIO0) {
1645 dprintk(D_MM, "Speakerbox detected\n");
1646 dbri->mm.onboard = 0;
1647
1648 if (reg2 & D_PIO2) {
1649 printk(KERN_INFO "DBRI: Using speakerbox / "
1650 "ignoring onboard mmcodec.\n");
1651 sbus_writel(D_ENPIO2, dbri->regs + REG2);
1652 }
1653 }
1654
1655 if (!(reg2 & (D_PIO0 | D_PIO2))) {
1656 printk(KERN_ERR "DBRI: no mmcodec found.\n");
1657 return -EIO;
1658 }
1659
1660 cs4215_setup_pipes(dbri);
1661
1662 cs4215_init_data(&dbri->mm);
1663
1664 /* Enable capture of the status & version timeslots. */
1665 recv_fixed(dbri, 18, &dbri->mm.status);
1666 recv_fixed(dbri, 19, &dbri->mm.version);
1667
1668 dbri->mm.offset = dbri->mm.onboard ? 0 : 8;
1669 if (cs4215_setctrl(dbri) == -1 || dbri->mm.version == 0xff) {
1670 dprintk(D_MM, "CS4215 failed probe at offset %d\n",
1671 dbri->mm.offset);
1672 return -EIO;
1673 }
1674 dprintk(D_MM, "Found CS4215 at offset %d\n", dbri->mm.offset);
1675
1676 return 0;
1677 }
1678
1679 /*
1680 ****************************************************************************
1681 *************************** DBRI interrupt handler *************************
1682 ****************************************************************************
1683
1684 The DBRI communicates with the CPU mainly via a circular interrupt
1685 buffer. When an interrupt is signaled, the CPU walks through the
1686 buffer and calls dbri_process_one_interrupt() for each interrupt word.
1687 Complicated interrupts are handled by dedicated functions (which
1688 appear first in this file). Any pending interrupts can be serviced by
1689 calling dbri_process_interrupt_buffer(), which works even if the CPU's
1690 interrupts are disabled. This function is used by dbri_cmdlock()
1691 to make sure we're synced up with the chip before each command sequence,
1692 even if we're running cli'ed.
1693
1694 */
1695
1696 /* xmit_descs()
1697 *
1698 * Transmit the current TD's for recording/playing, if needed.
1699 * For playback, ALSA has filled the DMA memory with new data (we hope).
1700 */
1701 static void xmit_descs(unsigned long data)
1702 {
1703 snd_dbri_t *dbri = (snd_dbri_t *) data;
1704 dbri_streaminfo_t *info;
1705 volatile s32 *cmd;
1706 unsigned long flags;
1707 int first_td;
1708
1709 if (dbri == NULL)
1710 return; /* Disabled */
1711
1712 /* First check the recording stream for buffer overflow */
1713 info = &dbri->stream_info[DBRI_REC];
1714 spin_lock_irqsave(&dbri->lock, flags);
1715
1716 if ((info->left >= info->size) && (info->pipe >= 0)) {
1717 first_td = dbri->pipes[info->pipe].first_desc;
1718
1719 dprintk(D_DESC, "xmit_descs rec @ TD %d\n", first_td);
1720
1721 /* Stream could be closed by the time we run. */
1722 if (first_td < 0) {
1723 goto play;
1724 }
1725
1726 cmd = dbri_cmdlock(dbri, NoGetLock);
1727 *(cmd++) = DBRI_CMD(D_SDP, 0,
1728 dbri->pipes[info->pipe].sdp
1729 | D_SDP_P | D_SDP_EVERY | D_SDP_C);
1730 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, first_td);
1731 dbri_cmdsend(dbri, cmd);
1732
1733 /* Reset our admin of the pipe & bytes read. */
1734 dbri->pipes[info->pipe].desc = first_td;
1735 info->left = 0;
1736 }
1737
1738 play:
1739 spin_unlock_irqrestore(&dbri->lock, flags);
1740
1741 /* Now check the playback stream for buffer underflow */
1742 info = &dbri->stream_info[DBRI_PLAY];
1743 spin_lock_irqsave(&dbri->lock, flags);
1744
1745 if ((info->left <= 0) && (info->pipe >= 0)) {
1746 first_td = dbri->pipes[info->pipe].first_desc;
1747
1748 dprintk(D_DESC, "xmit_descs play @ TD %d\n", first_td);
1749
1750 /* Stream could be closed by the time we run. */
1751 if (first_td < 0) {
1752 spin_unlock_irqrestore(&dbri->lock, flags);
1753 return;
1754 }
1755
1756 cmd = dbri_cmdlock(dbri, NoGetLock);
1757 *(cmd++) = DBRI_CMD(D_SDP, 0,
1758 dbri->pipes[info->pipe].sdp
1759 | D_SDP_P | D_SDP_EVERY | D_SDP_C);
1760 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, first_td);
1761 dbri_cmdsend(dbri, cmd);
1762
1763 /* Reset our admin of the pipe & bytes written. */
1764 dbri->pipes[info->pipe].desc = first_td;
1765 info->left = info->size;
1766 }
1767 spin_unlock_irqrestore(&dbri->lock, flags);
1768 }
1769
1770 DECLARE_TASKLET(xmit_descs_task, xmit_descs, 0);
1771
1772 /* transmission_complete_intr()
1773 *
1774 * Called by main interrupt handler when DBRI signals transmission complete
1775 * on a pipe (interrupt triggered by the B bit in a transmit descriptor).
1776 *
1777 * Walks through the pipe's list of transmit buffer descriptors and marks
1778 * them as available. Stops when the first descriptor is found without
1779 * TBC (Transmit Buffer Complete) set, or we've run through them all.
1780 *
1781 * The DMA buffers are not released, but re-used. Since the transmit buffer
1782 * descriptors are not clobbered, they can be re-submitted as is. This is
1783 * done by the xmit_descs() tasklet above since that could take longer.
1784 */
1785
1786 static void transmission_complete_intr(snd_dbri_t * dbri, int pipe)
1787 {
1788 dbri_streaminfo_t *info;
1789 int td;
1790 int status;
1791
1792 info = &dbri->stream_info[DBRI_PLAY];
1793
1794 td = dbri->pipes[pipe].desc;
1795 while (td >= 0) {
1796 if (td >= DBRI_NO_DESCS) {
1797 printk(KERN_ERR "DBRI: invalid td on pipe %d\n", pipe);
1798 return;
1799 }
1800
1801 status = DBRI_TD_STATUS(dbri->dma->desc[td].word4);
1802 if (!(status & DBRI_TD_TBC)) {
1803 break;
1804 }
1805
1806 dprintk(D_INT, "TD %d, status 0x%02x\n", td, status);
1807
1808 dbri->dma->desc[td].word4 = 0; /* Reset it for next time. */
1809 info->offset += dbri->descs[td].len;
1810 info->left -= dbri->descs[td].len;
1811
1812 /* On the last TD, transmit them all again. */
1813 if (dbri->descs[td].next == -1) {
1814 if (info->left > 0) {
1815 printk(KERN_WARNING
1816 "%d bytes left after last transfer.\n",
1817 info->left);
1818 info->left = 0;
1819 }
1820 tasklet_schedule(&xmit_descs_task);
1821 }
1822
1823 td = dbri->descs[td].next;
1824 dbri->pipes[pipe].desc = td;
1825 }
1826
1827 /* Notify ALSA */
1828 if (spin_is_locked(&dbri->lock)) {
1829 spin_unlock(&dbri->lock);
1830 snd_pcm_period_elapsed(info->substream);
1831 spin_lock(&dbri->lock);
1832 } else
1833 snd_pcm_period_elapsed(info->substream);
1834 }
1835
1836 static void reception_complete_intr(snd_dbri_t * dbri, int pipe)
1837 {
1838 dbri_streaminfo_t *info;
1839 int rd = dbri->pipes[pipe].desc;
1840 s32 status;
1841
1842 if (rd < 0 || rd >= DBRI_NO_DESCS) {
1843 printk(KERN_ERR "DBRI: invalid rd on pipe %d\n", pipe);
1844 return;
1845 }
1846
1847 dbri->descs[rd].inuse = 0;
1848 dbri->pipes[pipe].desc = dbri->descs[rd].next;
1849 status = dbri->dma->desc[rd].word1;
1850 dbri->dma->desc[rd].word1 = 0; /* Reset it for next time. */
1851
1852 info = &dbri->stream_info[DBRI_REC];
1853 info->offset += DBRI_RD_CNT(status);
1854 info->left += DBRI_RD_CNT(status);
1855
1856 /* FIXME: Check status */
1857
1858 dprintk(D_INT, "Recv RD %d, status 0x%02x, len %d\n",
1859 rd, DBRI_RD_STATUS(status), DBRI_RD_CNT(status));
1860
1861 /* On the last TD, transmit them all again. */
1862 if (dbri->descs[rd].next == -1) {
1863 if (info->left > info->size) {
1864 printk(KERN_WARNING
1865 "%d bytes recorded in %d size buffer.\n",
1866 info->left, info->size);
1867 }
1868 tasklet_schedule(&xmit_descs_task);
1869 }
1870
1871 /* Notify ALSA */
1872 if (spin_is_locked(&dbri->lock)) {
1873 spin_unlock(&dbri->lock);
1874 snd_pcm_period_elapsed(info->substream);
1875 spin_lock(&dbri->lock);
1876 } else
1877 snd_pcm_period_elapsed(info->substream);
1878 }
1879
1880 static void dbri_process_one_interrupt(snd_dbri_t * dbri, int x)
1881 {
1882 int val = D_INTR_GETVAL(x);
1883 int channel = D_INTR_GETCHAN(x);
1884 int command = D_INTR_GETCMD(x);
1885 int code = D_INTR_GETCODE(x);
1886 #ifdef DBRI_DEBUG
1887 int rval = D_INTR_GETRVAL(x);
1888 #endif
1889
1890 if (channel == D_INTR_CMD) {
1891 dprintk(D_CMD, "INTR: Command: %-5s Value:%d\n",
1892 cmds[command], val);
1893 } else {
1894 dprintk(D_INT, "INTR: Chan:%d Code:%d Val:%#x\n",
1895 channel, code, rval);
1896 }
1897
1898 if (channel == D_INTR_CMD && command == D_WAIT) {
1899 dbri->wait_ackd = val;
1900 if (dbri->wait_send != val) {
1901 printk(KERN_ERR "Processing wait command %d when %d was send.\n",
1902 val, dbri->wait_send);
1903 }
1904 return;
1905 }
1906
1907 switch (code) {
1908 case D_INTR_BRDY:
1909 reception_complete_intr(dbri, channel);
1910 break;
1911 case D_INTR_XCMP:
1912 case D_INTR_MINT:
1913 transmission_complete_intr(dbri, channel);
1914 break;
1915 case D_INTR_UNDR:
1916 /* UNDR - Transmission underrun
1917 * resend SDP command with clear pipe bit (C) set
1918 */
1919 {
1920 volatile s32 *cmd;
1921
1922 int pipe = channel;
1923 int td = dbri->pipes[pipe].desc;
1924
1925 dbri->dma->desc[td].word4 = 0;
1926 cmd = dbri_cmdlock(dbri, NoGetLock);
1927 *(cmd++) = DBRI_CMD(D_SDP, 0,
1928 dbri->pipes[pipe].sdp
1929 | D_SDP_P | D_SDP_C | D_SDP_2SAME);
1930 *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, td);
1931 dbri_cmdsend(dbri, cmd);
1932 }
1933 break;
1934 case D_INTR_FXDT:
1935 /* FXDT - Fixed data change */
1936 if (dbri->pipes[channel].sdp & D_SDP_MSB)
1937 val = reverse_bytes(val, dbri->pipes[channel].length);
1938
1939 if (dbri->pipes[channel].recv_fixed_ptr)
1940 *(dbri->pipes[channel].recv_fixed_ptr) = val;
1941 break;
1942 default:
1943 if (channel != D_INTR_CMD)
1944 printk(KERN_WARNING
1945 "DBRI: Ignored Interrupt: %d (0x%x)\n", code, x);
1946 }
1947 }
1948
1949 /* dbri_process_interrupt_buffer advances through the DBRI's interrupt
1950 * buffer until it finds a zero word (indicating nothing more to do
1951 * right now). Non-zero words require processing and are handed off
1952 * to dbri_process_one_interrupt AFTER advancing the pointer. This
1953 * order is important since we might recurse back into this function
1954 * and need to make sure the pointer has been advanced first.
1955 */
1956 static void dbri_process_interrupt_buffer(snd_dbri_t * dbri)
1957 {
1958 s32 x;
1959
1960 while ((x = dbri->dma->intr[dbri->dbri_irqp]) != 0) {
1961 dbri->dma->intr[dbri->dbri_irqp] = 0;
1962 dbri->dbri_irqp++;
1963 if (dbri->dbri_irqp == (DBRI_NO_INTS * DBRI_INT_BLK))
1964 dbri->dbri_irqp = 1;
1965 else if ((dbri->dbri_irqp & (DBRI_INT_BLK - 1)) == 0)
1966 dbri->dbri_irqp++;
1967
1968 dbri_process_one_interrupt(dbri, x);
1969 }
1970 }
1971
1972 static irqreturn_t snd_dbri_interrupt(int irq, void *dev_id,
1973 struct pt_regs *regs)
1974 {
1975 snd_dbri_t *dbri = dev_id;
1976 static int errcnt = 0;
1977 int x;
1978
1979 if (dbri == NULL)
1980 return IRQ_NONE;
1981 spin_lock(&dbri->lock);
1982
1983 /*
1984 * Read it, so the interrupt goes away.
1985 */
1986 x = sbus_readl(dbri->regs + REG1);
1987
1988 if (x & (D_MRR | D_MLE | D_LBG | D_MBE)) {
1989 u32 tmp;
1990
1991 if (x & D_MRR)
1992 printk(KERN_ERR
1993 "DBRI: Multiple Error Ack on SBus reg1=0x%x\n",
1994 x);
1995 if (x & D_MLE)
1996 printk(KERN_ERR
1997 "DBRI: Multiple Late Error on SBus reg1=0x%x\n",
1998 x);
1999 if (x & D_LBG)
2000 printk(KERN_ERR
2001 "DBRI: Lost Bus Grant on SBus reg1=0x%x\n", x);
2002 if (x & D_MBE)
2003 printk(KERN_ERR
2004 "DBRI: Burst Error on SBus reg1=0x%x\n", x);
2005
2006 /* Some of these SBus errors cause the chip's SBus circuitry
2007 * to be disabled, so just re-enable and try to keep going.
2008 *
2009 * The only one I've seen is MRR, which will be triggered
2010 * if you let a transmit pipe underrun, then try to CDP it.
2011 *
2012 * If these things persist, we reset the chip.
2013 */
2014 if ((++errcnt) % 10 == 0) {
2015 dprintk(D_INT, "Interrupt errors exceeded.\n");
2016 dbri_reset(dbri);
2017 } else {
2018 tmp = sbus_readl(dbri->regs + REG0);
2019 tmp &= ~(D_D);
2020 sbus_writel(tmp, dbri->regs + REG0);
2021 }
2022 }
2023
2024 dbri_process_interrupt_buffer(dbri);
2025
2026 /* FIXME: Write 0 into regs to ACK interrupt */
2027
2028 spin_unlock(&dbri->lock);
2029
2030 return IRQ_HANDLED;
2031 }
2032
2033 /****************************************************************************
2034 PCM Interface
2035 ****************************************************************************/
2036 static snd_pcm_hardware_t snd_dbri_pcm_hw = {
2037 .info = (SNDRV_PCM_INFO_MMAP |
2038 SNDRV_PCM_INFO_INTERLEAVED |
2039 SNDRV_PCM_INFO_BLOCK_TRANSFER |
2040 SNDRV_PCM_INFO_MMAP_VALID),
2041 .formats = SNDRV_PCM_FMTBIT_MU_LAW |
2042 SNDRV_PCM_FMTBIT_A_LAW |
2043 SNDRV_PCM_FMTBIT_U8 |
2044 SNDRV_PCM_FMTBIT_S16_BE,
2045 .rates = SNDRV_PCM_RATE_8000_48000,
2046 .rate_min = 8000,
2047 .rate_max = 48000,
2048 .channels_min = 1,
2049 .channels_max = 2,
2050 .buffer_bytes_max = (64 * 1024),
2051 .period_bytes_min = 1,
2052 .period_bytes_max = DBRI_TD_MAXCNT,
2053 .periods_min = 1,
2054 .periods_max = 1024,
2055 };
2056
2057 static int snd_dbri_open(snd_pcm_substream_t * substream)
2058 {
2059 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2060 snd_pcm_runtime_t *runtime = substream->runtime;
2061 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2062 unsigned long flags;
2063
2064 dprintk(D_USR, "open audio output.\n");
2065 runtime->hw = snd_dbri_pcm_hw;
2066
2067 spin_lock_irqsave(&dbri->lock, flags);
2068 info->substream = substream;
2069 info->left = 0;
2070 info->offset = 0;
2071 info->dvma_buffer = 0;
2072 info->pipe = -1;
2073 spin_unlock_irqrestore(&dbri->lock, flags);
2074
2075 cs4215_open(dbri);
2076
2077 return 0;
2078 }
2079
2080 static int snd_dbri_close(snd_pcm_substream_t * substream)
2081 {
2082 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2083 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2084
2085 dprintk(D_USR, "close audio output.\n");
2086 info->substream = NULL;
2087 info->left = 0;
2088 info->offset = 0;
2089
2090 return 0;
2091 }
2092
2093 static int snd_dbri_hw_params(snd_pcm_substream_t * substream,
2094 snd_pcm_hw_params_t * hw_params)
2095 {
2096 snd_pcm_runtime_t *runtime = substream->runtime;
2097 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2098 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2099 int direction;
2100 int ret;
2101
2102 /* set sampling rate, audio format and number of channels */
2103 ret = cs4215_prepare(dbri, params_rate(hw_params),
2104 params_format(hw_params),
2105 params_channels(hw_params));
2106 if (ret != 0)
2107 return ret;
2108
2109 if ((ret = snd_pcm_lib_malloc_pages(substream,
2110 params_buffer_bytes(hw_params))) < 0) {
2111 printk(KERN_ERR "malloc_pages failed with %d\n", ret);
2112 return ret;
2113 }
2114
2115 /* hw_params can get called multiple times. Only map the DMA once.
2116 */
2117 if (info->dvma_buffer == 0) {
2118 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2119 direction = SBUS_DMA_TODEVICE;
2120 else
2121 direction = SBUS_DMA_FROMDEVICE;
2122
2123 info->dvma_buffer = sbus_map_single(dbri->sdev,
2124 runtime->dma_area,
2125 params_buffer_bytes(hw_params),
2126 direction);
2127 }
2128
2129 direction = params_buffer_bytes(hw_params);
2130 dprintk(D_USR, "hw_params: %d bytes, dvma=%x\n",
2131 direction, info->dvma_buffer);
2132 return 0;
2133 }
2134
2135 static int snd_dbri_hw_free(snd_pcm_substream_t * substream)
2136 {
2137 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2138 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2139 int direction;
2140 dprintk(D_USR, "hw_free.\n");
2141
2142 /* hw_free can get called multiple times. Only unmap the DMA once.
2143 */
2144 if (info->dvma_buffer) {
2145 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2146 direction = SBUS_DMA_TODEVICE;
2147 else
2148 direction = SBUS_DMA_FROMDEVICE;
2149
2150 sbus_unmap_single(dbri->sdev, info->dvma_buffer,
2151 substream->runtime->buffer_size, direction);
2152 info->dvma_buffer = 0;
2153 }
2154 info->pipe = -1;
2155
2156 return snd_pcm_lib_free_pages(substream);
2157 }
2158
2159 static int snd_dbri_prepare(snd_pcm_substream_t * substream)
2160 {
2161 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2162 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2163 snd_pcm_runtime_t *runtime = substream->runtime;
2164 int ret;
2165
2166 info->size = snd_pcm_lib_buffer_bytes(substream);
2167 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
2168 info->pipe = 4; /* Send pipe */
2169 else {
2170 info->pipe = 6; /* Receive pipe */
2171 info->left = info->size; /* To trigger submittal */
2172 }
2173
2174 spin_lock_irq(&dbri->lock);
2175
2176 /* Setup the all the transmit/receive desciptors to cover the
2177 * whole DMA buffer.
2178 */
2179 ret = setup_descs(dbri, DBRI_STREAMNO(substream),
2180 snd_pcm_lib_period_bytes(substream));
2181
2182 runtime->stop_threshold = DBRI_TD_MAXCNT / runtime->channels;
2183
2184 spin_unlock_irq(&dbri->lock);
2185
2186 dprintk(D_USR, "prepare audio output. %d bytes\n", info->size);
2187 return ret;
2188 }
2189
2190 static int snd_dbri_trigger(snd_pcm_substream_t * substream, int cmd)
2191 {
2192 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2193 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2194 int ret = 0;
2195
2196 switch (cmd) {
2197 case SNDRV_PCM_TRIGGER_START:
2198 dprintk(D_USR, "start audio, period is %d bytes\n",
2199 (int)snd_pcm_lib_period_bytes(substream));
2200 /* Enable & schedule the tasklet that re-submits the TDs. */
2201 xmit_descs_task.data = (unsigned long)dbri;
2202 tasklet_schedule(&xmit_descs_task);
2203 break;
2204 case SNDRV_PCM_TRIGGER_STOP:
2205 dprintk(D_USR, "stop audio.\n");
2206 /* Make the tasklet bail out immediately. */
2207 xmit_descs_task.data = 0;
2208 reset_pipe(dbri, info->pipe);
2209 break;
2210 default:
2211 ret = -EINVAL;
2212 }
2213
2214 return ret;
2215 }
2216
2217 static snd_pcm_uframes_t snd_dbri_pointer(snd_pcm_substream_t * substream)
2218 {
2219 snd_dbri_t *dbri = snd_pcm_substream_chip(substream);
2220 dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream);
2221 snd_pcm_uframes_t ret;
2222
2223 ret = bytes_to_frames(substream->runtime, info->offset)
2224 % substream->runtime->buffer_size;
2225 dprintk(D_USR, "I/O pointer: %ld frames, %d bytes left.\n",
2226 ret, info->left);
2227 return ret;
2228 }
2229
2230 static snd_pcm_ops_t snd_dbri_ops = {
2231 .open = snd_dbri_open,
2232 .close = snd_dbri_close,
2233 .ioctl = snd_pcm_lib_ioctl,
2234 .hw_params = snd_dbri_hw_params,
2235 .hw_free = snd_dbri_hw_free,
2236 .prepare = snd_dbri_prepare,
2237 .trigger = snd_dbri_trigger,
2238 .pointer = snd_dbri_pointer,
2239 };
2240
2241 static int __devinit snd_dbri_pcm(snd_dbri_t * dbri)
2242 {
2243 snd_pcm_t *pcm;
2244 int err;
2245
2246 if ((err = snd_pcm_new(dbri->card,
2247 /* ID */ "sun_dbri",
2248 /* device */ 0,
2249 /* playback count */ 1,
2250 /* capture count */ 1, &pcm)) < 0)
2251 return err;
2252 snd_assert(pcm != NULL, return -EINVAL);
2253
2254 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_dbri_ops);
2255 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_dbri_ops);
2256
2257 pcm->private_data = dbri;
2258 pcm->info_flags = 0;
2259 strcpy(pcm->name, dbri->card->shortname);
2260 dbri->pcm = pcm;
2261
2262 if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm,
2263 SNDRV_DMA_TYPE_CONTINUOUS,
2264 snd_dma_continuous_data(GFP_KERNEL),
2265 64 * 1024, 64 * 1024)) < 0) {
2266 return err;
2267 }
2268
2269 return 0;
2270 }
2271
2272 /*****************************************************************************
2273 Mixer interface
2274 *****************************************************************************/
2275
2276 static int snd_cs4215_info_volume(snd_kcontrol_t * kcontrol,
2277 snd_ctl_elem_info_t * uinfo)
2278 {
2279 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2280 uinfo->count = 2;
2281 uinfo->value.integer.min = 0;
2282 if (kcontrol->private_value == DBRI_PLAY) {
2283 uinfo->value.integer.max = DBRI_MAX_VOLUME;
2284 } else {
2285 uinfo->value.integer.max = DBRI_MAX_GAIN;
2286 }
2287 return 0;
2288 }
2289
2290 static int snd_cs4215_get_volume(snd_kcontrol_t * kcontrol,
2291 snd_ctl_elem_value_t * ucontrol)
2292 {
2293 snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol);
2294 dbri_streaminfo_t *info;
2295 snd_assert(dbri != NULL, return -EINVAL);
2296 info = &dbri->stream_info[kcontrol->private_value];
2297 snd_assert(info != NULL, return -EINVAL);
2298
2299 ucontrol->value.integer.value[0] = info->left_gain;
2300 ucontrol->value.integer.value[1] = info->right_gain;
2301 return 0;
2302 }
2303
2304 static int snd_cs4215_put_volume(snd_kcontrol_t * kcontrol,
2305 snd_ctl_elem_value_t * ucontrol)
2306 {
2307 snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol);
2308 dbri_streaminfo_t *info = &dbri->stream_info[kcontrol->private_value];
2309 unsigned long flags;
2310 int changed = 0;
2311
2312 if (info->left_gain != ucontrol->value.integer.value[0]) {
2313 info->left_gain = ucontrol->value.integer.value[0];
2314 changed = 1;
2315 }
2316 if (info->right_gain != ucontrol->value.integer.value[1]) {
2317 info->right_gain = ucontrol->value.integer.value[1];
2318 changed = 1;
2319 }
2320 if (changed == 1) {
2321 /* First mute outputs, and wait 1/8000 sec (125 us)
2322 * to make sure this takes. This avoids clicking noises.
2323 */
2324 spin_lock_irqsave(&dbri->lock, flags);
2325
2326 cs4215_setdata(dbri, 1);
2327 udelay(125);
2328 cs4215_setdata(dbri, 0);
2329
2330 spin_unlock_irqrestore(&dbri->lock, flags);
2331 }
2332 return changed;
2333 }
2334
2335 static int snd_cs4215_info_single(snd_kcontrol_t * kcontrol,
2336 snd_ctl_elem_info_t * uinfo)
2337 {
2338 int mask = (kcontrol->private_value >> 16) & 0xff;
2339
2340 uinfo->type = (mask == 1) ?
2341 SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2342 uinfo->count = 1;
2343 uinfo->value.integer.min = 0;
2344 uinfo->value.integer.max = mask;
2345 return 0;
2346 }
2347
2348 static int snd_cs4215_get_single(snd_kcontrol_t * kcontrol,
2349 snd_ctl_elem_value_t * ucontrol)
2350 {
2351 snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol);
2352 int elem = kcontrol->private_value & 0xff;
2353 int shift = (kcontrol->private_value >> 8) & 0xff;
2354 int mask = (kcontrol->private_value >> 16) & 0xff;
2355 int invert = (kcontrol->private_value >> 24) & 1;
2356 snd_assert(dbri != NULL, return -EINVAL);
2357
2358 if (elem < 4) {
2359 ucontrol->value.integer.value[0] =
2360 (dbri->mm.data[elem] >> shift) & mask;
2361 } else {
2362 ucontrol->value.integer.value[0] =
2363 (dbri->mm.ctrl[elem - 4] >> shift) & mask;
2364 }
2365
2366 if (invert == 1) {
2367 ucontrol->value.integer.value[0] =
2368 mask - ucontrol->value.integer.value[0];
2369 }
2370 return 0;
2371 }
2372
2373 static int snd_cs4215_put_single(snd_kcontrol_t * kcontrol,
2374 snd_ctl_elem_value_t * ucontrol)
2375 {
2376 snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol);
2377 unsigned long flags;
2378 int elem = kcontrol->private_value & 0xff;
2379 int shift = (kcontrol->private_value >> 8) & 0xff;
2380 int mask = (kcontrol->private_value >> 16) & 0xff;
2381 int invert = (kcontrol->private_value >> 24) & 1;
2382 int changed = 0;
2383 unsigned short val;
2384 snd_assert(dbri != NULL, return -EINVAL);
2385
2386 val = (ucontrol->value.integer.value[0] & mask);
2387 if (invert == 1)
2388 val = mask - val;
2389 val <<= shift;
2390
2391 if (elem < 4) {
2392 dbri->mm.data[elem] = (dbri->mm.data[elem] &
2393 ~(mask << shift)) | val;
2394 changed = (val != dbri->mm.data[elem]);
2395 } else {
2396 dbri->mm.ctrl[elem - 4] = (dbri->mm.ctrl[elem - 4] &
2397 ~(mask << shift)) | val;
2398 changed = (val != dbri->mm.ctrl[elem - 4]);
2399 }
2400
2401 dprintk(D_GEN, "put_single: mask=0x%x, changed=%d, "
2402 "mixer-value=%ld, mm-value=0x%x\n",
2403 mask, changed, ucontrol->value.integer.value[0],
2404 dbri->mm.data[elem & 3]);
2405
2406 if (changed) {
2407 /* First mute outputs, and wait 1/8000 sec (125 us)
2408 * to make sure this takes. This avoids clicking noises.
2409 */
2410 spin_lock_irqsave(&dbri->lock, flags);
2411
2412 cs4215_setdata(dbri, 1);
2413 udelay(125);
2414 cs4215_setdata(dbri, 0);
2415
2416 spin_unlock_irqrestore(&dbri->lock, flags);
2417 }
2418 return changed;
2419 }
2420
2421 /* Entries 0-3 map to the 4 data timeslots, entries 4-7 map to the 4 control
2422 timeslots. Shift is the bit offset in the timeslot, mask defines the
2423 number of bits. invert is a boolean for use with attenuation.
2424 */
2425 #define CS4215_SINGLE(xname, entry, shift, mask, invert) \
2426 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
2427 .info = snd_cs4215_info_single, \
2428 .get = snd_cs4215_get_single, .put = snd_cs4215_put_single, \
2429 .private_value = entry | (shift << 8) | (mask << 16) | (invert << 24) },
2430
2431 static snd_kcontrol_new_t dbri_controls[] __devinitdata = {
2432 {
2433 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2434 .name = "Playback Volume",
2435 .info = snd_cs4215_info_volume,
2436 .get = snd_cs4215_get_volume,
2437 .put = snd_cs4215_put_volume,
2438 .private_value = DBRI_PLAY,
2439 },
2440 CS4215_SINGLE("Headphone switch", 0, 7, 1, 0)
2441 CS4215_SINGLE("Line out switch", 0, 6, 1, 0)
2442 CS4215_SINGLE("Speaker switch", 1, 6, 1, 0)
2443 {
2444 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2445 .name = "Capture Volume",
2446 .info = snd_cs4215_info_volume,
2447 .get = snd_cs4215_get_volume,
2448 .put = snd_cs4215_put_volume,
2449 .private_value = DBRI_REC,
2450 },
2451 /* FIXME: mic/line switch */
2452 CS4215_SINGLE("Line in switch", 2, 4, 1, 0)
2453 CS4215_SINGLE("High Pass Filter switch", 5, 7, 1, 0)
2454 CS4215_SINGLE("Monitor Volume", 3, 4, 0xf, 1)
2455 CS4215_SINGLE("Mic boost", 4, 4, 1, 1)
2456 };
2457
2458 #define NUM_CS4215_CONTROLS (sizeof(dbri_controls)/sizeof(snd_kcontrol_new_t))
2459
2460 static int __init snd_dbri_mixer(snd_dbri_t * dbri)
2461 {
2462 snd_card_t *card;
2463 int idx, err;
2464
2465 snd_assert(dbri != NULL && dbri->card != NULL, return -EINVAL);
2466
2467 card = dbri->card;
2468 strcpy(card->mixername, card->shortname);
2469
2470 for (idx = 0; idx < NUM_CS4215_CONTROLS; idx++) {
2471 if ((err = snd_ctl_add(card,
2472 snd_ctl_new1(&dbri_controls[idx], dbri))) < 0)
2473 return err;
2474 }
2475
2476 for (idx = DBRI_REC; idx < DBRI_NO_STREAMS; idx++) {
2477 dbri->stream_info[idx].left_gain = 0;
2478 dbri->stream_info[idx].right_gain = 0;
2479 dbri->stream_info[idx].balance = DBRI_MID_BALANCE;
2480 }
2481
2482 return 0;
2483 }
2484
2485 /****************************************************************************
2486 /proc interface
2487 ****************************************************************************/
2488 static void dbri_regs_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer)
2489 {
2490 snd_dbri_t *dbri = entry->private_data;
2491
2492 snd_iprintf(buffer, "REG0: 0x%x\n", sbus_readl(dbri->regs + REG0));
2493 snd_iprintf(buffer, "REG2: 0x%x\n", sbus_readl(dbri->regs + REG2));
2494 snd_iprintf(buffer, "REG8: 0x%x\n", sbus_readl(dbri->regs + REG8));
2495 snd_iprintf(buffer, "REG9: 0x%x\n", sbus_readl(dbri->regs + REG9));
2496 }
2497
2498 #ifdef DBRI_DEBUG
2499 static void dbri_debug_read(snd_info_entry_t * entry,
2500 snd_info_buffer_t * buffer)
2501 {
2502 snd_dbri_t *dbri = entry->private_data;
2503 int pipe;
2504 snd_iprintf(buffer, "debug=%d\n", dbri_debug);
2505
2506 for (pipe = 0; pipe < 32; pipe++) {
2507 if (pipe_active(dbri, pipe)) {
2508 struct dbri_pipe *pptr = &dbri->pipes[pipe];
2509 snd_iprintf(buffer,
2510 "Pipe %d: %s SDP=0x%x desc=%d, "
2511 "len=%d @ %d prev: %d next %d\n",
2512 pipe,
2513 (pptr->direction ==
2514 PIPEinput ? "input" : "output"), pptr->sdp,
2515 pptr->desc, pptr->length, pptr->cycle,
2516 pptr->prevpipe, pptr->nextpipe);
2517 }
2518 }
2519 }
2520 #endif
2521
2522 void snd_dbri_proc(snd_dbri_t * dbri)
2523 {
2524 snd_info_entry_t *entry;
2525 int err;
2526
2527 err = snd_card_proc_new(dbri->card, "regs", &entry);
2528 snd_info_set_text_ops(entry, dbri, 1024, dbri_regs_read);
2529
2530 #ifdef DBRI_DEBUG
2531 err = snd_card_proc_new(dbri->card, "debug", &entry);
2532 snd_info_set_text_ops(entry, dbri, 4096, dbri_debug_read);
2533 entry->mode = S_IFREG | S_IRUGO; /* Readable only. */
2534 #endif
2535 }
2536
2537 /*
2538 ****************************************************************************
2539 **************************** Initialization ********************************
2540 ****************************************************************************
2541 */
2542 static void snd_dbri_free(snd_dbri_t * dbri);
2543
2544 static int __init snd_dbri_create(snd_card_t * card,
2545 struct sbus_dev *sdev,
2546 struct linux_prom_irqs *irq, int dev)
2547 {
2548 snd_dbri_t *dbri = card->private_data;
2549 int err;
2550
2551 spin_lock_init(&dbri->lock);
2552 dbri->card = card;
2553 dbri->sdev = sdev;
2554 dbri->irq = irq->pri;
2555 dbri->dbri_version = sdev->prom_name[9];
2556
2557 dbri->dma = sbus_alloc_consistent(sdev, sizeof(struct dbri_dma),
2558 &dbri->dma_dvma);
2559 memset((void *)dbri->dma, 0, sizeof(struct dbri_dma));
2560
2561 dprintk(D_GEN, "DMA Cmd Block 0x%p (0x%08x)\n",
2562 dbri->dma, dbri->dma_dvma);
2563
2564 /* Map the registers into memory. */
2565 dbri->regs_size = sdev->reg_addrs[0].reg_size;
2566 dbri->regs = sbus_ioremap(&sdev->resource[0], 0,
2567 dbri->regs_size, "DBRI Registers");
2568 if (!dbri->regs) {
2569 printk(KERN_ERR "DBRI: could not allocate registers\n");
2570 sbus_free_consistent(sdev, sizeof(struct dbri_dma),
2571 (void *)dbri->dma, dbri->dma_dvma);
2572 return -EIO;
2573 }
2574
2575 err = request_irq(dbri->irq, snd_dbri_interrupt, SA_SHIRQ,
2576 "DBRI audio", dbri);
2577 if (err) {
2578 printk(KERN_ERR "DBRI: Can't get irq %d\n", dbri->irq);
2579 sbus_iounmap(dbri->regs, dbri->regs_size);
2580 sbus_free_consistent(sdev, sizeof(struct dbri_dma),
2581 (void *)dbri->dma, dbri->dma_dvma);
2582 return err;
2583 }
2584
2585 /* Do low level initialization of the DBRI and CS4215 chips */
2586 dbri_initialize(dbri);
2587 err = cs4215_init(dbri);
2588 if (err) {
2589 snd_dbri_free(dbri);
2590 return err;
2591 }
2592
2593 dbri->next = dbri_list;
2594 dbri_list = dbri;
2595
2596 return 0;
2597 }
2598
2599 static void snd_dbri_free(snd_dbri_t * dbri)
2600 {
2601 dprintk(D_GEN, "snd_dbri_free\n");
2602 dbri_reset(dbri);
2603
2604 if (dbri->irq)
2605 free_irq(dbri->irq, dbri);
2606
2607 if (dbri->regs)
2608 sbus_iounmap(dbri->regs, dbri->regs_size);
2609
2610 if (dbri->dma)
2611 sbus_free_consistent(dbri->sdev, sizeof(struct dbri_dma),
2612 (void *)dbri->dma, dbri->dma_dvma);
2613 }
2614
2615 static int __init dbri_attach(int prom_node, struct sbus_dev *sdev)
2616 {
2617 snd_dbri_t *dbri;
2618 struct linux_prom_irqs irq;
2619 struct resource *rp;
2620 snd_card_t *card;
2621 static int dev = 0;
2622 int err;
2623
2624 if (sdev->prom_name[9] < 'e') {
2625 printk(KERN_ERR "DBRI: unsupported chip version %c found.\n",
2626 sdev->prom_name[9]);
2627 return -EIO;
2628 }
2629
2630 if (dev >= SNDRV_CARDS)
2631 return -ENODEV;
2632 if (!enable[dev]) {
2633 dev++;
2634 return -ENOENT;
2635 }
2636
2637 err = prom_getproperty(prom_node, "intr", (char *)&irq, sizeof(irq));
2638 if (err < 0) {
2639 printk(KERN_ERR "DBRI-%d: Firmware node lacks IRQ property.\n", dev);
2640 return -ENODEV;
2641 }
2642
2643 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
2644 sizeof(snd_dbri_t));
2645 if (card == NULL)
2646 return -ENOMEM;
2647
2648 strcpy(card->driver, "DBRI");
2649 strcpy(card->shortname, "Sun DBRI");
2650 rp = &sdev->resource[0];
2651 sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %s",
2652 card->shortname,
2653 rp->flags & 0xffL, rp->start, __irq_itoa(irq.pri));
2654
2655 if ((err = snd_dbri_create(card, sdev, &irq, dev)) < 0) {
2656 snd_card_free(card);
2657 return err;
2658 }
2659
2660 dbri = (snd_dbri_t *) card->private_data;
2661 if ((err = snd_dbri_pcm(dbri)) < 0)
2662 goto _err;
2663
2664 if ((err = snd_dbri_mixer(dbri)) < 0)
2665 goto _err;
2666
2667 /* /proc file handling */
2668 snd_dbri_proc(dbri);
2669
2670 if ((err = snd_card_set_generic_dev(card)) < 0)
2671 goto _err;
2672
2673 if ((err = snd_card_register(card)) < 0)
2674 goto _err;
2675
2676 printk(KERN_INFO "audio%d at %p (irq %d) is DBRI(%c)+CS4215(%d)\n",
2677 dev, dbri->regs,
2678 dbri->irq, dbri->dbri_version, dbri->mm.version);
2679 dev++;
2680
2681 return 0;
2682
2683 _err:
2684 snd_dbri_free(dbri);
2685 snd_card_free(card);
2686 return err;
2687 }
2688
2689 /* Probe for the dbri chip and then attach the driver. */
2690 static int __init dbri_init(void)
2691 {
2692 struct sbus_bus *sbus;
2693 struct sbus_dev *sdev;
2694 int found = 0;
2695
2696 /* Probe each SBUS for the DBRI chip(s). */
2697 for_all_sbusdev(sdev, sbus) {
2698 /*
2699 * The version is coded in the last character
2700 */
2701 if (!strncmp(sdev->prom_name, "SUNW,DBRI", 9)) {
2702 dprintk(D_GEN, "DBRI: Found %s in SBUS slot %d\n",
2703 sdev->prom_name, sdev->slot);
2704
2705 if (dbri_attach(sdev->prom_node, sdev) == 0)
2706 found++;
2707 }
2708 }
2709
2710 return (found > 0) ? 0 : -EIO;
2711 }
2712
2713 static void __exit dbri_exit(void)
2714 {
2715 snd_dbri_t *this = dbri_list;
2716
2717 while (this != NULL) {
2718 snd_dbri_t *next = this->next;
2719 snd_card_t *card = this->card;
2720
2721 snd_dbri_free(this);
2722 snd_card_free(card);
2723 this = next;
2724 }
2725 dbri_list = NULL;
2726 }
2727
2728 module_init(dbri_init);
2729 module_exit(dbri_exit);
Linux kernel - Deliverables
This page took 0.087241 seconds and 5 git commands to generate.