1 /* 2 * Line6 Linux USB driver - 0.9.1beta 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 /* 13 PCM interface to POD series devices. 14 */ 15 16 #ifndef PCM_H 17 #define PCM_H 18 19 #include <sound/pcm.h> 20 21 #include "driver.h" 22 #include "usbdefs.h" 23 24 /* number of URBs */ 25 #define LINE6_ISO_BUFFERS 2 26 27 /* 28 number of USB frames per URB 29 The Line6 Windows driver always transmits two frames per packet, but 30 the Linux driver performs significantly better (i.e., lower latency) 31 with only one frame per packet. 32 */ 33 #define LINE6_ISO_PACKETS 1 34 35 /* in a "full speed" device (such as the PODxt Pro) this means 1ms */ 36 #define LINE6_ISO_INTERVAL 1 37 38 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 39 #define LINE6_IMPULSE_DEFAULT_PERIOD 100 40 #endif 41 42 #define LINE6_BACKUP_MONITOR_SIGNAL 0 43 #define LINE6_REUSE_DMA_AREA_FOR_PLAYBACK 0 44 45 /* 46 Get substream from Line6 PCM data structure 47 */ 48 #define get_substream(line6pcm, stream) \ 49 (line6pcm->pcm->streams[stream].substream) 50 51 /* 52 PCM mode bits and masks. 53 "ALSA": operations triggered by applications via ALSA 54 "MONITOR": software monitoring 55 "IMPULSE": optional impulse response operation 56 */ 57 enum { 58 /* individual bits: */ 59 BIT_PCM_ALSA_PLAYBACK, 60 BIT_PCM_ALSA_CAPTURE, 61 BIT_PCM_MONITOR_PLAYBACK, 62 BIT_PCM_MONITOR_CAPTURE, 63 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 64 BIT_PCM_IMPULSE_PLAYBACK, 65 BIT_PCM_IMPULSE_CAPTURE, 66 #endif 67 BIT_PAUSE_PLAYBACK, 68 BIT_PREPARED, 69 70 /* individual masks: */ 71 /* *INDENT-OFF* */ 72 MASK_PCM_ALSA_PLAYBACK = 1 << BIT_PCM_ALSA_PLAYBACK, 73 MASK_PCM_ALSA_CAPTURE = 1 << BIT_PCM_ALSA_CAPTURE, 74 MASK_PCM_MONITOR_PLAYBACK = 1 << BIT_PCM_MONITOR_PLAYBACK, 75 MASK_PCM_MONITOR_CAPTURE = 1 << BIT_PCM_MONITOR_CAPTURE, 76 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 77 MASK_PCM_IMPULSE_PLAYBACK = 1 << BIT_PCM_IMPULSE_PLAYBACK, 78 MASK_PCM_IMPULSE_CAPTURE = 1 << BIT_PCM_IMPULSE_CAPTURE, 79 #endif 80 MASK_PAUSE_PLAYBACK = 1 << BIT_PAUSE_PLAYBACK, 81 MASK_PREPARED = 1 << BIT_PREPARED, 82 /* *INDENT-ON* */ 83 84 /* combined masks (by operation): */ 85 MASK_PCM_ALSA = MASK_PCM_ALSA_PLAYBACK | MASK_PCM_ALSA_CAPTURE, 86 MASK_PCM_MONITOR = MASK_PCM_MONITOR_PLAYBACK | MASK_PCM_MONITOR_CAPTURE, 87 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 88 MASK_PCM_IMPULSE = MASK_PCM_IMPULSE_PLAYBACK | MASK_PCM_IMPULSE_CAPTURE, 89 #endif 90 91 /* combined masks (by direction): */ 92 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 93 MASK_PLAYBACK = 94 MASK_PCM_ALSA_PLAYBACK | MASK_PCM_MONITOR_PLAYBACK | 95 MASK_PCM_IMPULSE_PLAYBACK, 96 MASK_CAPTURE = 97 MASK_PCM_ALSA_CAPTURE | MASK_PCM_MONITOR_CAPTURE | 98 MASK_PCM_IMPULSE_CAPTURE 99 #else 100 MASK_PLAYBACK = MASK_PCM_ALSA_PLAYBACK | MASK_PCM_MONITOR_PLAYBACK, 101 MASK_CAPTURE = MASK_PCM_ALSA_CAPTURE | MASK_PCM_MONITOR_CAPTURE 102 #endif 103 }; 104 105 struct line6_pcm_properties { 106 struct snd_pcm_hardware snd_line6_playback_hw, snd_line6_capture_hw; 107 struct snd_pcm_hw_constraint_ratdens snd_line6_rates; 108 int bytes_per_frame; 109 }; 110 111 struct snd_line6_pcm { 112 /** 113 Pointer back to the Line6 driver data structure. 114 */ 115 struct usb_line6 *line6; 116 117 /** 118 Properties. 119 */ 120 struct line6_pcm_properties *properties; 121 122 /** 123 ALSA pcm stream 124 */ 125 struct snd_pcm *pcm; 126 127 /** 128 URBs for audio playback. 129 */ 130 struct urb *urb_audio_out[LINE6_ISO_BUFFERS]; 131 132 /** 133 URBs for audio capture. 134 */ 135 struct urb *urb_audio_in[LINE6_ISO_BUFFERS]; 136 137 /** 138 Temporary buffer for playback. 139 Since the packet size is not known in advance, this buffer is 140 large enough to store maximum size packets. 141 */ 142 unsigned char *buffer_out; 143 144 /** 145 Temporary buffer for capture. 146 Since the packet size is not known in advance, this buffer is 147 large enough to store maximum size packets. 148 */ 149 unsigned char *buffer_in; 150 151 /** 152 Temporary buffer index for playback. 153 */ 154 int index_out; 155 156 /** 157 Previously captured frame (for software monitoring). 158 */ 159 unsigned char *prev_fbuf; 160 161 /** 162 Size of previously captured frame (for software monitoring). 163 */ 164 int prev_fsize; 165 166 /** 167 Free frame position in the playback buffer. 168 */ 169 snd_pcm_uframes_t pos_out; 170 171 /** 172 Count processed bytes for playback. 173 This is modulo period size (to determine when a period is 174 finished). 175 */ 176 unsigned bytes_out; 177 178 /** 179 Counter to create desired playback sample rate. 180 */ 181 unsigned count_out; 182 183 /** 184 Playback period size in bytes 185 */ 186 unsigned period_out; 187 188 /** 189 Processed frame position in the playback buffer. 190 The contents of the output ring buffer have been consumed by 191 the USB subsystem (i.e., sent to the USB device) up to this 192 position. 193 */ 194 snd_pcm_uframes_t pos_out_done; 195 196 /** 197 Count processed bytes for capture. 198 This is modulo period size (to determine when a period is 199 finished). 200 */ 201 unsigned bytes_in; 202 203 /** 204 Counter to create desired capture sample rate. 205 */ 206 unsigned count_in; 207 208 /** 209 Capture period size in bytes 210 */ 211 unsigned period_in; 212 213 /** 214 Processed frame position in the capture buffer. 215 The contents of the output ring buffer have been consumed by 216 the USB subsystem (i.e., sent to the USB device) up to this 217 position. 218 */ 219 snd_pcm_uframes_t pos_in_done; 220 221 /** 222 Bit mask of active playback URBs. 223 */ 224 unsigned long active_urb_out; 225 226 /** 227 Maximum size of USB packet. 228 */ 229 int max_packet_size; 230 231 /** 232 USB endpoint for listening to audio data. 233 */ 234 int ep_audio_read; 235 236 /** 237 USB endpoint for writing audio data. 238 */ 239 int ep_audio_write; 240 241 /** 242 Bit mask of active capture URBs. 243 */ 244 unsigned long active_urb_in; 245 246 /** 247 Bit mask of playback URBs currently being unlinked. 248 */ 249 unsigned long unlink_urb_out; 250 251 /** 252 Bit mask of capture URBs currently being unlinked. 253 */ 254 unsigned long unlink_urb_in; 255 256 /** 257 Spin lock to protect updates of the playback buffer positions (not 258 contents!) 259 */ 260 spinlock_t lock_audio_out; 261 262 /** 263 Spin lock to protect updates of the capture buffer positions (not 264 contents!) 265 */ 266 spinlock_t lock_audio_in; 267 268 /** 269 Spin lock to protect trigger. 270 */ 271 spinlock_t lock_trigger; 272 273 /** 274 PCM playback volume (left and right). 275 */ 276 int volume_playback[2]; 277 278 /** 279 PCM monitor volume. 280 */ 281 int volume_monitor; 282 283 #ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 284 /** 285 Volume of impulse response test signal (if zero, test is disabled). 286 */ 287 int impulse_volume; 288 289 /** 290 Period of impulse response test signal. 291 */ 292 int impulse_period; 293 294 /** 295 Counter for impulse response test signal. 296 */ 297 int impulse_count; 298 #endif 299 300 /** 301 Several status bits (see BIT_*). 302 */ 303 unsigned long flags; 304 305 int last_frame_in, last_frame_out; 306 }; 307 308 extern int line6_init_pcm(struct usb_line6 *line6, 309 struct line6_pcm_properties *properties); 310 extern int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd); 311 extern int snd_line6_prepare(struct snd_pcm_substream *substream); 312 extern void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm); 313 extern int line6_pcm_start(struct snd_line6_pcm *line6pcm, int channels); 314 extern int line6_pcm_stop(struct snd_line6_pcm *line6pcm, int channels); 315 316 #define PRINT_FRAME_DIFF(op) { \ 317 static int diff_prev = 1000; \ 318 int diff = line6pcm->last_frame_out - line6pcm->last_frame_in; \ 319 if ((diff != diff_prev) && (abs(diff) < 100)) { \ 320 printk(KERN_INFO "%s frame diff = %d\n", op, diff); \ 321 diff_prev = diff; \ 322 } \ 323 } 324 325 #endif 326