1 /* 2 * Line 6 Linux USB driver 3 * 4 * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation, version 2. 9 * 10 */ 11 12 #include <linux/slab.h> 13 #include <sound/core.h> 14 #include <sound/pcm.h> 15 #include <sound/pcm_params.h> 16 17 #include "capture.h" 18 #include "driver.h" 19 #include "pcm.h" 20 #include "playback.h" 21 22 /* 23 Software stereo volume control. 24 */ 25 static void change_volume(struct urb *urb_out, int volume[], 26 int bytes_per_frame) 27 { 28 int chn = 0; 29 30 if (volume[0] == 256 && volume[1] == 256) 31 return; /* maximum volume - no change */ 32 33 if (bytes_per_frame == 4) { 34 __le16 *p, *buf_end; 35 36 p = (__le16 *)urb_out->transfer_buffer; 37 buf_end = p + urb_out->transfer_buffer_length / sizeof(*p); 38 39 for (; p < buf_end; ++p) { 40 short pv = le16_to_cpu(*p); 41 int val = (pv * volume[chn & 1]) >> 8; 42 pv = clamp(val, -0x8000, 0x7fff); 43 *p = cpu_to_le16(pv); 44 ++chn; 45 } 46 } else if (bytes_per_frame == 6) { 47 unsigned char *p, *buf_end; 48 49 p = (unsigned char *)urb_out->transfer_buffer; 50 buf_end = p + urb_out->transfer_buffer_length; 51 52 for (; p < buf_end; p += 3) { 53 int val; 54 55 val = p[0] + (p[1] << 8) + ((signed char)p[2] << 16); 56 val = (val * volume[chn & 1]) >> 8; 57 val = clamp(val, -0x800000, 0x7fffff); 58 p[0] = val; 59 p[1] = val >> 8; 60 p[2] = val >> 16; 61 ++chn; 62 } 63 } 64 } 65 66 /* 67 Create signal for impulse response test. 68 */ 69 static void create_impulse_test_signal(struct snd_line6_pcm *line6pcm, 70 struct urb *urb_out, int bytes_per_frame) 71 { 72 int frames = urb_out->transfer_buffer_length / bytes_per_frame; 73 74 if (bytes_per_frame == 4) { 75 int i; 76 short *pi = (short *)line6pcm->prev_fbuf; 77 short *po = (short *)urb_out->transfer_buffer; 78 79 for (i = 0; i < frames; ++i) { 80 po[0] = pi[0]; 81 po[1] = 0; 82 pi += 2; 83 po += 2; 84 } 85 } else if (bytes_per_frame == 6) { 86 int i, j; 87 unsigned char *pi = line6pcm->prev_fbuf; 88 unsigned char *po = urb_out->transfer_buffer; 89 90 for (i = 0; i < frames; ++i) { 91 for (j = 0; j < bytes_per_frame / 2; ++j) 92 po[j] = pi[j]; 93 94 for (; j < bytes_per_frame; ++j) 95 po[j] = 0; 96 97 pi += bytes_per_frame; 98 po += bytes_per_frame; 99 } 100 } 101 if (--line6pcm->impulse_count <= 0) { 102 ((unsigned char *)(urb_out->transfer_buffer))[bytes_per_frame - 103 1] = 104 line6pcm->impulse_volume; 105 line6pcm->impulse_count = line6pcm->impulse_period; 106 } 107 } 108 109 /* 110 Add signal to buffer for software monitoring. 111 */ 112 static void add_monitor_signal(struct urb *urb_out, unsigned char *signal, 113 int volume, int bytes_per_frame) 114 { 115 if (volume == 0) 116 return; /* zero volume - no change */ 117 118 if (bytes_per_frame == 4) { 119 __le16 *pi, *po, *buf_end; 120 121 pi = (__le16 *)signal; 122 po = (__le16 *)urb_out->transfer_buffer; 123 buf_end = po + urb_out->transfer_buffer_length / sizeof(*po); 124 125 for (; po < buf_end; ++pi, ++po) { 126 short pov = le16_to_cpu(*po); 127 short piv = le16_to_cpu(*pi); 128 int val = pov + ((piv * volume) >> 8); 129 pov = clamp(val, -0x8000, 0x7fff); 130 *po = cpu_to_le16(pov); 131 } 132 } 133 134 /* 135 We don't need to handle devices with 6 bytes per frame here 136 since they all support hardware monitoring. 137 */ 138 } 139 140 /* 141 Find a free URB, prepare audio data, and submit URB. 142 must be called in line6pcm->out.lock context 143 */ 144 static int submit_audio_out_urb(struct snd_line6_pcm *line6pcm) 145 { 146 int index; 147 int i, urb_size, urb_frames; 148 int ret; 149 const int bytes_per_frame = 150 line6pcm->properties->bytes_per_channel * 151 line6pcm->properties->playback_hw.channels_max; 152 const int frame_increment = 153 line6pcm->properties->rates.rats[0].num_min; 154 const int frame_factor = 155 line6pcm->properties->rates.rats[0].den * 156 (line6pcm->line6->intervals_per_second / LINE6_ISO_INTERVAL); 157 struct urb *urb_out; 158 159 index = find_first_zero_bit(&line6pcm->out.active_urbs, 160 line6pcm->line6->iso_buffers); 161 162 if (index < 0 || index >= line6pcm->line6->iso_buffers) { 163 dev_err(line6pcm->line6->ifcdev, "no free URB found\n"); 164 return -EINVAL; 165 } 166 167 urb_out = line6pcm->out.urbs[index]; 168 urb_size = 0; 169 170 /* TODO: this may not work for LINE6_ISO_PACKETS != 1 */ 171 for (i = 0; i < LINE6_ISO_PACKETS; ++i) { 172 /* compute frame size for given sampling rate */ 173 int fsize = 0; 174 struct usb_iso_packet_descriptor *fout = 175 &urb_out->iso_frame_desc[i]; 176 177 fsize = line6pcm->prev_fsize; 178 if (fsize == 0) { 179 int n; 180 181 line6pcm->out.count += frame_increment; 182 n = line6pcm->out.count / frame_factor; 183 line6pcm->out.count -= n * frame_factor; 184 fsize = n; 185 } 186 187 fsize *= bytes_per_frame; 188 189 fout->offset = urb_size; 190 fout->length = fsize; 191 urb_size += fsize; 192 } 193 194 if (urb_size == 0) { 195 /* can't determine URB size */ 196 dev_err(line6pcm->line6->ifcdev, "driver bug: urb_size = 0\n"); 197 return -EINVAL; 198 } 199 200 urb_frames = urb_size / bytes_per_frame; 201 urb_out->transfer_buffer = 202 line6pcm->out.buffer + 203 index * LINE6_ISO_PACKETS * line6pcm->max_packet_size_out; 204 urb_out->transfer_buffer_length = urb_size; 205 urb_out->context = line6pcm; 206 207 if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running) && 208 !test_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags)) { 209 struct snd_pcm_runtime *runtime = 210 get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK)->runtime; 211 212 if (line6pcm->out.pos + urb_frames > runtime->buffer_size) { 213 /* 214 The transferred area goes over buffer boundary, 215 copy the data to the temp buffer. 216 */ 217 int len; 218 219 len = runtime->buffer_size - line6pcm->out.pos; 220 221 if (len > 0) { 222 memcpy(urb_out->transfer_buffer, 223 runtime->dma_area + 224 line6pcm->out.pos * bytes_per_frame, 225 len * bytes_per_frame); 226 memcpy(urb_out->transfer_buffer + 227 len * bytes_per_frame, runtime->dma_area, 228 (urb_frames - len) * bytes_per_frame); 229 } else 230 dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n", 231 len); 232 } else { 233 memcpy(urb_out->transfer_buffer, 234 runtime->dma_area + 235 line6pcm->out.pos * bytes_per_frame, 236 urb_out->transfer_buffer_length); 237 } 238 239 line6pcm->out.pos += urb_frames; 240 if (line6pcm->out.pos >= runtime->buffer_size) 241 line6pcm->out.pos -= runtime->buffer_size; 242 243 change_volume(urb_out, line6pcm->volume_playback, 244 bytes_per_frame); 245 } else { 246 memset(urb_out->transfer_buffer, 0, 247 urb_out->transfer_buffer_length); 248 } 249 250 spin_lock_nested(&line6pcm->in.lock, SINGLE_DEPTH_NESTING); 251 if (line6pcm->prev_fbuf) { 252 if (test_bit(LINE6_STREAM_IMPULSE, &line6pcm->out.running)) { 253 create_impulse_test_signal(line6pcm, urb_out, 254 bytes_per_frame); 255 if (test_bit(LINE6_STREAM_PCM, &line6pcm->in.running)) { 256 line6_capture_copy(line6pcm, 257 urb_out->transfer_buffer, 258 urb_out-> 259 transfer_buffer_length); 260 line6_capture_check_period(line6pcm, 261 urb_out->transfer_buffer_length); 262 } 263 } else { 264 if (!(line6pcm->line6->properties->capabilities & LINE6_CAP_HWMON) 265 && line6pcm->out.running && line6pcm->in.running) 266 add_monitor_signal(urb_out, line6pcm->prev_fbuf, 267 line6pcm->volume_monitor, 268 bytes_per_frame); 269 } 270 line6pcm->prev_fbuf = NULL; 271 line6pcm->prev_fsize = 0; 272 } 273 spin_unlock(&line6pcm->in.lock); 274 275 ret = usb_submit_urb(urb_out, GFP_ATOMIC); 276 277 if (ret == 0) 278 set_bit(index, &line6pcm->out.active_urbs); 279 else 280 dev_err(line6pcm->line6->ifcdev, 281 "URB out #%d submission failed (%d)\n", index, ret); 282 283 return 0; 284 } 285 286 /* 287 Submit all currently available playback URBs. 288 must be called in line6pcm->out.lock context 289 */ 290 int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm) 291 { 292 int ret = 0, i; 293 294 for (i = 0; i < line6pcm->line6->iso_buffers; ++i) { 295 ret = submit_audio_out_urb(line6pcm); 296 if (ret < 0) 297 break; 298 } 299 300 return ret; 301 } 302 303 /* 304 Callback for completed playback URB. 305 */ 306 static void audio_out_callback(struct urb *urb) 307 { 308 int i, index, length = 0, shutdown = 0; 309 unsigned long flags; 310 struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context; 311 struct snd_pcm_substream *substream = 312 get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK); 313 const int bytes_per_frame = 314 line6pcm->properties->bytes_per_channel * 315 line6pcm->properties->playback_hw.channels_max; 316 317 #if USE_CLEAR_BUFFER_WORKAROUND 318 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length); 319 #endif 320 321 line6pcm->out.last_frame = urb->start_frame; 322 323 /* find index of URB */ 324 for (index = 0; index < line6pcm->line6->iso_buffers; index++) 325 if (urb == line6pcm->out.urbs[index]) 326 break; 327 328 if (index >= line6pcm->line6->iso_buffers) 329 return; /* URB has been unlinked asynchronously */ 330 331 for (i = 0; i < LINE6_ISO_PACKETS; i++) 332 length += urb->iso_frame_desc[i].length; 333 334 spin_lock_irqsave(&line6pcm->out.lock, flags); 335 336 if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) { 337 struct snd_pcm_runtime *runtime = substream->runtime; 338 339 line6pcm->out.pos_done += 340 length / bytes_per_frame; 341 342 if (line6pcm->out.pos_done >= runtime->buffer_size) 343 line6pcm->out.pos_done -= runtime->buffer_size; 344 } 345 346 clear_bit(index, &line6pcm->out.active_urbs); 347 348 for (i = 0; i < LINE6_ISO_PACKETS; i++) 349 if (urb->iso_frame_desc[i].status == -EXDEV) { 350 shutdown = 1; 351 break; 352 } 353 354 if (test_and_clear_bit(index, &line6pcm->out.unlink_urbs)) 355 shutdown = 1; 356 357 if (!shutdown) { 358 submit_audio_out_urb(line6pcm); 359 360 if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) { 361 line6pcm->out.bytes += length; 362 if (line6pcm->out.bytes >= line6pcm->out.period) { 363 line6pcm->out.bytes %= line6pcm->out.period; 364 spin_unlock(&line6pcm->out.lock); 365 snd_pcm_period_elapsed(substream); 366 spin_lock(&line6pcm->out.lock); 367 } 368 } 369 } 370 spin_unlock_irqrestore(&line6pcm->out.lock, flags); 371 } 372 373 /* open playback callback */ 374 static int snd_line6_playback_open(struct snd_pcm_substream *substream) 375 { 376 int err; 377 struct snd_pcm_runtime *runtime = substream->runtime; 378 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 379 380 err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 381 &line6pcm->properties->rates); 382 if (err < 0) 383 return err; 384 385 runtime->hw = line6pcm->properties->playback_hw; 386 return 0; 387 } 388 389 /* close playback callback */ 390 static int snd_line6_playback_close(struct snd_pcm_substream *substream) 391 { 392 return 0; 393 } 394 395 /* playback operators */ 396 struct snd_pcm_ops snd_line6_playback_ops = { 397 .open = snd_line6_playback_open, 398 .close = snd_line6_playback_close, 399 .ioctl = snd_pcm_lib_ioctl, 400 .hw_params = snd_line6_hw_params, 401 .hw_free = snd_line6_hw_free, 402 .prepare = snd_line6_prepare, 403 .trigger = snd_line6_trigger, 404 .pointer = snd_line6_pointer, 405 }; 406 407 int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm) 408 { 409 struct usb_line6 *line6 = line6pcm->line6; 410 int i; 411 412 line6pcm->out.urbs = kzalloc( 413 sizeof(struct urb *) * line6->iso_buffers, GFP_KERNEL); 414 if (line6pcm->out.urbs == NULL) 415 return -ENOMEM; 416 417 /* create audio URBs and fill in constant values: */ 418 for (i = 0; i < line6->iso_buffers; ++i) { 419 struct urb *urb; 420 421 /* URB for audio out: */ 422 urb = line6pcm->out.urbs[i] = 423 usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL); 424 425 if (urb == NULL) 426 return -ENOMEM; 427 428 urb->dev = line6->usbdev; 429 urb->pipe = 430 usb_sndisocpipe(line6->usbdev, 431 line6->properties->ep_audio_w & 432 USB_ENDPOINT_NUMBER_MASK); 433 urb->transfer_flags = URB_ISO_ASAP; 434 urb->start_frame = -1; 435 urb->number_of_packets = LINE6_ISO_PACKETS; 436 urb->interval = LINE6_ISO_INTERVAL; 437 urb->error_count = 0; 438 urb->complete = audio_out_callback; 439 } 440 441 return 0; 442 } 443