drivers/usb/gadget/function/f_uac1.c

   1 /*
   2  * f_uac1.c -- USB Audio Class 1.0 Function (using u_audio API)
   3  *
   4  * Copyright (C) 2016 Ruslan Bilovol <ruslan.bilovol@gmail.com>
   5  *
   6  * This driver doesn't expect any real Audio codec to be present
   7  * on the device - the audio streams are simply sinked to and
   8  * sourced from a virtual ALSA sound card created.
   9  *
  10  * This file is based on f_uac1.c which is
  11  *   Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
  12  *   Copyright (C) 2008 Analog Devices, Inc
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  */
  19
  20 #include <linux/usb/audio.h>
  21 #include <linux/module.h>
  22
  23 #include "u_audio.h"
  24 #include "u_uac1.h"
  25
  26 /* UAC1 spec: 3.7.2.3 Audio Channel Cluster Format */
  27 #define UAC1_CHANNEL_MASK 0x0FFF
  28
  29 struct f_uac1 {
  30         struct g_audio g_audio;
  31         u8 ac_intf, as_in_intf, as_out_intf;
  32         u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
  33 };
  34
  35 static inline struct f_uac1 *func_to_uac1(struct usb_function *f)
  36 {
  37         return container_of(f, struct f_uac1, g_audio.func);
  38 }
  39
  40 static inline struct f_uac1_opts *g_audio_to_uac1_opts(struct g_audio *audio)
  41 {
  42         return container_of(audio->func.fi, struct f_uac1_opts, func_inst);
  43 }
  44
  45 /*
  46  * DESCRIPTORS ... most are static, but strings and full
  47  * configuration descriptors are built on demand.
  48  */
  49
  50 /*
  51  * We have three interfaces - one AudioControl and two AudioStreaming
  52  *
  53  * The driver implements a simple UAC_1 topology.
  54  * USB-OUT -> IT_1 -> OT_2 -> ALSA_Capture
  55  * ALSA_Playback -> IT_3 -> OT_4 -> USB-IN
  56  */
  57 #define F_AUDIO_AC_INTERFACE            0
  58 #define F_AUDIO_AS_OUT_INTERFACE        1
  59 #define F_AUDIO_AS_IN_INTERFACE         2
  60 /* Number of streaming interfaces */
  61 #define F_AUDIO_NUM_INTERFACES          2
  62
  63 /* B.3.1  Standard AC Interface Descriptor */
  64 static struct usb_interface_descriptor ac_interface_desc = {
  65         .bLength =              USB_DT_INTERFACE_SIZE,
  66         .bDescriptorType =      USB_DT_INTERFACE,
  67         .bNumEndpoints =        0,
  68         .bInterfaceClass =      USB_CLASS_AUDIO,
  69         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOCONTROL,
  70 };
  71
  72 /*
  73  * The number of AudioStreaming and MIDIStreaming interfaces
  74  * in the Audio Interface Collection
  75  */
  76 DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
  77
  78 #define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
  79 /* 2 input terminals and 2 output terminals */
  80 #define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH \
  81         + 2*UAC_DT_INPUT_TERMINAL_SIZE + 2*UAC_DT_OUTPUT_TERMINAL_SIZE)
  82 /* B.3.2  Class-Specific AC Interface Descriptor */
  83 static struct uac1_ac_header_descriptor_2 ac_header_desc = {
  84         .bLength =              UAC_DT_AC_HEADER_LENGTH,
  85         .bDescriptorType =      USB_DT_CS_INTERFACE,
  86         .bDescriptorSubtype =   UAC_HEADER,
  87         .bcdADC =               cpu_to_le16(0x0100),
  88         .wTotalLength =         cpu_to_le16(UAC_DT_TOTAL_LENGTH),
  89         .bInCollection =        F_AUDIO_NUM_INTERFACES,
  90         .baInterfaceNr = {
  91         /* Interface number of the AudioStream interfaces */
  92                 [0] =           1,
  93                 [1] =           2,
  94         }
  95 };
  96
  97 #define USB_OUT_IT_ID   1
  98 static struct uac_input_terminal_descriptor usb_out_it_desc = {
  99         .bLength =              UAC_DT_INPUT_TERMINAL_SIZE,
 100         .bDescriptorType =      USB_DT_CS_INTERFACE,
 101         .bDescriptorSubtype =   UAC_INPUT_TERMINAL,
 102         .bTerminalID =          USB_OUT_IT_ID,
 103         .wTerminalType =        cpu_to_le16(UAC_TERMINAL_STREAMING),
 104         .bAssocTerminal =       0,
 105         .wChannelConfig =       cpu_to_le16(0x3),
 106 };
 107
 108 #define IO_OUT_OT_ID    2
 109 static struct uac1_output_terminal_descriptor io_out_ot_desc = {
 110         .bLength                = UAC_DT_OUTPUT_TERMINAL_SIZE,
 111         .bDescriptorType        = USB_DT_CS_INTERFACE,
 112         .bDescriptorSubtype     = UAC_OUTPUT_TERMINAL,
 113         .bTerminalID            = IO_OUT_OT_ID,
 114         .wTerminalType          = cpu_to_le16(UAC_OUTPUT_TERMINAL_SPEAKER),
 115         .bAssocTerminal         = 0,
 116         .bSourceID              = USB_OUT_IT_ID,
 117 };
 118
 119 #define IO_IN_IT_ID     3
 120 static struct uac_input_terminal_descriptor io_in_it_desc = {
 121         .bLength                = UAC_DT_INPUT_TERMINAL_SIZE,
 122         .bDescriptorType        = USB_DT_CS_INTERFACE,
 123         .bDescriptorSubtype     = UAC_INPUT_TERMINAL,
 124         .bTerminalID            = IO_IN_IT_ID,
 125         .wTerminalType          = cpu_to_le16(UAC_INPUT_TERMINAL_MICROPHONE),
 126         .bAssocTerminal         = 0,
 127         .wChannelConfig         = cpu_to_le16(0x3),
 128 };
 129
 130 #define USB_IN_OT_ID    4
 131 static struct uac1_output_terminal_descriptor usb_in_ot_desc = {
 132         .bLength =              UAC_DT_OUTPUT_TERMINAL_SIZE,
 133         .bDescriptorType =      USB_DT_CS_INTERFACE,
 134         .bDescriptorSubtype =   UAC_OUTPUT_TERMINAL,
 135         .bTerminalID =          USB_IN_OT_ID,
 136         .wTerminalType =        cpu_to_le16(UAC_TERMINAL_STREAMING),
 137         .bAssocTerminal =       0,
 138         .bSourceID =            IO_IN_IT_ID,
 139 };
 140
 141 /* B.4.1  Standard AS Interface Descriptor */
 142 static struct usb_interface_descriptor as_out_interface_alt_0_desc = {
 143         .bLength =              USB_DT_INTERFACE_SIZE,
 144         .bDescriptorType =      USB_DT_INTERFACE,
 145         .bAlternateSetting =    0,
 146         .bNumEndpoints =        0,
 147         .bInterfaceClass =      USB_CLASS_AUDIO,
 148         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
 149 };
 150
 151 static struct usb_interface_descriptor as_out_interface_alt_1_desc = {
 152         .bLength =              USB_DT_INTERFACE_SIZE,
 153         .bDescriptorType =      USB_DT_INTERFACE,
 154         .bAlternateSetting =    1,
 155         .bNumEndpoints =        1,
 156         .bInterfaceClass =      USB_CLASS_AUDIO,
 157         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
 158 };
 159
 160 static struct usb_interface_descriptor as_in_interface_alt_0_desc = {
 161         .bLength =              USB_DT_INTERFACE_SIZE,
 162         .bDescriptorType =      USB_DT_INTERFACE,
 163         .bAlternateSetting =    0,
 164         .bNumEndpoints =        0,
 165         .bInterfaceClass =      USB_CLASS_AUDIO,
 166         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
 167 };
 168
 169 static struct usb_interface_descriptor as_in_interface_alt_1_desc = {
 170         .bLength =              USB_DT_INTERFACE_SIZE,
 171         .bDescriptorType =      USB_DT_INTERFACE,
 172         .bAlternateSetting =    1,
 173         .bNumEndpoints =        1,
 174         .bInterfaceClass =      USB_CLASS_AUDIO,
 175         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
 176 };
 177
 178 /* B.4.2  Class-Specific AS Interface Descriptor */
 179 static struct uac1_as_header_descriptor as_out_header_desc = {
 180         .bLength =              UAC_DT_AS_HEADER_SIZE,
 181         .bDescriptorType =      USB_DT_CS_INTERFACE,
 182         .bDescriptorSubtype =   UAC_AS_GENERAL,
 183         .bTerminalLink =        USB_OUT_IT_ID,
 184         .bDelay =               1,
 185         .wFormatTag =           cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
 186 };
 187
 188 static struct uac1_as_header_descriptor as_in_header_desc = {
 189         .bLength =              UAC_DT_AS_HEADER_SIZE,
 190         .bDescriptorType =      USB_DT_CS_INTERFACE,
 191         .bDescriptorSubtype =   UAC_AS_GENERAL,
 192         .bTerminalLink =        USB_IN_OT_ID,
 193         .bDelay =               1,
 194         .wFormatTag =           cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
 195 };
 196
 197 DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
 198
 199 static struct uac_format_type_i_discrete_descriptor_1 as_out_type_i_desc = {
 200         .bLength =              UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
 201         .bDescriptorType =      USB_DT_CS_INTERFACE,
 202         .bDescriptorSubtype =   UAC_FORMAT_TYPE,
 203         .bFormatType =          UAC_FORMAT_TYPE_I,
 204         .bSubframeSize =        2,
 205         .bBitResolution =       16,
 206         .bSamFreqType =         1,
 207 };
 208
 209 /* Standard ISO OUT Endpoint Descriptor */
 210 static struct usb_endpoint_descriptor as_out_ep_desc  = {
 211         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
 212         .bDescriptorType =      USB_DT_ENDPOINT,
 213         .bEndpointAddress =     USB_DIR_OUT,
 214         .bmAttributes =         USB_ENDPOINT_SYNC_ADAPTIVE
 215                                 | USB_ENDPOINT_XFER_ISOC,
 216         .wMaxPacketSize =       cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 217         .bInterval =            4,
 218 };
 219
 220 /* Class-specific AS ISO OUT Endpoint Descriptor */
 221 static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
 222         .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
 223         .bDescriptorType =      USB_DT_CS_ENDPOINT,
 224         .bDescriptorSubtype =   UAC_EP_GENERAL,
 225         .bmAttributes =         1,
 226         .bLockDelayUnits =      1,
 227         .wLockDelay =           cpu_to_le16(1),
 228 };
 229
 230 static struct uac_format_type_i_discrete_descriptor_1 as_in_type_i_desc = {
 231         .bLength =              UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
 232         .bDescriptorType =      USB_DT_CS_INTERFACE,
 233         .bDescriptorSubtype =   UAC_FORMAT_TYPE,
 234         .bFormatType =          UAC_FORMAT_TYPE_I,
 235         .bSubframeSize =        2,
 236         .bBitResolution =       16,
 237         .bSamFreqType =         1,
 238 };
 239
 240 /* Standard ISO OUT Endpoint Descriptor */
 241 static struct usb_endpoint_descriptor as_in_ep_desc  = {
 242         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
 243         .bDescriptorType =      USB_DT_ENDPOINT,
 244         .bEndpointAddress =     USB_DIR_IN,
 245         .bmAttributes =         USB_ENDPOINT_SYNC_ASYNC
 246                                 | USB_ENDPOINT_XFER_ISOC,
 247         .wMaxPacketSize =       cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 248         .bInterval =            4,
 249 };
 250
 251 /* Class-specific AS ISO OUT Endpoint Descriptor */
 252 static struct uac_iso_endpoint_descriptor as_iso_in_desc = {
 253         .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
 254         .bDescriptorType =      USB_DT_CS_ENDPOINT,
 255         .bDescriptorSubtype =   UAC_EP_GENERAL,
 256         .bmAttributes =         1,
 257         .bLockDelayUnits =      0,
 258         .wLockDelay =           0,
 259 };
 260
 261 static struct usb_descriptor_header *f_audio_desc[] = {
 262         (struct usb_descriptor_header *)&ac_interface_desc,
 263         (struct usb_descriptor_header *)&ac_header_desc,
 264
 265         (struct usb_descriptor_header *)&usb_out_it_desc,
 266         (struct usb_descriptor_header *)&io_out_ot_desc,
 267         (struct usb_descriptor_header *)&io_in_it_desc,
 268         (struct usb_descriptor_header *)&usb_in_ot_desc,
 269
 270         (struct usb_descriptor_header *)&as_out_interface_alt_0_desc,
 271         (struct usb_descriptor_header *)&as_out_interface_alt_1_desc,
 272         (struct usb_descriptor_header *)&as_out_header_desc,
 273
 274         (struct usb_descriptor_header *)&as_out_type_i_desc,
 275
 276         (struct usb_descriptor_header *)&as_out_ep_desc,
 277         (struct usb_descriptor_header *)&as_iso_out_desc,
 278
 279         (struct usb_descriptor_header *)&as_in_interface_alt_0_desc,
 280         (struct usb_descriptor_header *)&as_in_interface_alt_1_desc,
 281         (struct usb_descriptor_header *)&as_in_header_desc,
 282
 283         (struct usb_descriptor_header *)&as_in_type_i_desc,
 284
 285         (struct usb_descriptor_header *)&as_in_ep_desc,
 286         (struct usb_descriptor_header *)&as_iso_in_desc,
 287         NULL,
 288 };
 289
 290 enum {
 291         STR_AC_IF,
 292         STR_USB_OUT_IT,
 293         STR_USB_OUT_IT_CH_NAMES,
 294         STR_IO_OUT_OT,
 295         STR_IO_IN_IT,
 296         STR_IO_IN_IT_CH_NAMES,
 297         STR_USB_IN_OT,
 298         STR_AS_OUT_IF_ALT0,
 299         STR_AS_OUT_IF_ALT1,
 300         STR_AS_IN_IF_ALT0,
 301         STR_AS_IN_IF_ALT1,
 302 };
 303
 304 static struct usb_string strings_uac1[] = {
 305         [STR_AC_IF].s = "AC Interface",
 306         [STR_USB_OUT_IT].s = "Playback Input terminal",
 307         [STR_USB_OUT_IT_CH_NAMES].s = "Playback Channels",
 308         [STR_IO_OUT_OT].s = "Playback Output terminal",
 309         [STR_IO_IN_IT].s = "Capture Input terminal",
 310         [STR_IO_IN_IT_CH_NAMES].s = "Capture Channels",
 311         [STR_USB_IN_OT].s = "Capture Output terminal",
 312         [STR_AS_OUT_IF_ALT0].s = "Playback Inactive",
 313         [STR_AS_OUT_IF_ALT1].s = "Playback Active",
 314         [STR_AS_IN_IF_ALT0].s = "Capture Inactive",
 315         [STR_AS_IN_IF_ALT1].s = "Capture Active",
 316         { },
 317 };
 318
 319 static struct usb_gadget_strings str_uac1 = {
 320         .language = 0x0409,     /* en-us */
 321         .strings = strings_uac1,
 322 };
 323
 324 static struct usb_gadget_strings *uac1_strings[] = {
 325         &str_uac1,
 326         NULL,
 327 };
 328
 329 /*
 330  * This function is an ALSA sound card following USB Audio Class Spec 1.0.
 331  */
 332
 333 static int audio_set_endpoint_req(struct usb_function *f,
 334                 const struct usb_ctrlrequest *ctrl)
 335 {
 336         struct usb_composite_dev *cdev = f->config->cdev;
 337         int                     value = -EOPNOTSUPP;
 338         u16                     ep = le16_to_cpu(ctrl->wIndex);
 339         u16                     len = le16_to_cpu(ctrl->wLength);
 340         u16                     w_value = le16_to_cpu(ctrl->wValue);
 341
 342         DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
 343                         ctrl->bRequest, w_value, len, ep);
 344
 345         switch (ctrl->bRequest) {
 346         case UAC_SET_CUR:
 347                 value = len;
 348                 break;
 349
 350         case UAC_SET_MIN:
 351                 break;
 352
 353         case UAC_SET_MAX:
 354                 break;
 355
 356         case UAC_SET_RES:
 357                 break;
 358
 359         case UAC_SET_MEM:
 360                 break;
 361
 362         default:
 363                 break;
 364         }
 365
 366         return value;
 367 }
 368
 369 static int audio_get_endpoint_req(struct usb_function *f,
 370                 const struct usb_ctrlrequest *ctrl)
 371 {
 372         struct usb_composite_dev *cdev = f->config->cdev;
 373         int value = -EOPNOTSUPP;
 374         u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
 375         u16 len = le16_to_cpu(ctrl->wLength);
 376         u16 w_value = le16_to_cpu(ctrl->wValue);
 377
 378         DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
 379                         ctrl->bRequest, w_value, len, ep);
 380
 381         switch (ctrl->bRequest) {
 382         case UAC_GET_CUR:
 383         case UAC_GET_MIN:
 384         case UAC_GET_MAX:
 385         case UAC_GET_RES:
 386                 value = len;
 387                 break;
 388         case UAC_GET_MEM:
 389                 break;
 390         default:
 391                 break;
 392         }
 393
 394         return value;
 395 }
 396
 397 static int
 398 f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 399 {
 400         struct usb_composite_dev *cdev = f->config->cdev;
 401         struct usb_request      *req = cdev->req;
 402         int                     value = -EOPNOTSUPP;
 403         u16                     w_index = le16_to_cpu(ctrl->wIndex);
 404         u16                     w_value = le16_to_cpu(ctrl->wValue);
 405         u16                     w_length = le16_to_cpu(ctrl->wLength);
 406
 407         /* composite driver infrastructure handles everything; interface
 408          * activation uses set_alt().
 409          */
 410         switch (ctrl->bRequestType) {
 411         case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
 412                 value = audio_set_endpoint_req(f, ctrl);
 413                 break;
 414
 415         case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
 416                 value = audio_get_endpoint_req(f, ctrl);
 417                 break;
 418
 419         default:
 420                 ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
 421                         ctrl->bRequestType, ctrl->bRequest,
 422                         w_value, w_index, w_length);
 423         }
 424
 425         /* respond with data transfer or status phase? */
 426         if (value >= 0) {
 427                 DBG(cdev, "audio req%02x.%02x v%04x i%04x l%d\n",
 428                         ctrl->bRequestType, ctrl->bRequest,
 429                         w_value, w_index, w_length);
 430                 req->zero = 0;
 431                 req->length = value;
 432                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 433                 if (value < 0)
 434                         ERROR(cdev, "audio response on err %d\n", value);
 435         }
 436
 437         /* device either stalls (value < 0) or reports success */
 438         return value;
 439 }
 440
 441 static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 442 {
 443         struct usb_composite_dev *cdev = f->config->cdev;
 444         struct usb_gadget *gadget = cdev->gadget;
 445         struct device *dev = &gadget->dev;
 446         struct f_uac1 *uac1 = func_to_uac1(f);
 447         int ret = 0;
 448
 449         /* No i/f has more than 2 alt settings */
 450         if (alt > 1) {
 451                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 452                 return -EINVAL;
 453         }
 454
 455         if (intf == uac1->ac_intf) {
 456                 /* Control I/f has only 1 AltSetting - 0 */
 457                 if (alt) {
 458                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 459                         return -EINVAL;
 460                 }
 461                 return 0;
 462         }
 463
 464         if (intf == uac1->as_out_intf) {
 465                 uac1->as_out_alt = alt;
 466
 467                 if (alt)
 468                         ret = u_audio_start_capture(&uac1->g_audio);
 469                 else
 470                         u_audio_stop_capture(&uac1->g_audio);
 471         } else if (intf == uac1->as_in_intf) {
 472                 uac1->as_in_alt = alt;
 473
 474                         if (alt)
 475                                 ret = u_audio_start_playback(&uac1->g_audio);
 476                         else
 477                                 u_audio_stop_playback(&uac1->g_audio);
 478         } else {
 479                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 480                 return -EINVAL;
 481         }
 482
 483         return ret;
 484 }
 485
 486 static int f_audio_get_alt(struct usb_function *f, unsigned intf)
 487 {
 488         struct usb_composite_dev *cdev = f->config->cdev;
 489         struct usb_gadget *gadget = cdev->gadget;
 490         struct device *dev = &gadget->dev;
 491         struct f_uac1 *uac1 = func_to_uac1(f);
 492
 493         if (intf == uac1->ac_intf)
 494                 return uac1->ac_alt;
 495         else if (intf == uac1->as_out_intf)
 496                 return uac1->as_out_alt;
 497         else if (intf == uac1->as_in_intf)
 498                 return uac1->as_in_alt;
 499         else
 500                 dev_err(dev, "%s:%d Invalid Interface %d!\n",
 501                         __func__, __LINE__, intf);
 502
 503         return -EINVAL;
 504 }
 505
 506
 507 static void f_audio_disable(struct usb_function *f)
 508 {
 509         struct f_uac1 *uac1 = func_to_uac1(f);
 510
 511         uac1->as_out_alt = 0;
 512         uac1->as_in_alt = 0;
 513
 514         u_audio_stop_playback(&uac1->g_audio);
 515         u_audio_stop_capture(&uac1->g_audio);
 516 }
 517
 518 /*-------------------------------------------------------------------------*/
 519
 520 static int f_audio_validate_opts(struct g_audio *audio, struct device *dev)
 521 {
 522         struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 523
 524         if (!opts->p_chmask && !opts->c_chmask) {
 525                 dev_err(dev, "Error: no playback and capture channels\n");
 526                 return -EINVAL;
 527         } else if (opts->p_chmask & ~UAC1_CHANNEL_MASK) {
 528                 dev_err(dev, "Error: unsupported playback channels mask\n");
 529                 return -EINVAL;
 530         } else if (opts->c_chmask & ~UAC1_CHANNEL_MASK) {
 531                 dev_err(dev, "Error: unsupported capture channels mask\n");
 532                 return -EINVAL;
 533         } else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) {
 534                 dev_err(dev, "Error: incorrect playback sample size\n");
 535                 return -EINVAL;
 536         } else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) {
 537                 dev_err(dev, "Error: incorrect capture sample size\n");
 538                 return -EINVAL;
 539         } else if (!opts->p_srate) {
 540                 dev_err(dev, "Error: incorrect playback sampling rate\n");
 541                 return -EINVAL;
 542         } else if (!opts->c_srate) {
 543                 dev_err(dev, "Error: incorrect capture sampling rate\n");
 544                 return -EINVAL;
 545         }
 546
 547         return 0;
 548 }
 549
 550 /* audio function driver setup/binding */
 551 static int f_audio_bind(struct usb_configuration *c, struct usb_function *f)
 552 {
 553         struct usb_composite_dev        *cdev = c->cdev;
 554         struct usb_gadget               *gadget = cdev->gadget;
 555         struct device                   *dev = &gadget->dev;
 556         struct f_uac1                   *uac1 = func_to_uac1(f);
 557         struct g_audio                  *audio = func_to_g_audio(f);
 558         struct f_uac1_opts              *audio_opts;
 559         struct usb_ep                   *ep = NULL;
 560         struct usb_string               *us;
 561         u8                              *sam_freq;
 562         int                             rate;
 563         int                             status;
 564
 565         status = f_audio_validate_opts(audio, dev);
 566         if (status)
 567                 return status;
 568
 569         audio_opts = container_of(f->fi, struct f_uac1_opts, func_inst);
 570
 571         us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1));
 572         if (IS_ERR(us))
 573                 return PTR_ERR(us);
 574         ac_interface_desc.iInterface = us[STR_AC_IF].id;
 575         usb_out_it_desc.iTerminal = us[STR_USB_OUT_IT].id;
 576         usb_out_it_desc.iChannelNames = us[STR_USB_OUT_IT_CH_NAMES].id;
 577         io_out_ot_desc.iTerminal = us[STR_IO_OUT_OT].id;
 578         as_out_interface_alt_0_desc.iInterface = us[STR_AS_OUT_IF_ALT0].id;
 579         as_out_interface_alt_1_desc.iInterface = us[STR_AS_OUT_IF_ALT1].id;
 580         io_in_it_desc.iTerminal = us[STR_IO_IN_IT].id;
 581         io_in_it_desc.iChannelNames = us[STR_IO_IN_IT_CH_NAMES].id;
 582         usb_in_ot_desc.iTerminal = us[STR_USB_IN_OT].id;
 583         as_in_interface_alt_0_desc.iInterface = us[STR_AS_IN_IF_ALT0].id;
 584         as_in_interface_alt_1_desc.iInterface = us[STR_AS_IN_IF_ALT1].id;
 585
 586         /* Set channel numbers */
 587         usb_out_it_desc.bNrChannels = num_channels(audio_opts->c_chmask);
 588         usb_out_it_desc.wChannelConfig = cpu_to_le16(audio_opts->c_chmask);
 589         as_out_type_i_desc.bNrChannels = num_channels(audio_opts->c_chmask);
 590         as_out_type_i_desc.bSubframeSize = audio_opts->c_ssize;
 591         as_out_type_i_desc.bBitResolution = audio_opts->c_ssize * 8;
 592         io_in_it_desc.bNrChannels = num_channels(audio_opts->p_chmask);
 593         io_in_it_desc.wChannelConfig = cpu_to_le16(audio_opts->p_chmask);
 594         as_in_type_i_desc.bNrChannels = num_channels(audio_opts->p_chmask);
 595         as_in_type_i_desc.bSubframeSize = audio_opts->p_ssize;
 596         as_in_type_i_desc.bBitResolution = audio_opts->p_ssize * 8;
 597
 598         /* Set sample rates */
 599         rate = audio_opts->c_srate;
 600         sam_freq = as_out_type_i_desc.tSamFreq[0];
 601         memcpy(sam_freq, &rate, 3);
 602         rate = audio_opts->p_srate;
 603         sam_freq = as_in_type_i_desc.tSamFreq[0];
 604         memcpy(sam_freq, &rate, 3);
 605
 606         /* allocate instance-specific interface IDs, and patch descriptors */
 607         status = usb_interface_id(c, f);
 608         if (status < 0)
 609                 goto fail;
 610         ac_interface_desc.bInterfaceNumber = status;
 611         uac1->ac_intf = status;
 612         uac1->ac_alt = 0;
 613
 614         status = usb_interface_id(c, f);
 615         if (status < 0)
 616                 goto fail;
 617         as_out_interface_alt_0_desc.bInterfaceNumber = status;
 618         as_out_interface_alt_1_desc.bInterfaceNumber = status;
 619         uac1->as_out_intf = status;
 620         uac1->as_out_alt = 0;
 621
 622         status = usb_interface_id(c, f);
 623         if (status < 0)
 624                 goto fail;
 625         as_in_interface_alt_0_desc.bInterfaceNumber = status;
 626         as_in_interface_alt_1_desc.bInterfaceNumber = status;
 627         uac1->as_in_intf = status;
 628         uac1->as_in_alt = 0;
 629
 630         audio->gadget = gadget;
 631
 632         status = -ENODEV;
 633
 634         /* allocate instance-specific endpoints */
 635         ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc);
 636         if (!ep)
 637                 goto fail;
 638         audio->out_ep = ep;
 639         audio->out_ep->desc = &as_out_ep_desc;
 640
 641         ep = usb_ep_autoconfig(cdev->gadget, &as_in_ep_desc);
 642         if (!ep)
 643                 goto fail;
 644         audio->in_ep = ep;
 645         audio->in_ep->desc = &as_in_ep_desc;
 646
 647         /* copy descriptors, and track endpoint copies */
 648         status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL,
 649                                         NULL);
 650         if (status)
 651                 goto fail;
 652
 653         audio->out_ep_maxpsize = le16_to_cpu(as_out_ep_desc.wMaxPacketSize);
 654         audio->in_ep_maxpsize = le16_to_cpu(as_in_ep_desc.wMaxPacketSize);
 655         audio->params.c_chmask = audio_opts->c_chmask;
 656         audio->params.c_srate = audio_opts->c_srate;
 657         audio->params.c_ssize = audio_opts->c_ssize;
 658         audio->params.p_chmask = audio_opts->p_chmask;
 659         audio->params.p_srate = audio_opts->p_srate;
 660         audio->params.p_ssize = audio_opts->p_ssize;
 661         audio->params.req_number = audio_opts->req_number;
 662
 663         status = g_audio_setup(audio, "UAC1_PCM", "UAC1_Gadget");
 664         if (status)
 665                 goto err_card_register;
 666
 667         return 0;
 668
 669 err_card_register:
 670         usb_free_all_descriptors(f);
 671 fail:
 672         return status;
 673 }
 674
 675 /*-------------------------------------------------------------------------*/
 676
 677 static inline struct f_uac1_opts *to_f_uac1_opts(struct config_item *item)
 678 {
 679         return container_of(to_config_group(item), struct f_uac1_opts,
 680                             func_inst.group);
 681 }
 682
 683 static void f_uac1_attr_release(struct config_item *item)
 684 {
 685         struct f_uac1_opts *opts = to_f_uac1_opts(item);
 686
 687         usb_put_function_instance(&opts->func_inst);
 688 }
 689
 690 static struct configfs_item_operations f_uac1_item_ops = {
 691         .release        = f_uac1_attr_release,
 692 };
 693
 694 #define UAC1_ATTRIBUTE(name)                                            \
 695 static ssize_t f_uac1_opts_##name##_show(                               \
 696                                           struct config_item *item,     \
 697                                           char *page)                   \
 698 {                                                                       \
 699         struct f_uac1_opts *opts = to_f_uac1_opts(item);                \
 700         int result;                                                     \
 701                                                                         \
 702         mutex_lock(&opts->lock);                                        \
 703         result = sprintf(page, "%u\n", opts->name);                     \
 704         mutex_unlock(&opts->lock);                                      \
 705                                                                         \
 706         return result;                                                  \
 707 }                                                                       \
 708                                                                         \
 709 static ssize_t f_uac1_opts_##name##_store(                              \
 710                                           struct config_item *item,     \
 711                                           const char *page, size_t len) \
 712 {                                                                       \
 713         struct f_uac1_opts *opts = to_f_uac1_opts(item);                \
 714         int ret;                                                        \
 715         u32 num;                                                        \
 716                                                                         \
 717         mutex_lock(&opts->lock);                                        \
 718         if (opts->refcnt) {                                             \
 719                 ret = -EBUSY;                                           \
 720                 goto end;                                               \
 721         }                                                               \
 722                                                                         \
 723         ret = kstrtou32(page, 0, &num);                                 \
 724         if (ret)                                                        \
 725                 goto end;                                               \
 726                                                                         \
 727         opts->name = num;                                               \
 728         ret = len;                                                      \
 729                                                                         \
 730 end:                                                                    \
 731         mutex_unlock(&opts->lock);                                      \
 732         return ret;                                                     \
 733 }                                                                       \
 734                                                                         \
 735 CONFIGFS_ATTR(f_uac1_opts_, name)
 736
 737 UAC1_ATTRIBUTE(c_chmask);
 738 UAC1_ATTRIBUTE(c_srate);
 739 UAC1_ATTRIBUTE(c_ssize);
 740 UAC1_ATTRIBUTE(p_chmask);
 741 UAC1_ATTRIBUTE(p_srate);
 742 UAC1_ATTRIBUTE(p_ssize);
 743 UAC1_ATTRIBUTE(req_number);
 744
 745 static struct configfs_attribute *f_uac1_attrs[] = {
 746         &f_uac1_opts_attr_c_chmask,
 747         &f_uac1_opts_attr_c_srate,
 748         &f_uac1_opts_attr_c_ssize,
 749         &f_uac1_opts_attr_p_chmask,
 750         &f_uac1_opts_attr_p_srate,
 751         &f_uac1_opts_attr_p_ssize,
 752         &f_uac1_opts_attr_req_number,
 753         NULL,
 754 };
 755
 756 static struct config_item_type f_uac1_func_type = {
 757         .ct_item_ops    = &f_uac1_item_ops,
 758         .ct_attrs       = f_uac1_attrs,
 759         .ct_owner       = THIS_MODULE,
 760 };
 761
 762 static void f_audio_free_inst(struct usb_function_instance *f)
 763 {
 764         struct f_uac1_opts *opts;
 765
 766         opts = container_of(f, struct f_uac1_opts, func_inst);
 767         kfree(opts);
 768 }
 769
 770 static struct usb_function_instance *f_audio_alloc_inst(void)
 771 {
 772         struct f_uac1_opts *opts;
 773
 774         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 775         if (!opts)
 776                 return ERR_PTR(-ENOMEM);
 777
 778         mutex_init(&opts->lock);
 779         opts->func_inst.free_func_inst = f_audio_free_inst;
 780
 781         config_group_init_type_name(&opts->func_inst.group, "",
 782                                     &f_uac1_func_type);
 783
 784         opts->c_chmask = UAC1_DEF_CCHMASK;
 785         opts->c_srate = UAC1_DEF_CSRATE;
 786         opts->c_ssize = UAC1_DEF_CSSIZE;
 787         opts->p_chmask = UAC1_DEF_PCHMASK;
 788         opts->p_srate = UAC1_DEF_PSRATE;
 789         opts->p_ssize = UAC1_DEF_PSSIZE;
 790         opts->req_number = UAC1_DEF_REQ_NUM;
 791         return &opts->func_inst;
 792 }
 793
 794 static void f_audio_free(struct usb_function *f)
 795 {
 796         struct g_audio *audio;
 797         struct f_uac1_opts *opts;
 798
 799         audio = func_to_g_audio(f);
 800         opts = container_of(f->fi, struct f_uac1_opts, func_inst);
 801         kfree(audio);
 802         mutex_lock(&opts->lock);
 803         --opts->refcnt;
 804         mutex_unlock(&opts->lock);
 805 }
 806
 807 static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
 808 {
 809         struct g_audio *audio = func_to_g_audio(f);
 810
 811         g_audio_cleanup(audio);
 812         usb_free_all_descriptors(f);
 813
 814         audio->gadget = NULL;
 815 }
 816
 817 static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
 818 {
 819         struct f_uac1 *uac1;
 820         struct f_uac1_opts *opts;
 821
 822         /* allocate and initialize one new instance */
 823         uac1 = kzalloc(sizeof(*uac1), GFP_KERNEL);
 824         if (!uac1)
 825                 return ERR_PTR(-ENOMEM);
 826
 827         opts = container_of(fi, struct f_uac1_opts, func_inst);
 828         mutex_lock(&opts->lock);
 829         ++opts->refcnt;
 830         mutex_unlock(&opts->lock);
 831
 832         uac1->g_audio.func.name = "uac1_func";
 833         uac1->g_audio.func.bind = f_audio_bind;
 834         uac1->g_audio.func.unbind = f_audio_unbind;
 835         uac1->g_audio.func.set_alt = f_audio_set_alt;
 836         uac1->g_audio.func.get_alt = f_audio_get_alt;
 837         uac1->g_audio.func.setup = f_audio_setup;
 838         uac1->g_audio.func.disable = f_audio_disable;
 839         uac1->g_audio.func.free_func = f_audio_free;
 840
 841         return &uac1->g_audio.func;
 842 }
 843
 844 DECLARE_USB_FUNCTION_INIT(uac1, f_audio_alloc_inst, f_audio_alloc);
 845 MODULE_LICENSE("GPL");
 846 MODULE_AUTHOR("Ruslan Bilovol");