acx_func.h

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