carl9170fw/carlfw/usb/fifo.c

   1 /*
   2  * carl9170 firmware - used by the ar9170 wireless device
   3  *
   4  * Copyright (c) 2000-2005  ZyDAS Technology Corporation
   5  * Copyright (c) 2007-2009 Atheros Communications, Inc.
   6  * Copyright    2009    Johannes Berg <johannes@sipsolutions.net>
   7  * Copyright 2009-2011  Christian Lamparter <chunkeey@googlemail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "carl9170.h"
  24 #include "printf.h"
  25 #include "rom.h"
  26 #include "usb_fifo.h"
  27
  28 /* TODO / TOTEST */
  29 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
  30 static void usb_ep_map(const uint8_t ep, const uint8_t map)
  31 {
  32         setb(AR9170_USB_REG_EP_MAP + (ep - 1), map);
  33 }
  34
  35 static void usb_fifo_map(const uint8_t fifo, const uint8_t map)
  36 {
  37         setb(AR9170_USB_REG_FIFO_MAP + (fifo - 1), map);
  38 }
  39
  40 static void usb_fifo_config(const uint8_t fifo, const uint8_t cfg)
  41 {
  42         setb(AR9170_USB_REG_FIFO_CONFIG + (fifo - 1), cfg);
  43 }
  44
  45 static void usb_ep_packet_size_hi(const uint8_t ep, const uint8_t dir,
  46                              const uint16_t size)
  47 {
  48         setb(AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH + (((dir * 0x20) + ep) << 1),
  49              (size >> 8) & 0xf);
  50 }
  51
  52 static void usb_ep_packet_size_lo(const uint8_t ep, const uint8_t dir,
  53                             const uint16_t size)
  54 {
  55         setb(AR9170_USB_REG_EP_IN_MAX_SIZE_LOW + (((dir * 0x20) + ep) << 1),
  56              size & 0xff);
  57 }
  58
  59 static void usb_ep_in_highbandset(const uint8_t ep, const uint8_t dir,
  60                                 const uint16_t size)
  61 {
  62         andb(AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH + (ep << 1), ~(BIT(6) | BIT(5)));
  63
  64         switch (dir) {
  65         case DIRECTION_IN:
  66                 setb(AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH + (ep << 1),
  67                      ((size >> 11) + 1) << 5);
  68                 break;
  69         case DIRECTION_OUT:
  70         default:
  71                 break;
  72         }
  73 }
  74
  75 /*
  76  *      vUsbFIFO_EPxCfg_HS(void)
  77  *      Description:
  78  *          1. Configure the FIFO and EPx map
  79  *      input: none
  80  *      output: none
  81  */
  82
  83 void usb_init_highspeed_fifo_cfg(void)
  84 {
  85         int i;
  86
  87         /* EP 1 */
  88         usb_ep_map(1, HS_C1_I0_A0_EP1_MAP);
  89         usb_fifo_map(HS_C1_I0_A0_EP1_FIFO_START, HS_C1_I0_A0_EP1_FIFO_MAP);
  90         usb_fifo_config(HS_C1_I0_A0_EP1_FIFO_START, HS_C1_I0_A0_EP1_FIFO_CONFIG);
  91
  92         for (i = HS_C1_I0_A0_EP1_FIFO_START + 1;
  93              i < HS_C1_I0_A0_EP1_FIFO_START + HS_C1_I0_A0_EP1_FIFO_NO; i++) {
  94                 usb_fifo_config(i, (HS_C1_I0_A0_EP1_FIFO_CONFIG & (~BIT(7))));
  95         }
  96
  97         usb_ep_packet_size_hi(1, HS_C1_I0_A0_EP1_DIRECTION, (HS_C1_I0_A0_EP1_MAX_PACKET & 0x7ff));
  98         usb_ep_packet_size_lo(1, HS_C1_I0_A0_EP1_DIRECTION, (HS_C1_I0_A0_EP1_MAX_PACKET & 0x7ff));
  99         usb_ep_in_highbandset(1, HS_C1_I0_A0_EP1_DIRECTION, HS_C1_I0_A0_EP1_MAX_PACKET);
 100
 101         /* EP 2 */
 102         usb_ep_map(2, HS_C1_I0_A0_EP2_MAP);
 103         usb_fifo_map(HS_C1_I0_A0_EP2_FIFO_START, HS_C1_I0_A0_EP2_FIFO_MAP);
 104         usb_fifo_config(HS_C1_I0_A0_EP2_FIFO_START, HS_C1_I0_A0_EP2_FIFO_CONFIG);
 105
 106         for (i = HS_C1_I0_A0_EP2_FIFO_START + 1;
 107              i < HS_C1_I0_A0_EP2_FIFO_START + HS_C1_I0_A0_EP2_FIFO_NO; i++) {
 108                 usb_fifo_config(i, (HS_C1_I0_A0_EP2_FIFO_CONFIG & (~BIT(7))));
 109         }
 110
 111         usb_ep_packet_size_hi(2, HS_C1_I0_A0_EP2_DIRECTION, (HS_C1_I0_A0_EP2_MAX_PACKET & 0x7ff));
 112         usb_ep_packet_size_lo(2, HS_C1_I0_A0_EP2_DIRECTION, (HS_C1_I0_A0_EP2_MAX_PACKET & 0x7ff));
 113         usb_ep_in_highbandset(2, HS_C1_I0_A0_EP2_DIRECTION, HS_C1_I0_A0_EP2_MAX_PACKET);
 114
 115         /* EP 3 */
 116         usb_ep_map(3, HS_C1_I0_A0_EP3_MAP);
 117         usb_fifo_map(HS_C1_I0_A0_EP3_FIFO_START, HS_C1_I0_A0_EP3_FIFO_MAP);
 118         usb_fifo_config(HS_C1_I0_A0_EP3_FIFO_START, HS_C1_I0_A0_EP3_FIFO_CONFIG);
 119
 120         for (i = HS_C1_I0_A0_EP3_FIFO_START + 1;
 121              i < HS_C1_I0_A0_EP3_FIFO_START + HS_C1_I0_A0_EP3_FIFO_NO; i++) {
 122                 usb_fifo_config(i, (HS_C1_I0_A0_EP3_FIFO_CONFIG & (~BIT(7))));
 123         }
 124
 125         usb_ep_packet_size_hi(3, HS_C1_I0_A0_EP3_DIRECTION, (HS_C1_I0_A0_EP3_MAX_PACKET & 0x7ff));
 126         usb_ep_packet_size_lo(3, HS_C1_I0_A0_EP3_DIRECTION, (HS_C1_I0_A0_EP3_MAX_PACKET & 0x7ff));
 127         usb_ep_in_highbandset(3, HS_C1_I0_A0_EP3_DIRECTION, HS_C1_I0_A0_EP3_MAX_PACKET);
 128
 129         /* EP 4 */
 130         usb_ep_map(4, HS_C1_I0_A0_EP4_MAP);
 131         usb_fifo_map(HS_C1_I0_A0_EP4_FIFO_START, HS_C1_I0_A0_EP4_FIFO_MAP);
 132         usb_fifo_config(HS_C1_I0_A0_EP4_FIFO_START, HS_C1_I0_A0_EP4_FIFO_CONFIG);
 133
 134         for (i = HS_C1_I0_A0_EP4_FIFO_START + 1;
 135              i < HS_C1_I0_A0_EP4_FIFO_START + HS_C1_I0_A0_EP4_FIFO_NO; i++) {
 136                 usb_fifo_config(i, (HS_C1_I0_A0_EP4_FIFO_CONFIG & (~BIT(7))));
 137         }
 138
 139         usb_ep_packet_size_hi(4, HS_C1_I0_A0_EP4_DIRECTION, (HS_C1_I0_A0_EP4_MAX_PACKET & 0x7ff));
 140         usb_ep_packet_size_lo(4, HS_C1_I0_A0_EP4_DIRECTION, (HS_C1_I0_A0_EP4_MAX_PACKET & 0x7ff));
 141         usb_ep_in_highbandset(4, HS_C1_I0_A0_EP4_DIRECTION, HS_C1_I0_A0_EP4_MAX_PACKET);
 142 }
 143
 144 void usb_init_fullspeed_fifo_cfg(void)
 145 {
 146         int i;
 147
 148         /* EP 1 */
 149         usb_ep_map(1, FS_C1_I0_A0_EP1_MAP);
 150         usb_fifo_map(FS_C1_I0_A0_EP1_FIFO_START, FS_C1_I0_A0_EP1_FIFO_MAP);
 151         usb_fifo_config(FS_C1_I0_A0_EP1_FIFO_START, FS_C1_I0_A0_EP1_FIFO_CONFIG);
 152
 153         for (i = FS_C1_I0_A0_EP1_FIFO_START + 1;
 154              i < FS_C1_I0_A0_EP1_FIFO_START + FS_C1_I0_A0_EP1_FIFO_NO; i++) {
 155                 usb_fifo_config(i, (FS_C1_I0_A0_EP1_FIFO_CONFIG & (~BIT(7))));
 156         }
 157
 158         usb_ep_packet_size_hi(1, FS_C1_I0_A0_EP1_DIRECTION, (FS_C1_I0_A0_EP1_MAX_PACKET & 0x7ff));
 159         usb_ep_packet_size_lo(1, FS_C1_I0_A0_EP1_DIRECTION, (FS_C1_I0_A0_EP1_MAX_PACKET & 0x7ff));
 160         /* ``.JWEI 2003/04/29 */
 161         usb_ep_in_highbandset(1, FS_C1_I0_A0_EP1_DIRECTION, FS_C1_I0_A0_EP1_MAX_PACKET);
 162
 163         /* EP 2 */
 164         usb_ep_map(2, FS_C1_I0_A0_EP2_MAP);
 165         usb_fifo_map(FS_C1_I0_A0_EP2_FIFO_START, FS_C1_I0_A0_EP2_FIFO_MAP);
 166         usb_fifo_config(FS_C1_I0_A0_EP2_FIFO_START, FS_C1_I0_A0_EP2_FIFO_CONFIG);
 167
 168         for (i = FS_C1_I0_A0_EP2_FIFO_START + 1;
 169              i < FS_C1_I0_A0_EP2_FIFO_START + FS_C1_I0_A0_EP2_FIFO_NO; i++) {
 170                 usb_fifo_config(i, (FS_C1_I0_A0_EP2_FIFO_CONFIG & (~BIT(7))));
 171         }
 172
 173         usb_ep_packet_size_hi(2, FS_C1_I0_A0_EP2_DIRECTION, (FS_C1_I0_A0_EP2_MAX_PACKET & 0x7ff));
 174         usb_ep_packet_size_lo(2, FS_C1_I0_A0_EP2_DIRECTION, (FS_C1_I0_A0_EP2_MAX_PACKET & 0x7ff));
 175         usb_ep_in_highbandset(2, FS_C1_I0_A0_EP2_DIRECTION, FS_C1_I0_A0_EP2_MAX_PACKET);
 176
 177         /* EP 3 */
 178         usb_ep_map(3, FS_C1_I0_A0_EP3_MAP);
 179         usb_fifo_map(FS_C1_I0_A0_EP3_FIFO_START, FS_C1_I0_A0_EP3_FIFO_MAP);
 180         usb_fifo_config(FS_C1_I0_A0_EP3_FIFO_START, FS_C1_I0_A0_EP3_FIFO_CONFIG);
 181
 182         for (i = FS_C1_I0_A0_EP3_FIFO_START + 1;
 183              i < FS_C1_I0_A0_EP3_FIFO_START + FS_C1_I0_A0_EP3_FIFO_NO; i++) {
 184                 usb_fifo_config(i, (FS_C1_I0_A0_EP3_FIFO_CONFIG & (~BIT(7))));
 185         }
 186
 187         usb_ep_packet_size_hi(3, FS_C1_I0_A0_EP3_DIRECTION, (FS_C1_I0_A0_EP3_MAX_PACKET & 0x7ff));
 188         usb_ep_packet_size_lo(3, FS_C1_I0_A0_EP3_DIRECTION, (FS_C1_I0_A0_EP3_MAX_PACKET & 0x7ff));
 189         usb_ep_in_highbandset(3, FS_C1_I0_A0_EP3_DIRECTION, FS_C1_I0_A0_EP3_MAX_PACKET);
 190
 191         /* EP 4 */
 192         usb_ep_map(4, FS_C1_I0_A0_EP4_MAP);
 193         usb_fifo_map(FS_C1_I0_A0_EP4_FIFO_START, FS_C1_I0_A0_EP4_FIFO_MAP);
 194         usb_fifo_config(FS_C1_I0_A0_EP4_FIFO_START, FS_C1_I0_A0_EP4_FIFO_CONFIG);
 195
 196         for (i = FS_C1_I0_A0_EP4_FIFO_START + 1;
 197              i < FS_C1_I0_A0_EP4_FIFO_START + FS_C1_I0_A0_EP4_FIFO_NO; i++) {
 198                 usb_fifo_config(i, (FS_C1_I0_A0_EP4_FIFO_CONFIG & (~BIT(7))));
 199         }
 200
 201         usb_ep_packet_size_hi(4, FS_C1_I0_A0_EP4_DIRECTION, (FS_C1_I0_A0_EP4_MAX_PACKET & 0x7ff));
 202         usb_ep_packet_size_lo(4, FS_C1_I0_A0_EP4_DIRECTION, (FS_C1_I0_A0_EP4_MAX_PACKET & 0x7ff));
 203         usb_ep_in_highbandset(4, FS_C1_I0_A0_EP4_DIRECTION, FS_C1_I0_A0_EP4_MAX_PACKET);
 204 }
 205 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */