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