linux/drivers/usb/gadget/function/f_uac2.c
<<
>>
Prefs
   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
  49struct 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
  55static 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
  60static inline
  61struct 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
  68enum {
  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
  83static char clksrc_in[8];
  84static char clksrc_out[8];
  85
  86static 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
 102static struct usb_gadget_strings str_fn = {
 103        .language = 0x0409,     /* en-us */
 104        .strings = strings_fn,
 105};
 106
 107static struct usb_gadget_strings *fn_strings[] = {
 108        &str_fn,
 109        NULL,
 110};
 111
 112static 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 */
 124static 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 */
 136static 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 */
 148static 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 */
 160static 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 */
 174static 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 */
 188static 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 */
 202static 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
 215static 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 */
 227static 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 */
 239static 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 */
 251static 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 */
 264static 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 */
 272static 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
 282static 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
 291static 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
 301static 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 */
 310static 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 */
 322static 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
 332static 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
 341static 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 */
 353static 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 */
 365static 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 */
 377static 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 */
 390static 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 */
 398static 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
 408static 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
 417static 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
 427static 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 */
 436static 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
 447static 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
 478static 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
 509static 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
 542struct cntrl_cur_lay3 {
 543        __le32  dCUR;
 544};
 545
 546struct cntrl_range_lay3 {
 547        __le16  wNumSubRanges;
 548        __le32  dMIN;
 549        __le32  dMAX;
 550        __le32  dRES;
 551} __packed;
 552
 553static 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
 601static 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
 674static 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
 728static 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
 758static int
 759afunc_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
 969err_free_descs:
 970        usb_free_all_descriptors(fn);
 971        agdev->gadget = NULL;
 972        return ret;
 973}
 974
 975static int
 976afunc_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
1021static int
1022afunc_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
1041static void
1042afunc_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
1052static int
1053in_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
1093static int
1094in_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
1135static int
1136ac_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
1146static int
1147out_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
1159static int
1160setup_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
1181static int
1182afunc_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
1214static 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
1220static 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
1227static struct configfs_item_operations f_uac2_item_ops = {
1228        .release        = f_uac2_attr_release,
1229};
1230
1231#define UAC2_ATTRIBUTE(name)                                            \
1232static 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                                                                        \
1245static 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                                                                        \
1265end:                                                                    \
1266        mutex_unlock(&opts->lock);                                      \
1267        return ret;                                                     \
1268}                                                                       \
1269                                                                        \
1270CONFIGFS_ATTR(f_uac2_opts_, name)
1271
1272#define UAC2_ATTRIBUTE_SYNC(name)                                       \
1273static 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                                                                        \
1298static 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                                                                        \
1321end:                                                                    \
1322        mutex_unlock(&opts->lock);                                      \
1323        return ret;                                                     \
1324}                                                                       \
1325                                                                        \
1326CONFIGFS_ATTR(f_uac2_opts_, name)
1327
1328UAC2_ATTRIBUTE(p_chmask);
1329UAC2_ATTRIBUTE(p_srate);
1330UAC2_ATTRIBUTE(p_ssize);
1331UAC2_ATTRIBUTE(c_chmask);
1332UAC2_ATTRIBUTE(c_srate);
1333UAC2_ATTRIBUTE_SYNC(c_sync);
1334UAC2_ATTRIBUTE(c_ssize);
1335UAC2_ATTRIBUTE(req_number);
1336UAC2_ATTRIBUTE(fb_max);
1337
1338static 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
1351static 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
1357static 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
1365static 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
1391static 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
1404static 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
1414static 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
1440DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1441MODULE_LICENSE("GPL");
1442MODULE_AUTHOR("Yadwinder Singh");
1443MODULE_AUTHOR("Jaswinder Singh");
1444