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