drivers/staging/rtlwifi/halmac/halmac_88xx/halmac_api_88xx_pcie.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_pcie_cfg_88xx() -  init PCIe
  29  * @halmac_adapter : the adapter of halmac
  30  * Author : KaiYuan Chang
  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_pcie_cfg_88xx(struct halmac_adapter *halmac_adapter)
  36 {
  37         void *driver_adapter = NULL;
  38
  39         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  40                 return HALMAC_RET_ADAPTER_INVALID;
  41
  42         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  43                 return HALMAC_RET_API_INVALID;
  44
  45         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_INIT_PCIE_CFG);
  46
  47         driver_adapter = halmac_adapter->driver_adapter;
  48
  49         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  50                         "%s ==========>\n", __func__);
  51
  52         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  53                         "%s <==========\n", __func__);
  54
  55         return HALMAC_RET_SUCCESS;
  56 }
  57
  58 /**
  59  * halmac_deinit_pcie_cfg_88xx() - deinit PCIE
  60  * @halmac_adapter : the adapter of halmac
  61  * Author : KaiYuan Chang
  62  * Return : enum halmac_ret_status
  63  * More details of status code can be found in prototype document
  64  */
  65 enum halmac_ret_status
  66 halmac_deinit_pcie_cfg_88xx(struct halmac_adapter *halmac_adapter)
  67 {
  68         void *driver_adapter = NULL;
  69
  70         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  71                 return HALMAC_RET_ADAPTER_INVALID;
  72
  73         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
  74                 return HALMAC_RET_API_INVALID;
  75
  76         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_DEINIT_PCIE_CFG);
  77
  78         driver_adapter = halmac_adapter->driver_adapter;
  79
  80         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  81                         "%s ==========>\n", __func__);
  82
  83         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
  84                         "%s <==========\n", __func__);
  85
  86         return HALMAC_RET_SUCCESS;
  87 }
  88
  89 /**
  90  * halmac_cfg_rx_aggregation_88xx_pcie() - config rx aggregation
  91  * @halmac_adapter : the adapter of halmac
  92  * @halmac_rx_agg_mode
  93  * Author : KaiYuan Chang/Ivan Lin
  94  * Return : enum halmac_ret_status
  95  * More details of status code can be found in prototype document
  96  */
  97 enum halmac_ret_status
  98 halmac_cfg_rx_aggregation_88xx_pcie(struct halmac_adapter *halmac_adapter,
  99                                     struct halmac_rxagg_cfg *phalmac_rxagg_cfg)
 100 {
 101         void *driver_adapter = NULL;
 102
 103         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 104                 return HALMAC_RET_ADAPTER_INVALID;
 105
 106         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 107                 return HALMAC_RET_API_INVALID;
 108
 109         halmac_api_record_id_88xx(halmac_adapter,
 110                                   HALMAC_API_CFG_RX_AGGREGATION);
 111
 112         driver_adapter = halmac_adapter->driver_adapter;
 113
 114         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 115                         "%s ==========>\n", __func__);
 116
 117         HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 118                         "%s <==========\n", __func__);
 119
 120         return HALMAC_RET_SUCCESS;
 121 }
 122
 123 /**
 124  * halmac_reg_read_8_pcie_88xx() - read 1byte register
 125  * @halmac_adapter : the adapter of halmac
 126  * @halmac_offset : register offset
 127  * Author : KaiYuan Chang/Ivan Lin
 128  * Return : enum halmac_ret_status
 129  * More details of status code can be found in prototype document
 130  */
 131 u8 halmac_reg_read_8_pcie_88xx(struct halmac_adapter *halmac_adapter,
 132                                u32 halmac_offset)
 133 {
 134         void *driver_adapter = NULL;
 135         struct halmac_api *halmac_api;
 136
 137         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 138                 return HALMAC_RET_ADAPTER_INVALID;
 139
 140         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 141                 return HALMAC_RET_API_INVALID;
 142
 143         driver_adapter = halmac_adapter->driver_adapter;
 144         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 145
 146         return PLATFORM_REG_READ_8(driver_adapter, halmac_offset);
 147 }
 148
 149 /**
 150  * halmac_reg_write_8_pcie_88xx() - write 1byte register
 151  * @halmac_adapter : the adapter of halmac
 152  * @halmac_offset : register offset
 153  * @halmac_data : register value
 154  * Author : KaiYuan Chang/Ivan Lin
 155  * Return : enum halmac_ret_status
 156  * More details of status code can be found in prototype document
 157  */
 158 enum halmac_ret_status
 159 halmac_reg_write_8_pcie_88xx(struct halmac_adapter *halmac_adapter,
 160                              u32 halmac_offset, u8 halmac_data)
 161 {
 162         void *driver_adapter = NULL;
 163         struct halmac_api *halmac_api;
 164
 165         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 166                 return HALMAC_RET_ADAPTER_INVALID;
 167
 168         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 169                 return HALMAC_RET_API_INVALID;
 170
 171         driver_adapter = halmac_adapter->driver_adapter;
 172         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 173
 174         PLATFORM_REG_WRITE_8(driver_adapter, halmac_offset, halmac_data);
 175
 176         return HALMAC_RET_SUCCESS;
 177 }
 178
 179 /**
 180  * halmac_reg_read_16_pcie_88xx() - read 2byte register
 181  * @halmac_adapter : the adapter of halmac
 182  * @halmac_offset : register offset
 183  * Author : KaiYuan Chang/Ivan Lin
 184  * Return : enum halmac_ret_status
 185  * More details of status code can be found in prototype document
 186  */
 187 u16 halmac_reg_read_16_pcie_88xx(struct halmac_adapter *halmac_adapter,
 188                                  u32 halmac_offset)
 189 {
 190         void *driver_adapter = NULL;
 191         struct halmac_api *halmac_api;
 192
 193         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 194                 return HALMAC_RET_ADAPTER_INVALID;
 195
 196         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 197                 return HALMAC_RET_API_INVALID;
 198
 199         driver_adapter = halmac_adapter->driver_adapter;
 200         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 201
 202         return PLATFORM_REG_READ_16(driver_adapter, halmac_offset);
 203 }
 204
 205 /**
 206  * halmac_reg_write_16_pcie_88xx() - write 2byte register
 207  * @halmac_adapter : the adapter of halmac
 208  * @halmac_offset : register offset
 209  * @halmac_data : register value
 210  * Author : KaiYuan Chang/Ivan Lin
 211  * Return : enum halmac_ret_status
 212  * More details of status code can be found in prototype document
 213  */
 214 enum halmac_ret_status
 215 halmac_reg_write_16_pcie_88xx(struct halmac_adapter *halmac_adapter,
 216                               u32 halmac_offset, u16 halmac_data)
 217 {
 218         void *driver_adapter = NULL;
 219         struct halmac_api *halmac_api;
 220
 221         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 222                 return HALMAC_RET_ADAPTER_INVALID;
 223
 224         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 225                 return HALMAC_RET_API_INVALID;
 226
 227         driver_adapter = halmac_adapter->driver_adapter;
 228         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 229
 230         PLATFORM_REG_WRITE_16(driver_adapter, halmac_offset, halmac_data);
 231
 232         return HALMAC_RET_SUCCESS;
 233 }
 234
 235 /**
 236  * halmac_reg_read_32_pcie_88xx() - read 4byte register
 237  * @halmac_adapter : the adapter of halmac
 238  * @halmac_offset : register offset
 239  * Author : KaiYuan Chang/Ivan Lin
 240  * Return : enum halmac_ret_status
 241  * More details of status code can be found in prototype document
 242  */
 243 u32 halmac_reg_read_32_pcie_88xx(struct halmac_adapter *halmac_adapter,
 244                                  u32 halmac_offset)
 245 {
 246         void *driver_adapter = NULL;
 247         struct halmac_api *halmac_api;
 248
 249         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 250                 return HALMAC_RET_ADAPTER_INVALID;
 251
 252         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 253                 return HALMAC_RET_API_INVALID;
 254
 255         driver_adapter = halmac_adapter->driver_adapter;
 256         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 257
 258         return PLATFORM_REG_READ_32(driver_adapter, halmac_offset);
 259 }
 260
 261 /**
 262  * halmac_reg_write_32_pcie_88xx() - write 4byte register
 263  * @halmac_adapter : the adapter of halmac
 264  * @halmac_offset : register offset
 265  * @halmac_data : register value
 266  * Author : KaiYuan Chang/Ivan Lin
 267  * Return : enum halmac_ret_status
 268  * More details of status code can be found in prototype document
 269  */
 270 enum halmac_ret_status
 271 halmac_reg_write_32_pcie_88xx(struct halmac_adapter *halmac_adapter,
 272                               u32 halmac_offset, u32 halmac_data)
 273 {
 274         void *driver_adapter = NULL;
 275         struct halmac_api *halmac_api;
 276
 277         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 278                 return HALMAC_RET_ADAPTER_INVALID;
 279
 280         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 281                 return HALMAC_RET_API_INVALID;
 282
 283         driver_adapter = halmac_adapter->driver_adapter;
 284         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 285
 286         PLATFORM_REG_WRITE_32(driver_adapter, halmac_offset, halmac_data);
 287
 288         return HALMAC_RET_SUCCESS;
 289 }
 290
 291 /**
 292  * halmac_cfg_tx_agg_align_pcie_88xx() -config sdio bus tx agg alignment
 293  * @halmac_adapter : the adapter of halmac
 294  * @enable : function enable(1)/disable(0)
 295  * @align_size : sdio bus tx agg alignment size (2^n, n = 3~11)
 296  * Author : Soar Tu
 297  * Return : enum halmac_ret_status
 298  * More details of status code can be found in prototype document
 299  */
 300 enum halmac_ret_status halmac_cfg_tx_agg_align_pcie_not_support_88xx(
 301         struct halmac_adapter *halmac_adapter, u8 enable, u16 align_size)
 302 {
 303         struct halmac_api *halmac_api;
 304         void *driver_adapter = NULL;
 305
 306         if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 307                 return HALMAC_RET_ADAPTER_INVALID;
 308
 309         if (halmac_api_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
 310                 return HALMAC_RET_API_INVALID;
 311
 312         halmac_api_record_id_88xx(halmac_adapter, HALMAC_API_CFG_TX_AGG_ALIGN);
 313
 314         driver_adapter = halmac_adapter->driver_adapter;
 315         halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
 316
 317         HALMAC_RT_TRACE(
 318                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 319                 "%s ==========>\n", __func__);
 320
 321         HALMAC_RT_TRACE(
 322                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 323                 "%s not support\n", __func__);
 324         HALMAC_RT_TRACE(
 325                 driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
 326                 "%s <==========\n", __func__);
 327
 328         return HALMAC_RET_SUCCESS;
 329 }