]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
9ab4d072 SS |
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> | |
5a0e3ad6 | 11 | #include <linux/gfp.h> |
9ab4d072 | 12 | #include <linux/moduleparam.h> |
96c7d478 | 13 | #include <linux/interrupt.h> |
6cbbfe1c | 14 | #include <linux/io.h> |
9ab4d072 | 15 | #include <sound/pcm.h> |
9ab4d072 SS |
16 | #include "pcsp.h" |
17 | ||
a67ff6a5 | 18 | static bool nforce_wa; |
9ab4d072 SS |
19 | module_param(nforce_wa, bool, 0444); |
20 | MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround " | |
21 | "(expect bad sound)"); | |
22 | ||
4dfd7954 SS |
23 | #define DMIX_WANTS_S16 1 |
24 | ||
96c7d478 TI |
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 | ||
eea0579f TI |
41 | /* write the port and returns the next expire time in ns; |
42 | * called at the trigger-start and in hrtimer callback | |
43 | */ | |
b71207e9 | 44 | static u64 pcsp_timer_update(struct snd_pcsp *chip) |
9ab4d072 | 45 | { |
9ab4d072 | 46 | unsigned char timer_cnt, val; |
9ab4d072 | 47 | u64 ns; |
9ab4d072 SS |
48 | struct snd_pcm_substream *substream; |
49 | struct snd_pcm_runtime *runtime; | |
96c7d478 | 50 | unsigned long flags; |
9ab4d072 SS |
51 | |
52 | if (chip->thalf) { | |
53 | outb(chip->val61, 0x61); | |
54 | chip->thalf = 0; | |
eea0579f | 55 | return chip->ns_rem; |
9ab4d072 SS |
56 | } |
57 | ||
96c7d478 TI |
58 | substream = chip->playback_substream; |
59 | if (!substream) | |
eea0579f | 60 | return 0; |
9ab4d072 SS |
61 | |
62 | runtime = substream->runtime; | |
4dfd7954 | 63 | /* assume it is mono! */ |
eea0579f TI |
64 | val = runtime->dma_area[chip->playback_ptr + chip->fmt_size - 1]; |
65 | if (chip->is_signed) | |
4dfd7954 | 66 | val ^= 0x80; |
9ab4d072 SS |
67 | timer_cnt = val * CUR_DIV() / 256; |
68 | ||
69 | if (timer_cnt && chip->enable) { | |
ced918eb | 70 | raw_spin_lock_irqsave(&i8253_lock, flags); |
9ab4d072 SS |
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 | } | |
ced918eb | 79 | raw_spin_unlock_irqrestore(&i8253_lock, flags); |
9ab4d072 SS |
80 | } |
81 | ||
eea0579f TI |
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 | ||
b71207e9 | 88 | static void pcsp_pointer_update(struct snd_pcsp *chip) |
eea0579f | 89 | { |
eea0579f | 90 | struct snd_pcm_substream *substream; |
eea0579f | 91 | size_t period_bytes, buffer_bytes; |
b71207e9 | 92 | int periods_elapsed; |
eea0579f TI |
93 | unsigned long flags; |
94 | ||
eea0579f TI |
95 | /* update the playback position */ |
96 | substream = chip->playback_substream; | |
97 | if (!substream) | |
b71207e9 | 98 | return; |
eea0579f | 99 | |
9ab4d072 SS |
100 | period_bytes = snd_pcm_lib_period_bytes(substream); |
101 | buffer_bytes = snd_pcm_lib_buffer_bytes(substream); | |
96c7d478 TI |
102 | |
103 | spin_lock_irqsave(&chip->substream_lock, flags); | |
eea0579f | 104 | chip->playback_ptr += PCSP_INDEX_INC() * chip->fmt_size; |
9ab4d072 SS |
105 | periods_elapsed = chip->playback_ptr - chip->period_ptr; |
106 | if (periods_elapsed < 0) { | |
42ece6c1 SS |
107 | #if PCSP_DEBUG |
108 | printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? " | |
9ab4d072 SS |
109 | "(%zi %zi %zi)\n", |
110 | chip->playback_ptr, period_bytes, buffer_bytes); | |
42ece6c1 | 111 | #endif |
9ab4d072 SS |
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 | ||
9ab4d072 | 119 | if (periods_elapsed) { |
9ab4d072 SS |
120 | chip->period_ptr += periods_elapsed * period_bytes; |
121 | chip->period_ptr %= buffer_bytes; | |
122 | } | |
96c7d478 | 123 | spin_unlock_irqrestore(&chip->substream_lock, flags); |
9ab4d072 | 124 | |
eea0579f TI |
125 | if (periods_elapsed) |
126 | tasklet_schedule(&pcsp_pcm_tasklet); | |
b71207e9 SS |
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); | |
9ab4d072 | 147 | |
eea0579f | 148 | hrtimer_forward(handle, hrtimer_get_expires(handle), ns_to_ktime(ns)); |
9ab4d072 | 149 | |
eea0579f | 150 | return HRTIMER_RESTART; |
9ab4d072 SS |
151 | } |
152 | ||
eea0579f | 153 | static int pcsp_start_playing(struct snd_pcsp *chip) |
9ab4d072 SS |
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"); | |
eea0579f | 160 | return -EIO; |
9ab4d072 SS |
161 | } |
162 | ||
ced918eb | 163 | raw_spin_lock(&i8253_lock); |
9ab4d072 SS |
164 | chip->val61 = inb(0x61) | 0x03; |
165 | outb_p(0x92, 0x43); /* binary, mode 1, LSB only, ch 2 */ | |
ced918eb | 166 | raw_spin_unlock(&i8253_lock); |
9ab4d072 SS |
167 | atomic_set(&chip->timer_active, 1); |
168 | chip->thalf = 0; | |
169 | ||
8b0e1953 | 170 | hrtimer_start(&pcsp_chip.timer, 0, HRTIMER_MODE_REL); |
eea0579f | 171 | return 0; |
9ab4d072 SS |
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); | |
ced918eb | 183 | raw_spin_lock(&i8253_lock); |
9ab4d072 SS |
184 | /* restore the timer */ |
185 | outb_p(0xb6, 0x43); /* binary, mode 3, LSB/MSB, ch 2 */ | |
186 | outb(chip->val61 & 0xFC, 0x61); | |
ced918eb | 187 | raw_spin_unlock(&i8253_lock); |
9ab4d072 SS |
188 | } |
189 | ||
96c7d478 TI |
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 | ||
9ab4d072 SS |
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 | |
96c7d478 | 208 | pcsp_sync_stop(chip); |
9ab4d072 | 209 | chip->playback_substream = NULL; |
9ab4d072 SS |
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 | { | |
96c7d478 | 216 | struct snd_pcsp *chip = snd_pcm_substream_chip(substream); |
9ab4d072 | 217 | int err; |
96c7d478 | 218 | pcsp_sync_stop(chip); |
9ab4d072 SS |
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 | { | |
96c7d478 | 228 | struct snd_pcsp *chip = snd_pcm_substream_chip(substream); |
9ab4d072 SS |
229 | #if PCSP_DEBUG |
230 | printk(KERN_INFO "PCSP: hw_free called\n"); | |
231 | #endif | |
96c7d478 | 232 | pcsp_sync_stop(chip); |
9ab4d072 SS |
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); | |
b71207e9 SS |
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); | |
9ab4d072 SS |
245 | #if PCSP_DEBUG |
246 | printk(KERN_INFO "PCSP: prepare called, " | |
b71207e9 | 247 | "size=%zi psize=%zi f=%zi f1=%i fsize=%i\n", |
9ab4d072 SS |
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), | |
b71207e9 SS |
252 | substream->runtime->periods, |
253 | chip->fmt_size); | |
9ab4d072 | 254 | #endif |
9ab4d072 SS |
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: | |
eea0579f | 267 | return pcsp_start_playing(chip); |
9ab4d072 SS |
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); | |
96c7d478 TI |
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); | |
9ab4d072 SS |
287 | } |
288 | ||
b6c0b715 | 289 | static const struct snd_pcm_hardware snd_pcsp_playback = { |
9ab4d072 SS |
290 | .info = (SNDRV_PCM_INFO_INTERLEAVED | |
291 | SNDRV_PCM_INFO_HALF_DUPLEX | | |
292 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID), | |
4dfd7954 SS |
293 | .formats = (SNDRV_PCM_FMTBIT_U8 |
294 | #if DMIX_WANTS_S16 | |
295 | | SNDRV_PCM_FMTBIT_S16_LE | |
296 | #endif | |
297 | ), | |
9ab4d072 SS |
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 | ||
642b7589 | 327 | static const struct snd_pcm_ops snd_pcsp_playback_ops = { |
9ab4d072 SS |
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 | ||
fbbb01a1 | 338 | int snd_pcsp_new_pcm(struct snd_pcsp *chip) |
9ab4d072 SS |
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 | } |