Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Driver for Philips UDA1341TS on Compaq iPAQ H3600 soundcard | |
3 | * Copyright (C) 2002 Tomas Kasparek <tomas.kasparek@seznam.cz> | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License. | |
7 | * | |
8 | * History: | |
9 | * | |
10 | * 2002-03-13 Tomas Kasparek initial release - based on h3600-uda1341.c from OSS | |
11 | * 2002-03-20 Tomas Kasparek playback over ALSA is working | |
12 | * 2002-03-28 Tomas Kasparek playback over OSS emulation is working | |
13 | * 2002-03-29 Tomas Kasparek basic capture is working (native ALSA) | |
14 | * 2002-03-29 Tomas Kasparek capture is working (OSS emulation) | |
15 | * 2002-04-04 Tomas Kasparek better rates handling (allow non-standard rates) | |
16 | * 2003-02-14 Brian Avery fixed full duplex mode, other updates | |
17 | * 2003-02-20 Tomas Kasparek merged updates by Brian (except HAL) | |
18 | * 2003-04-19 Jaroslav Kysela recoded DMA stuff to follow 2.4.18rmk3-hh24 kernel | |
19 | * working suspend and resume | |
20 | * 2003-04-28 Tomas Kasparek updated work by Jaroslav to compile it under 2.5.x again | |
21 | * merged HAL layer (patches from Brian) | |
22 | */ | |
23 | ||
1da177e4 LT |
24 | /*************************************************************************************************** |
25 | * | |
26 | * To understand what Alsa Drivers should be doing look at "Writing an Alsa Driver" by Takashi Iwai | |
27 | * available in the Alsa doc section on the website | |
28 | * | |
29 | * A few notes to make things clearer. The UDA1341 is hooked up to Serial port 4 on the SA1100. | |
30 | * We are using SSP mode to talk to the UDA1341. The UDA1341 bit & wordselect clocks are generated | |
31 | * by this UART. Unfortunately, the clock only runs if the transmit buffer has something in it. | |
32 | * So, if we are just recording, we feed the transmit DMA stream a bunch of 0x0000 so that the | |
33 | * transmit buffer is full and the clock keeps going. The zeroes come from FLUSH_BASE_PHYS which | |
34 | * is a mem loc that always decodes to 0's w/ no off chip access. | |
35 | * | |
36 | * Some alsa terminology: | |
37 | * frame => num_channels * sample_size e.g stereo 16 bit is 2 * 16 = 32 bytes | |
38 | * period => the least number of bytes that will generate an interrupt e.g. we have a 1024 byte | |
39 | * buffer and 4 periods in the runtime structure this means we'll get an int every 256 | |
40 | * bytes or 4 times per buffer. | |
41 | * A number of the sizes are in frames rather than bytes, use frames_to_bytes and | |
42 | * bytes_to_frames to convert. The easiest way to tell the units is to look at the | |
43 | * type i.e. runtime-> buffer_size is in frames and its type is snd_pcm_uframes_t | |
44 | * | |
45 | * Notes about the pointer fxn: | |
46 | * The pointer fxn needs to return the offset into the dma buffer in frames. | |
47 | * Interrupts must be blocked before calling the dma_get_pos fxn to avoid race with interrupts. | |
48 | * | |
49 | * Notes about pause/resume | |
50 | * Implementing this would be complicated so it's skipped. The problem case is: | |
51 | * A full duplex connection is going, then play is paused. At this point you need to start xmitting | |
52 | * 0's to keep the record active which means you cant just freeze the dma and resume it later you'd | |
53 | * need to save off the dma info, and restore it properly on a resume. Yeach! | |
54 | * | |
55 | * Notes about transfer methods: | |
56 | * The async write calls fail. I probably need to implement something else to support them? | |
57 | * | |
58 | ***************************************************************************************************/ | |
59 | ||
1da177e4 LT |
60 | #include <linux/module.h> |
61 | #include <linux/moduleparam.h> | |
62 | #include <linux/init.h> | |
2b3f5587 TI |
63 | #include <linux/err.h> |
64 | #include <linux/platform_device.h> | |
1da177e4 LT |
65 | #include <linux/errno.h> |
66 | #include <linux/ioctl.h> | |
67 | #include <linux/delay.h> | |
68 | #include <linux/slab.h> | |
69 | ||
70 | #ifdef CONFIG_PM | |
71 | #include <linux/pm.h> | |
72 | #endif | |
73 | ||
a09e64fb RK |
74 | #include <mach/hardware.h> |
75 | #include <mach/h3600.h> | |
1da177e4 LT |
76 | #include <asm/mach-types.h> |
77 | #include <asm/dma.h> | |
78 | ||
1da177e4 LT |
79 | #include <sound/core.h> |
80 | #include <sound/pcm.h> | |
81 | #include <sound/initval.h> | |
82 | ||
83 | #include <linux/l3/l3.h> | |
84 | ||
85 | #undef DEBUG_MODE | |
86 | #undef DEBUG_FUNCTION_NAMES | |
87 | #include <sound/uda1341.h> | |
88 | ||
89 | /* | |
90 | * FIXME: Is this enough as autodetection of 2.4.X-rmkY-hhZ kernels? | |
91 | * We use DMA stuff from 2.4.18-rmk3-hh24 here to be able to compile this | |
92 | * module for Familiar 0.6.1 | |
93 | */ | |
1da177e4 LT |
94 | |
95 | /* {{{ Type definitions */ | |
96 | ||
97 | MODULE_AUTHOR("Tomas Kasparek <tomas.kasparek@seznam.cz>"); | |
98 | MODULE_LICENSE("GPL"); | |
99 | MODULE_DESCRIPTION("SA1100/SA1111 + UDA1341TS driver for ALSA"); | |
100 | MODULE_SUPPORTED_DEVICE("{{UDA1341,iPAQ H3600 UDA1341TS}}"); | |
101 | ||
6581f4e7 | 102 | static char *id; /* ID for this card */ |
1da177e4 LT |
103 | |
104 | module_param(id, charp, 0444); | |
105 | MODULE_PARM_DESC(id, "ID string for SA1100/SA1111 + UDA1341TS soundcard."); | |
106 | ||
af0fbfb5 | 107 | struct audio_stream { |
1da177e4 LT |
108 | char *id; /* identification string */ |
109 | int stream_id; /* numeric identification */ | |
110 | dma_device_t dma_dev; /* device identifier for DMA */ | |
111 | #ifdef HH_VERSION | |
112 | dmach_t dmach; /* dma channel identification */ | |
113 | #else | |
114 | dma_regs_t *dma_regs; /* points to our DMA registers */ | |
115 | #endif | |
940cc2df | 116 | unsigned int active:1; /* we are using this stream for transfer now */ |
1da177e4 LT |
117 | int period; /* current transfer period */ |
118 | int periods; /* current count of periods registerd in the DMA engine */ | |
119 | int tx_spin; /* are we recoding - flag used to do DMA trans. for sync */ | |
120 | unsigned int old_offset; | |
121 | spinlock_t dma_lock; /* for locking in DMA operations (see dma-sa1100.c in the kernel) */ | |
af0fbfb5 TI |
122 | struct snd_pcm_substream *stream; |
123 | }; | |
1da177e4 | 124 | |
af0fbfb5 TI |
125 | struct sa11xx_uda1341 { |
126 | struct snd_card *card; | |
1da177e4 | 127 | struct l3_client *uda1341; |
af0fbfb5 | 128 | struct snd_pcm *pcm; |
1da177e4 | 129 | long samplerate; |
af0fbfb5 TI |
130 | struct audio_stream s[2]; /* playback & capture */ |
131 | }; | |
1da177e4 | 132 | |
1da177e4 LT |
133 | static unsigned int rates[] = { |
134 | 8000, 10666, 10985, 14647, | |
135 | 16000, 21970, 22050, 24000, | |
136 | 29400, 32000, 44100, 48000, | |
137 | }; | |
138 | ||
af0fbfb5 | 139 | static struct snd_pcm_hw_constraint_list hw_constraints_rates = { |
1da177e4 LT |
140 | .count = ARRAY_SIZE(rates), |
141 | .list = rates, | |
142 | .mask = 0, | |
143 | }; | |
144 | ||
f7a9275d CL |
145 | static struct platform_device *device; |
146 | ||
1da177e4 LT |
147 | /* }}} */ |
148 | ||
149 | /* {{{ Clock and sample rate stuff */ | |
150 | ||
151 | /* | |
152 | * Stop-gap solution until rest of hh.org HAL stuff is merged. | |
153 | */ | |
154 | #define GPIO_H3600_CLK_SET0 GPIO_GPIO (12) | |
155 | #define GPIO_H3600_CLK_SET1 GPIO_GPIO (13) | |
156 | ||
157 | #ifdef CONFIG_SA1100_H3XXX | |
158 | #define clr_sa11xx_uda1341_egpio(x) clr_h3600_egpio(x) | |
159 | #define set_sa11xx_uda1341_egpio(x) set_h3600_egpio(x) | |
160 | #else | |
161 | #error This driver could serve H3x00 handhelds only! | |
162 | #endif | |
163 | ||
164 | static void sa11xx_uda1341_set_audio_clock(long val) | |
165 | { | |
166 | switch (val) { | |
167 | case 24000: case 32000: case 48000: /* 00: 12.288 MHz */ | |
168 | GPCR = GPIO_H3600_CLK_SET0 | GPIO_H3600_CLK_SET1; | |
169 | break; | |
170 | ||
171 | case 22050: case 29400: case 44100: /* 01: 11.2896 MHz */ | |
172 | GPSR = GPIO_H3600_CLK_SET0; | |
173 | GPCR = GPIO_H3600_CLK_SET1; | |
174 | break; | |
175 | ||
176 | case 8000: case 10666: case 16000: /* 10: 4.096 MHz */ | |
177 | GPCR = GPIO_H3600_CLK_SET0; | |
178 | GPSR = GPIO_H3600_CLK_SET1; | |
179 | break; | |
180 | ||
181 | case 10985: case 14647: case 21970: /* 11: 5.6245 MHz */ | |
182 | GPSR = GPIO_H3600_CLK_SET0 | GPIO_H3600_CLK_SET1; | |
183 | break; | |
184 | } | |
185 | } | |
186 | ||
af0fbfb5 | 187 | static void sa11xx_uda1341_set_samplerate(struct sa11xx_uda1341 *sa11xx_uda1341, long rate) |
1da177e4 LT |
188 | { |
189 | int clk_div = 0; | |
190 | int clk=0; | |
191 | ||
192 | /* We don't want to mess with clocks when frames are in flight */ | |
193 | Ser4SSCR0 &= ~SSCR0_SSE; | |
194 | /* wait for any frame to complete */ | |
195 | udelay(125); | |
196 | ||
197 | /* | |
198 | * We have the following clock sources: | |
199 | * 4.096 MHz, 5.6245 MHz, 11.2896 MHz, 12.288 MHz | |
200 | * Those can be divided either by 256, 384 or 512. | |
201 | * This makes up 12 combinations for the following samplerates... | |
202 | */ | |
203 | if (rate >= 48000) | |
204 | rate = 48000; | |
205 | else if (rate >= 44100) | |
206 | rate = 44100; | |
207 | else if (rate >= 32000) | |
208 | rate = 32000; | |
209 | else if (rate >= 29400) | |
210 | rate = 29400; | |
211 | else if (rate >= 24000) | |
212 | rate = 24000; | |
213 | else if (rate >= 22050) | |
214 | rate = 22050; | |
215 | else if (rate >= 21970) | |
216 | rate = 21970; | |
217 | else if (rate >= 16000) | |
218 | rate = 16000; | |
219 | else if (rate >= 14647) | |
220 | rate = 14647; | |
221 | else if (rate >= 10985) | |
222 | rate = 10985; | |
223 | else if (rate >= 10666) | |
224 | rate = 10666; | |
225 | else | |
226 | rate = 8000; | |
227 | ||
228 | /* Set the external clock generator */ | |
350a29b4 | 229 | |
1da177e4 | 230 | sa11xx_uda1341_set_audio_clock(rate); |
1da177e4 LT |
231 | |
232 | /* Select the clock divisor */ | |
233 | switch (rate) { | |
234 | case 8000: | |
235 | case 10985: | |
236 | case 22050: | |
237 | case 24000: | |
238 | clk = F512; | |
239 | clk_div = SSCR0_SerClkDiv(16); | |
240 | break; | |
241 | case 16000: | |
242 | case 21970: | |
243 | case 44100: | |
244 | case 48000: | |
245 | clk = F256; | |
246 | clk_div = SSCR0_SerClkDiv(8); | |
247 | break; | |
248 | case 10666: | |
249 | case 14647: | |
250 | case 29400: | |
251 | case 32000: | |
252 | clk = F384; | |
253 | clk_div = SSCR0_SerClkDiv(12); | |
254 | break; | |
255 | } | |
256 | ||
257 | /* FMT setting should be moved away when other FMTs are added (FIXME) */ | |
258 | l3_command(sa11xx_uda1341->uda1341, CMD_FORMAT, (void *)LSB16); | |
259 | ||
260 | l3_command(sa11xx_uda1341->uda1341, CMD_FS, (void *)clk); | |
261 | Ser4SSCR0 = (Ser4SSCR0 & ~0xff00) + clk_div + SSCR0_SSE; | |
262 | sa11xx_uda1341->samplerate = rate; | |
263 | } | |
264 | ||
265 | /* }}} */ | |
266 | ||
267 | /* {{{ HW init and shutdown */ | |
268 | ||
af0fbfb5 | 269 | static void sa11xx_uda1341_audio_init(struct sa11xx_uda1341 *sa11xx_uda1341) |
1da177e4 LT |
270 | { |
271 | unsigned long flags; | |
272 | ||
273 | /* Setup DMA stuff */ | |
274 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].id = "UDA1341 out"; | |
275 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].stream_id = SNDRV_PCM_STREAM_PLAYBACK; | |
276 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].dma_dev = DMA_Ser4SSPWr; | |
277 | ||
278 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].id = "UDA1341 in"; | |
279 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].stream_id = SNDRV_PCM_STREAM_CAPTURE; | |
280 | sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].dma_dev = DMA_Ser4SSPRd; | |
281 | ||
282 | /* Initialize the UDA1341 internal state */ | |
283 | ||
284 | /* Setup the uarts */ | |
285 | local_irq_save(flags); | |
286 | GAFR |= (GPIO_SSP_CLK); | |
287 | GPDR &= ~(GPIO_SSP_CLK); | |
288 | Ser4SSCR0 = 0; | |
289 | Ser4SSCR0 = SSCR0_DataSize(16) + SSCR0_TI + SSCR0_SerClkDiv(8); | |
290 | Ser4SSCR1 = SSCR1_SClkIactL + SSCR1_SClk1P + SSCR1_ExtClk; | |
291 | Ser4SSCR0 |= SSCR0_SSE; | |
292 | local_irq_restore(flags); | |
293 | ||
294 | /* Enable the audio power */ | |
350a29b4 | 295 | |
1da177e4 LT |
296 | clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET); |
297 | set_sa11xx_uda1341_egpio(IPAQ_EGPIO_AUDIO_ON); | |
298 | set_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE); | |
1da177e4 LT |
299 | |
300 | /* Wait for the UDA1341 to wake up */ | |
301 | mdelay(1); //FIXME - was removed by Perex - Why? | |
302 | ||
303 | /* Initialize the UDA1341 internal state */ | |
304 | l3_open(sa11xx_uda1341->uda1341); | |
305 | ||
306 | /* external clock configuration (after l3_open - regs must be initialized */ | |
307 | sa11xx_uda1341_set_samplerate(sa11xx_uda1341, sa11xx_uda1341->samplerate); | |
308 | ||
309 | /* Wait for the UDA1341 to wake up */ | |
310 | set_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET); | |
311 | mdelay(1); | |
312 | ||
313 | /* make the left and right channels unswapped (flip the WS latch) */ | |
314 | Ser4SSDR = 0; | |
315 | ||
350a29b4 | 316 | clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE); |
1da177e4 LT |
317 | } |
318 | ||
af0fbfb5 | 319 | static void sa11xx_uda1341_audio_shutdown(struct sa11xx_uda1341 *sa11xx_uda1341) |
1da177e4 LT |
320 | { |
321 | /* mute on */ | |
1da177e4 | 322 | set_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE); |
1da177e4 LT |
323 | |
324 | /* disable the audio power and all signals leading to the audio chip */ | |
325 | l3_close(sa11xx_uda1341->uda1341); | |
326 | Ser4SSCR0 = 0; | |
327 | clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET); | |
328 | ||
329 | /* power off and mute off */ | |
330 | /* FIXME - is muting off necesary??? */ | |
350a29b4 | 331 | |
1da177e4 LT |
332 | clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_AUDIO_ON); |
333 | clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE); | |
1da177e4 LT |
334 | } |
335 | ||
336 | /* }}} */ | |
337 | ||
338 | /* {{{ DMA staff */ | |
339 | ||
340 | /* | |
341 | * these are the address and sizes used to fill the xmit buffer | |
342 | * so we can get a clock in record only mode | |
343 | */ | |
344 | #define FORCE_CLOCK_ADDR (dma_addr_t)FLUSH_BASE_PHYS | |
345 | #define FORCE_CLOCK_SIZE 4096 // was 2048 | |
346 | ||
347 | // FIXME Why this value exactly - wrote comment | |
348 | #define DMA_BUF_SIZE 8176 /* <= MAX_DMA_SIZE from asm/arch-sa1100/dma.h */ | |
349 | ||
350 | #ifdef HH_VERSION | |
351 | ||
af0fbfb5 | 352 | static int audio_dma_request(struct audio_stream *s, void (*callback)(void *, int)) |
1da177e4 LT |
353 | { |
354 | int ret; | |
355 | ||
356 | ret = sa1100_request_dma(&s->dmach, s->id, s->dma_dev); | |
357 | if (ret < 0) { | |
358 | printk(KERN_ERR "unable to grab audio dma 0x%x\n", s->dma_dev); | |
359 | return ret; | |
360 | } | |
361 | sa1100_dma_set_callback(s->dmach, callback); | |
362 | return 0; | |
363 | } | |
364 | ||
af0fbfb5 | 365 | static inline void audio_dma_free(struct audio_stream *s) |
1da177e4 LT |
366 | { |
367 | sa1100_free_dma(s->dmach); | |
368 | s->dmach = -1; | |
369 | } | |
370 | ||
371 | #else | |
372 | ||
af0fbfb5 | 373 | static int audio_dma_request(struct audio_stream *s, void (*callback)(void *)) |
1da177e4 LT |
374 | { |
375 | int ret; | |
376 | ||
377 | ret = sa1100_request_dma(s->dma_dev, s->id, callback, s, &s->dma_regs); | |
378 | if (ret < 0) | |
379 | printk(KERN_ERR "unable to grab audio dma 0x%x\n", s->dma_dev); | |
380 | return ret; | |
381 | } | |
382 | ||
af0fbfb5 | 383 | static void audio_dma_free(struct audio_stream *s) |
1da177e4 | 384 | { |
0948e3c8 TI |
385 | sa1100_free_dma(s->dma_regs); |
386 | s->dma_regs = 0; | |
1da177e4 LT |
387 | } |
388 | ||
389 | #endif | |
390 | ||
af0fbfb5 | 391 | static u_int audio_get_dma_pos(struct audio_stream *s) |
1da177e4 | 392 | { |
af0fbfb5 TI |
393 | struct snd_pcm_substream *substream = s->stream; |
394 | struct snd_pcm_runtime *runtime = substream->runtime; | |
1da177e4 LT |
395 | unsigned int offset; |
396 | unsigned long flags; | |
397 | dma_addr_t addr; | |
398 | ||
399 | // this must be called w/ interrupts locked out see dma-sa1100.c in the kernel | |
400 | spin_lock_irqsave(&s->dma_lock, flags); | |
401 | #ifdef HH_VERSION | |
402 | sa1100_dma_get_current(s->dmach, NULL, &addr); | |
403 | #else | |
404 | addr = sa1100_get_dma_pos((s)->dma_regs); | |
405 | #endif | |
406 | offset = addr - runtime->dma_addr; | |
407 | spin_unlock_irqrestore(&s->dma_lock, flags); | |
408 | ||
409 | offset = bytes_to_frames(runtime,offset); | |
410 | if (offset >= runtime->buffer_size) | |
411 | offset = 0; | |
412 | ||
413 | return offset; | |
414 | } | |
415 | ||
416 | /* | |
417 | * this stops the dma and clears the dma ptrs | |
418 | */ | |
af0fbfb5 | 419 | static void audio_stop_dma(struct audio_stream *s) |
1da177e4 LT |
420 | { |
421 | unsigned long flags; | |
422 | ||
423 | spin_lock_irqsave(&s->dma_lock, flags); | |
424 | s->active = 0; | |
425 | s->period = 0; | |
426 | /* this stops the dma channel and clears the buffer ptrs */ | |
427 | #ifdef HH_VERSION | |
428 | sa1100_dma_flush_all(s->dmach); | |
429 | #else | |
430 | sa1100_clear_dma(s->dma_regs); | |
431 | #endif | |
432 | spin_unlock_irqrestore(&s->dma_lock, flags); | |
433 | } | |
434 | ||
af0fbfb5 | 435 | static void audio_process_dma(struct audio_stream *s) |
1da177e4 | 436 | { |
af0fbfb5 TI |
437 | struct snd_pcm_substream *substream = s->stream; |
438 | struct snd_pcm_runtime *runtime; | |
1da177e4 LT |
439 | unsigned int dma_size; |
440 | unsigned int offset; | |
441 | int ret; | |
442 | ||
443 | /* we are requested to process synchronization DMA transfer */ | |
444 | if (s->tx_spin) { | |
5e246b85 TI |
445 | if (snd_BUG_ON(s->stream_id != SNDRV_PCM_STREAM_PLAYBACK)) |
446 | return; | |
1da177e4 LT |
447 | /* fill the xmit dma buffers and return */ |
448 | #ifdef HH_VERSION | |
449 | sa1100_dma_set_spin(s->dmach, FORCE_CLOCK_ADDR, FORCE_CLOCK_SIZE); | |
450 | #else | |
451 | while (1) { | |
452 | ret = sa1100_start_dma(s->dma_regs, FORCE_CLOCK_ADDR, FORCE_CLOCK_SIZE); | |
453 | if (ret) | |
454 | return; | |
455 | } | |
456 | #endif | |
457 | return; | |
458 | } | |
459 | ||
460 | /* must be set here - only valid for running streams, not for forced_clock dma fills */ | |
461 | runtime = substream->runtime; | |
462 | while (s->active && s->periods < runtime->periods) { | |
463 | dma_size = frames_to_bytes(runtime, runtime->period_size); | |
464 | if (s->old_offset) { | |
465 | /* a little trick, we need resume from old position */ | |
466 | offset = frames_to_bytes(runtime, s->old_offset - 1); | |
467 | s->old_offset = 0; | |
468 | s->periods = 0; | |
469 | s->period = offset / dma_size; | |
470 | offset %= dma_size; | |
471 | dma_size = dma_size - offset; | |
472 | if (!dma_size) | |
473 | continue; /* special case */ | |
474 | } else { | |
475 | offset = dma_size * s->period; | |
5e246b85 | 476 | snd_BUG_ON(dma_size > DMA_BUF_SIZE); |
1da177e4 LT |
477 | } |
478 | #ifdef HH_VERSION | |
479 | ret = sa1100_dma_queue_buffer(s->dmach, s, runtime->dma_addr + offset, dma_size); | |
480 | if (ret) | |
481 | return; //FIXME | |
482 | #else | |
483 | ret = sa1100_start_dma((s)->dma_regs, runtime->dma_addr + offset, dma_size); | |
484 | if (ret) { | |
485 | printk(KERN_ERR "audio_process_dma: cannot queue DMA buffer (%i)\n", ret); | |
486 | return; | |
487 | } | |
488 | #endif | |
489 | ||
490 | s->period++; | |
491 | s->period %= runtime->periods; | |
492 | s->periods++; | |
493 | } | |
494 | } | |
495 | ||
496 | #ifdef HH_VERSION | |
497 | static void audio_dma_callback(void *data, int size) | |
498 | #else | |
499 | static void audio_dma_callback(void *data) | |
500 | #endif | |
501 | { | |
af0fbfb5 | 502 | struct audio_stream *s = data; |
1da177e4 LT |
503 | |
504 | /* | |
505 | * If we are getting a callback for an active stream then we inform | |
506 | * the PCM middle layer we've finished a period | |
507 | */ | |
508 | if (s->active) | |
509 | snd_pcm_period_elapsed(s->stream); | |
510 | ||
511 | spin_lock(&s->dma_lock); | |
512 | if (!s->tx_spin && s->periods > 0) | |
513 | s->periods--; | |
514 | audio_process_dma(s); | |
515 | spin_unlock(&s->dma_lock); | |
516 | } | |
517 | ||
518 | /* }}} */ | |
519 | ||
520 | /* {{{ PCM setting */ | |
521 | ||
522 | /* {{{ trigger & timer */ | |
523 | ||
af0fbfb5 | 524 | static int snd_sa11xx_uda1341_trigger(struct snd_pcm_substream *substream, int cmd) |
1da177e4 | 525 | { |
af0fbfb5 | 526 | struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); |
1da177e4 | 527 | int stream_id = substream->pstr->stream; |
af0fbfb5 TI |
528 | struct audio_stream *s = &chip->s[stream_id]; |
529 | struct audio_stream *s1 = &chip->s[stream_id ^ 1]; | |
1da177e4 LT |
530 | int err = 0; |
531 | ||
532 | /* note local interrupts are already disabled in the midlevel code */ | |
533 | spin_lock(&s->dma_lock); | |
534 | switch (cmd) { | |
535 | case SNDRV_PCM_TRIGGER_START: | |
536 | /* now we need to make sure a record only stream has a clock */ | |
537 | if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) { | |
538 | /* we need to force fill the xmit DMA with zeros */ | |
539 | s1->tx_spin = 1; | |
540 | audio_process_dma(s1); | |
541 | } | |
542 | /* this case is when you were recording then you turn on a | |
543 | * playback stream so we stop (also clears it) the dma first, | |
544 | * clear the sync flag and then we let it turned on | |
545 | */ | |
546 | else { | |
547 | s->tx_spin = 0; | |
548 | } | |
549 | ||
550 | /* requested stream startup */ | |
551 | s->active = 1; | |
552 | audio_process_dma(s); | |
553 | break; | |
554 | case SNDRV_PCM_TRIGGER_STOP: | |
555 | /* requested stream shutdown */ | |
556 | audio_stop_dma(s); | |
557 | ||
558 | /* | |
559 | * now we need to make sure a record only stream has a clock | |
560 | * so if we're stopping a playback with an active capture | |
561 | * we need to turn the 0 fill dma on for the xmit side | |
562 | */ | |
563 | if (stream_id == SNDRV_PCM_STREAM_PLAYBACK && s1->active) { | |
564 | /* we need to force fill the xmit DMA with zeros */ | |
565 | s->tx_spin = 1; | |
566 | audio_process_dma(s); | |
567 | } | |
568 | /* | |
569 | * we killed a capture only stream, so we should also kill | |
570 | * the zero fill transmit | |
571 | */ | |
572 | else { | |
573 | if (s1->tx_spin) { | |
574 | s1->tx_spin = 0; | |
575 | audio_stop_dma(s1); | |
576 | } | |
577 | } | |
578 | ||
579 | break; | |
580 | case SNDRV_PCM_TRIGGER_SUSPEND: | |
581 | s->active = 0; | |
582 | #ifdef HH_VERSION | |
583 | sa1100_dma_stop(s->dmach); | |
584 | #else | |
585 | //FIXME - DMA API | |
586 | #endif | |
587 | s->old_offset = audio_get_dma_pos(s) + 1; | |
588 | #ifdef HH_VERSION | |
589 | sa1100_dma_flush_all(s->dmach); | |
590 | #else | |
591 | //FIXME - DMA API | |
592 | #endif | |
593 | s->periods = 0; | |
594 | break; | |
595 | case SNDRV_PCM_TRIGGER_RESUME: | |
596 | s->active = 1; | |
597 | s->tx_spin = 0; | |
598 | audio_process_dma(s); | |
599 | if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) { | |
600 | s1->tx_spin = 1; | |
601 | audio_process_dma(s1); | |
602 | } | |
603 | break; | |
604 | case SNDRV_PCM_TRIGGER_PAUSE_PUSH: | |
605 | #ifdef HH_VERSION | |
606 | sa1100_dma_stop(s->dmach); | |
607 | #else | |
608 | //FIXME - DMA API | |
609 | #endif | |
610 | s->active = 0; | |
611 | if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) { | |
612 | if (s1->active) { | |
613 | s->tx_spin = 1; | |
614 | s->old_offset = audio_get_dma_pos(s) + 1; | |
615 | #ifdef HH_VERSION | |
616 | sa1100_dma_flush_all(s->dmach); | |
617 | #else | |
618 | //FIXME - DMA API | |
619 | #endif | |
620 | audio_process_dma(s); | |
621 | } | |
622 | } else { | |
623 | if (s1->tx_spin) { | |
624 | s1->tx_spin = 0; | |
625 | #ifdef HH_VERSION | |
626 | sa1100_dma_flush_all(s1->dmach); | |
627 | #else | |
628 | //FIXME - DMA API | |
629 | #endif | |
630 | } | |
631 | } | |
632 | break; | |
633 | case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: | |
634 | s->active = 1; | |
635 | if (s->old_offset) { | |
636 | s->tx_spin = 0; | |
637 | audio_process_dma(s); | |
638 | break; | |
639 | } | |
640 | if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) { | |
641 | s1->tx_spin = 1; | |
642 | audio_process_dma(s1); | |
643 | } | |
644 | #ifdef HH_VERSION | |
645 | sa1100_dma_resume(s->dmach); | |
646 | #else | |
647 | //FIXME - DMA API | |
648 | #endif | |
649 | break; | |
650 | default: | |
651 | err = -EINVAL; | |
652 | break; | |
653 | } | |
654 | spin_unlock(&s->dma_lock); | |
655 | return err; | |
656 | } | |
657 | ||
af0fbfb5 | 658 | static int snd_sa11xx_uda1341_prepare(struct snd_pcm_substream *substream) |
1da177e4 | 659 | { |
af0fbfb5 TI |
660 | struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); |
661 | struct snd_pcm_runtime *runtime = substream->runtime; | |
662 | struct audio_stream *s = &chip->s[substream->pstr->stream]; | |
1da177e4 LT |
663 | |
664 | /* set requested samplerate */ | |
665 | sa11xx_uda1341_set_samplerate(chip, runtime->rate); | |
666 | ||
667 | /* set requestd format when available */ | |
668 | /* set FMT here !!! FIXME */ | |
669 | ||
670 | s->period = 0; | |
671 | s->periods = 0; | |
672 | ||
673 | return 0; | |
674 | } | |
675 | ||
af0fbfb5 | 676 | static snd_pcm_uframes_t snd_sa11xx_uda1341_pointer(struct snd_pcm_substream *substream) |
1da177e4 | 677 | { |
af0fbfb5 | 678 | struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); |
1da177e4 LT |
679 | return audio_get_dma_pos(&chip->s[substream->pstr->stream]); |
680 | } | |
681 | ||
682 | /* }}} */ | |
683 | ||
af0fbfb5 | 684 | static struct snd_pcm_hardware snd_sa11xx_uda1341_capture = |
1da177e4 LT |
685 | { |
686 | .info = (SNDRV_PCM_INFO_INTERLEAVED | | |
687 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
688 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | | |
689 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME), | |
690 | .formats = SNDRV_PCM_FMTBIT_S16_LE, | |
691 | .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\ | |
692 | SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |\ | |
693 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ | |
694 | SNDRV_PCM_RATE_KNOT), | |
695 | .rate_min = 8000, | |
696 | .rate_max = 48000, | |
697 | .channels_min = 2, | |
698 | .channels_max = 2, | |
699 | .buffer_bytes_max = 64*1024, | |
700 | .period_bytes_min = 64, | |
701 | .period_bytes_max = DMA_BUF_SIZE, | |
702 | .periods_min = 2, | |
703 | .periods_max = 255, | |
704 | .fifo_size = 0, | |
705 | }; | |
706 | ||
af0fbfb5 | 707 | static struct snd_pcm_hardware snd_sa11xx_uda1341_playback = |
1da177e4 LT |
708 | { |
709 | .info = (SNDRV_PCM_INFO_INTERLEAVED | | |
710 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
711 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | | |
712 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME), | |
713 | .formats = SNDRV_PCM_FMTBIT_S16_LE, | |
714 | .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\ | |
715 | SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |\ | |
716 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ | |
717 | SNDRV_PCM_RATE_KNOT), | |
718 | .rate_min = 8000, | |
719 | .rate_max = 48000, | |
720 | .channels_min = 2, | |
721 | .channels_max = 2, | |
722 | .buffer_bytes_max = 64*1024, | |
723 | .period_bytes_min = 64, | |
724 | .period_bytes_max = DMA_BUF_SIZE, | |
725 | .periods_min = 2, | |
726 | .periods_max = 255, | |
727 | .fifo_size = 0, | |
728 | }; | |
729 | ||
af0fbfb5 | 730 | static int snd_card_sa11xx_uda1341_open(struct snd_pcm_substream *substream) |
1da177e4 | 731 | { |
af0fbfb5 TI |
732 | struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); |
733 | struct snd_pcm_runtime *runtime = substream->runtime; | |
1da177e4 LT |
734 | int stream_id = substream->pstr->stream; |
735 | int err; | |
736 | ||
737 | chip->s[stream_id].stream = substream; | |
738 | ||
739 | if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) | |
740 | runtime->hw = snd_sa11xx_uda1341_playback; | |
741 | else | |
742 | runtime->hw = snd_sa11xx_uda1341_capture; | |
743 | if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) | |
744 | return err; | |
745 | if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0) | |
746 | return err; | |
747 | ||
748 | return 0; | |
749 | } | |
750 | ||
af0fbfb5 | 751 | static int snd_card_sa11xx_uda1341_close(struct snd_pcm_substream *substream) |
1da177e4 | 752 | { |
af0fbfb5 | 753 | struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); |
1da177e4 LT |
754 | |
755 | chip->s[substream->pstr->stream].stream = NULL; | |
756 | return 0; | |
757 | } | |
758 | ||
759 | /* {{{ HW params & free */ | |
760 | ||
af0fbfb5 TI |
761 | static int snd_sa11xx_uda1341_hw_params(struct snd_pcm_substream *substream, |
762 | struct snd_pcm_hw_params *hw_params) | |
1da177e4 LT |
763 | { |
764 | ||
765 | return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); | |
766 | } | |
767 | ||
af0fbfb5 | 768 | static int snd_sa11xx_uda1341_hw_free(struct snd_pcm_substream *substream) |
1da177e4 LT |
769 | { |
770 | return snd_pcm_lib_free_pages(substream); | |
771 | } | |
772 | ||
773 | /* }}} */ | |
774 | ||
af0fbfb5 | 775 | static struct snd_pcm_ops snd_card_sa11xx_uda1341_playback_ops = { |
1da177e4 LT |
776 | .open = snd_card_sa11xx_uda1341_open, |
777 | .close = snd_card_sa11xx_uda1341_close, | |
778 | .ioctl = snd_pcm_lib_ioctl, | |
779 | .hw_params = snd_sa11xx_uda1341_hw_params, | |
780 | .hw_free = snd_sa11xx_uda1341_hw_free, | |
781 | .prepare = snd_sa11xx_uda1341_prepare, | |
782 | .trigger = snd_sa11xx_uda1341_trigger, | |
783 | .pointer = snd_sa11xx_uda1341_pointer, | |
784 | }; | |
785 | ||
af0fbfb5 | 786 | static struct snd_pcm_ops snd_card_sa11xx_uda1341_capture_ops = { |
1da177e4 LT |
787 | .open = snd_card_sa11xx_uda1341_open, |
788 | .close = snd_card_sa11xx_uda1341_close, | |
789 | .ioctl = snd_pcm_lib_ioctl, | |
790 | .hw_params = snd_sa11xx_uda1341_hw_params, | |
791 | .hw_free = snd_sa11xx_uda1341_hw_free, | |
792 | .prepare = snd_sa11xx_uda1341_prepare, | |
793 | .trigger = snd_sa11xx_uda1341_trigger, | |
794 | .pointer = snd_sa11xx_uda1341_pointer, | |
795 | }; | |
796 | ||
af0fbfb5 | 797 | static int __init snd_card_sa11xx_uda1341_pcm(struct sa11xx_uda1341 *sa11xx_uda1341, int device) |
1da177e4 | 798 | { |
af0fbfb5 | 799 | struct snd_pcm *pcm; |
1da177e4 LT |
800 | int err; |
801 | ||
802 | if ((err = snd_pcm_new(sa11xx_uda1341->card, "UDA1341 PCM", device, 1, 1, &pcm)) < 0) | |
803 | return err; | |
804 | ||
805 | /* | |
806 | * this sets up our initial buffers and sets the dma_type to isa. | |
807 | * isa works but I'm not sure why (or if) it's the right choice | |
808 | * this may be too large, trying it for now | |
809 | */ | |
0948e3c8 TI |
810 | snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, |
811 | snd_dma_isa_data(), | |
1da177e4 LT |
812 | 64*1024, 64*1024); |
813 | ||
814 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_sa11xx_uda1341_playback_ops); | |
815 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_sa11xx_uda1341_capture_ops); | |
816 | pcm->private_data = sa11xx_uda1341; | |
817 | pcm->info_flags = 0; | |
818 | strcpy(pcm->name, "UDA1341 PCM"); | |
819 | ||
820 | sa11xx_uda1341_audio_init(sa11xx_uda1341); | |
821 | ||
822 | /* setup DMA controller */ | |
823 | audio_dma_request(&sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK], audio_dma_callback); | |
824 | audio_dma_request(&sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE], audio_dma_callback); | |
825 | ||
826 | sa11xx_uda1341->pcm = pcm; | |
827 | ||
828 | return 0; | |
829 | } | |
830 | ||
831 | /* }}} */ | |
832 | ||
833 | /* {{{ module init & exit */ | |
834 | ||
835 | #ifdef CONFIG_PM | |
836 | ||
2b3f5587 TI |
837 | static int snd_sa11xx_uda1341_suspend(struct platform_device *devptr, |
838 | pm_message_t state) | |
1da177e4 | 839 | { |
2b3f5587 TI |
840 | struct snd_card *card = platform_get_drvdata(devptr); |
841 | struct sa11xx_uda1341 *chip = card->private_data; | |
1da177e4 | 842 | |
2b3f5587 | 843 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); |
1da177e4 | 844 | snd_pcm_suspend_all(chip->pcm); |
2b3f5587 | 845 | #ifdef HH_VERSION |
1da177e4 LT |
846 | sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_PLAYBACK].dmach); |
847 | sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_CAPTURE].dmach); | |
848 | #else | |
849 | //FIXME | |
850 | #endif | |
851 | l3_command(chip->uda1341, CMD_SUSPEND, NULL); | |
852 | sa11xx_uda1341_audio_shutdown(chip); | |
2b3f5587 | 853 | |
1da177e4 LT |
854 | return 0; |
855 | } | |
856 | ||
2b3f5587 | 857 | static int snd_sa11xx_uda1341_resume(struct platform_device *devptr) |
1da177e4 | 858 | { |
2b3f5587 TI |
859 | struct snd_card *card = platform_get_drvdata(devptr); |
860 | struct sa11xx_uda1341 *chip = card->private_data; | |
1da177e4 LT |
861 | |
862 | sa11xx_uda1341_audio_init(chip); | |
863 | l3_command(chip->uda1341, CMD_RESUME, NULL); | |
864 | #ifdef HH_VERSION | |
865 | sa1100_dma_wakeup(chip->s[SNDRV_PCM_STREAM_PLAYBACK].dmach); | |
866 | sa1100_dma_wakeup(chip->s[SNDRV_PCM_STREAM_CAPTURE].dmach); | |
867 | #else | |
868 | //FIXME | |
869 | #endif | |
2b3f5587 | 870 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); |
1da177e4 LT |
871 | return 0; |
872 | } | |
873 | #endif /* COMFIG_PM */ | |
874 | ||
af0fbfb5 | 875 | void snd_sa11xx_uda1341_free(struct snd_card *card) |
1da177e4 | 876 | { |
af0fbfb5 | 877 | struct sa11xx_uda1341 *chip = card->private_data; |
1da177e4 LT |
878 | |
879 | audio_dma_free(&chip->s[SNDRV_PCM_STREAM_PLAYBACK]); | |
880 | audio_dma_free(&chip->s[SNDRV_PCM_STREAM_CAPTURE]); | |
1da177e4 LT |
881 | } |
882 | ||
2b3f5587 | 883 | static int __init sa11xx_uda1341_probe(struct platform_device *devptr) |
1da177e4 LT |
884 | { |
885 | int err; | |
af0fbfb5 TI |
886 | struct snd_card *card; |
887 | struct sa11xx_uda1341 *chip; | |
1da177e4 | 888 | |
1da177e4 | 889 | /* register the soundcard */ |
af0fbfb5 | 890 | card = snd_card_new(-1, id, THIS_MODULE, sizeof(struct sa11xx_uda1341)); |
1da177e4 LT |
891 | if (card == NULL) |
892 | return -ENOMEM; | |
893 | ||
0948e3c8 | 894 | chip = card->private_data; |
1da177e4 LT |
895 | spin_lock_init(&chip->s[0].dma_lock); |
896 | spin_lock_init(&chip->s[1].dma_lock); | |
af0fbfb5 | 897 | |
2b3f5587 | 898 | card->private_free = snd_sa11xx_uda1341_free; |
0948e3c8 TI |
899 | chip->card = card; |
900 | chip->samplerate = AUDIO_RATE_DEFAULT; | |
1da177e4 LT |
901 | |
902 | // mixer | |
af0fbfb5 | 903 | if ((err = snd_chip_uda1341_mixer_new(card, &chip->uda1341))) |
1da177e4 LT |
904 | goto nodev; |
905 | ||
906 | // PCM | |
0948e3c8 | 907 | if ((err = snd_card_sa11xx_uda1341_pcm(chip, 0)) < 0) |
1da177e4 LT |
908 | goto nodev; |
909 | ||
1da177e4 LT |
910 | strcpy(card->driver, "UDA1341"); |
911 | strcpy(card->shortname, "H3600 UDA1341TS"); | |
912 | sprintf(card->longname, "Compaq iPAQ H3600 with Philips UDA1341TS"); | |
913 | ||
2b3f5587 | 914 | snd_card_set_dev(card, &devptr->dev); |
16dab54b | 915 | |
1da177e4 LT |
916 | if ((err = snd_card_register(card)) == 0) { |
917 | printk( KERN_INFO "iPAQ audio support initialized\n" ); | |
2b3f5587 | 918 | platform_set_drvdata(devptr, card); |
1da177e4 LT |
919 | return 0; |
920 | } | |
921 | ||
922 | nodev: | |
923 | snd_card_free(card); | |
924 | return err; | |
925 | } | |
926 | ||
2b3f5587 TI |
927 | static int __devexit sa11xx_uda1341_remove(struct platform_device *devptr) |
928 | { | |
929 | snd_card_free(platform_get_drvdata(devptr)); | |
930 | platform_set_drvdata(devptr, NULL); | |
931 | return 0; | |
932 | } | |
933 | ||
934 | #define SA11XX_UDA1341_DRIVER "sa11xx_uda1341" | |
935 | ||
936 | static struct platform_driver sa11xx_uda1341_driver = { | |
937 | .probe = sa11xx_uda1341_probe, | |
938 | .remove = __devexit_p(sa11xx_uda1341_remove), | |
939 | #ifdef CONFIG_PM | |
940 | .suspend = snd_sa11xx_uda1341_suspend, | |
941 | .resume = snd_sa11xx_uda1341_resume, | |
942 | #endif | |
943 | .driver = { | |
944 | .name = SA11XX_UDA1341_DRIVER, | |
945 | }, | |
946 | }; | |
947 | ||
948 | static int __init sa11xx_uda1341_init(void) | |
949 | { | |
950 | int err; | |
2b3f5587 TI |
951 | |
952 | if (!machine_is_h3xxx()) | |
953 | return -ENODEV; | |
954 | if ((err = platform_driver_register(&sa11xx_uda1341_driver)) < 0) | |
955 | return err; | |
956 | device = platform_device_register_simple(SA11XX_UDA1341_DRIVER, -1, NULL, 0); | |
7152447d RH |
957 | if (!IS_ERR(device)) { |
958 | if (platform_get_drvdata(device)) | |
959 | return 0; | |
960 | platform_device_unregister(device); | |
632155e6 | 961 | err = -ENODEV; |
7152447d RH |
962 | } else |
963 | err = PTR_ERR(device); | |
964 | platform_driver_unregister(&sa11xx_uda1341_driver); | |
965 | return err; | |
2b3f5587 TI |
966 | } |
967 | ||
1da177e4 LT |
968 | static void __exit sa11xx_uda1341_exit(void) |
969 | { | |
f7a9275d | 970 | platform_device_unregister(device); |
2b3f5587 | 971 | platform_driver_unregister(&sa11xx_uda1341_driver); |
1da177e4 LT |
972 | } |
973 | ||
974 | module_init(sa11xx_uda1341_init); | |
975 | module_exit(sa11xx_uda1341_exit); | |
976 | ||
977 | /* }}} */ | |
978 | ||
979 | /* | |
980 | * Local variables: | |
981 | * indent-tabs-mode: t | |
982 | * End: | |
983 | */ |