Lines Matching refs:this
82 * The event() function is this driver's Card Services event handler. It will
198 static inline void wl3501_switch_page(struct wl3501_card *this, u8 page)
200 wl3501_outb(page, this->base_addr + WL3501_NIC_BSS);
209 static int wl3501_get_flash_mac_addr(struct wl3501_card *this)
211 int base_addr = this->base_addr;
220 this->mac_addr[0] = inb(base_addr + WL3501_NIC_IODPA);
222 this->mac_addr[1] = inb(base_addr + WL3501_NIC_IODPA);
224 this->mac_addr[2] = inb(base_addr + WL3501_NIC_IODPA);
226 this->mac_addr[3] = inb(base_addr + WL3501_NIC_IODPA);
228 this->mac_addr[4] = inb(base_addr + WL3501_NIC_IODPA);
230 this->mac_addr[5] = inb(base_addr + WL3501_NIC_IODPA);
232 this->reg_domain = inb(base_addr + WL3501_NIC_IODPA);
238 this->version[0] = inb(base_addr + WL3501_NIC_IODPA);
240 this->version[1] = inb(base_addr + WL3501_NIC_IODPA);
242 wl3501_switch_page(this, WL3501_BSS_SPAGE0);
245 return this->mac_addr[0] == 0x00 && this->mac_addr[1] == 0x60;
256 static void wl3501_set_to_wla(struct wl3501_card *this, u16 dest, void *src,
260 wl3501_switch_page(this, (dest & 0x8000) ? WL3501_BSS_SPAGE1 :
263 wl3501_outb(dest & 0xff, this->base_addr + WL3501_NIC_LMAL);
264 wl3501_outb(((dest >> 8) & 0x7f), this->base_addr + WL3501_NIC_LMAH);
267 wl3501_outsb(this->base_addr + WL3501_NIC_IODPA, src, size);
278 static void wl3501_get_from_wla(struct wl3501_card *this, u16 src, void *dest,
282 wl3501_switch_page(this, (src & 0x8000) ? WL3501_BSS_SPAGE1 :
285 wl3501_outb(src & 0xff, this->base_addr + WL3501_NIC_LMAL);
286 wl3501_outb((src >> 8) & 0x7f, this->base_addr + WL3501_NIC_LMAH);
289 insb(this->base_addr + WL3501_NIC_IODPA, dest, size);
304 static u16 wl3501_get_tx_buffer(struct wl3501_card *this, u16 len)
310 if (full_len > this->tx_buffer_cnt * 254)
312 ret = this->tx_buffer_head;
318 wl3501_get_from_wla(this, this->tx_buffer_head, &next,
321 wl3501_set_to_wla(this, this->tx_buffer_head, &zero,
323 this->tx_buffer_head = next;
327 this->tx_buffer_head = ret;
332 this->tx_buffer_cnt -= blk_cnt;
340 static void wl3501_free_tx_buffer(struct wl3501_card *this, u16 ptr)
343 if (!this->tx_buffer_head)
344 this->tx_buffer_head = ptr;
346 wl3501_set_to_wla(this, this->tx_buffer_tail,
351 this->tx_buffer_cnt++;
352 wl3501_get_from_wla(this, ptr, &next, sizeof(next));
353 this->tx_buffer_tail = ptr;
358 static int wl3501_esbq_req_test(struct wl3501_card *this)
362 wl3501_get_from_wla(this, this->esbq_req_head + 3, &tmp, sizeof(tmp));
366 static void wl3501_esbq_req(struct wl3501_card *this, u16 *ptr)
370 wl3501_set_to_wla(this, this->esbq_req_head, ptr, 2);
371 wl3501_set_to_wla(this, this->esbq_req_head + 2, &tmp, sizeof(tmp));
372 this->esbq_req_head += 4;
373 if (this->esbq_req_head >= this->esbq_req_end)
374 this->esbq_req_head = this->esbq_req_start;
377 static int wl3501_esbq_exec(struct wl3501_card *this, void *sig, int sig_size)
381 if (wl3501_esbq_req_test(this)) {
382 u16 ptr = wl3501_get_tx_buffer(this, sig_size);
384 wl3501_set_to_wla(this, ptr, sig, sig_size);
385 wl3501_esbq_req(this, &ptr);
392 static int wl3501_get_mib_value(struct wl3501_card *this, u8 index,
402 spin_lock_irqsave(&this->lock, flags);
403 if (wl3501_esbq_req_test(this)) {
404 u16 ptr = wl3501_get_tx_buffer(this, sizeof(sig));
406 wl3501_set_to_wla(this, ptr, &sig, sizeof(sig));
407 wl3501_esbq_req(this, &ptr);
408 this->sig_get_confirm.mib_status = 255;
409 spin_unlock_irqrestore(&this->lock, flags);
410 rc = wait_event_interruptible(this->wait,
411 this->sig_get_confirm.mib_status != 255);
413 memcpy(bf, this->sig_get_confirm.mib_value,
418 spin_unlock_irqrestore(&this->lock, flags);
423 static int wl3501_pwr_mgmt(struct wl3501_card *this, int suspend)
434 spin_lock_irqsave(&this->lock, flags);
435 if (wl3501_esbq_req_test(this)) {
436 u16 ptr = wl3501_get_tx_buffer(this, sizeof(sig));
438 wl3501_set_to_wla(this, ptr, &sig, sizeof(sig));
439 wl3501_esbq_req(this, &ptr);
440 this->sig_pwr_mgmt_confirm.status = 255;
441 spin_unlock_irqrestore(&this->lock, flags);
442 rc = wait_event_interruptible(this->wait,
443 this->sig_pwr_mgmt_confirm.status != 255);
446 this->sig_pwr_mgmt_confirm.status);
450 spin_unlock_irqrestore(&this->lock, flags);
457 * @this - card
465 static int wl3501_send_pkt(struct wl3501_card *this, u8 *data, u16 len)
474 if (wl3501_esbq_req_test(this)) {
475 sig_bf = wl3501_get_tx_buffer(this, sizeof(sig));
479 bf = wl3501_get_tx_buffer(this, len + 26 + 24);
482 wl3501_free_tx_buffer(this, sig_bf);
495 wl3501_set_to_wla(this, bf + 2 +
506 wl3501_set_to_wla(this,
510 wl3501_get_from_wla(this, bf, &next, sizeof(next));
523 wl3501_set_to_wla(this, bf + 2 +
527 wl3501_get_from_wla(this, bf, &next, sizeof(next));
538 wl3501_set_to_wla(this, bf + 2, pdata, tmplen);
540 wl3501_get_from_wla(this, bf, &next, sizeof(next));
543 wl3501_set_to_wla(this, sig_bf, &sig, sizeof(sig));
544 wl3501_esbq_req(this, &sig_bf);
550 static int wl3501_mgmt_resync(struct wl3501_card *this)
556 return wl3501_esbq_exec(this, &sig, sizeof(sig));
559 static inline int wl3501_fw_bss_type(struct wl3501_card *this)
561 return this->net_type == IW_MODE_INFRA ? WL3501_NET_TYPE_INFRA :
565 static inline int wl3501_fw_cap_info(struct wl3501_card *this)
567 return this->net_type == IW_MODE_INFRA ? WL3501_MGMT_CAPABILITY_ESS :
571 static int wl3501_mgmt_scan(struct wl3501_card *this, u16 chan_time)
579 .bss_type = wl3501_fw_bss_type(this),
582 this->bss_cnt = this->join_sta_bss = 0;
583 return wl3501_esbq_exec(this, &sig, sizeof(sig));
586 static int wl3501_mgmt_join(struct wl3501_card *this, u16 stas)
596 .chan = this->chan,
600 memcpy(&sig.beacon_period, &this->bss_set[stas].beacon_period, 72);
601 return wl3501_esbq_exec(this, &sig, sizeof(sig));
604 static int wl3501_mgmt_start(struct wl3501_card *this)
615 .chan = this->chan,
648 .bss_type = wl3501_fw_bss_type(this),
649 .cap_info = wl3501_fw_cap_info(this),
652 iw_copy_mgmt_info_element(&sig.ssid.el, &this->essid.el);
653 iw_copy_mgmt_info_element(&this->keep_essid.el, &this->essid.el);
654 return wl3501_esbq_exec(this, &sig, sizeof(sig));
657 static void wl3501_mgmt_scan_confirm(struct wl3501_card *this, u16 addr)
664 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
667 if ((this->net_type == IW_MODE_INFRA &&
669 (this->net_type == IW_MODE_ADHOC &&
671 this->net_type == IW_MODE_AUTO) {
672 if (!this->essid.el.len)
674 else if (this->essid.el.len == 3 &&
675 !memcmp(this->essid.essid, "ANY", 3))
677 else if (this->essid.el.len != sig.ssid.el.len)
679 else if (memcmp(this->essid.essid, sig.ssid.essid,
680 this->essid.el.len))
685 for (i = 0; i < this->bss_cnt; i++) {
686 if (!memcmp(this->bss_set[i].bssid,
694 memcpy(&this->bss_set[i].beacon_period,
696 this->bss_cnt++;
697 this->rssi = sig.rssi;
702 this->join_sta_bss = 0;
703 for (i = this->join_sta_bss; i < this->bss_cnt; i++)
704 if (!wl3501_mgmt_join(this, i))
706 this->join_sta_bss = i;
707 if (this->join_sta_bss == this->bss_cnt) {
708 if (this->net_type == IW_MODE_INFRA)
709 wl3501_mgmt_scan(this, 100);
711 this->adhoc_times++;
712 if (this->adhoc_times > WL3501_MAX_ADHOC_TRIES)
713 wl3501_mgmt_start(this);
715 wl3501_mgmt_scan(this, 100);
723 * @this - card
728 static int wl3501_block_interrupt(struct wl3501_card *this)
730 u8 old = inb(this->base_addr + WL3501_NIC_GCR);
734 wl3501_outb(new, this->base_addr + WL3501_NIC_GCR);
740 * @this - card
745 static int wl3501_unblock_interrupt(struct wl3501_card *this)
747 u8 old = inb(this->base_addr + WL3501_NIC_GCR);
751 wl3501_outb(new, this->base_addr + WL3501_NIC_GCR);
760 * @this: card
764 static u16 wl3501_receive(struct wl3501_card *this, u8 *bf, u16 size)
770 wl3501_get_from_wla(this, this->start_seg + 2,
773 wl3501_get_from_wla(this,
774 this->start_seg +
781 wl3501_get_from_wla(this,
782 this->start_seg +
789 wl3501_get_from_wla(this, next_addr + 5, data,
793 wl3501_get_from_wla(this, next_addr + 2, &next_addr1,
797 wl3501_get_from_wla(this, next_addr + 5, data, size);
804 static void wl3501_esbq_req_free(struct wl3501_card *this)
809 if (this->esbq_req_head == this->esbq_req_tail)
811 wl3501_get_from_wla(this, this->esbq_req_tail + 3, &tmp, sizeof(tmp));
814 wl3501_get_from_wla(this, this->esbq_req_tail, &addr, sizeof(addr));
815 wl3501_free_tx_buffer(this, addr);
816 this->esbq_req_tail += 4;
817 if (this->esbq_req_tail >= this->esbq_req_end)
818 this->esbq_req_tail = this->esbq_req_start;
823 static int wl3501_esbq_confirm(struct wl3501_card *this)
827 wl3501_get_from_wla(this, this->esbq_confirm + 3, &tmp, sizeof(tmp));
833 struct wl3501_card *this = netdev_priv(dev);
836 dev->name, this->bssid);
840 static void wl3501_esbq_confirm_done(struct wl3501_card *this)
844 wl3501_set_to_wla(this, this->esbq_confirm + 3, &tmp, sizeof(tmp));
845 this->esbq_confirm += 4;
846 if (this->esbq_confirm >= this->esbq_confirm_end)
847 this->esbq_confirm = this->esbq_confirm_start;
850 static int wl3501_mgmt_auth(struct wl3501_card *this)
859 memcpy(sig.mac_addr, this->bssid, ETH_ALEN);
860 return wl3501_esbq_exec(this, &sig, sizeof(sig));
863 static int wl3501_mgmt_association(struct wl3501_card *this)
869 .cap_info = this->cap_info,
873 memcpy(sig.mac_addr, this->bssid, ETH_ALEN);
874 return wl3501_esbq_exec(this, &sig, sizeof(sig));
879 struct wl3501_card *this = netdev_priv(dev);
883 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
885 if (this->net_type == IW_MODE_INFRA) {
886 if (this->join_sta_bss < this->bss_cnt) {
887 const int i = this->join_sta_bss;
888 memcpy(this->bssid,
889 this->bss_set[i].bssid, ETH_ALEN);
890 this->chan = this->bss_set[i].ds_pset.chan;
891 iw_copy_mgmt_info_element(&this->keep_essid.el,
892 &this->bss_set[i].ssid.el);
893 wl3501_mgmt_auth(this);
896 const int i = this->join_sta_bss;
898 memcpy(&this->bssid, &this->bss_set[i].bssid, ETH_ALEN);
899 this->chan = this->bss_set[i].ds_pset.chan;
900 iw_copy_mgmt_info_element(&this->keep_essid.el,
901 &this->bss_set[i].ssid.el);
906 this->join_sta_bss++;
907 for (i = this->join_sta_bss; i < this->bss_cnt; i++)
908 if (!wl3501_mgmt_join(this, i))
910 this->join_sta_bss = i;
911 if (this->join_sta_bss == this->bss_cnt) {
912 if (this->net_type == IW_MODE_INFRA)
913 wl3501_mgmt_scan(this, 100);
915 this->adhoc_times++;
916 if (this->adhoc_times > WL3501_MAX_ADHOC_TRIES)
917 wl3501_mgmt_start(this);
919 wl3501_mgmt_scan(this, 100);
926 struct wl3501_card *this)
928 if (this->net_type == IW_MODE_INFRA) {
931 wl3501_mgmt_resync(this);
936 struct wl3501_card *this,
942 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
943 wl3501_free_tx_buffer(this, sig.data);
949 struct wl3501_card *this, u16 addr)
956 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
957 this->start_seg = sig.data;
958 wl3501_get_from_wla(this,
961 this->rssi = rssi <= 63 ? (rssi * 100) / 64 : 255;
963 wl3501_get_from_wla(this,
984 wl3501_receive(this, skb->data, pkt_len);
993 static inline void wl3501_get_confirm_interrupt(struct wl3501_card *this,
997 wl3501_get_from_wla(this, addr, &this->sig_get_confirm,
998 sizeof(this->sig_get_confirm));
999 wake_up(&this->wait);
1003 struct wl3501_card *this,
1009 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1017 struct wl3501_card *this = netdev_priv(dev);
1021 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1027 static inline void wl3501_auth_confirm_interrupt(struct wl3501_card *this,
1033 wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1036 wl3501_mgmt_association(this);
1038 wl3501_mgmt_resync(this);
1046 struct wl3501_card *this = netdev_priv(dev);
1051 if (!wl3501_esbq_confirm(this))
1053 wl3501_get_from_wla(this, this->esbq_confirm, &addr, sizeof(addr));
1054 wl3501_get_from_wla(this, addr + 2, &sig_id, sizeof(sig_id));
1060 wl3501_alarm_interrupt(dev, this);
1063 wl3501_md_confirm_interrupt(dev, this, addr);
1066 wl3501_md_ind_interrupt(dev, this, addr);
1069 wl3501_get_confirm_interrupt(this, addr,
1070 &this->sig_get_confirm,
1071 sizeof(this->sig_get_confirm));
1074 wl3501_get_confirm_interrupt(this, addr,
1075 &this->sig_pwr_mgmt_confirm,
1076 sizeof(this->sig_pwr_mgmt_confirm));
1079 wl3501_start_confirm_interrupt(dev, this, addr);
1082 wl3501_mgmt_scan_confirm(this, addr);
1091 wl3501_auth_confirm_interrupt(this, addr);
1094 wl3501_mgmt_resync(this);
1097 wl3501_esbq_confirm_done(this);
1101 wl3501_esbq_req_free(this);
1106 static inline void wl3501_ack_interrupt(struct wl3501_card *this)
1108 wl3501_outb(WL3501_GCR_ECINT, this->base_addr + WL3501_NIC_GCR);
1126 struct wl3501_card *this;
1128 this = netdev_priv(dev);
1129 spin_lock(&this->lock);
1130 wl3501_ack_interrupt(this);
1131 wl3501_block_interrupt(this);
1133 wl3501_unblock_interrupt(this);
1134 spin_unlock(&this->lock);
1139 static int wl3501_reset_board(struct wl3501_card *this)
1145 wl3501_outb_p(WL3501_GCR_CORESET, this->base_addr + WL3501_NIC_GCR);
1146 wl3501_outb_p(0, this->base_addr + WL3501_NIC_GCR);
1147 wl3501_outb_p(WL3501_GCR_CORESET, this->base_addr + WL3501_NIC_GCR);
1150 wl3501_set_to_wla(this, 0x480, &tmp, sizeof(tmp));
1153 wl3501_outb_p(0, this->base_addr + WL3501_NIC_GCR);
1157 wl3501_unblock_interrupt(this); /* acme: was commented */
1161 wl3501_get_from_wla(this, 0x480, &tmp, sizeof(tmp));
1166 wl3501_set_to_wla(this, 0x480, &tmp, sizeof(tmp));
1177 static int wl3501_init_firmware(struct wl3501_card *this)
1180 int rc = wl3501_reset_board(this);
1184 this->card_name[0] = '\0';
1185 wl3501_get_from_wla(this, 0x1a00,
1186 this->card_name, sizeof(this->card_name));
1187 this->card_name[sizeof(this->card_name) - 1] = '\0';
1188 this->firmware_date[0] = '\0';
1189 wl3501_get_from_wla(this, 0x1a40,
1190 this->firmware_date, sizeof(this->firmware_date));
1191 this->firmware_date[sizeof(this->firmware_date) - 1] = '\0';
1193 wl3501_switch_page(this, WL3501_BSS_SPAGE0);
1195 wl3501_get_from_wla(this, 0x482, &this->esbq_req_start, 2);
1196 wl3501_get_from_wla(this, 0x486, &this->esbq_req_end, 2);
1197 wl3501_get_from_wla(this, 0x488, &this->esbq_confirm_start, 2);
1198 wl3501_get_from_wla(this, 0x48c, &this->esbq_confirm_end, 2);
1199 wl3501_get_from_wla(this, 0x48e, &this->tx_buffer_head, 2);
1200 wl3501_get_from_wla(this, 0x492, &this->tx_buffer_size, 2);
1201 this->esbq_req_tail = this->esbq_req_head = this->esbq_req_start;
1202 this->esbq_req_end += this->esbq_req_start;
1203 this->esbq_confirm = this->esbq_confirm_start;
1204 this->esbq_confirm_end += this->esbq_confirm_start;
1206 this->tx_buffer_cnt = 1;
1207 ptr = this->tx_buffer_head;
1209 while ((next - this->tx_buffer_head) < this->tx_buffer_size) {
1210 this->tx_buffer_cnt++;
1211 wl3501_set_to_wla(this, ptr, &next, sizeof(next));
1217 wl3501_set_to_wla(this, ptr, &next, sizeof(next));
1218 this->tx_buffer_tail = ptr;
1228 struct wl3501_card *this = netdev_priv(dev);
1232 link = this->p_dev;
1234 spin_lock_irqsave(&this->lock, flags);
1239 wl3501_ack_interrupt(this);
1242 wl3501_block_interrupt(this);
1246 spin_unlock_irqrestore(&this->lock, flags);
1260 struct wl3501_card *this = netdev_priv(dev);
1263 wl3501_block_interrupt(this);
1265 if (wl3501_init_firmware(this)) {
1277 this->adhoc_times = 0;
1278 wl3501_ack_interrupt(this);
1279 wl3501_unblock_interrupt(this);
1280 wl3501_mgmt_scan(this, 100);
1289 struct wl3501_card *this = netdev_priv(dev);
1295 spin_lock_irqsave(&this->lock, flags);
1297 spin_unlock_irqrestore(&this->lock, flags);
1316 struct wl3501_card *this = netdev_priv(dev);
1319 spin_lock_irqsave(&this->lock, flags);
1320 enabled = wl3501_block_interrupt(this);
1321 rc = wl3501_send_pkt(this, skb->data, skb->len);
1323 wl3501_unblock_interrupt(this);
1332 if (this->tx_buffer_cnt < 2)
1335 spin_unlock_irqrestore(&this->lock, flags);
1342 struct wl3501_card *this = netdev_priv(dev);
1345 link = this->p_dev;
1347 spin_lock_irqsave(&this->lock, flags);
1355 if (wl3501_init_firmware(this))
1358 this->adhoc_times = 0;
1360 wl3501_ack_interrupt(this);
1363 wl3501_unblock_interrupt(this);
1364 wl3501_mgmt_scan(this, 100);
1369 dev->name, this->card_name,
1370 dev->name, this->firmware_date);
1372 spin_unlock_irqrestore(&this->lock, flags);
1381 struct wl3501_card *this = netdev_priv(dev);
1382 struct iw_statistics *wstats = &this->wstats;
1387 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_ICV_ERROR_COUNT,
1390 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_UNDECRYPTABLE_COUNT,
1393 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_EXCLUDED_COUNT,
1396 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_RETRY_COUNT,
1399 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_FAILED_COUNT,
1402 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_RTS_FAILURE_COUNT,
1405 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_ACK_FAILURE_COUNT,
1408 if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_FRAME_DUPLICATE_COUNT,
1461 struct wl3501_card *this = netdev_priv(dev);
1465 if (iw_valid_channel(this->reg_domain, channel)) {
1466 this->chan = channel;
1475 struct wl3501_card *this = netdev_priv(dev);
1477 wrqu->freq.m = ieee80211_dsss_chan_to_freq(this->chan) * 100000;
1490 struct wl3501_card *this = netdev_priv(dev);
1492 this->net_type = wrqu->mode;
1501 struct wl3501_card *this = netdev_priv(dev);
1503 wrqu->mode = this->net_type;
1510 struct wl3501_card *this = netdev_priv(dev);
1512 wrqu->sens.value = this->rssi;
1540 struct wl3501_card *this = netdev_priv(dev);
1548 memcpy(this->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
1557 struct wl3501_card *this = netdev_priv(dev);
1560 memcpy(wrqu->ap_addr.sa_data, this->bssid, ETH_ALEN);
1573 struct wl3501_card *this = netdev_priv(dev);
1578 for (i = 0; i < this->bss_cnt; ++i) {
1581 memcpy(iwe.u.ap_addr.sa_data, this->bss_set[i].bssid, ETH_ALEN);
1587 iwe.u.data.length = this->bss_set[i].ssid.el.len;
1591 this->bss_set[i].ssid.essid);
1593 iwe.u.mode = this->bss_set[i].bss_type;
1598 iwe.u.freq.m = this->bss_set[i].ds_pset.chan;
1604 if (this->bss_set[i].cap_info & WL3501_MGMT_CAPABILITY_PRIVACY)
1623 struct wl3501_card *this = netdev_priv(dev);
1627 &this->essid.el,
1631 &this->essid.el, "ANY", 3);
1640 struct wl3501_card *this = netdev_priv(dev);
1643 spin_lock_irqsave(&this->lock, flags);
1645 wrqu->essid.length = this->essid.el.len;
1646 memcpy(extra, this->essid.essid, this->essid.el.len);
1647 spin_unlock_irqrestore(&this->lock, flags);
1654 struct wl3501_card *this = netdev_priv(dev);
1656 if (wrqu->data.length > sizeof(this->nick))
1658 strlcpy(this->nick, extra, wrqu->data.length);
1665 struct wl3501_card *this = netdev_priv(dev);
1667 strlcpy(extra, this->nick, 32);
1685 struct wl3501_card *this = netdev_priv(dev);
1686 int rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_RTS_THRESHOLD,
1701 struct wl3501_card *this = netdev_priv(dev);
1702 int rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_FRAG_THRESHOLD,
1717 struct wl3501_card *this = netdev_priv(dev);
1718 int rc = wl3501_get_mib_value(this,
1725 * From the MIB values I think this can be configurable,
1739 struct wl3501_card *this = netdev_priv(dev);
1740 int rc = wl3501_get_mib_value(this,
1749 rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_SHORT_RETRY_LIMIT,
1766 struct wl3501_card *this = netdev_priv(dev);
1767 int rc = wl3501_get_mib_value(this,
1776 rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_EXCLUDE_UNENCRYPTED,
1782 rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_KEY_MAPPINGS_LEN,
1786 rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_KEY_MAPPINGS,
1803 struct wl3501_card *this = netdev_priv(dev);
1804 int rc = wl3501_get_mib_value(this,
1867 * card at this point -- we wait until we receive a card insertion event.
1872 struct wl3501_card *this;
1891 this = netdev_priv(dev);
1892 this->wireless_data.spy_data = &this->spy_data;
1893 this->p_dev = p_dev;
1894 dev->wireless_data = &this->wireless_data;
1917 struct wl3501_card *this;
1926 * 0x200-0x2ff, and so on, because this seems safer */
1936 /* Now allocate an interrupt line. Note that this does not actually
1958 this = netdev_priv(dev);
1960 this->base_addr = dev->base_addr;
1962 if (!wl3501_get_flash_mac_addr(this)) {
1970 dev->dev_addr[i] = ((char *)&this->mac_addr)[i];
1975 dev->name, this->base_addr, (int)dev->irq,
1980 this->net_type = IW_MODE_INFRA;
1981 this->bss_cnt = 0;
1982 this->join_sta_bss = 0;
1983 this->adhoc_times = 0;
1984 iw_set_mgmt_info_element(IW_MGMT_INFO_ELEMENT_SSID, &this->essid.el,
1986 this->card_name[0] = '\0';
1987 this->firmware_date[0] = '\0';
1988 this->rssi = 255;
1989 this->chan = iw_default_channel(this->reg_domain);
1990 strlcpy(this->nick, "Planet WL3501", sizeof(this->nick));
1991 spin_lock_init(&this->lock);
1992 init_waitqueue_head(&this->wait);
2006 * and release the PCMCIA configuration. If the device is still open, this