acx_func.h

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