This source file includes following definitions.
- pcsp_call_pcm_elapsed
- pcsp_timer_update
- pcsp_pointer_update
- pcsp_do_timer
- pcsp_start_playing
- pcsp_stop_playing
- pcsp_sync_stop
- snd_pcsp_playback_close
- snd_pcsp_playback_hw_params
- snd_pcsp_playback_hw_free
- snd_pcsp_playback_prepare
- snd_pcsp_trigger
- snd_pcsp_playback_pointer
- snd_pcsp_playback_open
- snd_pcsp_new_pcm
1
2
3
4
5
6
7
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
27
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
42
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
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
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
116
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);
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
185 outb_p(0xb6, 0x43);
186 outb(chip->val61 & 0xFC, 0x61);
187 raw_spin_unlock(&i8253_lock);
188 }
189
190
191
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 }