[ALSA] pcsp: remove downsampling
[linux-2.6.git] / sound / drivers / pcsp / pcsp_lib.c
1 /*
2  * PC-Speaker driver for Linux
3  *
4  * Copyright (C) 1993-1997  Michael Beck
5  * Copyright (C) 1997-2001  David Woodhouse
6  * Copyright (C) 2001-2008  Stas Sergeev
7  */
8
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <sound/pcm.h>
12 #include <linux/interrupt.h>
13 #include <asm/io.h>
14 #include "pcsp.h"
15
16 static int nforce_wa;
17 module_param(nforce_wa, bool, 0444);
18 MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround "
19                 "(expect bad sound)");
20
21 static void pcsp_start_timer(unsigned long dummy)
22 {
23         hrtimer_start(&pcsp_chip.timer, ktime_set(0, 0), HRTIMER_MODE_REL);
24 }
25
26 /*
27  * We need the hrtimer_start as a tasklet to avoid
28  * the nasty locking problem. :(
29  * The problem:
30  * - The timer handler is called with the cpu_base->lock
31  *   already held by hrtimer code.
32  * - snd_pcm_period_elapsed() takes the
33  *   substream->self_group.lock.
34  * So far so good.
35  * But the snd_pcsp_trigger() is called with the
36  * substream->self_group.lock held, and it calls
37  * hrtimer_start(), which takes the cpu_base->lock.
38  * You see the problem. We have the code pathes
39  * which take two locks in a reverse order. This
40  * can deadlock and the lock validator complains.
41  * The only solution I could find was to move the
42  * hrtimer_start() into a tasklet. -stsp
43  */
44 static DECLARE_TASKLET(pcsp_start_timer_tasklet, pcsp_start_timer, 0);
45
46 enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle)
47 {
48         unsigned long flags;
49         unsigned char timer_cnt, val;
50         int periods_elapsed;
51         u64 ns;
52         size_t period_bytes, buffer_bytes;
53         struct snd_pcm_substream *substream;
54         struct snd_pcm_runtime *runtime;
55         struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer);
56
57         if (chip->thalf) {
58                 outb(chip->val61, 0x61);
59                 chip->thalf = 0;
60                 if (!atomic_read(&chip->timer_active))
61                         return HRTIMER_NORESTART;
62                 hrtimer_forward(&chip->timer, chip->timer.expires,
63                                 ktime_set(0, chip->ns_rem));
64                 return HRTIMER_RESTART;
65         }
66
67         /* hrtimer calls us from both hardirq and softirq contexts,
68          * so irqsave :( */
69         spin_lock_irqsave(&chip->substream_lock, flags);
70         /* Takashi Iwai says regarding this extra lock:
71
72         If the irq handler handles some data on the DMA buffer, it should
73         do snd_pcm_stream_lock().
74         That protects basically against all races among PCM callbacks, yes.
75         However, there are two remaining issues:
76         1. The substream pointer you try to lock isn't protected _before_
77           this lock yet.
78         2. snd_pcm_period_elapsed() itself acquires the lock.
79         The requirement of another lock is because of 1.  When you get
80         chip->playback_substream, it's not protected.
81         Keeping this lock while snd_pcm_period_elapsed() assures the substream
82         is still protected (at least, not released).  And the other status is
83         handled properly inside snd_pcm_stream_lock() in
84         snd_pcm_period_elapsed().
85
86         */
87         if (!chip->playback_substream)
88                 goto exit_nr_unlock1;
89         substream = chip->playback_substream;
90         snd_pcm_stream_lock(substream);
91         if (!atomic_read(&chip->timer_active))
92                 goto exit_nr_unlock2;
93
94         runtime = substream->runtime;
95         /* assume it is u8 mono */
96         val = runtime->dma_area[chip->playback_ptr];
97         timer_cnt = val * CUR_DIV() / 256;
98
99         if (timer_cnt && chip->enable) {
100                 spin_lock(&i8253_lock);
101                 if (!nforce_wa) {
102                         outb_p(chip->val61, 0x61);
103                         outb_p(timer_cnt, 0x42);
104                         outb(chip->val61 ^ 1, 0x61);
105                 } else {
106                         outb(chip->val61 ^ 2, 0x61);
107                         chip->thalf = 1;
108                 }
109                 spin_unlock(&i8253_lock);
110         }
111
112         period_bytes = snd_pcm_lib_period_bytes(substream);
113         buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
114         chip->playback_ptr += PCSP_INDEX_INC();
115         periods_elapsed = chip->playback_ptr - chip->period_ptr;
116         if (periods_elapsed < 0) {
117                 printk(KERN_WARNING "PCSP: playback_ptr inconsistent "
118                         "(%zi %zi %zi)\n",
119                         chip->playback_ptr, period_bytes, buffer_bytes);
120                 periods_elapsed += buffer_bytes;
121         }
122         periods_elapsed /= period_bytes;
123         /* wrap the pointer _before_ calling snd_pcm_period_elapsed(),
124          * or ALSA will BUG on us. */
125         chip->playback_ptr %= buffer_bytes;
126
127         snd_pcm_stream_unlock(substream);
128
129         if (periods_elapsed) {
130                 snd_pcm_period_elapsed(substream);
131                 chip->period_ptr += periods_elapsed * period_bytes;
132                 chip->period_ptr %= buffer_bytes;
133         }
134
135         spin_unlock_irqrestore(&chip->substream_lock, flags);
136
137         if (!atomic_read(&chip->timer_active))
138                 return HRTIMER_NORESTART;
139
140         chip->ns_rem = PCSP_PERIOD_NS();
141         ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem);
142         chip->ns_rem -= ns;
143         hrtimer_forward(&chip->timer, chip->timer.expires, ktime_set(0, ns));
144         return HRTIMER_RESTART;
145
146 exit_nr_unlock2:
147         snd_pcm_stream_unlock(substream);
148 exit_nr_unlock1:
149         spin_unlock_irqrestore(&chip->substream_lock, flags);
150         return HRTIMER_NORESTART;
151 }
152
153 static void pcsp_start_playing(struct snd_pcsp *chip)
154 {
155 #if PCSP_DEBUG
156         printk(KERN_INFO "PCSP: start_playing called\n");
157 #endif
158         if (atomic_read(&chip->timer_active)) {
159                 printk(KERN_ERR "PCSP: Timer already active\n");
160                 return;
161         }
162
163         spin_lock(&i8253_lock);
164         chip->val61 = inb(0x61) | 0x03;
165         outb_p(0x92, 0x43);     /* binary, mode 1, LSB only, ch 2 */
166         spin_unlock(&i8253_lock);
167         atomic_set(&chip->timer_active, 1);
168         chip->thalf = 0;
169
170         tasklet_schedule(&pcsp_start_timer_tasklet);
171 }
172
173 static void pcsp_stop_playing(struct snd_pcsp *chip)
174 {
175 #if PCSP_DEBUG
176         printk(KERN_INFO "PCSP: stop_playing called\n");
177 #endif
178         if (!atomic_read(&chip->timer_active))
179                 return;
180
181         atomic_set(&chip->timer_active, 0);
182         spin_lock(&i8253_lock);
183         /* restore the timer */
184         outb_p(0xb6, 0x43);     /* binary, mode 3, LSB/MSB, ch 2 */
185         outb(chip->val61 & 0xFC, 0x61);
186         spin_unlock(&i8253_lock);
187 }
188
189 static int snd_pcsp_playback_close(struct snd_pcm_substream *substream)
190 {
191         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
192 #if PCSP_DEBUG
193         printk(KERN_INFO "PCSP: close called\n");
194 #endif
195         if (atomic_read(&chip->timer_active)) {
196                 printk(KERN_ERR "PCSP: timer still active\n");
197                 pcsp_stop_playing(chip);
198         }
199         spin_lock_irq(&chip->substream_lock);
200         chip->playback_substream = NULL;
201         spin_unlock_irq(&chip->substream_lock);
202         return 0;
203 }
204
205 static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream,
206                                        struct snd_pcm_hw_params *hw_params)
207 {
208         int err;
209         err = snd_pcm_lib_malloc_pages(substream,
210                                       params_buffer_bytes(hw_params));
211         if (err < 0)
212                 return err;
213         return 0;
214 }
215
216 static int snd_pcsp_playback_hw_free(struct snd_pcm_substream *substream)
217 {
218 #if PCSP_DEBUG
219         printk(KERN_INFO "PCSP: hw_free called\n");
220 #endif
221         return snd_pcm_lib_free_pages(substream);
222 }
223
224 static int snd_pcsp_playback_prepare(struct snd_pcm_substream *substream)
225 {
226         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
227 #if PCSP_DEBUG
228         printk(KERN_INFO "PCSP: prepare called, "
229                         "size=%zi psize=%zi f=%zi f1=%i\n",
230                         snd_pcm_lib_buffer_bytes(substream),
231                         snd_pcm_lib_period_bytes(substream),
232                         snd_pcm_lib_buffer_bytes(substream) /
233                         snd_pcm_lib_period_bytes(substream),
234                         substream->runtime->periods);
235 #endif
236         chip->playback_ptr = 0;
237         chip->period_ptr = 0;
238         return 0;
239 }
240
241 static int snd_pcsp_trigger(struct snd_pcm_substream *substream, int cmd)
242 {
243         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
244 #if PCSP_DEBUG
245         printk(KERN_INFO "PCSP: trigger called\n");
246 #endif
247         switch (cmd) {
248         case SNDRV_PCM_TRIGGER_START:
249         case SNDRV_PCM_TRIGGER_RESUME:
250                 pcsp_start_playing(chip);
251                 break;
252         case SNDRV_PCM_TRIGGER_STOP:
253         case SNDRV_PCM_TRIGGER_SUSPEND:
254                 pcsp_stop_playing(chip);
255                 break;
256         default:
257                 return -EINVAL;
258         }
259         return 0;
260 }
261
262 static snd_pcm_uframes_t snd_pcsp_playback_pointer(struct snd_pcm_substream
263                                                    *substream)
264 {
265         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
266         return bytes_to_frames(substream->runtime, chip->playback_ptr);
267 }
268
269 static struct snd_pcm_hardware snd_pcsp_playback = {
270         .info = (SNDRV_PCM_INFO_INTERLEAVED |
271                  SNDRV_PCM_INFO_HALF_DUPLEX |
272                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID),
273         .formats = SNDRV_PCM_FMTBIT_U8,
274         .rates = SNDRV_PCM_RATE_KNOT,
275         .rate_min = PCSP_DEFAULT_SRATE,
276         .rate_max = PCSP_DEFAULT_SRATE,
277         .channels_min = 1,
278         .channels_max = 1,
279         .buffer_bytes_max = PCSP_BUFFER_SIZE,
280         .period_bytes_min = 64,
281         .period_bytes_max = PCSP_MAX_PERIOD_SIZE,
282         .periods_min = 2,
283         .periods_max = PCSP_MAX_PERIODS,
284         .fifo_size = 0,
285 };
286
287 static int snd_pcsp_playback_open(struct snd_pcm_substream *substream)
288 {
289         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
290         struct snd_pcm_runtime *runtime = substream->runtime;
291 #if PCSP_DEBUG
292         printk(KERN_INFO "PCSP: open called\n");
293 #endif
294         if (atomic_read(&chip->timer_active)) {
295                 printk(KERN_ERR "PCSP: still active!!\n");
296                 return -EBUSY;
297         }
298         runtime->hw = snd_pcsp_playback;
299         spin_lock_irq(&chip->substream_lock);
300         chip->playback_substream = substream;
301         spin_unlock_irq(&chip->substream_lock);
302         return 0;
303 }
304
305 static struct snd_pcm_ops snd_pcsp_playback_ops = {
306         .open = snd_pcsp_playback_open,
307         .close = snd_pcsp_playback_close,
308         .ioctl = snd_pcm_lib_ioctl,
309         .hw_params = snd_pcsp_playback_hw_params,
310         .hw_free = snd_pcsp_playback_hw_free,
311         .prepare = snd_pcsp_playback_prepare,
312         .trigger = snd_pcsp_trigger,
313         .pointer = snd_pcsp_playback_pointer,
314 };
315
316 int __devinit snd_pcsp_new_pcm(struct snd_pcsp *chip)
317 {
318         int err;
319
320         err = snd_pcm_new(chip->card, "pcspeaker", 0, 1, 0, &chip->pcm);
321         if (err < 0)
322                 return err;
323
324         snd_pcm_set_ops(chip->pcm, SNDRV_PCM_STREAM_PLAYBACK,
325                         &snd_pcsp_playback_ops);
326
327         chip->pcm->private_data = chip;
328         chip->pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
329         strcpy(chip->pcm->name, "pcsp");
330
331         snd_pcm_lib_preallocate_pages_for_all(chip->pcm,
332                                               SNDRV_DMA_TYPE_CONTINUOUS,
333                                               snd_dma_continuous_data
334                                               (GFP_KERNEL), PCSP_BUFFER_SIZE,
335                                               PCSP_BUFFER_SIZE);
336
337         return 0;
338 }