Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dedb1eb9 authored by Rafał Miłecki's avatar Rafał Miłecki Committed by John W. Linville
Browse files

b43: rename b43_wldev's field with ssb_device to sdev 



We free name "dev" for something generic (like dev abstraction layer).
Additionaly code is cleaner now, especially magic dev->dev-dev chains.

Signed-off-by: default avatarRafał Miłecki <zajec5@gmail.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent d0df9eec

drivers/net/wireless/b43/b43.h

+5 −5
Original line number Diff line number Diff line
@@ -705,7 +705,7 @@ enum { 


/* Data structure for one wireless device (802.11 core) */

struct b43_wldev {

	struct ssb_device *dev;

	struct ssb_device *sdev;

	struct b43_wl *wl;



	/* The device initialization status.
@@ -879,22 +879,22 @@ static inline enum ieee80211_band b43_current_band(struct b43_wl *wl) 


static inline u16 b43_read16(struct b43_wldev *dev, u16 offset)

{

	return ssb_read16(dev->dev, offset);

	return ssb_read16(dev->sdev, offset);

}



static inline void b43_write16(struct b43_wldev *dev, u16 offset, u16 value)

{

	ssb_write16(dev->dev, offset, value);

	ssb_write16(dev->sdev, offset, value);

}



static inline u32 b43_read32(struct b43_wldev *dev, u16 offset)

{

	return ssb_read32(dev->dev, offset);

	return ssb_read32(dev->sdev, offset);

}



static inline void b43_write32(struct b43_wldev *dev, u16 offset, u32 value)

{

	ssb_write32(dev->dev, offset, value);

	ssb_write32(dev->sdev, offset, value);

}



static inline bool b43_using_pio_transfers(struct b43_wldev *dev)

drivers/net/wireless/b43/dma.c

+18 −18
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ static void op32_fill_descriptor(struct b43_dmaring *ring, 
	addr = (u32) (dmaaddr & ~SSB_DMA_TRANSLATION_MASK);

	addrext = (u32) (dmaaddr & SSB_DMA_TRANSLATION_MASK)

	    >> SSB_DMA_TRANSLATION_SHIFT;

	addr |= ssb_dma_translation(ring->dev->dev);

	addr |= ssb_dma_translation(ring->dev->sdev);

	ctl = bufsize & B43_DMA32_DCTL_BYTECNT;

	if (slot == ring->nr_slots - 1)

		ctl |= B43_DMA32_DCTL_DTABLEEND;
@@ -174,7 +174,7 @@ static void op64_fill_descriptor(struct b43_dmaring *ring, 
	addrhi = (((u64) dmaaddr >> 32) & ~SSB_DMA_TRANSLATION_MASK);

	addrext = (((u64) dmaaddr >> 32) & SSB_DMA_TRANSLATION_MASK)

	    >> SSB_DMA_TRANSLATION_SHIFT;

	addrhi |= (ssb_dma_translation(ring->dev->dev) << 1);

	addrhi |= (ssb_dma_translation(ring->dev->sdev) << 1);

	if (slot == ring->nr_slots - 1)

		ctl0 |= B43_DMA64_DCTL0_DTABLEEND;

	if (start)
@@ -333,10 +333,10 @@ static inline 
	dma_addr_t dmaaddr;



	if (tx) {

		dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

		dmaaddr = dma_map_single(ring->dev->sdev->dma_dev,

					 buf, len, DMA_TO_DEVICE);

	} else {

		dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

		dmaaddr = dma_map_single(ring->dev->sdev->dma_dev,

					 buf, len, DMA_FROM_DEVICE);

	}
@@ -348,10 +348,10 @@ static inline 
			  dma_addr_t addr, size_t len, int tx)

{

	if (tx) {

		dma_unmap_single(ring->dev->dev->dma_dev,

		dma_unmap_single(ring->dev->sdev->dma_dev,

				 addr, len, DMA_TO_DEVICE);

	} else {

		dma_unmap_single(ring->dev->dev->dma_dev,

		dma_unmap_single(ring->dev->sdev->dma_dev,

				 addr, len, DMA_FROM_DEVICE);

	}

}
@@ -361,7 +361,7 @@ static inline 
				 dma_addr_t addr, size_t len)

{

	B43_WARN_ON(ring->tx);

	dma_sync_single_for_cpu(ring->dev->dev->dma_dev,

	dma_sync_single_for_cpu(ring->dev->sdev->dma_dev,

				    addr, len, DMA_FROM_DEVICE);

}
@@ -370,7 +370,7 @@ static inline 
				    dma_addr_t addr, size_t len)

{

	B43_WARN_ON(ring->tx);

	dma_sync_single_for_device(ring->dev->dev->dma_dev,

	dma_sync_single_for_device(ring->dev->sdev->dma_dev,

				   addr, len, DMA_FROM_DEVICE);

}
@@ -401,7 +401,7 @@ static int alloc_ringmemory(struct b43_dmaring *ring) 
	 */

	if (ring->type == B43_DMA_64BIT)

		flags |= GFP_DMA;

	ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,

	ring->descbase = dma_alloc_coherent(ring->dev->sdev->dma_dev,

					    B43_DMA_RINGMEMSIZE,

					    &(ring->dmabase), flags);

	if (!ring->descbase) {
@@ -415,7 +415,7 @@ static int alloc_ringmemory(struct b43_dmaring *ring) 


static void free_ringmemory(struct b43_dmaring *ring)

{

	dma_free_coherent(ring->dev->dev->dma_dev, B43_DMA_RINGMEMSIZE,

	dma_free_coherent(ring->dev->sdev->dma_dev, B43_DMA_RINGMEMSIZE,

			  ring->descbase, ring->dmabase);

}
@@ -523,7 +523,7 @@ static bool b43_dma_mapping_error(struct b43_dmaring *ring, 
				  dma_addr_t addr,

				  size_t buffersize, bool dma_to_device)

{

	if (unlikely(dma_mapping_error(ring->dev->dev->dma_dev, addr)))

	if (unlikely(dma_mapping_error(ring->dev->sdev->dma_dev, addr)))

		return 1;



	switch (ring->type) {
@@ -658,7 +658,7 @@ static int dmacontroller_setup(struct b43_dmaring *ring) 
	int err = 0;

	u32 value;

	u32 addrext;

	u32 trans = ssb_dma_translation(ring->dev->dev);

	u32 trans = ssb_dma_translation(ring->dev->sdev);



	if (ring->tx) {

		if (ring->type == B43_DMA_64BIT) {
@@ -869,7 +869,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev, 
			goto err_kfree_meta;



		/* test for ability to dma to txhdr_cache */

		dma_test = dma_map_single(dev->dev->dma_dev,

		dma_test = dma_map_single(dev->sdev->dma_dev,

					  ring->txhdr_cache,

					  b43_txhdr_size(dev),

					  DMA_TO_DEVICE);
@@ -884,7 +884,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev, 
			if (!ring->txhdr_cache)

				goto err_kfree_meta;



			dma_test = dma_map_single(dev->dev->dma_dev,

			dma_test = dma_map_single(dev->sdev->dma_dev,

						  ring->txhdr_cache,

						  b43_txhdr_size(dev),

						  DMA_TO_DEVICE);
@@ -898,7 +898,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev, 
			}

		}



		dma_unmap_single(dev->dev->dma_dev,

		dma_unmap_single(dev->sdev->dma_dev,

				 dma_test, b43_txhdr_size(dev),

				 DMA_TO_DEVICE);

	}
@@ -1013,9 +1013,9 @@ static int b43_dma_set_mask(struct b43_wldev *dev, u64 mask) 
	/* Try to set the DMA mask. If it fails, try falling back to a

	 * lower mask, as we can always also support a lower one. */

	while (1) {

		err = dma_set_mask(dev->dev->dma_dev, mask);

		err = dma_set_mask(dev->sdev->dma_dev, mask);

		if (!err) {

			err = dma_set_coherent_mask(dev->dev->dma_dev, mask);

			err = dma_set_coherent_mask(dev->sdev->dma_dev, mask);

			if (!err)

				break;

		}
@@ -1084,7 +1084,7 @@ int b43_dma_init(struct b43_wldev *dev) 
		goto err_destroy_mcast;



	/* No support for the TX status DMA ring. */

	B43_WARN_ON(dev->dev->id.revision < 5);

	B43_WARN_ON(dev->sdev->id.revision < 5);



	b43dbg(dev->wl, "%u-bit DMA initialized\n",

	       (unsigned int)type);

drivers/net/wireless/b43/leds.c

+2 −2
Original line number Diff line number Diff line
@@ -138,7 +138,7 @@ static int b43_register_led(struct b43_wldev *dev, struct b43_led *led, 
	led->led_dev.default_trigger = default_trigger;

	led->led_dev.brightness_set = b43_led_brightness_set;



	err = led_classdev_register(dev->dev->dev, &led->led_dev);

	err = led_classdev_register(dev->sdev->dev, &led->led_dev);

	if (err) {

		b43warn(dev->wl, "LEDs: Failed to register %s\n", name);

		led->wl = NULL;
@@ -215,7 +215,7 @@ static void b43_led_get_sprominfo(struct b43_wldev *dev, 
				  enum b43_led_behaviour *behaviour,

				  bool *activelow)

{

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	u8 sprom[4];



	sprom[0] = bus->sprom.gpio0;

drivers/net/wireless/b43/lo.c

+2 −2
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ static u16 lo_measure_feedthrough(struct b43_wldev *dev, 
		rfover |= pga;

		rfover |= lna;

		rfover |= trsw_rx;

		if ((dev->dev->bus->sprom.boardflags_lo & B43_BFL_EXTLNA)

		if ((dev->sdev->bus->sprom.boardflags_lo & B43_BFL_EXTLNA)

		    && phy->rev > 6)

			rfover |= B43_PHY_RFOVERVAL_EXTLNA;
@@ -387,7 +387,7 @@ struct lo_g_saved_values { 
static void lo_measure_setup(struct b43_wldev *dev,

			     struct lo_g_saved_values *sav)

{

	struct ssb_sprom *sprom = &dev->dev->bus->sprom;

	struct ssb_sprom *sprom = &dev->sdev->bus->sprom;

	struct b43_phy *phy = &dev->phy;

	struct b43_phy_g *gphy = phy->g;

	struct b43_txpower_lo_control *lo = gphy->lo_control;

drivers/net/wireless/b43/main.c

+62 −61
Original line number Diff line number Diff line
@@ -547,7 +547,7 @@ void b43_tsf_read(struct b43_wldev *dev, u64 *tsf) 
{

	u32 low, high;



	B43_WARN_ON(dev->dev->id.revision < 3);

	B43_WARN_ON(dev->sdev->id.revision < 3);



	/* The hardware guarantees us an atomic read, if we

	 * read the low register first. */
@@ -585,7 +585,7 @@ static void b43_tsf_write_locked(struct b43_wldev *dev, u64 tsf) 
{

	u32 low, high;



	B43_WARN_ON(dev->dev->id.revision < 3);

	B43_WARN_ON(dev->sdev->id.revision < 3);



	low = tsf;

	high = (tsf >> 32);
@@ -713,7 +713,7 @@ void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on) 
		b43_ram_write(dev, i * 4, buffer[i]);



	b43_write16(dev, 0x0568, 0x0000);

	if (dev->dev->id.revision < 11)

	if (dev->sdev->id.revision < 11)

		b43_write16(dev, 0x07C0, 0x0000);

	else

		b43_write16(dev, 0x07C0, 0x0100);
@@ -1131,7 +1131,7 @@ void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags) 
	b43_write32(dev, B43_MMIO_MACCTL, macctl);

	/* Commit write */

	b43_read32(dev, B43_MMIO_MACCTL);

	if (awake && dev->dev->id.revision >= 5) {

	if (awake && dev->sdev->id.revision >= 5) {

		/* Wait for the microcode to wake up. */

		for (i = 0; i < 100; i++) {

			ucstat = b43_shm_read16(dev, B43_SHM_SHARED,
@@ -1152,19 +1152,19 @@ void b43_wireless_core_reset(struct b43_wldev *dev, u32 flags) 
	flags |= B43_TMSLOW_PHYRESET;

	if (dev->phy.type == B43_PHYTYPE_N)

		flags |= B43_TMSLOW_PHY_BANDWIDTH_20MHZ; /* Make 20 MHz def */

	ssb_device_enable(dev->dev, flags);

	ssb_device_enable(dev->sdev, flags);

	msleep(2);		/* Wait for the PLL to turn on. */



	/* Now take the PHY out of Reset again */

	tmslow = ssb_read32(dev->dev, SSB_TMSLOW);

	tmslow = ssb_read32(dev->sdev, SSB_TMSLOW);

	tmslow |= SSB_TMSLOW_FGC;

	tmslow &= ~B43_TMSLOW_PHYRESET;

	ssb_write32(dev->dev, SSB_TMSLOW, tmslow);

	ssb_read32(dev->dev, SSB_TMSLOW);	/* flush */

	ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);

	ssb_read32(dev->sdev, SSB_TMSLOW);	/* flush */

	msleep(1);

	tmslow &= ~SSB_TMSLOW_FGC;

	ssb_write32(dev->dev, SSB_TMSLOW, tmslow);

	ssb_read32(dev->dev, SSB_TMSLOW);	/* flush */

	ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);

	ssb_read32(dev->sdev, SSB_TMSLOW);	/* flush */

	msleep(1);



	/* Turn Analog ON, but only if we already know the PHY-type.
@@ -1214,7 +1214,7 @@ static void drain_txstatus_queue(struct b43_wldev *dev) 
{

	u32 dummy;



	if (dev->dev->id.revision < 5)

	if (dev->sdev->id.revision < 5)

		return;

	/* Read all entries from the microcode TXstatus FIFO

	 * and throw them away.
@@ -1420,9 +1420,9 @@ u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev, 


	/* Get the mask of available antennas. */

	if (dev->phy.gmode)

		antenna_mask = dev->dev->bus->sprom.ant_available_bg;

		antenna_mask = dev->sdev->bus->sprom.ant_available_bg;

	else

		antenna_mask = dev->dev->bus->sprom.ant_available_a;

		antenna_mask = dev->sdev->bus->sprom.ant_available_a;



	if (!(antenna_mask & (1 << (antenna_nr - 1)))) {

		/* This antenna is not available. Fall back to default. */
@@ -1637,7 +1637,7 @@ static void b43_beacon_update_trigger_work(struct work_struct *work) 
	mutex_lock(&wl->mutex);

	dev = wl->current_dev;

	if (likely(dev && (b43_status(dev) >= B43_STAT_INITIALIZED))) {

		if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {

		if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {

			/* wl->mutex is enough. */

			b43_do_beacon_update_trigger_work(dev);

			mmiowb();
@@ -1682,7 +1682,7 @@ static void b43_update_templates(struct b43_wl *wl) 
static void b43_set_beacon_int(struct b43_wldev *dev, u16 beacon_int)

{

	b43_time_lock(dev);

	if (dev->dev->id.revision >= 3) {

	if (dev->sdev->id.revision >= 3) {

		b43_write32(dev, B43_MMIO_TSF_CFP_REP, (beacon_int << 16));

		b43_write32(dev, B43_MMIO_TSF_CFP_START, (beacon_int << 10));

	} else {
@@ -2056,7 +2056,7 @@ int b43_do_request_fw(struct b43_request_fw_context *ctx, 
		B43_WARN_ON(1);

		return -ENOSYS;

	}

	err = request_firmware(&blob, ctx->fwname, ctx->dev->dev->dev);

	err = request_firmware(&blob, ctx->fwname, ctx->dev->sdev->dev);

	if (err == -ENOENT) {

		snprintf(ctx->errors[ctx->req_type],

			 sizeof(ctx->errors[ctx->req_type]),
@@ -2106,13 +2106,13 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx) 
{

	struct b43_wldev *dev = ctx->dev;

	struct b43_firmware *fw = &ctx->dev->fw;

	const u8 rev = ctx->dev->dev->id.revision;

	const u8 rev = ctx->dev->sdev->id.revision;

	const char *filename;

	u32 tmshigh;

	int err;



	/* Get microcode */

	tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH);

	tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH);

	if ((rev >= 5) && (rev <= 10))

		filename = "ucode5";

	else if ((rev >= 11) && (rev <= 12))
@@ -2440,7 +2440,7 @@ static int b43_upload_microcode(struct b43_wldev *dev) 


	snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "%u.%u",

			dev->fw.rev, dev->fw.patch);

	wiphy->hw_version = dev->dev->id.coreid;

	wiphy->hw_version = dev->sdev->id.coreid;



	if (b43_is_old_txhdr_format(dev)) {

		/* We're over the deadline, but we keep support for old fw
@@ -2558,7 +2558,7 @@ static int b43_upload_initvals(struct b43_wldev *dev) 
 */

static int b43_gpio_init(struct b43_wldev *dev)

{

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	struct ssb_device *gpiodev, *pcidev = NULL;

	u32 mask, set;
@@ -2570,7 +2570,7 @@ static int b43_gpio_init(struct b43_wldev *dev) 


	mask = 0x0000001F;

	set = 0x0000000F;

	if (dev->dev->bus->chip_id == 0x4301) {

	if (dev->sdev->bus->chip_id == 0x4301) {

		mask |= 0x0060;

		set |= 0x0060;

	}
@@ -2581,14 +2581,14 @@ static int b43_gpio_init(struct b43_wldev *dev) 
		mask |= 0x0180;

		set |= 0x0180;

	}

	if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_PACTRL) {

	if (dev->sdev->bus->sprom.boardflags_lo & B43_BFL_PACTRL) {

		b43_write16(dev, B43_MMIO_GPIO_MASK,

			    b43_read16(dev, B43_MMIO_GPIO_MASK)

			    | 0x0200);

		mask |= 0x0200;

		set |= 0x0200;

	}

	if (dev->dev->id.revision >= 2)

	if (dev->sdev->id.revision >= 2)

		mask |= 0x0010;	/* FIXME: This is redundant. */



#ifdef CONFIG_SSB_DRIVER_PCICORE
@@ -2607,7 +2607,7 @@ static int b43_gpio_init(struct b43_wldev *dev) 
/* Turn off all GPIO stuff. Call this on module unload, for example. */

static void b43_gpio_cleanup(struct b43_wldev *dev)

{

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	struct ssb_device *gpiodev, *pcidev = NULL;



#ifdef CONFIG_SSB_DRIVER_PCICORE
@@ -2688,12 +2688,12 @@ void b43_mac_suspend(struct b43_wldev *dev) 
/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/MacPhyClkSet */

void b43_mac_phy_clock_set(struct b43_wldev *dev, bool on)

{

	u32 tmslow = ssb_read32(dev->dev, SSB_TMSLOW);

	u32 tmslow = ssb_read32(dev->sdev, SSB_TMSLOW);

	if (on)

		tmslow |= B43_TMSLOW_MACPHYCLKEN;

	else

		tmslow &= ~B43_TMSLOW_MACPHYCLKEN;

	ssb_write32(dev->dev, SSB_TMSLOW, tmslow);

	ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);

}



static void b43_adjust_opmode(struct b43_wldev *dev)
@@ -2732,15 +2732,15 @@ static void b43_adjust_opmode(struct b43_wldev *dev) 
	/* Workaround: On old hardware the HW-MAC-address-filter

	 * doesn't work properly, so always run promisc in filter

	 * it in software. */

	if (dev->dev->id.revision <= 4)

	if (dev->sdev->id.revision <= 4)

		ctl |= B43_MACCTL_PROMISC;



	b43_write32(dev, B43_MMIO_MACCTL, ctl);



	cfp_pretbtt = 2;

	if ((ctl & B43_MACCTL_INFRA) && !(ctl & B43_MACCTL_AP)) {

		if (dev->dev->bus->chip_id == 0x4306 &&

		    dev->dev->bus->chip_rev == 3)

		if (dev->sdev->bus->chip_id == 0x4306 &&

		    dev->sdev->bus->chip_rev == 3)

			cfp_pretbtt = 100;

		else

			cfp_pretbtt = 50;
@@ -2898,7 +2898,7 @@ static int b43_chip_init(struct b43_wldev *dev) 
		b43_write16(dev, 0x005E, value16);

	}

	b43_write32(dev, 0x0100, 0x01000000);

	if (dev->dev->id.revision < 5)

	if (dev->sdev->id.revision < 5)

		b43_write32(dev, 0x010C, 0x01000000);



	b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
@@ -2913,7 +2913,7 @@ static int b43_chip_init(struct b43_wldev *dev) 
	/* Initially set the wireless operation mode. */

	b43_adjust_opmode(dev);



	if (dev->dev->id.revision < 3) {

	if (dev->sdev->id.revision < 3) {

		b43_write16(dev, 0x060E, 0x0000);

		b43_write16(dev, 0x0610, 0x8000);

		b43_write16(dev, 0x0604, 0x0000);
@@ -2933,7 +2933,7 @@ static int b43_chip_init(struct b43_wldev *dev) 
	b43_mac_phy_clock_set(dev, true);



	b43_write16(dev, B43_MMIO_POWERUP_DELAY,

		    dev->dev->bus->chipco.fast_pwrup_delay);

		    dev->sdev->bus->chipco.fast_pwrup_delay);



	err = 0;

	b43dbg(dev->wl, "Chip initialized\n");
@@ -3096,7 +3096,7 @@ static int b43_validate_chipaccess(struct b43_wldev *dev) 
	b43_shm_write32(dev, B43_SHM_SHARED, 0, backup0);

	b43_shm_write32(dev, B43_SHM_SHARED, 4, backup4);



	if ((dev->dev->id.revision >= 3) && (dev->dev->id.revision <= 10)) {

	if ((dev->sdev->id.revision >= 3) && (dev->sdev->id.revision <= 10)) {

		/* The 32bit register shadows the two 16bit registers

		 * with update sideeffects. Validate this. */

		b43_write16(dev, B43_MMIO_TSF_CFP_START, 0xAAAA);
@@ -3449,7 +3449,7 @@ static void b43_op_set_tsf(struct ieee80211_hw *hw, u64 tsf) 


static void b43_put_phy_into_reset(struct b43_wldev *dev)

{

	struct ssb_device *sdev = dev->dev;

	struct ssb_device *sdev = dev->sdev;

	u32 tmslow;



	tmslow = ssb_read32(sdev, SSB_TMSLOW);
@@ -3945,7 +3945,7 @@ static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev) 


	/* Disable interrupts on the device. */

	b43_set_status(dev, B43_STAT_INITIALIZED);

	if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {

	if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {

		/* wl->mutex is locked. That is enough. */

		b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);

		b43_read32(dev, B43_MMIO_GEN_IRQ_MASK);	/* Flush */
@@ -3958,11 +3958,11 @@ static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev) 
	/* Synchronize and free the interrupt handlers. Unlock to avoid deadlocks. */

	orig_dev = dev;

	mutex_unlock(&wl->mutex);

	if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {

	if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {

		b43_sdio_free_irq(dev);

	} else {

		synchronize_irq(dev->dev->irq);

		free_irq(dev->dev->irq, dev);

		synchronize_irq(dev->sdev->irq);

		free_irq(dev->sdev->irq, dev);

	}

	mutex_lock(&wl->mutex);

	dev = wl->current_dev;
@@ -3995,18 +3995,19 @@ static int b43_wireless_core_start(struct b43_wldev *dev) 
	B43_WARN_ON(b43_status(dev) != B43_STAT_INITIALIZED);



	drain_txstatus_queue(dev);

	if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {

	if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {

		err = b43_sdio_request_irq(dev, b43_sdio_interrupt_handler);

		if (err) {

			b43err(dev->wl, "Cannot request SDIO IRQ\n");

			goto out;

		}

	} else {

		err = request_threaded_irq(dev->dev->irq, b43_interrupt_handler,

		err = request_threaded_irq(dev->sdev->irq, b43_interrupt_handler,

					   b43_interrupt_thread_handler,

					   IRQF_SHARED, KBUILD_MODNAME, dev);

		if (err) {

			b43err(dev->wl, "Cannot request IRQ-%d\n", dev->dev->irq);

			b43err(dev->wl, "Cannot request IRQ-%d\n",

			       dev->sdev->irq);

			goto out;

		}

	}
@@ -4086,10 +4087,10 @@ static int b43_phy_versioning(struct b43_wldev *dev) 
	       analog_type, phy_type, phy_rev);



	/* Get RADIO versioning */

	if (dev->dev->bus->chip_id == 0x4317) {

		if (dev->dev->bus->chip_rev == 0)

	if (dev->sdev->bus->chip_id == 0x4317) {

		if (dev->sdev->bus->chip_rev == 0)

			tmp = 0x3205017F;

		else if (dev->dev->bus->chip_rev == 1)

		else if (dev->sdev->bus->chip_rev == 1)

			tmp = 0x4205017F;

		else

			tmp = 0x5205017F;
@@ -4194,7 +4195,7 @@ static void setup_struct_wldev_for_init(struct b43_wldev *dev) 


static void b43_bluetooth_coext_enable(struct b43_wldev *dev)

{

	struct ssb_sprom *sprom = &dev->dev->bus->sprom;

	struct ssb_sprom *sprom = &dev->sdev->bus->sprom;

	u64 hf;



	if (!modparam_btcoex)
@@ -4221,16 +4222,16 @@ static void b43_bluetooth_coext_disable(struct b43_wldev *dev) 


static void b43_imcfglo_timeouts_workaround(struct b43_wldev *dev)

{

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	u32 tmp;



	if ((bus->chip_id == 0x4311 && bus->chip_rev == 2) ||

	    (bus->chip_id == 0x4312)) {

		tmp = ssb_read32(dev->dev, SSB_IMCFGLO);

		tmp = ssb_read32(dev->sdev, SSB_IMCFGLO);

		tmp &= ~SSB_IMCFGLO_REQTO;

		tmp &= ~SSB_IMCFGLO_SERTO;

		tmp |= 0x3;

		ssb_write32(dev->dev, SSB_IMCFGLO, tmp);

		ssb_write32(dev->sdev, SSB_IMCFGLO, tmp);

		ssb_commit_settings(bus);

	}

}
@@ -4300,14 +4301,14 @@ static void b43_wireless_core_exit(struct b43_wldev *dev) 
		dev->wl->current_beacon = NULL;

	}



	ssb_device_disable(dev->dev, 0);

	ssb_bus_may_powerdown(dev->dev->bus);

	ssb_device_disable(dev->sdev, 0);

	ssb_bus_may_powerdown(dev->sdev->bus);

}



/* Initialize a wireless core */

static int b43_wireless_core_init(struct b43_wldev *dev)

{

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	struct ssb_sprom *sprom = &bus->sprom;

	struct b43_phy *phy = &dev->phy;

	int err;
@@ -4319,7 +4320,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev) 
	err = ssb_bus_powerup(bus, 0);

	if (err)

		goto out;

	if (!ssb_device_is_enabled(dev->dev)) {

	if (!ssb_device_is_enabled(dev->sdev)) {

		tmp = phy->gmode ? B43_TMSLOW_GMODE : 0;

		b43_wireless_core_reset(dev, tmp);

	}
@@ -4329,7 +4330,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev) 
	phy->ops->prepare_structs(dev);



	/* Enable IRQ routing to this device. */

	ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->dev);

	ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->sdev);



	b43_imcfglo_timeouts_workaround(dev);

	b43_bluetooth_coext_disable(dev);
@@ -4342,7 +4343,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev) 
	if (err)

		goto err_busdown;

	b43_shm_write16(dev, B43_SHM_SHARED,

			B43_SHM_SH_WLCOREREV, dev->dev->id.revision);

			B43_SHM_SH_WLCOREREV, dev->sdev->id.revision);

	hf = b43_hf_read(dev);

	if (phy->type == B43_PHYTYPE_G) {

		hf |= B43_HF_SYMW;
@@ -4389,8 +4390,8 @@ static int b43_wireless_core_init(struct b43_wldev *dev) 
	/* Maximum Contention Window */

	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MAXCONT, 0x3FF);



	if ((dev->dev->bus->bustype == SSB_BUSTYPE_PCMCIA) ||

	    (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) ||

	if ((dev->sdev->bus->bustype == SSB_BUSTYPE_PCMCIA) ||

	    (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) ||

	    dev->use_pio) {

		dev->__using_pio_transfers = 1;

		err = b43_pio_init(dev);
@@ -4727,7 +4728,7 @@ static void b43_wireless_core_detach(struct b43_wldev *dev) 
static int b43_wireless_core_attach(struct b43_wldev *dev)

{

	struct b43_wl *wl = dev->wl;

	struct ssb_bus *bus = dev->dev->bus;

	struct ssb_bus *bus = dev->sdev->bus;

	struct pci_dev *pdev = (bus->bustype == SSB_BUSTYPE_PCI) ? bus->host_pci : NULL;

	int err;

	bool have_2ghz_phy = 0, have_5ghz_phy = 0;
@@ -4746,10 +4747,10 @@ static int b43_wireless_core_attach(struct b43_wldev *dev) 
		goto out;

	}

	/* Get the PHY type. */

	if (dev->dev->id.revision >= 5) {

	if (dev->sdev->id.revision >= 5) {

		u32 tmshigh;



		tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH);

		tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH);

		have_2ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY);

		have_5ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_5GHZ_PHY);

	} else
@@ -4822,7 +4823,7 @@ static int b43_wireless_core_attach(struct b43_wldev *dev) 
	INIT_WORK(&dev->restart_work, b43_chip_reset);



	dev->phy.ops->switch_analog(dev, 0);

	ssb_device_disable(dev->dev, 0);

	ssb_device_disable(dev->sdev, 0);

	ssb_bus_may_powerdown(bus);



out:
@@ -4863,7 +4864,7 @@ static int b43_one_core_attach(struct ssb_device *dev, struct b43_wl *wl) 
		goto out;



	wldev->use_pio = b43_modparam_pio;

	wldev->dev = dev;

	wldev->sdev = dev;

	wldev->wl = wl;

	b43_set_status(wldev, B43_STAT_UNINIT);

	wldev->bad_frames_preempt = modparam_bad_frames_preempt;