acx_func.h

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
   3  * The ACX100 Open Source Project <acx100-devel@lists.sourceforge.net>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #ifndef _ACX_FUNC_H_
  19 #define _ACX_FUNC_H_
  20
  21 #include <linux/version.h>
  22 #include "acx_commands.h"
  23
  24 /***********************************************************************
  25 ** LOGGING
  26 **
  27 ** - Avoid SHOUTING needlessly. Avoid excessive verbosity.
  28 **   Gradually remove messages which are old debugging aids.
  29 **
  30 ** - Use printk() for messages which are to be always logged.
  31 **   Supply either 'acx:' or '<devname>:' prefix so that user
  32 **   can figure out who's speaking among other kernel chatter.
  33 **   acx: is for general issues (e.g. "acx: no firmware image!")
  34 **   while <devname>: is related to a particular device
  35 **   (think about multi-card setup). Double check that message
  36 **   is not confusing to the average user.
  37 **
  38 ** - use printk KERN_xxx level only if message is not a WARNING
  39 **   but is INFO, ERR etc.
  40 **
  41 ** - Use printk_ratelimited() for messages which may flood
  42 **   (e.g. "rx DUP pkt!").
  43 **
  44 ** - Use log() for messages which may be omitted (and they
  45 **   _will_ be omitted in non-debug builds). Note that
  46 **   message levels may be disabled at compile-time selectively,
  47 **   thus select them wisely. Example: L_DEBUG is the lowest
  48 **   (most likely to be compiled out) -> use for less important stuff.
  49 **
  50 ** - Do not print important stuff with log(), or else people
  51 **   will never build non-debug driver.
  52 **
  53 ** Style:
  54 ** hex: capital letters, zero filled (e.g. 0x02AC)
  55 ** str: dont start from capitals, no trailing periods ("tx: queue is stopped")
  56 */
  57
  58 #if ACX_DEBUG > 1
  59
  60 void log_fn_enter(const char *funcname);
  61 void log_fn_exit(const char *funcname);
  62 void log_fn_exit_v(const char *funcname, int v);
  63
  64 void acx_print_mac(const char *head, const u8 *mac, const char *tail);
  65
  66 #define FN_ENTER \
  67         do { \
  68                 if (unlikely(acx_debug & L_FUNC)) { \
  69                         log_fn_enter(__func__); \
  70                 } \
  71         } while (0)
  72
  73 #define FN_EXIT1(v) \
  74         do { \
  75                 if (unlikely(acx_debug & L_FUNC)) { \
  76                         log_fn_exit_v(__func__, v); \
  77                 } \
  78         } while (0)
  79 #define FN_EXIT0 \
  80         do { \
  81                 if (unlikely(acx_debug & L_FUNC)) { \
  82                         log_fn_exit(__func__); \
  83                 } \
  84         } while (0)
  85
  86 #else
  87
  88 #define FN_ENTER do {} while(0)
  89 #define FN_EXIT1(v) do {} while(0)
  90 #define FN_EXIT0 do {} while(0)
  91
  92 #endif /* ACX_DEBUG > 1 */
  93
  94
  95 #if ACX_DEBUG
  96
  97 #define log(chan, args...) \
  98         do { \
  99                 if (acx_debug & (chan)) \
 100                         printk(args); \
 101         } while (0)
 102 #define printk_ratelimited(args...) printk(args)
 103
 104 #else /* Non-debug build: */
 105
 106 #define log(chan, args...)
 107 /* Standard way of log flood prevention */
 108 #define printk_ratelimited(args...) \
 109 do { \
 110         if (printk_ratelimit()) \
 111                 printk(args); \
 112 } while (0)
 113
 114 #endif /* ACX_DEBUG */
 115
 116 /* Optimized out to nothing in non-debug build */
 117 static inline void
 118 acxlog_mac(int level, const char *head, const u8 *mac, const char *tail)
 119 {
 120         if (acx_debug & level) {
 121                 acx_print_mac(head, mac, tail);
 122         }
 123 }
 124
 125
 126 /***********************************************************************
 127 ** MAC address helpers
 128 */
 129 static inline void
 130 MAC_COPY(u8 *mac, const u8 *src)
 131 {
 132         memcpy(mac, src, ETH_ALEN);
 133 }
 134
 135 static inline void
 136 MAC_FILL(u8 *mac, u8 val)
 137 {
 138         memset(mac, val, ETH_ALEN);
 139 }
 140
 141 static inline void
 142 MAC_BCAST(u8 *mac)
 143 {
 144         ((u16*)mac)[2] = *(u32*)mac = -1;
 145 }
 146
 147 static inline void
 148 MAC_ZERO(u8 *mac)
 149 {
 150         ((u16*)mac)[2] = *(u32*)mac = 0;
 151 }
 152
 153 static inline int
 154 mac_is_equal(const u8 *a, const u8 *b)
 155 {
 156         /* can't beat this */
 157         return memcmp(a, b, ETH_ALEN) == 0;
 158 }
 159
 160 static inline int
 161 mac_is_bcast(const u8 *mac)
 162 {
 163         /* AND together 4 first bytes with sign-extended 2 last bytes
 164         ** Only bcast address gives 0xffffffff. +1 gives 0 */
 165         return ( *(s32*)mac & ((s16*)mac)[2] ) + 1 == 0;
 166 }
 167
 168 static inline int
 169 mac_is_zero(const u8 *mac)
 170 {
 171         return ( *(u32*)mac | ((u16*)mac)[2] ) == 0;
 172 }
 173
 174 static inline int
 175 mac_is_directed(const u8 *mac)
 176 {
 177         return (mac[0] & 1)==0;
 178 }
 179
 180 static inline int
 181 mac_is_mcast(const u8 *mac)
 182 {
 183         return (mac[0] & 1) && !mac_is_bcast(mac);
 184 }
 185
 186 #define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"
 187 #define MAC(bytevector) \
 188         ((unsigned char *)bytevector)[0], \
 189         ((unsigned char *)bytevector)[1], \
 190         ((unsigned char *)bytevector)[2], \
 191         ((unsigned char *)bytevector)[3], \
 192         ((unsigned char *)bytevector)[4], \
 193         ((unsigned char *)bytevector)[5]
 194
 195
 196 /***********************************************************************
 197 ** Random helpers
 198 */
 199 #define TO_STRING(x)    #x
 200 #define STRING(x)       TO_STRING(x)
 201
 202 #define CLEAR_BIT(val, mask) ((val) &= ~(mask))
 203 #define SET_BIT(val, mask) ((val) |= (mask))
 204 #define CHECK_BIT(val, mask) ((val) & (mask))
 205
 206 /* undefined if v==0 */
 207 static inline unsigned int
 208 lowest_bit(u16 v)
 209 {
 210         unsigned int n = 0;
 211         while (!(v & 0xf)) { v>>=4; n+=4; }
 212         while (!(v & 1)) { v>>=1; n++; }
 213         return n;
 214 }
 215
 216 /* undefined if v==0 */
 217 static inline unsigned int
 218 highest_bit(u16 v)
 219 {
 220         unsigned int n = 0;
 221         while (v>0xf) { v>>=4; n+=4; }
 222         while (v>1) { v>>=1; n++; }
 223         return n;
 224 }
 225
 226 /* undefined if v==0 */
 227 static inline int
 228 has_only_one_bit(u16 v)
 229 {
 230         return ((v-1) ^ v) >= v;
 231 }
 232
 233
 234 static inline int
 235 is_hidden_essid(char *essid)
 236 {
 237         return (('\0' == essid[0]) ||
 238                 ((' ' == essid[0]) && ('\0' == essid[1])));
 239 }
 240
 241 /***********************************************************************
 242 ** LOCKING
 243 ** We have adev->sem and adev->spinlock.
 244 **
 245 ** We employ following naming convention in order to get locking right:
 246 **
 247 ** acx_e_xxxx - external entry points called from process context.
 248 **      It is okay to sleep. adev->sem is to be taken on entry.
 249 ** acx_i_xxxx - external entry points possibly called from atomic context.
 250 **      Sleeping is not allowed (and thus down(sem) is not legal!)
 251 ** acx_s_xxxx - potentially sleeping functions. Do not ever call under lock!
 252 ** acx_l_xxxx - functions which expect lock to be already taken.
 253 ** rest       - non-sleeping functions which do not require locking
 254 **              but may be run under lock
 255 **
 256 ** A small number of local helpers do not have acx_[eisl]_ prefix.
 257 ** They are always close to caller and are to be reviewed locally.
 258 **
 259 ** Theory of operation:
 260 **
 261 ** All process-context entry points (_e_ functions) take sem
 262 ** immediately. IRQ handler and other 'atomic-context' entry points
 263 ** (_i_ functions) take lock immediately on entry, but dont take sem
 264 ** because that might sleep.
 265 **
 266 ** Thus *all* code is either protected by sem or lock, or both.
 267 **
 268 ** Code which must not run concurrently with IRQ takes lock.
 269 ** Such code is marked with _l_.
 270 **
 271 ** This results in the following rules of thumb useful in code review:
 272 **
 273 ** + If a function calls _s_ fn, it must be an _s_ itself.
 274 ** + You can call _l_ fn only (a) from another _l_ fn
 275 **   or (b) from _s_, _e_ or _i_ fn by taking lock, calling _l_,
 276 **   and dropping lock.
 277 ** + All IRQ code runs under lock.
 278 ** + Any _s_ fn is running under sem.
 279 ** + Code under sem can race only with IRQ code.
 280 ** + Code under sem+lock cannot race with anything.
 281 */
 282
 283 /* These functions *must* be inline or they will break horribly on SPARC, due
 284  * to its weird semantics for save/restore flags */
 285
 286 #if defined(PARANOID_LOCKING) /* Lock debugging */
 287
 288 void acx_lock_debug(acx_device_t *adev, const char* where);
 289 void acx_unlock_debug(acx_device_t *adev, const char* where);
 290 void acx_down_debug(acx_device_t *adev, const char* where);
 291 void acx_up_debug(acx_device_t *adev, const char* where);
 292 void acx_lock_unhold(void);
 293 void acx_sem_unhold(void);
 294
 295 static inline void
 296 acx_lock_helper(acx_device_t *adev, unsigned long *fp, const char* where)
 297 {
 298         acx_lock_debug(adev, where);
 299         spin_lock_irqsave(&adev->spinlock, *fp);
 300 }
 301 static inline void
 302 acx_unlock_helper(acx_device_t *adev, unsigned long *fp, const char* where)
 303 {
 304         acx_unlock_debug(adev, where);
 305         spin_unlock_irqrestore(&adev->spinlock, *fp);
 306 }
 307 #define acx_lock(adev, flags)   acx_lock_helper(adev, &(flags), __FILE__ ":" STRING(__LINE__))
 308 #define acx_unlock(adev, flags) acx_unlock_helper(adev, &(flags), __FILE__ ":" STRING(__LINE__))
 309 #define acx_sem_lock(adev)      mutex_lock(&(adev)->mutex)
 310 #define acx_sem_unlock(adev)    mutex_unlock(&(adev)->mutex)
 311
 312 #elif defined(DO_LOCKING)
 313
 314 #define acx_lock(adev, flags)   spin_lock_irqsave(&adev->spinlock, flags)
 315 #define acx_unlock(adev, flags) spin_unlock_irqrestore(&adev->spinlock, flags)
 316 #define acx_sem_lock(adev)      mutex_lock(&(adev)->mutex)
 317 #define acx_sem_unlock(adev)    mutex_unlock(&(adev)->mutex)
 318 #define acx_lock_unhold()       ((void)0)
 319 #define acx_sem_unhold()        ((void)0)
 320
 321 #else /* no locking! :( */
 322
 323 #define acx_lock(adev, flags)   ((void)0)
 324 #define acx_unlock(adev, flags) ((void)0)
 325 #define acx_sem_lock(adev)      ((void)0)
 326 #define acx_sem_unlock(adev)    ((void)0)
 327 #define acx_lock_unhold()       ((void)0)
 328 #define acx_sem_unhold()        ((void)0)
 329
 330 #endif
 331
 332
 333 /***********************************************************************
 334 */
 335
 336 /* Can race with rx path (which is not protected by sem):
 337 ** rx -> process_[re]assocresp() -> set_status(ASSOCIATED) -> wake_queue()
 338 ** Can race with tx_complete IRQ:
 339 ** IRQ -> acxpci_l_clean_txdesc -> acx_wake_queue
 340 ** Review carefully all callsites */
 341 static inline void
 342 acx_stop_queue(struct ieee80211_hw *hw, const char *msg)
 343 {/*
 344         if (netif_queue_stopped(ndev))
 345                 return;
 346 */
 347         ieee80211_stop_queues(hw);
 348         if (msg)
 349                 log(L_BUFT, "acx: tx: stop queue %s\n", msg);
 350 }
 351
 352 /*static inline int
 353 acx_queue_stopped(struct ieee80211_hw *ieee)
 354 {
 355         return netif_queue_stopped(ieee);
 356 }
 357
 358
 359 static inline void
 360 acx_start_queue(struct ieee80211_hw *hw, const char *msg)
 361 {
 362         ieee80211_start_queues(hw);
 363         if (msg)
 364                 log(L_BUFT, "acx: tx: start queue %s\n", msg);
 365 }
 366 */
 367 static inline void
 368 acx_wake_queue(struct ieee80211_hw *hw, const char *msg)
 369 {
 370         ieee80211_wake_queues(hw);
 371         if (msg)
 372                 log(L_BUFT, "acx: tx: wake queue %s\n", msg);
 373 }
 374 /*
 375 static inline void
 376 acx_carrier_off(struct net_device *ndev, const char *msg)
 377 {
 378         netif_carrier_off(ndev);
 379         if (msg)
 380                 log(L_BUFT, "acx: tx: carrier off %s\n", msg);
 381 }
 382
 383 static inline void
 384 acx_carrier_on(struct net_device *ndev, const char *msg)
 385 {
 386         netif_carrier_on(ndev);
 387         if (msg)
 388                 log(L_BUFT, "acx: tx: carrier on %s\n", msg);
 389 }
 390
 391 */
 392
 393
 394 /***********************************************************************
 395 ** Communication with firmware
 396 */
 397 #define CMD_TIMEOUT_MS(n)       (n)
 398 #define ACX_CMD_TIMEOUT_DEFAULT CMD_TIMEOUT_MS(50)
 399
 400 #if ACX_DEBUG
 401
 402 /* We want to log cmd names */
 403 int acxpci_s_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout, const char* cmdstr);
 404 int acxusb_s_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout, const char* cmdstr);
 405 static inline int
 406 acx_s_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout, const char* cmdstr)
 407 {
 408         if (IS_PCI(adev))
 409                 return acxpci_s_issue_cmd_timeo_debug(adev, cmd, param, len, timeout, cmdstr);
 410         return acxusb_s_issue_cmd_timeo_debug(adev, cmd, param, len, timeout, cmdstr);
 411 }
 412 #define acx_s_issue_cmd(adev,cmd,param,len) \
 413         acx_s_issue_cmd_timeo_debug(adev,cmd,param,len,ACX_CMD_TIMEOUT_DEFAULT,#cmd)
 414 #define acx_s_issue_cmd_timeo(adev,cmd,param,len,timeo) \
 415         acx_s_issue_cmd_timeo_debug(adev,cmd,param,len,timeo,#cmd)
 416 int acx_s_configure_debug(acx_device_t *adev, void *pdr, int type, const char* str);
 417 #define acx_s_configure(adev,pdr,type) \
 418         acx_s_configure_debug(adev,pdr,type,#type)
 419 int acx_s_interrogate_debug(acx_device_t *adev, void *pdr, int type, const char* str);
 420 #define acx_s_interrogate(adev,pdr,type) \
 421         acx_s_interrogate_debug(adev,pdr,type,#type)
 422
 423 #else
 424
 425 int acxpci_s_issue_cmd_timeo(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout);
 426 int acxusb_s_issue_cmd_timeo(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout);
 427 static inline int
 428 acx_s_issue_cmd_timeo(acx_device_t *adev, unsigned cmd, void *param, unsigned len, unsigned timeout)
 429 {
 430         if (IS_PCI(adev))
 431                 return acxpci_s_issue_cmd_timeo(adev, cmd, param, len, timeout);
 432         return acxusb_s_issue_cmd_timeo(adev, cmd, param, len, timeout);
 433 }
 434 static inline int
 435 acx_s_issue_cmd(acx_device_t *adev, unsigned cmd, void *param, unsigned len)
 436 {
 437         if (IS_PCI(adev))
 438                 return acxpci_s_issue_cmd_timeo(adev, cmd, param, len, ACX_CMD_TIMEOUT_DEFAULT);
 439         return acxusb_s_issue_cmd_timeo(adev, cmd, param, len, ACX_CMD_TIMEOUT_DEFAULT);
 440 }
 441 int acx_s_configure(acx_device_t *adev, void *pdr, int type);
 442 int acx_s_interrogate(acx_device_t *adev, void *pdr, int type);
 443
 444 #endif
 445
 446 void acx_s_cmd_start_scan(acx_device_t *adev);
 447
 448
 449 /***********************************************************************
 450 ** Ioctls
 451 */
 452 /*int
 453 acx111pci_ioctl_info(
 454         struct net_device *ndev,
 455         struct iw_request_info *info,
 456         struct iw_param *vwrq,
 457         char *extra);
 458 int
 459 acx100pci_ioctl_set_phy_amp_bias(
 460         struct net_device *ndev,
 461         struct iw_request_info *info,
 462         struct iw_param *vwrq,
 463         char *extra);
 464 */
 465
 466 /***********************************************************************
 467 ** /proc
 468 */
 469 #ifdef CONFIG_PROC_FS
 470 int acx_proc_register_entries(struct ieee80211_hw *ieee);
 471 int acx_proc_unregister_entries(struct ieee80211_hw *ieee);
 472 #else
 473 static inline int
 474 acx_proc_register_entries(const struct ieee80211_hw *ieee) { return OK; }
 475 static inline int
 476 acx_proc_unregister_entries(const struct ieee80211_hw *ieee) { return OK; }
 477 #endif
 478
 479
 480 /***********************************************************************
 481 */
 482 firmware_image_t *acx_s_read_fw(struct device *dev, const char *file, u32 *size);
 483 int acxpci_s_upload_radio(acx_device_t *adev);
 484
 485
 486 /***********************************************************************
 487 ** Unsorted yet :)
 488 */
 489 int acxpci_s_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf);
 490 int acxusb_s_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf);
 491 static inline int
 492 acx_s_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf)
 493 {
 494         if (IS_PCI(adev))
 495                 return acxpci_s_read_phy_reg(adev, reg, charbuf);
 496         return acxusb_s_read_phy_reg(adev, reg, charbuf);
 497 }
 498
 499 int acxpci_s_write_phy_reg(acx_device_t *adev, u32 reg, u8 value);
 500 int acxusb_s_write_phy_reg(acx_device_t *adev, u32 reg, u8 value);
 501 static inline int
 502 acx_s_write_phy_reg(acx_device_t *adev, u32 reg, u8 value)
 503 {
 504         if (IS_PCI(adev))
 505                 return acxpci_s_write_phy_reg(adev, reg, value);
 506         return acxusb_s_write_phy_reg(adev, reg, value);
 507 }
 508
 509 tx_t* acxpci_l_alloc_tx(acx_device_t *adev);
 510 tx_t* acxusb_l_alloc_tx(acx_device_t *adev);
 511 static inline tx_t*
 512 acx_l_alloc_tx(acx_device_t *adev)
 513 {
 514         if (IS_PCI(adev))
 515                 return acxpci_l_alloc_tx(adev);
 516         return acxusb_l_alloc_tx(adev);
 517 }
 518
 519 void acxusb_l_dealloc_tx(tx_t *tx_opaque);
 520 static inline void
 521 acx_l_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque)
 522 {
 523         if (IS_USB(adev))
 524                 acxusb_l_dealloc_tx(tx_opaque);
 525 }
 526
 527 void* acxpci_l_get_txbuf(acx_device_t *adev, tx_t *tx_opaque);
 528 void* acxusb_l_get_txbuf(acx_device_t *adev, tx_t *tx_opaque);
 529 static inline void*
 530 acx_l_get_txbuf(acx_device_t *adev, tx_t *tx_opaque)
 531 {
 532         if (IS_PCI(adev))
 533                 return acxpci_l_get_txbuf(adev, tx_opaque);
 534         return acxusb_l_get_txbuf(adev, tx_opaque);
 535 }
 536
 537 void acxpci_l_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len,
 538                         struct ieee80211_tx_control *ieeectl, struct sk_buff *skb);
 539 void acxusb_l_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_control *ieeectl,
 540                         struct sk_buff *skb);
 541 static inline void
 542 acx_l_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len,
 543                         struct ieee80211_tx_control *ieeectl, struct sk_buff *skb)
 544 {
 545         if (IS_PCI(adev))
 546                 acxpci_l_tx_data(adev, tx_opaque, len, ieeectl,skb);
 547         else
 548                 acxusb_l_tx_data(adev, tx_opaque, len, ieeectl,skb);
 549 }
 550
 551 static inline struct ieee80211_hdr *
 552 acx_get_wlan_hdr(acx_device_t *adev, const rxbuffer_t *rxbuf)
 553 {
 554         return (struct ieee80211_hdr *)((u8 *)&rxbuf->hdr_a3 + adev->phy_header_len);
 555 }
 556 void acxpci_l_power_led(acx_device_t *adev, int enable);
 557 int acxpci_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf);
 558 unsigned int acxpci_l_clean_txdesc(acx_device_t *adev);
 559 void acxpci_l_clean_txdesc_emergency(acx_device_t *adev);
 560 int acxpci_s_create_hostdesc_queues(acx_device_t *adev);
 561 void acxpci_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, u32 rx_queue_start);
 562 void acxpci_free_desc_queues(acx_device_t *adev);
 563 char* acxpci_s_proc_diag_output(char *p, acx_device_t *adev);
 564 int acxpci_proc_eeprom_output(char *p, acx_device_t *adev);
 565 void acxpci_set_interrupt_mask(acx_device_t *adev);
 566 int acx100pci_s_set_tx_level(acx_device_t *adev, u8 level_dbm);
 567
 568 void acx_s_mwait(int ms);
 569 int acx_s_init_mac(acx_device_t *adev);
 570 void acx_set_reg_domain(acx_device_t *adev, unsigned char reg_dom_id);
 571 void acx_update_capabilities(acx_device_t *adev);
 572 void acx_s_start(acx_device_t *adev);
 573
 574 void acx_s_update_card_settings(acx_device_t *adev);
 575 void acx_s_parse_configoption(acx_device_t *adev, const acx111_ie_configoption_t *pcfg);
 576 void acx_l_update_ratevector(acx_device_t *adev);
 577
 578 void acx_init_task_scheduler(acx_device_t *adev);
 579 void acx_schedule_task(acx_device_t *adev, unsigned int set_flag);
 580
 581 int acx_e_ioctl_old(struct net_device *ndev, struct ifreq *ifr, int cmd);
 582
 583 client_t *acx_l_sta_list_get(acx_device_t *adev, const u8 *address);
 584 void acx_l_sta_list_del(acx_device_t *adev, client_t *clt);
 585
 586 void acx_i_timer(unsigned long a);
 587
 588 struct sk_buff *acx_rxbuf_to_ether(acx_device_t *adev, rxbuffer_t *rxbuf);
 589 int acx_ether_to_txbuf(acx_device_t *adev, void *txbuf, const struct sk_buff *skb);
 590
 591 u8 acx_signal_determine_quality(u8 signal, u8 noise);
 592
 593 void acx_l_process_rxbuf(acx_device_t *adev, rxbuffer_t *rxbuf);
 594 void acx_l_handle_txrate_auto(acx_device_t *adev, struct client *txc,
 595                         u16 intended_rate, u8 rate100, u16 rate111, u8 error,
 596                         int pkts_to_ignore);
 597
 598 void acx_dump_bytes(const void *, int);
 599
 600 u8 acx_rate111to100(u16);
 601
 602 void acx_s_set_defaults(acx_device_t *adev);
 603
 604 #if !ACX_DEBUG
 605 static inline const char* acx_get_packet_type_string(u16 fc) { return ""; }
 606 #else
 607 const char* acx_get_packet_type_string(u16 fc);
 608 #endif
 609 const char* acx_cmd_status_str(unsigned int state);
 610
 611 /*** Devicescape functions ***/
 612 int acx_setup_modes(acx_device_t *adev);
 613 void acx_free_modes(acx_device_t *adev);
 614 int acx_i_start_xmit(struct ieee80211_hw* ieee,
 615                         struct sk_buff *skb,
 616                         struct ieee80211_tx_control *ctl);
 617 int acx_add_interface(struct ieee80211_hw* ieee,
 618                 struct ieee80211_if_init_conf *conf);
 619 void acx_remove_interface(struct ieee80211_hw* ieee,
 620                 struct ieee80211_if_init_conf *conf);
 621 int acx_net_reset(struct ieee80211_hw* ieee);
 622 int acx_net_set_key(struct ieee80211_hw *hw,
 623                 enum set_key_cmd cmd,
 624                 const u8 *local_addr, const u8 *addr,
 625                 struct ieee80211_key_conf *key);
 626
 627 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 628 extern int acx_config_interface(struct ieee80211_hw* ieee,
 629                                 struct ieee80211_vif *vif,
 630                                 struct ieee80211_if_conf *conf);
 631 #else
 632 int acx_config_interface(struct ieee80211_hw* ieee, int if_id,
 633                          struct ieee80211_if_conf *conf);
 634 #endif
 635
 636 int acx_net_config(struct ieee80211_hw* ieee, struct ieee80211_conf *conf);
 637 int acx_net_get_tx_stats(struct ieee80211_hw* ieee, struct ieee80211_tx_queue_stats *stats);
 638 int acx_net_conf_tx(struct ieee80211_hw* ieee, int queue,
 639                 const struct ieee80211_tx_queue_params *params);
 640 //int acx_passive_scan(struct net_device *net_dev, int state, struct ieee80211_scan_conf *conf);
 641 //static void acx_netdev_init(struct net_device *ndev);
 642 int acxpci_s_reset_dev(acx_device_t *adev);
 643 void acx_e_after_interrupt_task(struct work_struct* work);
 644 void acx_i_set_multicast_list(struct ieee80211_hw *hw,
 645                             unsigned int changed_flags,
 646                             unsigned int *total_flags,
 647                             int mc_count, struct dev_addr_list *mc_list);
 648
 649 /*** End DeviceScape Functions **/
 650
 651 void great_inquisitor(acx_device_t *adev);
 652
 653 void acx_s_get_firmware_version(acx_device_t *adev);
 654 void acx_display_hardware_details(acx_device_t *adev);
 655
 656 int acx_e_change_mtu(struct ieee80211_hw *hw, int mtu);
 657 int acx_e_get_stats(struct ieee80211_hw *hw, struct ieee80211_low_level_stats *stats);
 658 struct iw_statistics* acx_e_get_wireless_stats(struct ieee80211_hw *hw);
 659 void acx_interrupt_tasklet(struct work_struct *work);
 660
 661 int __init acxpci_e_init_module(void);
 662 int __init acxusb_e_init_module(void);
 663 void __exit acxpci_e_cleanup_module(void);
 664 void __exit acxusb_e_cleanup_module(void);
 665
 666 #endif /* _ACX_FUNC_H_ */