This source file includes following definitions.
- ivtv_alsa_announce_pcm_data
- snd_ivtv_pcm_capture_open
- snd_ivtv_pcm_capture_close
- snd_ivtv_pcm_ioctl
- snd_pcm_alloc_vmalloc_buffer
- snd_ivtv_pcm_hw_params
- snd_ivtv_pcm_hw_free
- snd_ivtv_pcm_prepare
- snd_ivtv_pcm_trigger
- snd_ivtv_pcm_pointer
- snd_pcm_get_vmalloc_page
- snd_ivtv_pcm_create
1
2
3
4
5
6
7
8
9
10
11
12 #include "ivtv-driver.h"
13 #include "ivtv-queue.h"
14 #include "ivtv-streams.h"
15 #include "ivtv-fileops.h"
16 #include "ivtv-alsa.h"
17 #include "ivtv-alsa-pcm.h"
18
19 #include <linux/vmalloc.h>
20
21 #include <sound/core.h>
22 #include <sound/pcm.h>
23
24
25 static unsigned int pcm_debug;
26 module_param(pcm_debug, int, 0644);
27 MODULE_PARM_DESC(pcm_debug, "enable debug messages for pcm");
28
29 #define dprintk(fmt, arg...) \
30 do { \
31 if (pcm_debug) \
32 pr_info("ivtv-alsa-pcm %s: " fmt, __func__, ##arg); \
33 } while (0)
34
35 static const struct snd_pcm_hardware snd_ivtv_hw_capture = {
36 .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
37 SNDRV_PCM_INFO_MMAP |
38 SNDRV_PCM_INFO_INTERLEAVED |
39 SNDRV_PCM_INFO_MMAP_VALID,
40
41 .formats = SNDRV_PCM_FMTBIT_S16_LE,
42
43 .rates = SNDRV_PCM_RATE_48000,
44
45 .rate_min = 48000,
46 .rate_max = 48000,
47 .channels_min = 2,
48 .channels_max = 2,
49 .buffer_bytes_max = 62720 * 8,
50 .period_bytes_min = 64,
51 .period_bytes_max = 12544,
52 .periods_min = 2,
53 .periods_max = 98,
54 };
55
56 static void ivtv_alsa_announce_pcm_data(struct snd_ivtv_card *itvsc,
57 u8 *pcm_data,
58 size_t num_bytes)
59 {
60 struct snd_pcm_substream *substream;
61 struct snd_pcm_runtime *runtime;
62 unsigned int oldptr;
63 unsigned int stride;
64 int period_elapsed = 0;
65 int length;
66
67 dprintk("ivtv alsa announce ptr=%p data=%p num_bytes=%zu\n", itvsc,
68 pcm_data, num_bytes);
69
70 substream = itvsc->capture_pcm_substream;
71 if (substream == NULL) {
72 dprintk("substream was NULL\n");
73 return;
74 }
75
76 runtime = substream->runtime;
77 if (runtime == NULL) {
78 dprintk("runtime was NULL\n");
79 return;
80 }
81
82 stride = runtime->frame_bits >> 3;
83 if (stride == 0) {
84 dprintk("stride is zero\n");
85 return;
86 }
87
88 length = num_bytes / stride;
89 if (length == 0) {
90 dprintk("%s: length was zero\n", __func__);
91 return;
92 }
93
94 if (runtime->dma_area == NULL) {
95 dprintk("dma area was NULL - ignoring\n");
96 return;
97 }
98
99 oldptr = itvsc->hwptr_done_capture;
100 if (oldptr + length >= runtime->buffer_size) {
101 unsigned int cnt =
102 runtime->buffer_size - oldptr;
103 memcpy(runtime->dma_area + oldptr * stride, pcm_data,
104 cnt * stride);
105 memcpy(runtime->dma_area, pcm_data + cnt * stride,
106 length * stride - cnt * stride);
107 } else {
108 memcpy(runtime->dma_area + oldptr * stride, pcm_data,
109 length * stride);
110 }
111 snd_pcm_stream_lock(substream);
112
113 itvsc->hwptr_done_capture += length;
114 if (itvsc->hwptr_done_capture >=
115 runtime->buffer_size)
116 itvsc->hwptr_done_capture -=
117 runtime->buffer_size;
118
119 itvsc->capture_transfer_done += length;
120 if (itvsc->capture_transfer_done >=
121 runtime->period_size) {
122 itvsc->capture_transfer_done -=
123 runtime->period_size;
124 period_elapsed = 1;
125 }
126
127 snd_pcm_stream_unlock(substream);
128
129 if (period_elapsed)
130 snd_pcm_period_elapsed(substream);
131 }
132
133 static int snd_ivtv_pcm_capture_open(struct snd_pcm_substream *substream)
134 {
135 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
136 struct snd_pcm_runtime *runtime = substream->runtime;
137 struct v4l2_device *v4l2_dev = itvsc->v4l2_dev;
138 struct ivtv *itv = to_ivtv(v4l2_dev);
139 struct ivtv_stream *s;
140 struct ivtv_open_id item;
141 int ret;
142
143
144 snd_ivtv_lock(itvsc);
145
146 if (ivtv_init_on_first_open(itv)) {
147 snd_ivtv_unlock(itvsc);
148 return -ENXIO;
149 }
150
151 s = &itv->streams[IVTV_ENC_STREAM_TYPE_PCM];
152
153 v4l2_fh_init(&item.fh, &s->vdev);
154 item.itv = itv;
155 item.type = s->type;
156
157
158 if (ivtv_claim_stream(&item, item.type)) {
159
160 v4l2_fh_exit(&item.fh);
161 snd_ivtv_unlock(itvsc);
162 return -EBUSY;
163 }
164
165 if (test_bit(IVTV_F_S_STREAMOFF, &s->s_flags) ||
166 test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
167
168 snd_ivtv_unlock(itvsc);
169 return 0;
170 }
171
172
173 runtime->hw = snd_ivtv_hw_capture;
174 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
175 itvsc->capture_pcm_substream = substream;
176 runtime->private_data = itv;
177
178 itv->pcm_announce_callback = ivtv_alsa_announce_pcm_data;
179
180
181 set_bit(IVTV_F_S_STREAMING, &s->s_flags);
182 ret = ivtv_start_v4l2_encode_stream(s);
183 snd_ivtv_unlock(itvsc);
184
185 return ret;
186 }
187
188 static int snd_ivtv_pcm_capture_close(struct snd_pcm_substream *substream)
189 {
190 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
191 struct v4l2_device *v4l2_dev = itvsc->v4l2_dev;
192 struct ivtv *itv = to_ivtv(v4l2_dev);
193 struct ivtv_stream *s;
194
195
196 snd_ivtv_lock(itvsc);
197 s = &itv->streams[IVTV_ENC_STREAM_TYPE_PCM];
198 ivtv_stop_v4l2_encode_stream(s, 0);
199 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
200
201 ivtv_release_stream(s);
202
203 itv->pcm_announce_callback = NULL;
204 snd_ivtv_unlock(itvsc);
205
206 return 0;
207 }
208
209 static int snd_ivtv_pcm_ioctl(struct snd_pcm_substream *substream,
210 unsigned int cmd, void *arg)
211 {
212 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
213 int ret;
214
215 snd_ivtv_lock(itvsc);
216 ret = snd_pcm_lib_ioctl(substream, cmd, arg);
217 snd_ivtv_unlock(itvsc);
218 return ret;
219 }
220
221
222 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
223 size_t size)
224 {
225 struct snd_pcm_runtime *runtime = subs->runtime;
226
227 dprintk("Allocating vbuffer\n");
228 if (runtime->dma_area) {
229 if (runtime->dma_bytes > size)
230 return 0;
231
232 vfree(runtime->dma_area);
233 }
234 runtime->dma_area = vmalloc(size);
235 if (!runtime->dma_area)
236 return -ENOMEM;
237
238 runtime->dma_bytes = size;
239
240 return 0;
241 }
242
243 static int snd_ivtv_pcm_hw_params(struct snd_pcm_substream *substream,
244 struct snd_pcm_hw_params *params)
245 {
246 dprintk("%s called\n", __func__);
247
248 return snd_pcm_alloc_vmalloc_buffer(substream,
249 params_buffer_bytes(params));
250 }
251
252 static int snd_ivtv_pcm_hw_free(struct snd_pcm_substream *substream)
253 {
254 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
255 unsigned long flags;
256 unsigned char *dma_area = NULL;
257
258 spin_lock_irqsave(&itvsc->slock, flags);
259 if (substream->runtime->dma_area) {
260 dprintk("freeing pcm capture region\n");
261 dma_area = substream->runtime->dma_area;
262 substream->runtime->dma_area = NULL;
263 }
264 spin_unlock_irqrestore(&itvsc->slock, flags);
265 vfree(dma_area);
266
267 return 0;
268 }
269
270 static int snd_ivtv_pcm_prepare(struct snd_pcm_substream *substream)
271 {
272 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
273
274 itvsc->hwptr_done_capture = 0;
275 itvsc->capture_transfer_done = 0;
276
277 return 0;
278 }
279
280 static int snd_ivtv_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
281 {
282 return 0;
283 }
284
285 static
286 snd_pcm_uframes_t snd_ivtv_pcm_pointer(struct snd_pcm_substream *substream)
287 {
288 unsigned long flags;
289 snd_pcm_uframes_t hwptr_done;
290 struct snd_ivtv_card *itvsc = snd_pcm_substream_chip(substream);
291
292 spin_lock_irqsave(&itvsc->slock, flags);
293 hwptr_done = itvsc->hwptr_done_capture;
294 spin_unlock_irqrestore(&itvsc->slock, flags);
295
296 return hwptr_done;
297 }
298
299 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
300 unsigned long offset)
301 {
302 void *pageptr = subs->runtime->dma_area + offset;
303
304 return vmalloc_to_page(pageptr);
305 }
306
307 static const struct snd_pcm_ops snd_ivtv_pcm_capture_ops = {
308 .open = snd_ivtv_pcm_capture_open,
309 .close = snd_ivtv_pcm_capture_close,
310 .ioctl = snd_ivtv_pcm_ioctl,
311 .hw_params = snd_ivtv_pcm_hw_params,
312 .hw_free = snd_ivtv_pcm_hw_free,
313 .prepare = snd_ivtv_pcm_prepare,
314 .trigger = snd_ivtv_pcm_trigger,
315 .pointer = snd_ivtv_pcm_pointer,
316 .page = snd_pcm_get_vmalloc_page,
317 };
318
319 int snd_ivtv_pcm_create(struct snd_ivtv_card *itvsc)
320 {
321 struct snd_pcm *sp;
322 struct snd_card *sc = itvsc->sc;
323 struct v4l2_device *v4l2_dev = itvsc->v4l2_dev;
324 struct ivtv *itv = to_ivtv(v4l2_dev);
325 int ret;
326
327 ret = snd_pcm_new(sc, "CX2341[56] PCM",
328 0,
329 0,
330 1,
331 &sp);
332 if (ret) {
333 IVTV_ALSA_ERR("%s: snd_ivtv_pcm_create() failed with err %d\n",
334 __func__, ret);
335 goto err_exit;
336 }
337
338 spin_lock_init(&itvsc->slock);
339
340 snd_pcm_set_ops(sp, SNDRV_PCM_STREAM_CAPTURE,
341 &snd_ivtv_pcm_capture_ops);
342 sp->info_flags = 0;
343 sp->private_data = itvsc;
344 strscpy(sp->name, itv->card_name, sizeof(sp->name));
345
346 return 0;
347
348 err_exit:
349 return ret;
350 }