1 /* 2 * ALSA PCM device for the 3 * ALSA interface to cx18 PCM capture streams 4 * 5 * Copyright (C) 2009 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. 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 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 23 * 02111-1307 USA 24 */ 25 26 #include <linux/init.h> 27 #include <linux/kernel.h> 28 #include <linux/vmalloc.h> 29 30 #include <media/v4l2-device.h> 31 32 #include <sound/core.h> 33 #include <sound/pcm.h> 34 35 #include "cx18-driver.h" 36 #include "cx18-queue.h" 37 #include "cx18-streams.h" 38 #include "cx18-fileops.h" 39 #include "cx18-alsa.h" 40 #include "cx18-alsa-pcm.h" 41 42 static unsigned int pcm_debug; 43 module_param(pcm_debug, int, 0644); 44 MODULE_PARM_DESC(pcm_debug, "enable debug messages for pcm"); 45 46 #define dprintk(fmt, arg...) do { \ 47 if (pcm_debug) \ 48 printk(KERN_INFO "cx18-alsa-pcm %s: " fmt, \ 49 __func__, ##arg); \ 50 } while (0) 51 52 static struct snd_pcm_hardware snd_cx18_hw_capture = { 53 .info = SNDRV_PCM_INFO_BLOCK_TRANSFER | 54 SNDRV_PCM_INFO_MMAP | 55 SNDRV_PCM_INFO_INTERLEAVED | 56 SNDRV_PCM_INFO_MMAP_VALID, 57 58 .formats = SNDRV_PCM_FMTBIT_S16_LE, 59 60 .rates = SNDRV_PCM_RATE_48000, 61 62 .rate_min = 48000, 63 .rate_max = 48000, 64 .channels_min = 2, 65 .channels_max = 2, 66 .buffer_bytes_max = 62720 * 8, /* just about the value in usbaudio.c */ 67 .period_bytes_min = 64, /* 12544/2, */ 68 .period_bytes_max = 12544, 69 .periods_min = 2, 70 .periods_max = 98, /* 12544, */ 71 }; 72 73 void cx18_alsa_announce_pcm_data(struct snd_cx18_card *cxsc, u8 *pcm_data, 74 size_t num_bytes) 75 { 76 struct snd_pcm_substream *substream; 77 struct snd_pcm_runtime *runtime; 78 unsigned int oldptr; 79 unsigned int stride; 80 int period_elapsed = 0; 81 int length; 82 83 dprintk("cx18 alsa announce ptr=%p data=%p num_bytes=%zd\n", cxsc, 84 pcm_data, num_bytes); 85 86 substream = cxsc->capture_pcm_substream; 87 if (substream == NULL) { 88 dprintk("substream was NULL\n"); 89 return; 90 } 91 92 runtime = substream->runtime; 93 if (runtime == NULL) { 94 dprintk("runtime was NULL\n"); 95 return; 96 } 97 98 stride = runtime->frame_bits >> 3; 99 if (stride == 0) { 100 dprintk("stride is zero\n"); 101 return; 102 } 103 104 length = num_bytes / stride; 105 if (length == 0) { 106 dprintk("%s: length was zero\n", __func__); 107 return; 108 } 109 110 if (runtime->dma_area == NULL) { 111 dprintk("dma area was NULL - ignoring\n"); 112 return; 113 } 114 115 oldptr = cxsc->hwptr_done_capture; 116 if (oldptr + length >= runtime->buffer_size) { 117 unsigned int cnt = 118 runtime->buffer_size - oldptr; 119 memcpy(runtime->dma_area + oldptr * stride, pcm_data, 120 cnt * stride); 121 memcpy(runtime->dma_area, pcm_data + cnt * stride, 122 length * stride - cnt * stride); 123 } else { 124 memcpy(runtime->dma_area + oldptr * stride, pcm_data, 125 length * stride); 126 } 127 snd_pcm_stream_lock(substream); 128 129 cxsc->hwptr_done_capture += length; 130 if (cxsc->hwptr_done_capture >= 131 runtime->buffer_size) 132 cxsc->hwptr_done_capture -= 133 runtime->buffer_size; 134 135 cxsc->capture_transfer_done += length; 136 if (cxsc->capture_transfer_done >= 137 runtime->period_size) { 138 cxsc->capture_transfer_done -= 139 runtime->period_size; 140 period_elapsed = 1; 141 } 142 143 snd_pcm_stream_unlock(substream); 144 145 if (period_elapsed) 146 snd_pcm_period_elapsed(substream); 147 } 148 149 static int snd_cx18_pcm_capture_open(struct snd_pcm_substream *substream) 150 { 151 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 152 struct snd_pcm_runtime *runtime = substream->runtime; 153 struct v4l2_device *v4l2_dev = cxsc->v4l2_dev; 154 struct cx18 *cx = to_cx18(v4l2_dev); 155 struct cx18_stream *s; 156 struct cx18_open_id item; 157 int ret; 158 159 /* Instruct the cx18 to start sending packets */ 160 snd_cx18_lock(cxsc); 161 s = &cx->streams[CX18_ENC_STREAM_TYPE_PCM]; 162 163 item.cx = cx; 164 item.type = s->type; 165 item.open_id = cx->open_id++; 166 167 /* See if the stream is available */ 168 if (cx18_claim_stream(&item, item.type)) { 169 /* No, it's already in use */ 170 snd_cx18_unlock(cxsc); 171 return -EBUSY; 172 } 173 174 if (test_bit(CX18_F_S_STREAMOFF, &s->s_flags) || 175 test_and_set_bit(CX18_F_S_STREAMING, &s->s_flags)) { 176 /* We're already streaming. No additional action required */ 177 snd_cx18_unlock(cxsc); 178 return 0; 179 } 180 181 182 runtime->hw = snd_cx18_hw_capture; 183 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 184 cxsc->capture_pcm_substream = substream; 185 runtime->private_data = cx; 186 187 cx->pcm_announce_callback = cx18_alsa_announce_pcm_data; 188 189 /* Not currently streaming, so start it up */ 190 set_bit(CX18_F_S_STREAMING, &s->s_flags); 191 ret = cx18_start_v4l2_encode_stream(s); 192 snd_cx18_unlock(cxsc); 193 194 return ret; 195 } 196 197 static int snd_cx18_pcm_capture_close(struct snd_pcm_substream *substream) 198 { 199 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 200 struct v4l2_device *v4l2_dev = cxsc->v4l2_dev; 201 struct cx18 *cx = to_cx18(v4l2_dev); 202 struct cx18_stream *s; 203 204 /* Instruct the cx18 to stop sending packets */ 205 snd_cx18_lock(cxsc); 206 s = &cx->streams[CX18_ENC_STREAM_TYPE_PCM]; 207 cx18_stop_v4l2_encode_stream(s, 0); 208 clear_bit(CX18_F_S_STREAMING, &s->s_flags); 209 210 cx18_release_stream(s); 211 212 cx->pcm_announce_callback = NULL; 213 snd_cx18_unlock(cxsc); 214 215 return 0; 216 } 217 218 static int snd_cx18_pcm_ioctl(struct snd_pcm_substream *substream, 219 unsigned int cmd, void *arg) 220 { 221 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 222 int ret; 223 224 snd_cx18_lock(cxsc); 225 ret = snd_pcm_lib_ioctl(substream, cmd, arg); 226 snd_cx18_unlock(cxsc); 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_cx18_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_cx18_pcm_hw_free(struct snd_pcm_substream *substream) 262 { 263 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 264 unsigned long flags; 265 266 spin_lock_irqsave(&cxsc->slock, flags); 267 if (substream->runtime->dma_area) { 268 dprintk("freeing pcm capture region\n"); 269 vfree(substream->runtime->dma_area); 270 substream->runtime->dma_area = NULL; 271 } 272 spin_unlock_irqrestore(&cxsc->slock, flags); 273 274 return 0; 275 } 276 277 static int snd_cx18_pcm_prepare(struct snd_pcm_substream *substream) 278 { 279 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 280 281 cxsc->hwptr_done_capture = 0; 282 cxsc->capture_transfer_done = 0; 283 284 return 0; 285 } 286 287 static int snd_cx18_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 288 { 289 return 0; 290 } 291 292 static 293 snd_pcm_uframes_t snd_cx18_pcm_pointer(struct snd_pcm_substream *substream) 294 { 295 unsigned long flags; 296 snd_pcm_uframes_t hwptr_done; 297 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream); 298 299 spin_lock_irqsave(&cxsc->slock, flags); 300 hwptr_done = cxsc->hwptr_done_capture; 301 spin_unlock_irqrestore(&cxsc->slock, flags); 302 303 return hwptr_done; 304 } 305 306 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, 307 unsigned long offset) 308 { 309 void *pageptr = subs->runtime->dma_area + offset; 310 311 return vmalloc_to_page(pageptr); 312 } 313 314 static struct snd_pcm_ops snd_cx18_pcm_capture_ops = { 315 .open = snd_cx18_pcm_capture_open, 316 .close = snd_cx18_pcm_capture_close, 317 .ioctl = snd_cx18_pcm_ioctl, 318 .hw_params = snd_cx18_pcm_hw_params, 319 .hw_free = snd_cx18_pcm_hw_free, 320 .prepare = snd_cx18_pcm_prepare, 321 .trigger = snd_cx18_pcm_trigger, 322 .pointer = snd_cx18_pcm_pointer, 323 .page = snd_pcm_get_vmalloc_page, 324 }; 325 326 int snd_cx18_pcm_create(struct snd_cx18_card *cxsc) 327 { 328 struct snd_pcm *sp; 329 struct snd_card *sc = cxsc->sc; 330 struct v4l2_device *v4l2_dev = cxsc->v4l2_dev; 331 struct cx18 *cx = to_cx18(v4l2_dev); 332 int ret; 333 334 ret = snd_pcm_new(sc, "CX23418 PCM", 335 0, /* PCM device 0, the only one for this card */ 336 0, /* 0 playback substreams */ 337 1, /* 1 capture substream */ 338 &sp); 339 if (ret) { 340 CX18_ALSA_ERR("%s: snd_cx18_pcm_create() failed with err %d\n", 341 __func__, ret); 342 goto err_exit; 343 } 344 345 spin_lock_init(&cxsc->slock); 346 347 snd_pcm_set_ops(sp, SNDRV_PCM_STREAM_CAPTURE, 348 &snd_cx18_pcm_capture_ops); 349 sp->info_flags = 0; 350 sp->private_data = cxsc; 351 strlcpy(sp->name, cx->card_name, sizeof(sp->name)); 352 353 return 0; 354 355 err_exit: 356 return ret; 357 } 358