drivers/staging/rtlwifi/halmac/halmac_88xx/halmac_api_88xx_sdio.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2016  Realtek Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * The full GNU General Public License is included in this distribution in the
  15  * file called LICENSE.
  16  *
  17  * Contact Information:
  18  * wlanfae <wlanfae@realtek.com>
  19  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  20  * Hsinchu 300, Taiwan.
  21  *
  22  * Larry Finger <Larry.Finger@lwfinger.net>
  23  *
  24  *****************************************************************************/
  25 #include "halmac_88xx_cfg.h"
  26
  27 /**
  28  * halmac_init_sdio_cfg_88xx() - init SDIO
  29  * @halmac_adapter : the adapter of halmac
  30  * Author : KaiYuan Chang/Ivan Lin
  31  * Return : enum halmac_ret_status
  32  * More details of status code can be found in prototype document
  33  */
  34 enum halmac_ret_status
  35 halmac_init_sdio_cfg_88xx(struct halmac_adapter *halmac_adapter)
  36 {
  37         void *driver_adapter = NULL;
  38         struct halmac_api *halmac_api;
  39
  40         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  41                 return HALMAC_RET_ADAPTER_INVALID;
  42
  43         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  44                 return HALMAC_RET_API_INVALID;
  45
  46         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_INIT_SDIO_CFG);
  47
  48         driver_adapter = halmac_adapter->driver_adapter;
  49         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
  50
  51         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  52                         "%s ==========>\n", __func__);
  53
  54         HALMAC_REG_READ_32(halmac_adapter, REG_SDIO_FREE_TXPG);
  55         HALMAC_REG_WRITE_32(halmac_adapter, REG_SDIO_TX_CTRL, 0x00000000);
  56
  57         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  58                         "%s <==========\n", __func__);
  59
  60         return HALMAC_RET_SUCCESS;
  61 }
  62
  63 /**
  64  * halmac_deinit_sdio_cfg_88xx() - deinit SDIO
  65  * @halmac_adapter : the adapter of halmac
  66  * Author : KaiYuan Chang/Ivan Lin
  67  * Return : enum halmac_ret_status
  68  * More details of status code can be found in prototype document
  69  */
  70 enum halmac_ret_status
  71 halmac_deinit_sdio_cfg_88xx(struct halmac_adapter *halmac_adapter)
  72 {
  73         void *driver_adapter = NULL;
  74
  75         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  76                 return HALMAC_RET_ADAPTER_INVALID;
  77
  78         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  79                 return HALMAC_RET_API_INVALID;
  80
  81         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_DEINIT_SDIO_CFG);
  82
  83         driver_adapter = halmac_adapter->driver_adapter;
  84
  85         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  86                         "%s ==========>\n", __func__);
  87
  88         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  89                         "%s <==========\n", __func__);
  90
  91         return HALMAC_RET_SUCCESS;
  92 }
  93
  94 /**
  95  * halmac_cfg_rx_aggregation_88xx_sdio() - config rx aggregation
  96  * @halmac_adapter : the adapter of halmac
  97  * @halmac_rx_agg_mode
  98  * Author : KaiYuan Chang/Ivan Lin
  99  * Return : enum halmac_ret_status
 100  * More details of status code can be found in prototype document
 101  */
 102 enum halmac_ret_status
 103 halmac_cfg_rx_aggregation_88xx_sdio(struct halmac_adapter *halmac_adapter,
 104                                     struct halmac_rxagg_cfg *phalmac_rxagg_cfg)
 105 {
 106         u8 value8;
 107         u8 size = 0, timeout = 0, agg_enable = 0;
 108         void *driver_adapter = NULL;
 109         struct halmac_api *halmac_api;
 110
 111         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 112                 return HALMAC_RET_ADAPTER_INVALID;
 113
 114         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 115                 return HALMAC_RET_API_INVALID;
 116
 117         halmac_api_record_id_88xx(halmac_adapter,
 118                                   HALMAC_API_CFG_RX_AGGREGATION);
 119
 120         driver_adapter = halmac_adapter->driver_adapter;
 121         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 122
 123         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 124                         "%s ==========>\n", __func__);
 125
 126         agg_enable = HALMAC_REG_READ_8(halmac_adapter, REG_TXDMA_PQ_MAP);
 127
 128         switch (phalmac_rxagg_cfg->mode) {
 129         case HALMAC_RX_AGG_MODE_NONE:
 130                 agg_enable &= ~(BIT_RXDMA_AGG_EN);
 131                 break;
 132         case HALMAC_RX_AGG_MODE_DMA:
 133         case HALMAC_RX_AGG_MODE_USB:
 134                 agg_enable |= BIT_RXDMA_AGG_EN;
 135                 break;
 136         default:
 137                 pr_err("halmac_cfg_rx_aggregation_88xx_usb switch case not support\n");
 138                 agg_enable &= ~BIT_RXDMA_AGG_EN;
 139                 break;
 140         }
 141
 142         if (!phalmac_rxagg_cfg->threshold.drv_define) {
 143                 size = 0xFF;
 144                 timeout = 0x01;
 145         } else {
 146                 size = phalmac_rxagg_cfg->threshold.size;
 147                 timeout = phalmac_rxagg_cfg->threshold.timeout;
 148         }
 149
 150         HALMAC_REG_WRITE_8(halmac_adapter, REG_TXDMA_PQ_MAP, agg_enable);
 151         HALMAC_REG_WRITE_16(halmac_adapter, REG_RXDMA_AGG_PG_TH,
 152                             (u16)(size | (timeout << BIT_SHIFT_DMA_AGG_TO)));
 153
 154         value8 = HALMAC_REG_READ_8(halmac_adapter, REG_RXDMA_MODE);
 155         if ((agg_enable & BIT_RXDMA_AGG_EN) != 0)
 156                 HALMAC_REG_WRITE_8(halmac_adapter, REG_RXDMA_MODE,
 157                                    value8 | BIT_DMA_MODE);
 158         else
 159                 HALMAC_REG_WRITE_8(halmac_adapter, REG_RXDMA_MODE,
 160                                    value8 & ~(BIT_DMA_MODE));
 161
 162         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 163                         "%s <==========\n", __func__);
 164
 165         return HALMAC_RET_SUCCESS;
 166 }
 167
 168 /**
 169  * halmac_reg_read_8_sdio_88xx() - read 1byte register
 170  * @halmac_adapter : the adapter of halmac
 171  * @halmac_offset : register offset
 172  * Author : KaiYuan Chang/Ivan Lin
 173  * Return : enum halmac_ret_status
 174  * More details of status code can be found in prototype document
 175  */
 176 u8 halmac_reg_read_8_sdio_88xx(struct halmac_adapter *halmac_adapter,
 177                                u32 halmac_offset)
 178 {
 179         u8 value8;
 180         void *driver_adapter = NULL;
 181         struct halmac_api *halmac_api;
 182         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 183
 184         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 185                 return HALMAC_RET_ADAPTER_INVALID;
 186
 187         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 188                 return HALMAC_RET_API_INVALID;
 189
 190         driver_adapter = halmac_adapter->driver_adapter;
 191         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 192
 193         if ((halmac_offset & 0xFFFF0000) == 0)
 194                 halmac_offset |= WLAN_IOREG_OFFSET;
 195
 196         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 197                                                         &halmac_offset);
 198
 199         if (status != HALMAC_RET_SUCCESS) {
 200                 pr_err("%s error = %x\n", __func__, status);
 201                 return status;
 202         }
 203
 204         value8 = PLATFORM_SDIO_CMD52_READ(driver_adapter, halmac_offset);
 205
 206         return value8;
 207 }
 208
 209 /**
 210  * halmac_reg_write_8_sdio_88xx() - write 1byte register
 211  * @halmac_adapter : the adapter of halmac
 212  * @halmac_offset : register offset
 213  * @halmac_data : register value
 214  * Author : KaiYuan Chang/Ivan Lin
 215  * Return : enum halmac_ret_status
 216  * More details of status code can be found in prototype document
 217  */
 218 enum halmac_ret_status
 219 halmac_reg_write_8_sdio_88xx(struct halmac_adapter *halmac_adapter,
 220                              u32 halmac_offset, u8 halmac_data)
 221 {
 222         void *driver_adapter = NULL;
 223         struct halmac_api *halmac_api;
 224         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 225
 226         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 227                 return HALMAC_RET_ADAPTER_INVALID;
 228
 229         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 230                 return HALMAC_RET_API_INVALID;
 231
 232         driver_adapter = halmac_adapter->driver_adapter;
 233         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 234
 235         if ((halmac_offset & 0xFFFF0000) == 0)
 236                 halmac_offset |= WLAN_IOREG_OFFSET;
 237
 238         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 239                                                         &halmac_offset);
 240
 241         if (status != HALMAC_RET_SUCCESS) {
 242                 pr_err("%s error = %x\n", __func__, status);
 243                 return status;
 244         }
 245
 246         PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset, halmac_data);
 247
 248         return HALMAC_RET_SUCCESS;
 249 }
 250
 251 /**
 252  * halmac_reg_read_16_sdio_88xx() - read 2byte register
 253  * @halmac_adapter : the adapter of halmac
 254  * @halmac_offset : register offset
 255  * Author : KaiYuan Chang/Ivan Lin
 256  * Return : enum halmac_ret_status
 257  * More details of status code can be found in prototype document
 258  */
 259 u16 halmac_reg_read_16_sdio_88xx(struct halmac_adapter *halmac_adapter,
 260                                  u32 halmac_offset)
 261 {
 262         void *driver_adapter = NULL;
 263         struct halmac_api *halmac_api;
 264         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 265
 266         union {
 267                 u16 word;
 268                 u8 byte[2];
 269                 __le16 le_word;
 270         } value16 = {0x0000};
 271
 272         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 273                 return HALMAC_RET_ADAPTER_INVALID;
 274
 275         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 276                 return HALMAC_RET_API_INVALID;
 277
 278         driver_adapter = halmac_adapter->driver_adapter;
 279         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 280
 281         if ((halmac_offset & 0xFFFF0000) == 0)
 282                 halmac_offset |= WLAN_IOREG_OFFSET;
 283
 284         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 285                                                         &halmac_offset);
 286
 287         if (status != HALMAC_RET_SUCCESS) {
 288                 pr_err("%s error = %x\n", __func__, status);
 289                 return status;
 290         }
 291
 292         if (halmac_adapter->halmac_state.mac_power == HALMAC_MAC_POWER_OFF ||
 293             (halmac_offset & (2 - 1)) != 0 ||
 294             halmac_adapter->sdio_cmd53_4byte ==
 295                     HALMAC_SDIO_CMD53_4BYTE_MODE_RW ||
 296             halmac_adapter->sdio_cmd53_4byte ==
 297                     HALMAC_SDIO_CMD53_4BYTE_MODE_R) {
 298                 value16.byte[0] =
 299                         PLATFORM_SDIO_CMD52_READ(driver_adapter, halmac_offset);
 300                 value16.byte[1] = PLATFORM_SDIO_CMD52_READ(driver_adapter,
 301                                                            halmac_offset + 1);
 302                 value16.word = le16_to_cpu(value16.le_word);
 303         } else {
 304 #if (PLATFORM_SD_CLK > HALMAC_SD_CLK_THRESHOLD_88XX)
 305                 if ((halmac_offset & 0xffffef00) == 0x00000000) {
 306                         value16.byte[0] = PLATFORM_SDIO_CMD52_READ(
 307                                 driver_adapter, halmac_offset);
 308                         value16.byte[1] = PLATFORM_SDIO_CMD52_READ(
 309                                 driver_adapter, halmac_offset + 1);
 310                         value16.word = le16_to_cpu(value16.word);
 311                 } else {
 312                         value16.word = PLATFORM_SDIO_CMD53_READ_16(
 313                                 driver_adapter, halmac_offset);
 314                 }
 315 #else
 316                 value16.word = PLATFORM_SDIO_CMD53_READ_16(driver_adapter,
 317                                                            halmac_offset);
 318 #endif
 319         }
 320
 321         return value16.word;
 322 }
 323
 324 /**
 325  * halmac_reg_write_16_sdio_88xx() - write 2byte register
 326  * @halmac_adapter : the adapter of halmac
 327  * @halmac_offset : register offset
 328  * @halmac_data : register value
 329  * Author : KaiYuan Chang/Ivan Lin
 330  * Return : enum halmac_ret_status
 331  * More details of status code can be found in prototype document
 332  */
 333 enum halmac_ret_status
 334 halmac_reg_write_16_sdio_88xx(struct halmac_adapter *halmac_adapter,
 335                               u32 halmac_offset, u16 halmac_data)
 336 {
 337         void *driver_adapter = NULL;
 338         struct halmac_api *halmac_api;
 339         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 340
 341         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 342                 return HALMAC_RET_ADAPTER_INVALID;
 343
 344         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 345                 return HALMAC_RET_API_INVALID;
 346
 347         driver_adapter = halmac_adapter->driver_adapter;
 348         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 349
 350         if ((halmac_offset & 0xFFFF0000) == 0)
 351                 halmac_offset |= WLAN_IOREG_OFFSET;
 352
 353         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 354                                                         &halmac_offset);
 355
 356         if (status != HALMAC_RET_SUCCESS) {
 357                 pr_err("%s error = %x\n", __func__, status);
 358                 return status;
 359         }
 360
 361         if (halmac_adapter->halmac_state.mac_power == HALMAC_MAC_POWER_OFF ||
 362             (halmac_offset & (2 - 1)) != 0 ||
 363             halmac_adapter->sdio_cmd53_4byte ==
 364                     HALMAC_SDIO_CMD53_4BYTE_MODE_RW ||
 365             halmac_adapter->sdio_cmd53_4byte ==
 366                     HALMAC_SDIO_CMD53_4BYTE_MODE_W) {
 367                 PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset,
 368                                           (u8)(halmac_data & 0xFF));
 369                 PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset + 1,
 370                                           (u8)((halmac_data & 0xFF00) >> 8));
 371         } else {
 372                 PLATFORM_SDIO_CMD53_WRITE_16(driver_adapter, halmac_offset,
 373                                              halmac_data);
 374         }
 375
 376         return HALMAC_RET_SUCCESS;
 377 }
 378
 379 /**
 380  * halmac_reg_read_32_sdio_88xx() - read 4byte register
 381  * @halmac_adapter : the adapter of halmac
 382  * @halmac_offset : register offset
 383  * Author : KaiYuan Chang/Ivan Lin
 384  * Return : enum halmac_ret_status
 385  * More details of status code can be found in prototype document
 386  */
 387 u32 halmac_reg_read_32_sdio_88xx(struct halmac_adapter *halmac_adapter,
 388                                  u32 halmac_offset)
 389 {
 390         void *driver_adapter = NULL;
 391         struct halmac_api *halmac_api;
 392         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 393         u32 halmac_offset_old = 0;
 394
 395         union {
 396                 u32 dword;
 397                 u8 byte[4];
 398                 __le32 le_dword;
 399         } value32 = {0x00000000};
 400
 401         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 402                 return HALMAC_RET_ADAPTER_INVALID;
 403
 404         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 405                 return HALMAC_RET_API_INVALID;
 406
 407         driver_adapter = halmac_adapter->driver_adapter;
 408         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 409
 410         halmac_offset_old = halmac_offset;
 411
 412         if ((halmac_offset & 0xFFFF0000) == 0)
 413                 halmac_offset |= WLAN_IOREG_OFFSET;
 414
 415         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 416                                                         &halmac_offset);
 417         if (status != HALMAC_RET_SUCCESS) {
 418                 pr_err("%s error = %x\n", __func__, status);
 419                 return status;
 420         }
 421
 422         if (halmac_adapter->halmac_state.mac_power == HALMAC_MAC_POWER_OFF ||
 423             (halmac_offset & (4 - 1)) != 0) {
 424                 value32.byte[0] =
 425                         PLATFORM_SDIO_CMD52_READ(driver_adapter, halmac_offset);
 426                 value32.byte[1] = PLATFORM_SDIO_CMD52_READ(driver_adapter,
 427                                                            halmac_offset + 1);
 428                 value32.byte[2] = PLATFORM_SDIO_CMD52_READ(driver_adapter,
 429                                                            halmac_offset + 2);
 430                 value32.byte[3] = PLATFORM_SDIO_CMD52_READ(driver_adapter,
 431                                                            halmac_offset + 3);
 432                 value32.dword = le32_to_cpu(value32.le_dword);
 433         } else {
 434 #if (PLATFORM_SD_CLK > HALMAC_SD_CLK_THRESHOLD_88XX)
 435                 if ((halmac_offset_old & 0xffffef00) == 0x00000000) {
 436                         value32.byte[0] = PLATFORM_SDIO_CMD52_READ(
 437                                 driver_adapter, halmac_offset);
 438                         value32.byte[1] = PLATFORM_SDIO_CMD52_READ(
 439                                 driver_adapter, halmac_offset + 1);
 440                         value32.byte[2] = PLATFORM_SDIO_CMD52_READ(
 441                                 driver_adapter, halmac_offset + 2);
 442                         value32.byte[3] = PLATFORM_SDIO_CMD52_READ(
 443                                 driver_adapter, halmac_offset + 3);
 444                         value32.dword = le32_to_cpu(value32.dword);
 445                 } else {
 446                         value32.dword = PLATFORM_SDIO_CMD53_READ_32(
 447                                 driver_adapter, halmac_offset);
 448                 }
 449 #else
 450                 value32.dword = PLATFORM_SDIO_CMD53_READ_32(driver_adapter,
 451                                                             halmac_offset);
 452 #endif
 453         }
 454
 455         return value32.dword;
 456 }
 457
 458 /**
 459  * halmac_reg_write_32_sdio_88xx() - write 4byte register
 460  * @halmac_adapter : the adapter of halmac
 461  * @halmac_offset : register offset
 462  * @halmac_data : register value
 463  * Author : KaiYuan Chang/Ivan Lin
 464  * Return : enum halmac_ret_status
 465  * More details of status code can be found in prototype document
 466  */
 467 enum halmac_ret_status
 468 halmac_reg_write_32_sdio_88xx(struct halmac_adapter *halmac_adapter,
 469                               u32 halmac_offset, u32 halmac_data)
 470 {
 471         void *driver_adapter = NULL;
 472         struct halmac_api *halmac_api;
 473         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 474
 475         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 476                 return HALMAC_RET_ADAPTER_INVALID;
 477
 478         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 479                 return HALMAC_RET_API_INVALID;
 480
 481         driver_adapter = halmac_adapter->driver_adapter;
 482         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 483
 484         if ((halmac_offset & 0xFFFF0000) == 0)
 485                 halmac_offset |= WLAN_IOREG_OFFSET;
 486
 487         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 488                                                         &halmac_offset);
 489
 490         if (status != HALMAC_RET_SUCCESS) {
 491                 pr_err("%s error = %x\n", __func__, status);
 492                 return status;
 493         }
 494
 495         if (halmac_adapter->halmac_state.mac_power == HALMAC_MAC_POWER_OFF ||
 496             (halmac_offset & (4 - 1)) != 0) {
 497                 PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset,
 498                                           (u8)(halmac_data & 0xFF));
 499                 PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset + 1,
 500                                           (u8)((halmac_data & 0xFF00) >> 8));
 501                 PLATFORM_SDIO_CMD52_WRITE(driver_adapter, halmac_offset + 2,
 502                                           (u8)((halmac_data & 0xFF0000) >> 16));
 503                 PLATFORM_SDIO_CMD52_WRITE(
 504                         driver_adapter, halmac_offset + 3,
 505                         (u8)((halmac_data & 0xFF000000) >> 24));
 506         } else {
 507                 PLATFORM_SDIO_CMD53_WRITE_32(driver_adapter, halmac_offset,
 508                                              halmac_data);
 509         }
 510
 511         return HALMAC_RET_SUCCESS;
 512 }
 513
 514 /**
 515  * halmac_reg_read_nbyte_sdio_88xx() - read n byte register
 516  * @halmac_adapter : the adapter of halmac
 517  * @halmac_offset : register offset
 518  * @halmac_size : register value size
 519  * @halmac_data : register value
 520  * Author : Soar
 521  * Return : enum halmac_ret_status
 522  * More details of status code can be found in prototype document
 523  */
 524 u8 halmac_reg_read_nbyte_sdio_88xx(struct halmac_adapter *halmac_adapter,
 525                                    u32 halmac_offset, u32 halmac_size,
 526                                    u8 *halmac_data)
 527 {
 528         void *driver_adapter = NULL;
 529         struct halmac_api *halmac_api;
 530         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 531
 532         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 533                 return HALMAC_RET_ADAPTER_INVALID;
 534
 535         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 536                 return HALMAC_RET_API_INVALID;
 537
 538         driver_adapter = halmac_adapter->driver_adapter;
 539         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 540
 541         if ((halmac_offset & 0xFFFF0000) == 0) {
 542                 pr_err("halmac_offset error = 0x%x\n", halmac_offset);
 543                 return HALMAC_RET_FAIL;
 544         }
 545
 546         status = halmac_convert_to_sdio_bus_offset_88xx(halmac_adapter,
 547                                                         &halmac_offset);
 548         if (status != HALMAC_RET_SUCCESS) {
 549                 pr_err("%s error = %x\n", __func__, status);
 550                 return status;
 551         }
 552
 553         if (halmac_adapter->halmac_state.mac_power == HALMAC_MAC_POWER_OFF) {
 554                 pr_err("halmac_state error = 0x%x\n",
 555                        halmac_adapter->halmac_state.mac_power);
 556                 return HALMAC_RET_FAIL;
 557         }
 558
 559         PLATFORM_SDIO_CMD53_READ_N(driver_adapter, halmac_offset, halmac_size,
 560                                    halmac_data);
 561
 562         return HALMAC_RET_SUCCESS;
 563 }
 564
 565 /**
 566  * halmac_get_sdio_tx_addr_sdio_88xx() - get CMD53 addr for the TX packet
 567  * @halmac_adapter : the adapter of halmac
 568  * @halmac_buf : tx packet, include txdesc
 569  * @halmac_size : tx packet size
 570  * @pcmd53_addr : cmd53 addr value
 571  * Author : KaiYuan Chang/Ivan Lin
 572  * Return : enum halmac_ret_status
 573  * More details of status code can be found in prototype document
 574  */
 575 enum halmac_ret_status
 576 halmac_get_sdio_tx_addr_88xx(struct halmac_adapter *halmac_adapter,
 577                              u8 *halmac_buf, u32 halmac_size, u32 *pcmd53_addr)
 578 {
 579         u32 four_byte_len;
 580         void *driver_adapter = NULL;
 581         struct halmac_api *halmac_api;
 582         enum halmac_queue_select queue_sel;
 583         enum halmac_dma_mapping dma_mapping;
 584
 585         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 586                 return HALMAC_RET_ADAPTER_INVALID;
 587
 588         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 589                 return HALMAC_RET_API_INVALID;
 590
 591         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_GET_SDIO_TX_ADDR);
 592
 593         driver_adapter = halmac_adapter->driver_adapter;
 594         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 595
 596         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 597                         "%s ==========>\n", __func__);
 598
 599         if (!halmac_buf) {
 600                 pr_err("halmac_buf is NULL!!\n");
 601                 return HALMAC_RET_DATA_BUF_NULL;
 602         }
 603
 604         if (halmac_size == 0) {
 605                 pr_err("halmac_size is 0!!\n");
 606                 return HALMAC_RET_DATA_SIZE_INCORRECT;
 607         }
 608
 609         queue_sel = (enum halmac_queue_select)GET_TX_DESC_QSEL(halmac_buf);
 610
 611         switch (queue_sel) {
 612         case HALMAC_QUEUE_SELECT_VO:
 613         case HALMAC_QUEUE_SELECT_VO_V2:
 614                 dma_mapping =
 615                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VO];
 616                 break;
 617         case HALMAC_QUEUE_SELECT_VI:
 618         case HALMAC_QUEUE_SELECT_VI_V2:
 619                 dma_mapping =
 620                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VI];
 621                 break;
 622         case HALMAC_QUEUE_SELECT_BE:
 623         case HALMAC_QUEUE_SELECT_BE_V2:
 624                 dma_mapping =
 625                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BE];
 626                 break;
 627         case HALMAC_QUEUE_SELECT_BK:
 628         case HALMAC_QUEUE_SELECT_BK_V2:
 629                 dma_mapping =
 630                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BK];
 631                 break;
 632         case HALMAC_QUEUE_SELECT_MGNT:
 633                 dma_mapping =
 634                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_MG];
 635                 break;
 636         case HALMAC_QUEUE_SELECT_HIGH:
 637         case HALMAC_QUEUE_SELECT_BCN:
 638         case HALMAC_QUEUE_SELECT_CMD:
 639                 dma_mapping =
 640                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_HI];
 641                 break;
 642         default:
 643                 pr_err("Qsel is out of range\n");
 644                 return HALMAC_RET_QSEL_INCORRECT;
 645         }
 646
 647         four_byte_len = (halmac_size >> 2) + ((halmac_size & (4 - 1)) ? 1 : 0);
 648
 649         switch (dma_mapping) {
 650         case HALMAC_DMA_MAPPING_HIGH:
 651                 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_HIGH;
 652                 break;
 653         case HALMAC_DMA_MAPPING_NORMAL:
 654                 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_NORMAL;
 655                 break;
 656         case HALMAC_DMA_MAPPING_LOW:
 657                 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_LOW;
 658                 break;
 659         case HALMAC_DMA_MAPPING_EXTRA:
 660                 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_EXTRA;
 661                 break;
 662         default:
 663                 pr_err("DmaMapping is out of range\n");
 664                 return HALMAC_RET_DMA_MAP_INCORRECT;
 665         }
 666
 667         *pcmd53_addr = (*pcmd53_addr << 13) |
 668                        (four_byte_len & HALMAC_SDIO_4BYTE_LEN_MASK);
 669
 670         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 671                         "%s <==========\n", __func__);
 672
 673         return HALMAC_RET_SUCCESS;
 674 }
 675
 676 /**
 677  * halmac_cfg_tx_agg_align_sdio_88xx() -config sdio bus tx agg alignment
 678  * @halmac_adapter : the adapter of halmac
 679  * @enable : function enable(1)/disable(0)
 680  * @align_size : sdio bus tx agg alignment size (2^n, n = 3~11)
 681  * Author : Soar Tu
 682  * Return : enum halmac_ret_status
 683  * More details of status code can be found in prototype document
 684  */
 685 enum halmac_ret_status
 686 halmac_cfg_tx_agg_align_sdio_88xx(struct halmac_adapter *halmac_adapter,
 687                                   u8 enable, u16 align_size)
 688 {
 689         struct halmac_api *halmac_api;
 690         void *driver_adapter = NULL;
 691         u8 i, align_size_ok = 0;
 692
 693         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 694                 return HALMAC_RET_ADAPTER_INVALID;
 695
 696         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 697                 return HALMAC_RET_API_INVALID;
 698
 699         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_CFG_TX_AGG_ALIGN);
 700
 701         driver_adapter = halmac_adapter->driver_adapter;
 702         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 703
 704         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 705                         "%s ==========>\n", __func__);
 706
 707         if ((align_size & 0xF000) != 0) {
 708                 pr_err("Align size is out of range\n");
 709                 return HALMAC_RET_FAIL;
 710         }
 711
 712         for (i = 3; i <= 11; i++) {
 713                 if (align_size == 1 << i) {
 714                         align_size_ok = 1;
 715                         break;
 716                 }
 717         }
 718         if (align_size_ok == 0) {
 719                 pr_err("Align size is not 2^3 ~ 2^11\n");
 720                 return HALMAC_RET_FAIL;
 721         }
 722
 723         /*Keep sdio tx agg alignment size for driver query*/
 724         halmac_adapter->hw_config_info.tx_align_size = align_size;
 725
 726         if (enable)
 727                 HALMAC_REG_WRITE_16(halmac_adapter, REG_RQPN_CTRL_2,
 728                                     0x8000 | align_size);
 729         else
 730                 HALMAC_REG_WRITE_16(halmac_adapter, REG_RQPN_CTRL_2,
 731                                     align_size);
 732
 733         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 734                         "%s <==========\n", __func__);
 735
 736         return HALMAC_RET_SUCCESS;
 737 }
 738
 739 enum halmac_ret_status halmac_cfg_tx_agg_align_sdio_not_support_88xx(
 740         struct halmac_adapter *halmac_adapter, u8 enable, u16 align_size)
 741 {
 742         struct halmac_api *halmac_api;
 743         void *driver_adapter = NULL;
 744
 745         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 746                 return HALMAC_RET_ADAPTER_INVALID;
 747
 748         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 749                 return HALMAC_RET_API_INVALID;
 750
 751         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_CFG_TX_AGG_ALIGN);
 752
 753         driver_adapter = halmac_adapter->driver_adapter;
 754         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 755
 756         HALMAC_RT_TRACE(
 757                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 758                 "%s ==========>\n", __func__);
 759
 760         HALMAC_RT_TRACE(
 761                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 762                 "%s not support\n", __func__);
 763         HALMAC_RT_TRACE(
 764                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 765                 "%s <==========\n", __func__);
 766
 767         return HALMAC_RET_SUCCESS;
 768 }
 769
 770 /**
 771  * halmac_tx_allowed_sdio_88xx() - check tx status
 772  * @halmac_adapter : the adapter of halmac
 773  * @halmac_buf : tx packet, include txdesc
 774  * @halmac_size : tx packet size, include txdesc
 775  * Author : Ivan Lin
 776  * Return : enum halmac_ret_status
 777  * More details of status code can be found in prototype document
 778  */
 779 enum halmac_ret_status
 780 halmac_tx_allowed_sdio_88xx(struct halmac_adapter *halmac_adapter,
 781                             u8 *halmac_buf, u32 halmac_size)
 782 {
 783         u8 *curr_packet;
 784         u16 *curr_free_space;
 785         u32 i, counter;
 786         u32 tx_agg_num, packet_size = 0;
 787         u32 tx_required_page_num, total_required_page_num = 0;
 788         enum halmac_ret_status status = HALMAC_RET_SUCCESS;
 789         void *driver_adapter = NULL;
 790         enum halmac_dma_mapping dma_mapping;
 791
 792         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 793                 return HALMAC_RET_ADAPTER_INVALID;
 794
 795         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 796                 return HALMAC_RET_API_INVALID;
 797
 798         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_TX_ALLOWED_SDIO);
 799
 800         driver_adapter = halmac_adapter->driver_adapter;
 801
 802         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 803                         "%s ==========>\n", __func__);
 804
 805         tx_agg_num = GET_TX_DESC_DMA_TXAGG_NUM(halmac_buf);
 806         curr_packet = halmac_buf;
 807
 808         tx_agg_num = tx_agg_num == 0 ? 1 : tx_agg_num;
 809
 810         switch ((enum halmac_queue_select)GET_TX_DESC_QSEL(curr_packet)) {
 811         case HALMAC_QUEUE_SELECT_VO:
 812         case HALMAC_QUEUE_SELECT_VO_V2:
 813                 dma_mapping =
 814                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VO];
 815                 break;
 816         case HALMAC_QUEUE_SELECT_VI:
 817         case HALMAC_QUEUE_SELECT_VI_V2:
 818                 dma_mapping =
 819                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VI];
 820                 break;
 821         case HALMAC_QUEUE_SELECT_BE:
 822         case HALMAC_QUEUE_SELECT_BE_V2:
 823                 dma_mapping =
 824                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BE];
 825                 break;
 826         case HALMAC_QUEUE_SELECT_BK:
 827         case HALMAC_QUEUE_SELECT_BK_V2:
 828                 dma_mapping =
 829                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BK];
 830                 break;
 831         case HALMAC_QUEUE_SELECT_MGNT:
 832                 dma_mapping =
 833                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_MG];
 834                 break;
 835         case HALMAC_QUEUE_SELECT_HIGH:
 836                 dma_mapping =
 837                         halmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_HI];
 838                 break;
 839         case HALMAC_QUEUE_SELECT_BCN:
 840         case HALMAC_QUEUE_SELECT_CMD:
 841                 return HALMAC_RET_SUCCESS;
 842         default:
 843                 pr_err("Qsel is out of range\n");
 844                 return HALMAC_RET_QSEL_INCORRECT;
 845         }
 846
 847         switch (dma_mapping) {
 848         case HALMAC_DMA_MAPPING_HIGH:
 849                 curr_free_space =
 850                         &halmac_adapter->sdio_free_space.high_queue_number;
 851                 break;
 852         case HALMAC_DMA_MAPPING_NORMAL:
 853                 curr_free_space =
 854                         &halmac_adapter->sdio_free_space.normal_queue_number;
 855                 break;
 856         case HALMAC_DMA_MAPPING_LOW:
 857                 curr_free_space =
 858                         &halmac_adapter->sdio_free_space.low_queue_number;
 859                 break;
 860         case HALMAC_DMA_MAPPING_EXTRA:
 861                 curr_free_space =
 862                         &halmac_adapter->sdio_free_space.extra_queue_number;
 863                 break;
 864         default:
 865                 pr_err("DmaMapping is out of range\n");
 866                 return HALMAC_RET_DMA_MAP_INCORRECT;
 867         }
 868
 869         for (i = 0; i < tx_agg_num; i++) {
 870                 packet_size = GET_TX_DESC_TXPKTSIZE(curr_packet) +
 871                               GET_TX_DESC_OFFSET(curr_packet) +
 872                               (GET_TX_DESC_PKT_OFFSET(curr_packet) << 3);
 873                 tx_required_page_num =
 874                         (packet_size >>
 875                          halmac_adapter->hw_config_info.page_size_2_power) +
 876                         ((packet_size &
 877                           (halmac_adapter->hw_config_info.page_size - 1)) ?
 878                                  1 :
 879                                  0);
 880                 total_required_page_num += tx_required_page_num;
 881
 882                 packet_size = HALMAC_ALIGN(packet_size, 8);
 883
 884                 curr_packet += packet_size;
 885         }
 886
 887         counter = 10;
 888         do {
 889                 if ((u32)(*curr_free_space +
 890                           halmac_adapter->sdio_free_space.public_queue_number) >
 891                     total_required_page_num) {
 892                         if (*curr_free_space >= total_required_page_num) {
 893                                 *curr_free_space -=
 894                                         (u16)total_required_page_num;
 895                         } else {
 896                                 halmac_adapter->sdio_free_space
 897                                         .public_queue_number -=
 898                                         (u16)(total_required_page_num -
 899                                               *curr_free_space);
 900                                 *curr_free_space = 0;
 901                         }
 902
 903                         status = halmac_check_oqt_88xx(halmac_adapter,
 904                                                        tx_agg_num, halmac_buf);
 905
 906                         if (status != HALMAC_RET_SUCCESS)
 907                                 return status;
 908
 909                         break;
 910                 }
 911
 912                 halmac_update_sdio_free_page_88xx(halmac_adapter);
 913
 914                 counter--;
 915                 if (counter == 0)
 916                         return HALMAC_RET_FREE_SPACE_NOT_ENOUGH;
 917         } while (1);
 918
 919         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 920                         "%s <==========\n", __func__);
 921
 922         return HALMAC_RET_SUCCESS;
 923 }
 924
 925 /**
 926  * halmac_reg_read_indirect_32_sdio_88xx() - read MAC reg by SDIO reg
 927  * @halmac_adapter : the adapter of halmac
 928  * @halmac_offset : register offset
 929  * Author : Soar
 930  * Return : enum halmac_ret_status
 931  * More details of status code can be found in prototype document
 932  */
 933 u32 halmac_reg_read_indirect_32_sdio_88xx(struct halmac_adapter *halmac_adapter,
 934                                           u32 halmac_offset)
 935 {
 936         u8 rtemp;
 937         u32 counter = 1000;
 938         void *driver_adapter = NULL;
 939
 940         union {
 941                 u32 dword;
 942                 u8 byte[4];
 943         } value32 = {0x00000000};
 944
 945         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 946                 return HALMAC_RET_ADAPTER_INVALID;
 947
 948         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 949                 return HALMAC_RET_API_INVALID;
 950
 951         driver_adapter = halmac_adapter->driver_adapter;
 952
 953         PLATFORM_SDIO_CMD53_WRITE_32(
 954                 driver_adapter,
 955                 (HALMAC_SDIO_CMD_ADDR_SDIO_REG << 13) |
 956                         (REG_SDIO_INDIRECT_REG_CFG & HALMAC_SDIO_LOCAL_MSK),
 957                 halmac_offset | BIT(19) | BIT(17));
 958
 959         do {
 960                 rtemp = PLATFORM_SDIO_CMD52_READ(
 961                         driver_adapter,
 962                         (HALMAC_SDIO_CMD_ADDR_SDIO_REG << 13) |
 963                                 ((REG_SDIO_INDIRECT_REG_CFG + 2) &
 964                                  HALMAC_SDIO_LOCAL_MSK));
 965                 counter--;
 966         } while ((rtemp & BIT(4)) != 0 && counter > 0);
 967
 968         value32.dword = PLATFORM_SDIO_CMD53_READ_32(
 969                 driver_adapter,
 970                 (HALMAC_SDIO_CMD_ADDR_SDIO_REG << 13) |
 971                         (REG_SDIO_INDIRECT_REG_DATA & HALMAC_SDIO_LOCAL_MSK));
 972
 973         return value32.dword;
 974 }