2 * sh_dac_audio.c - SuperH DAC audio driver for ALSA
4 * Copyright (c) 2009 by Rafael Ignacio Zurita <rizurita@yahoo.com>
7 * Based on sh_dac_audio.c (Copyright (C) 2004, 2005 by Andriy Skulysh)
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/hrtimer.h>
26 #include <linux/interrupt.h>
28 #include <linux/platform_device.h>
29 #include <sound/core.h>
30 #include <sound/initval.h>
31 #include <sound/pcm.h>
32 #include <sound/sh_dac_audio.h>
33 #include <asm/clock.h>
34 #include <asm/hd64461.h>
35 #include <mach/hp6xx.h>
38 MODULE_AUTHOR("Rafael Ignacio Zurita <rizurita@yahoo.com>");
39 MODULE_DESCRIPTION("SuperH DAC audio driver");
40 MODULE_LICENSE("GPL");
41 MODULE_SUPPORTED_DEVICE("{{SuperH DAC audio support}}");
43 /* Module Parameters */
44 static int index
= SNDRV_DEFAULT_IDX1
;
45 static char *id
= SNDRV_DEFAULT_STR1
;
46 module_param(index
, int, 0444);
47 MODULE_PARM_DESC(index
, "Index value for SuperH DAC audio.");
48 module_param(id
, charp
, 0444);
49 MODULE_PARM_DESC(id
, "ID string for SuperH DAC audio.");
53 struct snd_card
*card
;
54 struct snd_pcm_substream
*substream
;
55 struct hrtimer hrtimer
;
56 ktime_t wakeups_per_second
;
60 char *data_buffer
, *buffer_begin
, *buffer_end
;
61 int processed
; /* bytes proccesed, to compare with period_size */
63 struct dac_audio_pdata
*pdata
;
67 static void dac_audio_start_timer(struct snd_sh_dac
*chip
)
69 hrtimer_start(&chip
->hrtimer
, chip
->wakeups_per_second
,
73 static void dac_audio_stop_timer(struct snd_sh_dac
*chip
)
75 hrtimer_cancel(&chip
->hrtimer
);
78 static void dac_audio_reset(struct snd_sh_dac
*chip
)
80 dac_audio_stop_timer(chip
);
81 chip
->buffer_begin
= chip
->buffer_end
= chip
->data_buffer
;
86 static void dac_audio_set_rate(struct snd_sh_dac
*chip
)
88 chip
->wakeups_per_second
= ktime_set(0, 1000000000 / chip
->rate
);
94 static struct snd_pcm_hardware snd_sh_dac_pcm_hw
= {
95 .info
= (SNDRV_PCM_INFO_MMAP
|
96 SNDRV_PCM_INFO_MMAP_VALID
|
97 SNDRV_PCM_INFO_INTERLEAVED
|
98 SNDRV_PCM_INFO_HALF_DUPLEX
),
99 .formats
= SNDRV_PCM_FMTBIT_U8
,
100 .rates
= SNDRV_PCM_RATE_8000
,
105 .buffer_bytes_max
= (48*1024),
106 .period_bytes_min
= 1,
107 .period_bytes_max
= (48*1024),
112 static int snd_sh_dac_pcm_open(struct snd_pcm_substream
*substream
)
114 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
115 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
117 runtime
->hw
= snd_sh_dac_pcm_hw
;
119 chip
->substream
= substream
;
120 chip
->buffer_begin
= chip
->buffer_end
= chip
->data_buffer
;
124 chip
->pdata
->start(chip
->pdata
);
129 static int snd_sh_dac_pcm_close(struct snd_pcm_substream
*substream
)
131 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
133 chip
->substream
= NULL
;
135 dac_audio_stop_timer(chip
);
136 chip
->pdata
->stop(chip
->pdata
);
141 static int snd_sh_dac_pcm_hw_params(struct snd_pcm_substream
*substream
,
142 struct snd_pcm_hw_params
*hw_params
)
144 return snd_pcm_lib_malloc_pages(substream
,
145 params_buffer_bytes(hw_params
));
148 static int snd_sh_dac_pcm_hw_free(struct snd_pcm_substream
*substream
)
150 return snd_pcm_lib_free_pages(substream
);
153 static int snd_sh_dac_pcm_prepare(struct snd_pcm_substream
*substream
)
155 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
156 struct snd_pcm_runtime
*runtime
= chip
->substream
->runtime
;
158 chip
->buffer_size
= runtime
->buffer_size
;
159 memset(chip
->data_buffer
, 0, chip
->pdata
->buffer_size
);
164 static int snd_sh_dac_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
166 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
169 case SNDRV_PCM_TRIGGER_START
:
170 dac_audio_start_timer(chip
);
172 case SNDRV_PCM_TRIGGER_STOP
:
173 chip
->buffer_begin
= chip
->buffer_end
= chip
->data_buffer
;
176 dac_audio_stop_timer(chip
);
185 static int snd_sh_dac_pcm_copy(struct snd_pcm_substream
*substream
, int channel
,
186 snd_pcm_uframes_t pos
, void __user
*src
, snd_pcm_uframes_t count
)
188 /* channel is not used (interleaved data) */
189 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
190 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
191 ssize_t b_count
= frames_to_bytes(runtime
, count
);
192 ssize_t b_pos
= frames_to_bytes(runtime
, pos
);
200 memcpy_toio(chip
->data_buffer
+ b_pos
, src
, b_count
);
201 chip
->buffer_end
= chip
->data_buffer
+ b_pos
+ b_count
;
205 dac_audio_start_timer(chip
);
211 static int snd_sh_dac_pcm_silence(struct snd_pcm_substream
*substream
,
212 int channel
, snd_pcm_uframes_t pos
,
213 snd_pcm_uframes_t count
)
215 /* channel is not used (interleaved data) */
216 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
217 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
218 ssize_t b_count
= frames_to_bytes(runtime
, count
);
219 ssize_t b_pos
= frames_to_bytes(runtime
, pos
);
227 memset_io(chip
->data_buffer
+ b_pos
, 0, b_count
);
228 chip
->buffer_end
= chip
->data_buffer
+ b_pos
+ b_count
;
232 dac_audio_start_timer(chip
);
239 snd_pcm_uframes_t
snd_sh_dac_pcm_pointer(struct snd_pcm_substream
*substream
)
241 struct snd_sh_dac
*chip
= snd_pcm_substream_chip(substream
);
242 int pointer
= chip
->buffer_begin
- chip
->data_buffer
;
248 static struct snd_pcm_ops snd_sh_dac_pcm_ops
= {
249 .open
= snd_sh_dac_pcm_open
,
250 .close
= snd_sh_dac_pcm_close
,
251 .ioctl
= snd_pcm_lib_ioctl
,
252 .hw_params
= snd_sh_dac_pcm_hw_params
,
253 .hw_free
= snd_sh_dac_pcm_hw_free
,
254 .prepare
= snd_sh_dac_pcm_prepare
,
255 .trigger
= snd_sh_dac_pcm_trigger
,
256 .pointer
= snd_sh_dac_pcm_pointer
,
257 .copy
= snd_sh_dac_pcm_copy
,
258 .silence
= snd_sh_dac_pcm_silence
,
259 .mmap
= snd_pcm_lib_mmap_iomem
,
262 static int __devinit
snd_sh_dac_pcm(struct snd_sh_dac
*chip
, int device
)
267 /* device should be always 0 for us */
268 err
= snd_pcm_new(chip
->card
, "SH_DAC PCM", device
, 1, 0, &pcm
);
272 pcm
->private_data
= chip
;
273 strcpy(pcm
->name
, "SH_DAC PCM");
274 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_sh_dac_pcm_ops
);
276 /* buffer size=48K */
277 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
278 snd_dma_continuous_data(GFP_KERNEL
),
284 /* END OF PCM INTERFACE */
287 /* driver .remove -- destructor */
288 static int snd_sh_dac_remove(struct platform_device
*devptr
)
290 snd_card_free(platform_get_drvdata(devptr
));
291 platform_set_drvdata(devptr
, NULL
);
296 /* free -- it has been defined by create */
297 static int snd_sh_dac_free(struct snd_sh_dac
*chip
)
299 /* release the data */
300 kfree(chip
->data_buffer
);
306 static int snd_sh_dac_dev_free(struct snd_device
*device
)
308 struct snd_sh_dac
*chip
= device
->device_data
;
310 return snd_sh_dac_free(chip
);
313 static enum hrtimer_restart
sh_dac_audio_timer(struct hrtimer
*handle
)
315 struct snd_sh_dac
*chip
= container_of(handle
, struct snd_sh_dac
,
317 struct snd_pcm_runtime
*runtime
= chip
->substream
->runtime
;
318 ssize_t b_ps
= frames_to_bytes(runtime
, runtime
->period_size
);
321 sh_dac_output(*chip
->buffer_begin
, chip
->pdata
->channel
);
322 chip
->buffer_begin
++;
325 if (chip
->processed
>= b_ps
) {
326 chip
->processed
-= b_ps
;
327 snd_pcm_period_elapsed(chip
->substream
);
330 if (chip
->buffer_begin
== (chip
->data_buffer
+
331 chip
->buffer_size
- 1))
332 chip
->buffer_begin
= chip
->data_buffer
;
334 if (chip
->buffer_begin
== chip
->buffer_end
)
340 hrtimer_start(&chip
->hrtimer
, chip
->wakeups_per_second
,
343 return HRTIMER_NORESTART
;
346 /* create -- chip-specific constructor for the cards components */
347 static int __devinit
snd_sh_dac_create(struct snd_card
*card
,
348 struct platform_device
*devptr
,
349 struct snd_sh_dac
**rchip
)
351 struct snd_sh_dac
*chip
;
354 static struct snd_device_ops ops
= {
355 .dev_free
= snd_sh_dac_dev_free
,
360 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
366 hrtimer_init(&chip
->hrtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
367 chip
->hrtimer
.function
= sh_dac_audio_timer
;
369 dac_audio_reset(chip
);
371 dac_audio_set_rate(chip
);
373 chip
->pdata
= devptr
->dev
.platform_data
;
375 chip
->data_buffer
= kmalloc(chip
->pdata
->buffer_size
, GFP_KERNEL
);
376 if (chip
->data_buffer
== NULL
) {
381 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
383 snd_sh_dac_free(chip
);
392 /* driver .probe -- constructor */
393 static int __devinit
snd_sh_dac_probe(struct platform_device
*devptr
)
395 struct snd_sh_dac
*chip
;
396 struct snd_card
*card
;
399 err
= snd_card_create(index
, id
, THIS_MODULE
, 0, &card
);
401 snd_printk(KERN_ERR
"cannot allocate the card\n");
405 err
= snd_sh_dac_create(card
, devptr
, &chip
);
409 err
= snd_sh_dac_pcm(chip
, 0);
413 strcpy(card
->driver
, "snd_sh_dac");
414 strcpy(card
->shortname
, "SuperH DAC audio driver");
415 printk(KERN_INFO
"%s %s", card
->longname
, card
->shortname
);
417 err
= snd_card_register(card
);
421 snd_printk("ALSA driver for SuperH DAC audio");
423 platform_set_drvdata(devptr
, card
);
432 * "driver" definition
434 static struct platform_driver driver
= {
435 .probe
= snd_sh_dac_probe
,
436 .remove
= snd_sh_dac_remove
,
442 static int __init
sh_dac_init(void)
444 return platform_driver_register(&driver
);
447 static void __exit
sh_dac_exit(void)
449 platform_driver_unregister(&driver
);
452 module_init(sh_dac_init
);
453 module_exit(sh_dac_exit
);