1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Focusrite Control Protocol Driver for ALSA
4 *
5 * Copyright (c) 2024-2025 by Geoffrey D. Bennett <g at b4.vu>
6 */
7 /*
8 * DOC: Theory of Operation
9 *
10 * The Focusrite Control Protocol (FCP) driver provides a minimal
11 * kernel interface that allows a user-space driver (primarily
12 * fcp-server) to communicate with Focusrite USB audio interfaces
13 * using their vendor-specific protocol. This protocol is used by
14 * Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, Clarett+, and
15 * Vocaster series devices.
16 *
17 * Unlike the existing scarlett2 driver which implements all controls
18 * in kernel space, this driver takes a lighter-weight approach by
19 * moving most functionality to user space. The only control
20 * implemented in kernel space is the Level Meter, since it requires
21 * frequent polling of volatile data.
22 *
23 * The driver provides an hwdep interface that allows the user-space
24 * driver to:
25 * - Initialise the protocol
26 * - Send arbitrary FCP commands to the device
27 * - Receive notifications from the device
28 * - Configure the Level Meter control
29 *
30 * Usage Flow
31 * ----------
32 * 1. Open the hwdep device (requires CAP_SYS_RAWIO)
33 * 2. Get protocol version using FCP_IOCTL_PVERSION
34 * 3. Initialise protocol using FCP_IOCTL_INIT
35 * 4. Send commands using FCP_IOCTL_CMD
36 * 5. Receive notifications using read()
37 * 6. Optionally set up the Level Meter control using
38 * FCP_IOCTL_SET_METER_MAP
39 * 7. Optionally add labels to the Level Meter control using
40 * FCP_IOCTL_SET_METER_LABELS
41 *
42 * Level Meter
43 * -----------
44 * The Level Meter is implemented as an ALSA control that provides
45 * real-time level monitoring. When the control is read, the driver
46 * requests the current meter levels from the device, translates the
47 * levels using the configured mapping, and returns the result to the
48 * user. The mapping between device meters and the ALSA control's
49 * channels is configured with FCP_IOCTL_SET_METER_MAP.
50 *
51 * Labels for the Level Meter channels can be set using
52 * FCP_IOCTL_SET_METER_LABELS and read by applications through the
53 * control's TLV data. The labels are transferred as a sequence of
54 * null-terminated strings.
55 */
56
57 #include <linux/slab.h>
58 #include <linux/usb.h>
59
60 #include <sound/control.h>
61 #include <sound/hwdep.h>
62 #include <sound/tlv.h>
63
64 #include <uapi/sound/fcp.h>
65
66 #include "usbaudio.h"
67 #include "mixer.h"
68 #include "helper.h"
69
70 #include "fcp.h"
71
72 /* notify waiting to send to *file */
73 struct fcp_notify {
74 wait_queue_head_t queue;
75 u32 event;
76 spinlock_t lock;
77 };
78
79 struct fcp_data {
80 struct usb_mixer_interface *mixer;
81
82 struct mutex mutex; /* serialise access to the device */
83 struct completion cmd_done; /* wait for command completion */
84 struct file *file; /* hwdep file */
85 struct urb *urb; /* FCP notification endpoint */
86
87 struct fcp_notify notify;
88
89 u8 bInterfaceNumber;
90 u8 bEndpointAddress;
91 u16 wMaxPacketSize;
92 u8 bInterval;
93
94 uint16_t step0_resp_size;
95 uint16_t step2_resp_size;
96 uint32_t init1_opcode;
97 uint32_t init2_opcode;
98
99 u8 init;
100 u16 seq;
101
102 u8 num_meter_slots;
103 s16 *meter_level_map;
104 __le32 *meter_levels;
105 struct snd_kcontrol *meter_ctl;
106
107 unsigned int *meter_labels_tlv;
108 int meter_labels_tlv_size;
109 };
110
111 /*** USB Interactions ***/
112
113 /* FCP Command ACK notification bit */
114 #define FCP_NOTIFY_ACK 1
115
116 /* Vendor-specific USB control requests */
117 #define FCP_USB_REQ_STEP0 0
118 #define FCP_USB_REQ_CMD_TX 2
119 #define FCP_USB_REQ_CMD_RX 3
120
121 /* Focusrite Control Protocol opcodes that the kernel side needs to
122 * know about
123 */
124 #define FCP_USB_REBOOT 0x00000003
125 #define FCP_USB_GET_METER 0x00001001
126 #define FCP_USB_FLASH_ERASE 0x00004002
127 #define FCP_USB_FLASH_WRITE 0x00004004
128
129 #define FCP_USB_METER_LEVELS_GET_MAGIC 1
130
131 #define FCP_SEGMENT_APP_GOLD 0
132
133 #define FCP_MAX_METER_MAP_SIZE \
134 (sizeof_field(struct snd_ctl_elem_value, value.integer.value) / \
135 sizeof(long))
136
137 /* Forward declarations */
138 static int fcp_init(struct usb_mixer_interface *mixer,
139 void *step0_resp, void *step2_resp);
140
141 /* FCP command request/response format */
142 struct fcp_usb_packet {
143 __le32 opcode;
144 __le16 size;
145 __le16 seq;
146 __le32 error;
147 __le32 pad;
148 u8 data[];
149 };
150
fcp_fill_request_header(struct fcp_data * private,struct fcp_usb_packet * req,u32 opcode,u16 req_size)151 static void fcp_fill_request_header(struct fcp_data *private,
152 struct fcp_usb_packet *req,
153 u32 opcode, u16 req_size)
154 {
155 /* sequence must go up by 1 for each request */
156 u16 seq = private->seq++;
157
158 req->opcode = cpu_to_le32(opcode);
159 req->size = cpu_to_le16(req_size);
160 req->seq = cpu_to_le16(seq);
161 req->error = 0;
162 req->pad = 0;
163 }
164
fcp_usb_tx(struct usb_device * dev,int interface,void * buf,u16 size)165 static int fcp_usb_tx(struct usb_device *dev, int interface,
166 void *buf, u16 size)
167 {
168 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
169 FCP_USB_REQ_CMD_TX,
170 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
171 0, interface, buf, size);
172 }
173
fcp_usb_rx(struct usb_device * dev,int interface,void * buf,u16 size)174 static int fcp_usb_rx(struct usb_device *dev, int interface,
175 void *buf, u16 size)
176 {
177 return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
178 FCP_USB_REQ_CMD_RX,
179 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
180 0, interface, buf, size);
181 }
182
183 /* Send an FCP command and get the response */
fcp_usb(struct usb_mixer_interface * mixer,u32 opcode,const void * req_data,u16 req_size,void * resp_data,u16 resp_size)184 static int fcp_usb(struct usb_mixer_interface *mixer, u32 opcode,
185 const void *req_data, u16 req_size,
186 void *resp_data, u16 resp_size)
187 {
188 struct fcp_data *private = mixer->private_data;
189 struct usb_device *dev = mixer->chip->dev;
190 int retries = 0;
191 const int max_retries = 5;
192 int err;
193
194 CLASS(snd_usb_lock, pm)(mixer->chip);
195 if (pm.err < 0)
196 return -EIO;
197
198 if (!private->urb)
199 return -ENODEV;
200
201 struct fcp_usb_packet *req __free(kfree) = NULL;
202 size_t req_buf_size = struct_size(req, data, req_size);
203 req = kmalloc_flex(*req, data, req_size);
204 if (!req)
205 return -ENOMEM;
206
207 struct fcp_usb_packet *resp __free(kfree) = NULL;
208 size_t resp_buf_size = struct_size(resp, data, resp_size);
209 resp = kmalloc_flex(*resp, data, resp_size);
210 if (!resp)
211 return -ENOMEM;
212
213 /* build request message */
214 fcp_fill_request_header(private, req, opcode, req_size);
215 if (req_size)
216 memcpy(req->data, req_data, req_size);
217
218 /* send the request and retry on EPROTO */
219 retry:
220 err = fcp_usb_tx(dev, private->bInterfaceNumber, req, req_buf_size);
221 if (err == -EPROTO && ++retries <= max_retries) {
222 msleep(1 << (retries - 1));
223 goto retry;
224 }
225
226 if (err != req_buf_size) {
227 usb_audio_err(mixer->chip,
228 "FCP request %08x failed: %d\n", opcode, err);
229 return -EINVAL;
230 }
231
232 if (!wait_for_completion_timeout(&private->cmd_done,
233 msecs_to_jiffies(1000))) {
234 usb_audio_err(mixer->chip,
235 "FCP request %08x timed out\n", opcode);
236
237 return -ETIMEDOUT;
238 }
239
240 /* send a second message to get the response */
241 err = fcp_usb_rx(dev, private->bInterfaceNumber, resp, resp_buf_size);
242
243 /* validate the response */
244
245 if (err < 0) {
246
247 /* ESHUTDOWN and EPROTO are valid responses to a
248 * reboot request
249 */
250 if (opcode == FCP_USB_REBOOT &&
251 (err == -ESHUTDOWN || err == -EPROTO))
252 return 0;
253
254 usb_audio_err(mixer->chip,
255 "FCP read response %08x failed: %d\n",
256 opcode, err);
257 return -EINVAL;
258 }
259
260 if (err < sizeof(*resp)) {
261 usb_audio_err(mixer->chip,
262 "FCP response %08x too short: %d\n",
263 opcode, err);
264 return -EINVAL;
265 }
266
267 if (req->seq != resp->seq) {
268 usb_audio_err(mixer->chip,
269 "FCP response %08x seq mismatch %d/%d\n",
270 opcode,
271 le16_to_cpu(req->seq), le16_to_cpu(resp->seq));
272 return -EINVAL;
273 }
274
275 if (req->opcode != resp->opcode) {
276 usb_audio_err(mixer->chip,
277 "FCP response %08x opcode mismatch %08x\n",
278 opcode, le32_to_cpu(resp->opcode));
279 return -EINVAL;
280 }
281
282 if (resp->error) {
283 usb_audio_err(mixer->chip,
284 "FCP response %08x error %d\n",
285 opcode, le32_to_cpu(resp->error));
286 return -EINVAL;
287 }
288
289 if (err != resp_buf_size) {
290 usb_audio_err(mixer->chip,
291 "FCP response %08x buffer size mismatch %d/%zu\n",
292 opcode, err, resp_buf_size);
293 return -EINVAL;
294 }
295
296 if (resp_size != le16_to_cpu(resp->size)) {
297 usb_audio_err(mixer->chip,
298 "FCP response %08x size mismatch %d/%d\n",
299 opcode, resp_size, le16_to_cpu(resp->size));
300 return -EINVAL;
301 }
302
303 if (resp_data && resp_size > 0)
304 memcpy(resp_data, resp->data, resp_size);
305
306 return 0;
307 }
308
fcp_reinit(struct usb_mixer_interface * mixer)309 static int fcp_reinit(struct usb_mixer_interface *mixer)
310 {
311 struct fcp_data *private = mixer->private_data;
312
313 if (private->urb)
314 return 0;
315
316 void *step0_resp __free(kfree) =
317 kmalloc(private->step0_resp_size, GFP_KERNEL);
318 if (!step0_resp)
319 return -ENOMEM;
320
321 void *step2_resp __free(kfree) =
322 kmalloc(private->step2_resp_size, GFP_KERNEL);
323 if (!step2_resp)
324 return -ENOMEM;
325
326 return fcp_init(mixer, step0_resp, step2_resp);
327 }
328
329 /*** Control Functions ***/
330
331 /* helper function to create a new control */
fcp_add_new_ctl(struct usb_mixer_interface * mixer,const struct snd_kcontrol_new * ncontrol,int index,int channels,const char * name,struct snd_kcontrol ** kctl_return)332 static int fcp_add_new_ctl(struct usb_mixer_interface *mixer,
333 const struct snd_kcontrol_new *ncontrol,
334 int index, int channels, const char *name,
335 struct snd_kcontrol **kctl_return)
336 {
337 struct snd_kcontrol *kctl;
338 struct usb_mixer_elem_info *elem;
339 int err;
340
341 elem = kzalloc_obj(*elem);
342 if (!elem)
343 return -ENOMEM;
344
345 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
346 * ignores them for resume and other operations.
347 * Also, the head.id field is set to 0, as we don't use this field.
348 */
349 elem->head.mixer = mixer;
350 elem->control = index;
351 elem->head.id = 0;
352 elem->channels = channels;
353 elem->val_type = USB_MIXER_BESPOKEN;
354
355 kctl = snd_ctl_new1(ncontrol, elem);
356 if (!kctl) {
357 kfree(elem);
358 return -ENOMEM;
359 }
360 kctl->private_free = snd_usb_mixer_elem_free;
361
362 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
363
364 err = snd_usb_mixer_add_control(&elem->head, kctl);
365 if (err < 0)
366 return err;
367
368 if (kctl_return)
369 *kctl_return = kctl;
370
371 return 0;
372 }
373
374 /*** Level Meter Control ***/
375
fcp_meter_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)376 static int fcp_meter_ctl_info(struct snd_kcontrol *kctl,
377 struct snd_ctl_elem_info *uinfo)
378 {
379 struct usb_mixer_elem_info *elem = kctl->private_data;
380
381 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
382 uinfo->count = elem->channels;
383 uinfo->value.integer.min = 0;
384 uinfo->value.integer.max = 4095;
385 uinfo->value.integer.step = 1;
386 return 0;
387 }
388
fcp_meter_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)389 static int fcp_meter_ctl_get(struct snd_kcontrol *kctl,
390 struct snd_ctl_elem_value *ucontrol)
391 {
392 struct usb_mixer_elem_info *elem = kctl->private_data;
393 struct usb_mixer_interface *mixer = elem->head.mixer;
394 struct fcp_data *private = mixer->private_data;
395 int num_meter_slots, resp_size;
396 __le32 *resp = private->meter_levels;
397 int i, err = 0;
398
399 struct {
400 __le16 pad;
401 __le16 num_meters;
402 __le32 magic;
403 } __packed req;
404
405 guard(mutex)(&private->mutex);
406
407 err = fcp_reinit(mixer);
408 if (err < 0)
409 return err;
410
411 num_meter_slots = private->num_meter_slots;
412 resp_size = num_meter_slots * sizeof(u32);
413
414 req.pad = 0;
415 req.num_meters = cpu_to_le16(num_meter_slots);
416 req.magic = cpu_to_le32(FCP_USB_METER_LEVELS_GET_MAGIC);
417 err = fcp_usb(mixer, FCP_USB_GET_METER,
418 &req, sizeof(req), resp, resp_size);
419 if (err < 0)
420 return err;
421
422 if (WARN_ON_ONCE(elem->channels > FCP_MAX_METER_MAP_SIZE))
423 return -EINVAL;
424
425 /* copy & translate from resp[] using meter_level_map[] */
426 for (i = 0; i < elem->channels; i++) {
427 int idx = private->meter_level_map[i];
428 int value = idx < 0 ? 0 : le32_to_cpu(resp[idx]);
429
430 ucontrol->value.integer.value[i] = value;
431 }
432
433 return 0;
434 }
435
fcp_meter_tlv_callback(struct snd_kcontrol * kctl,int op_flag,unsigned int size,unsigned int __user * tlv)436 static int fcp_meter_tlv_callback(struct snd_kcontrol *kctl,
437 int op_flag, unsigned int size,
438 unsigned int __user *tlv)
439 {
440 struct usb_mixer_elem_info *elem = kctl->private_data;
441 struct usb_mixer_interface *mixer = elem->head.mixer;
442 struct fcp_data *private = mixer->private_data;
443
444 guard(mutex)(&private->mutex);
445
446 if (op_flag == SNDRV_CTL_TLV_OP_READ) {
447 if (private->meter_labels_tlv_size == 0)
448 return 0;
449
450 if (size > private->meter_labels_tlv_size)
451 size = private->meter_labels_tlv_size;
452
453 if (copy_to_user(tlv, private->meter_labels_tlv, size))
454 return -EFAULT;
455
456 return size;
457 }
458
459 return -EINVAL;
460 }
461
462 static const struct snd_kcontrol_new fcp_meter_ctl = {
463 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
464 .access = SNDRV_CTL_ELEM_ACCESS_READ |
465 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
466 .info = fcp_meter_ctl_info,
467 .get = fcp_meter_ctl_get,
468 .tlv = { .c = fcp_meter_tlv_callback },
469 };
470
471 /*** hwdep interface ***/
472
473 /* FCP initialisation */
fcp_ioctl_init(struct usb_mixer_interface * mixer,struct fcp_init __user * arg)474 static int fcp_ioctl_init(struct usb_mixer_interface *mixer,
475 struct fcp_init __user *arg)
476 {
477 struct fcp_init init;
478 struct usb_device *dev = mixer->chip->dev;
479 struct fcp_data *private = mixer->private_data;
480 void *step2_resp;
481 int err, buf_size;
482
483 if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
484 return -EINVAL;
485
486 /* Get initialisation parameters */
487 if (copy_from_user(&init, arg, sizeof(init)))
488 return -EFAULT;
489
490 /* Validate the response sizes */
491 if (init.step0_resp_size < 1 ||
492 init.step0_resp_size > 255 ||
493 init.step2_resp_size < 1 ||
494 init.step2_resp_size > 255)
495 return -EINVAL;
496
497 /* Allocate response buffer */
498 buf_size = init.step0_resp_size + init.step2_resp_size;
499
500 void *resp __free(kfree) =
501 kzalloc(buf_size, GFP_KERNEL);
502 if (!resp)
503 return -ENOMEM;
504
505 private->step0_resp_size = init.step0_resp_size;
506 private->step2_resp_size = init.step2_resp_size;
507 private->init1_opcode = init.init1_opcode;
508 private->init2_opcode = init.init2_opcode;
509
510 step2_resp = resp + private->step0_resp_size;
511
512 err = fcp_init(mixer, resp, step2_resp);
513 if (err < 0)
514 return err;
515
516 if (copy_to_user(arg->resp, resp, buf_size))
517 return -EFAULT;
518
519 return 0;
520 }
521
522 /* Check that the command is allowed
523 * Don't permit erasing/writing segment 0 (App_Gold)
524 */
fcp_validate_cmd(u32 opcode,void * data,u16 size)525 static int fcp_validate_cmd(u32 opcode, void *data, u16 size)
526 {
527 if (opcode == FCP_USB_FLASH_ERASE) {
528 struct {
529 __le32 segment_num;
530 __le32 pad;
531 } __packed *req = data;
532
533 if (size != sizeof(*req))
534 return -EINVAL;
535
536 if (le32_to_cpu(req->segment_num) == FCP_SEGMENT_APP_GOLD)
537 return -EPERM;
538
539 if (req->pad != 0)
540 return -EINVAL;
541
542 } else if (opcode == FCP_USB_FLASH_WRITE) {
543 struct {
544 __le32 segment_num;
545 __le32 offset;
546 __le32 pad;
547 u8 data[];
548 } __packed *req = data;
549
550 if (size < sizeof(*req))
551 return -EINVAL;
552
553 if (le32_to_cpu(req->segment_num) == FCP_SEGMENT_APP_GOLD)
554 return -EPERM;
555
556 if (req->pad != 0)
557 return -EINVAL;
558 }
559
560 return 0;
561 }
562
563 /* Execute an FCP command specified by the user */
fcp_ioctl_cmd(struct usb_mixer_interface * mixer,struct fcp_cmd __user * arg)564 static int fcp_ioctl_cmd(struct usb_mixer_interface *mixer,
565 struct fcp_cmd __user *arg)
566 {
567 struct fcp_cmd cmd;
568 int err, buf_size;
569 void *data __free(kfree) = NULL;
570
571 /* get opcode and request/response size */
572 if (copy_from_user(&cmd, arg, sizeof(cmd)))
573 return -EFAULT;
574
575 /* validate request and response sizes */
576 if (cmd.req_size > 4096 || cmd.resp_size > 4096)
577 return -EINVAL;
578
579 /* reinit if needed */
580 err = fcp_reinit(mixer);
581 if (err < 0)
582 return err;
583
584 /* allocate request/response buffer */
585 buf_size = max(cmd.req_size, cmd.resp_size);
586
587 if (buf_size > 0) {
588 data = kmalloc(buf_size, GFP_KERNEL);
589 if (!data)
590 return -ENOMEM;
591 }
592
593 /* copy request from user */
594 if (cmd.req_size > 0)
595 if (copy_from_user(data, arg->data, cmd.req_size))
596 return -EFAULT;
597
598 /* check that the command is allowed */
599 err = fcp_validate_cmd(cmd.opcode, data, cmd.req_size);
600 if (err < 0)
601 return err;
602
603 /* send request, get response */
604 err = fcp_usb(mixer, cmd.opcode,
605 data, cmd.req_size, data, cmd.resp_size);
606 if (err < 0)
607 return err;
608
609 /* copy response to user */
610 if (cmd.resp_size > 0)
611 if (copy_to_user(arg->data, data, cmd.resp_size))
612 return -EFAULT;
613
614 return 0;
615 }
616
617 /* Validate the Level Meter map passed by the user */
validate_meter_map(const s16 * map,int map_size,int meter_slots)618 static int validate_meter_map(const s16 *map, int map_size, int meter_slots)
619 {
620 int i;
621
622 for (i = 0; i < map_size; i++)
623 if (map[i] < -1 || map[i] >= meter_slots)
624 return -EINVAL;
625
626 return 0;
627 }
628
629 /* Set the Level Meter map and add the control */
fcp_ioctl_set_meter_map(struct usb_mixer_interface * mixer,struct fcp_meter_map __user * arg)630 static int fcp_ioctl_set_meter_map(struct usb_mixer_interface *mixer,
631 struct fcp_meter_map __user *arg)
632 {
633 struct fcp_meter_map map;
634 struct fcp_data *private = mixer->private_data;
635 int err;
636
637 if (copy_from_user(&map, arg, sizeof(map)))
638 return -EFAULT;
639
640 /* Don't allow changing the map size or meter slots once set */
641 if (private->meter_ctl) {
642 struct usb_mixer_elem_info *elem =
643 private->meter_ctl->private_data;
644
645 if (map.map_size != elem->channels ||
646 map.meter_slots != private->num_meter_slots)
647 return -EINVAL;
648 }
649
650 /* Validate the map size */
651 if (map.map_size < 1 ||
652 map.map_size > FCP_MAX_METER_MAP_SIZE ||
653 map.meter_slots < 1 || map.meter_slots > 255)
654 return -EINVAL;
655
656 /* Allocate and copy the map data */
657 s16 *tmp_map __free(kfree) =
658 memdup_array_user(arg->map, map.map_size, sizeof(s16));
659 if (IS_ERR(tmp_map))
660 return PTR_ERR(tmp_map);
661
662 err = validate_meter_map(tmp_map, map.map_size, map.meter_slots);
663 if (err < 0)
664 return err;
665
666 /* If the control doesn't exist, create it */
667 if (!private->meter_ctl) {
668 /* Allocate buffer for the map */
669 s16 *new_map __free(kfree) =
670 kmalloc_objs(s16, map.map_size);
671 if (!new_map)
672 return -ENOMEM;
673
674 /* Allocate buffer for reading meter levels */
675 __le32 *meter_levels __free(kfree) =
676 kmalloc_array(map.meter_slots, sizeof(__le32),
677 GFP_KERNEL);
678 if (!meter_levels)
679 return -ENOMEM;
680
681 /* Create the Level Meter control */
682 err = fcp_add_new_ctl(mixer, &fcp_meter_ctl, 0, map.map_size,
683 "Level Meter", &private->meter_ctl);
684 if (err < 0)
685 return err;
686
687 /* Success; save the pointers in private and don't free them */
688 private->meter_level_map = new_map;
689 private->meter_levels = meter_levels;
690 private->num_meter_slots = map.meter_slots;
691 new_map = NULL;
692 meter_levels = NULL;
693 }
694
695 /* Install the new map */
696 memcpy(private->meter_level_map, tmp_map, map.map_size * sizeof(s16));
697
698 return 0;
699 }
700
701 /* Set the Level Meter labels */
fcp_ioctl_set_meter_labels(struct usb_mixer_interface * mixer,struct fcp_meter_labels __user * arg)702 static int fcp_ioctl_set_meter_labels(struct usb_mixer_interface *mixer,
703 struct fcp_meter_labels __user *arg)
704 {
705 struct fcp_meter_labels labels;
706 struct fcp_data *private = mixer->private_data;
707 unsigned int *tlv_data;
708 unsigned int tlv_size, data_size;
709
710 if (copy_from_user(&labels, arg, sizeof(labels)))
711 return -EFAULT;
712
713 /* Remove existing labels if size is zero */
714 if (!labels.labels_size) {
715
716 /* Clear TLV read/callback bits if labels were present */
717 if (private->meter_labels_tlv) {
718 private->meter_ctl->vd[0].access &=
719 ~(SNDRV_CTL_ELEM_ACCESS_TLV_READ |
720 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK);
721 snd_ctl_notify(mixer->chip->card,
722 SNDRV_CTL_EVENT_MASK_INFO,
723 &private->meter_ctl->id);
724 }
725
726 kfree(private->meter_labels_tlv);
727 private->meter_labels_tlv = NULL;
728 private->meter_labels_tlv_size = 0;
729
730 return 0;
731 }
732
733 /* Validate size */
734 if (labels.labels_size > 4096)
735 return -EINVAL;
736
737 /* Calculate padded data size */
738 data_size = ALIGN(labels.labels_size, sizeof(unsigned int));
739
740 /* Calculate total TLV size including header */
741 tlv_size = sizeof(unsigned int) * 2 + data_size;
742
743 /* Allocate, set up TLV header, and copy the labels data */
744 tlv_data = kzalloc(tlv_size, GFP_KERNEL);
745 if (!tlv_data)
746 return -ENOMEM;
747 tlv_data[0] = SNDRV_CTL_TLVT_FCP_CHANNEL_LABELS;
748 tlv_data[1] = data_size;
749 if (copy_from_user(&tlv_data[2], arg->labels, labels.labels_size)) {
750 kfree(tlv_data);
751 return -EFAULT;
752 }
753
754 /* Set TLV read/callback bits if labels weren't present */
755 if (!private->meter_labels_tlv) {
756 private->meter_ctl->vd[0].access |=
757 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
758 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
759 snd_ctl_notify(mixer->chip->card,
760 SNDRV_CTL_EVENT_MASK_INFO,
761 &private->meter_ctl->id);
762 }
763
764 /* Swap in the new labels */
765 kfree(private->meter_labels_tlv);
766 private->meter_labels_tlv = tlv_data;
767 private->meter_labels_tlv_size = tlv_size;
768
769 return 0;
770 }
771
fcp_hwdep_open(struct snd_hwdep * hw,struct file * file)772 static int fcp_hwdep_open(struct snd_hwdep *hw, struct file *file)
773 {
774 struct usb_mixer_interface *mixer = hw->private_data;
775 struct fcp_data *private = mixer->private_data;
776
777 if (!capable(CAP_SYS_RAWIO))
778 return -EPERM;
779
780 private->file = file;
781
782 return 0;
783 }
784
fcp_hwdep_ioctl(struct snd_hwdep * hw,struct file * file,unsigned int cmd,unsigned long arg)785 static int fcp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
786 unsigned int cmd, unsigned long arg)
787 {
788 struct usb_mixer_interface *mixer = hw->private_data;
789 struct fcp_data *private = mixer->private_data;
790 void __user *argp = (void __user *)arg;
791
792 guard(mutex)(&private->mutex);
793
794 switch (cmd) {
795
796 case FCP_IOCTL_PVERSION:
797 return put_user(FCP_HWDEP_VERSION,
798 (int __user *)argp) ? -EFAULT : 0;
799 break;
800
801 case FCP_IOCTL_INIT:
802 return fcp_ioctl_init(mixer, argp);
803
804 case FCP_IOCTL_CMD:
805 if (!private->init)
806 return -EINVAL;
807 return fcp_ioctl_cmd(mixer, argp);
808
809 case FCP_IOCTL_SET_METER_MAP:
810 if (!private->init)
811 return -EINVAL;
812 return fcp_ioctl_set_meter_map(mixer, argp);
813
814 case FCP_IOCTL_SET_METER_LABELS:
815 if (!private->init)
816 return -EINVAL;
817 if (!private->meter_ctl)
818 return -EINVAL;
819 return fcp_ioctl_set_meter_labels(mixer, argp);
820
821 default:
822 return -ENOIOCTLCMD;
823 }
824
825 /* not reached */
826 }
827
fcp_hwdep_read(struct snd_hwdep * hw,char __user * buf,long count,loff_t * offset)828 static long fcp_hwdep_read(struct snd_hwdep *hw, char __user *buf,
829 long count, loff_t *offset)
830 {
831 struct usb_mixer_interface *mixer = hw->private_data;
832 struct fcp_data *private = mixer->private_data;
833 long ret = 0;
834 u32 event;
835
836 if (count < sizeof(event))
837 return -EINVAL;
838
839 ret = wait_event_interruptible(private->notify.queue,
840 private->notify.event);
841 if (ret)
842 return ret;
843
844 scoped_guard(spinlock_irqsave, &private->notify.lock) {
845 event = private->notify.event;
846 private->notify.event = 0;
847 }
848
849 if (copy_to_user(buf, &event, sizeof(event)))
850 return -EFAULT;
851
852 return sizeof(event);
853 }
854
fcp_hwdep_poll(struct snd_hwdep * hw,struct file * file,poll_table * wait)855 static __poll_t fcp_hwdep_poll(struct snd_hwdep *hw,
856 struct file *file,
857 poll_table *wait)
858 {
859 struct usb_mixer_interface *mixer = hw->private_data;
860 struct fcp_data *private = mixer->private_data;
861 __poll_t mask = 0;
862
863 poll_wait(file, &private->notify.queue, wait);
864
865 if (private->notify.event)
866 mask |= EPOLLIN | EPOLLRDNORM;
867
868 return mask;
869 }
870
fcp_hwdep_release(struct snd_hwdep * hw,struct file * file)871 static int fcp_hwdep_release(struct snd_hwdep *hw, struct file *file)
872 {
873 struct usb_mixer_interface *mixer = hw->private_data;
874 struct fcp_data *private = mixer->private_data;
875
876 if (!private)
877 return 0;
878
879 private->file = NULL;
880
881 return 0;
882 }
883
fcp_hwdep_init(struct usb_mixer_interface * mixer)884 static int fcp_hwdep_init(struct usb_mixer_interface *mixer)
885 {
886 struct snd_hwdep *hw;
887 int err;
888
889 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);
890 if (err < 0)
891 return err;
892
893 hw->private_data = mixer;
894 hw->exclusive = 1;
895 hw->ops.open = fcp_hwdep_open;
896 hw->ops.ioctl = fcp_hwdep_ioctl;
897 hw->ops.ioctl_compat = fcp_hwdep_ioctl;
898 hw->ops.read = fcp_hwdep_read;
899 hw->ops.poll = fcp_hwdep_poll;
900 hw->ops.release = fcp_hwdep_release;
901
902 return 0;
903 }
904
905 /*** Cleanup ***/
906
fcp_cleanup_urb(struct usb_mixer_interface * mixer)907 static void fcp_cleanup_urb(struct usb_mixer_interface *mixer)
908 {
909 struct fcp_data *private = mixer->private_data;
910
911 if (!private->urb)
912 return;
913
914 usb_kill_urb(private->urb);
915 kfree(private->urb->transfer_buffer);
916 usb_free_urb(private->urb);
917 private->urb = NULL;
918 }
919
fcp_private_free(struct usb_mixer_interface * mixer)920 static void fcp_private_free(struct usb_mixer_interface *mixer)
921 {
922 struct fcp_data *private = mixer->private_data;
923
924 fcp_cleanup_urb(mixer);
925
926 kfree(private->meter_level_map);
927 kfree(private->meter_levels);
928 kfree(private->meter_labels_tlv);
929 kfree(private);
930 mixer->private_data = NULL;
931 }
932
fcp_private_suspend(struct usb_mixer_interface * mixer)933 static void fcp_private_suspend(struct usb_mixer_interface *mixer)
934 {
935 fcp_cleanup_urb(mixer);
936 }
937
938 /*** Callbacks ***/
939
fcp_notify(struct urb * urb)940 static void fcp_notify(struct urb *urb)
941 {
942 struct usb_mixer_interface *mixer = urb->context;
943 struct fcp_data *private = mixer->private_data;
944 int len = urb->actual_length;
945 int ustatus = urb->status;
946 u32 data;
947
948 if (ustatus != 0 || len != 8)
949 goto requeue;
950
951 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
952
953 /* Handle command acknowledgement */
954 if (data & FCP_NOTIFY_ACK) {
955 complete(&private->cmd_done);
956 data &= ~FCP_NOTIFY_ACK;
957 }
958
959 if (data) {
960 scoped_guard(spinlock_irqsave, &private->notify.lock) {
961 private->notify.event |= data;
962 }
963
964 wake_up_interruptible(&private->notify.queue);
965 }
966
967 requeue:
968 if (ustatus != -ENOENT &&
969 ustatus != -ECONNRESET &&
970 ustatus != -ESHUTDOWN) {
971 urb->dev = mixer->chip->dev;
972 usb_submit_urb(urb, GFP_ATOMIC);
973 } else {
974 complete(&private->cmd_done);
975 }
976 }
977
978 /* Submit a URB to receive notifications from the device */
fcp_init_notify(struct usb_mixer_interface * mixer)979 static int fcp_init_notify(struct usb_mixer_interface *mixer)
980 {
981 struct usb_device *dev = mixer->chip->dev;
982 struct fcp_data *private = mixer->private_data;
983 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
984 void *transfer_buffer;
985 int err;
986
987 /* Already set up */
988 if (private->urb)
989 return 0;
990
991 if (usb_pipe_type_check(dev, pipe))
992 return -EINVAL;
993
994 private->urb = usb_alloc_urb(0, GFP_KERNEL);
995 if (!private->urb)
996 return -ENOMEM;
997
998 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
999 if (!transfer_buffer) {
1000 usb_free_urb(private->urb);
1001 private->urb = NULL;
1002 return -ENOMEM;
1003 }
1004
1005 usb_fill_int_urb(private->urb, dev, pipe,
1006 transfer_buffer, private->wMaxPacketSize,
1007 fcp_notify, mixer, private->bInterval);
1008
1009 reinit_completion(&private->cmd_done);
1010
1011 err = usb_submit_urb(private->urb, GFP_KERNEL);
1012 if (err) {
1013 usb_audio_err(mixer->chip,
1014 "%s: usb_submit_urb failed: %d\n",
1015 __func__, err);
1016 kfree(transfer_buffer);
1017 usb_free_urb(private->urb);
1018 private->urb = NULL;
1019 }
1020
1021 return err;
1022 }
1023
1024 /*** Initialisation ***/
1025
fcp_init(struct usb_mixer_interface * mixer,void * step0_resp,void * step2_resp)1026 static int fcp_init(struct usb_mixer_interface *mixer,
1027 void *step0_resp, void *step2_resp)
1028 {
1029 struct fcp_data *private = mixer->private_data;
1030 struct usb_device *dev = mixer->chip->dev;
1031 int err;
1032
1033 CLASS(snd_usb_lock, pm)(mixer->chip);
1034 if (pm.err < 0)
1035 return -EIO;
1036
1037 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1038 FCP_USB_REQ_STEP0,
1039 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1040 0, private->bInterfaceNumber,
1041 step0_resp, private->step0_resp_size);
1042 if (err < 0)
1043 return err;
1044 if (err != private->step0_resp_size)
1045 return -EIO;
1046
1047 err = fcp_init_notify(mixer);
1048 if (err < 0)
1049 return err;
1050
1051 private->seq = 0;
1052 private->init = 1;
1053
1054 err = fcp_usb(mixer, private->init1_opcode, NULL, 0, NULL, 0);
1055 if (err < 0)
1056 return err;
1057
1058 err = fcp_usb(mixer, private->init2_opcode,
1059 NULL, 0, step2_resp, private->step2_resp_size);
1060 if (err < 0)
1061 return err;
1062
1063 return 0;
1064 }
1065
fcp_init_private(struct usb_mixer_interface * mixer)1066 static int fcp_init_private(struct usb_mixer_interface *mixer)
1067 {
1068 struct fcp_data *private =
1069 kzalloc_obj(struct fcp_data);
1070
1071 if (!private)
1072 return -ENOMEM;
1073
1074 mutex_init(&private->mutex);
1075 init_completion(&private->cmd_done);
1076 init_waitqueue_head(&private->notify.queue);
1077 spin_lock_init(&private->notify.lock);
1078
1079 mixer->private_data = private;
1080 mixer->private_free = fcp_private_free;
1081 mixer->private_suspend = fcp_private_suspend;
1082
1083 private->mixer = mixer;
1084
1085 return 0;
1086 }
1087
1088 /* Look through the interface descriptors for the Focusrite Control
1089 * interface (bInterfaceClass = 255 Vendor Specific Class) and set
1090 * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
1091 * in private
1092 */
fcp_find_fc_interface(struct usb_mixer_interface * mixer)1093 static int fcp_find_fc_interface(struct usb_mixer_interface *mixer)
1094 {
1095 struct snd_usb_audio *chip = mixer->chip;
1096 struct fcp_data *private = mixer->private_data;
1097 struct usb_host_config *config = chip->dev->actconfig;
1098 int i;
1099
1100 for (i = 0; i < config->desc.bNumInterfaces; i++) {
1101 struct usb_interface *intf = config->interface[i];
1102 struct usb_interface_descriptor *desc =
1103 &intf->altsetting[0].desc;
1104 struct usb_endpoint_descriptor *epd;
1105
1106 if (desc->bInterfaceClass != 255)
1107 continue;
1108 if (desc->bNumEndpoints < 1)
1109 continue;
1110
1111 epd = get_endpoint(intf->altsetting, 0);
1112 private->bInterfaceNumber = desc->bInterfaceNumber;
1113 private->bEndpointAddress = usb_endpoint_num(epd);
1114 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
1115 private->bInterval = epd->bInterval;
1116 return 0;
1117 }
1118
1119 usb_audio_err(chip, "Focusrite vendor-specific interface not found\n");
1120 return -EINVAL;
1121 }
1122
snd_fcp_init(struct usb_mixer_interface * mixer)1123 int snd_fcp_init(struct usb_mixer_interface *mixer)
1124 {
1125 struct snd_usb_audio *chip = mixer->chip;
1126 int err;
1127
1128 /* only use UAC_VERSION_2 */
1129 if (!mixer->protocol)
1130 return 0;
1131
1132 err = fcp_init_private(mixer);
1133 if (err < 0)
1134 return err;
1135
1136 err = fcp_find_fc_interface(mixer);
1137 if (err < 0)
1138 return err;
1139
1140 err = fcp_hwdep_init(mixer);
1141 if (err < 0)
1142 return err;
1143
1144 usb_audio_info(chip,
1145 "Focusrite Control Protocol Driver ready (pid=0x%04x); "
1146 "report any issues to "
1147 "https://github.com/geoffreybennett/fcp-support/issues",
1148 USB_ID_PRODUCT(chip->usb_id));
1149
1150 return err;
1151 }
1152