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 = (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 = (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 = (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 = (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 = sizeof in_clk_src_desc + sizeof out_clk_src_desc
 224                          + sizeof usb_out_it_desc + sizeof io_in_it_desc
 225                         + sizeof usb_in_ot_desc + sizeof io_out_ot_desc,
 226         .bmControls = 0,
 227 };
 228
 229 /* Audio Streaming OUT Interface - Alt0 */
 230 static struct usb_interface_descriptor std_as_out_if0_desc = {
 231         .bLength = sizeof std_as_out_if0_desc,
 232         .bDescriptorType = USB_DT_INTERFACE,
 233
 234         .bAlternateSetting = 0,
 235         .bNumEndpoints = 0,
 236         .bInterfaceClass = USB_CLASS_AUDIO,
 237         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 238         .bInterfaceProtocol = UAC_VERSION_2,
 239 };
 240
 241 /* Audio Streaming OUT Interface - Alt1 */
 242 static struct usb_interface_descriptor std_as_out_if1_desc = {
 243         .bLength = sizeof std_as_out_if1_desc,
 244         .bDescriptorType = USB_DT_INTERFACE,
 245
 246         .bAlternateSetting = 1,
 247         .bNumEndpoints = 1,
 248         .bInterfaceClass = USB_CLASS_AUDIO,
 249         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 250         .bInterfaceProtocol = UAC_VERSION_2,
 251 };
 252
 253 /* Audio Stream OUT Intface Desc */
 254 static struct uac2_as_header_descriptor as_out_hdr_desc = {
 255         .bLength = sizeof as_out_hdr_desc,
 256         .bDescriptorType = USB_DT_CS_INTERFACE,
 257
 258         .bDescriptorSubtype = UAC_AS_GENERAL,
 259         .bTerminalLink = USB_OUT_IT_ID,
 260         .bmControls = 0,
 261         .bFormatType = UAC_FORMAT_TYPE_I,
 262         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 263         .iChannelNames = 0,
 264 };
 265
 266 /* Audio USB_OUT Format */
 267 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
 268         .bLength = sizeof as_out_fmt1_desc,
 269         .bDescriptorType = USB_DT_CS_INTERFACE,
 270         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 271         .bFormatType = UAC_FORMAT_TYPE_I,
 272 };
 273
 274 /* STD AS ISO OUT Endpoint */
 275 static struct usb_endpoint_descriptor fs_epout_desc = {
 276         .bLength = USB_DT_ENDPOINT_SIZE,
 277         .bDescriptorType = USB_DT_ENDPOINT,
 278
 279         .bEndpointAddress = USB_DIR_OUT,
 280         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 281         .wMaxPacketSize = cpu_to_le16(1023),
 282         .bInterval = 1,
 283 };
 284
 285 static struct usb_endpoint_descriptor hs_epout_desc = {
 286         .bLength = USB_DT_ENDPOINT_SIZE,
 287         .bDescriptorType = USB_DT_ENDPOINT,
 288
 289         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 290         .wMaxPacketSize = cpu_to_le16(1024),
 291         .bInterval = 4,
 292 };
 293
 294 /* CS AS ISO OUT Endpoint */
 295 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
 296         .bLength = sizeof as_iso_out_desc,
 297         .bDescriptorType = USB_DT_CS_ENDPOINT,
 298
 299         .bDescriptorSubtype = UAC_EP_GENERAL,
 300         .bmAttributes = 0,
 301         .bmControls = 0,
 302         .bLockDelayUnits = 0,
 303         .wLockDelay = 0,
 304 };
 305
 306 /* Audio Streaming IN Interface - Alt0 */
 307 static struct usb_interface_descriptor std_as_in_if0_desc = {
 308         .bLength = sizeof std_as_in_if0_desc,
 309         .bDescriptorType = USB_DT_INTERFACE,
 310
 311         .bAlternateSetting = 0,
 312         .bNumEndpoints = 0,
 313         .bInterfaceClass = USB_CLASS_AUDIO,
 314         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 315         .bInterfaceProtocol = UAC_VERSION_2,
 316 };
 317
 318 /* Audio Streaming IN Interface - Alt1 */
 319 static struct usb_interface_descriptor std_as_in_if1_desc = {
 320         .bLength = sizeof std_as_in_if1_desc,
 321         .bDescriptorType = USB_DT_INTERFACE,
 322
 323         .bAlternateSetting = 1,
 324         .bNumEndpoints = 1,
 325         .bInterfaceClass = USB_CLASS_AUDIO,
 326         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 327         .bInterfaceProtocol = UAC_VERSION_2,
 328 };
 329
 330 /* Audio Stream IN Intface Desc */
 331 static struct uac2_as_header_descriptor as_in_hdr_desc = {
 332         .bLength = sizeof as_in_hdr_desc,
 333         .bDescriptorType = USB_DT_CS_INTERFACE,
 334
 335         .bDescriptorSubtype = UAC_AS_GENERAL,
 336         .bTerminalLink = USB_IN_OT_ID,
 337         .bmControls = 0,
 338         .bFormatType = UAC_FORMAT_TYPE_I,
 339         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 340         .iChannelNames = 0,
 341 };
 342
 343 /* Audio USB_IN Format */
 344 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
 345         .bLength = sizeof as_in_fmt1_desc,
 346         .bDescriptorType = USB_DT_CS_INTERFACE,
 347         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 348         .bFormatType = UAC_FORMAT_TYPE_I,
 349 };
 350
 351 /* STD AS ISO IN Endpoint */
 352 static struct usb_endpoint_descriptor fs_epin_desc = {
 353         .bLength = USB_DT_ENDPOINT_SIZE,
 354         .bDescriptorType = USB_DT_ENDPOINT,
 355
 356         .bEndpointAddress = USB_DIR_IN,
 357         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 358         .wMaxPacketSize = cpu_to_le16(1023),
 359         .bInterval = 1,
 360 };
 361
 362 static struct usb_endpoint_descriptor hs_epin_desc = {
 363         .bLength = USB_DT_ENDPOINT_SIZE,
 364         .bDescriptorType = USB_DT_ENDPOINT,
 365
 366         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 367         .wMaxPacketSize = cpu_to_le16(1024),
 368         .bInterval = 4,
 369 };
 370
 371 /* CS AS ISO IN Endpoint */
 372 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
 373         .bLength = sizeof as_iso_in_desc,
 374         .bDescriptorType = USB_DT_CS_ENDPOINT,
 375
 376         .bDescriptorSubtype = UAC_EP_GENERAL,
 377         .bmAttributes = 0,
 378         .bmControls = 0,
 379         .bLockDelayUnits = 0,
 380         .wLockDelay = 0,
 381 };
 382
 383 static struct usb_descriptor_header *fs_audio_desc[] = {
 384         (struct usb_descriptor_header *)&iad_desc,
 385         (struct usb_descriptor_header *)&std_ac_if_desc,
 386
 387         (struct usb_descriptor_header *)&ac_hdr_desc,
 388         (struct usb_descriptor_header *)&in_clk_src_desc,
 389         (struct usb_descriptor_header *)&out_clk_src_desc,
 390         (struct usb_descriptor_header *)&usb_out_it_desc,
 391         (struct usb_descriptor_header *)&io_in_it_desc,
 392         (struct usb_descriptor_header *)&usb_in_ot_desc,
 393         (struct usb_descriptor_header *)&io_out_ot_desc,
 394
 395         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 396         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 397
 398         (struct usb_descriptor_header *)&as_out_hdr_desc,
 399         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 400         (struct usb_descriptor_header *)&fs_epout_desc,
 401         (struct usb_descriptor_header *)&as_iso_out_desc,
 402
 403         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 404         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 405
 406         (struct usb_descriptor_header *)&as_in_hdr_desc,
 407         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 408         (struct usb_descriptor_header *)&fs_epin_desc,
 409         (struct usb_descriptor_header *)&as_iso_in_desc,
 410         NULL,
 411 };
 412
 413 static struct usb_descriptor_header *hs_audio_desc[] = {
 414         (struct usb_descriptor_header *)&iad_desc,
 415         (struct usb_descriptor_header *)&std_ac_if_desc,
 416
 417         (struct usb_descriptor_header *)&ac_hdr_desc,
 418         (struct usb_descriptor_header *)&in_clk_src_desc,
 419         (struct usb_descriptor_header *)&out_clk_src_desc,
 420         (struct usb_descriptor_header *)&usb_out_it_desc,
 421         (struct usb_descriptor_header *)&io_in_it_desc,
 422         (struct usb_descriptor_header *)&usb_in_ot_desc,
 423         (struct usb_descriptor_header *)&io_out_ot_desc,
 424
 425         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 426         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 427
 428         (struct usb_descriptor_header *)&as_out_hdr_desc,
 429         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 430         (struct usb_descriptor_header *)&hs_epout_desc,
 431         (struct usb_descriptor_header *)&as_iso_out_desc,
 432
 433         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 434         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 435
 436         (struct usb_descriptor_header *)&as_in_hdr_desc,
 437         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 438         (struct usb_descriptor_header *)&hs_epin_desc,
 439         (struct usb_descriptor_header *)&as_iso_in_desc,
 440         NULL,
 441 };
 442
 443 struct cntrl_cur_lay3 {
 444         __u32   dCUR;
 445 };
 446
 447 struct cntrl_range_lay3 {
 448         __u16   wNumSubRanges;
 449         __u32   dMIN;
 450         __u32   dMAX;
 451         __u32   dRES;
 452 } __packed;
 453
 454 static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 455         struct usb_endpoint_descriptor *ep_desc,
 456         unsigned int factor, bool is_playback)
 457 {
 458         int chmask, srate, ssize;
 459         u16 max_packet_size;
 460
 461         if (is_playback) {
 462                 chmask = uac2_opts->p_chmask;
 463                 srate = uac2_opts->p_srate;
 464                 ssize = uac2_opts->p_ssize;
 465         } else {
 466                 chmask = uac2_opts->c_chmask;
 467                 srate = uac2_opts->c_srate;
 468                 ssize = uac2_opts->c_ssize;
 469         }
 470
 471         max_packet_size = num_channels(chmask) * ssize *
 472                 DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));
 473         ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_packet_size,
 474                                 le16_to_cpu(ep_desc->wMaxPacketSize)));
 475 }
 476
 477 static int
 478 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 479 {
 480         struct f_uac2 *uac2 = func_to_uac2(fn);
 481         struct g_audio *agdev = func_to_g_audio(fn);
 482         struct usb_composite_dev *cdev = cfg->cdev;
 483         struct usb_gadget *gadget = cdev->gadget;
 484         struct device *dev = &gadget->dev;
 485         struct f_uac2_opts *uac2_opts;
 486         struct usb_string *us;
 487         int ret;
 488
 489         uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
 490
 491         us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
 492         if (IS_ERR(us))
 493                 return PTR_ERR(us);
 494         iad_desc.iFunction = us[STR_ASSOC].id;
 495         std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
 496         in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
 497         out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
 498         usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
 499         io_in_it_desc.iTerminal = us[STR_IO_IT].id;
 500         usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
 501         io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
 502         std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
 503         std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
 504         std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
 505         std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
 506
 507
 508         /* Initialize the configurable parameters */
 509         usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 510         usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 511         io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 512         io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 513         as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 514         as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 515         as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 516         as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 517         as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
 518         as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
 519         as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
 520         as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
 521
 522         snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
 523         snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
 524
 525         ret = usb_interface_id(cfg, fn);
 526         if (ret < 0) {
 527                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 528                 return ret;
 529         }
 530         std_ac_if_desc.bInterfaceNumber = ret;
 531         uac2->ac_intf = ret;
 532         uac2->ac_alt = 0;
 533
 534         ret = usb_interface_id(cfg, fn);
 535         if (ret < 0) {
 536                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 537                 return ret;
 538         }
 539         std_as_out_if0_desc.bInterfaceNumber = ret;
 540         std_as_out_if1_desc.bInterfaceNumber = ret;
 541         uac2->as_out_intf = ret;
 542         uac2->as_out_alt = 0;
 543
 544         ret = usb_interface_id(cfg, fn);
 545         if (ret < 0) {
 546                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 547                 return ret;
 548         }
 549         std_as_in_if0_desc.bInterfaceNumber = ret;
 550         std_as_in_if1_desc.bInterfaceNumber = ret;
 551         uac2->as_in_intf = ret;
 552         uac2->as_in_alt = 0;
 553
 554         /* Calculate wMaxPacketSize according to audio bandwidth */
 555         set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
 556         set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
 557         set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
 558         set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
 559
 560         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
 561         if (!agdev->out_ep) {
 562                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 563                 return ret;
 564         }
 565
 566         agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
 567         if (!agdev->in_ep) {
 568                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 569                 return ret;
 570         }
 571
 572         agdev->in_ep_maxpsize = max(fs_epin_desc.wMaxPacketSize,
 573                                         hs_epin_desc.wMaxPacketSize);
 574         agdev->out_ep_maxpsize = max(fs_epout_desc.wMaxPacketSize,
 575                                         hs_epout_desc.wMaxPacketSize);
 576
 577         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 578         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 579
 580         ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL,
 581                                      NULL);
 582         if (ret)
 583                 return ret;
 584
 585         agdev->gadget = gadget;
 586
 587         agdev->params.p_chmask = uac2_opts->p_chmask;
 588         agdev->params.p_srate = uac2_opts->p_srate;
 589         agdev->params.p_ssize = uac2_opts->p_ssize;
 590         agdev->params.c_chmask = uac2_opts->c_chmask;
 591         agdev->params.c_srate = uac2_opts->c_srate;
 592         agdev->params.c_ssize = uac2_opts->c_ssize;
 593         agdev->params.req_number = uac2_opts->req_number;
 594         ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
 595         if (ret)
 596                 goto err_free_descs;
 597         return 0;
 598
 599 err_free_descs:
 600         usb_free_all_descriptors(fn);
 601         agdev->gadget = NULL;
 602         return ret;
 603 }
 604
 605 static int
 606 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
 607 {
 608         struct usb_composite_dev *cdev = fn->config->cdev;
 609         struct f_uac2 *uac2 = func_to_uac2(fn);
 610         struct usb_gadget *gadget = cdev->gadget;
 611         struct device *dev = &gadget->dev;
 612         int ret = 0;
 613
 614         /* No i/f has more than 2 alt settings */
 615         if (alt > 1) {
 616                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 617                 return -EINVAL;
 618         }
 619
 620         if (intf == uac2->ac_intf) {
 621                 /* Control I/f has only 1 AltSetting - 0 */
 622                 if (alt) {
 623                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 624                         return -EINVAL;
 625                 }
 626                 return 0;
 627         }
 628
 629         if (intf == uac2->as_out_intf) {
 630                 uac2->as_out_alt = alt;
 631
 632                 if (alt)
 633                         ret = u_audio_start_capture(&uac2->g_audio);
 634                 else
 635                         u_audio_stop_capture(&uac2->g_audio);
 636         } else if (intf == uac2->as_in_intf) {
 637                 uac2->as_in_alt = alt;
 638
 639                 if (alt)
 640                         ret = u_audio_start_playback(&uac2->g_audio);
 641                 else
 642                         u_audio_stop_playback(&uac2->g_audio);
 643         } else {
 644                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 645                 return -EINVAL;
 646         }
 647
 648         return ret;
 649 }
 650
 651 static int
 652 afunc_get_alt(struct usb_function *fn, unsigned intf)
 653 {
 654         struct f_uac2 *uac2 = func_to_uac2(fn);
 655         struct g_audio *agdev = func_to_g_audio(fn);
 656
 657         if (intf == uac2->ac_intf)
 658                 return uac2->ac_alt;
 659         else if (intf == uac2->as_out_intf)
 660                 return uac2->as_out_alt;
 661         else if (intf == uac2->as_in_intf)
 662                 return uac2->as_in_alt;
 663         else
 664                 dev_err(&agdev->gadget->dev,
 665                         "%s:%d Invalid Interface %d!\n",
 666                         __func__, __LINE__, intf);
 667
 668         return -EINVAL;
 669 }
 670
 671 static void
 672 afunc_disable(struct usb_function *fn)
 673 {
 674         struct f_uac2 *uac2 = func_to_uac2(fn);
 675
 676         uac2->as_in_alt = 0;
 677         uac2->as_out_alt = 0;
 678         u_audio_stop_capture(&uac2->g_audio);
 679         u_audio_stop_playback(&uac2->g_audio);
 680 }
 681
 682 static int
 683 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 684 {
 685         struct usb_request *req = fn->config->cdev->req;
 686         struct g_audio *agdev = func_to_g_audio(fn);
 687         struct f_uac2_opts *opts;
 688         u16 w_length = le16_to_cpu(cr->wLength);
 689         u16 w_index = le16_to_cpu(cr->wIndex);
 690         u16 w_value = le16_to_cpu(cr->wValue);
 691         u8 entity_id = (w_index >> 8) & 0xff;
 692         u8 control_selector = w_value >> 8;
 693         int value = -EOPNOTSUPP;
 694         int p_srate, c_srate;
 695
 696         opts = g_audio_to_uac2_opts(agdev);
 697         p_srate = opts->p_srate;
 698         c_srate = opts->c_srate;
 699
 700         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
 701                 struct cntrl_cur_lay3 c;
 702                 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
 703
 704                 if (entity_id == USB_IN_CLK_ID)
 705                         c.dCUR = p_srate;
 706                 else if (entity_id == USB_OUT_CLK_ID)
 707                         c.dCUR = c_srate;
 708
 709                 value = min_t(unsigned, w_length, sizeof c);
 710                 memcpy(req->buf, &c, value);
 711         } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
 712                 *(u8 *)req->buf = 1;
 713                 value = min_t(unsigned, w_length, 1);
 714         } else {
 715                 dev_err(&agdev->gadget->dev,
 716                         "%s:%d control_selector=%d TODO!\n",
 717                         __func__, __LINE__, control_selector);
 718         }
 719
 720         return value;
 721 }
 722
 723 static int
 724 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 725 {
 726         struct usb_request *req = fn->config->cdev->req;
 727         struct g_audio *agdev = func_to_g_audio(fn);
 728         struct f_uac2_opts *opts;
 729         u16 w_length = le16_to_cpu(cr->wLength);
 730         u16 w_index = le16_to_cpu(cr->wIndex);
 731         u16 w_value = le16_to_cpu(cr->wValue);
 732         u8 entity_id = (w_index >> 8) & 0xff;
 733         u8 control_selector = w_value >> 8;
 734         struct cntrl_range_lay3 r;
 735         int value = -EOPNOTSUPP;
 736         int p_srate, c_srate;
 737
 738         opts = g_audio_to_uac2_opts(agdev);
 739         p_srate = opts->p_srate;
 740         c_srate = opts->c_srate;
 741
 742         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
 743                 if (entity_id == USB_IN_CLK_ID)
 744                         r.dMIN = p_srate;
 745                 else if (entity_id == USB_OUT_CLK_ID)
 746                         r.dMIN = c_srate;
 747                 else
 748                         return -EOPNOTSUPP;
 749
 750                 r.dMAX = r.dMIN;
 751                 r.dRES = 0;
 752                 r.wNumSubRanges = 1;
 753
 754                 value = min_t(unsigned, w_length, sizeof r);
 755                 memcpy(req->buf, &r, value);
 756         } else {
 757                 dev_err(&agdev->gadget->dev,
 758                         "%s:%d control_selector=%d TODO!\n",
 759                         __func__, __LINE__, control_selector);
 760         }
 761
 762         return value;
 763 }
 764
 765 static int
 766 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 767 {
 768         if (cr->bRequest == UAC2_CS_CUR)
 769                 return in_rq_cur(fn, cr);
 770         else if (cr->bRequest == UAC2_CS_RANGE)
 771                 return in_rq_range(fn, cr);
 772         else
 773                 return -EOPNOTSUPP;
 774 }
 775
 776 static int
 777 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 778 {
 779         u16 w_length = le16_to_cpu(cr->wLength);
 780         u16 w_value = le16_to_cpu(cr->wValue);
 781         u8 control_selector = w_value >> 8;
 782
 783         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
 784                 return w_length;
 785
 786         return -EOPNOTSUPP;
 787 }
 788
 789 static int
 790 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 791 {
 792         struct f_uac2 *uac2 = func_to_uac2(fn);
 793         struct g_audio *agdev = func_to_g_audio(fn);
 794         u16 w_index = le16_to_cpu(cr->wIndex);
 795         u8 intf = w_index & 0xff;
 796
 797         if (intf != uac2->ac_intf) {
 798                 dev_err(&agdev->gadget->dev,
 799                         "%s:%d Error!\n", __func__, __LINE__);
 800                 return -EOPNOTSUPP;
 801         }
 802
 803         if (cr->bRequestType & USB_DIR_IN)
 804                 return ac_rq_in(fn, cr);
 805         else if (cr->bRequest == UAC2_CS_CUR)
 806                 return out_rq_cur(fn, cr);
 807
 808         return -EOPNOTSUPP;
 809 }
 810
 811 static int
 812 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 813 {
 814         struct usb_composite_dev *cdev = fn->config->cdev;
 815         struct g_audio *agdev = func_to_g_audio(fn);
 816         struct usb_request *req = cdev->req;
 817         u16 w_length = le16_to_cpu(cr->wLength);
 818         int value = -EOPNOTSUPP;
 819
 820         /* Only Class specific requests are supposed to reach here */
 821         if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
 822                 return -EOPNOTSUPP;
 823
 824         if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
 825                 value = setup_rq_inf(fn, cr);
 826         else
 827                 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
 828                                 __func__, __LINE__);
 829
 830         if (value >= 0) {
 831                 req->length = value;
 832                 req->zero = value < w_length;
 833                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 834                 if (value < 0) {
 835                         dev_err(&agdev->gadget->dev,
 836                                 "%s:%d Error!\n", __func__, __LINE__);
 837                         req->status = 0;
 838                 }
 839         }
 840
 841         return value;
 842 }
 843
 844 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
 845 {
 846         return container_of(to_config_group(item), struct f_uac2_opts,
 847                             func_inst.group);
 848 }
 849
 850 static void f_uac2_attr_release(struct config_item *item)
 851 {
 852         struct f_uac2_opts *opts = to_f_uac2_opts(item);
 853
 854         usb_put_function_instance(&opts->func_inst);
 855 }
 856
 857 static struct configfs_item_operations f_uac2_item_ops = {
 858         .release        = f_uac2_attr_release,
 859 };
 860
 861 #define UAC2_ATTRIBUTE(name)                                            \
 862 static ssize_t f_uac2_opts_##name##_show(struct config_item *item,      \
 863                                          char *page)                    \
 864 {                                                                       \
 865         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
 866         int result;                                                     \
 867                                                                         \
 868         mutex_lock(&opts->lock);                                        \
 869         result = sprintf(page, "%u\n", opts->name);                     \
 870         mutex_unlock(&opts->lock);                                      \
 871                                                                         \
 872         return result;                                                  \
 873 }                                                                       \
 874                                                                         \
 875 static ssize_t f_uac2_opts_##name##_store(struct config_item *item,     \
 876                                           const char *page, size_t len) \
 877 {                                                                       \
 878         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
 879         int ret;                                                        \
 880         u32 num;                                                        \
 881                                                                         \
 882         mutex_lock(&opts->lock);                                        \
 883         if (opts->refcnt) {                                             \
 884                 ret = -EBUSY;                                           \
 885                 goto end;                                               \
 886         }                                                               \
 887                                                                         \
 888         ret = kstrtou32(page, 0, &num);                                 \
 889         if (ret)                                                        \
 890                 goto end;                                               \
 891                                                                         \
 892         opts->name = num;                                               \
 893         ret = len;                                                      \
 894                                                                         \
 895 end:                                                                    \
 896         mutex_unlock(&opts->lock);                                      \
 897         return ret;                                                     \
 898 }                                                                       \
 899                                                                         \
 900 CONFIGFS_ATTR(f_uac2_opts_, name)
 901
 902 UAC2_ATTRIBUTE(p_chmask);
 903 UAC2_ATTRIBUTE(p_srate);
 904 UAC2_ATTRIBUTE(p_ssize);
 905 UAC2_ATTRIBUTE(c_chmask);
 906 UAC2_ATTRIBUTE(c_srate);
 907 UAC2_ATTRIBUTE(c_ssize);
 908 UAC2_ATTRIBUTE(req_number);
 909
 910 static struct configfs_attribute *f_uac2_attrs[] = {
 911         &f_uac2_opts_attr_p_chmask,
 912         &f_uac2_opts_attr_p_srate,
 913         &f_uac2_opts_attr_p_ssize,
 914         &f_uac2_opts_attr_c_chmask,
 915         &f_uac2_opts_attr_c_srate,
 916         &f_uac2_opts_attr_c_ssize,
 917         &f_uac2_opts_attr_req_number,
 918         NULL,
 919 };
 920
 921 static struct config_item_type f_uac2_func_type = {
 922         .ct_item_ops    = &f_uac2_item_ops,
 923         .ct_attrs       = f_uac2_attrs,
 924         .ct_owner       = THIS_MODULE,
 925 };
 926
 927 static void afunc_free_inst(struct usb_function_instance *f)
 928 {
 929         struct f_uac2_opts *opts;
 930
 931         opts = container_of(f, struct f_uac2_opts, func_inst);
 932         kfree(opts);
 933 }
 934
 935 static struct usb_function_instance *afunc_alloc_inst(void)
 936 {
 937         struct f_uac2_opts *opts;
 938
 939         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 940         if (!opts)
 941                 return ERR_PTR(-ENOMEM);
 942
 943         mutex_init(&opts->lock);
 944         opts->func_inst.free_func_inst = afunc_free_inst;
 945
 946         config_group_init_type_name(&opts->func_inst.group, "",
 947                                     &f_uac2_func_type);
 948
 949         opts->p_chmask = UAC2_DEF_PCHMASK;
 950         opts->p_srate = UAC2_DEF_PSRATE;
 951         opts->p_ssize = UAC2_DEF_PSSIZE;
 952         opts->c_chmask = UAC2_DEF_CCHMASK;
 953         opts->c_srate = UAC2_DEF_CSRATE;
 954         opts->c_ssize = UAC2_DEF_CSSIZE;
 955         opts->req_number = UAC2_DEF_REQ_NUM;
 956         return &opts->func_inst;
 957 }
 958
 959 static void afunc_free(struct usb_function *f)
 960 {
 961         struct g_audio *agdev;
 962         struct f_uac2_opts *opts;
 963
 964         agdev = func_to_g_audio(f);
 965         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
 966         kfree(agdev);
 967         mutex_lock(&opts->lock);
 968         --opts->refcnt;
 969         mutex_unlock(&opts->lock);
 970 }
 971
 972 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 973 {
 974         struct g_audio *agdev = func_to_g_audio(f);
 975
 976         g_audio_cleanup(agdev);
 977         usb_free_all_descriptors(f);
 978
 979         agdev->gadget = NULL;
 980 }
 981
 982 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
 983 {
 984         struct f_uac2   *uac2;
 985         struct f_uac2_opts *opts;
 986
 987         uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
 988         if (uac2 == NULL)
 989                 return ERR_PTR(-ENOMEM);
 990
 991         opts = container_of(fi, struct f_uac2_opts, func_inst);
 992         mutex_lock(&opts->lock);
 993         ++opts->refcnt;
 994         mutex_unlock(&opts->lock);
 995
 996         uac2->g_audio.func.name = "uac2_func";
 997         uac2->g_audio.func.bind = afunc_bind;
 998         uac2->g_audio.func.unbind = afunc_unbind;
 999         uac2->g_audio.func.set_alt = afunc_set_alt;
1000         uac2->g_audio.func.get_alt = afunc_get_alt;
1001         uac2->g_audio.func.disable = afunc_disable;
1002         uac2->g_audio.func.setup = afunc_setup;
1003         uac2->g_audio.func.free_func = afunc_free;
1004
1005         return &uac2->g_audio.func;
1006 }
1007
1008 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1009 MODULE_LICENSE("GPL");
1010 MODULE_AUTHOR("Yadwinder Singh");
1011 MODULE_AUTHOR("Jaswinder Singh");