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

source code of linux/sound/drivers/pcsp/pcsp_lib.c