drivers/usb/gadget/function/f_uac2.c

   1 /*
   2  * f_uac2.c -- USB Audio Class 2.0 Function
   3  *
   4  * Copyright (C) 2011
   5  *    Yadwinder Singh (yadi.brar01@gmail.com)
   6  *    Jaswinder Singh (jaswinder.singh@linaro.org)
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/usb/audio.h>
  15 #include <linux/usb/audio-v2.h>
  16 #include <linux/module.h>
  17
  18 #include "u_audio.h"
  19 #include "u_uac2.h"
  20
  21 /*
  22  * The driver implements a simple UAC_2 topology.
  23  * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
  24  * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
  25  * Capture and Playback sampling rates are independently
  26  *  controlled by two clock sources :
  27  *    CLK_5 := c_srate, and CLK_6 := p_srate
  28  */
  29 #define USB_OUT_IT_ID   1
  30 #define IO_IN_IT_ID     2
  31 #define IO_OUT_OT_ID    3
  32 #define USB_IN_OT_ID    4
  33 #define USB_OUT_CLK_ID  5
  34 #define USB_IN_CLK_ID   6
  35
  36 #define CONTROL_ABSENT  0
  37 #define CONTROL_RDONLY  1
  38 #define CONTROL_RDWR    3
  39
  40 #define CLK_FREQ_CTRL   0
  41 #define CLK_VLD_CTRL    2
  42
  43 #define COPY_CTRL       0
  44 #define CONN_CTRL       2
  45 #define OVRLD_CTRL      4
  46 #define CLSTR_CTRL      6
  47 #define UNFLW_CTRL      8
  48 #define OVFLW_CTRL      10
  49
  50 struct f_uac2 {
  51         struct g_audio g_audio;
  52         u8 ac_intf, as_in_intf, as_out_intf;
  53         u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
  54 };
  55
  56 static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
  57 {
  58         return container_of(f, struct f_uac2, g_audio.func);
  59 }
  60
  61 static inline
  62 struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
  63 {
  64         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
  65 }
  66
  67 /* --------- USB Function Interface ------------- */
  68
  69 enum {
  70         STR_ASSOC,
  71         STR_IF_CTRL,
  72         STR_CLKSRC_IN,
  73         STR_CLKSRC_OUT,
  74         STR_USB_IT,
  75         STR_IO_IT,
  76         STR_USB_OT,
  77         STR_IO_OT,
  78         STR_AS_OUT_ALT0,
  79         STR_AS_OUT_ALT1,
  80         STR_AS_IN_ALT0,
  81         STR_AS_IN_ALT1,
  82 };
  83
  84 static char clksrc_in[8];
  85 static char clksrc_out[8];
  86
  87 static struct usb_string strings_fn[] = {
  88         [STR_ASSOC].s = "Source/Sink",
  89         [STR_IF_CTRL].s = "Topology Control",
  90         [STR_CLKSRC_IN].s = clksrc_in,
  91         [STR_CLKSRC_OUT].s = clksrc_out,
  92         [STR_USB_IT].s = "USBH Out",
  93         [STR_IO_IT].s = "USBD Out",
  94         [STR_USB_OT].s = "USBH In",
  95         [STR_IO_OT].s = "USBD In",
  96         [STR_AS_OUT_ALT0].s = "Playback Inactive",
  97         [STR_AS_OUT_ALT1].s = "Playback Active",
  98         [STR_AS_IN_ALT0].s = "Capture Inactive",
  99         [STR_AS_IN_ALT1].s = "Capture Active",
 100         { },
 101 };
 102
 103 static struct usb_gadget_strings str_fn = {
 104         .language = 0x0409,     /* en-us */
 105         .strings = strings_fn,
 106 };
 107
 108 static struct usb_gadget_strings *fn_strings[] = {
 109         &str_fn,
 110         NULL,
 111 };
 112
 113 static struct usb_interface_assoc_descriptor iad_desc = {
 114         .bLength = sizeof iad_desc,
 115         .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
 116
 117         .bFirstInterface = 0,
 118         .bInterfaceCount = 3,
 119         .bFunctionClass = USB_CLASS_AUDIO,
 120         .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
 121         .bFunctionProtocol = UAC_VERSION_2,
 122 };
 123
 124 /* Audio Control Interface */
 125 static struct usb_interface_descriptor std_ac_if_desc = {
 126         .bLength = sizeof std_ac_if_desc,
 127         .bDescriptorType = USB_DT_INTERFACE,
 128
 129         .bAlternateSetting = 0,
 130         .bNumEndpoints = 0,
 131         .bInterfaceClass = USB_CLASS_AUDIO,
 132         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 133         .bInterfaceProtocol = UAC_VERSION_2,
 134 };
 135
 136 /* Clock source for IN traffic */
 137 static struct uac_clock_source_descriptor in_clk_src_desc = {
 138         .bLength = sizeof in_clk_src_desc,
 139         .bDescriptorType = USB_DT_CS_INTERFACE,
 140
 141         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 142         .bClockID = USB_IN_CLK_ID,
 143         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 144         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 145         .bAssocTerminal = 0,
 146 };
 147
 148 /* Clock source for OUT traffic */
 149 static struct uac_clock_source_descriptor out_clk_src_desc = {
 150         .bLength = sizeof out_clk_src_desc,
 151         .bDescriptorType = USB_DT_CS_INTERFACE,
 152
 153         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 154         .bClockID = USB_OUT_CLK_ID,
 155         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 156         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 157         .bAssocTerminal = 0,
 158 };
 159
 160 /* Input Terminal for USB_OUT */
 161 static struct uac2_input_terminal_descriptor usb_out_it_desc = {
 162         .bLength = sizeof usb_out_it_desc,
 163         .bDescriptorType = USB_DT_CS_INTERFACE,
 164
 165         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 166         .bTerminalID = USB_OUT_IT_ID,
 167         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 168         .bAssocTerminal = 0,
 169         .bCSourceID = USB_OUT_CLK_ID,
 170         .iChannelNames = 0,
 171         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 172 };
 173
 174 /* Input Terminal for I/O-In */
 175 static struct uac2_input_terminal_descriptor io_in_it_desc = {
 176         .bLength = sizeof io_in_it_desc,
 177         .bDescriptorType = USB_DT_CS_INTERFACE,
 178
 179         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 180         .bTerminalID = IO_IN_IT_ID,
 181         .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
 182         .bAssocTerminal = 0,
 183         .bCSourceID = USB_IN_CLK_ID,
 184         .iChannelNames = 0,
 185         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 186 };
 187
 188 /* Ouput Terminal for USB_IN */
 189 static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
 190         .bLength = sizeof usb_in_ot_desc,
 191         .bDescriptorType = USB_DT_CS_INTERFACE,
 192
 193         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 194         .bTerminalID = USB_IN_OT_ID,
 195         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 196         .bAssocTerminal = 0,
 197         .bSourceID = IO_IN_IT_ID,
 198         .bCSourceID = USB_IN_CLK_ID,
 199         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 200 };
 201
 202 /* Ouput Terminal for I/O-Out */
 203 static struct uac2_output_terminal_descriptor io_out_ot_desc = {
 204         .bLength = sizeof io_out_ot_desc,
 205         .bDescriptorType = USB_DT_CS_INTERFACE,
 206
 207         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 208         .bTerminalID = IO_OUT_OT_ID,
 209         .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
 210         .bAssocTerminal = 0,
 211         .bSourceID = USB_OUT_IT_ID,
 212         .bCSourceID = USB_OUT_CLK_ID,
 213         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 214 };
 215
 216 static struct uac2_ac_header_descriptor ac_hdr_desc = {
 217         .bLength = sizeof ac_hdr_desc,
 218         .bDescriptorType = USB_DT_CS_INTERFACE,
 219
 220         .bDescriptorSubtype = UAC_MS_HEADER,
 221         .bcdADC = cpu_to_le16(0x200),
 222         .bCategory = UAC2_FUNCTION_IO_BOX,
 223         .wTotalLength = cpu_to_le16(sizeof in_clk_src_desc
 224                         + sizeof out_clk_src_desc + sizeof usb_out_it_desc
 225                         + sizeof io_in_it_desc + sizeof usb_in_ot_desc
 226                         + sizeof io_out_ot_desc),
 227         .bmControls = 0,
 228 };
 229
 230 /* Audio Streaming OUT Interface - Alt0 */
 231 static struct usb_interface_descriptor std_as_out_if0_desc = {
 232         .bLength = sizeof std_as_out_if0_desc,
 233         .bDescriptorType = USB_DT_INTERFACE,
 234
 235         .bAlternateSetting = 0,
 236         .bNumEndpoints = 0,
 237         .bInterfaceClass = USB_CLASS_AUDIO,
 238         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 239         .bInterfaceProtocol = UAC_VERSION_2,
 240 };
 241
 242 /* Audio Streaming OUT Interface - Alt1 */
 243 static struct usb_interface_descriptor std_as_out_if1_desc = {
 244         .bLength = sizeof std_as_out_if1_desc,
 245         .bDescriptorType = USB_DT_INTERFACE,
 246
 247         .bAlternateSetting = 1,
 248         .bNumEndpoints = 1,
 249         .bInterfaceClass = USB_CLASS_AUDIO,
 250         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 251         .bInterfaceProtocol = UAC_VERSION_2,
 252 };
 253
 254 /* Audio Stream OUT Intface Desc */
 255 static struct uac2_as_header_descriptor as_out_hdr_desc = {
 256         .bLength = sizeof as_out_hdr_desc,
 257         .bDescriptorType = USB_DT_CS_INTERFACE,
 258
 259         .bDescriptorSubtype = UAC_AS_GENERAL,
 260         .bTerminalLink = USB_OUT_IT_ID,
 261         .bmControls = 0,
 262         .bFormatType = UAC_FORMAT_TYPE_I,
 263         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 264         .iChannelNames = 0,
 265 };
 266
 267 /* Audio USB_OUT Format */
 268 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
 269         .bLength = sizeof as_out_fmt1_desc,
 270         .bDescriptorType = USB_DT_CS_INTERFACE,
 271         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 272         .bFormatType = UAC_FORMAT_TYPE_I,
 273 };
 274
 275 /* STD AS ISO OUT Endpoint */
 276 static struct usb_endpoint_descriptor fs_epout_desc = {
 277         .bLength = USB_DT_ENDPOINT_SIZE,
 278         .bDescriptorType = USB_DT_ENDPOINT,
 279
 280         .bEndpointAddress = USB_DIR_OUT,
 281         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 282         .wMaxPacketSize = cpu_to_le16(1023),
 283         .bInterval = 1,
 284 };
 285
 286 static struct usb_endpoint_descriptor hs_epout_desc = {
 287         .bLength = USB_DT_ENDPOINT_SIZE,
 288         .bDescriptorType = USB_DT_ENDPOINT,
 289
 290         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 291         .wMaxPacketSize = cpu_to_le16(1024),
 292         .bInterval = 4,
 293 };
 294
 295 /* CS AS ISO OUT Endpoint */
 296 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
 297         .bLength = sizeof as_iso_out_desc,
 298         .bDescriptorType = USB_DT_CS_ENDPOINT,
 299
 300         .bDescriptorSubtype = UAC_EP_GENERAL,
 301         .bmAttributes = 0,
 302         .bmControls = 0,
 303         .bLockDelayUnits = 0,
 304         .wLockDelay = 0,
 305 };
 306
 307 /* Audio Streaming IN Interface - Alt0 */
 308 static struct usb_interface_descriptor std_as_in_if0_desc = {
 309         .bLength = sizeof std_as_in_if0_desc,
 310         .bDescriptorType = USB_DT_INTERFACE,
 311
 312         .bAlternateSetting = 0,
 313         .bNumEndpoints = 0,
 314         .bInterfaceClass = USB_CLASS_AUDIO,
 315         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 316         .bInterfaceProtocol = UAC_VERSION_2,
 317 };
 318
 319 /* Audio Streaming IN Interface - Alt1 */
 320 static struct usb_interface_descriptor std_as_in_if1_desc = {
 321         .bLength = sizeof std_as_in_if1_desc,
 322         .bDescriptorType = USB_DT_INTERFACE,
 323
 324         .bAlternateSetting = 1,
 325         .bNumEndpoints = 1,
 326         .bInterfaceClass = USB_CLASS_AUDIO,
 327         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 328         .bInterfaceProtocol = UAC_VERSION_2,
 329 };
 330
 331 /* Audio Stream IN Intface Desc */
 332 static struct uac2_as_header_descriptor as_in_hdr_desc = {
 333         .bLength = sizeof as_in_hdr_desc,
 334         .bDescriptorType = USB_DT_CS_INTERFACE,
 335
 336         .bDescriptorSubtype = UAC_AS_GENERAL,
 337         .bTerminalLink = USB_IN_OT_ID,
 338         .bmControls = 0,
 339         .bFormatType = UAC_FORMAT_TYPE_I,
 340         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 341         .iChannelNames = 0,
 342 };
 343
 344 /* Audio USB_IN Format */
 345 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
 346         .bLength = sizeof as_in_fmt1_desc,
 347         .bDescriptorType = USB_DT_CS_INTERFACE,
 348         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 349         .bFormatType = UAC_FORMAT_TYPE_I,
 350 };
 351
 352 /* STD AS ISO IN Endpoint */
 353 static struct usb_endpoint_descriptor fs_epin_desc = {
 354         .bLength = USB_DT_ENDPOINT_SIZE,
 355         .bDescriptorType = USB_DT_ENDPOINT,
 356
 357         .bEndpointAddress = USB_DIR_IN,
 358         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 359         .wMaxPacketSize = cpu_to_le16(1023),
 360         .bInterval = 1,
 361 };
 362
 363 static struct usb_endpoint_descriptor hs_epin_desc = {
 364         .bLength = USB_DT_ENDPOINT_SIZE,
 365         .bDescriptorType = USB_DT_ENDPOINT,
 366
 367         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 368         .wMaxPacketSize = cpu_to_le16(1024),
 369         .bInterval = 4,
 370 };
 371
 372 /* CS AS ISO IN Endpoint */
 373 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
 374         .bLength = sizeof as_iso_in_desc,
 375         .bDescriptorType = USB_DT_CS_ENDPOINT,
 376
 377         .bDescriptorSubtype = UAC_EP_GENERAL,
 378         .bmAttributes = 0,
 379         .bmControls = 0,
 380         .bLockDelayUnits = 0,
 381         .wLockDelay = 0,
 382 };
 383
 384 static struct usb_descriptor_header *fs_audio_desc[] = {
 385         (struct usb_descriptor_header *)&iad_desc,
 386         (struct usb_descriptor_header *)&std_ac_if_desc,
 387
 388         (struct usb_descriptor_header *)&ac_hdr_desc,
 389         (struct usb_descriptor_header *)&in_clk_src_desc,
 390         (struct usb_descriptor_header *)&out_clk_src_desc,
 391         (struct usb_descriptor_header *)&usb_out_it_desc,
 392         (struct usb_descriptor_header *)&io_in_it_desc,
 393         (struct usb_descriptor_header *)&usb_in_ot_desc,
 394         (struct usb_descriptor_header *)&io_out_ot_desc,
 395
 396         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 397         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 398
 399         (struct usb_descriptor_header *)&as_out_hdr_desc,
 400         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 401         (struct usb_descriptor_header *)&fs_epout_desc,
 402         (struct usb_descriptor_header *)&as_iso_out_desc,
 403
 404         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 405         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 406
 407         (struct usb_descriptor_header *)&as_in_hdr_desc,
 408         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 409         (struct usb_descriptor_header *)&fs_epin_desc,
 410         (struct usb_descriptor_header *)&as_iso_in_desc,
 411         NULL,
 412 };
 413
 414 static struct usb_descriptor_header *hs_audio_desc[] = {
 415         (struct usb_descriptor_header *)&iad_desc,
 416         (struct usb_descriptor_header *)&std_ac_if_desc,
 417
 418         (struct usb_descriptor_header *)&ac_hdr_desc,
 419         (struct usb_descriptor_header *)&in_clk_src_desc,
 420         (struct usb_descriptor_header *)&out_clk_src_desc,
 421         (struct usb_descriptor_header *)&usb_out_it_desc,
 422         (struct usb_descriptor_header *)&io_in_it_desc,
 423         (struct usb_descriptor_header *)&usb_in_ot_desc,
 424         (struct usb_descriptor_header *)&io_out_ot_desc,
 425
 426         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 427         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 428
 429         (struct usb_descriptor_header *)&as_out_hdr_desc,
 430         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 431         (struct usb_descriptor_header *)&hs_epout_desc,
 432         (struct usb_descriptor_header *)&as_iso_out_desc,
 433
 434         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 435         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 436
 437         (struct usb_descriptor_header *)&as_in_hdr_desc,
 438         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 439         (struct usb_descriptor_header *)&hs_epin_desc,
 440         (struct usb_descriptor_header *)&as_iso_in_desc,
 441         NULL,
 442 };
 443
 444 struct cntrl_cur_lay3 {
 445         __u32   dCUR;
 446 };
 447
 448 struct cntrl_range_lay3 {
 449         __u16   wNumSubRanges;
 450         __u32   dMIN;
 451         __u32   dMAX;
 452         __u32   dRES;
 453 } __packed;
 454
 455 static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 456         struct usb_endpoint_descriptor *ep_desc,
 457         unsigned int factor, bool is_playback)
 458 {
 459         int chmask, srate, ssize;
 460         u16 max_packet_size;
 461
 462         if (is_playback) {
 463                 chmask = uac2_opts->p_chmask;
 464                 srate = uac2_opts->p_srate;
 465                 ssize = uac2_opts->p_ssize;
 466         } else {
 467                 chmask = uac2_opts->c_chmask;
 468                 srate = uac2_opts->c_srate;
 469                 ssize = uac2_opts->c_ssize;
 470         }
 471
 472         max_packet_size = num_channels(chmask) * ssize *
 473                 DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));
 474         ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_packet_size,
 475                                 le16_to_cpu(ep_desc->wMaxPacketSize)));
 476 }
 477
 478 static int
 479 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 480 {
 481         struct f_uac2 *uac2 = func_to_uac2(fn);
 482         struct g_audio *agdev = func_to_g_audio(fn);
 483         struct usb_composite_dev *cdev = cfg->cdev;
 484         struct usb_gadget *gadget = cdev->gadget;
 485         struct device *dev = &gadget->dev;
 486         struct f_uac2_opts *uac2_opts;
 487         struct usb_string *us;
 488         int ret;
 489
 490         uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
 491
 492         us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
 493         if (IS_ERR(us))
 494                 return PTR_ERR(us);
 495         iad_desc.iFunction = us[STR_ASSOC].id;
 496         std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
 497         in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
 498         out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
 499         usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
 500         io_in_it_desc.iTerminal = us[STR_IO_IT].id;
 501         usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
 502         io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
 503         std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
 504         std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
 505         std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
 506         std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
 507
 508
 509         /* Initialize the configurable parameters */
 510         usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 511         usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 512         io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 513         io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 514         as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 515         as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 516         as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 517         as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 518         as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
 519         as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
 520         as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
 521         as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
 522
 523         snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
 524         snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
 525
 526         ret = usb_interface_id(cfg, fn);
 527         if (ret < 0) {
 528                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 529                 return ret;
 530         }
 531         std_ac_if_desc.bInterfaceNumber = ret;
 532         uac2->ac_intf = ret;
 533         uac2->ac_alt = 0;
 534
 535         ret = usb_interface_id(cfg, fn);
 536         if (ret < 0) {
 537                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 538                 return ret;
 539         }
 540         std_as_out_if0_desc.bInterfaceNumber = ret;
 541         std_as_out_if1_desc.bInterfaceNumber = ret;
 542         uac2->as_out_intf = ret;
 543         uac2->as_out_alt = 0;
 544
 545         ret = usb_interface_id(cfg, fn);
 546         if (ret < 0) {
 547                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 548                 return ret;
 549         }
 550         std_as_in_if0_desc.bInterfaceNumber = ret;
 551         std_as_in_if1_desc.bInterfaceNumber = ret;
 552         uac2->as_in_intf = ret;
 553         uac2->as_in_alt = 0;
 554
 555         /* Calculate wMaxPacketSize according to audio bandwidth */
 556         set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
 557         set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
 558         set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
 559         set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
 560
 561         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
 562         if (!agdev->out_ep) {
 563                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 564                 return ret;
 565         }
 566
 567         agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
 568         if (!agdev->in_ep) {
 569                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 570                 return ret;
 571         }
 572
 573         agdev->in_ep_maxpsize = max_t(u16,
 574                                 le16_to_cpu(fs_epin_desc.wMaxPacketSize),
 575                                 le16_to_cpu(hs_epin_desc.wMaxPacketSize));
 576         agdev->out_ep_maxpsize = max_t(u16,
 577                                 le16_to_cpu(fs_epout_desc.wMaxPacketSize),
 578                                 le16_to_cpu(hs_epout_desc.wMaxPacketSize));
 579
 580         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 581         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 582
 583         ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL,
 584                                      NULL);
 585         if (ret)
 586                 return ret;
 587
 588         agdev->gadget = gadget;
 589
 590         agdev->params.p_chmask = uac2_opts->p_chmask;
 591         agdev->params.p_srate = uac2_opts->p_srate;
 592         agdev->params.p_ssize = uac2_opts->p_ssize;
 593         agdev->params.c_chmask = uac2_opts->c_chmask;
 594         agdev->params.c_srate = uac2_opts->c_srate;
 595         agdev->params.c_ssize = uac2_opts->c_ssize;
 596         agdev->params.req_number = uac2_opts->req_number;
 597         ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
 598         if (ret)
 599                 goto err_free_descs;
 600         return 0;
 601
 602 err_free_descs:
 603         usb_free_all_descriptors(fn);
 604         agdev->gadget = NULL;
 605         return ret;
 606 }
 607
 608 static int
 609 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
 610 {
 611         struct usb_composite_dev *cdev = fn->config->cdev;
 612         struct f_uac2 *uac2 = func_to_uac2(fn);
 613         struct usb_gadget *gadget = cdev->gadget;
 614         struct device *dev = &gadget->dev;
 615         int ret = 0;
 616
 617         /* No i/f has more than 2 alt settings */
 618         if (alt > 1) {
 619                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 620                 return -EINVAL;
 621         }
 622
 623         if (intf == uac2->ac_intf) {
 624                 /* Control I/f has only 1 AltSetting - 0 */
 625                 if (alt) {
 626                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 627                         return -EINVAL;
 628                 }
 629                 return 0;
 630         }
 631
 632         if (intf == uac2->as_out_intf) {
 633                 uac2->as_out_alt = alt;
 634
 635                 if (alt)
 636                         ret = u_audio_start_capture(&uac2->g_audio);
 637                 else
 638                         u_audio_stop_capture(&uac2->g_audio);
 639         } else if (intf == uac2->as_in_intf) {
 640                 uac2->as_in_alt = alt;
 641
 642                 if (alt)
 643                         ret = u_audio_start_playback(&uac2->g_audio);
 644                 else
 645                         u_audio_stop_playback(&uac2->g_audio);
 646         } else {
 647                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 648                 return -EINVAL;
 649         }
 650
 651         return ret;
 652 }
 653
 654 static int
 655 afunc_get_alt(struct usb_function *fn, unsigned intf)
 656 {
 657         struct f_uac2 *uac2 = func_to_uac2(fn);
 658         struct g_audio *agdev = func_to_g_audio(fn);
 659
 660         if (intf == uac2->ac_intf)
 661                 return uac2->ac_alt;
 662         else if (intf == uac2->as_out_intf)
 663                 return uac2->as_out_alt;
 664         else if (intf == uac2->as_in_intf)
 665                 return uac2->as_in_alt;
 666         else
 667                 dev_err(&agdev->gadget->dev,
 668                         "%s:%d Invalid Interface %d!\n",
 669                         __func__, __LINE__, intf);
 670
 671         return -EINVAL;
 672 }
 673
 674 static void
 675 afunc_disable(struct usb_function *fn)
 676 {
 677         struct f_uac2 *uac2 = func_to_uac2(fn);
 678
 679         uac2->as_in_alt = 0;
 680         uac2->as_out_alt = 0;
 681         u_audio_stop_capture(&uac2->g_audio);
 682         u_audio_stop_playback(&uac2->g_audio);
 683 }
 684
 685 static int
 686 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 687 {
 688         struct usb_request *req = fn->config->cdev->req;
 689         struct g_audio *agdev = func_to_g_audio(fn);
 690         struct f_uac2_opts *opts;
 691         u16 w_length = le16_to_cpu(cr->wLength);
 692         u16 w_index = le16_to_cpu(cr->wIndex);
 693         u16 w_value = le16_to_cpu(cr->wValue);
 694         u8 entity_id = (w_index >> 8) & 0xff;
 695         u8 control_selector = w_value >> 8;
 696         int value = -EOPNOTSUPP;
 697         int p_srate, c_srate;
 698
 699         opts = g_audio_to_uac2_opts(agdev);
 700         p_srate = opts->p_srate;
 701         c_srate = opts->c_srate;
 702
 703         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
 704                 struct cntrl_cur_lay3 c;
 705                 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
 706
 707                 if (entity_id == USB_IN_CLK_ID)
 708                         c.dCUR = p_srate;
 709                 else if (entity_id == USB_OUT_CLK_ID)
 710                         c.dCUR = c_srate;
 711
 712                 value = min_t(unsigned, w_length, sizeof c);
 713                 memcpy(req->buf, &c, value);
 714         } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
 715                 *(u8 *)req->buf = 1;
 716                 value = min_t(unsigned, w_length, 1);
 717         } else {
 718                 dev_err(&agdev->gadget->dev,
 719                         "%s:%d control_selector=%d TODO!\n",
 720                         __func__, __LINE__, control_selector);
 721         }
 722
 723         return value;
 724 }
 725
 726 static int
 727 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 728 {
 729         struct usb_request *req = fn->config->cdev->req;
 730         struct g_audio *agdev = func_to_g_audio(fn);
 731         struct f_uac2_opts *opts;
 732         u16 w_length = le16_to_cpu(cr->wLength);
 733         u16 w_index = le16_to_cpu(cr->wIndex);
 734         u16 w_value = le16_to_cpu(cr->wValue);
 735         u8 entity_id = (w_index >> 8) & 0xff;
 736         u8 control_selector = w_value >> 8;
 737         struct cntrl_range_lay3 r;
 738         int value = -EOPNOTSUPP;
 739         int p_srate, c_srate;
 740
 741         opts = g_audio_to_uac2_opts(agdev);
 742         p_srate = opts->p_srate;
 743         c_srate = opts->c_srate;
 744
 745         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
 746                 if (entity_id == USB_IN_CLK_ID)
 747                         r.dMIN = p_srate;
 748                 else if (entity_id == USB_OUT_CLK_ID)
 749                         r.dMIN = c_srate;
 750                 else
 751                         return -EOPNOTSUPP;
 752
 753                 r.dMAX = r.dMIN;
 754                 r.dRES = 0;
 755                 r.wNumSubRanges = 1;
 756
 757                 value = min_t(unsigned, w_length, sizeof r);
 758                 memcpy(req->buf, &r, value);
 759         } else {
 760                 dev_err(&agdev->gadget->dev,
 761                         "%s:%d control_selector=%d TODO!\n",
 762                         __func__, __LINE__, control_selector);
 763         }
 764
 765         return value;
 766 }
 767
 768 static int
 769 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 770 {
 771         if (cr->bRequest == UAC2_CS_CUR)
 772                 return in_rq_cur(fn, cr);
 773         else if (cr->bRequest == UAC2_CS_RANGE)
 774                 return in_rq_range(fn, cr);
 775         else
 776                 return -EOPNOTSUPP;
 777 }
 778
 779 static int
 780 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 781 {
 782         u16 w_length = le16_to_cpu(cr->wLength);
 783         u16 w_value = le16_to_cpu(cr->wValue);
 784         u8 control_selector = w_value >> 8;
 785
 786         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
 787                 return w_length;
 788
 789         return -EOPNOTSUPP;
 790 }
 791
 792 static int
 793 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 794 {
 795         struct f_uac2 *uac2 = func_to_uac2(fn);
 796         struct g_audio *agdev = func_to_g_audio(fn);
 797         u16 w_index = le16_to_cpu(cr->wIndex);
 798         u8 intf = w_index & 0xff;
 799
 800         if (intf != uac2->ac_intf) {
 801                 dev_err(&agdev->gadget->dev,
 802                         "%s:%d Error!\n", __func__, __LINE__);
 803                 return -EOPNOTSUPP;
 804         }
 805
 806         if (cr->bRequestType & USB_DIR_IN)
 807                 return ac_rq_in(fn, cr);
 808         else if (cr->bRequest == UAC2_CS_CUR)
 809                 return out_rq_cur(fn, cr);
 810
 811         return -EOPNOTSUPP;
 812 }
 813
 814 static int
 815 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 816 {
 817         struct usb_composite_dev *cdev = fn->config->cdev;
 818         struct g_audio *agdev = func_to_g_audio(fn);
 819         struct usb_request *req = cdev->req;
 820         u16 w_length = le16_to_cpu(cr->wLength);
 821         int value = -EOPNOTSUPP;
 822
 823         /* Only Class specific requests are supposed to reach here */
 824         if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
 825                 return -EOPNOTSUPP;
 826
 827         if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
 828                 value = setup_rq_inf(fn, cr);
 829         else
 830                 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
 831                                 __func__, __LINE__);
 832
 833         if (value >= 0) {
 834                 req->length = value;
 835                 req->zero = value < w_length;
 836                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 837                 if (value < 0) {
 838                         dev_err(&agdev->gadget->dev,
 839                                 "%s:%d Error!\n", __func__, __LINE__);
 840                         req->status = 0;
 841                 }
 842         }
 843
 844         return value;
 845 }
 846
 847 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
 848 {
 849         return container_of(to_config_group(item), struct f_uac2_opts,
 850                             func_inst.group);
 851 }
 852
 853 static void f_uac2_attr_release(struct config_item *item)
 854 {
 855         struct f_uac2_opts *opts = to_f_uac2_opts(item);
 856
 857         usb_put_function_instance(&opts->func_inst);
 858 }
 859
 860 static struct configfs_item_operations f_uac2_item_ops = {
 861         .release        = f_uac2_attr_release,
 862 };
 863
 864 #define UAC2_ATTRIBUTE(name)                                            \
 865 static ssize_t f_uac2_opts_##name##_show(struct config_item *item,      \
 866                                          char *page)                    \
 867 {                                                                       \
 868         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
 869         int result;                                                     \
 870                                                                         \
 871         mutex_lock(&opts->lock);                                        \
 872         result = sprintf(page, "%u\n", opts->name);                     \
 873         mutex_unlock(&opts->lock);                                      \
 874                                                                         \
 875         return result;                                                  \
 876 }                                                                       \
 877                                                                         \
 878 static ssize_t f_uac2_opts_##name##_store(struct config_item *item,     \
 879                                           const char *page, size_t len) \
 880 {                                                                       \
 881         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
 882         int ret;                                                        \
 883         u32 num;                                                        \
 884                                                                         \
 885         mutex_lock(&opts->lock);                                        \
 886         if (opts->refcnt) {                                             \
 887                 ret = -EBUSY;                                           \
 888                 goto end;                                               \
 889         }                                                               \
 890                                                                         \
 891         ret = kstrtou32(page, 0, &num);                                 \
 892         if (ret)                                                        \
 893                 goto end;                                               \
 894                                                                         \
 895         opts->name = num;                                               \
 896         ret = len;                                                      \
 897                                                                         \
 898 end:                                                                    \
 899         mutex_unlock(&opts->lock);                                      \
 900         return ret;                                                     \
 901 }                                                                       \
 902                                                                         \
 903 CONFIGFS_ATTR(f_uac2_opts_, name)
 904
 905 UAC2_ATTRIBUTE(p_chmask);
 906 UAC2_ATTRIBUTE(p_srate);
 907 UAC2_ATTRIBUTE(p_ssize);
 908 UAC2_ATTRIBUTE(c_chmask);
 909 UAC2_ATTRIBUTE(c_srate);
 910 UAC2_ATTRIBUTE(c_ssize);
 911 UAC2_ATTRIBUTE(req_number);
 912
 913 static struct configfs_attribute *f_uac2_attrs[] = {
 914         &f_uac2_opts_attr_p_chmask,
 915         &f_uac2_opts_attr_p_srate,
 916         &f_uac2_opts_attr_p_ssize,
 917         &f_uac2_opts_attr_c_chmask,
 918         &f_uac2_opts_attr_c_srate,
 919         &f_uac2_opts_attr_c_ssize,
 920         &f_uac2_opts_attr_req_number,
 921         NULL,
 922 };
 923
 924 static struct config_item_type f_uac2_func_type = {
 925         .ct_item_ops    = &f_uac2_item_ops,
 926         .ct_attrs       = f_uac2_attrs,
 927         .ct_owner       = THIS_MODULE,
 928 };
 929
 930 static void afunc_free_inst(struct usb_function_instance *f)
 931 {
 932         struct f_uac2_opts *opts;
 933
 934         opts = container_of(f, struct f_uac2_opts, func_inst);
 935         kfree(opts);
 936 }
 937
 938 static struct usb_function_instance *afunc_alloc_inst(void)
 939 {
 940         struct f_uac2_opts *opts;
 941
 942         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 943         if (!opts)
 944                 return ERR_PTR(-ENOMEM);
 945
 946         mutex_init(&opts->lock);
 947         opts->func_inst.free_func_inst = afunc_free_inst;
 948
 949         config_group_init_type_name(&opts->func_inst.group, "",
 950                                     &f_uac2_func_type);
 951
 952         opts->p_chmask = UAC2_DEF_PCHMASK;
 953         opts->p_srate = UAC2_DEF_PSRATE;
 954         opts->p_ssize = UAC2_DEF_PSSIZE;
 955         opts->c_chmask = UAC2_DEF_CCHMASK;
 956         opts->c_srate = UAC2_DEF_CSRATE;
 957         opts->c_ssize = UAC2_DEF_CSSIZE;
 958         opts->req_number = UAC2_DEF_REQ_NUM;
 959         return &opts->func_inst;
 960 }
 961
 962 static void afunc_free(struct usb_function *f)
 963 {
 964         struct g_audio *agdev;
 965         struct f_uac2_opts *opts;
 966
 967         agdev = func_to_g_audio(f);
 968         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
 969         kfree(agdev);
 970         mutex_lock(&opts->lock);
 971         --opts->refcnt;
 972         mutex_unlock(&opts->lock);
 973 }
 974
 975 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 976 {
 977         struct g_audio *agdev = func_to_g_audio(f);
 978
 979         g_audio_cleanup(agdev);
 980         usb_free_all_descriptors(f);
 981
 982         agdev->gadget = NULL;
 983 }
 984
 985 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
 986 {
 987         struct f_uac2   *uac2;
 988         struct f_uac2_opts *opts;
 989
 990         uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
 991         if (uac2 == NULL)
 992                 return ERR_PTR(-ENOMEM);
 993
 994         opts = container_of(fi, struct f_uac2_opts, func_inst);
 995         mutex_lock(&opts->lock);
 996         ++opts->refcnt;
 997         mutex_unlock(&opts->lock);
 998
 999         uac2->g_audio.func.name = "uac2_func";
1000         uac2->g_audio.func.bind = afunc_bind;
1001         uac2->g_audio.func.unbind = afunc_unbind;
1002         uac2->g_audio.func.set_alt = afunc_set_alt;
1003         uac2->g_audio.func.get_alt = afunc_get_alt;
1004         uac2->g_audio.func.disable = afunc_disable;
1005         uac2->g_audio.func.setup = afunc_setup;
1006         uac2->g_audio.func.free_func = afunc_free;
1007
1008         return &uac2->g_audio.func;
1009 }
1010
1011 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1012 MODULE_LICENSE("GPL");
1013 MODULE_AUTHOR("Yadwinder Singh");
1014 MODULE_AUTHOR("Jaswinder Singh");