drivers/net/wireless/ath/ath10k/hif.h

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2015,2017 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #ifndef _HIF_H_
  19 #define _HIF_H_
  20
  21 #include <linux/kernel.h>
  22 #include "core.h"
  23 #include "bmi.h"
  24 #include "debug.h"
  25
  26 struct ath10k_hif_sg_item {
  27         u16 transfer_id;
  28         void *transfer_context; /* NULL = tx completion callback not called */
  29         void *vaddr; /* for debugging mostly */
  30         dma_addr_t paddr;
  31         u16 len;
  32 };
  33
  34 struct ath10k_hif_ops {
  35         /* send a scatter-gather list to the target */
  36         int (*tx_sg)(struct ath10k *ar, u8 pipe_id,
  37                      struct ath10k_hif_sg_item *items, int n_items);
  38
  39         /* read firmware memory through the diagnose interface */
  40         int (*diag_read)(struct ath10k *ar, u32 address, void *buf,
  41                          size_t buf_len);
  42
  43         int (*diag_write)(struct ath10k *ar, u32 address, const void *data,
  44                           int nbytes);
  45         /*
  46          * API to handle HIF-specific BMI message exchanges, this API is
  47          * synchronous and only allowed to be called from a context that
  48          * can block (sleep)
  49          */
  50         int (*exchange_bmi_msg)(struct ath10k *ar,
  51                                 void *request, u32 request_len,
  52                                 void *response, u32 *response_len);
  53
  54         /* Post BMI phase, after FW is loaded. Starts regular operation */
  55         int (*start)(struct ath10k *ar);
  56
  57         /* Clean up what start() did. This does not revert to BMI phase. If
  58          * desired so, call power_down() and power_up()
  59          */
  60         void (*stop)(struct ath10k *ar);
  61
  62         int (*swap_mailbox)(struct ath10k *ar);
  63
  64         int (*map_service_to_pipe)(struct ath10k *ar, u16 service_id,
  65                                    u8 *ul_pipe, u8 *dl_pipe);
  66
  67         void (*get_default_pipe)(struct ath10k *ar, u8 *ul_pipe, u8 *dl_pipe);
  68
  69         /*
  70          * Check if prior sends have completed.
  71          *
  72          * Check whether the pipe in question has any completed
  73          * sends that have not yet been processed.
  74          * This function is only relevant for HIF pipes that are configured
  75          * to be polled rather than interrupt-driven.
  76          */
  77         void (*send_complete_check)(struct ath10k *ar, u8 pipe_id, int force);
  78
  79         u16 (*get_free_queue_number)(struct ath10k *ar, u8 pipe_id);
  80
  81         u32 (*read32)(struct ath10k *ar, u32 address);
  82
  83         void (*write32)(struct ath10k *ar, u32 address, u32 value);
  84
  85         /* Power up the device and enter BMI transfer mode for FW download */
  86         int (*power_up)(struct ath10k *ar, enum ath10k_firmware_mode fw_mode);
  87
  88         /* Power down the device and free up resources. stop() must be called
  89          * before this if start() was called earlier
  90          */
  91         void (*power_down)(struct ath10k *ar);
  92
  93         int (*suspend)(struct ath10k *ar);
  94         int (*resume)(struct ath10k *ar);
  95
  96         /* fetch calibration data from target eeprom */
  97         int (*fetch_cal_eeprom)(struct ath10k *ar, void **data,
  98                                 size_t *data_len);
  99
 100         int (*get_target_info)(struct ath10k *ar,
 101                                struct bmi_target_info *target_info);
 102 };
 103
 104 static inline int ath10k_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
 105                                    struct ath10k_hif_sg_item *items,
 106                                    int n_items)
 107 {
 108         return ar->hif.ops->tx_sg(ar, pipe_id, items, n_items);
 109 }
 110
 111 static inline int ath10k_hif_diag_read(struct ath10k *ar, u32 address, void *buf,
 112                                        size_t buf_len)
 113 {
 114         return ar->hif.ops->diag_read(ar, address, buf, buf_len);
 115 }
 116
 117 static inline int ath10k_hif_diag_write(struct ath10k *ar, u32 address,
 118                                         const void *data, int nbytes)
 119 {
 120         if (!ar->hif.ops->diag_write)
 121                 return -EOPNOTSUPP;
 122
 123         return ar->hif.ops->diag_write(ar, address, data, nbytes);
 124 }
 125
 126 static inline int ath10k_hif_exchange_bmi_msg(struct ath10k *ar,
 127                                               void *request, u32 request_len,
 128                                               void *response, u32 *response_len)
 129 {
 130         return ar->hif.ops->exchange_bmi_msg(ar, request, request_len,
 131                                              response, response_len);
 132 }
 133
 134 static inline int ath10k_hif_start(struct ath10k *ar)
 135 {
 136         return ar->hif.ops->start(ar);
 137 }
 138
 139 static inline void ath10k_hif_stop(struct ath10k *ar)
 140 {
 141         return ar->hif.ops->stop(ar);
 142 }
 143
 144 static inline int ath10k_hif_swap_mailbox(struct ath10k *ar)
 145 {
 146         if (ar->hif.ops->swap_mailbox)
 147                 return ar->hif.ops->swap_mailbox(ar);
 148         return 0;
 149 }
 150
 151 static inline int ath10k_hif_map_service_to_pipe(struct ath10k *ar,
 152                                                  u16 service_id,
 153                                                  u8 *ul_pipe, u8 *dl_pipe)
 154 {
 155         return ar->hif.ops->map_service_to_pipe(ar, service_id,
 156                                                 ul_pipe, dl_pipe);
 157 }
 158
 159 static inline void ath10k_hif_get_default_pipe(struct ath10k *ar,
 160                                                u8 *ul_pipe, u8 *dl_pipe)
 161 {
 162         ar->hif.ops->get_default_pipe(ar, ul_pipe, dl_pipe);
 163 }
 164
 165 static inline void ath10k_hif_send_complete_check(struct ath10k *ar,
 166                                                   u8 pipe_id, int force)
 167 {
 168         ar->hif.ops->send_complete_check(ar, pipe_id, force);
 169 }
 170
 171 static inline u16 ath10k_hif_get_free_queue_number(struct ath10k *ar,
 172                                                    u8 pipe_id)
 173 {
 174         return ar->hif.ops->get_free_queue_number(ar, pipe_id);
 175 }
 176
 177 static inline int ath10k_hif_power_up(struct ath10k *ar,
 178                                       enum ath10k_firmware_mode fw_mode)
 179 {
 180         return ar->hif.ops->power_up(ar, fw_mode);
 181 }
 182
 183 static inline void ath10k_hif_power_down(struct ath10k *ar)
 184 {
 185         ar->hif.ops->power_down(ar);
 186 }
 187
 188 static inline int ath10k_hif_suspend(struct ath10k *ar)
 189 {
 190         if (!ar->hif.ops->suspend)
 191                 return -EOPNOTSUPP;
 192
 193         return ar->hif.ops->suspend(ar);
 194 }
 195
 196 static inline int ath10k_hif_resume(struct ath10k *ar)
 197 {
 198         if (!ar->hif.ops->resume)
 199                 return -EOPNOTSUPP;
 200
 201         return ar->hif.ops->resume(ar);
 202 }
 203
 204 static inline u32 ath10k_hif_read32(struct ath10k *ar, u32 address)
 205 {
 206         if (!ar->hif.ops->read32) {
 207                 ath10k_warn(ar, "hif read32 not supported\n");
 208                 return 0xdeaddead;
 209         }
 210
 211         return ar->hif.ops->read32(ar, address);
 212 }
 213
 214 static inline void ath10k_hif_write32(struct ath10k *ar,
 215                                       u32 address, u32 data)
 216 {
 217         if (!ar->hif.ops->write32) {
 218                 ath10k_warn(ar, "hif write32 not supported\n");
 219                 return;
 220         }
 221
 222         ar->hif.ops->write32(ar, address, data);
 223 }
 224
 225 static inline int ath10k_hif_fetch_cal_eeprom(struct ath10k *ar,
 226                                               void **data,
 227                                               size_t *data_len)
 228 {
 229         if (!ar->hif.ops->fetch_cal_eeprom)
 230                 return -EOPNOTSUPP;
 231
 232         return ar->hif.ops->fetch_cal_eeprom(ar, data, data_len);
 233 }
 234
 235 static inline int ath10k_hif_get_target_info(struct ath10k *ar,
 236                                              struct bmi_target_info *tgt_info)
 237 {
 238         if (!ar->hif.ops->get_target_info)
 239                 return -EOPNOTSUPP;
 240
 241         return ar->hif.ops->get_target_info(ar, tgt_info);
 242 }
 243
 244 #endif /* _HIF_H_ */