]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - sound/oss/swarm_cs4297a.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / sound / oss / swarm_cs4297a.c
1 /*******************************************************************************
2 *
3 * "swarm_cs4297a.c" -- Cirrus Logic-Crystal CS4297a linux audio driver.
4 *
5 * Copyright (C) 2001 Broadcom Corporation.
6 * Copyright (C) 2000,2001 Cirrus Logic Corp.
7 * -- adapted from drivers by Thomas Sailer,
8 * -- but don't bug him; Problems should go to:
9 * -- tom woller (twoller@crystal.cirrus.com) or
10 * (audio@crystal.cirrus.com).
11 * -- adapted from cs4281 PCI driver for cs4297a on
12 * BCM1250 Synchronous Serial interface
13 * (Kip Walker, Broadcom Corp.)
14 * Copyright (C) 2004 Maciej W. Rozycki
15 * Copyright (C) 2005 Ralf Baechle (ralf@linux-mips.org)
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 *
31 * Module command line parameters:
32 * none
33 *
34 * Supported devices:
35 * /dev/dsp standard /dev/dsp device, (mostly) OSS compatible
36 * /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
37 * /dev/midi simple MIDI UART interface, no ioctl
38 *
39 * Modification History
40 * 08/20/00 trw - silence and no stopping DAC until release
41 * 08/23/00 trw - added CS_DBG statements, fix interrupt hang issue on DAC stop.
42 * 09/18/00 trw - added 16bit only record with conversion
43 * 09/24/00 trw - added Enhanced Full duplex (separate simultaneous
44 * capture/playback rates)
45 * 10/03/00 trw - fixed mmap (fixed GRECORD and the XMMS mmap test plugin
46 * libOSSm.so)
47 * 10/11/00 trw - modified for 2.4.0-test9 kernel enhancements (NR_MAP removal)
48 * 11/03/00 trw - fixed interrupt loss/stutter, added debug.
49 * 11/10/00 bkz - added __devinit to cs4297a_hw_init()
50 * 11/10/00 trw - fixed SMP and capture spinlock hang.
51 * 12/04/00 trw - cleaned up CSDEBUG flags and added "defaultorder" moduleparm.
52 * 12/05/00 trw - fixed polling (myth2), and added underrun swptr fix.
53 * 12/08/00 trw - added PM support.
54 * 12/14/00 trw - added wrapper code, builds under 2.4.0, 2.2.17-20, 2.2.17-8
55 * (RH/Dell base), 2.2.18, 2.2.12. cleaned up code mods by ident.
56 * 12/19/00 trw - added PM support for 2.2 base (apm_callback). other PM cleanup.
57 * 12/21/00 trw - added fractional "defaultorder" inputs. if >100 then use
58 * defaultorder-100 as power of 2 for the buffer size. example:
59 * 106 = 2^(106-100) = 2^6 = 64 bytes for the buffer size.
60 *
61 *******************************************************************************/
62
63 #include <linux/list.h>
64 #include <linux/module.h>
65 #include <linux/string.h>
66 #include <linux/ioport.h>
67 #include <linux/sched.h>
68 #include <linux/delay.h>
69 #include <linux/sound.h>
70 #include <linux/slab.h>
71 #include <linux/soundcard.h>
72 #include <linux/ac97_codec.h>
73 #include <linux/pci.h>
74 #include <linux/bitops.h>
75 #include <linux/interrupt.h>
76 #include <linux/init.h>
77 #include <linux/poll.h>
78 #include <linux/smp_lock.h>
79
80 #include <asm/byteorder.h>
81 #include <asm/dma.h>
82 #include <asm/io.h>
83 #include <asm/uaccess.h>
84
85 #include <asm/sibyte/sb1250_regs.h>
86 #include <asm/sibyte/sb1250_int.h>
87 #include <asm/sibyte/sb1250_dma.h>
88 #include <asm/sibyte/sb1250_scd.h>
89 #include <asm/sibyte/sb1250_syncser.h>
90 #include <asm/sibyte/sb1250_mac.h>
91 #include <asm/sibyte/sb1250.h>
92
93 struct cs4297a_state;
94
95 static void stop_dac(struct cs4297a_state *s);
96 static void stop_adc(struct cs4297a_state *s);
97 static void start_dac(struct cs4297a_state *s);
98 static void start_adc(struct cs4297a_state *s);
99 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
100
101 // ---------------------------------------------------------------------
102
103 #define CS4297a_MAGIC 0xf00beef1
104
105 // buffer order determines the size of the dma buffer for the driver.
106 // under Linux, a smaller buffer allows more responsiveness from many of the
107 // applications (e.g. games). A larger buffer allows some of the apps (esound)
108 // to not underrun the dma buffer as easily. As default, use 32k (order=3)
109 // rather than 64k as some of the games work more responsively.
110 // log base 2( buff sz = 32k).
111
112 //static unsigned long defaultorder = 3;
113 //MODULE_PARM(defaultorder, "i");
114
115 //
116 // Turn on/off debugging compilation by commenting out "#define CSDEBUG"
117 //
118 #define CSDEBUG 0
119 #if CSDEBUG
120 #define CSDEBUG_INTERFACE 1
121 #else
122 #undef CSDEBUG_INTERFACE
123 #endif
124 //
125 // cs_debugmask areas
126 //
127 #define CS_INIT 0x00000001 // initialization and probe functions
128 #define CS_ERROR 0x00000002 // tmp debugging bit placeholder
129 #define CS_INTERRUPT 0x00000004 // interrupt handler (separate from all other)
130 #define CS_FUNCTION 0x00000008 // enter/leave functions
131 #define CS_WAVE_WRITE 0x00000010 // write information for wave
132 #define CS_WAVE_READ 0x00000020 // read information for wave
133 #define CS_AC97 0x00000040 // AC97 register access
134 #define CS_DESCR 0x00000080 // descriptor management
135 #define CS_OPEN 0x00000400 // all open functions in the driver
136 #define CS_RELEASE 0x00000800 // all release functions in the driver
137 #define CS_PARMS 0x00001000 // functional and operational parameters
138 #define CS_IOCTL 0x00002000 // ioctl (non-mixer)
139 #define CS_TMP 0x10000000 // tmp debug mask bit
140
141 //
142 // CSDEBUG is usual mode is set to 1, then use the
143 // cs_debuglevel and cs_debugmask to turn on or off debugging.
144 // Debug level of 1 has been defined to be kernel errors and info
145 // that should be printed on any released driver.
146 //
147 #if CSDEBUG
148 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask) ) {x;}
149 #else
150 #define CS_DBGOUT(mask,level,x)
151 #endif
152
153 #if CSDEBUG
154 static unsigned long cs_debuglevel = 4; // levels range from 1-9
155 static unsigned long cs_debugmask = CS_INIT /*| CS_IOCTL*/;
156 MODULE_PARM(cs_debuglevel, "i");
157 MODULE_PARM(cs_debugmask, "i");
158 #endif
159 #define CS_TRUE 1
160 #define CS_FALSE 0
161
162 #define CS_TYPE_ADC 0
163 #define CS_TYPE_DAC 1
164
165 #define SER_BASE (A_SER_BASE_1 + KSEG1)
166 #define SS_CSR(t) (SER_BASE+t)
167 #define SS_TXTBL(t) (SER_BASE+R_SER_TX_TABLE_BASE+(t*8))
168 #define SS_RXTBL(t) (SER_BASE+R_SER_RX_TABLE_BASE+(t*8))
169
170 #define FRAME_BYTES 32
171 #define FRAME_SAMPLE_BYTES 4
172
173 /* Should this be variable? */
174 #define SAMPLE_BUF_SIZE (16*1024)
175 #define SAMPLE_FRAME_COUNT (SAMPLE_BUF_SIZE / FRAME_SAMPLE_BYTES)
176 /* The driver can explode/shrink the frames to/from a smaller sample
177 buffer */
178 #define DMA_BLOAT_FACTOR 1
179 #define DMA_DESCR (SAMPLE_FRAME_COUNT / DMA_BLOAT_FACTOR)
180 #define DMA_BUF_SIZE (DMA_DESCR * FRAME_BYTES)
181
182 /* Use the maxmium count (255 == 5.1 ms between interrupts) */
183 #define DMA_INT_CNT ((1 << S_DMA_INT_PKTCNT) - 1)
184
185 /* Figure this out: how many TX DMAs ahead to schedule a reg access */
186 #define REG_LATENCY 150
187
188 #define FRAME_TX_US 20
189
190 #define SERDMA_NEXTBUF(d,f) (((d)->f+1) % (d)->ringsz)
191
192 static const char invalid_magic[] =
193 KERN_CRIT "cs4297a: invalid magic value\n";
194
195 #define VALIDATE_STATE(s) \
196 ({ \
197 if (!(s) || (s)->magic != CS4297a_MAGIC) { \
198 printk(invalid_magic); \
199 return -ENXIO; \
200 } \
201 })
202
203 struct list_head cs4297a_devs = { &cs4297a_devs, &cs4297a_devs };
204
205 typedef struct serdma_descr_s {
206 u64 descr_a;
207 u64 descr_b;
208 } serdma_descr_t;
209
210 typedef unsigned long paddr_t;
211
212 typedef struct serdma_s {
213 unsigned ringsz;
214 serdma_descr_t *descrtab;
215 serdma_descr_t *descrtab_end;
216 paddr_t descrtab_phys;
217
218 serdma_descr_t *descr_add;
219 serdma_descr_t *descr_rem;
220
221 u64 *dma_buf; // buffer for DMA contents (frames)
222 paddr_t dma_buf_phys;
223 u16 *sample_buf; // tmp buffer for sample conversions
224 u16 *sb_swptr;
225 u16 *sb_hwptr;
226 u16 *sb_end;
227
228 dma_addr_t dmaaddr;
229 // unsigned buforder; // Log base 2 of 'dma_buf' size in bytes..
230 unsigned numfrag; // # of 'fragments' in the buffer.
231 unsigned fragshift; // Log base 2 of fragment size.
232 unsigned hwptr, swptr;
233 unsigned total_bytes; // # bytes process since open.
234 unsigned blocks; // last returned blocks value GETOPTR
235 unsigned wakeup; // interrupt occurred on block
236 int count;
237 unsigned underrun; // underrun flag
238 unsigned error; // over/underrun
239 wait_queue_head_t wait;
240 wait_queue_head_t reg_wait;
241 // redundant, but makes calculations easier
242 unsigned fragsize; // 2**fragshift..
243 unsigned sbufsz; // 2**buforder.
244 unsigned fragsamples;
245 // OSS stuff
246 unsigned mapped:1; // Buffer mapped in cs4297a_mmap()?
247 unsigned ready:1; // prog_dmabuf_dac()/adc() successful?
248 unsigned endcleared:1;
249 unsigned type:1; // adc or dac buffer (CS_TYPE_XXX)
250 unsigned ossfragshift;
251 int ossmaxfrags;
252 unsigned subdivision;
253 } serdma_t;
254
255 struct cs4297a_state {
256 // magic
257 unsigned int magic;
258
259 struct list_head list;
260
261 // soundcore stuff
262 int dev_audio;
263 int dev_mixer;
264
265 // hardware resources
266 unsigned int irq;
267
268 struct {
269 unsigned int rx_ovrrn; /* FIFO */
270 unsigned int rx_overflow; /* staging buffer */
271 unsigned int tx_underrun;
272 unsigned int rx_bad;
273 unsigned int rx_good;
274 } stats;
275
276 // mixer registers
277 struct {
278 unsigned short vol[10];
279 unsigned int recsrc;
280 unsigned int modcnt;
281 unsigned short micpreamp;
282 } mix;
283
284 // wave stuff
285 struct properties {
286 unsigned fmt;
287 unsigned fmt_original; // original requested format
288 unsigned channels;
289 unsigned rate;
290 } prop_dac, prop_adc;
291 unsigned conversion:1; // conversion from 16 to 8 bit in progress
292 unsigned ena;
293 spinlock_t lock;
294 struct semaphore open_sem;
295 struct semaphore open_sem_adc;
296 struct semaphore open_sem_dac;
297 mode_t open_mode;
298 wait_queue_head_t open_wait;
299 wait_queue_head_t open_wait_adc;
300 wait_queue_head_t open_wait_dac;
301
302 dma_addr_t dmaaddr_sample_buf;
303 unsigned buforder_sample_buf; // Log base 2 of 'dma_buf' size in bytes..
304
305 serdma_t dma_dac, dma_adc;
306
307 volatile u16 read_value;
308 volatile u16 read_reg;
309 volatile u64 reg_request;
310 };
311
312 #if 1
313 #define prog_codec(a,b)
314 #define dealloc_dmabuf(a,b);
315 #endif
316
317 static int prog_dmabuf_adc(struct cs4297a_state *s)
318 {
319 s->dma_adc.ready = 1;
320 return 0;
321 }
322
323
324 static int prog_dmabuf_dac(struct cs4297a_state *s)
325 {
326 s->dma_dac.ready = 1;
327 return 0;
328 }
329
330 static void clear_advance(void *buf, unsigned bsize, unsigned bptr,
331 unsigned len, unsigned char c)
332 {
333 if (bptr + len > bsize) {
334 unsigned x = bsize - bptr;
335 memset(((char *) buf) + bptr, c, x);
336 bptr = 0;
337 len -= x;
338 }
339 CS_DBGOUT(CS_WAVE_WRITE, 4, printk(KERN_INFO
340 "cs4297a: clear_advance(): memset %d at 0x%.8x for %d size \n",
341 (unsigned)c, (unsigned)((char *) buf) + bptr, len));
342 memset(((char *) buf) + bptr, c, len);
343 }
344
345 #if CSDEBUG
346
347 // DEBUG ROUTINES
348
349 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
350 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
351 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
352 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
353
354 static void cs_printioctl(unsigned int x)
355 {
356 unsigned int i;
357 unsigned char vidx;
358 // Index of mixtable1[] member is Device ID
359 // and must be <= SOUND_MIXER_NRDEVICES.
360 // Value of array member is index into s->mix.vol[]
361 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
362 [SOUND_MIXER_PCM] = 1, // voice
363 [SOUND_MIXER_LINE1] = 2, // AUX
364 [SOUND_MIXER_CD] = 3, // CD
365 [SOUND_MIXER_LINE] = 4, // Line
366 [SOUND_MIXER_SYNTH] = 5, // FM
367 [SOUND_MIXER_MIC] = 6, // Mic
368 [SOUND_MIXER_SPEAKER] = 7, // Speaker
369 [SOUND_MIXER_RECLEV] = 8, // Recording level
370 [SOUND_MIXER_VOLUME] = 9 // Master Volume
371 };
372
373 switch (x) {
374 case SOUND_MIXER_CS_GETDBGMASK:
375 CS_DBGOUT(CS_IOCTL, 4,
376 printk("SOUND_MIXER_CS_GETDBGMASK:\n"));
377 break;
378 case SOUND_MIXER_CS_GETDBGLEVEL:
379 CS_DBGOUT(CS_IOCTL, 4,
380 printk("SOUND_MIXER_CS_GETDBGLEVEL:\n"));
381 break;
382 case SOUND_MIXER_CS_SETDBGMASK:
383 CS_DBGOUT(CS_IOCTL, 4,
384 printk("SOUND_MIXER_CS_SETDBGMASK:\n"));
385 break;
386 case SOUND_MIXER_CS_SETDBGLEVEL:
387 CS_DBGOUT(CS_IOCTL, 4,
388 printk("SOUND_MIXER_CS_SETDBGLEVEL:\n"));
389 break;
390 case OSS_GETVERSION:
391 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION:\n"));
392 break;
393 case SNDCTL_DSP_SYNC:
394 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC:\n"));
395 break;
396 case SNDCTL_DSP_SETDUPLEX:
397 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX:\n"));
398 break;
399 case SNDCTL_DSP_GETCAPS:
400 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS:\n"));
401 break;
402 case SNDCTL_DSP_RESET:
403 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET:\n"));
404 break;
405 case SNDCTL_DSP_SPEED:
406 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED:\n"));
407 break;
408 case SNDCTL_DSP_STEREO:
409 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO:\n"));
410 break;
411 case SNDCTL_DSP_CHANNELS:
412 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS:\n"));
413 break;
414 case SNDCTL_DSP_GETFMTS:
415 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS:\n"));
416 break;
417 case SNDCTL_DSP_SETFMT:
418 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT:\n"));
419 break;
420 case SNDCTL_DSP_POST:
421 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST:\n"));
422 break;
423 case SNDCTL_DSP_GETTRIGGER:
424 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER:\n"));
425 break;
426 case SNDCTL_DSP_SETTRIGGER:
427 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER:\n"));
428 break;
429 case SNDCTL_DSP_GETOSPACE:
430 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE:\n"));
431 break;
432 case SNDCTL_DSP_GETISPACE:
433 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE:\n"));
434 break;
435 case SNDCTL_DSP_NONBLOCK:
436 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK:\n"));
437 break;
438 case SNDCTL_DSP_GETODELAY:
439 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY:\n"));
440 break;
441 case SNDCTL_DSP_GETIPTR:
442 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR:\n"));
443 break;
444 case SNDCTL_DSP_GETOPTR:
445 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR:\n"));
446 break;
447 case SNDCTL_DSP_GETBLKSIZE:
448 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE:\n"));
449 break;
450 case SNDCTL_DSP_SETFRAGMENT:
451 CS_DBGOUT(CS_IOCTL, 4,
452 printk("SNDCTL_DSP_SETFRAGMENT:\n"));
453 break;
454 case SNDCTL_DSP_SUBDIVIDE:
455 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE:\n"));
456 break;
457 case SOUND_PCM_READ_RATE:
458 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE:\n"));
459 break;
460 case SOUND_PCM_READ_CHANNELS:
461 CS_DBGOUT(CS_IOCTL, 4,
462 printk("SOUND_PCM_READ_CHANNELS:\n"));
463 break;
464 case SOUND_PCM_READ_BITS:
465 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS:\n"));
466 break;
467 case SOUND_PCM_WRITE_FILTER:
468 CS_DBGOUT(CS_IOCTL, 4,
469 printk("SOUND_PCM_WRITE_FILTER:\n"));
470 break;
471 case SNDCTL_DSP_SETSYNCRO:
472 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO:\n"));
473 break;
474 case SOUND_PCM_READ_FILTER:
475 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER:\n"));
476 break;
477 case SOUND_MIXER_PRIVATE1:
478 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1:\n"));
479 break;
480 case SOUND_MIXER_PRIVATE2:
481 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2:\n"));
482 break;
483 case SOUND_MIXER_PRIVATE3:
484 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3:\n"));
485 break;
486 case SOUND_MIXER_PRIVATE4:
487 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4:\n"));
488 break;
489 case SOUND_MIXER_PRIVATE5:
490 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5:\n"));
491 break;
492 case SOUND_MIXER_INFO:
493 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO:\n"));
494 break;
495 case SOUND_OLD_MIXER_INFO:
496 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO:\n"));
497 break;
498
499 default:
500 switch (_IOC_NR(x)) {
501 case SOUND_MIXER_VOLUME:
502 CS_DBGOUT(CS_IOCTL, 4,
503 printk("SOUND_MIXER_VOLUME:\n"));
504 break;
505 case SOUND_MIXER_SPEAKER:
506 CS_DBGOUT(CS_IOCTL, 4,
507 printk("SOUND_MIXER_SPEAKER:\n"));
508 break;
509 case SOUND_MIXER_RECLEV:
510 CS_DBGOUT(CS_IOCTL, 4,
511 printk("SOUND_MIXER_RECLEV:\n"));
512 break;
513 case SOUND_MIXER_MIC:
514 CS_DBGOUT(CS_IOCTL, 4,
515 printk("SOUND_MIXER_MIC:\n"));
516 break;
517 case SOUND_MIXER_SYNTH:
518 CS_DBGOUT(CS_IOCTL, 4,
519 printk("SOUND_MIXER_SYNTH:\n"));
520 break;
521 case SOUND_MIXER_RECSRC:
522 CS_DBGOUT(CS_IOCTL, 4,
523 printk("SOUND_MIXER_RECSRC:\n"));
524 break;
525 case SOUND_MIXER_DEVMASK:
526 CS_DBGOUT(CS_IOCTL, 4,
527 printk("SOUND_MIXER_DEVMASK:\n"));
528 break;
529 case SOUND_MIXER_RECMASK:
530 CS_DBGOUT(CS_IOCTL, 4,
531 printk("SOUND_MIXER_RECMASK:\n"));
532 break;
533 case SOUND_MIXER_STEREODEVS:
534 CS_DBGOUT(CS_IOCTL, 4,
535 printk("SOUND_MIXER_STEREODEVS:\n"));
536 break;
537 case SOUND_MIXER_CAPS:
538 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:\n"));
539 break;
540 default:
541 i = _IOC_NR(x);
542 if (i >= SOUND_MIXER_NRDEVICES
543 || !(vidx = mixtable1[i])) {
544 CS_DBGOUT(CS_IOCTL, 4, printk
545 ("UNKNOWN IOCTL: 0x%.8x NR=%d\n",
546 x, i));
547 } else {
548 CS_DBGOUT(CS_IOCTL, 4, printk
549 ("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d\n",
550 x, i));
551 }
552 break;
553 }
554 }
555 }
556 #endif
557
558
559 static int ser_init(struct cs4297a_state *s)
560 {
561 int i;
562
563 CS_DBGOUT(CS_INIT, 2,
564 printk(KERN_INFO "cs4297a: Setting up serial parameters\n"));
565
566 __raw_writeq(M_SYNCSER_CMD_RX_RESET | M_SYNCSER_CMD_TX_RESET, SS_CSR(R_SER_CMD));
567
568 __raw_writeq(M_SYNCSER_MSB_FIRST, SS_CSR(R_SER_MODE));
569 __raw_writeq(32, SS_CSR(R_SER_MINFRM_SZ));
570 __raw_writeq(32, SS_CSR(R_SER_MAXFRM_SZ));
571
572 __raw_writeq(1, SS_CSR(R_SER_TX_RD_THRSH));
573 __raw_writeq(4, SS_CSR(R_SER_TX_WR_THRSH));
574 __raw_writeq(8, SS_CSR(R_SER_RX_RD_THRSH));
575
576 /* This looks good from experimentation */
577 __raw_writeq((M_SYNCSER_TXSYNC_INT | V_SYNCSER_TXSYNC_DLY(0) | M_SYNCSER_TXCLK_EXT |
578 M_SYNCSER_RXSYNC_INT | V_SYNCSER_RXSYNC_DLY(1) | M_SYNCSER_RXCLK_EXT | M_SYNCSER_RXSYNC_EDGE),
579 SS_CSR(R_SER_LINE_MODE));
580
581 /* This looks good from experimentation */
582 __raw_writeq(V_SYNCSER_SEQ_COUNT(14) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_STROBE,
583 SS_TXTBL(0));
584 __raw_writeq(V_SYNCSER_SEQ_COUNT(15) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_BYTE,
585 SS_TXTBL(1));
586 __raw_writeq(V_SYNCSER_SEQ_COUNT(13) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_BYTE,
587 SS_TXTBL(2));
588 __raw_writeq(V_SYNCSER_SEQ_COUNT( 0) | M_SYNCSER_SEQ_ENABLE |
589 M_SYNCSER_SEQ_STROBE | M_SYNCSER_SEQ_LAST, SS_TXTBL(3));
590
591 __raw_writeq(V_SYNCSER_SEQ_COUNT(14) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_STROBE,
592 SS_RXTBL(0));
593 __raw_writeq(V_SYNCSER_SEQ_COUNT(15) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_BYTE,
594 SS_RXTBL(1));
595 __raw_writeq(V_SYNCSER_SEQ_COUNT(13) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_BYTE,
596 SS_RXTBL(2));
597 __raw_writeq(V_SYNCSER_SEQ_COUNT( 0) | M_SYNCSER_SEQ_ENABLE | M_SYNCSER_SEQ_STROBE |
598 M_SYNCSER_SEQ_LAST, SS_RXTBL(3));
599
600 for (i=4; i<16; i++) {
601 /* Just in case... */
602 __raw_writeq(M_SYNCSER_SEQ_LAST, SS_TXTBL(i));
603 __raw_writeq(M_SYNCSER_SEQ_LAST, SS_RXTBL(i));
604 }
605
606 return 0;
607 }
608
609 static int init_serdma(serdma_t *dma)
610 {
611 CS_DBGOUT(CS_INIT, 2,
612 printk(KERN_ERR "cs4297a: desc - %d sbufsize - %d dbufsize - %d\n",
613 DMA_DESCR, SAMPLE_BUF_SIZE, DMA_BUF_SIZE));
614
615 /* Descriptors */
616 dma->ringsz = DMA_DESCR;
617 dma->descrtab = kmalloc(dma->ringsz * sizeof(serdma_descr_t), GFP_KERNEL);
618 if (!dma->descrtab) {
619 printk(KERN_ERR "cs4297a: kmalloc descrtab failed\n");
620 return -1;
621 }
622 memset(dma->descrtab, 0, dma->ringsz * sizeof(serdma_descr_t));
623 dma->descrtab_end = dma->descrtab + dma->ringsz;
624 /* XXX bloddy mess, use proper DMA API here ... */
625 dma->descrtab_phys = CPHYSADDR((long)dma->descrtab);
626 dma->descr_add = dma->descr_rem = dma->descrtab;
627
628 /* Frame buffer area */
629 dma->dma_buf = kmalloc(DMA_BUF_SIZE, GFP_KERNEL);
630 if (!dma->dma_buf) {
631 printk(KERN_ERR "cs4297a: kmalloc dma_buf failed\n");
632 kfree(dma->descrtab);
633 return -1;
634 }
635 memset(dma->dma_buf, 0, DMA_BUF_SIZE);
636 dma->dma_buf_phys = CPHYSADDR((long)dma->dma_buf);
637
638 /* Samples buffer area */
639 dma->sbufsz = SAMPLE_BUF_SIZE;
640 dma->sample_buf = kmalloc(dma->sbufsz, GFP_KERNEL);
641 if (!dma->sample_buf) {
642 printk(KERN_ERR "cs4297a: kmalloc sample_buf failed\n");
643 kfree(dma->descrtab);
644 kfree(dma->dma_buf);
645 return -1;
646 }
647 dma->sb_swptr = dma->sb_hwptr = dma->sample_buf;
648 dma->sb_end = (u16 *)((void *)dma->sample_buf + dma->sbufsz);
649 dma->fragsize = dma->sbufsz >> 1;
650
651 CS_DBGOUT(CS_INIT, 4,
652 printk(KERN_ERR "cs4297a: descrtab - %08x dma_buf - %x sample_buf - %x\n",
653 (int)dma->descrtab, (int)dma->dma_buf,
654 (int)dma->sample_buf));
655
656 return 0;
657 }
658
659 static int dma_init(struct cs4297a_state *s)
660 {
661 int i;
662
663 CS_DBGOUT(CS_INIT, 2,
664 printk(KERN_INFO "cs4297a: Setting up DMA\n"));
665
666 if (init_serdma(&s->dma_adc) ||
667 init_serdma(&s->dma_dac))
668 return -1;
669
670 if (__raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_RX))||
671 __raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_TX))) {
672 panic("DMA state corrupted?!");
673 }
674
675 /* Initialize now - the descr/buffer pairings will never
676 change... */
677 for (i=0; i<DMA_DESCR; i++) {
678 s->dma_dac.descrtab[i].descr_a = M_DMA_SERRX_SOP | V_DMA_DSCRA_A_SIZE(1) |
679 (s->dma_dac.dma_buf_phys + i*FRAME_BYTES);
680 s->dma_dac.descrtab[i].descr_b = V_DMA_DSCRB_PKT_SIZE(FRAME_BYTES);
681 s->dma_adc.descrtab[i].descr_a = V_DMA_DSCRA_A_SIZE(1) |
682 (s->dma_adc.dma_buf_phys + i*FRAME_BYTES);
683 s->dma_adc.descrtab[i].descr_b = 0;
684 }
685
686 __raw_writeq((M_DMA_EOP_INT_EN | V_DMA_INT_PKTCNT(DMA_INT_CNT) |
687 V_DMA_RINGSZ(DMA_DESCR) | M_DMA_TDX_EN),
688 SS_CSR(R_SER_DMA_CONFIG0_RX));
689 __raw_writeq(M_DMA_L2CA, SS_CSR(R_SER_DMA_CONFIG1_RX));
690 __raw_writeq(s->dma_adc.descrtab_phys, SS_CSR(R_SER_DMA_DSCR_BASE_RX));
691
692 __raw_writeq(V_DMA_RINGSZ(DMA_DESCR), SS_CSR(R_SER_DMA_CONFIG0_TX));
693 __raw_writeq(M_DMA_L2CA | M_DMA_NO_DSCR_UPDT, SS_CSR(R_SER_DMA_CONFIG1_TX));
694 __raw_writeq(s->dma_dac.descrtab_phys, SS_CSR(R_SER_DMA_DSCR_BASE_TX));
695
696 /* Prep the receive DMA descriptor ring */
697 __raw_writeq(DMA_DESCR, SS_CSR(R_SER_DMA_DSCR_COUNT_RX));
698
699 __raw_writeq(M_SYNCSER_DMA_RX_EN | M_SYNCSER_DMA_TX_EN, SS_CSR(R_SER_DMA_ENABLE));
700
701 __raw_writeq((M_SYNCSER_RX_SYNC_ERR | M_SYNCSER_RX_OVERRUN | M_SYNCSER_RX_EOP_COUNT),
702 SS_CSR(R_SER_INT_MASK));
703
704 /* Enable the rx/tx; let the codec warm up to the sync and
705 start sending good frames before the receive FIFO is
706 enabled */
707 __raw_writeq(M_SYNCSER_CMD_TX_EN, SS_CSR(R_SER_CMD));
708 udelay(1000);
709 __raw_writeq(M_SYNCSER_CMD_RX_EN | M_SYNCSER_CMD_TX_EN, SS_CSR(R_SER_CMD));
710
711 /* XXXKW is this magic? (the "1" part) */
712 while ((__raw_readq(SS_CSR(R_SER_STATUS)) & 0xf1) != 1)
713 ;
714
715 CS_DBGOUT(CS_INIT, 4,
716 printk(KERN_INFO "cs4297a: status: %08x\n",
717 (unsigned int)(__raw_readq(SS_CSR(R_SER_STATUS)) & 0xffffffff)));
718
719 return 0;
720 }
721
722 static int serdma_reg_access(struct cs4297a_state *s, u64 data)
723 {
724 serdma_t *d = &s->dma_dac;
725 u64 *data_p;
726 unsigned swptr;
727 int flags;
728 serdma_descr_t *descr;
729
730 if (s->reg_request) {
731 printk(KERN_ERR "cs4297a: attempt to issue multiple reg_access\n");
732 return -1;
733 }
734
735 if (s->ena & FMODE_WRITE) {
736 /* Since a writer has the DSP open, we have to mux the
737 request in */
738 s->reg_request = data;
739 interruptible_sleep_on(&s->dma_dac.reg_wait);
740 /* XXXKW how can I deal with the starvation case where
741 the opener isn't writing? */
742 } else {
743 /* Be safe when changing ring pointers */
744 spin_lock_irqsave(&s->lock, flags);
745 if (d->hwptr != d->swptr) {
746 printk(KERN_ERR "cs4297a: reg access found bookkeeping error (hw/sw = %d/%d\n",
747 d->hwptr, d->swptr);
748 spin_unlock_irqrestore(&s->lock, flags);
749 return -1;
750 }
751 swptr = d->swptr;
752 d->hwptr = d->swptr = (d->swptr + 1) % d->ringsz;
753 spin_unlock_irqrestore(&s->lock, flags);
754
755 descr = &d->descrtab[swptr];
756 data_p = &d->dma_buf[swptr * 4];
757 *data_p = cpu_to_be64(data);
758 __raw_writeq(1, SS_CSR(R_SER_DMA_DSCR_COUNT_TX));
759 CS_DBGOUT(CS_DESCR, 4,
760 printk(KERN_INFO "cs4297a: add_tx %p (%x -> %x)\n",
761 data_p, swptr, d->hwptr));
762 }
763
764 CS_DBGOUT(CS_FUNCTION, 6,
765 printk(KERN_INFO "cs4297a: serdma_reg_access()-\n"));
766
767 return 0;
768 }
769
770 //****************************************************************************
771 // "cs4297a_read_ac97" -- Reads an AC97 register
772 //****************************************************************************
773 static int cs4297a_read_ac97(struct cs4297a_state *s, u32 offset,
774 u32 * value)
775 {
776 CS_DBGOUT(CS_AC97, 1,
777 printk(KERN_INFO "cs4297a: read reg %2x\n", offset));
778 if (serdma_reg_access(s, (0xCLL << 60) | (1LL << 47) | ((u64)(offset & 0x7F) << 40)))
779 return -1;
780
781 interruptible_sleep_on(&s->dma_adc.reg_wait);
782 *value = s->read_value;
783 CS_DBGOUT(CS_AC97, 2,
784 printk(KERN_INFO "cs4297a: rdr reg %x -> %x\n", s->read_reg, s->read_value));
785
786 return 0;
787 }
788
789
790 //****************************************************************************
791 // "cs4297a_write_ac97()"-- writes an AC97 register
792 //****************************************************************************
793 static int cs4297a_write_ac97(struct cs4297a_state *s, u32 offset,
794 u32 value)
795 {
796 CS_DBGOUT(CS_AC97, 1,
797 printk(KERN_INFO "cs4297a: write reg %2x -> %04x\n", offset, value));
798 return (serdma_reg_access(s, (0xELL << 60) | ((u64)(offset & 0x7F) << 40) | ((value & 0xffff) << 12)));
799 }
800
801 static void stop_dac(struct cs4297a_state *s)
802 {
803 unsigned long flags;
804
805 CS_DBGOUT(CS_WAVE_WRITE, 3, printk(KERN_INFO "cs4297a: stop_dac():\n"));
806 spin_lock_irqsave(&s->lock, flags);
807 s->ena &= ~FMODE_WRITE;
808 #if 0
809 /* XXXKW what do I really want here? My theory for now is
810 that I just flip the "ena" bit, and the interrupt handler
811 will stop processing the xmit channel */
812 __raw_writeq((s->ena & FMODE_READ) ? M_SYNCSER_DMA_RX_EN : 0,
813 SS_CSR(R_SER_DMA_ENABLE));
814 #endif
815
816 spin_unlock_irqrestore(&s->lock, flags);
817 }
818
819
820 static void start_dac(struct cs4297a_state *s)
821 {
822 unsigned long flags;
823
824 CS_DBGOUT(CS_FUNCTION, 3, printk(KERN_INFO "cs4297a: start_dac()+\n"));
825 spin_lock_irqsave(&s->lock, flags);
826 if (!(s->ena & FMODE_WRITE) && (s->dma_dac.mapped ||
827 (s->dma_dac.count > 0
828 && s->dma_dac.ready))) {
829 s->ena |= FMODE_WRITE;
830 /* XXXKW what do I really want here? My theory for
831 now is that I just flip the "ena" bit, and the
832 interrupt handler will start processing the xmit
833 channel */
834
835 CS_DBGOUT(CS_WAVE_WRITE | CS_PARMS, 8, printk(KERN_INFO
836 "cs4297a: start_dac(): start dma\n"));
837
838 }
839 spin_unlock_irqrestore(&s->lock, flags);
840 CS_DBGOUT(CS_FUNCTION, 3,
841 printk(KERN_INFO "cs4297a: start_dac()-\n"));
842 }
843
844
845 static void stop_adc(struct cs4297a_state *s)
846 {
847 unsigned long flags;
848
849 CS_DBGOUT(CS_FUNCTION, 3,
850 printk(KERN_INFO "cs4297a: stop_adc()+\n"));
851
852 spin_lock_irqsave(&s->lock, flags);
853 s->ena &= ~FMODE_READ;
854
855 if (s->conversion == 1) {
856 s->conversion = 0;
857 s->prop_adc.fmt = s->prop_adc.fmt_original;
858 }
859 /* Nothing to do really, I need to keep the DMA going
860 XXXKW when do I get here, and is there more I should do? */
861 spin_unlock_irqrestore(&s->lock, flags);
862 CS_DBGOUT(CS_FUNCTION, 3,
863 printk(KERN_INFO "cs4297a: stop_adc()-\n"));
864 }
865
866
867 static void start_adc(struct cs4297a_state *s)
868 {
869 unsigned long flags;
870
871 CS_DBGOUT(CS_FUNCTION, 2,
872 printk(KERN_INFO "cs4297a: start_adc()+\n"));
873
874 if (!(s->ena & FMODE_READ) &&
875 (s->dma_adc.mapped || s->dma_adc.count <=
876 (signed) (s->dma_adc.sbufsz - 2 * s->dma_adc.fragsize))
877 && s->dma_adc.ready) {
878 if (s->prop_adc.fmt & AFMT_S8 || s->prop_adc.fmt & AFMT_U8) {
879 //
880 // now only use 16 bit capture, due to truncation issue
881 // in the chip, noticable distortion occurs.
882 // allocate buffer and then convert from 16 bit to
883 // 8 bit for the user buffer.
884 //
885 s->prop_adc.fmt_original = s->prop_adc.fmt;
886 if (s->prop_adc.fmt & AFMT_S8) {
887 s->prop_adc.fmt &= ~AFMT_S8;
888 s->prop_adc.fmt |= AFMT_S16_LE;
889 }
890 if (s->prop_adc.fmt & AFMT_U8) {
891 s->prop_adc.fmt &= ~AFMT_U8;
892 s->prop_adc.fmt |= AFMT_U16_LE;
893 }
894 //
895 // prog_dmabuf_adc performs a stop_adc() but that is
896 // ok since we really haven't started the DMA yet.
897 //
898 prog_codec(s, CS_TYPE_ADC);
899
900 prog_dmabuf_adc(s);
901 s->conversion = 1;
902 }
903 spin_lock_irqsave(&s->lock, flags);
904 s->ena |= FMODE_READ;
905 /* Nothing to do really, I am probably already
906 DMAing... XXXKW when do I get here, and is there
907 more I should do? */
908 spin_unlock_irqrestore(&s->lock, flags);
909
910 CS_DBGOUT(CS_PARMS, 6, printk(KERN_INFO
911 "cs4297a: start_adc(): start adc\n"));
912 }
913 CS_DBGOUT(CS_FUNCTION, 2,
914 printk(KERN_INFO "cs4297a: start_adc()-\n"));
915
916 }
917
918
919 // call with spinlock held!
920 static void cs4297a_update_ptr(struct cs4297a_state *s, int intflag)
921 {
922 int good_diff, diff, diff2;
923 u64 *data_p, data;
924 u32 *s_ptr;
925 unsigned hwptr;
926 u32 status;
927 serdma_t *d;
928 serdma_descr_t *descr;
929
930 // update ADC pointer
931 status = intflag ? __raw_readq(SS_CSR(R_SER_STATUS)) : 0;
932
933 if ((s->ena & FMODE_READ) || (status & (M_SYNCSER_RX_EOP_COUNT))) {
934 d = &s->dma_adc;
935 hwptr = (unsigned) (((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_RX)) & M_DMA_CURDSCR_ADDR) -
936 d->descrtab_phys) / sizeof(serdma_descr_t));
937
938 if (s->ena & FMODE_READ) {
939 CS_DBGOUT(CS_FUNCTION, 2,
940 printk(KERN_INFO "cs4297a: upd_rcv sw->hw->hw %x/%x/%x (int-%d)n",
941 d->swptr, d->hwptr, hwptr, intflag));
942 /* Number of DMA buffers available for software: */
943 diff2 = diff = (d->ringsz + hwptr - d->hwptr) % d->ringsz;
944 d->hwptr = hwptr;
945 good_diff = 0;
946 s_ptr = (u32 *)&(d->dma_buf[d->swptr*4]);
947 descr = &d->descrtab[d->swptr];
948 while (diff2--) {
949 u64 data = be64_to_cpu(*(u64 *)s_ptr);
950 u64 descr_a;
951 u16 left, right;
952 descr_a = descr->descr_a;
953 descr->descr_a &= ~M_DMA_SERRX_SOP;
954 if ((descr_a & M_DMA_DSCRA_A_ADDR) != CPHYSADDR((long)s_ptr)) {
955 printk(KERN_ERR "cs4297a: RX Bad address (read)\n");
956 }
957 if (((data & 0x9800000000000000) != 0x9800000000000000) ||
958 (!(descr_a & M_DMA_SERRX_SOP)) ||
959 (G_DMA_DSCRB_PKT_SIZE(descr->descr_b) != FRAME_BYTES)) {
960 s->stats.rx_bad++;
961 printk(KERN_DEBUG "cs4297a: RX Bad attributes (read)\n");
962 continue;
963 }
964 s->stats.rx_good++;
965 if ((data >> 61) == 7) {
966 s->read_value = (data >> 12) & 0xffff;
967 s->read_reg = (data >> 40) & 0x7f;
968 wake_up(&d->reg_wait);
969 }
970 if (d->count && (d->sb_hwptr == d->sb_swptr)) {
971 s->stats.rx_overflow++;
972 printk(KERN_DEBUG "cs4297a: RX overflow\n");
973 continue;
974 }
975 good_diff++;
976 left = ((be32_to_cpu(s_ptr[1]) & 0xff) << 8) |
977 ((be32_to_cpu(s_ptr[2]) >> 24) & 0xff);
978 right = (be32_to_cpu(s_ptr[2]) >> 4) & 0xffff;
979 *d->sb_hwptr++ = cpu_to_be16(left);
980 *d->sb_hwptr++ = cpu_to_be16(right);
981 if (d->sb_hwptr == d->sb_end)
982 d->sb_hwptr = d->sample_buf;
983 descr++;
984 if (descr == d->descrtab_end) {
985 descr = d->descrtab;
986 s_ptr = (u32 *)s->dma_adc.dma_buf;
987 } else {
988 s_ptr += 8;
989 }
990 }
991 d->total_bytes += good_diff * FRAME_SAMPLE_BYTES;
992 d->count += good_diff * FRAME_SAMPLE_BYTES;
993 if (d->count > d->sbufsz) {
994 printk(KERN_ERR "cs4297a: bogus receive overflow!!\n");
995 }
996 d->swptr = (d->swptr + diff) % d->ringsz;
997 __raw_writeq(diff, SS_CSR(R_SER_DMA_DSCR_COUNT_RX));
998 if (d->mapped) {
999 if (d->count >= (signed) d->fragsize)
1000 wake_up(&d->wait);
1001 } else {
1002 if (d->count > 0) {
1003 CS_DBGOUT(CS_WAVE_READ, 4,
1004 printk(KERN_INFO
1005 "cs4297a: update count -> %d\n", d->count));
1006 wake_up(&d->wait);
1007 }
1008 }
1009 } else {
1010 /* Receive is going even if no one is
1011 listening (for register accesses and to
1012 avoid FIFO overrun) */
1013 diff2 = diff = (hwptr + d->ringsz - d->hwptr) % d->ringsz;
1014 if (!diff) {
1015 printk(KERN_ERR "cs4297a: RX full or empty?\n");
1016 }
1017
1018 descr = &d->descrtab[d->swptr];
1019 data_p = &d->dma_buf[d->swptr*4];
1020
1021 /* Force this to happen at least once; I got
1022 here because of an interrupt, so there must
1023 be a buffer to process. */
1024 do {
1025 data = be64_to_cpu(*data_p);
1026 if ((descr->descr_a & M_DMA_DSCRA_A_ADDR) != CPHYSADDR((long)data_p)) {
1027 printk(KERN_ERR "cs4297a: RX Bad address %d (%llx %lx)\n", d->swptr,
1028 (long long)(descr->descr_a & M_DMA_DSCRA_A_ADDR),
1029 (long)CPHYSADDR((long)data_p));
1030 }
1031 if (!(data & (1LL << 63)) ||
1032 !(descr->descr_a & M_DMA_SERRX_SOP) ||
1033 (G_DMA_DSCRB_PKT_SIZE(descr->descr_b) != FRAME_BYTES)) {
1034 s->stats.rx_bad++;
1035 printk(KERN_DEBUG "cs4297a: RX Bad attributes\n");
1036 } else {
1037 s->stats.rx_good++;
1038 if ((data >> 61) == 7) {
1039 s->read_value = (data >> 12) & 0xffff;
1040 s->read_reg = (data >> 40) & 0x7f;
1041 wake_up(&d->reg_wait);
1042 }
1043 }
1044 descr->descr_a &= ~M_DMA_SERRX_SOP;
1045 descr++;
1046 d->swptr++;
1047 data_p += 4;
1048 if (descr == d->descrtab_end) {
1049 descr = d->descrtab;
1050 d->swptr = 0;
1051 data_p = d->dma_buf;
1052 }
1053 __raw_writeq(1, SS_CSR(R_SER_DMA_DSCR_COUNT_RX));
1054 } while (--diff);
1055 d->hwptr = hwptr;
1056
1057 CS_DBGOUT(CS_DESCR, 6,
1058 printk(KERN_INFO "cs4297a: hw/sw %x/%x\n", d->hwptr, d->swptr));
1059 }
1060
1061 CS_DBGOUT(CS_PARMS, 8, printk(KERN_INFO
1062 "cs4297a: cs4297a_update_ptr(): s=0x%.8x hwptr=%d total_bytes=%d count=%d \n",
1063 (unsigned)s, d->hwptr,
1064 d->total_bytes, d->count));
1065 }
1066
1067 /* XXXKW worry about s->reg_request -- there is a starvation
1068 case if s->ena has FMODE_WRITE on, but the client isn't
1069 doing writes */
1070
1071 // update DAC pointer
1072 //
1073 // check for end of buffer, means that we are going to wait for another interrupt
1074 // to allow silence to fill the fifos on the part, to keep pops down to a minimum.
1075 //
1076 if (s->ena & FMODE_WRITE) {
1077 serdma_t *d = &s->dma_dac;
1078 hwptr = (unsigned) (((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_TX)) & M_DMA_CURDSCR_ADDR) -
1079 d->descrtab_phys) / sizeof(serdma_descr_t));
1080 diff = (d->ringsz + hwptr - d->hwptr) % d->ringsz;
1081 CS_DBGOUT(CS_WAVE_WRITE, 4, printk(KERN_INFO
1082 "cs4297a: cs4297a_update_ptr(): hw/hw/sw %x/%x/%x diff %d count %d\n",
1083 d->hwptr, hwptr, d->swptr, diff, d->count));
1084 d->hwptr = hwptr;
1085 /* XXXKW stereo? conversion? Just assume 2 16-bit samples for now */
1086 d->total_bytes += diff * FRAME_SAMPLE_BYTES;
1087 if (d->mapped) {
1088 d->count += diff * FRAME_SAMPLE_BYTES;
1089 if (d->count >= d->fragsize) {
1090 d->wakeup = 1;
1091 wake_up(&d->wait);
1092 if (d->count > d->sbufsz)
1093 d->count &= d->sbufsz - 1;
1094 }
1095 } else {
1096 d->count -= diff * FRAME_SAMPLE_BYTES;
1097 if (d->count <= 0) {
1098 //
1099 // fill with silence, and do not shut down the DAC.
1100 // Continue to play silence until the _release.
1101 //
1102 CS_DBGOUT(CS_WAVE_WRITE, 6, printk(KERN_INFO
1103 "cs4297a: cs4297a_update_ptr(): memset %d at 0x%.8x for %d size \n",
1104 (unsigned)(s->prop_dac.fmt &
1105 (AFMT_U8 | AFMT_U16_LE)) ? 0x80 : 0,
1106 (unsigned)d->dma_buf,
1107 d->ringsz));
1108 memset(d->dma_buf, 0, d->ringsz * FRAME_BYTES);
1109 if (d->count < 0) {
1110 d->underrun = 1;
1111 s->stats.tx_underrun++;
1112 d->count = 0;
1113 CS_DBGOUT(CS_ERROR, 9, printk(KERN_INFO
1114 "cs4297a: cs4297a_update_ptr(): underrun\n"));
1115 }
1116 } else if (d->count <=
1117 (signed) d->fragsize
1118 && !d->endcleared) {
1119 /* XXXKW what is this for? */
1120 clear_advance(d->dma_buf,
1121 d->sbufsz,
1122 d->swptr,
1123 d->fragsize,
1124 0);
1125 d->endcleared = 1;
1126 }
1127 if ( (d->count <= (signed) d->sbufsz/2) || intflag)
1128 {
1129 CS_DBGOUT(CS_WAVE_WRITE, 4,
1130 printk(KERN_INFO
1131 "cs4297a: update count -> %d\n", d->count));
1132 wake_up(&d->wait);
1133 }
1134 }
1135 CS_DBGOUT(CS_PARMS, 8, printk(KERN_INFO
1136 "cs4297a: cs4297a_update_ptr(): s=0x%.8x hwptr=%d total_bytes=%d count=%d \n",
1137 (unsigned) s, d->hwptr,
1138 d->total_bytes, d->count));
1139 }
1140 }
1141
1142 static int mixer_ioctl(struct cs4297a_state *s, unsigned int cmd,
1143 unsigned long arg)
1144 {
1145 // Index to mixer_src[] is value of AC97 Input Mux Select Reg.
1146 // Value of array member is recording source Device ID Mask.
1147 static const unsigned int mixer_src[8] = {
1148 SOUND_MASK_MIC, SOUND_MASK_CD, 0, SOUND_MASK_LINE1,
1149 SOUND_MASK_LINE, SOUND_MASK_VOLUME, 0, 0
1150 };
1151
1152 // Index of mixtable1[] member is Device ID
1153 // and must be <= SOUND_MIXER_NRDEVICES.
1154 // Value of array member is index into s->mix.vol[]
1155 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
1156 [SOUND_MIXER_PCM] = 1, // voice
1157 [SOUND_MIXER_LINE1] = 2, // AUX
1158 [SOUND_MIXER_CD] = 3, // CD
1159 [SOUND_MIXER_LINE] = 4, // Line
1160 [SOUND_MIXER_SYNTH] = 5, // FM
1161 [SOUND_MIXER_MIC] = 6, // Mic
1162 [SOUND_MIXER_SPEAKER] = 7, // Speaker
1163 [SOUND_MIXER_RECLEV] = 8, // Recording level
1164 [SOUND_MIXER_VOLUME] = 9 // Master Volume
1165 };
1166
1167 static const unsigned mixreg[] = {
1168 AC97_PCMOUT_VOL,
1169 AC97_AUX_VOL,
1170 AC97_CD_VOL,
1171 AC97_LINEIN_VOL
1172 };
1173 unsigned char l, r, rl, rr, vidx;
1174 unsigned char attentbl[11] =
1175 { 63, 42, 26, 17, 14, 11, 8, 6, 4, 2, 0 };
1176 unsigned temp1;
1177 int i, val;
1178
1179 VALIDATE_STATE(s);
1180 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
1181 "cs4297a: mixer_ioctl(): s=0x%.8x cmd=0x%.8x\n",
1182 (unsigned) s, cmd));
1183 #if CSDEBUG
1184 cs_printioctl(cmd);
1185 #endif
1186 #if CSDEBUG_INTERFACE
1187
1188 if ((cmd == SOUND_MIXER_CS_GETDBGMASK) ||
1189 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
1190 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
1191 (cmd == SOUND_MIXER_CS_SETDBGLEVEL))
1192 {
1193 switch (cmd) {
1194
1195 case SOUND_MIXER_CS_GETDBGMASK:
1196 return put_user(cs_debugmask,
1197 (unsigned long *) arg);
1198
1199 case SOUND_MIXER_CS_GETDBGLEVEL:
1200 return put_user(cs_debuglevel,
1201 (unsigned long *) arg);
1202
1203 case SOUND_MIXER_CS_SETDBGMASK:
1204 if (get_user(val, (unsigned long *) arg))
1205 return -EFAULT;
1206 cs_debugmask = val;
1207 return 0;
1208
1209 case SOUND_MIXER_CS_SETDBGLEVEL:
1210 if (get_user(val, (unsigned long *) arg))
1211 return -EFAULT;
1212 cs_debuglevel = val;
1213 return 0;
1214 default:
1215 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
1216 "cs4297a: mixer_ioctl(): ERROR unknown debug cmd\n"));
1217 return 0;
1218 }
1219 }
1220 #endif
1221
1222 if (cmd == SOUND_MIXER_PRIVATE1) {
1223 return -EINVAL;
1224 }
1225 if (cmd == SOUND_MIXER_PRIVATE2) {
1226 // enable/disable/query spatializer
1227 if (get_user(val, (int *) arg))
1228 return -EFAULT;
1229 if (val != -1) {
1230 temp1 = (val & 0x3f) >> 2;
1231 cs4297a_write_ac97(s, AC97_3D_CONTROL, temp1);
1232 cs4297a_read_ac97(s, AC97_GENERAL_PURPOSE,
1233 &temp1);
1234 cs4297a_write_ac97(s, AC97_GENERAL_PURPOSE,
1235 temp1 | 0x2000);
1236 }
1237 cs4297a_read_ac97(s, AC97_3D_CONTROL, &temp1);
1238 return put_user((temp1 << 2) | 3, (int *) arg);
1239 }
1240 if (cmd == SOUND_MIXER_INFO) {
1241 mixer_info info;
1242 memset(&info, 0, sizeof(info));
1243 strlcpy(info.id, "CS4297a", sizeof(info.id));
1244 strlcpy(info.name, "Crystal CS4297a", sizeof(info.name));
1245 info.modify_counter = s->mix.modcnt;
1246 if (copy_to_user((void *) arg, &info, sizeof(info)))
1247 return -EFAULT;
1248 return 0;
1249 }
1250 if (cmd == SOUND_OLD_MIXER_INFO) {
1251 _old_mixer_info info;
1252 memset(&info, 0, sizeof(info));
1253 strlcpy(info.id, "CS4297a", sizeof(info.id));
1254 strlcpy(info.name, "Crystal CS4297a", sizeof(info.name));
1255 if (copy_to_user((void *) arg, &info, sizeof(info)))
1256 return -EFAULT;
1257 return 0;
1258 }
1259 if (cmd == OSS_GETVERSION)
1260 return put_user(SOUND_VERSION, (int *) arg);
1261
1262 if (_IOC_TYPE(cmd) != 'M' || _SIOC_SIZE(cmd) != sizeof(int))
1263 return -EINVAL;
1264
1265 // If ioctl has only the SIOC_READ bit(bit 31)
1266 // on, process the only-read commands.
1267 if (_SIOC_DIR(cmd) == _SIOC_READ) {
1268 switch (_IOC_NR(cmd)) {
1269 case SOUND_MIXER_RECSRC: // Arg contains a bit for each recording source
1270 cs4297a_read_ac97(s, AC97_RECORD_SELECT,
1271 &temp1);
1272 return put_user(mixer_src[temp1 & 7], (int *) arg);
1273
1274 case SOUND_MIXER_DEVMASK: // Arg contains a bit for each supported device
1275 return put_user(SOUND_MASK_PCM | SOUND_MASK_LINE |
1276 SOUND_MASK_VOLUME | SOUND_MASK_RECLEV,
1277 (int *) arg);
1278
1279 case SOUND_MIXER_RECMASK: // Arg contains a bit for each supported recording source
1280 return put_user(SOUND_MASK_LINE | SOUND_MASK_VOLUME,
1281 (int *) arg);
1282
1283 case SOUND_MIXER_STEREODEVS: // Mixer channels supporting stereo
1284 return put_user(SOUND_MASK_PCM | SOUND_MASK_LINE |
1285 SOUND_MASK_VOLUME | SOUND_MASK_RECLEV,
1286 (int *) arg);
1287
1288 case SOUND_MIXER_CAPS:
1289 return put_user(SOUND_CAP_EXCL_INPUT, (int *) arg);
1290
1291 default:
1292 i = _IOC_NR(cmd);
1293 if (i >= SOUND_MIXER_NRDEVICES
1294 || !(vidx = mixtable1[i]))
1295 return -EINVAL;
1296 return put_user(s->mix.vol[vidx - 1], (int *) arg);
1297 }
1298 }
1299 // If ioctl doesn't have both the SIOC_READ and
1300 // the SIOC_WRITE bit set, return invalid.
1301 if (_SIOC_DIR(cmd) != (_SIOC_READ | _SIOC_WRITE))
1302 return -EINVAL;
1303
1304 // Increment the count of volume writes.
1305 s->mix.modcnt++;
1306
1307 // Isolate the command; it must be a write.
1308 switch (_IOC_NR(cmd)) {
1309
1310 case SOUND_MIXER_RECSRC: // Arg contains a bit for each recording source
1311 if (get_user(val, (int *) arg))
1312 return -EFAULT;
1313 i = hweight32(val); // i = # bits on in val.
1314 if (i != 1) // One & only 1 bit must be on.
1315 return 0;
1316 for (i = 0; i < sizeof(mixer_src) / sizeof(int); i++) {
1317 if (val == mixer_src[i]) {
1318 temp1 = (i << 8) | i;
1319 cs4297a_write_ac97(s,
1320 AC97_RECORD_SELECT,
1321 temp1);
1322 return 0;
1323 }
1324 }
1325 return 0;
1326
1327 case SOUND_MIXER_VOLUME:
1328 if (get_user(val, (int *) arg))
1329 return -EFAULT;
1330 l = val & 0xff;
1331 if (l > 100)
1332 l = 100; // Max soundcard.h vol is 100.
1333 if (l < 6) {
1334 rl = 63;
1335 l = 0;
1336 } else
1337 rl = attentbl[(10 * l) / 100]; // Convert 0-100 vol to 63-0 atten.
1338
1339 r = (val >> 8) & 0xff;
1340 if (r > 100)
1341 r = 100; // Max right volume is 100, too
1342 if (r < 6) {
1343 rr = 63;
1344 r = 0;
1345 } else
1346 rr = attentbl[(10 * r) / 100]; // Convert volume to attenuation.
1347
1348 if ((rl > 60) && (rr > 60)) // If both l & r are 'low',
1349 temp1 = 0x8000; // turn on the mute bit.
1350 else
1351 temp1 = 0;
1352
1353 temp1 |= (rl << 8) | rr;
1354
1355 cs4297a_write_ac97(s, AC97_MASTER_VOL_STEREO, temp1);
1356 cs4297a_write_ac97(s, AC97_PHONE_VOL, temp1);
1357
1358 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1359 s->mix.vol[8] = ((unsigned int) r << 8) | l;
1360 #else
1361 s->mix.vol[8] = val;
1362 #endif
1363 return put_user(s->mix.vol[8], (int *) arg);
1364
1365 case SOUND_MIXER_SPEAKER:
1366 if (get_user(val, (int *) arg))
1367 return -EFAULT;
1368 l = val & 0xff;
1369 if (l > 100)
1370 l = 100;
1371 if (l < 3) {
1372 rl = 0;
1373 l = 0;
1374 } else {
1375 rl = (l * 2 - 5) / 13; // Convert 0-100 range to 0-15.
1376 l = (rl * 13 + 5) / 2;
1377 }
1378
1379 if (rl < 3) {
1380 temp1 = 0x8000;
1381 rl = 0;
1382 } else
1383 temp1 = 0;
1384 rl = 15 - rl; // Convert volume to attenuation.
1385 temp1 |= rl << 1;
1386 cs4297a_write_ac97(s, AC97_PCBEEP_VOL, temp1);
1387
1388 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1389 s->mix.vol[6] = l << 8;
1390 #else
1391 s->mix.vol[6] = val;
1392 #endif
1393 return put_user(s->mix.vol[6], (int *) arg);
1394
1395 case SOUND_MIXER_RECLEV:
1396 if (get_user(val, (int *) arg))
1397 return -EFAULT;
1398 l = val & 0xff;
1399 if (l > 100)
1400 l = 100;
1401 r = (val >> 8) & 0xff;
1402 if (r > 100)
1403 r = 100;
1404 rl = (l * 2 - 5) / 13; // Convert 0-100 scale to 0-15.
1405 rr = (r * 2 - 5) / 13;
1406 if (rl < 3 && rr < 3)
1407 temp1 = 0x8000;
1408 else
1409 temp1 = 0;
1410
1411 temp1 = temp1 | (rl << 8) | rr;
1412 cs4297a_write_ac97(s, AC97_RECORD_GAIN, temp1);
1413
1414 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1415 s->mix.vol[7] = ((unsigned int) r << 8) | l;
1416 #else
1417 s->mix.vol[7] = val;
1418 #endif
1419 return put_user(s->mix.vol[7], (int *) arg);
1420
1421 case SOUND_MIXER_MIC:
1422 if (get_user(val, (int *) arg))
1423 return -EFAULT;
1424 l = val & 0xff;
1425 if (l > 100)
1426 l = 100;
1427 if (l < 1) {
1428 l = 0;
1429 rl = 0;
1430 } else {
1431 rl = ((unsigned) l * 5 - 4) / 16; // Convert 0-100 range to 0-31.
1432 l = (rl * 16 + 4) / 5;
1433 }
1434 cs4297a_read_ac97(s, AC97_MIC_VOL, &temp1);
1435 temp1 &= 0x40; // Isolate 20db gain bit.
1436 if (rl < 3) {
1437 temp1 |= 0x8000;
1438 rl = 0;
1439 }
1440 rl = 31 - rl; // Convert volume to attenuation.
1441 temp1 |= rl;
1442 cs4297a_write_ac97(s, AC97_MIC_VOL, temp1);
1443
1444 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1445 s->mix.vol[5] = val << 8;
1446 #else
1447 s->mix.vol[5] = val;
1448 #endif
1449 return put_user(s->mix.vol[5], (int *) arg);
1450
1451
1452 case SOUND_MIXER_SYNTH:
1453 if (get_user(val, (int *) arg))
1454 return -EFAULT;
1455 l = val & 0xff;
1456 if (l > 100)
1457 l = 100;
1458 if (get_user(val, (int *) arg))
1459 return -EFAULT;
1460 r = (val >> 8) & 0xff;
1461 if (r > 100)
1462 r = 100;
1463 rl = (l * 2 - 11) / 3; // Convert 0-100 range to 0-63.
1464 rr = (r * 2 - 11) / 3;
1465 if (rl < 3) // If l is low, turn on
1466 temp1 = 0x0080; // the mute bit.
1467 else
1468 temp1 = 0;
1469
1470 rl = 63 - rl; // Convert vol to attenuation.
1471 // writel(temp1 | rl, s->pBA0 + FMLVC);
1472 if (rr < 3) // If rr is low, turn on
1473 temp1 = 0x0080; // the mute bit.
1474 else
1475 temp1 = 0;
1476 rr = 63 - rr; // Convert vol to attenuation.
1477 // writel(temp1 | rr, s->pBA0 + FMRVC);
1478
1479 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1480 s->mix.vol[4] = (r << 8) | l;
1481 #else
1482 s->mix.vol[4] = val;
1483 #endif
1484 return put_user(s->mix.vol[4], (int *) arg);
1485
1486
1487 default:
1488 CS_DBGOUT(CS_IOCTL, 4, printk(KERN_INFO
1489 "cs4297a: mixer_ioctl(): default\n"));
1490
1491 i = _IOC_NR(cmd);
1492 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
1493 return -EINVAL;
1494 if (get_user(val, (int *) arg))
1495 return -EFAULT;
1496 l = val & 0xff;
1497 if (l > 100)
1498 l = 100;
1499 if (l < 1) {
1500 l = 0;
1501 rl = 31;
1502 } else
1503 rl = (attentbl[(l * 10) / 100]) >> 1;
1504
1505 r = (val >> 8) & 0xff;
1506 if (r > 100)
1507 r = 100;
1508 if (r < 1) {
1509 r = 0;
1510 rr = 31;
1511 } else
1512 rr = (attentbl[(r * 10) / 100]) >> 1;
1513 if ((rl > 30) && (rr > 30))
1514 temp1 = 0x8000;
1515 else
1516 temp1 = 0;
1517 temp1 = temp1 | (rl << 8) | rr;
1518 cs4297a_write_ac97(s, mixreg[vidx - 1], temp1);
1519
1520 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1521 s->mix.vol[vidx - 1] = ((unsigned int) r << 8) | l;
1522 #else
1523 s->mix.vol[vidx - 1] = val;
1524 #endif
1525 return put_user(s->mix.vol[vidx - 1], (int *) arg);
1526 }
1527 }
1528
1529
1530 // ---------------------------------------------------------------------
1531
1532 static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
1533 {
1534 int minor = iminor(inode);
1535 struct cs4297a_state *s=NULL;
1536 struct list_head *entry;
1537
1538 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
1539 printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()+\n"));
1540
1541 list_for_each(entry, &cs4297a_devs)
1542 {
1543 s = list_entry(entry, struct cs4297a_state, list);
1544 if(s->dev_mixer == minor)
1545 break;
1546 }
1547 if (!s)
1548 {
1549 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
1550 printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- -ENODEV\n"));
1551 return -ENODEV;
1552 }
1553 VALIDATE_STATE(s);
1554 file->private_data = s;
1555
1556 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
1557 printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- 0\n"));
1558
1559 return nonseekable_open(inode, file);
1560 }
1561
1562
1563 static int cs4297a_release_mixdev(struct inode *inode, struct file *file)
1564 {
1565 struct cs4297a_state *s =
1566 (struct cs4297a_state *) file->private_data;
1567
1568 VALIDATE_STATE(s);
1569 return 0;
1570 }
1571
1572
1573 static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
1574 unsigned int cmd, unsigned long arg)
1575 {
1576 return mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
1577 arg);
1578 }
1579
1580
1581 // ******************************************************************************************
1582 // Mixer file operations struct.
1583 // ******************************************************************************************
1584 static /*const */ struct file_operations cs4297a_mixer_fops = {
1585 .owner = THIS_MODULE,
1586 .llseek = no_llseek,
1587 .ioctl = cs4297a_ioctl_mixdev,
1588 .open = cs4297a_open_mixdev,
1589 .release = cs4297a_release_mixdev,
1590 };
1591
1592 // ---------------------------------------------------------------------
1593
1594
1595 static int drain_adc(struct cs4297a_state *s, int nonblock)
1596 {
1597 /* This routine serves no purpose currently - any samples
1598 sitting in the receive queue will just be processed by the
1599 background consumer. This would be different if DMA
1600 actually stopped when there were no clients. */
1601 return 0;
1602 }
1603
1604 static int drain_dac(struct cs4297a_state *s, int nonblock)
1605 {
1606 DECLARE_WAITQUEUE(wait, current);
1607 unsigned long flags;
1608 unsigned hwptr;
1609 unsigned tmo;
1610 int count;
1611
1612 if (s->dma_dac.mapped)
1613 return 0;
1614 if (nonblock)
1615 return -EBUSY;
1616 add_wait_queue(&s->dma_dac.wait, &wait);
1617 while ((count = __raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_TX))) ||
1618 (s->dma_dac.count > 0)) {
1619 if (!signal_pending(current)) {
1620 set_current_state(TASK_INTERRUPTIBLE);
1621 /* XXXKW is this calculation working? */
1622 tmo = ((count * FRAME_TX_US) * HZ) / 1000000;
1623 schedule_timeout(tmo + 1);
1624 } else {
1625 /* XXXKW do I care if there is a signal pending? */
1626 }
1627 }
1628 spin_lock_irqsave(&s->lock, flags);
1629 /* Reset the bookkeeping */
1630 hwptr = (int)(((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_TX)) & M_DMA_CURDSCR_ADDR) -
1631 s->dma_dac.descrtab_phys) / sizeof(serdma_descr_t));
1632 s->dma_dac.hwptr = s->dma_dac.swptr = hwptr;
1633 spin_unlock_irqrestore(&s->lock, flags);
1634 remove_wait_queue(&s->dma_dac.wait, &wait);
1635 current->state = TASK_RUNNING;
1636 return 0;
1637 }
1638
1639
1640 // ---------------------------------------------------------------------
1641
1642 static ssize_t cs4297a_read(struct file *file, char *buffer, size_t count,
1643 loff_t * ppos)
1644 {
1645 struct cs4297a_state *s =
1646 (struct cs4297a_state *) file->private_data;
1647 ssize_t ret;
1648 unsigned long flags;
1649 int cnt, count_fr, cnt_by;
1650 unsigned copied = 0;
1651
1652 CS_DBGOUT(CS_FUNCTION | CS_WAVE_READ, 2,
1653 printk(KERN_INFO "cs4297a: cs4297a_read()+ %d \n", count));
1654
1655 VALIDATE_STATE(s);
1656 if (s->dma_adc.mapped)
1657 return -ENXIO;
1658 if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
1659 return ret;
1660 if (!access_ok(VERIFY_WRITE, buffer, count))
1661 return -EFAULT;
1662 ret = 0;
1663 //
1664 // "count" is the amount of bytes to read (from app), is decremented each loop
1665 // by the amount of bytes that have been returned to the user buffer.
1666 // "cnt" is the running total of each read from the buffer (changes each loop)
1667 // "buffer" points to the app's buffer
1668 // "ret" keeps a running total of the amount of bytes that have been copied
1669 // to the user buffer.
1670 // "copied" is the total bytes copied into the user buffer for each loop.
1671 //
1672 while (count > 0) {
1673 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1674 "_read() count>0 count=%d .count=%d .swptr=%d .hwptr=%d \n",
1675 count, s->dma_adc.count,
1676 s->dma_adc.swptr, s->dma_adc.hwptr));
1677 spin_lock_irqsave(&s->lock, flags);
1678
1679 /* cnt will be the number of available samples (16-bit
1680 stereo); it starts out as the maxmimum consequetive
1681 samples */
1682 cnt = (s->dma_adc.sb_end - s->dma_adc.sb_swptr) / 2;
1683 count_fr = s->dma_adc.count / FRAME_SAMPLE_BYTES;
1684
1685 // dma_adc.count is the current total bytes that have not been read.
1686 // if the amount of unread bytes from the current sw pointer to the
1687 // end of the buffer is greater than the current total bytes that
1688 // have not been read, then set the "cnt" (unread bytes) to the
1689 // amount of unread bytes.
1690
1691 if (count_fr < cnt)
1692 cnt = count_fr;
1693 cnt_by = cnt * FRAME_SAMPLE_BYTES;
1694 spin_unlock_irqrestore(&s->lock, flags);
1695 //
1696 // if we are converting from 8/16 then we need to copy
1697 // twice the number of 16 bit bytes then 8 bit bytes.
1698 //
1699 if (s->conversion) {
1700 if (cnt_by > (count * 2)) {
1701 cnt = (count * 2) / FRAME_SAMPLE_BYTES;
1702 cnt_by = count * 2;
1703 }
1704 } else {
1705 if (cnt_by > count) {
1706 cnt = count / FRAME_SAMPLE_BYTES;
1707 cnt_by = count;
1708 }
1709 }
1710 //
1711 // "cnt" NOW is the smaller of the amount that will be read,
1712 // and the amount that is requested in this read (or partial).
1713 // if there are no bytes in the buffer to read, then start the
1714 // ADC and wait for the interrupt handler to wake us up.
1715 //
1716 if (cnt <= 0) {
1717
1718 // start up the dma engine and then continue back to the top of
1719 // the loop when wake up occurs.
1720 start_adc(s);
1721 if (file->f_flags & O_NONBLOCK)
1722 return ret ? ret : -EAGAIN;
1723 interruptible_sleep_on(&s->dma_adc.wait);
1724 if (signal_pending(current))
1725 return ret ? ret : -ERESTARTSYS;
1726 continue;
1727 }
1728 // there are bytes in the buffer to read.
1729 // copy from the hw buffer over to the user buffer.
1730 // user buffer is designated by "buffer"
1731 // virtual address to copy from is dma_buf+swptr
1732 // the "cnt" is the number of bytes to read.
1733
1734 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
1735 "_read() copy_to cnt=%d count=%d ", cnt_by, count));
1736 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1737 " .sbufsz=%d .count=%d buffer=0x%.8x ret=%d\n",
1738 s->dma_adc.sbufsz, s->dma_adc.count,
1739 (unsigned) buffer, ret));
1740
1741 if (copy_to_user (buffer, ((void *)s->dma_adc.sb_swptr), cnt_by))
1742 return ret ? ret : -EFAULT;
1743 copied = cnt_by;
1744
1745 /* Return the descriptors */
1746 spin_lock_irqsave(&s->lock, flags);
1747 CS_DBGOUT(CS_FUNCTION, 2,
1748 printk(KERN_INFO "cs4297a: upd_rcv sw->hw %x/%x\n", s->dma_adc.swptr, s->dma_adc.hwptr));
1749 s->dma_adc.count -= cnt_by;
1750 s->dma_adc.sb_swptr += cnt * 2;
1751 if (s->dma_adc.sb_swptr == s->dma_adc.sb_end)
1752 s->dma_adc.sb_swptr = s->dma_adc.sample_buf;
1753 spin_unlock_irqrestore(&s->lock, flags);
1754 count -= copied;
1755 buffer += copied;
1756 ret += copied;
1757 start_adc(s);
1758 }
1759 CS_DBGOUT(CS_FUNCTION | CS_WAVE_READ, 2,
1760 printk(KERN_INFO "cs4297a: cs4297a_read()- %d\n", ret));
1761 return ret;
1762 }
1763
1764
1765 static ssize_t cs4297a_write(struct file *file, const char *buffer,
1766 size_t count, loff_t * ppos)
1767 {
1768 struct cs4297a_state *s =
1769 (struct cs4297a_state *) file->private_data;
1770 ssize_t ret;
1771 unsigned long flags;
1772 unsigned swptr, hwptr;
1773 int cnt;
1774
1775 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE, 2,
1776 printk(KERN_INFO "cs4297a: cs4297a_write()+ count=%d\n",
1777 count));
1778 VALIDATE_STATE(s);
1779
1780 if (s->dma_dac.mapped)
1781 return -ENXIO;
1782 if (!s->dma_dac.ready && (ret = prog_dmabuf_dac(s)))
1783 return ret;
1784 if (!access_ok(VERIFY_READ, buffer, count))
1785 return -EFAULT;
1786 ret = 0;
1787 while (count > 0) {
1788 serdma_t *d = &s->dma_dac;
1789 int copy_cnt;
1790 u32 *s_tmpl;
1791 u32 *t_tmpl;
1792 u32 left, right;
1793 int swap = (s->prop_dac.fmt == AFMT_S16_LE) || (s->prop_dac.fmt == AFMT_U16_LE);
1794
1795 /* XXXXXX this is broken for BLOAT_FACTOR */
1796 spin_lock_irqsave(&s->lock, flags);
1797 if (d->count < 0) {
1798 d->count = 0;
1799 d->swptr = d->hwptr;
1800 }
1801 if (d->underrun) {
1802 d->underrun = 0;
1803 hwptr = (unsigned) (((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_TX)) & M_DMA_CURDSCR_ADDR) -
1804 d->descrtab_phys) / sizeof(serdma_descr_t));
1805 d->swptr = d->hwptr = hwptr;
1806 }
1807 swptr = d->swptr;
1808 cnt = d->sbufsz - (swptr * FRAME_SAMPLE_BYTES);
1809 /* Will this write fill up the buffer? */
1810 if (d->count + cnt > d->sbufsz)
1811 cnt = d->sbufsz - d->count;
1812 spin_unlock_irqrestore(&s->lock, flags);
1813 if (cnt > count)
1814 cnt = count;
1815 if (cnt <= 0) {
1816 start_dac(s);
1817 if (file->f_flags & O_NONBLOCK)
1818 return ret ? ret : -EAGAIN;
1819 interruptible_sleep_on(&d->wait);
1820 if (signal_pending(current))
1821 return ret ? ret : -ERESTARTSYS;
1822 continue;
1823 }
1824 if (copy_from_user(d->sample_buf, buffer, cnt))
1825 return ret ? ret : -EFAULT;
1826
1827 copy_cnt = cnt;
1828 s_tmpl = (u32 *)d->sample_buf;
1829 t_tmpl = (u32 *)(d->dma_buf + (swptr * 4));
1830
1831 /* XXXKW assuming 16-bit stereo! */
1832 do {
1833 u32 tmp;
1834
1835 t_tmpl[0] = cpu_to_be32(0x98000000);
1836
1837 tmp = be32_to_cpu(s_tmpl[0]);
1838 left = tmp & 0xffff;
1839 right = tmp >> 16;
1840 if (swap) {
1841 left = swab16(left);
1842 right = swab16(right);
1843 }
1844 t_tmpl[1] = cpu_to_be32(left >> 8);
1845 t_tmpl[2] = cpu_to_be32(((left & 0xff) << 24) |
1846 (right << 4));
1847
1848 s_tmpl++;
1849 t_tmpl += 8;
1850 copy_cnt -= 4;
1851 } while (copy_cnt);
1852
1853 /* Mux in any pending read/write accesses */
1854 if (s->reg_request) {
1855 *(u64 *)(d->dma_buf + (swptr * 4)) |=
1856 cpu_to_be64(s->reg_request);
1857 s->reg_request = 0;
1858 wake_up(&s->dma_dac.reg_wait);
1859 }
1860
1861 CS_DBGOUT(CS_WAVE_WRITE, 4,
1862 printk(KERN_INFO
1863 "cs4297a: copy in %d to swptr %x\n", cnt, swptr));
1864
1865 swptr = (swptr + (cnt/FRAME_SAMPLE_BYTES)) % d->ringsz;
1866 __raw_writeq(cnt/FRAME_SAMPLE_BYTES, SS_CSR(R_SER_DMA_DSCR_COUNT_TX));
1867 spin_lock_irqsave(&s->lock, flags);
1868 d->swptr = swptr;
1869 d->count += cnt;
1870 d->endcleared = 0;
1871 spin_unlock_irqrestore(&s->lock, flags);
1872 count -= cnt;
1873 buffer += cnt;
1874 ret += cnt;
1875 start_dac(s);
1876 }
1877 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE, 2,
1878 printk(KERN_INFO "cs4297a: cs4297a_write()- %d\n", ret));
1879 return ret;
1880 }
1881
1882
1883 static unsigned int cs4297a_poll(struct file *file,
1884 struct poll_table_struct *wait)
1885 {
1886 struct cs4297a_state *s =
1887 (struct cs4297a_state *) file->private_data;
1888 unsigned long flags;
1889 unsigned int mask = 0;
1890
1891 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE | CS_WAVE_READ, 4,
1892 printk(KERN_INFO "cs4297a: cs4297a_poll()+\n"));
1893 VALIDATE_STATE(s);
1894 if (file->f_mode & FMODE_WRITE) {
1895 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE | CS_WAVE_READ, 4,
1896 printk(KERN_INFO
1897 "cs4297a: cs4297a_poll() wait on FMODE_WRITE\n"));
1898 if(!s->dma_dac.ready && prog_dmabuf_dac(s))
1899 return 0;
1900 poll_wait(file, &s->dma_dac.wait, wait);
1901 }
1902 if (file->f_mode & FMODE_READ) {
1903 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE | CS_WAVE_READ, 4,
1904 printk(KERN_INFO
1905 "cs4297a: cs4297a_poll() wait on FMODE_READ\n"));
1906 if(!s->dma_dac.ready && prog_dmabuf_adc(s))
1907 return 0;
1908 poll_wait(file, &s->dma_adc.wait, wait);
1909 }
1910 spin_lock_irqsave(&s->lock, flags);
1911 cs4297a_update_ptr(s,CS_FALSE);
1912 if (file->f_mode & FMODE_WRITE) {
1913 if (s->dma_dac.mapped) {
1914 if (s->dma_dac.count >=
1915 (signed) s->dma_dac.fragsize) {
1916 if (s->dma_dac.wakeup)
1917 mask |= POLLOUT | POLLWRNORM;
1918 else
1919 mask = 0;
1920 s->dma_dac.wakeup = 0;
1921 }
1922 } else {
1923 if ((signed) (s->dma_dac.sbufsz/2) >= s->dma_dac.count)
1924 mask |= POLLOUT | POLLWRNORM;
1925 }
1926 } else if (file->f_mode & FMODE_READ) {
1927 if (s->dma_adc.mapped) {
1928 if (s->dma_adc.count >= (signed) s->dma_adc.fragsize)
1929 mask |= POLLIN | POLLRDNORM;
1930 } else {
1931 if (s->dma_adc.count > 0)
1932 mask |= POLLIN | POLLRDNORM;
1933 }
1934 }
1935 spin_unlock_irqrestore(&s->lock, flags);
1936 CS_DBGOUT(CS_FUNCTION | CS_WAVE_WRITE | CS_WAVE_READ, 4,
1937 printk(KERN_INFO "cs4297a: cs4297a_poll()- 0x%.8x\n",
1938 mask));
1939 return mask;
1940 }
1941
1942
1943 static int cs4297a_mmap(struct file *file, struct vm_area_struct *vma)
1944 {
1945 /* XXXKW currently no mmap support */
1946 return -EINVAL;
1947 return 0;
1948 }
1949
1950
1951 static int cs4297a_ioctl(struct inode *inode, struct file *file,
1952 unsigned int cmd, unsigned long arg)
1953 {
1954 struct cs4297a_state *s =
1955 (struct cs4297a_state *) file->private_data;
1956 unsigned long flags;
1957 audio_buf_info abinfo;
1958 count_info cinfo;
1959 int val, mapped, ret;
1960
1961 CS_DBGOUT(CS_FUNCTION|CS_IOCTL, 4, printk(KERN_INFO
1962 "cs4297a: cs4297a_ioctl(): file=0x%.8x cmd=0x%.8x\n",
1963 (unsigned) file, cmd));
1964 #if CSDEBUG
1965 cs_printioctl(cmd);
1966 #endif
1967 VALIDATE_STATE(s);
1968 mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
1969 ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
1970 switch (cmd) {
1971 case OSS_GETVERSION:
1972 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
1973 "cs4297a: cs4297a_ioctl(): SOUND_VERSION=0x%.8x\n",
1974 SOUND_VERSION));
1975 return put_user(SOUND_VERSION, (int *) arg);
1976
1977 case SNDCTL_DSP_SYNC:
1978 CS_DBGOUT(CS_IOCTL, 4, printk(KERN_INFO
1979 "cs4297a: cs4297a_ioctl(): DSP_SYNC\n"));
1980 if (file->f_mode & FMODE_WRITE)
1981 return drain_dac(s,
1982 0 /*file->f_flags & O_NONBLOCK */
1983 );
1984 return 0;
1985
1986 case SNDCTL_DSP_SETDUPLEX:
1987 return 0;
1988
1989 case SNDCTL_DSP_GETCAPS:
1990 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
1991 DSP_CAP_TRIGGER | DSP_CAP_MMAP,
1992 (int *) arg);
1993
1994 case SNDCTL_DSP_RESET:
1995 CS_DBGOUT(CS_IOCTL, 4, printk(KERN_INFO
1996 "cs4297a: cs4297a_ioctl(): DSP_RESET\n"));
1997 if (file->f_mode & FMODE_WRITE) {
1998 stop_dac(s);
1999 synchronize_irq(s->irq);
2000 s->dma_dac.count = s->dma_dac.total_bytes =
2001 s->dma_dac.blocks = s->dma_dac.wakeup = 0;
2002 s->dma_dac.swptr = s->dma_dac.hwptr =
2003 (int)(((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_TX)) & M_DMA_CURDSCR_ADDR) -
2004 s->dma_dac.descrtab_phys) / sizeof(serdma_descr_t));
2005 }
2006 if (file->f_mode & FMODE_READ) {
2007 stop_adc(s);
2008 synchronize_irq(s->irq);
2009 s->dma_adc.count = s->dma_adc.total_bytes =
2010 s->dma_adc.blocks = s->dma_dac.wakeup = 0;
2011 s->dma_adc.swptr = s->dma_adc.hwptr =
2012 (int)(((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_RX)) & M_DMA_CURDSCR_ADDR) -
2013 s->dma_adc.descrtab_phys) / sizeof(serdma_descr_t));
2014 }
2015 return 0;
2016
2017 case SNDCTL_DSP_SPEED:
2018 if (get_user(val, (int *) arg))
2019 return -EFAULT;
2020 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2021 "cs4297a: cs4297a_ioctl(): DSP_SPEED val=%d -> 48000\n", val));
2022 val = 48000;
2023 return put_user(val, (int *) arg);
2024
2025 case SNDCTL_DSP_STEREO:
2026 if (get_user(val, (int *) arg))
2027 return -EFAULT;
2028 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2029 "cs4297a: cs4297a_ioctl(): DSP_STEREO val=%d\n", val));
2030 if (file->f_mode & FMODE_READ) {
2031 stop_adc(s);
2032 s->dma_adc.ready = 0;
2033 s->prop_adc.channels = val ? 2 : 1;
2034 }
2035 if (file->f_mode & FMODE_WRITE) {
2036 stop_dac(s);
2037 s->dma_dac.ready = 0;
2038 s->prop_dac.channels = val ? 2 : 1;
2039 }
2040 return 0;
2041
2042 case SNDCTL_DSP_CHANNELS:
2043 if (get_user(val, (int *) arg))
2044 return -EFAULT;
2045 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2046 "cs4297a: cs4297a_ioctl(): DSP_CHANNELS val=%d\n",
2047 val));
2048 if (val != 0) {
2049 if (file->f_mode & FMODE_READ) {
2050 stop_adc(s);
2051 s->dma_adc.ready = 0;
2052 if (val >= 2)
2053 s->prop_adc.channels = 2;
2054 else
2055 s->prop_adc.channels = 1;
2056 }
2057 if (file->f_mode & FMODE_WRITE) {
2058 stop_dac(s);
2059 s->dma_dac.ready = 0;
2060 if (val >= 2)
2061 s->prop_dac.channels = 2;
2062 else
2063 s->prop_dac.channels = 1;
2064 }
2065 }
2066
2067 if (file->f_mode & FMODE_WRITE)
2068 val = s->prop_dac.channels;
2069 else if (file->f_mode & FMODE_READ)
2070 val = s->prop_adc.channels;
2071
2072 return put_user(val, (int *) arg);
2073
2074 case SNDCTL_DSP_GETFMTS: // Returns a mask
2075 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2076 "cs4297a: cs4297a_ioctl(): DSP_GETFMT val=0x%.8x\n",
2077 AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
2078 AFMT_U8));
2079 return put_user(AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
2080 AFMT_U8, (int *) arg);
2081
2082 case SNDCTL_DSP_SETFMT:
2083 if (get_user(val, (int *) arg))
2084 return -EFAULT;
2085 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2086 "cs4297a: cs4297a_ioctl(): DSP_SETFMT val=0x%.8x\n",
2087 val));
2088 if (val != AFMT_QUERY) {
2089 if (file->f_mode & FMODE_READ) {
2090 stop_adc(s);
2091 s->dma_adc.ready = 0;
2092 if (val != AFMT_S16_LE
2093 && val != AFMT_U16_LE && val != AFMT_S8
2094 && val != AFMT_U8)
2095 val = AFMT_U8;
2096 s->prop_adc.fmt = val;
2097 s->prop_adc.fmt_original = s->prop_adc.fmt;
2098 }
2099 if (file->f_mode & FMODE_WRITE) {
2100 stop_dac(s);
2101 s->dma_dac.ready = 0;
2102 if (val != AFMT_S16_LE
2103 && val != AFMT_U16_LE && val != AFMT_S8
2104 && val != AFMT_U8)
2105 val = AFMT_U8;
2106 s->prop_dac.fmt = val;
2107 s->prop_dac.fmt_original = s->prop_dac.fmt;
2108 }
2109 } else {
2110 if (file->f_mode & FMODE_WRITE)
2111 val = s->prop_dac.fmt_original;
2112 else if (file->f_mode & FMODE_READ)
2113 val = s->prop_adc.fmt_original;
2114 }
2115 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(KERN_INFO
2116 "cs4297a: cs4297a_ioctl(): DSP_SETFMT return val=0x%.8x\n",
2117 val));
2118 return put_user(val, (int *) arg);
2119
2120 case SNDCTL_DSP_POST:
2121 CS_DBGOUT(CS_IOCTL, 4, printk(KERN_INFO
2122 "cs4297a: cs4297a_ioctl(): DSP_POST\n"));
2123 return 0;
2124
2125 case SNDCTL_DSP_GETTRIGGER:
2126 val = 0;
2127 if (file->f_mode & s->ena & FMODE_READ)
2128 val |= PCM_ENABLE_INPUT;
2129 if (file->f_mode & s->ena & FMODE_WRITE)
2130 val |= PCM_ENABLE_OUTPUT;
2131 return put_user(val, (int *) arg);
2132
2133 case SNDCTL_DSP_SETTRIGGER:
2134 if (get_user(val, (int *) arg))
2135 return -EFAULT;
2136 if (file->f_mode & FMODE_READ) {
2137 if (val & PCM_ENABLE_INPUT) {
2138 if (!s->dma_adc.ready
2139 && (ret = prog_dmabuf_adc(s)))
2140 return ret;
2141 start_adc(s);
2142 } else
2143 stop_adc(s);
2144 }
2145 if (file->f_mode & FMODE_WRITE) {
2146 if (val & PCM_ENABLE_OUTPUT) {
2147 if (!s->dma_dac.ready
2148 && (ret = prog_dmabuf_dac(s)))
2149 return ret;
2150 start_dac(s);
2151 } else
2152 stop_dac(s);
2153 }
2154 return 0;
2155
2156 case SNDCTL_DSP_GETOSPACE:
2157 if (!(file->f_mode & FMODE_WRITE))
2158 return -EINVAL;
2159 if (!s->dma_dac.ready && (val = prog_dmabuf_dac(s)))
2160 return val;
2161 spin_lock_irqsave(&s->lock, flags);
2162 cs4297a_update_ptr(s,CS_FALSE);
2163 abinfo.fragsize = s->dma_dac.fragsize;
2164 if (s->dma_dac.mapped)
2165 abinfo.bytes = s->dma_dac.sbufsz;
2166 else
2167 abinfo.bytes =
2168 s->dma_dac.sbufsz - s->dma_dac.count;
2169 abinfo.fragstotal = s->dma_dac.numfrag;
2170 abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;
2171 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 4, printk(KERN_INFO
2172 "cs4297a: cs4297a_ioctl(): GETOSPACE .fragsize=%d .bytes=%d .fragstotal=%d .fragments=%d\n",
2173 abinfo.fragsize,abinfo.bytes,abinfo.fragstotal,
2174 abinfo.fragments));
2175 spin_unlock_irqrestore(&s->lock, flags);
2176 return copy_to_user((void *) arg, &abinfo,
2177 sizeof(abinfo)) ? -EFAULT : 0;
2178
2179 case SNDCTL_DSP_GETISPACE:
2180 if (!(file->f_mode & FMODE_READ))
2181 return -EINVAL;
2182 if (!s->dma_adc.ready && (val = prog_dmabuf_adc(s)))
2183 return val;
2184 spin_lock_irqsave(&s->lock, flags);
2185 cs4297a_update_ptr(s,CS_FALSE);
2186 if (s->conversion) {
2187 abinfo.fragsize = s->dma_adc.fragsize / 2;
2188 abinfo.bytes = s->dma_adc.count / 2;
2189 abinfo.fragstotal = s->dma_adc.numfrag;
2190 abinfo.fragments =
2191 abinfo.bytes >> (s->dma_adc.fragshift - 1);
2192 } else {
2193 abinfo.fragsize = s->dma_adc.fragsize;
2194 abinfo.bytes = s->dma_adc.count;
2195 abinfo.fragstotal = s->dma_adc.numfrag;
2196 abinfo.fragments =
2197 abinfo.bytes >> s->dma_adc.fragshift;
2198 }
2199 spin_unlock_irqrestore(&s->lock, flags);
2200 return copy_to_user((void *) arg, &abinfo,
2201 sizeof(abinfo)) ? -EFAULT : 0;
2202
2203 case SNDCTL_DSP_NONBLOCK:
2204 file->f_flags |= O_NONBLOCK;
2205 return 0;
2206
2207 case SNDCTL_DSP_GETODELAY:
2208 if (!(file->f_mode & FMODE_WRITE))
2209 return -EINVAL;
2210 if(!s->dma_dac.ready && prog_dmabuf_dac(s))
2211 return 0;
2212 spin_lock_irqsave(&s->lock, flags);
2213 cs4297a_update_ptr(s,CS_FALSE);
2214 val = s->dma_dac.count;
2215 spin_unlock_irqrestore(&s->lock, flags);
2216 return put_user(val, (int *) arg);
2217
2218 case SNDCTL_DSP_GETIPTR:
2219 if (!(file->f_mode & FMODE_READ))
2220 return -EINVAL;
2221 if(!s->dma_adc.ready && prog_dmabuf_adc(s))
2222 return 0;
2223 spin_lock_irqsave(&s->lock, flags);
2224 cs4297a_update_ptr(s,CS_FALSE);
2225 cinfo.bytes = s->dma_adc.total_bytes;
2226 if (s->dma_adc.mapped) {
2227 cinfo.blocks =
2228 (cinfo.bytes >> s->dma_adc.fragshift) -
2229 s->dma_adc.blocks;
2230 s->dma_adc.blocks =
2231 cinfo.bytes >> s->dma_adc.fragshift;
2232 } else {
2233 if (s->conversion) {
2234 cinfo.blocks =
2235 s->dma_adc.count /
2236 2 >> (s->dma_adc.fragshift - 1);
2237 } else
2238 cinfo.blocks =
2239 s->dma_adc.count >> s->dma_adc.
2240 fragshift;
2241 }
2242 if (s->conversion)
2243 cinfo.ptr = s->dma_adc.hwptr / 2;
2244 else
2245 cinfo.ptr = s->dma_adc.hwptr;
2246 if (s->dma_adc.mapped)
2247 s->dma_adc.count &= s->dma_adc.fragsize - 1;
2248 spin_unlock_irqrestore(&s->lock, flags);
2249 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2250
2251 case SNDCTL_DSP_GETOPTR:
2252 if (!(file->f_mode & FMODE_WRITE))
2253 return -EINVAL;
2254 if(!s->dma_dac.ready && prog_dmabuf_dac(s))
2255 return 0;
2256 spin_lock_irqsave(&s->lock, flags);
2257 cs4297a_update_ptr(s,CS_FALSE);
2258 cinfo.bytes = s->dma_dac.total_bytes;
2259 if (s->dma_dac.mapped) {
2260 cinfo.blocks =
2261 (cinfo.bytes >> s->dma_dac.fragshift) -
2262 s->dma_dac.blocks;
2263 s->dma_dac.blocks =
2264 cinfo.bytes >> s->dma_dac.fragshift;
2265 } else {
2266 cinfo.blocks =
2267 s->dma_dac.count >> s->dma_dac.fragshift;
2268 }
2269 cinfo.ptr = s->dma_dac.hwptr;
2270 if (s->dma_dac.mapped)
2271 s->dma_dac.count &= s->dma_dac.fragsize - 1;
2272 spin_unlock_irqrestore(&s->lock, flags);
2273 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2274
2275 case SNDCTL_DSP_GETBLKSIZE:
2276 if (file->f_mode & FMODE_WRITE) {
2277 if ((val = prog_dmabuf_dac(s)))
2278 return val;
2279 return put_user(s->dma_dac.fragsize, (int *) arg);
2280 }
2281 if ((val = prog_dmabuf_adc(s)))
2282 return val;
2283 if (s->conversion)
2284 return put_user(s->dma_adc.fragsize / 2,
2285 (int *) arg);
2286 else
2287 return put_user(s->dma_adc.fragsize, (int *) arg);
2288
2289 case SNDCTL_DSP_SETFRAGMENT:
2290 if (get_user(val, (int *) arg))
2291 return -EFAULT;
2292 return 0; // Say OK, but do nothing.
2293
2294 case SNDCTL_DSP_SUBDIVIDE:
2295 if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision)
2296 || (file->f_mode & FMODE_WRITE
2297 && s->dma_dac.subdivision)) return -EINVAL;
2298 if (get_user(val, (int *) arg))
2299 return -EFAULT;
2300 if (val != 1 && val != 2 && val != 4)
2301 return -EINVAL;
2302 if (file->f_mode & FMODE_READ)
2303 s->dma_adc.subdivision = val;
2304 else if (file->f_mode & FMODE_WRITE)
2305 s->dma_dac.subdivision = val;
2306 return 0;
2307
2308 case SOUND_PCM_READ_RATE:
2309 if (file->f_mode & FMODE_READ)
2310 return put_user(s->prop_adc.rate, (int *) arg);
2311 else if (file->f_mode & FMODE_WRITE)
2312 return put_user(s->prop_dac.rate, (int *) arg);
2313
2314 case SOUND_PCM_READ_CHANNELS:
2315 if (file->f_mode & FMODE_READ)
2316 return put_user(s->prop_adc.channels, (int *) arg);
2317 else if (file->f_mode & FMODE_WRITE)
2318 return put_user(s->prop_dac.channels, (int *) arg);
2319
2320 case SOUND_PCM_READ_BITS:
2321 if (file->f_mode & FMODE_READ)
2322 return
2323 put_user(
2324 (s->prop_adc.
2325 fmt & (AFMT_S8 | AFMT_U8)) ? 8 : 16,
2326 (int *) arg);
2327 else if (file->f_mode & FMODE_WRITE)
2328 return
2329 put_user(
2330 (s->prop_dac.
2331 fmt & (AFMT_S8 | AFMT_U8)) ? 8 : 16,
2332 (int *) arg);
2333
2334 case SOUND_PCM_WRITE_FILTER:
2335 case SNDCTL_DSP_SETSYNCRO:
2336 case SOUND_PCM_READ_FILTER:
2337 return -EINVAL;
2338 }
2339 return mixer_ioctl(s, cmd, arg);
2340 }
2341
2342
2343 static int cs4297a_release(struct inode *inode, struct file *file)
2344 {
2345 struct cs4297a_state *s =
2346 (struct cs4297a_state *) file->private_data;
2347
2348 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk(KERN_INFO
2349 "cs4297a: cs4297a_release(): inode=0x%.8x file=0x%.8x f_mode=0x%x\n",
2350 (unsigned) inode, (unsigned) file, file->f_mode));
2351 VALIDATE_STATE(s);
2352
2353 if (file->f_mode & FMODE_WRITE) {
2354 drain_dac(s, file->f_flags & O_NONBLOCK);
2355 down(&s->open_sem_dac);
2356 stop_dac(s);
2357 dealloc_dmabuf(s, &s->dma_dac);
2358 s->open_mode &= ~FMODE_WRITE;
2359 up(&s->open_sem_dac);
2360 wake_up(&s->open_wait_dac);
2361 }
2362 if (file->f_mode & FMODE_READ) {
2363 drain_adc(s, file->f_flags & O_NONBLOCK);
2364 down(&s->open_sem_adc);
2365 stop_adc(s);
2366 dealloc_dmabuf(s, &s->dma_adc);
2367 s->open_mode &= ~FMODE_READ;
2368 up(&s->open_sem_adc);
2369 wake_up(&s->open_wait_adc);
2370 }
2371 return 0;
2372 }
2373
2374 static int cs4297a_open(struct inode *inode, struct file *file)
2375 {
2376 int minor = iminor(inode);
2377 struct cs4297a_state *s=NULL;
2378 struct list_head *entry;
2379
2380 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
2381 "cs4297a: cs4297a_open(): inode=0x%.8x file=0x%.8x f_mode=0x%x\n",
2382 (unsigned) inode, (unsigned) file, file->f_mode));
2383 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
2384 "cs4297a: status = %08x\n", (int)__raw_readq(SS_CSR(R_SER_STATUS_DEBUG))));
2385
2386 list_for_each(entry, &cs4297a_devs)
2387 {
2388 s = list_entry(entry, struct cs4297a_state, list);
2389
2390 if (!((s->dev_audio ^ minor) & ~0xf))
2391 break;
2392 }
2393 if (entry == &cs4297a_devs)
2394 return -ENODEV;
2395 if (!s) {
2396 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
2397 "cs4297a: cs4297a_open(): Error - unable to find audio state struct\n"));
2398 return -ENODEV;
2399 }
2400 VALIDATE_STATE(s);
2401 file->private_data = s;
2402
2403 // wait for device to become free
2404 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ))) {
2405 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2, printk(KERN_INFO
2406 "cs4297a: cs4297a_open(): Error - must open READ and/or WRITE\n"));
2407 return -ENODEV;
2408 }
2409 if (file->f_mode & FMODE_WRITE) {
2410 if (__raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_TX)) != 0) {
2411 printk(KERN_ERR "cs4297a: TX pipe needs to drain\n");
2412 while (__raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_TX)))
2413 ;
2414 }
2415
2416 down(&s->open_sem_dac);
2417 while (s->open_mode & FMODE_WRITE) {
2418 if (file->f_flags & O_NONBLOCK) {
2419 up(&s->open_sem_dac);
2420 return -EBUSY;
2421 }
2422 up(&s->open_sem_dac);
2423 interruptible_sleep_on(&s->open_wait_dac);
2424
2425 if (signal_pending(current)) {
2426 printk("open - sig pending\n");
2427 return -ERESTARTSYS;
2428 }
2429 down(&s->open_sem_dac);
2430 }
2431 }
2432 if (file->f_mode & FMODE_READ) {
2433 down(&s->open_sem_adc);
2434 while (s->open_mode & FMODE_READ) {
2435 if (file->f_flags & O_NONBLOCK) {
2436 up(&s->open_sem_adc);
2437 return -EBUSY;
2438 }
2439 up(&s->open_sem_adc);
2440 interruptible_sleep_on(&s->open_wait_adc);
2441
2442 if (signal_pending(current)) {
2443 printk("open - sig pending\n");
2444 return -ERESTARTSYS;
2445 }
2446 down(&s->open_sem_adc);
2447 }
2448 }
2449 s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2450 if (file->f_mode & FMODE_READ) {
2451 s->prop_adc.fmt = AFMT_S16_BE;
2452 s->prop_adc.fmt_original = s->prop_adc.fmt;
2453 s->prop_adc.channels = 2;
2454 s->prop_adc.rate = 48000;
2455 s->conversion = 0;
2456 s->ena &= ~FMODE_READ;
2457 s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags =
2458 s->dma_adc.subdivision = 0;
2459 up(&s->open_sem_adc);
2460
2461 if (prog_dmabuf_adc(s)) {
2462 CS_DBGOUT(CS_OPEN | CS_ERROR, 2, printk(KERN_ERR
2463 "cs4297a: adc Program dmabufs failed.\n"));
2464 cs4297a_release(inode, file);
2465 return -ENOMEM;
2466 }
2467 }
2468 if (file->f_mode & FMODE_WRITE) {
2469 s->prop_dac.fmt = AFMT_S16_BE;
2470 s->prop_dac.fmt_original = s->prop_dac.fmt;
2471 s->prop_dac.channels = 2;
2472 s->prop_dac.rate = 48000;
2473 s->conversion = 0;
2474 s->ena &= ~FMODE_WRITE;
2475 s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags =
2476 s->dma_dac.subdivision = 0;
2477 up(&s->open_sem_dac);
2478
2479 if (prog_dmabuf_dac(s)) {
2480 CS_DBGOUT(CS_OPEN | CS_ERROR, 2, printk(KERN_ERR
2481 "cs4297a: dac Program dmabufs failed.\n"));
2482 cs4297a_release(inode, file);
2483 return -ENOMEM;
2484 }
2485 }
2486 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2,
2487 printk(KERN_INFO "cs4297a: cs4297a_open()- 0\n"));
2488 return nonseekable_open(inode, file);
2489 }
2490
2491
2492 // ******************************************************************************************
2493 // Wave (audio) file operations struct.
2494 // ******************************************************************************************
2495 static /*const */ struct file_operations cs4297a_audio_fops = {
2496 .owner = THIS_MODULE,
2497 .llseek = no_llseek,
2498 .read = cs4297a_read,
2499 .write = cs4297a_write,
2500 .poll = cs4297a_poll,
2501 .ioctl = cs4297a_ioctl,
2502 .mmap = cs4297a_mmap,
2503 .open = cs4297a_open,
2504 .release = cs4297a_release,
2505 };
2506
2507 static void cs4297a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2508 {
2509 struct cs4297a_state *s = (struct cs4297a_state *) dev_id;
2510 u32 status;
2511
2512 status = __raw_readq(SS_CSR(R_SER_STATUS_DEBUG));
2513
2514 CS_DBGOUT(CS_INTERRUPT, 6, printk(KERN_INFO
2515 "cs4297a: cs4297a_interrupt() HISR=0x%.8x\n", status));
2516
2517 #if 0
2518 /* XXXKW what check *should* be done here? */
2519 if (!(status & (M_SYNCSER_RX_EOP_COUNT | M_SYNCSER_RX_OVERRUN | M_SYNCSER_RX_SYNC_ERR))) {
2520 status = __raw_readq(SS_CSR(R_SER_STATUS));
2521 printk(KERN_ERR "cs4297a: unexpected interrupt (status %08x)\n", status);
2522 return;
2523 }
2524 #endif
2525
2526 if (status & M_SYNCSER_RX_SYNC_ERR) {
2527 status = __raw_readq(SS_CSR(R_SER_STATUS));
2528 printk(KERN_ERR "cs4297a: rx sync error (status %08x)\n", status);
2529 return;
2530 }
2531
2532 if (status & M_SYNCSER_RX_OVERRUN) {
2533 int newptr, i;
2534 s->stats.rx_ovrrn++;
2535 printk(KERN_ERR "cs4297a: receive FIFO overrun\n");
2536
2537 /* Fix things up: get the receive descriptor pool
2538 clean and give them back to the hardware */
2539 while (__raw_readq(SS_CSR(R_SER_DMA_DSCR_COUNT_RX)))
2540 ;
2541 newptr = (unsigned) (((__raw_readq(SS_CSR(R_SER_DMA_CUR_DSCR_ADDR_RX)) & M_DMA_CURDSCR_ADDR) -
2542 s->dma_adc.descrtab_phys) / sizeof(serdma_descr_t));
2543 for (i=0; i<DMA_DESCR; i++) {
2544 s->dma_adc.descrtab[i].descr_a &= ~M_DMA_SERRX_SOP;
2545 }
2546 s->dma_adc.swptr = s->dma_adc.hwptr = newptr;
2547 s->dma_adc.count = 0;
2548 s->dma_adc.sb_swptr = s->dma_adc.sb_hwptr = s->dma_adc.sample_buf;
2549 __raw_writeq(DMA_DESCR, SS_CSR(R_SER_DMA_DSCR_COUNT_RX));
2550 }
2551
2552 spin_lock(&s->lock);
2553 cs4297a_update_ptr(s,CS_TRUE);
2554 spin_unlock(&s->lock);
2555
2556 CS_DBGOUT(CS_INTERRUPT, 6, printk(KERN_INFO
2557 "cs4297a: cs4297a_interrupt()-\n"));
2558 }
2559
2560 #if 0
2561 static struct initvol {
2562 int mixch;
2563 int vol;
2564 } initvol[] __initdata = {
2565
2566 {SOUND_MIXER_WRITE_VOLUME, 0x4040},
2567 {SOUND_MIXER_WRITE_PCM, 0x4040},
2568 {SOUND_MIXER_WRITE_SYNTH, 0x4040},
2569 {SOUND_MIXER_WRITE_CD, 0x4040},
2570 {SOUND_MIXER_WRITE_LINE, 0x4040},
2571 {SOUND_MIXER_WRITE_LINE1, 0x4040},
2572 {SOUND_MIXER_WRITE_RECLEV, 0x0000},
2573 {SOUND_MIXER_WRITE_SPEAKER, 0x4040},
2574 {SOUND_MIXER_WRITE_MIC, 0x0000}
2575 };
2576 #endif
2577
2578 static int __init cs4297a_init(void)
2579 {
2580 struct cs4297a_state *s;
2581 u32 pwr, id;
2582 mm_segment_t fs;
2583 int rval;
2584 #ifndef CONFIG_BCM_CS4297A_CSWARM
2585 u64 cfg;
2586 int mdio_val;
2587 #endif
2588
2589 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
2590 "cs4297a: cs4297a_init_module()+ \n"));
2591
2592 #ifndef CONFIG_BCM_CS4297A_CSWARM
2593 mdio_val = __raw_readq(KSEG1 + A_MAC_REGISTER(2, R_MAC_MDIO)) &
2594 (M_MAC_MDIO_DIR|M_MAC_MDIO_OUT);
2595
2596 /* Check syscfg for synchronous serial on port 1 */
2597 cfg = __raw_readq(KSEG1 + A_SCD_SYSTEM_CFG);
2598 if (!(cfg & M_SYS_SER1_ENABLE)) {
2599 __raw_writeq(cfg | M_SYS_SER1_ENABLE, KSEG1+A_SCD_SYSTEM_CFG);
2600 cfg = __raw_readq(KSEG1 + A_SCD_SYSTEM_CFG);
2601 if (!(cfg & M_SYS_SER1_ENABLE)) {
2602 printk(KERN_INFO "cs4297a: serial port 1 not configured for synchronous operation\n");
2603 return -1;
2604 }
2605
2606 printk(KERN_INFO "cs4297a: serial port 1 switching to synchronous operation\n");
2607
2608 /* Force the codec (on SWARM) to reset by clearing
2609 GENO, preserving MDIO (no effect on CSWARM) */
2610 __raw_writeq(mdio_val, KSEG1+A_MAC_REGISTER(2, R_MAC_MDIO));
2611 udelay(10);
2612 }
2613
2614 /* Now set GENO */
2615 __raw_writeq(mdio_val | M_MAC_GENC, KSEG1+A_MAC_REGISTER(2, R_MAC_MDIO));
2616 /* Give the codec some time to finish resetting (start the bit clock) */
2617 udelay(100);
2618 #endif
2619
2620 if (!(s = kmalloc(sizeof(struct cs4297a_state), GFP_KERNEL))) {
2621 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
2622 "cs4297a: probe() no memory for state struct.\n"));
2623 return -1;
2624 }
2625 memset(s, 0, sizeof(struct cs4297a_state));
2626 s->magic = CS4297a_MAGIC;
2627 init_waitqueue_head(&s->dma_adc.wait);
2628 init_waitqueue_head(&s->dma_dac.wait);
2629 init_waitqueue_head(&s->dma_adc.reg_wait);
2630 init_waitqueue_head(&s->dma_dac.reg_wait);
2631 init_waitqueue_head(&s->open_wait);
2632 init_waitqueue_head(&s->open_wait_adc);
2633 init_waitqueue_head(&s->open_wait_dac);
2634 init_MUTEX(&s->open_sem_adc);
2635 init_MUTEX(&s->open_sem_dac);
2636 spin_lock_init(&s->lock);
2637
2638 s->irq = K_INT_SER_1;
2639
2640 if (request_irq
2641 (s->irq, cs4297a_interrupt, 0, "Crystal CS4297a", s)) {
2642 CS_DBGOUT(CS_INIT | CS_ERROR, 1,
2643 printk(KERN_ERR "cs4297a: irq %u in use\n", s->irq));
2644 goto err_irq;
2645 }
2646 if ((s->dev_audio = register_sound_dsp(&cs4297a_audio_fops, -1)) <
2647 0) {
2648 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
2649 "cs4297a: probe() register_sound_dsp() failed.\n"));
2650 goto err_dev1;
2651 }
2652 if ((s->dev_mixer = register_sound_mixer(&cs4297a_mixer_fops, -1)) <
2653 0) {
2654 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
2655 "cs4297a: probe() register_sound_mixer() failed.\n"));
2656 goto err_dev2;
2657 }
2658
2659 if (ser_init(s) || dma_init(s)) {
2660 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
2661 "cs4297a: ser_init failed.\n"));
2662 goto err_dev3;
2663 }
2664
2665 do {
2666 udelay(4000);
2667 rval = cs4297a_read_ac97(s, AC97_POWER_CONTROL, &pwr);
2668 } while (!rval && (pwr != 0xf));
2669
2670 if (!rval) {
2671 char *sb1250_duart_present;
2672
2673 fs = get_fs();
2674 set_fs(KERNEL_DS);
2675 #if 0
2676 val = SOUND_MASK_LINE;
2677 mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long) &val);
2678 for (i = 0; i < sizeof(initvol) / sizeof(initvol[0]); i++) {
2679 val = initvol[i].vol;
2680 mixer_ioctl(s, initvol[i].mixch, (unsigned long) &val);
2681 }
2682 // cs4297a_write_ac97(s, 0x18, 0x0808);
2683 #else
2684 // cs4297a_write_ac97(s, 0x5e, 0x180);
2685 cs4297a_write_ac97(s, 0x02, 0x0808);
2686 cs4297a_write_ac97(s, 0x18, 0x0808);
2687 #endif
2688 set_fs(fs);
2689
2690 list_add(&s->list, &cs4297a_devs);
2691
2692 cs4297a_read_ac97(s, AC97_VENDOR_ID1, &id);
2693
2694 sb1250_duart_present = symbol_get(sb1250_duart_present);
2695 if (sb1250_duart_present)
2696 sb1250_duart_present[1] = 0;
2697
2698 printk(KERN_INFO "cs4297a: initialized (vendor id = %x)\n", id);
2699
2700 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
2701 printk(KERN_INFO "cs4297a: cs4297a_init_module()-\n"));
2702
2703 return 0;
2704 }
2705
2706 err_dev3:
2707 unregister_sound_mixer(s->dev_mixer);
2708 err_dev2:
2709 unregister_sound_dsp(s->dev_audio);
2710 err_dev1:
2711 free_irq(s->irq, s);
2712 err_irq:
2713 kfree(s);
2714
2715 printk(KERN_INFO "cs4297a: initialization failed\n");
2716
2717 return -1;
2718 }
2719
2720 static void __exit cs4297a_cleanup(void)
2721 {
2722 /*
2723 XXXKW
2724 disable_irq, free_irq
2725 drain DMA queue
2726 disable DMA
2727 disable TX/RX
2728 free memory
2729 */
2730 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
2731 printk(KERN_INFO "cs4297a: cleanup_cs4297a() finished\n"));
2732 }
2733
2734 // ---------------------------------------------------------------------
2735
2736 MODULE_AUTHOR("Kip Walker, Broadcom Corp.");
2737 MODULE_DESCRIPTION("Cirrus Logic CS4297a Driver for Broadcom SWARM board");
2738
2739 // ---------------------------------------------------------------------
2740
2741 module_init(cs4297a_init);
2742 module_exit(cs4297a_cleanup);
Ubuntu Artful kernel mirror