carl9170fw/carlfw/usb/usb.c

   1 /*
   2  * carl9170 firmware - used by the ar9170 wireless device
   3  *
   4  * USB Controller
   5  *
   6  * Copyright (c) 2000-2005  ZyDAS Technology Corporation
   7  * Copyright (c) 2007-2009 Atheros Communications, Inc.
   8  * Copyright    2009    Johannes Berg <johannes@sipsolutions.net>
   9  * Copyright 2009-2011  Christian Lamparter <chunkeey@googlemail.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; If not, see <http://www.gnu.org/licenses/>.
  23  */
  24 #include "carl9170.h"
  25 #include "usb.h"
  26 #include "printf.h"
  27 #include "rom.h"
  28
  29 /*
  30  * NB: The firmware has to write into these structures
  31  * so don't try to make them "const".
  32  */
  33
  34 static struct ar9170_usb_config usb_config_highspeed = {
  35         .cfg = {
  36                 .bLength = USB_DT_CONFIG_SIZE,
  37                 .bDescriptorType = USB_DT_CONFIG,
  38                 .wTotalLength = cpu_to_le16(sizeof(usb_config_highspeed)),
  39                 .bNumInterfaces = 1,
  40                 .bConfigurationValue = 1,
  41                 .iConfiguration = 0,
  42                 .bmAttributes = USB_CONFIG_ATT_ONE |
  43 #ifdef CONFIG_CARL9170FW_WOL
  44                                 USB_CONFIG_ATT_WAKEUP |
  45 #endif /* CONFIG_CARL9170FW_WOL */
  46                                 0,
  47                 .bMaxPower = 0xfa, /* 500 mA */
  48         },
  49
  50         .intf = {
  51                 .bLength = USB_DT_INTERFACE_SIZE,
  52                 .bDescriptorType = USB_DT_INTERFACE,
  53                 .bInterfaceNumber = 0,
  54                 .bAlternateSetting = 0,
  55                 .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP,
  56                 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
  57                 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC,
  58                 .bInterfaceProtocol = 0,
  59                 .iInterface = 0,
  60         },
  61
  62         .ep = {
  63                 {       /* EP 1 */
  64                         .bLength = USB_DT_ENDPOINT_SIZE,
  65                         .bDescriptorType = USB_DT_ENDPOINT,
  66                         .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX,
  67                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
  68                         .wMaxPacketSize = cpu_to_le16(512),
  69                         .bInterval = 0,
  70                 },
  71
  72                 {       /* EP 2 */
  73                         .bLength = USB_DT_ENDPOINT_SIZE,
  74                         .bDescriptorType = USB_DT_ENDPOINT,
  75                         .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX,
  76                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
  77                         .wMaxPacketSize = cpu_to_le16(512),
  78                         .bInterval = 0,
  79                 },
  80
  81                 {       /* EP 3 */
  82                         .bLength = USB_DT_ENDPOINT_SIZE,
  83                         .bDescriptorType = USB_DT_ENDPOINT,
  84                         .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ,
  85                         .bmAttributes = USB_ENDPOINT_XFER_INT,
  86                         .wMaxPacketSize = cpu_to_le16(64),
  87                         .bInterval = 1,
  88                 },
  89
  90                 {       /* EP 4 */
  91                         .bLength = USB_DT_ENDPOINT_SIZE,
  92                         .bDescriptorType = USB_DT_ENDPOINT,
  93                         .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD,
  94                         .bmAttributes = USB_ENDPOINT_XFER_INT,
  95                         .wMaxPacketSize = cpu_to_le16(64),
  96                         .bInterval = 1,
  97                 },
  98         },
  99 };
 100
 101 static struct ar9170_usb_config usb_config_fullspeed = {
 102         .cfg = {
 103                 .bLength = USB_DT_CONFIG_SIZE,
 104                 .bDescriptorType = USB_DT_CONFIG,
 105                 .wTotalLength = cpu_to_le16(sizeof(usb_config_fullspeed)),
 106                 .bNumInterfaces = 1,
 107                 .bConfigurationValue = 1,
 108                 .iConfiguration = 0,
 109                 .bmAttributes = USB_CONFIG_ATT_ONE |
 110 #ifdef CONFIG_CARL9170FW_WOL
 111                                 USB_CONFIG_ATT_WAKEUP |
 112 #endif /* CONFIG_CARL9170FW_WOL */
 113                                 0,
 114                 .bMaxPower = 0xfa, /* 500 mA */
 115         },
 116
 117         .intf = {
 118                 .bLength = USB_DT_INTERFACE_SIZE,
 119                 .bDescriptorType = USB_DT_INTERFACE,
 120                 .bInterfaceNumber = 0,
 121                 .bAlternateSetting = 0,
 122                 .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP,
 123                 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 124                 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC,
 125                 .bInterfaceProtocol = 0,
 126                 .iInterface = 0,
 127         },
 128
 129         .ep = {
 130                 {       /* EP 1 */
 131                         .bLength = USB_DT_ENDPOINT_SIZE,
 132                         .bDescriptorType = USB_DT_ENDPOINT,
 133                         .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX,
 134                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
 135                         .wMaxPacketSize = cpu_to_le16(64),
 136                         .bInterval = 0,
 137                 },
 138
 139                 {       /* EP 2 */
 140                         .bLength = USB_DT_ENDPOINT_SIZE,
 141                         .bDescriptorType = USB_DT_ENDPOINT,
 142                         .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX,
 143                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
 144                         .wMaxPacketSize = cpu_to_le16(64),
 145                         .bInterval = 0,
 146                 },
 147
 148                 {       /* EP 3 */
 149                         .bLength = USB_DT_ENDPOINT_SIZE,
 150                         .bDescriptorType = USB_DT_ENDPOINT,
 151                         .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ,
 152                         .bmAttributes = USB_ENDPOINT_XFER_INT,
 153                         .wMaxPacketSize = cpu_to_le16(64),
 154                         .bInterval = 1,
 155                 },
 156
 157                 {       /* EP 4 */
 158                         .bLength = USB_DT_ENDPOINT_SIZE,
 159                         .bDescriptorType = USB_DT_ENDPOINT,
 160                         .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD,
 161                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
 162                         .wMaxPacketSize = cpu_to_le16(64),
 163                         .bInterval = 1,
 164                 },
 165         },
 166 };
 167
 168 void usb_reset_eps(void)
 169 {
 170         unsigned int i;
 171
 172         /* clear all EPs' toggle bit */
 173         for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) {
 174                 usb_set_input_ep_toggle(i);
 175                 usb_clear_input_ep_toggle(i);
 176                 usb_clear_input_ep_stall(i);
 177         }
 178
 179         /*
 180          * NB: I've no idea why this cannot be integrated into the
 181          * previous loop?
 182          */
 183         for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) {
 184                 usb_set_output_ep_toggle(i);
 185                 usb_clear_output_ep_toggle(i);
 186                 usb_clear_output_ep_stall(i);
 187         }
 188 }
 189
 190 static void usb_pta_init(void)
 191 {
 192         unsigned int usb_dma_ctrl = 0;
 193         /* Set PTA mode to USB */
 194         andl(AR9170_PTA_REG_DMA_MODE_CTRL,
 195                 ~AR9170_PTA_DMA_MODE_CTRL_DISABLE_USB);
 196
 197         /* Do a software reset to PTA component */
 198         orl(AR9170_PTA_REG_DMA_MODE_CTRL, AR9170_PTA_DMA_MODE_CTRL_RESET);
 199         andl(AR9170_PTA_REG_DMA_MODE_CTRL, ~AR9170_PTA_DMA_MODE_CTRL_RESET);
 200
 201         if (usb_detect_highspeed()) {
 202                 fw.usb.os_cfg_desc = &usb_config_fullspeed;
 203                 fw.usb.cfg_desc = &usb_config_highspeed;
 204
 205                 /* 512 Byte DMA transfers */
 206                 usb_dma_ctrl |= AR9170_USB_DMA_CTL_HIGH_SPEED;
 207         } else {
 208                 fw.usb.cfg_desc = &usb_config_fullspeed;
 209                 fw.usb.os_cfg_desc = &usb_config_highspeed;
 210         }
 211
 212 #ifdef CONFIG_CARL9170FW_USB_UP_STREAM
 213 # if (CONFIG_CARL9170FW_RX_FRAME_LEN == 4096)
 214         usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_4K;
 215 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 8192)
 216         usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_8K;
 217 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 16384)
 218         usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_16K;
 219 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 32768)
 220         usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_32K;
 221 # else
 222 #       error "Invalid AR9170_RX_FRAME_LEN setting"
 223 # endif
 224
 225 #else /* CONFIG_CARL9170FW_USB_UP_STREAM */
 226         usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_PACKET_MODE;
 227 #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */
 228
 229 #ifdef CONFIG_CARL9170FW_USB_DOWN_STREAM
 230         /* Enable down stream mode */
 231         usb_dma_ctrl |= AR9170_USB_DMA_CTL_DOWN_STREAM;
 232 #endif /* CONFIG_CARL9170FW_USB_DOWN_STREAM */
 233
 234 #ifdef CONFIG_CARL9170FW_USB_UP_STREAM
 235         /* Set the up stream mode maximum aggregate number */
 236         set(AR9170_USB_REG_MAX_AGG_UPLOAD, 4);
 237
 238         /*
 239          * Set the up stream mode timeout value.
 240          * NB: The vendor driver (otus) set 0x80?
 241          */
 242         set(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80);
 243 #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */
 244
 245         /* Enable up stream and down stream */
 246         usb_dma_ctrl |= AR9170_USB_DMA_CTL_ENABLE_TO_DEVICE |
 247             AR9170_USB_DMA_CTL_ENABLE_FROM_DEVICE;
 248
 249         set(AR9170_USB_REG_DMA_CTL, usb_dma_ctrl);
 250 }
 251
 252 void usb_init(void)
 253 {
 254         usb_pta_init();
 255
 256         fw.usb.config = 1;
 257         /*
 258          * The fw structure is always initialized with "0"
 259          * during boot(); No need to waste precious bytes here.
 260          *
 261          * fw.usb.interface_setting = 0;
 262          * fw.usb.alternate_interface_setting = 0;
 263          * fw.usb.device_feature = 0;
 264          */
 265
 266 #ifdef CONFIG_CARL9170FW_WOL
 267         fw.usb.device_feature |= USB_DEVICE_REMOTE_WAKEUP;
 268         usb_enable_remote_wakeup();
 269 #endif /* CONFIG_CARL9170FW_WOL */
 270 }
 271
 272 #define GET_ARRAY(a, o) ((uint32_t *) (((unsigned long) data) + offset))
 273
 274 static void usb_ep0rx_data(const void *data, const unsigned int len)
 275 {
 276         unsigned int offset;
 277         uint32_t value;
 278
 279         BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
 280         BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
 281
 282         for (offset = 0; offset < ((len + 3) & ~3); offset += 4) {
 283                 value = get(AR9170_USB_REG_EP0_DATA);
 284                 memcpy(GET_ARRAY(data, offset), &value,
 285                        min(len - offset, (unsigned int)4));
 286         }
 287 }
 288
 289 static int usb_ep0tx_data(const void *data, const unsigned int len)
 290 {
 291         unsigned int offset = 0, block, last_block = 0;
 292         uint32_t value;
 293
 294         BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
 295         BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
 296
 297         block = min(len, (unsigned int) 4);
 298         offset = 0;
 299         while (offset < len) {
 300
 301                 if (last_block != block || block < 4)
 302                         setb(AR9170_USB_REG_FIFO_SIZE, (1 << block) - 1);
 303
 304                 memcpy(&value, GET_ARRAY(data, offset), block);
 305
 306                 set(AR9170_USB_REG_EP0_DATA, value);
 307
 308                 offset += block;
 309                 last_block = block = min(len - offset, (unsigned int) 4);
 310         }
 311
 312         setb(AR9170_USB_REG_FIFO_SIZE, 0xf);
 313
 314         /* this will push the data to the host */
 315         return 1;
 316 }
 317 #undef GET_ARRAY
 318
 319 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
 320 static int usb_get_status(const struct usb_ctrlrequest *ctrl)
 321 {
 322         __le16 status = cpu_to_le16(fw.usb.device_feature);
 323
 324         if ((ctrl->bRequestType & USB_DIR_MASK) != USB_DIR_IN)
 325                 return -1;
 326
 327         switch (ctrl->bRequestType & USB_RECIP_MASK) {
 328         case USB_RECIP_DEVICE:
 329                 status &= cpu_to_le16(~USB_DEVICE_SELF_POWERED);
 330                 status &= cpu_to_le16(~USB_DEVICE_REMOTE_WAKEUP);
 331                 break;
 332
 333         case USB_RECIP_INTERFACE:
 334                 /* USB spec: This is reserved for future use. */
 335                 status = cpu_to_le16(0);
 336                 break;
 337
 338         case USB_RECIP_ENDPOINT: {
 339                 unsigned int ep = le16_to_cpu(ctrl->wIndex) & 0xf;
 340                 unsigned int dir = le16_to_cpu(ctrl->wIndex) & USB_DIR_MASK;
 341
 342                 if (ep == 0) {
 343                         status = !!(getb(AR9170_USB_REG_CX_CONFIG_STATUS) & BIT(2));
 344                 } else {
 345                         unsigned int addr;
 346
 347                         if (dir == USB_DIR_IN)
 348                                 addr = AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH;
 349                         else
 350                                 addr = AR9170_USB_REG_EP_OUT_MAX_SIZE_HIGH;
 351
 352                         addr += (ep << 1);
 353
 354                         /*
 355                          * AR9170_USB_EP_OUT_STALL == AR9170_USB_EP_IN_STALL
 356                          * so it doesn't matter which one we use
 357                          */
 358                         status = !!(getb(addr) & AR9170_USB_EP_OUT_STALL);
 359                 }
 360                 break;
 361                 }
 362         case USB_RECIP_OTHER:
 363         default:
 364                 break;
 365         }
 366
 367         return usb_ep0tx_data((const void *) &status, sizeof(status));
 368 }
 369
 370 static int usb_get_string_desc(const struct usb_ctrlrequest *ctrl)
 371 {
 372         const struct usb_string_descriptor *string_desc = NULL;
 373
 374         switch (le16_to_cpu(ctrl->wValue) & 0xff) {
 375         case 0x00:
 376                 string_desc = (const struct usb_string_descriptor *)
 377                         rom.hw.usb.string0_desc;
 378                 break;
 379
 380         case 0x10:
 381                 string_desc = (const struct usb_string_descriptor *)
 382                         rom.hw.usb.string1_desc;
 383                 break;
 384
 385         case 0x20:
 386                 string_desc = (const struct usb_string_descriptor *)
 387                         rom.hw.usb.string2_desc;
 388                 break;
 389
 390         case 0x30:
 391                 string_desc = (const struct usb_string_descriptor *)
 392                         rom.hw.usb.string3_desc;
 393                 break;
 394
 395         default:
 396                 break;
 397         }
 398
 399         if (string_desc)
 400                 return usb_ep0tx_data(string_desc, string_desc->bLength);
 401
 402         return -1;
 403 }
 404
 405 static int usb_get_device_desc(const struct usb_ctrlrequest *ctrl __unused)
 406 {
 407         return usb_ep0tx_data(&rom.hw.usb.device_desc,
 408                               rom.hw.usb.device_desc.bLength);
 409 }
 410
 411 static int usb_get_config_desc(const struct usb_ctrlrequest *ctrl __unused)
 412 {
 413         fw.usb.cfg_desc->cfg.bDescriptorType = USB_DT_CONFIG;
 414
 415         return usb_ep0tx_data(fw.usb.cfg_desc,
 416                 le16_to_cpu(fw.usb.cfg_desc->cfg.wTotalLength));
 417 }
 418
 419 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
 420 static int usb_get_otherspeed_desc(const struct usb_ctrlrequest *ctrl __unused)
 421 {
 422
 423         fw.usb.os_cfg_desc->cfg.bDescriptorType = USB_DT_OTHER_SPEED_CONFIG;
 424
 425         return usb_ep0tx_data(fw.usb.os_cfg_desc,
 426                 le16_to_cpu(fw.usb.os_cfg_desc->cfg.wTotalLength));
 427 }
 428 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
 429
 430 static int usb_get_qualifier_desc(const struct usb_ctrlrequest *ctrl __unused)
 431 {
 432         struct usb_qualifier_descriptor qual;
 433
 434         /*
 435          * The qualifier descriptor shares some structural details
 436          * with the main device descriptor.
 437          */
 438
 439         memcpy(&qual, &rom.hw.usb.device_desc, sizeof(qual));
 440
 441         /* (Re)-Initialize fields */
 442         qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
 443         qual.bLength = sizeof(qual);
 444         qual.bNumConfigurations = rom.hw.usb.device_desc.bNumConfigurations;
 445         qual.bRESERVED = 0;
 446
 447         return usb_ep0tx_data(&qual, qual.bLength);
 448 }
 449
 450 #define USB_CHECK_REQTYPE(ctrl, recip, dir)                     \
 451         (((ctrl->bRequestType & USB_RECIP_MASK) != recip) ||    \
 452          ((ctrl->bRequestType & USB_DIR_MASK) != dir))
 453
 454 static int usb_get_descriptor(const struct usb_ctrlrequest *ctrl)
 455 {
 456         int status = -1;
 457
 458         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN))
 459                 return status;
 460
 461         switch (le16_to_cpu(ctrl->wValue) >> 8) {
 462         case USB_DT_DEVICE:
 463                 status = usb_get_device_desc(ctrl);
 464                 break;
 465
 466         case USB_DT_CONFIG:
 467                 status = usb_get_config_desc(ctrl);
 468                 break;
 469
 470         case USB_DT_STRING:
 471                 status = usb_get_string_desc(ctrl);
 472                 break;
 473
 474         case USB_DT_INTERFACE:
 475                 break;
 476
 477         case USB_DT_ENDPOINT:
 478                 break;
 479
 480         case USB_DT_DEVICE_QUALIFIER:
 481                 status = usb_get_qualifier_desc(ctrl);
 482                 break;
 483
 484 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
 485         case USB_DT_OTHER_SPEED_CONFIG:
 486                 status = usb_get_otherspeed_desc(ctrl);
 487                 break;
 488 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
 489         default:
 490                 break;
 491
 492         }
 493
 494         return status;
 495 }
 496
 497 static int usb_get_configuration(const struct usb_ctrlrequest *ctrl)
 498 {
 499         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN))
 500                 return -1;
 501
 502         return usb_ep0tx_data(&fw.usb.config, fw.usb.config);
 503 }
 504
 505 static int usb_set_configuration(const struct usb_ctrlrequest *ctrl)
 506 {
 507         unsigned int config;
 508
 509         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT))
 510                 return -1;
 511
 512         config = le16_to_cpu(ctrl->wValue);
 513         switch (config) {
 514         case 0:
 515                 /* Disable Device */
 516                 andb(AR9170_USB_REG_DEVICE_ADDRESS,
 517                       (uint8_t) ~(AR9170_USB_DEVICE_ADDRESS_CONFIGURE));
 518                 /* fall through */
 519         case 1:
 520                 fw.usb.config = config;
 521
 522 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
 523                 if (usb_detect_highspeed()) {
 524                         /* High Speed Configuration */
 525                         usb_init_highspeed_fifo_cfg();
 526                 } else {
 527                         /* Full Speed Configuration */
 528                         usb_init_fullspeed_fifo_cfg();
 529                 }
 530                 /* usb_pta_init() ? */
 531 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
 532
 533                 usb_reset_eps();
 534                 orb(AR9170_USB_REG_DEVICE_ADDRESS,
 535                     (AR9170_USB_DEVICE_ADDRESS_CONFIGURE));
 536
 537                 usb_enable_global_int();
 538                 usb_trigger_out();
 539                 return 1;
 540
 541         default:
 542                 return -1;
 543         }
 544 }
 545
 546 static int usb_set_address(const struct usb_ctrlrequest *ctrl)
 547 {
 548         unsigned int address;
 549
 550         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT))
 551                 return -1;
 552
 553         address = le16_to_cpu(ctrl->wValue);
 554
 555         /*
 556          * The original firmware used 0x100 (which is, of course,
 557          * too big to fit into uint8_t).
 558          * However based on the available information (hw.h), BIT(7)
 559          * is used as some sort of flag and should not be
 560          * part of the device address.
 561          */
 562         if (address >= BIT(7))
 563                 return -1;
 564
 565         setb(AR9170_USB_REG_DEVICE_ADDRESS, (uint8_t) address);
 566         return 1;
 567 }
 568
 569 static int usb_get_interface(const struct usb_ctrlrequest *ctrl)
 570 {
 571         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_IN))
 572                 return -1;
 573
 574         if (usb_configured() == false)
 575                 return -1;
 576
 577         switch (fw.usb.config) {
 578         case 1:
 579                 break;
 580
 581         default:
 582                 return -1;
 583         }
 584
 585         return usb_ep0tx_data(&fw.usb.alternate_interface_setting, 1);
 586 }
 587
 588 static int usb_manipulate_feature(const struct usb_ctrlrequest *ctrl, bool __unused clear)
 589 {
 590         unsigned int feature;
 591
 592         if ((ctrl->bRequestType & USB_DIR_MASK) != USB_DIR_OUT)
 593                 return -1;
 594
 595         if (usb_configured() == false)
 596                 return -1;
 597
 598         feature = le16_to_cpu(ctrl->wValue);
 599
 600         switch (ctrl->bRequestType & USB_RECIP_MASK) {
 601         case USB_RECIP_DEVICE: {
 602 #ifdef CONFIG_CARL9170FW_WOL
 603                 if (feature & USB_DEVICE_REMOTE_WAKEUP) {
 604                         if (clear)
 605                                 usb_disable_remote_wakeup();
 606                         else
 607                                 usb_enable_remote_wakeup();
 608                 }
 609 #endif /* CONFIG_CARL9170FW_WOL */
 610
 611                 if (clear)
 612                         fw.usb.device_feature &= ~feature;
 613                 else
 614                         fw.usb.device_feature |= feature;
 615
 616
 617                 break;
 618                 }
 619
 620         case USB_RECIP_ENDPOINT: {
 621                 unsigned int ep, dir;
 622
 623                 ep = le16_to_cpu(ctrl->wIndex) & 0xf;
 624                 dir = le16_to_cpu(ctrl->wIndex) & USB_DIR_MASK;
 625                 if (ep == 0) {
 626                         /* According to the spec, EP cannot be stopped this way. */
 627                         return -1;
 628                 } else {
 629                         unsigned int addr;
 630
 631                         if (dir == USB_DIR_IN)
 632                                 addr = AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH;
 633                         else
 634                                 addr = AR9170_USB_REG_EP_OUT_MAX_SIZE_HIGH;
 635
 636                         addr += (ep << 1);
 637
 638                         if (clear)
 639                                 andb(addr, ~AR9170_USB_EP_OUT_STALL);
 640                         else
 641                                 orb(addr, AR9170_USB_EP_OUT_STALL);
 642                 }
 643                 break;
 644                 }
 645
 646         case USB_RECIP_INTERFACE:
 647                 /*
 648                  * the current USB Specification Revision 2
 649                  * specifies no interface features.
 650                  */
 651
 652         default:
 653                 return -1;
 654         }
 655
 656         return 1;
 657 }
 658
 659 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
 660 static int usb_set_interface(const struct usb_ctrlrequest *ctrl)
 661 {
 662         unsigned int intf, alt_intf;
 663         if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_OUT))
 664                 return -1;
 665
 666         if (usb_configured() == false)
 667                 return -1;
 668
 669         intf = le16_to_cpu(ctrl->wIndex);
 670         alt_intf = le16_to_cpu(ctrl->wValue);
 671
 672         switch (intf) {
 673         case 0:
 674                 if (alt_intf != fw.usb.cfg_desc->intf.bAlternateSetting)
 675                         return -1;
 676
 677                 fw.usb.interface_setting = (uint8_t) intf;
 678                 fw.usb.alternate_interface_setting = (uint8_t) alt_intf;
 679                 if (usb_detect_highspeed())
 680                         usb_init_highspeed_fifo_cfg();
 681                 else
 682                         usb_init_fullspeed_fifo_cfg();
 683
 684                 usb_reset_eps();
 685                 usb_enable_global_int();
 686                 usb_trigger_out();
 687                 return 1;
 688
 689         default:
 690                 return -1;
 691         }
 692 }
 693 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
 694 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
 695
 696 static int usb_standard_command(const struct usb_ctrlrequest *ctrl __unused)
 697 {
 698         int status = -1;
 699
 700 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
 701         switch (ctrl->bRequest) {
 702         case USB_REQ_GET_STATUS:
 703                 status = usb_get_status(ctrl);
 704                 break;
 705
 706         case USB_REQ_CLEAR_FEATURE:
 707         case USB_REQ_SET_FEATURE:
 708                 status = usb_manipulate_feature(ctrl, ctrl->bRequest == USB_REQ_CLEAR_FEATURE);
 709                 break;
 710
 711         case USB_REQ_SET_ADDRESS:
 712                 status = usb_set_address(ctrl);
 713                 break;
 714
 715         case USB_REQ_GET_DESCRIPTOR:
 716                 status = usb_get_descriptor(ctrl);
 717                 break;
 718
 719         case USB_REQ_SET_DESCRIPTOR:
 720                 break;
 721
 722         case USB_REQ_GET_CONFIGURATION:
 723                 status = usb_get_configuration(ctrl);
 724                 break;
 725
 726         case USB_REQ_SET_CONFIGURATION:
 727                 status = usb_set_configuration(ctrl);
 728                 break;
 729
 730         case USB_REQ_GET_INTERFACE:
 731                 status = usb_get_interface(ctrl);
 732                 break;
 733
 734         case USB_REQ_SET_INTERFACE:
 735 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
 736                 status = usb_set_interface(ctrl);
 737 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
 738                 break;
 739
 740         case USB_REQ_SYNCH_FRAME:
 741                 break;
 742
 743         default:
 744                 break;
 745
 746         }
 747 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
 748
 749         return status;
 750 }
 751
 752 static int usb_class_command(const struct usb_ctrlrequest *ctrl __unused)
 753 {
 754         return -1;
 755 }
 756
 757 static int usb_vendor_command(const struct usb_ctrlrequest *ctrl __unused)
 758 {
 759         /*
 760          * Note: Firmware upload/boot is not implemented.
 761          * It's impossible to replace the current image
 762          * in place.
 763          */
 764
 765         return -1;
 766 }
 767
 768 #undef USB_CHECK_TYPE
 769
 770 void usb_ep0setup(void)
 771 {
 772         struct usb_ctrlrequest ctrl;
 773         int status = -1;
 774         usb_ep0rx_data(&ctrl, sizeof(ctrl));
 775
 776         switch (ctrl.bRequestType & USB_TYPE_MASK) {
 777         case USB_TYPE_STANDARD:
 778                 status = usb_standard_command(&ctrl);
 779                 break;
 780
 781         case USB_TYPE_CLASS:
 782                 status = usb_class_command(&ctrl);
 783                 break;
 784
 785         case USB_TYPE_VENDOR:
 786                 status = usb_vendor_command(&ctrl);
 787                 break;
 788
 789         default:
 790                 break;
 791
 792         }
 793
 794         if (status < 0)
 795                 fw.usb.ep0_action |= CARL9170_EP0_STALL;
 796 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
 797         if (status > 0)
 798                 fw.usb.ep0_action |= CARL9170_EP0_TRIGGER;
 799 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
 800 }
 801
 802 void usb_ep0rx(void)
 803 {
 804         if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len))
 805                 return ;
 806
 807         usb_ep0rx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len);
 808         fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len;
 809 }
 810
 811 void usb_ep0tx(void)
 812 {
 813         if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len))
 814                 return ;
 815
 816         usb_ep0tx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len);
 817         fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len;
 818 }