acx_func.h

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