Lines Matching refs:dev
149 static void b43legacy_wireless_core_exit(struct b43legacy_wldev *dev);
150 static int b43legacy_wireless_core_init(struct b43legacy_wldev *dev);
151 static void b43legacy_wireless_core_stop(struct b43legacy_wldev *dev);
152 static int b43legacy_wireless_core_start(struct b43legacy_wldev *dev);
241 static void b43legacy_ram_write(struct b43legacy_wldev *dev, u16 offset,
248 status = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
252 b43legacy_write32(dev, B43legacy_MMIO_RAM_CONTROL, offset);
253 b43legacy_write32(dev, B43legacy_MMIO_RAM_DATA, val);
257 void b43legacy_shm_control_word(struct b43legacy_wldev *dev,
267 b43legacy_write32(dev, B43legacy_MMIO_SHM_CONTROL, control);
270 u32 b43legacy_shm_read32(struct b43legacy_wldev *dev,
279 b43legacy_shm_control_word(dev, routing, offset >> 2);
280 ret = b43legacy_read16(dev,
283 b43legacy_shm_control_word(dev, routing,
285 ret |= b43legacy_read16(dev, B43legacy_MMIO_SHM_DATA);
291 b43legacy_shm_control_word(dev, routing, offset);
292 ret = b43legacy_read32(dev, B43legacy_MMIO_SHM_DATA);
297 u16 b43legacy_shm_read16(struct b43legacy_wldev *dev,
306 b43legacy_shm_control_word(dev, routing, offset >> 2);
307 ret = b43legacy_read16(dev,
314 b43legacy_shm_control_word(dev, routing, offset);
315 ret = b43legacy_read16(dev, B43legacy_MMIO_SHM_DATA);
320 void b43legacy_shm_write32(struct b43legacy_wldev *dev,
328 b43legacy_shm_control_word(dev, routing, offset >> 2);
329 b43legacy_write16(dev,
332 b43legacy_shm_control_word(dev, routing,
334 b43legacy_write16(dev, B43legacy_MMIO_SHM_DATA,
340 b43legacy_shm_control_word(dev, routing, offset);
341 b43legacy_write32(dev, B43legacy_MMIO_SHM_DATA, value);
344 void b43legacy_shm_write16(struct b43legacy_wldev *dev, u16 routing, u16 offset,
351 b43legacy_shm_control_word(dev, routing, offset >> 2);
352 b43legacy_write16(dev,
359 b43legacy_shm_control_word(dev, routing, offset);
360 b43legacy_write16(dev, B43legacy_MMIO_SHM_DATA, value);
364 u32 b43legacy_hf_read(struct b43legacy_wldev *dev)
368 ret = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
371 ret |= b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
378 void b43legacy_hf_write(struct b43legacy_wldev *dev, u32 value)
380 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
383 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
388 void b43legacy_tsf_read(struct b43legacy_wldev *dev, u64 *tsf)
396 if (dev->dev->id.revision >= 3) {
402 high = b43legacy_read32(dev,
404 low = b43legacy_read32(dev,
406 high2 = b43legacy_read32(dev,
424 v3 = b43legacy_read16(dev, B43legacy_MMIO_TSF_3);
425 v2 = b43legacy_read16(dev, B43legacy_MMIO_TSF_2);
426 v1 = b43legacy_read16(dev, B43legacy_MMIO_TSF_1);
427 v0 = b43legacy_read16(dev, B43legacy_MMIO_TSF_0);
429 test3 = b43legacy_read16(dev, B43legacy_MMIO_TSF_3);
430 test2 = b43legacy_read16(dev, B43legacy_MMIO_TSF_2);
431 test1 = b43legacy_read16(dev, B43legacy_MMIO_TSF_1);
446 static void b43legacy_time_lock(struct b43legacy_wldev *dev)
450 status = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
452 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, status);
455 static void b43legacy_time_unlock(struct b43legacy_wldev *dev)
459 status = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
461 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, status);
464 static void b43legacy_tsf_write_locked(struct b43legacy_wldev *dev, u64 tsf)
470 if (dev->dev->id.revision >= 3) {
474 b43legacy_write32(dev, B43legacy_MMIO_REV3PLUS_TSF_LOW, 0);
475 b43legacy_write32(dev, B43legacy_MMIO_REV3PLUS_TSF_HIGH,
477 b43legacy_write32(dev, B43legacy_MMIO_REV3PLUS_TSF_LOW,
485 b43legacy_write16(dev, B43legacy_MMIO_TSF_0, 0);
486 b43legacy_write16(dev, B43legacy_MMIO_TSF_3, v3);
487 b43legacy_write16(dev, B43legacy_MMIO_TSF_2, v2);
488 b43legacy_write16(dev, B43legacy_MMIO_TSF_1, v1);
489 b43legacy_write16(dev, B43legacy_MMIO_TSF_0, v0);
493 void b43legacy_tsf_write(struct b43legacy_wldev *dev, u64 tsf)
495 b43legacy_time_lock(dev);
496 b43legacy_tsf_write_locked(dev, tsf);
497 b43legacy_time_unlock(dev);
501 void b43legacy_macfilter_set(struct b43legacy_wldev *dev,
511 b43legacy_write16(dev, B43legacy_MMIO_MACFILTER_CONTROL, offset);
515 b43legacy_write16(dev, B43legacy_MMIO_MACFILTER_DATA, data);
518 b43legacy_write16(dev, B43legacy_MMIO_MACFILTER_DATA, data);
521 b43legacy_write16(dev, B43legacy_MMIO_MACFILTER_DATA, data);
524 static void b43legacy_write_mac_bssid_templates(struct b43legacy_wldev *dev)
527 const u8 *mac = dev->wl->mac_addr;
528 const u8 *bssid = dev->wl->bssid;
538 b43legacy_macfilter_set(dev, B43legacy_MACFILTER_BSSID, bssid);
549 b43legacy_ram_write(dev, 0x20 + i, tmp);
550 b43legacy_ram_write(dev, 0x78 + i, tmp);
551 b43legacy_ram_write(dev, 0x478 + i, tmp);
555 static void b43legacy_upload_card_macaddress(struct b43legacy_wldev *dev)
557 b43legacy_write_mac_bssid_templates(dev);
558 b43legacy_macfilter_set(dev, B43legacy_MACFILTER_SELF,
559 dev->wl->mac_addr);
562 static void b43legacy_set_slot_time(struct b43legacy_wldev *dev,
566 if (dev->phy.type != B43legacy_PHYTYPE_G)
568 b43legacy_write16(dev, 0x684, 510 + slot_time);
569 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, 0x0010,
573 static void b43legacy_short_slot_timing_enable(struct b43legacy_wldev *dev)
575 b43legacy_set_slot_time(dev, 9);
578 static void b43legacy_short_slot_timing_disable(struct b43legacy_wldev *dev)
580 b43legacy_set_slot_time(dev, 20);
587 static void b43legacy_synchronize_irq(struct b43legacy_wldev *dev)
589 synchronize_irq(dev->dev->irq);
590 tasklet_kill(&dev->isr_tasklet);
596 void b43legacy_dummy_transmission(struct b43legacy_wldev *dev)
598 struct b43legacy_phy *phy = &dev->phy;
622 b43legacy_ram_write(dev, i * 4, buffer[i]);
625 b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
627 b43legacy_write16(dev, 0x0568, 0x0000);
628 b43legacy_write16(dev, 0x07C0, 0x0000);
629 b43legacy_write16(dev, 0x050C, 0x0000);
630 b43legacy_write16(dev, 0x0508, 0x0000);
631 b43legacy_write16(dev, 0x050A, 0x0000);
632 b43legacy_write16(dev, 0x054C, 0x0000);
633 b43legacy_write16(dev, 0x056A, 0x0014);
634 b43legacy_write16(dev, 0x0568, 0x0826);
635 b43legacy_write16(dev, 0x0500, 0x0000);
636 b43legacy_write16(dev, 0x0502, 0x0030);
639 b43legacy_radio_write16(dev, 0x0051, 0x0017);
641 value = b43legacy_read16(dev, 0x050E);
647 value = b43legacy_read16(dev, 0x050E);
653 value = b43legacy_read16(dev, 0x0690);
659 b43legacy_radio_write16(dev, 0x0051, 0x0037);
663 static void b43legacy_switch_analog(struct b43legacy_wldev *dev, int on)
665 b43legacy_write16(dev, B43legacy_MMIO_PHY0, on ? 0 : 0xF4);
668 void b43legacy_wireless_core_reset(struct b43legacy_wldev *dev, u32 flags)
675 ssb_device_enable(dev->dev, flags);
679 tmslow = ssb_read32(dev->dev, SSB_TMSLOW);
682 ssb_write32(dev->dev, SSB_TMSLOW, tmslow);
683 ssb_read32(dev->dev, SSB_TMSLOW); /* flush */
686 ssb_write32(dev->dev, SSB_TMSLOW, tmslow);
687 ssb_read32(dev->dev, SSB_TMSLOW); /* flush */
691 b43legacy_switch_analog(dev, 1);
693 macctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
697 dev->phy.gmode = true;
699 dev->phy.gmode = false;
701 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
704 static void handle_irq_transmit_status(struct b43legacy_wldev *dev)
712 v0 = b43legacy_read32(dev, B43legacy_MMIO_XMITSTAT_0);
715 v1 = b43legacy_read32(dev, B43legacy_MMIO_XMITSTAT_1);
729 b43legacy_handle_txstatus(dev, &stat);
733 static void drain_txstatus_queue(struct b43legacy_wldev *dev)
737 if (dev->dev->id.revision < 5)
743 dummy = b43legacy_read32(dev, B43legacy_MMIO_XMITSTAT_0);
746 dummy = b43legacy_read32(dev, B43legacy_MMIO_XMITSTAT_1);
750 static u32 b43legacy_jssi_read(struct b43legacy_wldev *dev)
754 val = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED, 0x40A);
756 val |= b43legacy_shm_read16(dev, B43legacy_SHM_SHARED, 0x408);
761 static void b43legacy_jssi_write(struct b43legacy_wldev *dev, u32 jssi)
763 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, 0x408,
765 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, 0x40A,
769 static void b43legacy_generate_noise_sample(struct b43legacy_wldev *dev)
771 b43legacy_jssi_write(dev, 0x7F7F7F7F);
772 b43legacy_write32(dev, B43legacy_MMIO_MACCMD,
773 b43legacy_read32(dev, B43legacy_MMIO_MACCMD)
775 B43legacy_WARN_ON(dev->noisecalc.channel_at_start !=
776 dev->phy.channel);
779 static void b43legacy_calculate_link_quality(struct b43legacy_wldev *dev)
783 if (dev->noisecalc.calculation_running)
785 dev->noisecalc.channel_at_start = dev->phy.channel;
786 dev->noisecalc.calculation_running = true;
787 dev->noisecalc.nr_samples = 0;
789 b43legacy_generate_noise_sample(dev);
792 static void handle_irq_noise(struct b43legacy_wldev *dev)
794 struct b43legacy_phy *phy = &dev->phy;
803 B43legacy_WARN_ON(!dev->noisecalc.calculation_running);
804 if (dev->noisecalc.channel_at_start != phy->channel)
806 *((__le32 *)noise) = cpu_to_le32(b43legacy_jssi_read(dev));
812 B43legacy_WARN_ON(dev->noisecalc.nr_samples >= 8);
813 i = dev->noisecalc.nr_samples;
818 dev->noisecalc.samples[i][0] = phy->nrssi_lt[noise[0]];
819 dev->noisecalc.samples[i][1] = phy->nrssi_lt[noise[1]];
820 dev->noisecalc.samples[i][2] = phy->nrssi_lt[noise[2]];
821 dev->noisecalc.samples[i][3] = phy->nrssi_lt[noise[3]];
822 dev->noisecalc.nr_samples++;
823 if (dev->noisecalc.nr_samples == 8) {
828 average += dev->noisecalc.samples[i][j];
834 tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
846 dev->stats.link_noise = average;
848 dev->noisecalc.calculation_running = false;
852 b43legacy_generate_noise_sample(dev);
855 static void handle_irq_tbtt_indication(struct b43legacy_wldev *dev)
857 if (b43legacy_is_mode(dev->wl, NL80211_IFTYPE_AP)) {
861 b43legacy_power_saving_ctl_bits(dev, -1, -1);
863 if (b43legacy_is_mode(dev->wl, NL80211_IFTYPE_ADHOC))
864 dev->dfq_valid = true;
867 static void handle_irq_atim_end(struct b43legacy_wldev *dev)
869 if (dev->dfq_valid) {
870 b43legacy_write32(dev, B43legacy_MMIO_MACCMD,
871 b43legacy_read32(dev, B43legacy_MMIO_MACCMD)
873 dev->dfq_valid = false;
877 static void handle_irq_pmq(struct b43legacy_wldev *dev)
884 tmp = b43legacy_read32(dev, B43legacy_MMIO_PS_STATUS);
889 b43legacy_write16(dev, B43legacy_MMIO_PS_STATUS, 0x0002);
892 static void b43legacy_write_template_common(struct b43legacy_wldev *dev,
903 b43legacy_ram_write(dev, ram_offset, le32_to_cpu(plcp.data));
910 b43legacy_ram_write(dev, ram_offset, tmp);
920 b43legacy_ram_write(dev, ram_offset + i - 2, tmp);
922 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, shm_size_offset,
938 static void b43legacy_write_beacon_template(struct b43legacy_wldev *dev,
950 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(dev->wl->current_beacon);
952 bcn = (const struct ieee80211_mgmt *)(dev->wl->current_beacon->data);
953 len = min_t(size_t, dev->wl->current_beacon->len,
955 rate = ieee80211_get_tx_rate(dev->wl->hw, info)->hw_value;
957 b43legacy_write_template_common(dev, (const u8 *)bcn, len, ram_offset,
963 ctl = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
971 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
1003 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
1005 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
1012 b43legacywarn(dev->wl, "Did not find a valid TIM IE in the "
1016 b43legacydbg(dev->wl, "Updated beacon template\n");
1019 static void b43legacy_write_probe_resp_plcp(struct b43legacy_wldev *dev,
1029 dur = ieee80211_generic_frame_duration(dev->wl->hw,
1030 dev->wl->vif,
1036 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, shm_offset,
1038 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, shm_offset + 2,
1040 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, shm_offset + 6,
1050 static const u8 *b43legacy_generate_probe_resp(struct b43legacy_wldev *dev,
1061 src_size = dev->wl->current_beacon->len;
1062 src_data = (const u8 *)dev->wl->current_beacon->data;
1095 dur = ieee80211_generic_frame_duration(dev->wl->hw,
1096 dev->wl->vif,
1105 static void b43legacy_write_probe_resp_template(struct b43legacy_wldev *dev,
1113 size = dev->wl->current_beacon->len;
1114 probe_resp_data = b43legacy_generate_probe_resp(dev, &size, rate);
1121 b43legacy_write_probe_resp_plcp(dev, 0x31A, size,
1123 b43legacy_write_probe_resp_plcp(dev, 0x32C, size,
1125 b43legacy_write_probe_resp_plcp(dev, 0x33E, size,
1127 b43legacy_write_probe_resp_plcp(dev, 0x350, size,
1132 b43legacy_write_template_common(dev, probe_resp_data,
1138 static void b43legacy_upload_beacon0(struct b43legacy_wldev *dev)
1140 struct b43legacy_wl *wl = dev->wl;
1144 b43legacy_write_beacon_template(dev, 0x68, 0x18);
1147 b43legacy_write_probe_resp_template(dev, 0x268, 0x4A,
1152 static void b43legacy_upload_beacon1(struct b43legacy_wldev *dev)
1154 struct b43legacy_wl *wl = dev->wl;
1158 b43legacy_write_beacon_template(dev, 0x468, 0x1A);
1162 static void handle_irq_beacon(struct b43legacy_wldev *dev)
1164 struct b43legacy_wl *wl = dev->wl;
1173 dev->irq_mask &= ~B43legacy_IRQ_BEACON;
1175 cmd = b43legacy_read32(dev, B43legacy_MMIO_MACCMD);
1181 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_REASON, B43legacy_IRQ_BEACON);
1182 dev->irq_mask |= B43legacy_IRQ_BEACON;
1190 b43legacy_upload_beacon0(dev);
1191 b43legacy_upload_beacon1(dev);
1192 cmd = b43legacy_read32(dev, B43legacy_MMIO_MACCMD);
1194 b43legacy_write32(dev, B43legacy_MMIO_MACCMD, cmd);
1197 b43legacy_upload_beacon0(dev);
1198 cmd = b43legacy_read32(dev, B43legacy_MMIO_MACCMD);
1200 b43legacy_write32(dev, B43legacy_MMIO_MACCMD, cmd);
1202 b43legacy_upload_beacon1(dev);
1203 cmd = b43legacy_read32(dev, B43legacy_MMIO_MACCMD);
1205 b43legacy_write32(dev, B43legacy_MMIO_MACCMD, cmd);
1214 struct b43legacy_wldev *dev;
1217 dev = wl->current_dev;
1218 if (likely(dev && (b43legacy_status(dev) >= B43legacy_STAT_INITIALIZED))) {
1221 handle_irq_beacon(dev);
1223 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK,
1224 dev->irq_mask);
1256 static void b43legacy_set_beacon_int(struct b43legacy_wldev *dev,
1259 b43legacy_time_lock(dev);
1260 if (dev->dev->id.revision >= 3) {
1261 b43legacy_write32(dev, B43legacy_MMIO_TSF_CFP_REP,
1263 b43legacy_write32(dev, B43legacy_MMIO_TSF_CFP_START,
1266 b43legacy_write16(dev, 0x606, (beacon_int >> 6));
1267 b43legacy_write16(dev, 0x610, beacon_int);
1269 b43legacy_time_unlock(dev);
1270 b43legacydbg(dev->wl, "Set beacon interval to %u\n", beacon_int);
1273 static void handle_irq_ucode_debug(struct b43legacy_wldev *dev)
1280 struct b43legacy_wldev *dev = from_tasklet(dev, t, isr_tasklet);
1282 u32 dma_reason[ARRAY_SIZE(dev->dma_reason)];
1287 spin_lock_irqsave(&dev->wl->irq_lock, flags);
1289 B43legacy_WARN_ON(b43legacy_status(dev) <
1292 reason = dev->irq_reason;
1294 dma_reason[i] = dev->dma_reason[i];
1299 b43legacyerr(dev->wl, "MAC transmission error\n");
1302 b43legacyerr(dev->wl, "PHY transmission error\n");
1304 if (unlikely(atomic_dec_and_test(&dev->phy.txerr_cnt))) {
1305 b43legacyerr(dev->wl, "Too many PHY TX errors, "
1307 b43legacy_controller_restart(dev, "PHY TX errors");
1314 b43legacyerr(dev->wl, "Fatal DMA error: "
1320 b43legacy_controller_restart(dev, "DMA error");
1321 spin_unlock_irqrestore(&dev->wl->irq_lock, flags);
1325 b43legacyerr(dev->wl, "DMA error: "
1334 handle_irq_ucode_debug(dev);
1336 handle_irq_tbtt_indication(dev);
1338 handle_irq_atim_end(dev);
1340 handle_irq_beacon(dev);
1342 handle_irq_pmq(dev);
1347 handle_irq_noise(dev);
1351 if (b43legacy_using_pio(dev))
1352 b43legacy_pio_rx(dev->pio.queue0);
1354 b43legacy_dma_rx(dev->dma.rx_ring0);
1359 if (b43legacy_using_pio(dev))
1360 b43legacy_pio_rx(dev->pio.queue3);
1362 b43legacy_dma_rx(dev->dma.rx_ring3);
1368 handle_irq_transmit_status(dev);
1370 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, dev->irq_mask);
1371 spin_unlock_irqrestore(&dev->wl->irq_lock, flags);
1374 static void pio_irq_workaround(struct b43legacy_wldev *dev,
1379 rxctl = b43legacy_read16(dev, base + B43legacy_PIO_RXCTL);
1381 dev->dma_reason[queueidx] |= B43legacy_DMAIRQ_RX_DONE;
1383 dev->dma_reason[queueidx] &= ~B43legacy_DMAIRQ_RX_DONE;
1386 static void b43legacy_interrupt_ack(struct b43legacy_wldev *dev, u32 reason)
1388 if (b43legacy_using_pio(dev) &&
1389 (dev->dev->id.revision < 3) &&
1392 pio_irq_workaround(dev, B43legacy_MMIO_PIO1_BASE, 0);
1393 pio_irq_workaround(dev, B43legacy_MMIO_PIO2_BASE, 1);
1394 pio_irq_workaround(dev, B43legacy_MMIO_PIO3_BASE, 2);
1395 pio_irq_workaround(dev, B43legacy_MMIO_PIO4_BASE, 3);
1398 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_REASON, reason);
1400 b43legacy_write32(dev, B43legacy_MMIO_DMA0_REASON,
1401 dev->dma_reason[0]);
1402 b43legacy_write32(dev, B43legacy_MMIO_DMA1_REASON,
1403 dev->dma_reason[1]);
1404 b43legacy_write32(dev, B43legacy_MMIO_DMA2_REASON,
1405 dev->dma_reason[2]);
1406 b43legacy_write32(dev, B43legacy_MMIO_DMA3_REASON,
1407 dev->dma_reason[3]);
1408 b43legacy_write32(dev, B43legacy_MMIO_DMA4_REASON,
1409 dev->dma_reason[4]);
1410 b43legacy_write32(dev, B43legacy_MMIO_DMA5_REASON,
1411 dev->dma_reason[5]);
1418 struct b43legacy_wldev *dev = dev_id;
1421 B43legacy_WARN_ON(!dev);
1423 spin_lock(&dev->wl->irq_lock);
1425 if (unlikely(b43legacy_status(dev) < B43legacy_STAT_STARTED))
1428 reason = b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
1432 reason &= dev->irq_mask;
1436 dev->dma_reason[0] = b43legacy_read32(dev,
1439 dev->dma_reason[1] = b43legacy_read32(dev,
1442 dev->dma_reason[2] = b43legacy_read32(dev,
1445 dev->dma_reason[3] = b43legacy_read32(dev,
1448 dev->dma_reason[4] = b43legacy_read32(dev,
1451 dev->dma_reason[5] = b43legacy_read32(dev,
1455 b43legacy_interrupt_ack(dev, reason);
1457 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, 0);
1459 dev->irq_reason = reason;
1460 tasklet_schedule(&dev->isr_tasklet);
1462 spin_unlock(&dev->wl->irq_lock);
1467 static void b43legacy_release_firmware(struct b43legacy_wldev *dev)
1469 release_firmware(dev->fw.ucode);
1470 dev->fw.ucode = NULL;
1471 release_firmware(dev->fw.pcm);
1472 dev->fw.pcm = NULL;
1473 release_firmware(dev->fw.initvals);
1474 dev->fw.initvals = NULL;
1475 release_firmware(dev->fw.initvals_band);
1476 dev->fw.initvals_band = NULL;
1488 struct b43legacy_wldev *dev = context;
1490 dev->fwp = firmware;
1491 complete(&dev->fw_load_complete);
1494 static int do_request_fw(struct b43legacy_wldev *dev,
1509 b43legacyinfo(dev->wl, "Loading firmware %s\n", path);
1511 init_completion(&dev->fw_load_complete);
1513 dev->dev->dev, GFP_KERNEL,
1514 dev, b43legacy_fw_cb);
1516 b43legacyerr(dev->wl, "Unable to load firmware\n");
1520 wait_for_completion(&dev->fw_load_complete);
1521 if (!dev->fwp)
1523 *fw = dev->fwp;
1525 err = request_firmware(fw, path, dev->dev->dev);
1528 b43legacyerr(dev->wl, "Firmware file \"%s\" not found "
1553 b43legacyerr(dev->wl, "Firmware file \"%s\" format error.\n", path);
1557 static int b43legacy_one_core_attach(struct ssb_device *dev,
1559 static void b43legacy_one_core_detach(struct ssb_device *dev);
1565 struct b43legacy_wldev *dev = wl->current_dev;
1566 struct b43legacy_firmware *fw = &dev->fw;
1567 const u8 rev = dev->dev->id.revision;
1578 err = do_request_fw(dev, filename, &fw->ucode, true);
1587 err = do_request_fw(dev, filename, &fw->pcm, false);
1592 switch (dev->phy.type) {
1605 err = do_request_fw(dev, filename, &fw->initvals, false);
1610 switch (dev->phy.type) {
1625 err = do_request_fw(dev, filename, &fw->initvals_band, false);
1635 b43legacy_one_core_detach(dev->dev);
1639 b43legacy_print_fw_helptext(dev->wl);
1644 b43legacyerr(dev->wl, "No Initial Values firmware file for PHY %u, "
1645 "core rev %u\n", dev->phy.type, rev);
1649 b43legacy_release_firmware(dev);
1653 static int b43legacy_upload_microcode(struct b43legacy_wldev *dev)
1655 struct wiphy *wiphy = dev->wl->hw->wiphy;
1668 macctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
1671 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
1674 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, i, 0);
1676 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, i, 0);
1679 data = (__be32 *) (dev->fw.ucode->data + hdr_len);
1680 len = (dev->fw.ucode->size - hdr_len) / sizeof(__be32);
1681 b43legacy_shm_control_word(dev,
1686 b43legacy_write32(dev, B43legacy_MMIO_SHM_DATA,
1691 if (dev->fw.pcm) {
1693 data = (__be32 *) (dev->fw.pcm->data + hdr_len);
1694 len = (dev->fw.pcm->size - hdr_len) / sizeof(__be32);
1695 b43legacy_shm_control_word(dev, B43legacy_SHM_HW, 0x01EA);
1696 b43legacy_write32(dev, B43legacy_MMIO_SHM_DATA, 0x00004000);
1698 b43legacy_shm_control_word(dev, B43legacy_SHM_HW, 0x01EB);
1700 b43legacy_write32(dev, B43legacy_MMIO_SHM_DATA,
1706 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_REASON,
1710 macctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
1713 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
1718 tmp = b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
1723 b43legacyerr(dev->wl, "Microcode not responding\n");
1724 b43legacy_print_fw_helptext(dev->wl);
1735 b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
1738 fwrev = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
1740 fwpatch = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
1742 fwdate = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
1744 fwtime = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
1748 b43legacyerr(dev->wl, "YOU ARE TRYING TO LOAD V4 FIRMWARE."
1752 b43legacy_print_fw_helptext(dev->wl);
1756 b43legacyinfo(dev->wl, "Loading firmware version 0x%X, patch level %u "
1762 dev->fw.rev = fwrev;
1763 dev->fw.patch = fwpatch;
1766 dev->fw.rev, dev->fw.patch);
1767 wiphy->hw_version = dev->dev->id.coreid;
1772 macctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
1775 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
1780 static int b43legacy_write_initvals(struct b43legacy_wldev *dev,
1809 b43legacy_write32(dev, offset, value);
1822 b43legacy_write16(dev, offset, value);
1835 b43legacyerr(dev->wl, "Initial Values Firmware file-format error.\n");
1836 b43legacy_print_fw_helptext(dev->wl);
1841 static int b43legacy_upload_initvals(struct b43legacy_wldev *dev)
1845 struct b43legacy_firmware *fw = &dev->fw;
1853 err = b43legacy_write_initvals(dev, ivals, count,
1863 err = b43legacy_write_initvals(dev, ivals, count,
1876 static int b43legacy_gpio_init(struct b43legacy_wldev *dev)
1878 struct ssb_bus *bus = dev->dev->bus;
1883 b43legacy_write32(dev, B43legacy_MMIO_MACCTL,
1884 b43legacy_read32(dev,
1888 b43legacy_write16(dev, B43legacy_MMIO_GPIO_MASK,
1889 b43legacy_read16(dev,
1895 if (dev->dev->bus->chip_id == 0x4301) {
1899 if (dev->dev->bus->sprom.boardflags_lo & B43legacy_BFL_PACTRL) {
1900 b43legacy_write16(dev, B43legacy_MMIO_GPIO_MASK,
1901 b43legacy_read16(dev,
1907 if (dev->dev->id.revision >= 2)
1911 pcidev = bus->pcicore.dev;
1913 gpiodev = bus->chipco.dev ? : pcidev;
1924 static void b43legacy_gpio_cleanup(struct b43legacy_wldev *dev)
1926 struct ssb_bus *bus = dev->dev->bus;
1930 pcidev = bus->pcicore.dev;
1932 gpiodev = bus->chipco.dev ? : pcidev;
1939 void b43legacy_mac_enable(struct b43legacy_wldev *dev)
1941 dev->mac_suspended--;
1942 B43legacy_WARN_ON(dev->mac_suspended < 0);
1944 if (dev->mac_suspended == 0) {
1945 b43legacy_write32(dev, B43legacy_MMIO_MACCTL,
1946 b43legacy_read32(dev,
1949 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_REASON,
1952 b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
1953 b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
1954 b43legacy_power_saving_ctl_bits(dev, -1, -1);
1957 spin_lock_irq(&dev->wl->irq_lock);
1958 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK,
1959 dev->irq_mask);
1960 spin_unlock_irq(&dev->wl->irq_lock);
1965 void b43legacy_mac_suspend(struct b43legacy_wldev *dev)
1972 B43legacy_WARN_ON(dev->mac_suspended < 0);
1974 if (dev->mac_suspended == 0) {
1977 spin_lock_irq(&dev->wl->irq_lock);
1978 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, 0);
1979 spin_unlock_irq(&dev->wl->irq_lock);
1980 b43legacy_synchronize_irq(dev);
1982 b43legacy_power_saving_ctl_bits(dev, -1, 1);
1983 b43legacy_write32(dev, B43legacy_MMIO_MACCTL,
1984 b43legacy_read32(dev,
1987 b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
1989 tmp = b43legacy_read32(dev,
1995 b43legacyerr(dev->wl, "MAC suspend failed\n");
1998 dev->mac_suspended++;
2001 static void b43legacy_adjust_opmode(struct b43legacy_wldev *dev)
2003 struct b43legacy_wl *wl = dev->wl;
2007 ctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
2034 if (dev->dev->id.revision <= 4)
2037 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, ctl);
2042 if (dev->dev->bus->chip_id == 0x4306 &&
2043 dev->dev->bus->chip_rev == 3)
2048 b43legacy_write16(dev, 0x612, cfp_pretbtt);
2051 static void b43legacy_rate_memory_write(struct b43legacy_wldev *dev,
2064 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, offset + 0x20,
2065 b43legacy_shm_read16(dev,
2069 static void b43legacy_rate_memory_init(struct b43legacy_wldev *dev)
2071 switch (dev->phy.type) {
2073 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_6MB, 1);
2074 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_12MB, 1);
2075 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_18MB, 1);
2076 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_24MB, 1);
2077 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_36MB, 1);
2078 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_48MB, 1);
2079 b43legacy_rate_memory_write(dev, B43legacy_OFDM_RATE_54MB, 1);
2082 b43legacy_rate_memory_write(dev, B43legacy_CCK_RATE_1MB, 0);
2083 b43legacy_rate_memory_write(dev, B43legacy_CCK_RATE_2MB, 0);
2084 b43legacy_rate_memory_write(dev, B43legacy_CCK_RATE_5MB, 0);
2085 b43legacy_rate_memory_write(dev, B43legacy_CCK_RATE_11MB, 0);
2093 static void b43legacy_mgmtframe_txantenna(struct b43legacy_wldev *dev,
2117 tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
2120 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
2123 tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
2126 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
2129 tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
2132 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
2137 static void b43legacy_chip_exit(struct b43legacy_wldev *dev)
2139 b43legacy_radio_turn_off(dev, 1);
2140 b43legacy_gpio_cleanup(dev);
2147 static int b43legacy_chip_init(struct b43legacy_wldev *dev)
2149 struct b43legacy_phy *phy = &dev->phy;
2157 if (dev->phy.gmode)
2160 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
2162 err = b43legacy_upload_microcode(dev);
2166 err = b43legacy_gpio_init(dev);
2170 err = b43legacy_upload_initvals(dev);
2173 b43legacy_radio_turn_on(dev);
2175 b43legacy_write16(dev, 0x03E6, 0x0000);
2176 err = b43legacy_phy_init(dev);
2183 b43legacy_radio_set_interference_mitigation(dev, tmp);
2185 b43legacy_phy_set_antenna_diversity(dev);
2186 b43legacy_mgmtframe_txantenna(dev, B43legacy_ANTENNA_DEFAULT);
2189 value16 = b43legacy_read16(dev, 0x005E);
2191 b43legacy_write16(dev, 0x005E, value16);
2193 b43legacy_write32(dev, 0x0100, 0x01000000);
2194 if (dev->dev->id.revision < 5)
2195 b43legacy_write32(dev, 0x010C, 0x01000000);
2197 value32 = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
2199 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, value32);
2200 value32 = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
2202 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, value32);
2204 if (b43legacy_using_pio(dev)) {
2205 b43legacy_write32(dev, 0x0210, 0x00000100);
2206 b43legacy_write32(dev, 0x0230, 0x00000100);
2207 b43legacy_write32(dev, 0x0250, 0x00000100);
2208 b43legacy_write32(dev, 0x0270, 0x00000100);
2209 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, 0x0034,
2215 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED, 0x0074, 0x0000);
2218 b43legacy_adjust_opmode(dev);
2220 if (dev->dev->id.revision < 3) {
2221 b43legacy_write16(dev, 0x060E, 0x0000);
2222 b43legacy_write16(dev, 0x0610, 0x8000);
2223 b43legacy_write16(dev, 0x0604, 0x0000);
2224 b43legacy_write16(dev, 0x0606, 0x0200);
2226 b43legacy_write32(dev, 0x0188, 0x80000000);
2227 b43legacy_write32(dev, 0x018C, 0x02000000);
2229 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_REASON, 0x00004000);
2230 b43legacy_write32(dev, B43legacy_MMIO_DMA0_IRQ_MASK, 0x0001DC00);
2231 b43legacy_write32(dev, B43legacy_MMIO_DMA1_IRQ_MASK, 0x0000DC00);
2232 b43legacy_write32(dev, B43legacy_MMIO_DMA2_IRQ_MASK, 0x0000DC00);
2233 b43legacy_write32(dev, B43legacy_MMIO_DMA3_IRQ_MASK, 0x0001DC00);
2234 b43legacy_write32(dev, B43legacy_MMIO_DMA4_IRQ_MASK, 0x0000DC00);
2235 b43legacy_write32(dev, B43legacy_MMIO_DMA5_IRQ_MASK, 0x0000DC00);
2237 value32 = ssb_read32(dev->dev, SSB_TMSLOW);
2239 ssb_write32(dev->dev, SSB_TMSLOW, value32);
2241 b43legacy_write16(dev, B43legacy_MMIO_POWERUP_DELAY,
2242 dev->dev->bus->chipco.fast_pwrup_delay);
2248 b43legacydbg(dev->wl, "Chip initialized\n");
2253 b43legacy_radio_turn_off(dev, 1);
2255 b43legacy_gpio_cleanup(dev);
2259 static void b43legacy_periodic_every120sec(struct b43legacy_wldev *dev)
2261 struct b43legacy_phy *phy = &dev->phy;
2266 b43legacy_mac_suspend(dev);
2267 b43legacy_phy_lo_g_measure(dev);
2268 b43legacy_mac_enable(dev);
2271 static void b43legacy_periodic_every60sec(struct b43legacy_wldev *dev)
2273 b43legacy_phy_lo_mark_all_unused(dev);
2274 if (dev->dev->bus->sprom.boardflags_lo & B43legacy_BFL_RSSI) {
2275 b43legacy_mac_suspend(dev);
2276 b43legacy_calc_nrssi_slope(dev);
2277 b43legacy_mac_enable(dev);
2281 static void b43legacy_periodic_every30sec(struct b43legacy_wldev *dev)
2284 b43legacy_calculate_link_quality(dev);
2287 static void b43legacy_periodic_every15sec(struct b43legacy_wldev *dev)
2289 b43legacy_phy_xmitpower(dev); /* FIXME: unless scanning? */
2291 atomic_set(&dev->phy.txerr_cnt, B43legacy_PHY_TX_BADNESS_LIMIT);
2295 static void do_periodic_work(struct b43legacy_wldev *dev)
2299 state = dev->periodic_state;
2301 b43legacy_periodic_every120sec(dev);
2303 b43legacy_periodic_every60sec(dev);
2305 b43legacy_periodic_every30sec(dev);
2306 b43legacy_periodic_every15sec(dev);
2316 struct b43legacy_wldev *dev = container_of(work, struct b43legacy_wldev,
2318 struct b43legacy_wl *wl = dev->wl;
2323 if (unlikely(b43legacy_status(dev) != B43legacy_STAT_STARTED))
2325 if (b43legacy_debug(dev, B43legacy_DBG_PWORK_STOP))
2328 do_periodic_work(dev);
2330 dev->periodic_state++;
2332 if (b43legacy_debug(dev, B43legacy_DBG_PWORK_FAST))
2336 ieee80211_queue_delayed_work(wl->hw, &dev->periodic_work, delay);
2341 static void b43legacy_periodic_tasks_setup(struct b43legacy_wldev *dev)
2343 struct delayed_work *work = &dev->periodic_work;
2345 dev->periodic_state = 0;
2347 ieee80211_queue_delayed_work(dev->wl->hw, work, 0);
2351 static int b43legacy_validate_chipaccess(struct b43legacy_wldev *dev)
2356 shm_backup = b43legacy_shm_read32(dev, B43legacy_SHM_SHARED, 0);
2357 b43legacy_shm_write32(dev, B43legacy_SHM_SHARED, 0, 0xAA5555AA);
2358 if (b43legacy_shm_read32(dev, B43legacy_SHM_SHARED, 0) !=
2361 b43legacy_shm_write32(dev, B43legacy_SHM_SHARED, 0, 0x55AAAA55);
2362 if (b43legacy_shm_read32(dev, B43legacy_SHM_SHARED, 0) !=
2365 b43legacy_shm_write32(dev, B43legacy_SHM_SHARED, 0, shm_backup);
2367 value = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
2372 value = b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_REASON);
2378 b43legacyerr(dev->wl, "Failed to validate the chipaccess\n");
2382 static void b43legacy_security_init(struct b43legacy_wldev *dev)
2384 dev->max_nr_keys = (dev->dev->id.revision >= 5) ? 58 : 20;
2385 B43legacy_WARN_ON(dev->max_nr_keys > ARRAY_SIZE(dev->key));
2386 dev->ktp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
2391 dev->ktp *= 2;
2392 if (dev->dev->id.revision >= 5)
2394 b43legacy_write16(dev, B43legacy_MMIO_RCMTA_COUNT,
2395 dev->max_nr_keys - 8);
2450 struct b43legacy_wldev *dev;
2456 dev = wl->current_dev;
2457 if (unlikely(!dev || b43legacy_status(dev) < B43legacy_STAT_STARTED)) {
2465 if (b43legacy_using_pio(dev))
2466 err = b43legacy_pio_tx(dev, skb);
2468 err = b43legacy_dma_tx(dev, skb);
2542 struct b43legacy_wldev **dev,
2552 *dev = d;
2561 static void b43legacy_put_phy_into_reset(struct b43legacy_wldev *dev)
2563 struct ssb_device *sdev = dev->dev;
2651 static void b43legacy_set_retry_limits(struct b43legacy_wldev *dev,
2660 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0006, short_retry);
2661 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0007, long_retry);
2668 struct b43legacy_wldev *dev;
2679 dev = wl->current_dev;
2680 phy = &dev->phy;
2683 b43legacy_set_retry_limits(dev,
2709 if (b43legacy_status(dev) < B43legacy_STAT_STARTED) {
2713 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, 0);
2715 b43legacy_synchronize_irq(dev);
2720 b43legacy_radio_selectchannel(dev, conf->chandef.chan->hw_value,
2723 dev->wl->radiotap_enabled = !!(conf->flags & IEEE80211_CONF_MONITOR);
2729 b43legacy_phy_xmitpower(dev);
2734 b43legacy_mgmtframe_txantenna(dev, antenna_tx);
2738 b43legacy_radio_turn_on(dev);
2739 b43legacyinfo(dev->wl, "Radio turned on by software\n");
2740 if (!dev->radio_hw_enable)
2741 b43legacyinfo(dev->wl, "The hardware RF-kill"
2746 b43legacy_radio_turn_off(dev, 0);
2747 b43legacyinfo(dev->wl, "Radio turned off by"
2753 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, dev->irq_mask);
2761 static void b43legacy_update_basic_rates(struct b43legacy_wldev *dev, u32 brates)
2764 dev->wl->hw->wiphy->bands[NL80211_BAND_2GHZ];
2798 rateptr = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED,
2801 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
2812 struct b43legacy_wldev *dev;
2818 dev = wl->current_dev;
2824 if (b43legacy_status(dev) < B43legacy_STAT_STARTED) {
2828 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, 0);
2831 b43legacy_synchronize_irq(dev);
2839 if (b43legacy_status(dev) >= B43legacy_STAT_INITIALIZED) {
2846 b43legacy_write_mac_bssid_templates(dev);
2850 b43legacy_mac_suspend(dev);
2855 b43legacy_set_beacon_int(dev, conf->beacon_int);
2858 b43legacy_update_basic_rates(dev, conf->basic_rates);
2862 b43legacy_short_slot_timing_enable(dev);
2864 b43legacy_short_slot_timing_disable(dev);
2867 b43legacy_mac_enable(dev);
2870 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, dev->irq_mask);
2882 struct b43legacy_wldev *dev = wl->current_dev;
2885 if (!dev) {
2907 if (changed && b43legacy_status(dev) >= B43legacy_STAT_INITIALIZED)
2908 b43legacy_adjust_opmode(dev);
2913 static void b43legacy_wireless_core_stop(struct b43legacy_wldev *dev)
2915 struct b43legacy_wl *wl = dev->wl;
2919 if (b43legacy_status(dev) < B43legacy_STAT_STARTED)
2926 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, 0);
2927 b43legacy_read32(dev, B43legacy_MMIO_GEN_IRQ_MASK); /* flush */
2929 b43legacy_synchronize_irq(dev);
2931 b43legacy_set_status(dev, B43legacy_STAT_INITIALIZED);
2936 cancel_delayed_work_sync(&dev->periodic_work);
2946 b43legacy_mac_suspend(dev);
2947 free_irq(dev->dev->irq, dev);
2952 static int b43legacy_wireless_core_start(struct b43legacy_wldev *dev)
2956 B43legacy_WARN_ON(b43legacy_status(dev) != B43legacy_STAT_INITIALIZED);
2958 drain_txstatus_queue(dev);
2959 err = request_irq(dev->dev->irq, b43legacy_interrupt_handler,
2960 IRQF_SHARED, KBUILD_MODNAME, dev);
2962 b43legacyerr(dev->wl, "Cannot request IRQ-%d\n",
2963 dev->dev->irq);
2967 ieee80211_wake_queues(dev->wl->hw);
2968 b43legacy_set_status(dev, B43legacy_STAT_STARTED);
2971 b43legacy_mac_enable(dev);
2972 b43legacy_write32(dev, B43legacy_MMIO_GEN_IRQ_MASK, dev->irq_mask);
2975 b43legacy_periodic_tasks_setup(dev);
2977 b43legacydbg(dev->wl, "Wireless interface started\n");
2983 static int b43legacy_phy_versioning(struct b43legacy_wldev *dev)
2985 struct b43legacy_phy *phy = &dev->phy;
2996 tmp = b43legacy_read16(dev, B43legacy_MMIO_PHY_VER);
3015 b43legacyerr(dev->wl, "FOUND UNSUPPORTED PHY "
3020 b43legacydbg(dev->wl, "Found PHY: Analog %u, Type %u, Revision %u\n",
3025 if (dev->dev->bus->chip_id == 0x4317) {
3026 if (dev->dev->bus->chip_rev == 0)
3028 else if (dev->dev->bus->chip_rev == 1)
3033 b43legacy_write16(dev, B43legacy_MMIO_RADIO_CONTROL,
3035 tmp = b43legacy_read16(dev, B43legacy_MMIO_RADIO_DATA_HIGH);
3037 b43legacy_write16(dev, B43legacy_MMIO_RADIO_CONTROL,
3039 tmp |= b43legacy_read16(dev, B43legacy_MMIO_RADIO_DATA_LOW);
3057 b43legacyerr(dev->wl, "FOUND UNSUPPORTED RADIO "
3062 b43legacydbg(dev->wl, "Found Radio: Manuf 0x%X, Version 0x%X,"
3077 static void setup_struct_phy_for_init(struct b43legacy_wldev *dev,
3088 dev->radio_hw_enable = true;
3103 phy->bbatt = b43legacy_default_baseband_attenuation(dev);
3104 phy->rfatt = b43legacy_default_radio_attenuation(dev);
3105 phy->txctl1 = b43legacy_default_txctl1(dev);
3122 static void setup_struct_wldev_for_init(struct b43legacy_wldev *dev)
3125 dev->dfq_valid = false;
3128 memset(&dev->stats, 0, sizeof(dev->stats));
3130 setup_struct_phy_for_init(dev, &dev->phy);
3133 dev->irq_reason = 0;
3134 memset(dev->dma_reason, 0, sizeof(dev->dma_reason));
3135 dev->irq_mask = B43legacy_IRQ_MASKTEMPLATE;
3137 dev->mac_suspended = 1;
3140 memset(&dev->noisecalc, 0, sizeof(dev->noisecalc));
3143 static void b43legacy_set_synth_pu_delay(struct b43legacy_wldev *dev,
3147 if (b43legacy_is_mode(dev->wl, NL80211_IFTYPE_ADHOC) || idle)
3149 if ((dev->phy.radio_ver == 0x2050) && (dev->phy.radio_rev == 8))
3152 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3157 static void b43legacy_set_pretbtt(struct b43legacy_wldev *dev)
3162 if (b43legacy_is_mode(dev->wl, NL80211_IFTYPE_ADHOC))
3166 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3168 b43legacy_write16(dev, B43legacy_MMIO_TSF_CFP_PRETBTT, pretbtt);
3173 static void b43legacy_wireless_core_exit(struct b43legacy_wldev *dev)
3175 struct b43legacy_phy *phy = &dev->phy;
3178 B43legacy_WARN_ON(b43legacy_status(dev) > B43legacy_STAT_INITIALIZED);
3179 if (b43legacy_status(dev) != B43legacy_STAT_INITIALIZED)
3181 b43legacy_set_status(dev, B43legacy_STAT_UNINIT);
3184 macctl = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
3187 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, macctl);
3189 b43legacy_leds_exit(dev);
3190 b43legacy_rng_exit(dev->wl);
3191 b43legacy_pio_free(dev);
3192 b43legacy_dma_free(dev);
3193 b43legacy_chip_exit(dev);
3194 b43legacy_radio_turn_off(dev, 1);
3195 b43legacy_switch_analog(dev, 0);
3200 if (dev->wl->current_beacon) {
3201 dev_kfree_skb_any(dev->wl->current_beacon);
3202 dev->wl->current_beacon = NULL;
3205 ssb_device_disable(dev->dev, 0);
3206 ssb_bus_may_powerdown(dev->dev->bus);
3209 static void prepare_phy_data_for_init(struct b43legacy_wldev *dev)
3211 struct b43legacy_phy *phy = &dev->phy;
3215 phy->bbatt = b43legacy_default_baseband_attenuation(dev);
3216 phy->rfatt = b43legacy_default_radio_attenuation(dev);
3217 phy->txctl1 = b43legacy_default_txctl1(dev);
3249 static int b43legacy_wireless_core_init(struct b43legacy_wldev *dev)
3251 struct b43legacy_wl *wl = dev->wl;
3252 struct ssb_bus *bus = dev->dev->bus;
3253 struct b43legacy_phy *phy = &dev->phy;
3254 struct ssb_sprom *sprom = &dev->dev->bus->sprom;
3259 B43legacy_WARN_ON(b43legacy_status(dev) != B43legacy_STAT_UNINIT);
3264 if (!ssb_device_is_enabled(dev->dev)) {
3266 b43legacy_wireless_core_reset(dev, tmp);
3277 setup_struct_wldev_for_init(dev);
3279 err = b43legacy_phy_init_tssi2dbm_table(dev);
3284 ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->dev);
3286 prepare_phy_data_for_init(dev);
3287 b43legacy_phy_calibrate(dev);
3288 err = b43legacy_chip_init(dev);
3291 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3293 dev->dev->id.revision);
3294 hf = b43legacy_hf_read(dev);
3306 b43legacy_hf_write(dev, hf);
3308 b43legacy_set_retry_limits(dev,
3312 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3314 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3321 b43legacy_shm_write16(dev, B43legacy_SHM_SHARED,
3324 b43legacy_rate_memory_init(dev);
3328 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS,
3331 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS,
3334 b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS,
3338 if (b43legacy_using_pio(dev))
3339 err = b43legacy_pio_init(dev);
3341 err = b43legacy_dma_init(dev);
3343 b43legacy_qos_init(dev);
3349 b43legacy_set_synth_pu_delay(dev, 1);
3352 b43legacy_upload_card_macaddress(dev);
3353 b43legacy_security_init(dev);
3356 ieee80211_wake_queues(dev->wl->hw);
3357 b43legacy_set_status(dev, B43legacy_STAT_INITIALIZED);
3359 b43legacy_leds_init(dev);
3364 b43legacy_chip_exit(dev);
3372 B43legacy_WARN_ON(b43legacy_status(dev) != B43legacy_STAT_UNINIT);
3380 struct b43legacy_wldev *dev;
3398 dev = wl->current_dev;
3405 b43legacy_adjust_opmode(dev);
3406 b43legacy_set_pretbtt(dev);
3407 b43legacy_set_synth_pu_delay(dev, 0);
3408 b43legacy_upload_card_macaddress(dev);
3422 struct b43legacy_wldev *dev = wl->current_dev;
3436 b43legacy_adjust_opmode(dev);
3438 b43legacy_upload_card_macaddress(dev);
3447 struct b43legacy_wldev *dev = wl->current_dev;
3464 if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
3465 err = b43legacy_wireless_core_init(dev);
3471 if (b43legacy_status(dev) < B43legacy_STAT_STARTED) {
3472 err = b43legacy_wireless_core_start(dev);
3475 b43legacy_wireless_core_exit(dev);
3491 struct b43legacy_wldev *dev = wl->current_dev;
3496 if (b43legacy_status(dev) >= B43legacy_STAT_STARTED)
3497 b43legacy_wireless_core_stop(dev);
3498 b43legacy_wireless_core_exit(dev);
3520 struct b43legacy_wldev *dev = wl->current_dev;
3528 survey->noise = dev->stats.link_noise;
3554 struct b43legacy_wldev *dev =
3556 struct b43legacy_wl *wl = dev->wl;
3562 prev_status = b43legacy_status(dev);
3565 b43legacy_wireless_core_stop(dev);
3567 b43legacy_wireless_core_exit(dev);
3571 err = b43legacy_wireless_core_init(dev);
3576 err = b43legacy_wireless_core_start(dev);
3578 b43legacy_wireless_core_exit(dev);
3584 wl->current_dev = NULL; /* Failed to init the dev. */
3592 static int b43legacy_setup_modes(struct b43legacy_wldev *dev,
3596 struct ieee80211_hw *hw = dev->wl->hw;
3597 struct b43legacy_phy *phy = &dev->phy;
3615 static void b43legacy_wireless_core_detach(struct b43legacy_wldev *dev)
3619 b43legacy_release_firmware(dev);
3622 static int b43legacy_wireless_core_attach(struct b43legacy_wldev *dev)
3624 struct b43legacy_wl *wl = dev->wl;
3625 struct ssb_bus *bus = dev->dev->bus;
3645 if (dev->dev->id.revision >= 5) {
3648 tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH);
3652 } else if (dev->dev->id.revision == 4)
3657 dev->phy.gmode = (have_gphy || have_bphy);
3658 dev->phy.radio_on = true;
3659 tmp = dev->phy.gmode ? B43legacy_TMSLOW_GMODE : 0;
3660 b43legacy_wireless_core_reset(dev, tmp);
3662 err = b43legacy_phy_versioning(dev);
3673 switch (dev->phy.type) {
3684 dev->phy.gmode = (have_gphy || have_bphy);
3685 tmp = dev->phy.gmode ? B43legacy_TMSLOW_GMODE : 0;
3686 b43legacy_wireless_core_reset(dev, tmp);
3688 err = b43legacy_validate_chipaccess(dev);
3691 err = b43legacy_setup_modes(dev, have_bphy, have_gphy);
3697 wl->current_dev = dev;
3698 INIT_WORK(&dev->restart_work, b43legacy_chip_reset);
3700 b43legacy_radio_turn_off(dev, 1);
3701 b43legacy_switch_analog(dev, 0);
3702 ssb_device_disable(dev->dev, 0);
3713 static void b43legacy_one_core_detach(struct ssb_device *dev)
3721 wldev = ssb_get_drvdata(dev);
3727 ssb_set_drvdata(dev, NULL);
3731 static int b43legacy_one_core_attach(struct ssb_device *dev,
3741 wldev->dev = dev;
3756 ssb_set_drvdata(dev, wldev);
3775 static void b43legacy_wireless_exit(struct ssb_device *dev,
3780 ssb_set_devtypedata(dev, NULL);
3784 static int b43legacy_wireless_init(struct ssb_device *dev)
3786 struct ssb_sprom *sprom = &dev->bus->sprom;
3792 b43legacy_sprom_fixup(dev->bus);
3814 SET_IEEE80211_DEV(hw, dev->dev);
3839 ssb_set_devtypedata(dev, wl);
3841 dev->bus->chip_id, dev->id.revision);
3847 static int b43legacy_probe(struct ssb_device *dev,
3854 wl = ssb_get_devtypedata(dev);
3858 err = b43legacy_wireless_init(dev);
3861 wl = ssb_get_devtypedata(dev);
3864 err = b43legacy_one_core_attach(dev, wl);
3877 b43legacy_wireless_exit(dev, wl);
3881 static void b43legacy_remove(struct ssb_device *dev)
3883 struct b43legacy_wl *wl = ssb_get_devtypedata(dev);
3884 struct b43legacy_wldev *wldev = ssb_get_drvdata(dev);
3898 b43legacy_one_core_detach(dev);
3904 b43legacy_wireless_exit(dev, wl);
3908 void b43legacy_controller_restart(struct b43legacy_wldev *dev,
3912 if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED)
3914 b43legacyinfo(dev->wl, "Controller RESET (%s) ...\n", reason);
3915 ieee80211_queue_work(dev->wl->hw, &dev->restart_work);
3920 static int b43legacy_suspend(struct ssb_device *dev, pm_message_t state)
3922 struct b43legacy_wldev *wldev = ssb_get_drvdata(dev);
3940 static int b43legacy_resume(struct ssb_device *dev)
3942 struct b43legacy_wldev *wldev = ssb_get_drvdata(dev);