drivers/usb/gadget/function/f_uac2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * f_uac2.c -- USB Audio Class 2.0 Function
   4  *
   5  * Copyright (C) 2011
   6  *    Yadwinder Singh (yadi.brar01@gmail.com)
   7  *    Jaswinder Singh (jaswinder.singh@linaro.org)
   8  */
   9
  10 #include <linux/usb/audio.h>
  11 #include <linux/usb/audio-v2.h>
  12 #include <linux/module.h>
  13
  14 #include "u_audio.h"
  15 #include "u_uac2.h"
  16
  17 /* UAC2 spec: 4.1 Audio Channel Cluster Descriptor */
  18 #define UAC2_CHANNEL_MASK 0x07FFFFFF
  19
  20 /*
  21  * The driver implements a simple UAC_2 topology.
  22  * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
  23  * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
  24  * Capture and Playback sampling rates are independently
  25  *  controlled by two clock sources :
  26  *    CLK_5 := c_srate, and CLK_6 := p_srate
  27  */
  28 #define USB_OUT_CLK_ID  (out_clk_src_desc.bClockID)
  29 #define USB_IN_CLK_ID   (in_clk_src_desc.bClockID)
  30
  31 #define CONTROL_ABSENT  0
  32 #define CONTROL_RDONLY  1
  33 #define CONTROL_RDWR    3
  34
  35 #define CLK_FREQ_CTRL   0
  36 #define CLK_VLD_CTRL    2
  37
  38 #define COPY_CTRL       0
  39 #define CONN_CTRL       2
  40 #define OVRLD_CTRL      4
  41 #define CLSTR_CTRL      6
  42 #define UNFLW_CTRL      8
  43 #define OVFLW_CTRL      10
  44
  45 #define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
  46 #define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
  47 #define EPOUT_FBACK_IN_EN(_opts) ((_opts)->c_sync == USB_ENDPOINT_SYNC_ASYNC)
  48
  49 struct f_uac2 {
  50         struct g_audio g_audio;
  51         u8 ac_intf, as_in_intf, as_out_intf;
  52         u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
  53 };
  54
  55 static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
  56 {
  57         return container_of(f, struct f_uac2, g_audio.func);
  58 }
  59
  60 static inline
  61 struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
  62 {
  63         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
  64 }
  65
  66 /* --------- USB Function Interface ------------- */
  67
  68 enum {
  69         STR_ASSOC,
  70         STR_IF_CTRL,
  71         STR_CLKSRC_IN,
  72         STR_CLKSRC_OUT,
  73         STR_USB_IT,
  74         STR_IO_IT,
  75         STR_USB_OT,
  76         STR_IO_OT,
  77         STR_AS_OUT_ALT0,
  78         STR_AS_OUT_ALT1,
  79         STR_AS_IN_ALT0,
  80         STR_AS_IN_ALT1,
  81 };
  82
  83 static char clksrc_in[8];
  84 static char clksrc_out[8];
  85
  86 static struct usb_string strings_fn[] = {
  87         [STR_ASSOC].s = "Source/Sink",
  88         [STR_IF_CTRL].s = "Topology Control",
  89         [STR_CLKSRC_IN].s = clksrc_in,
  90         [STR_CLKSRC_OUT].s = clksrc_out,
  91         [STR_USB_IT].s = "USBH Out",
  92         [STR_IO_IT].s = "USBD Out",
  93         [STR_USB_OT].s = "USBH In",
  94         [STR_IO_OT].s = "USBD In",
  95         [STR_AS_OUT_ALT0].s = "Playback Inactive",
  96         [STR_AS_OUT_ALT1].s = "Playback Active",
  97         [STR_AS_IN_ALT0].s = "Capture Inactive",
  98         [STR_AS_IN_ALT1].s = "Capture Active",
  99         { },
 100 };
 101
 102 static struct usb_gadget_strings str_fn = {
 103         .language = 0x0409,     /* en-us */
 104         .strings = strings_fn,
 105 };
 106
 107 static struct usb_gadget_strings *fn_strings[] = {
 108         &str_fn,
 109         NULL,
 110 };
 111
 112 static struct usb_interface_assoc_descriptor iad_desc = {
 113         .bLength = sizeof iad_desc,
 114         .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
 115
 116         .bFirstInterface = 0,
 117         .bInterfaceCount = 3,
 118         .bFunctionClass = USB_CLASS_AUDIO,
 119         .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
 120         .bFunctionProtocol = UAC_VERSION_2,
 121 };
 122
 123 /* Audio Control Interface */
 124 static struct usb_interface_descriptor std_ac_if_desc = {
 125         .bLength = sizeof std_ac_if_desc,
 126         .bDescriptorType = USB_DT_INTERFACE,
 127
 128         .bAlternateSetting = 0,
 129         .bNumEndpoints = 0,
 130         .bInterfaceClass = USB_CLASS_AUDIO,
 131         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 132         .bInterfaceProtocol = UAC_VERSION_2,
 133 };
 134
 135 /* Clock source for IN traffic */
 136 static struct uac_clock_source_descriptor in_clk_src_desc = {
 137         .bLength = sizeof in_clk_src_desc,
 138         .bDescriptorType = USB_DT_CS_INTERFACE,
 139
 140         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 141         /* .bClockID = DYNAMIC */
 142         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 143         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 144         .bAssocTerminal = 0,
 145 };
 146
 147 /* Clock source for OUT traffic */
 148 static struct uac_clock_source_descriptor out_clk_src_desc = {
 149         .bLength = sizeof out_clk_src_desc,
 150         .bDescriptorType = USB_DT_CS_INTERFACE,
 151
 152         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 153         /* .bClockID = DYNAMIC */
 154         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 155         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 156         .bAssocTerminal = 0,
 157 };
 158
 159 /* Input Terminal for USB_OUT */
 160 static struct uac2_input_terminal_descriptor usb_out_it_desc = {
 161         .bLength = sizeof usb_out_it_desc,
 162         .bDescriptorType = USB_DT_CS_INTERFACE,
 163
 164         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 165         /* .bTerminalID = DYNAMIC */
 166         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 167         .bAssocTerminal = 0,
 168         /* .bCSourceID = DYNAMIC */
 169         .iChannelNames = 0,
 170         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 171 };
 172
 173 /* Input Terminal for I/O-In */
 174 static struct uac2_input_terminal_descriptor io_in_it_desc = {
 175         .bLength = sizeof io_in_it_desc,
 176         .bDescriptorType = USB_DT_CS_INTERFACE,
 177
 178         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 179         /* .bTerminalID = DYNAMIC */
 180         .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
 181         .bAssocTerminal = 0,
 182         /* .bCSourceID = DYNAMIC */
 183         .iChannelNames = 0,
 184         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 185 };
 186
 187 /* Ouput Terminal for USB_IN */
 188 static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
 189         .bLength = sizeof usb_in_ot_desc,
 190         .bDescriptorType = USB_DT_CS_INTERFACE,
 191
 192         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 193         /* .bTerminalID = DYNAMIC */
 194         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 195         .bAssocTerminal = 0,
 196         /* .bSourceID = DYNAMIC */
 197         /* .bCSourceID = DYNAMIC */
 198         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 199 };
 200
 201 /* Ouput Terminal for I/O-Out */
 202 static struct uac2_output_terminal_descriptor io_out_ot_desc = {
 203         .bLength = sizeof io_out_ot_desc,
 204         .bDescriptorType = USB_DT_CS_INTERFACE,
 205
 206         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 207         /* .bTerminalID = DYNAMIC */
 208         .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
 209         .bAssocTerminal = 0,
 210         /* .bSourceID = DYNAMIC */
 211         /* .bCSourceID = DYNAMIC */
 212         .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
 213 };
 214
 215 static struct uac2_ac_header_descriptor ac_hdr_desc = {
 216         .bLength = sizeof ac_hdr_desc,
 217         .bDescriptorType = USB_DT_CS_INTERFACE,
 218
 219         .bDescriptorSubtype = UAC_MS_HEADER,
 220         .bcdADC = cpu_to_le16(0x200),
 221         .bCategory = UAC2_FUNCTION_IO_BOX,
 222         /* .wTotalLength = DYNAMIC */
 223         .bmControls = 0,
 224 };
 225
 226 /* Audio Streaming OUT Interface - Alt0 */
 227 static struct usb_interface_descriptor std_as_out_if0_desc = {
 228         .bLength = sizeof std_as_out_if0_desc,
 229         .bDescriptorType = USB_DT_INTERFACE,
 230
 231         .bAlternateSetting = 0,
 232         .bNumEndpoints = 0,
 233         .bInterfaceClass = USB_CLASS_AUDIO,
 234         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 235         .bInterfaceProtocol = UAC_VERSION_2,
 236 };
 237
 238 /* Audio Streaming OUT Interface - Alt1 */
 239 static struct usb_interface_descriptor std_as_out_if1_desc = {
 240         .bLength = sizeof std_as_out_if1_desc,
 241         .bDescriptorType = USB_DT_INTERFACE,
 242
 243         .bAlternateSetting = 1,
 244         .bNumEndpoints = 1,
 245         .bInterfaceClass = USB_CLASS_AUDIO,
 246         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 247         .bInterfaceProtocol = UAC_VERSION_2,
 248 };
 249
 250 /* Audio Stream OUT Intface Desc */
 251 static struct uac2_as_header_descriptor as_out_hdr_desc = {
 252         .bLength = sizeof as_out_hdr_desc,
 253         .bDescriptorType = USB_DT_CS_INTERFACE,
 254
 255         .bDescriptorSubtype = UAC_AS_GENERAL,
 256         /* .bTerminalLink = DYNAMIC */
 257         .bmControls = 0,
 258         .bFormatType = UAC_FORMAT_TYPE_I,
 259         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 260         .iChannelNames = 0,
 261 };
 262
 263 /* Audio USB_OUT Format */
 264 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
 265         .bLength = sizeof as_out_fmt1_desc,
 266         .bDescriptorType = USB_DT_CS_INTERFACE,
 267         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 268         .bFormatType = UAC_FORMAT_TYPE_I,
 269 };
 270
 271 /* STD AS ISO OUT Endpoint */
 272 static struct usb_endpoint_descriptor fs_epout_desc = {
 273         .bLength = USB_DT_ENDPOINT_SIZE,
 274         .bDescriptorType = USB_DT_ENDPOINT,
 275
 276         .bEndpointAddress = USB_DIR_OUT,
 277         /* .bmAttributes = DYNAMIC */
 278         /* .wMaxPacketSize = DYNAMIC */
 279         .bInterval = 1,
 280 };
 281
 282 static struct usb_endpoint_descriptor hs_epout_desc = {
 283         .bLength = USB_DT_ENDPOINT_SIZE,
 284         .bDescriptorType = USB_DT_ENDPOINT,
 285
 286         /* .bmAttributes = DYNAMIC */
 287         /* .wMaxPacketSize = DYNAMIC */
 288         .bInterval = 4,
 289 };
 290
 291 static struct usb_endpoint_descriptor ss_epout_desc = {
 292         .bLength = USB_DT_ENDPOINT_SIZE,
 293         .bDescriptorType = USB_DT_ENDPOINT,
 294
 295         .bEndpointAddress = USB_DIR_OUT,
 296         /* .bmAttributes = DYNAMIC */
 297         /* .wMaxPacketSize = DYNAMIC */
 298         .bInterval = 4,
 299 };
 300
 301 static struct usb_ss_ep_comp_descriptor ss_epout_desc_comp = {
 302         .bLength                = sizeof(ss_epout_desc_comp),
 303         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 304         .bMaxBurst              = 0,
 305         .bmAttributes           = 0,
 306         /* wBytesPerInterval = DYNAMIC */
 307 };
 308
 309 /* CS AS ISO OUT Endpoint */
 310 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
 311         .bLength = sizeof as_iso_out_desc,
 312         .bDescriptorType = USB_DT_CS_ENDPOINT,
 313
 314         .bDescriptorSubtype = UAC_EP_GENERAL,
 315         .bmAttributes = 0,
 316         .bmControls = 0,
 317         .bLockDelayUnits = 0,
 318         .wLockDelay = 0,
 319 };
 320
 321 /* STD AS ISO IN Feedback Endpoint */
 322 static struct usb_endpoint_descriptor fs_epin_fback_desc = {
 323         .bLength = USB_DT_ENDPOINT_SIZE,
 324         .bDescriptorType = USB_DT_ENDPOINT,
 325
 326         .bEndpointAddress = USB_DIR_IN,
 327         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
 328         .wMaxPacketSize = cpu_to_le16(3),
 329         .bInterval = 1,
 330 };
 331
 332 static struct usb_endpoint_descriptor hs_epin_fback_desc = {
 333         .bLength = USB_DT_ENDPOINT_SIZE,
 334         .bDescriptorType = USB_DT_ENDPOINT,
 335
 336         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
 337         .wMaxPacketSize = cpu_to_le16(4),
 338         .bInterval = 4,
 339 };
 340
 341 static struct usb_endpoint_descriptor ss_epin_fback_desc = {
 342         .bLength = USB_DT_ENDPOINT_SIZE,
 343         .bDescriptorType = USB_DT_ENDPOINT,
 344
 345         .bEndpointAddress = USB_DIR_IN,
 346         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
 347         .wMaxPacketSize = cpu_to_le16(4),
 348         .bInterval = 4,
 349 };
 350
 351
 352 /* Audio Streaming IN Interface - Alt0 */
 353 static struct usb_interface_descriptor std_as_in_if0_desc = {
 354         .bLength = sizeof std_as_in_if0_desc,
 355         .bDescriptorType = USB_DT_INTERFACE,
 356
 357         .bAlternateSetting = 0,
 358         .bNumEndpoints = 0,
 359         .bInterfaceClass = USB_CLASS_AUDIO,
 360         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 361         .bInterfaceProtocol = UAC_VERSION_2,
 362 };
 363
 364 /* Audio Streaming IN Interface - Alt1 */
 365 static struct usb_interface_descriptor std_as_in_if1_desc = {
 366         .bLength = sizeof std_as_in_if1_desc,
 367         .bDescriptorType = USB_DT_INTERFACE,
 368
 369         .bAlternateSetting = 1,
 370         .bNumEndpoints = 1,
 371         .bInterfaceClass = USB_CLASS_AUDIO,
 372         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 373         .bInterfaceProtocol = UAC_VERSION_2,
 374 };
 375
 376 /* Audio Stream IN Intface Desc */
 377 static struct uac2_as_header_descriptor as_in_hdr_desc = {
 378         .bLength = sizeof as_in_hdr_desc,
 379         .bDescriptorType = USB_DT_CS_INTERFACE,
 380
 381         .bDescriptorSubtype = UAC_AS_GENERAL,
 382         /* .bTerminalLink = DYNAMIC */
 383         .bmControls = 0,
 384         .bFormatType = UAC_FORMAT_TYPE_I,
 385         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 386         .iChannelNames = 0,
 387 };
 388
 389 /* Audio USB_IN Format */
 390 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
 391         .bLength = sizeof as_in_fmt1_desc,
 392         .bDescriptorType = USB_DT_CS_INTERFACE,
 393         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 394         .bFormatType = UAC_FORMAT_TYPE_I,
 395 };
 396
 397 /* STD AS ISO IN Endpoint */
 398 static struct usb_endpoint_descriptor fs_epin_desc = {
 399         .bLength = USB_DT_ENDPOINT_SIZE,
 400         .bDescriptorType = USB_DT_ENDPOINT,
 401
 402         .bEndpointAddress = USB_DIR_IN,
 403         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 404         /* .wMaxPacketSize = DYNAMIC */
 405         .bInterval = 1,
 406 };
 407
 408 static struct usb_endpoint_descriptor hs_epin_desc = {
 409         .bLength = USB_DT_ENDPOINT_SIZE,
 410         .bDescriptorType = USB_DT_ENDPOINT,
 411
 412         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 413         /* .wMaxPacketSize = DYNAMIC */
 414         .bInterval = 4,
 415 };
 416
 417 static struct usb_endpoint_descriptor ss_epin_desc = {
 418         .bLength = USB_DT_ENDPOINT_SIZE,
 419         .bDescriptorType = USB_DT_ENDPOINT,
 420
 421         .bEndpointAddress = USB_DIR_IN,
 422         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 423         /* .wMaxPacketSize = DYNAMIC */
 424         .bInterval = 4,
 425 };
 426
 427 static struct usb_ss_ep_comp_descriptor ss_epin_desc_comp = {
 428         .bLength                = sizeof(ss_epin_desc_comp),
 429         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 430         .bMaxBurst              = 0,
 431         .bmAttributes           = 0,
 432         /* wBytesPerInterval = DYNAMIC */
 433 };
 434
 435 /* CS AS ISO IN Endpoint */
 436 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
 437         .bLength = sizeof as_iso_in_desc,
 438         .bDescriptorType = USB_DT_CS_ENDPOINT,
 439
 440         .bDescriptorSubtype = UAC_EP_GENERAL,
 441         .bmAttributes = 0,
 442         .bmControls = 0,
 443         .bLockDelayUnits = 0,
 444         .wLockDelay = 0,
 445 };
 446
 447 static struct usb_descriptor_header *fs_audio_desc[] = {
 448         (struct usb_descriptor_header *)&iad_desc,
 449         (struct usb_descriptor_header *)&std_ac_if_desc,
 450
 451         (struct usb_descriptor_header *)&ac_hdr_desc,
 452         (struct usb_descriptor_header *)&in_clk_src_desc,
 453         (struct usb_descriptor_header *)&out_clk_src_desc,
 454         (struct usb_descriptor_header *)&usb_out_it_desc,
 455         (struct usb_descriptor_header *)&io_in_it_desc,
 456         (struct usb_descriptor_header *)&usb_in_ot_desc,
 457         (struct usb_descriptor_header *)&io_out_ot_desc,
 458
 459         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 460         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 461
 462         (struct usb_descriptor_header *)&as_out_hdr_desc,
 463         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 464         (struct usb_descriptor_header *)&fs_epout_desc,
 465         (struct usb_descriptor_header *)&as_iso_out_desc,
 466         (struct usb_descriptor_header *)&fs_epin_fback_desc,
 467
 468         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 469         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 470
 471         (struct usb_descriptor_header *)&as_in_hdr_desc,
 472         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 473         (struct usb_descriptor_header *)&fs_epin_desc,
 474         (struct usb_descriptor_header *)&as_iso_in_desc,
 475         NULL,
 476 };
 477
 478 static struct usb_descriptor_header *hs_audio_desc[] = {
 479         (struct usb_descriptor_header *)&iad_desc,
 480         (struct usb_descriptor_header *)&std_ac_if_desc,
 481
 482         (struct usb_descriptor_header *)&ac_hdr_desc,
 483         (struct usb_descriptor_header *)&in_clk_src_desc,
 484         (struct usb_descriptor_header *)&out_clk_src_desc,
 485         (struct usb_descriptor_header *)&usb_out_it_desc,
 486         (struct usb_descriptor_header *)&io_in_it_desc,
 487         (struct usb_descriptor_header *)&usb_in_ot_desc,
 488         (struct usb_descriptor_header *)&io_out_ot_desc,
 489
 490         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 491         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 492
 493         (struct usb_descriptor_header *)&as_out_hdr_desc,
 494         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 495         (struct usb_descriptor_header *)&hs_epout_desc,
 496         (struct usb_descriptor_header *)&as_iso_out_desc,
 497         (struct usb_descriptor_header *)&hs_epin_fback_desc,
 498
 499         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 500         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 501
 502         (struct usb_descriptor_header *)&as_in_hdr_desc,
 503         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 504         (struct usb_descriptor_header *)&hs_epin_desc,
 505         (struct usb_descriptor_header *)&as_iso_in_desc,
 506         NULL,
 507 };
 508
 509 static struct usb_descriptor_header *ss_audio_desc[] = {
 510         (struct usb_descriptor_header *)&iad_desc,
 511         (struct usb_descriptor_header *)&std_ac_if_desc,
 512
 513         (struct usb_descriptor_header *)&ac_hdr_desc,
 514         (struct usb_descriptor_header *)&in_clk_src_desc,
 515         (struct usb_descriptor_header *)&out_clk_src_desc,
 516         (struct usb_descriptor_header *)&usb_out_it_desc,
 517         (struct usb_descriptor_header *)&io_in_it_desc,
 518         (struct usb_descriptor_header *)&usb_in_ot_desc,
 519         (struct usb_descriptor_header *)&io_out_ot_desc,
 520
 521         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 522         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 523
 524         (struct usb_descriptor_header *)&as_out_hdr_desc,
 525         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 526         (struct usb_descriptor_header *)&ss_epout_desc,
 527         (struct usb_descriptor_header *)&ss_epout_desc_comp,
 528         (struct usb_descriptor_header *)&as_iso_out_desc,
 529         (struct usb_descriptor_header *)&ss_epin_fback_desc,
 530
 531         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 532         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 533
 534         (struct usb_descriptor_header *)&as_in_hdr_desc,
 535         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 536         (struct usb_descriptor_header *)&ss_epin_desc,
 537         (struct usb_descriptor_header *)&ss_epin_desc_comp,
 538         (struct usb_descriptor_header *)&as_iso_in_desc,
 539         NULL,
 540 };
 541
 542 struct cntrl_cur_lay3 {
 543         __le32  dCUR;
 544 };
 545
 546 struct cntrl_range_lay3 {
 547         __le16  wNumSubRanges;
 548         __le32  dMIN;
 549         __le32  dMAX;
 550         __le32  dRES;
 551 } __packed;
 552
 553 static int set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 554         struct usb_endpoint_descriptor *ep_desc,
 555         enum usb_device_speed speed, bool is_playback)
 556 {
 557         int chmask, srate, ssize;
 558         u16 max_size_bw, max_size_ep;
 559         unsigned int factor;
 560
 561         switch (speed) {
 562         case USB_SPEED_FULL:
 563                 max_size_ep = 1023;
 564                 factor = 1000;
 565                 break;
 566
 567         case USB_SPEED_HIGH:
 568         case USB_SPEED_SUPER:
 569                 max_size_ep = 1024;
 570                 factor = 8000;
 571                 break;
 572
 573         default:
 574                 return -EINVAL;
 575         }
 576
 577         if (is_playback) {
 578                 chmask = uac2_opts->p_chmask;
 579                 srate = uac2_opts->p_srate;
 580                 ssize = uac2_opts->p_ssize;
 581         } else {
 582                 chmask = uac2_opts->c_chmask;
 583                 srate = uac2_opts->c_srate;
 584                 ssize = uac2_opts->c_ssize;
 585         }
 586
 587         if (!is_playback && (uac2_opts->c_sync == USB_ENDPOINT_SYNC_ASYNC))
 588                 srate = srate * (1000 + uac2_opts->fb_max) / 1000;
 589
 590         max_size_bw = num_channels(chmask) * ssize *
 591                 DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));
 592         ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_size_bw,
 593                                                     max_size_ep));
 594
 595         return 0;
 596 }
 597
 598 /* Use macro to overcome line length limitation */
 599 #define USBDHDR(p) (struct usb_descriptor_header *)(p)
 600
 601 static void setup_headers(struct f_uac2_opts *opts,
 602                           struct usb_descriptor_header **headers,
 603                           enum usb_device_speed speed)
 604 {
 605         struct usb_ss_ep_comp_descriptor *epout_desc_comp = NULL;
 606         struct usb_ss_ep_comp_descriptor *epin_desc_comp = NULL;
 607         struct usb_endpoint_descriptor *epout_desc;
 608         struct usb_endpoint_descriptor *epin_desc;
 609         struct usb_endpoint_descriptor *epin_fback_desc;
 610         int i;
 611
 612         switch (speed) {
 613         case USB_SPEED_FULL:
 614                 epout_desc = &fs_epout_desc;
 615                 epin_desc = &fs_epin_desc;
 616                 epin_fback_desc = &fs_epin_fback_desc;
 617                 break;
 618         case USB_SPEED_HIGH:
 619                 epout_desc = &hs_epout_desc;
 620                 epin_desc = &hs_epin_desc;
 621                 epin_fback_desc = &hs_epin_fback_desc;
 622                 break;
 623         default:
 624                 epout_desc = &ss_epout_desc;
 625                 epin_desc = &ss_epin_desc;
 626                 epout_desc_comp = &ss_epout_desc_comp;
 627                 epin_desc_comp = &ss_epin_desc_comp;
 628                 epin_fback_desc = &ss_epin_fback_desc;
 629         }
 630
 631         i = 0;
 632         headers[i++] = USBDHDR(&iad_desc);
 633         headers[i++] = USBDHDR(&std_ac_if_desc);
 634         headers[i++] = USBDHDR(&ac_hdr_desc);
 635         if (EPIN_EN(opts))
 636                 headers[i++] = USBDHDR(&in_clk_src_desc);
 637         if (EPOUT_EN(opts)) {
 638                 headers[i++] = USBDHDR(&out_clk_src_desc);
 639                 headers[i++] = USBDHDR(&usb_out_it_desc);
 640         }
 641         if (EPIN_EN(opts)) {
 642                 headers[i++] = USBDHDR(&io_in_it_desc);
 643                 headers[i++] = USBDHDR(&usb_in_ot_desc);
 644         }
 645         if (EPOUT_EN(opts)) {
 646                 headers[i++] = USBDHDR(&io_out_ot_desc);
 647                 headers[i++] = USBDHDR(&std_as_out_if0_desc);
 648                 headers[i++] = USBDHDR(&std_as_out_if1_desc);
 649                 headers[i++] = USBDHDR(&as_out_hdr_desc);
 650                 headers[i++] = USBDHDR(&as_out_fmt1_desc);
 651                 headers[i++] = USBDHDR(epout_desc);
 652                 if (epout_desc_comp)
 653                         headers[i++] = USBDHDR(epout_desc_comp);
 654
 655                 headers[i++] = USBDHDR(&as_iso_out_desc);
 656
 657                 if (EPOUT_FBACK_IN_EN(opts))
 658                         headers[i++] = USBDHDR(epin_fback_desc);
 659         }
 660         if (EPIN_EN(opts)) {
 661                 headers[i++] = USBDHDR(&std_as_in_if0_desc);
 662                 headers[i++] = USBDHDR(&std_as_in_if1_desc);
 663                 headers[i++] = USBDHDR(&as_in_hdr_desc);
 664                 headers[i++] = USBDHDR(&as_in_fmt1_desc);
 665                 headers[i++] = USBDHDR(epin_desc);
 666                 if (epin_desc_comp)
 667                         headers[i++] = USBDHDR(epin_desc_comp);
 668
 669                 headers[i++] = USBDHDR(&as_iso_in_desc);
 670         }
 671         headers[i] = NULL;
 672 }
 673
 674 static void setup_descriptor(struct f_uac2_opts *opts)
 675 {
 676         /* patch descriptors */
 677         int i = 1; /* ID's start with 1 */
 678
 679         if (EPOUT_EN(opts))
 680                 usb_out_it_desc.bTerminalID = i++;
 681         if (EPIN_EN(opts))
 682                 io_in_it_desc.bTerminalID = i++;
 683         if (EPOUT_EN(opts))
 684                 io_out_ot_desc.bTerminalID = i++;
 685         if (EPIN_EN(opts))
 686                 usb_in_ot_desc.bTerminalID = i++;
 687         if (EPOUT_EN(opts))
 688                 out_clk_src_desc.bClockID = i++;
 689         if (EPIN_EN(opts))
 690                 in_clk_src_desc.bClockID = i++;
 691
 692         usb_out_it_desc.bCSourceID = out_clk_src_desc.bClockID;
 693         usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
 694         usb_in_ot_desc.bCSourceID = in_clk_src_desc.bClockID;
 695         io_in_it_desc.bCSourceID = in_clk_src_desc.bClockID;
 696         io_out_ot_desc.bCSourceID = out_clk_src_desc.bClockID;
 697         io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
 698         as_out_hdr_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
 699         as_in_hdr_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
 700
 701         iad_desc.bInterfaceCount = 1;
 702         ac_hdr_desc.wTotalLength = cpu_to_le16(sizeof(ac_hdr_desc));
 703
 704         if (EPIN_EN(opts)) {
 705                 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
 706
 707                 len += sizeof(in_clk_src_desc);
 708                 len += sizeof(usb_in_ot_desc);
 709                 len += sizeof(io_in_it_desc);
 710                 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
 711                 iad_desc.bInterfaceCount++;
 712         }
 713         if (EPOUT_EN(opts)) {
 714                 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
 715
 716                 len += sizeof(out_clk_src_desc);
 717                 len += sizeof(usb_out_it_desc);
 718                 len += sizeof(io_out_ot_desc);
 719                 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
 720                 iad_desc.bInterfaceCount++;
 721         }
 722
 723         setup_headers(opts, fs_audio_desc, USB_SPEED_FULL);
 724         setup_headers(opts, hs_audio_desc, USB_SPEED_HIGH);
 725         setup_headers(opts, ss_audio_desc, USB_SPEED_SUPER);
 726 }
 727
 728 static int afunc_validate_opts(struct g_audio *agdev, struct device *dev)
 729 {
 730         struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
 731
 732         if (!opts->p_chmask && !opts->c_chmask) {
 733                 dev_err(dev, "Error: no playback and capture channels\n");
 734                 return -EINVAL;
 735         } else if (opts->p_chmask & ~UAC2_CHANNEL_MASK) {
 736                 dev_err(dev, "Error: unsupported playback channels mask\n");
 737                 return -EINVAL;
 738         } else if (opts->c_chmask & ~UAC2_CHANNEL_MASK) {
 739                 dev_err(dev, "Error: unsupported capture channels mask\n");
 740                 return -EINVAL;
 741         } else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) {
 742                 dev_err(dev, "Error: incorrect playback sample size\n");
 743                 return -EINVAL;
 744         } else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) {
 745                 dev_err(dev, "Error: incorrect capture sample size\n");
 746                 return -EINVAL;
 747         } else if (!opts->p_srate) {
 748                 dev_err(dev, "Error: incorrect playback sampling rate\n");
 749                 return -EINVAL;
 750         } else if (!opts->c_srate) {
 751                 dev_err(dev, "Error: incorrect capture sampling rate\n");
 752                 return -EINVAL;
 753         }
 754
 755         return 0;
 756 }
 757
 758 static int
 759 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 760 {
 761         struct f_uac2 *uac2 = func_to_uac2(fn);
 762         struct g_audio *agdev = func_to_g_audio(fn);
 763         struct usb_composite_dev *cdev = cfg->cdev;
 764         struct usb_gadget *gadget = cdev->gadget;
 765         struct device *dev = &gadget->dev;
 766         struct f_uac2_opts *uac2_opts = g_audio_to_uac2_opts(agdev);
 767         struct usb_string *us;
 768         int ret;
 769
 770         ret = afunc_validate_opts(agdev, dev);
 771         if (ret)
 772                 return ret;
 773
 774         us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
 775         if (IS_ERR(us))
 776                 return PTR_ERR(us);
 777         iad_desc.iFunction = us[STR_ASSOC].id;
 778         std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
 779         in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
 780         out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
 781         usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
 782         io_in_it_desc.iTerminal = us[STR_IO_IT].id;
 783         usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
 784         io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
 785         std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
 786         std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
 787         std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
 788         std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
 789
 790
 791         /* Initialize the configurable parameters */
 792         usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 793         usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 794         io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 795         io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 796         as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
 797         as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
 798         as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
 799         as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
 800         as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
 801         as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
 802         as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
 803         as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
 804
 805         snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
 806         snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
 807
 808         ret = usb_interface_id(cfg, fn);
 809         if (ret < 0) {
 810                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 811                 return ret;
 812         }
 813         iad_desc.bFirstInterface = ret;
 814
 815         std_ac_if_desc.bInterfaceNumber = ret;
 816         uac2->ac_intf = ret;
 817         uac2->ac_alt = 0;
 818
 819         if (EPOUT_EN(uac2_opts)) {
 820                 ret = usb_interface_id(cfg, fn);
 821                 if (ret < 0) {
 822                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 823                         return ret;
 824                 }
 825                 std_as_out_if0_desc.bInterfaceNumber = ret;
 826                 std_as_out_if1_desc.bInterfaceNumber = ret;
 827                 uac2->as_out_intf = ret;
 828                 uac2->as_out_alt = 0;
 829
 830                 if (EPOUT_FBACK_IN_EN(uac2_opts)) {
 831                         fs_epout_desc.bmAttributes =
 832                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
 833                         hs_epout_desc.bmAttributes =
 834                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
 835                         ss_epout_desc.bmAttributes =
 836                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
 837                         std_as_out_if1_desc.bNumEndpoints++;
 838                 } else {
 839                         fs_epout_desc.bmAttributes =
 840                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
 841                         hs_epout_desc.bmAttributes =
 842                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
 843                         ss_epout_desc.bmAttributes =
 844                           USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
 845                 }
 846         }
 847
 848         if (EPIN_EN(uac2_opts)) {
 849                 ret = usb_interface_id(cfg, fn);
 850                 if (ret < 0) {
 851                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 852                         return ret;
 853                 }
 854                 std_as_in_if0_desc.bInterfaceNumber = ret;
 855                 std_as_in_if1_desc.bInterfaceNumber = ret;
 856                 uac2->as_in_intf = ret;
 857                 uac2->as_in_alt = 0;
 858         }
 859
 860         /* Calculate wMaxPacketSize according to audio bandwidth */
 861         ret = set_ep_max_packet_size(uac2_opts, &fs_epin_desc, USB_SPEED_FULL,
 862                                      true);
 863         if (ret < 0) {
 864                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 865                 return ret;
 866         }
 867
 868         ret = set_ep_max_packet_size(uac2_opts, &fs_epout_desc, USB_SPEED_FULL,
 869                                      false);
 870         if (ret < 0) {
 871                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 872                 return ret;
 873         }
 874
 875         ret = set_ep_max_packet_size(uac2_opts, &hs_epin_desc, USB_SPEED_HIGH,
 876                                      true);
 877         if (ret < 0) {
 878                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 879                 return ret;
 880         }
 881
 882         ret = set_ep_max_packet_size(uac2_opts, &hs_epout_desc, USB_SPEED_HIGH,
 883                                      false);
 884         if (ret < 0) {
 885                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 886                 return ret;
 887         }
 888
 889         ret = set_ep_max_packet_size(uac2_opts, &ss_epin_desc, USB_SPEED_SUPER,
 890                                      true);
 891         if (ret < 0) {
 892                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 893                 return ret;
 894         }
 895
 896         ret = set_ep_max_packet_size(uac2_opts, &ss_epout_desc, USB_SPEED_SUPER,
 897                                      false);
 898         if (ret < 0) {
 899                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 900                 return ret;
 901         }
 902
 903         if (EPOUT_EN(uac2_opts)) {
 904                 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
 905                 if (!agdev->out_ep) {
 906                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 907                         return -ENODEV;
 908                 }
 909                 if (EPOUT_FBACK_IN_EN(uac2_opts)) {
 910                         agdev->in_ep_fback = usb_ep_autoconfig(gadget,
 911                                                        &fs_epin_fback_desc);
 912                         if (!agdev->in_ep_fback) {
 913                                 dev_err(dev, "%s:%d Error!\n",
 914                                         __func__, __LINE__);
 915                                 return -ENODEV;
 916                         }
 917                 }
 918         }
 919
 920         if (EPIN_EN(uac2_opts)) {
 921                 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
 922                 if (!agdev->in_ep) {
 923                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 924                         return -ENODEV;
 925                 }
 926         }
 927
 928         agdev->in_ep_maxpsize = max_t(u16,
 929                                 le16_to_cpu(fs_epin_desc.wMaxPacketSize),
 930                                 le16_to_cpu(hs_epin_desc.wMaxPacketSize));
 931         agdev->out_ep_maxpsize = max_t(u16,
 932                                 le16_to_cpu(fs_epout_desc.wMaxPacketSize),
 933                                 le16_to_cpu(hs_epout_desc.wMaxPacketSize));
 934
 935         agdev->in_ep_maxpsize = max_t(u16, agdev->in_ep_maxpsize,
 936                                 le16_to_cpu(ss_epin_desc.wMaxPacketSize));
 937         agdev->out_ep_maxpsize = max_t(u16, agdev->out_ep_maxpsize,
 938                                 le16_to_cpu(ss_epout_desc.wMaxPacketSize));
 939
 940         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 941         hs_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
 942         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 943         ss_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 944         ss_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
 945         ss_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 946
 947         setup_descriptor(uac2_opts);
 948
 949         ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, ss_audio_desc,
 950                                      ss_audio_desc);
 951         if (ret)
 952                 return ret;
 953
 954         agdev->gadget = gadget;
 955
 956         agdev->params.p_chmask = uac2_opts->p_chmask;
 957         agdev->params.p_srate = uac2_opts->p_srate;
 958         agdev->params.p_ssize = uac2_opts->p_ssize;
 959         agdev->params.c_chmask = uac2_opts->c_chmask;
 960         agdev->params.c_srate = uac2_opts->c_srate;
 961         agdev->params.c_ssize = uac2_opts->c_ssize;
 962         agdev->params.req_number = uac2_opts->req_number;
 963         agdev->params.fb_max = uac2_opts->fb_max;
 964         ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
 965         if (ret)
 966                 goto err_free_descs;
 967         return 0;
 968
 969 err_free_descs:
 970         usb_free_all_descriptors(fn);
 971         agdev->gadget = NULL;
 972         return ret;
 973 }
 974
 975 static int
 976 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
 977 {
 978         struct usb_composite_dev *cdev = fn->config->cdev;
 979         struct f_uac2 *uac2 = func_to_uac2(fn);
 980         struct usb_gadget *gadget = cdev->gadget;
 981         struct device *dev = &gadget->dev;
 982         int ret = 0;
 983
 984         /* No i/f has more than 2 alt settings */
 985         if (alt > 1) {
 986                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 987                 return -EINVAL;
 988         }
 989
 990         if (intf == uac2->ac_intf) {
 991                 /* Control I/f has only 1 AltSetting - 0 */
 992                 if (alt) {
 993                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 994                         return -EINVAL;
 995                 }
 996                 return 0;
 997         }
 998
 999         if (intf == uac2->as_out_intf) {
1000                 uac2->as_out_alt = alt;
1001
1002                 if (alt)
1003                         ret = u_audio_start_capture(&uac2->g_audio);
1004                 else
1005                         u_audio_stop_capture(&uac2->g_audio);
1006         } else if (intf == uac2->as_in_intf) {
1007                 uac2->as_in_alt = alt;
1008
1009                 if (alt)
1010                         ret = u_audio_start_playback(&uac2->g_audio);
1011                 else
1012                         u_audio_stop_playback(&uac2->g_audio);
1013         } else {
1014                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1015                 return -EINVAL;
1016         }
1017
1018         return ret;
1019 }
1020
1021 static int
1022 afunc_get_alt(struct usb_function *fn, unsigned intf)
1023 {
1024         struct f_uac2 *uac2 = func_to_uac2(fn);
1025         struct g_audio *agdev = func_to_g_audio(fn);
1026
1027         if (intf == uac2->ac_intf)
1028                 return uac2->ac_alt;
1029         else if (intf == uac2->as_out_intf)
1030                 return uac2->as_out_alt;
1031         else if (intf == uac2->as_in_intf)
1032                 return uac2->as_in_alt;
1033         else
1034                 dev_err(&agdev->gadget->dev,
1035                         "%s:%d Invalid Interface %d!\n",
1036                         __func__, __LINE__, intf);
1037
1038         return -EINVAL;
1039 }
1040
1041 static void
1042 afunc_disable(struct usb_function *fn)
1043 {
1044         struct f_uac2 *uac2 = func_to_uac2(fn);
1045
1046         uac2->as_in_alt = 0;
1047         uac2->as_out_alt = 0;
1048         u_audio_stop_capture(&uac2->g_audio);
1049         u_audio_stop_playback(&uac2->g_audio);
1050 }
1051
1052 static int
1053 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1054 {
1055         struct usb_request *req = fn->config->cdev->req;
1056         struct g_audio *agdev = func_to_g_audio(fn);
1057         struct f_uac2_opts *opts;
1058         u16 w_length = le16_to_cpu(cr->wLength);
1059         u16 w_index = le16_to_cpu(cr->wIndex);
1060         u16 w_value = le16_to_cpu(cr->wValue);
1061         u8 entity_id = (w_index >> 8) & 0xff;
1062         u8 control_selector = w_value >> 8;
1063         int value = -EOPNOTSUPP;
1064         int p_srate, c_srate;
1065
1066         opts = g_audio_to_uac2_opts(agdev);
1067         p_srate = opts->p_srate;
1068         c_srate = opts->c_srate;
1069
1070         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1071                 struct cntrl_cur_lay3 c;
1072                 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
1073
1074                 if (entity_id == USB_IN_CLK_ID)
1075                         c.dCUR = cpu_to_le32(p_srate);
1076                 else if (entity_id == USB_OUT_CLK_ID)
1077                         c.dCUR = cpu_to_le32(c_srate);
1078
1079                 value = min_t(unsigned, w_length, sizeof c);
1080                 memcpy(req->buf, &c, value);
1081         } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1082                 *(u8 *)req->buf = 1;
1083                 value = min_t(unsigned, w_length, 1);
1084         } else {
1085                 dev_err(&agdev->gadget->dev,
1086                         "%s:%d control_selector=%d TODO!\n",
1087                         __func__, __LINE__, control_selector);
1088         }
1089
1090         return value;
1091 }
1092
1093 static int
1094 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1095 {
1096         struct usb_request *req = fn->config->cdev->req;
1097         struct g_audio *agdev = func_to_g_audio(fn);
1098         struct f_uac2_opts *opts;
1099         u16 w_length = le16_to_cpu(cr->wLength);
1100         u16 w_index = le16_to_cpu(cr->wIndex);
1101         u16 w_value = le16_to_cpu(cr->wValue);
1102         u8 entity_id = (w_index >> 8) & 0xff;
1103         u8 control_selector = w_value >> 8;
1104         struct cntrl_range_lay3 r;
1105         int value = -EOPNOTSUPP;
1106         int p_srate, c_srate;
1107
1108         opts = g_audio_to_uac2_opts(agdev);
1109         p_srate = opts->p_srate;
1110         c_srate = opts->c_srate;
1111
1112         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1113                 if (entity_id == USB_IN_CLK_ID)
1114                         r.dMIN = cpu_to_le32(p_srate);
1115                 else if (entity_id == USB_OUT_CLK_ID)
1116                         r.dMIN = cpu_to_le32(c_srate);
1117                 else
1118                         return -EOPNOTSUPP;
1119
1120                 r.dMAX = r.dMIN;
1121                 r.dRES = 0;
1122                 r.wNumSubRanges = cpu_to_le16(1);
1123
1124                 value = min_t(unsigned, w_length, sizeof r);
1125                 memcpy(req->buf, &r, value);
1126         } else {
1127                 dev_err(&agdev->gadget->dev,
1128                         "%s:%d control_selector=%d TODO!\n",
1129                         __func__, __LINE__, control_selector);
1130         }
1131
1132         return value;
1133 }
1134
1135 static int
1136 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1137 {
1138         if (cr->bRequest == UAC2_CS_CUR)
1139                 return in_rq_cur(fn, cr);
1140         else if (cr->bRequest == UAC2_CS_RANGE)
1141                 return in_rq_range(fn, cr);
1142         else
1143                 return -EOPNOTSUPP;
1144 }
1145
1146 static int
1147 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1148 {
1149         u16 w_length = le16_to_cpu(cr->wLength);
1150         u16 w_value = le16_to_cpu(cr->wValue);
1151         u8 control_selector = w_value >> 8;
1152
1153         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
1154                 return w_length;
1155
1156         return -EOPNOTSUPP;
1157 }
1158
1159 static int
1160 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1161 {
1162         struct f_uac2 *uac2 = func_to_uac2(fn);
1163         struct g_audio *agdev = func_to_g_audio(fn);
1164         u16 w_index = le16_to_cpu(cr->wIndex);
1165         u8 intf = w_index & 0xff;
1166
1167         if (intf != uac2->ac_intf) {
1168                 dev_err(&agdev->gadget->dev,
1169                         "%s:%d Error!\n", __func__, __LINE__);
1170                 return -EOPNOTSUPP;
1171         }
1172
1173         if (cr->bRequestType & USB_DIR_IN)
1174                 return ac_rq_in(fn, cr);
1175         else if (cr->bRequest == UAC2_CS_CUR)
1176                 return out_rq_cur(fn, cr);
1177
1178         return -EOPNOTSUPP;
1179 }
1180
1181 static int
1182 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1183 {
1184         struct usb_composite_dev *cdev = fn->config->cdev;
1185         struct g_audio *agdev = func_to_g_audio(fn);
1186         struct usb_request *req = cdev->req;
1187         u16 w_length = le16_to_cpu(cr->wLength);
1188         int value = -EOPNOTSUPP;
1189
1190         /* Only Class specific requests are supposed to reach here */
1191         if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1192                 return -EOPNOTSUPP;
1193
1194         if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1195                 value = setup_rq_inf(fn, cr);
1196         else
1197                 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
1198                                 __func__, __LINE__);
1199
1200         if (value >= 0) {
1201                 req->length = value;
1202                 req->zero = value < w_length;
1203                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1204                 if (value < 0) {
1205                         dev_err(&agdev->gadget->dev,
1206                                 "%s:%d Error!\n", __func__, __LINE__);
1207                         req->status = 0;
1208                 }
1209         }
1210
1211         return value;
1212 }
1213
1214 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1215 {
1216         return container_of(to_config_group(item), struct f_uac2_opts,
1217                             func_inst.group);
1218 }
1219
1220 static void f_uac2_attr_release(struct config_item *item)
1221 {
1222         struct f_uac2_opts *opts = to_f_uac2_opts(item);
1223
1224         usb_put_function_instance(&opts->func_inst);
1225 }
1226
1227 static struct configfs_item_operations f_uac2_item_ops = {
1228         .release        = f_uac2_attr_release,
1229 };
1230
1231 #define UAC2_ATTRIBUTE(name)                                            \
1232 static ssize_t f_uac2_opts_##name##_show(struct config_item *item,      \
1233                                          char *page)                    \
1234 {                                                                       \
1235         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1236         int result;                                                     \
1237                                                                         \
1238         mutex_lock(&opts->lock);                                        \
1239         result = sprintf(page, "%u\n", opts->name);                     \
1240         mutex_unlock(&opts->lock);                                      \
1241                                                                         \
1242         return result;                                                  \
1243 }                                                                       \
1244                                                                         \
1245 static ssize_t f_uac2_opts_##name##_store(struct config_item *item,     \
1246                                           const char *page, size_t len) \
1247 {                                                                       \
1248         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1249         int ret;                                                        \
1250         u32 num;                                                        \
1251                                                                         \
1252         mutex_lock(&opts->lock);                                        \
1253         if (opts->refcnt) {                                             \
1254                 ret = -EBUSY;                                           \
1255                 goto end;                                               \
1256         }                                                               \
1257                                                                         \
1258         ret = kstrtou32(page, 0, &num);                                 \
1259         if (ret)                                                        \
1260                 goto end;                                               \
1261                                                                         \
1262         opts->name = num;                                               \
1263         ret = len;                                                      \
1264                                                                         \
1265 end:                                                                    \
1266         mutex_unlock(&opts->lock);                                      \
1267         return ret;                                                     \
1268 }                                                                       \
1269                                                                         \
1270 CONFIGFS_ATTR(f_uac2_opts_, name)
1271
1272 #define UAC2_ATTRIBUTE_SYNC(name)                                       \
1273 static ssize_t f_uac2_opts_##name##_show(struct config_item *item,      \
1274                                          char *page)                    \
1275 {                                                                       \
1276         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1277         int result;                                                     \
1278         char *str;                                                      \
1279                                                                         \
1280         mutex_lock(&opts->lock);                                        \
1281         switch (opts->name) {                                           \
1282         case USB_ENDPOINT_SYNC_ASYNC:                                   \
1283                 str = "async";                                          \
1284                 break;                                                  \
1285         case USB_ENDPOINT_SYNC_ADAPTIVE:                                \
1286                 str = "adaptive";                                       \
1287                 break;                                                  \
1288         default:                                                        \
1289                 str = "unknown";                                        \
1290                 break;                                                  \
1291         }                                                               \
1292         result = sprintf(page, "%s\n", str);                            \
1293         mutex_unlock(&opts->lock);                                      \
1294                                                                         \
1295         return result;                                                  \
1296 }                                                                       \
1297                                                                         \
1298 static ssize_t f_uac2_opts_##name##_store(struct config_item *item,     \
1299                                           const char *page, size_t len) \
1300 {                                                                       \
1301         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1302         int ret = 0;                                                    \
1303                                                                         \
1304         mutex_lock(&opts->lock);                                        \
1305         if (opts->refcnt) {                                             \
1306                 ret = -EBUSY;                                           \
1307                 goto end;                                               \
1308         }                                                               \
1309                                                                         \
1310         if (!strncmp(page, "async", 5))                                 \
1311                 opts->name = USB_ENDPOINT_SYNC_ASYNC;                   \
1312         else if (!strncmp(page, "adaptive", 8))                         \
1313                 opts->name = USB_ENDPOINT_SYNC_ADAPTIVE;                \
1314         else {                                                          \
1315                 ret = -EINVAL;                                          \
1316                 goto end;                                               \
1317         }                                                               \
1318                                                                         \
1319         ret = len;                                                      \
1320                                                                         \
1321 end:                                                                    \
1322         mutex_unlock(&opts->lock);                                      \
1323         return ret;                                                     \
1324 }                                                                       \
1325                                                                         \
1326 CONFIGFS_ATTR(f_uac2_opts_, name)
1327
1328 UAC2_ATTRIBUTE(p_chmask);
1329 UAC2_ATTRIBUTE(p_srate);
1330 UAC2_ATTRIBUTE(p_ssize);
1331 UAC2_ATTRIBUTE(c_chmask);
1332 UAC2_ATTRIBUTE(c_srate);
1333 UAC2_ATTRIBUTE_SYNC(c_sync);
1334 UAC2_ATTRIBUTE(c_ssize);
1335 UAC2_ATTRIBUTE(req_number);
1336 UAC2_ATTRIBUTE(fb_max);
1337
1338 static struct configfs_attribute *f_uac2_attrs[] = {
1339         &f_uac2_opts_attr_p_chmask,
1340         &f_uac2_opts_attr_p_srate,
1341         &f_uac2_opts_attr_p_ssize,
1342         &f_uac2_opts_attr_c_chmask,
1343         &f_uac2_opts_attr_c_srate,
1344         &f_uac2_opts_attr_c_ssize,
1345         &f_uac2_opts_attr_c_sync,
1346         &f_uac2_opts_attr_req_number,
1347         &f_uac2_opts_attr_fb_max,
1348         NULL,
1349 };
1350
1351 static const struct config_item_type f_uac2_func_type = {
1352         .ct_item_ops    = &f_uac2_item_ops,
1353         .ct_attrs       = f_uac2_attrs,
1354         .ct_owner       = THIS_MODULE,
1355 };
1356
1357 static void afunc_free_inst(struct usb_function_instance *f)
1358 {
1359         struct f_uac2_opts *opts;
1360
1361         opts = container_of(f, struct f_uac2_opts, func_inst);
1362         kfree(opts);
1363 }
1364
1365 static struct usb_function_instance *afunc_alloc_inst(void)
1366 {
1367         struct f_uac2_opts *opts;
1368
1369         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1370         if (!opts)
1371                 return ERR_PTR(-ENOMEM);
1372
1373         mutex_init(&opts->lock);
1374         opts->func_inst.free_func_inst = afunc_free_inst;
1375
1376         config_group_init_type_name(&opts->func_inst.group, "",
1377                                     &f_uac2_func_type);
1378
1379         opts->p_chmask = UAC2_DEF_PCHMASK;
1380         opts->p_srate = UAC2_DEF_PSRATE;
1381         opts->p_ssize = UAC2_DEF_PSSIZE;
1382         opts->c_chmask = UAC2_DEF_CCHMASK;
1383         opts->c_srate = UAC2_DEF_CSRATE;
1384         opts->c_ssize = UAC2_DEF_CSSIZE;
1385         opts->c_sync = UAC2_DEF_CSYNC;
1386         opts->req_number = UAC2_DEF_REQ_NUM;
1387         opts->fb_max = UAC2_DEF_FB_MAX;
1388         return &opts->func_inst;
1389 }
1390
1391 static void afunc_free(struct usb_function *f)
1392 {
1393         struct g_audio *agdev;
1394         struct f_uac2_opts *opts;
1395
1396         agdev = func_to_g_audio(f);
1397         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
1398         kfree(agdev);
1399         mutex_lock(&opts->lock);
1400         --opts->refcnt;
1401         mutex_unlock(&opts->lock);
1402 }
1403
1404 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
1405 {
1406         struct g_audio *agdev = func_to_g_audio(f);
1407
1408         g_audio_cleanup(agdev);
1409         usb_free_all_descriptors(f);
1410
1411         agdev->gadget = NULL;
1412 }
1413
1414 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
1415 {
1416         struct f_uac2   *uac2;
1417         struct f_uac2_opts *opts;
1418
1419         uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
1420         if (uac2 == NULL)
1421                 return ERR_PTR(-ENOMEM);
1422
1423         opts = container_of(fi, struct f_uac2_opts, func_inst);
1424         mutex_lock(&opts->lock);
1425         ++opts->refcnt;
1426         mutex_unlock(&opts->lock);
1427
1428         uac2->g_audio.func.name = "uac2_func";
1429         uac2->g_audio.func.bind = afunc_bind;
1430         uac2->g_audio.func.unbind = afunc_unbind;
1431         uac2->g_audio.func.set_alt = afunc_set_alt;
1432         uac2->g_audio.func.get_alt = afunc_get_alt;
1433         uac2->g_audio.func.disable = afunc_disable;
1434         uac2->g_audio.func.setup = afunc_setup;
1435         uac2->g_audio.func.free_func = afunc_free;
1436
1437         return &uac2->g_audio.func;
1438 }
1439
1440 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1441 MODULE_LICENSE("GPL");
1442 MODULE_AUTHOR("Yadwinder Singh");
1443 MODULE_AUTHOR("Jaswinder Singh");