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