~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/drivers/pcsp/pcsp_lib.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * PC-Speaker driver for Linux
  4  *
  5  * Copyright (C) 1993-1997  Michael Beck
  6  * Copyright (C) 1997-2001  David Woodhouse
  7  * Copyright (C) 2001-2008  Stas Sergeev
  8  */
  9 
 10 #include <linux/module.h>
 11 #include <linux/gfp.h>
 12 #include <linux/moduleparam.h>
 13 #include <linux/interrupt.h>
 14 #include <linux/io.h>
 15 #include <sound/pcm.h>
 16 #include "pcsp.h"
 17 
 18 static bool nforce_wa;
 19 module_param(nforce_wa, bool, 0444);
 20 MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround "
 21                 "(expect bad sound)");
 22 
 23 #define DMIX_WANTS_S16  1
 24 
 25 /*
 26  * Call snd_pcm_period_elapsed in a tasklet
 27  * This avoids spinlock messes and long-running irq contexts
 28  */
 29 static void pcsp_call_pcm_elapsed(unsigned long priv)
 30 {
 31         if (atomic_read(&pcsp_chip.timer_active)) {
 32                 struct snd_pcm_substream *substream;
 33                 substream = pcsp_chip.playback_substream;
 34                 if (substream)
 35                         snd_pcm_period_elapsed(substream);
 36         }
 37 }
 38 
 39 static DECLARE_TASKLET(pcsp_pcm_tasklet, pcsp_call_pcm_elapsed, 0);
 40 
 41 /* write the port and returns the next expire time in ns;
 42  * called at the trigger-start and in hrtimer callback
 43  */
 44 static u64 pcsp_timer_update(struct snd_pcsp *chip)
 45 {
 46         unsigned char timer_cnt, val;
 47         u64 ns;
 48         struct snd_pcm_substream *substream;
 49         struct snd_pcm_runtime *runtime;
 50         unsigned long flags;
 51 
 52         if (chip->thalf) {
 53                 outb(chip->val61, 0x61);
 54                 chip->thalf = 0;
 55                 return chip->ns_rem;
 56         }
 57 
 58         substream = chip->playback_substream;
 59         if (!substream)
 60                 return 0;
 61 
 62         runtime = substream->runtime;
 63         /* assume it is mono! */
 64         val = runtime->dma_area[chip->playback_ptr + chip->fmt_size - 1];
 65         if (chip->is_signed)
 66                 val ^= 0x80;
 67         timer_cnt = val * CUR_DIV() / 256;
 68 
 69         if (timer_cnt && chip->enable) {
 70                 raw_spin_lock_irqsave(&i8253_lock, flags);
 71                 if (!nforce_wa) {
 72                         outb_p(chip->val61, 0x61);
 73                         outb_p(timer_cnt, 0x42);
 74                         outb(chip->val61 ^ 1, 0x61);
 75                 } else {
 76                         outb(chip->val61 ^ 2, 0x61);
 77                         chip->thalf = 1;
 78                 }
 79                 raw_spin_unlock_irqrestore(&i8253_lock, flags);
 80         }
 81 
 82         chip->ns_rem = PCSP_PERIOD_NS();
 83         ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem);
 84         chip->ns_rem -= ns;
 85         return ns;
 86 }
 87 
 88 static void pcsp_pointer_update(struct snd_pcsp *chip)
 89 {
 90         struct snd_pcm_substream *substream;
 91         size_t period_bytes, buffer_bytes;
 92         int periods_elapsed;
 93         unsigned long flags;
 94 
 95         /* update the playback position */
 96         substream = chip->playback_substream;
 97         if (!substream)
 98                 return;
 99 
100         period_bytes = snd_pcm_lib_period_bytes(substream);
101         buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
102 
103         spin_lock_irqsave(&chip->substream_lock, flags);
104         chip->playback_ptr += PCSP_INDEX_INC() * chip->fmt_size;
105         periods_elapsed = chip->playback_ptr - chip->period_ptr;
106         if (periods_elapsed < 0) {
107 #if PCSP_DEBUG
108                 printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? "
109                         "(%zi %zi %zi)\n",
110                         chip->playback_ptr, period_bytes, buffer_bytes);
111 #endif
112                 periods_elapsed += buffer_bytes;
113         }
114         periods_elapsed /= period_bytes;
115         /* wrap the pointer _before_ calling snd_pcm_period_elapsed(),
116          * or ALSA will BUG on us. */
117         chip->playback_ptr %= buffer_bytes;
118 
119         if (periods_elapsed) {
120                 chip->period_ptr += periods_elapsed * period_bytes;
121                 chip->period_ptr %= buffer_bytes;
122         }
123         spin_unlock_irqrestore(&chip->substream_lock, flags);
124 
125         if (periods_elapsed)
126                 tasklet_schedule(&pcsp_pcm_tasklet);
127 }
128 
129 enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle)
130 {
131         struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer);
132         int pointer_update;
133         u64 ns;
134 
135         if (!atomic_read(&chip->timer_active) || !chip->playback_substream)
136                 return HRTIMER_NORESTART;
137 
138         pointer_update = !chip->thalf;
139         ns = pcsp_timer_update(chip);
140         if (!ns) {
141                 printk(KERN_WARNING "PCSP: unexpected stop\n");
142                 return HRTIMER_NORESTART;
143         }
144 
145         if (pointer_update)
146                 pcsp_pointer_update(chip);
147 
148         hrtimer_forward(handle, hrtimer_get_expires(handle), ns_to_ktime(ns));
149 
150         return HRTIMER_RESTART;
151 }
152 
153 static int 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 -EIO;
161         }
162 
163         raw_spin_lock(&i8253_lock);
164         chip->val61 = inb(0x61) | 0x03;
165         outb_p(0x92, 0x43);     /* binary, mode 1, LSB only, ch 2 */
166         raw_spin_unlock(&i8253_lock);
167         atomic_set(&chip->timer_active, 1);
168         chip->thalf = 0;
169 
170         hrtimer_start(&pcsp_chip.timer, 0, HRTIMER_MODE_REL);
171         return 0;
172 }
173 
174 static void pcsp_stop_playing(struct snd_pcsp *chip)
175 {
176 #if PCSP_DEBUG
177         printk(KERN_INFO "PCSP: stop_playing called\n");
178 #endif
179         if (!atomic_read(&chip->timer_active))
180                 return;
181 
182         atomic_set(&chip->timer_active, 0);
183         raw_spin_lock(&i8253_lock);
184         /* restore the timer */
185         outb_p(0xb6, 0x43);     /* binary, mode 3, LSB/MSB, ch 2 */
186         outb(chip->val61 & 0xFC, 0x61);
187         raw_spin_unlock(&i8253_lock);
188 }
189 
190 /*
191  * Force to stop and sync the stream
192  */
193 void pcsp_sync_stop(struct snd_pcsp *chip)
194 {
195         local_irq_disable();
196         pcsp_stop_playing(chip);
197         local_irq_enable();
198         hrtimer_cancel(&chip->timer);
199         tasklet_kill(&pcsp_pcm_tasklet);
200 }
201 
202 static int snd_pcsp_playback_close(struct snd_pcm_substream *substream)
203 {
204         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
205 #if PCSP_DEBUG
206         printk(KERN_INFO "PCSP: close called\n");
207 #endif
208         pcsp_sync_stop(chip);
209         chip->playback_substream = NULL;
210         return 0;
211 }
212 
213 static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream,
214                                        struct snd_pcm_hw_params *hw_params)
215 {
216         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
217         int err;
218         pcsp_sync_stop(chip);
219         err = snd_pcm_lib_malloc_pages(substream,
220                                       params_buffer_bytes(hw_params));
221         if (err < 0)
222                 return err;
223         return 0;
224 }
225 
226 static int snd_pcsp_playback_hw_free(struct snd_pcm_substream *substream)
227 {
228         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
229 #if PCSP_DEBUG
230         printk(KERN_INFO "PCSP: hw_free called\n");
231 #endif
232         pcsp_sync_stop(chip);
233         return snd_pcm_lib_free_pages(substream);
234 }
235 
236 static int snd_pcsp_playback_prepare(struct snd_pcm_substream *substream)
237 {
238         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
239         pcsp_sync_stop(chip);
240         chip->playback_ptr = 0;
241         chip->period_ptr = 0;
242         chip->fmt_size =
243                 snd_pcm_format_physical_width(substream->runtime->format) >> 3;
244         chip->is_signed = snd_pcm_format_signed(substream->runtime->format);
245 #if PCSP_DEBUG
246         printk(KERN_INFO "PCSP: prepare called, "
247                         "size=%zi psize=%zi f=%zi f1=%i fsize=%i\n",
248                         snd_pcm_lib_buffer_bytes(substream),
249                         snd_pcm_lib_period_bytes(substream),
250                         snd_pcm_lib_buffer_bytes(substream) /
251                         snd_pcm_lib_period_bytes(substream),
252                         substream->runtime->periods,
253                         chip->fmt_size);
254 #endif
255         return 0;
256 }
257 
258 static int snd_pcsp_trigger(struct snd_pcm_substream *substream, int cmd)
259 {
260         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
261 #if PCSP_DEBUG
262         printk(KERN_INFO "PCSP: trigger called\n");
263 #endif
264         switch (cmd) {
265         case SNDRV_PCM_TRIGGER_START:
266         case SNDRV_PCM_TRIGGER_RESUME:
267                 return pcsp_start_playing(chip);
268         case SNDRV_PCM_TRIGGER_STOP:
269         case SNDRV_PCM_TRIGGER_SUSPEND:
270                 pcsp_stop_playing(chip);
271                 break;
272         default:
273                 return -EINVAL;
274         }
275         return 0;
276 }
277 
278 static snd_pcm_uframes_t snd_pcsp_playback_pointer(struct snd_pcm_substream
279                                                    *substream)
280 {
281         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
282         unsigned int pos;
283         spin_lock(&chip->substream_lock);
284         pos = chip->playback_ptr;
285         spin_unlock(&chip->substream_lock);
286         return bytes_to_frames(substream->runtime, pos);
287 }
288 
289 static const struct snd_pcm_hardware snd_pcsp_playback = {
290         .info = (SNDRV_PCM_INFO_INTERLEAVED |
291                  SNDRV_PCM_INFO_HALF_DUPLEX |
292                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID),
293         .formats = (SNDRV_PCM_FMTBIT_U8
294 #if DMIX_WANTS_S16
295                     | SNDRV_PCM_FMTBIT_S16_LE
296 #endif
297             ),
298         .rates = SNDRV_PCM_RATE_KNOT,
299         .rate_min = PCSP_DEFAULT_SRATE,
300         .rate_max = PCSP_DEFAULT_SRATE,
301         .channels_min = 1,
302         .channels_max = 1,
303         .buffer_bytes_max = PCSP_BUFFER_SIZE,
304         .period_bytes_min = 64,
305         .period_bytes_max = PCSP_MAX_PERIOD_SIZE,
306         .periods_min = 2,
307         .periods_max = PCSP_MAX_PERIODS,
308         .fifo_size = 0,
309 };
310 
311 static int snd_pcsp_playback_open(struct snd_pcm_substream *substream)
312 {
313         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
314         struct snd_pcm_runtime *runtime = substream->runtime;
315 #if PCSP_DEBUG
316         printk(KERN_INFO "PCSP: open called\n");
317 #endif
318         if (atomic_read(&chip->timer_active)) {
319                 printk(KERN_ERR "PCSP: still active!!\n");
320                 return -EBUSY;
321         }
322         runtime->hw = snd_pcsp_playback;
323         chip->playback_substream = substream;
324         return 0;
325 }
326 
327 static const struct snd_pcm_ops snd_pcsp_playback_ops = {
328         .open = snd_pcsp_playback_open,
329         .close = snd_pcsp_playback_close,
330         .ioctl = snd_pcm_lib_ioctl,
331         .hw_params = snd_pcsp_playback_hw_params,
332         .hw_free = snd_pcsp_playback_hw_free,
333         .prepare = snd_pcsp_playback_prepare,
334         .trigger = snd_pcsp_trigger,
335         .pointer = snd_pcsp_playback_pointer,
336 };
337 
338 int snd_pcsp_new_pcm(struct snd_pcsp *chip)
339 {
340         int err;
341 
342         err = snd_pcm_new(chip->card, "pcspeaker", 0, 1, 0, &chip->pcm);
343         if (err < 0)
344                 return err;
345 
346         snd_pcm_set_ops(chip->pcm, SNDRV_PCM_STREAM_PLAYBACK,
347                         &snd_pcsp_playback_ops);
348 
349         chip->pcm->private_data = chip;
350         chip->pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
351         strcpy(chip->pcm->name, "pcsp");
352 
353         snd_pcm_lib_preallocate_pages_for_all(chip->pcm,
354                                               SNDRV_DMA_TYPE_CONTINUOUS,
355                                               snd_dma_continuous_data
356                                               (GFP_KERNEL), PCSP_BUFFER_SIZE,
357                                               PCSP_BUFFER_SIZE);
358 
359         return 0;
360 }
361 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp