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