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

Commit eafe6002 authored by David Matlack's avatar David Matlack Committed by Greg Kroah-Hartman
Browse files

staging: slicoss: remove slic_spinlock wrapper 



As per TODO. This commit introduces no functional changes.

Signed-off-by: default avatarDavid Matlack <dmatlack@google.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 1645b55b

drivers/staging/slicoss/TODO

+0 −1
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ TODO: 
	- state variables for things that are

	  easily available and shouldn't be kept in card structure, cardnum, ...

	  slotnumber, events, ...

	- get rid of slic_spinlock wrapper

	- volatile == bad design => bad code

	- locking too fine grained, not designed just throw more locks

	  at problem

drivers/staging/slicoss/slic.h

+7 −12
Original line number Diff line number Diff line
@@ -56,11 +56,6 @@ static u32 OasisRcvUCodeLen = 512; 
static u32 GBRcvUCodeLen = 512;

#define SECTION_SIZE 65536



struct slic_spinlock {

	spinlock_t	lock;

	unsigned long	flags;

};



#define SLIC_RSPQ_PAGES_GB        10

#define SLIC_RSPQ_BUFSINPAGE      (PAGE_SIZE / SLIC_RSPBUF_SIZE)
@@ -165,7 +160,7 @@ struct slic_cmdqueue { 
	struct slic_hostcmd *head;

	struct slic_hostcmd *tail;

	int count;

	struct slic_spinlock lock;

	spinlock_t lock;

};



#define SLIC_MAX_CARDS              32
@@ -346,7 +341,7 @@ struct physcard { 
};



struct base_driver {

	struct slic_spinlock driver_lock;

	spinlock_t       driver_lock;

	u32              num_slic_cards;

	u32              num_slic_ports;

	u32              num_slic_ports_active;
@@ -401,8 +396,8 @@ struct adapter { 
	uint                card_size;

	uint                chipid;

	struct net_device  *netdev;

	struct slic_spinlock     adapter_lock;

	struct slic_spinlock     reset_lock;

	spinlock_t          adapter_lock;

	spinlock_t          reset_lock;

	struct pci_dev     *pcidev;

	uint                busnumber;

	uint                slotnumber;
@@ -441,8 +436,8 @@ struct adapter { 
	u32             pingtimerset;

	struct timer_list   loadtimer;

	u32             loadtimerset;

	struct slic_spinlock     upr_lock;

	struct slic_spinlock     bit64reglock;

	spinlock_t               upr_lock;

	spinlock_t               bit64reglock;

	struct slic_rspqueue     rspqueue;

	struct slic_rcvqueue     rcvqueue;

	struct slic_cmdqueue     cmdq_free;
@@ -457,7 +452,7 @@ struct adapter { 
	/* Free object handles*/

	struct slic_handle *pfree_slic_handles;

	/* Object handle list lock*/

	struct slic_spinlock     handle_lock;

	spinlock_t          handle_lock;

	ushort              slic_handle_ix;



	u32             xmitq_full;

drivers/staging/slicoss/slicoss.c

+58 −67
Original line number Diff line number Diff line
@@ -144,8 +144,9 @@ static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg, 
				    u32 value, void __iomem *regh, u32 paddrh,

				    bool flush)

{

	spin_lock_irqsave(&adapter->bit64reglock.lock,

				adapter->bit64reglock.flags);

	unsigned long flags;



	spin_lock_irqsave(&adapter->bit64reglock, flags);

	if (paddrh != adapter->curaddrupper) {

		adapter->curaddrupper = paddrh;

		writel(paddrh, regh);
@@ -153,8 +154,7 @@ static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg, 
	writel(value, reg);

	if (flush)

		mb();

	spin_unlock_irqrestore(&adapter->bit64reglock.lock,

				adapter->bit64reglock.flags);

	spin_unlock_irqrestore(&adapter->bit64reglock, flags);

}



static void slic_mcast_set_bit(struct adapter *adapter, char *address)
@@ -936,9 +936,10 @@ static int slic_upr_request(struct adapter *adapter, 
		     u32 upr_data_h,

		     u32 upr_buffer, u32 upr_buffer_h)

{

	unsigned long flags;

	int rc;



	spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);

	spin_lock_irqsave(&adapter->upr_lock, flags);

	rc = slic_upr_queue_request(adapter,

					upr_request,

					upr_data,
@@ -948,8 +949,7 @@ static int slic_upr_request(struct adapter *adapter, 


	slic_upr_start(adapter);

err_unlock_irq:

	spin_unlock_irqrestore(&adapter->upr_lock.lock,

				adapter->upr_lock.flags);

	spin_unlock_irqrestore(&adapter->upr_lock, flags);

	return rc;

}
@@ -1029,12 +1029,12 @@ static void slic_upr_request_complete(struct adapter *adapter, u32 isr) 
{

	struct sliccard *card = adapter->card;

	struct slic_upr *upr;

	unsigned long flags;



	spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);

	spin_lock_irqsave(&adapter->upr_lock, flags);

	upr = adapter->upr_list;

	if (!upr) {

		spin_unlock_irqrestore(&adapter->upr_lock.lock,

					adapter->upr_lock.flags);

		spin_unlock_irqrestore(&adapter->upr_lock, flags);

		return;

	}

	adapter->upr_list = upr->next;
@@ -1127,8 +1127,7 @@ static void slic_upr_request_complete(struct adapter *adapter, u32 isr) 
	}

	kfree(upr);

	slic_upr_start(adapter);

	spin_unlock_irqrestore(&adapter->upr_lock.lock,

				adapter->upr_lock.flags);

	spin_unlock_irqrestore(&adapter->upr_lock, flags);

}



static int slic_config_get(struct adapter *adapter, u32 config, u32 config_h)
@@ -1310,6 +1309,7 @@ static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page) 
	u32 phys_addrl;

	u32 phys_addrh;

	struct slic_handle *pslic_handle;

	unsigned long flags;



	cmdaddr = page;

	cmd = (struct slic_hostcmd *)cmdaddr;
@@ -1324,12 +1324,10 @@ static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page) 
	while ((cmdcnt < SLIC_CMDQ_CMDSINPAGE) &&

	       (adapter->slic_handle_ix < 256)) {

		/* Allocate and initialize a SLIC_HANDLE for this command */

		spin_lock_irqsave(&adapter->handle_lock.lock,

				adapter->handle_lock.flags);

		spin_lock_irqsave(&adapter->handle_lock, flags);

		pslic_handle  =  adapter->pfree_slic_handles;

		adapter->pfree_slic_handles = pslic_handle->next;

		spin_unlock_irqrestore(&adapter->handle_lock.lock,

				adapter->handle_lock.flags);

		spin_unlock_irqrestore(&adapter->handle_lock, flags);

		pslic_handle->type = SLIC_HANDLE_CMD;

		pslic_handle->address = (void *) cmd;

		pslic_handle->offset = (ushort) adapter->slic_handle_ix++;
@@ -1356,11 +1354,11 @@ static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page) 
	tail->next_all = cmdq->head;

	cmdq->head = prev;

	cmdq = &adapter->cmdq_free;

	spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);

	spin_lock_irqsave(&cmdq->lock, flags);

	cmdq->count += cmdcnt;	/*  SLIC_CMDQ_CMDSINPAGE;   mooktodo */

	tail->next = cmdq->head;

	cmdq->head = prev;

	spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);

	spin_unlock_irqrestore(&cmdq->lock, flags);

}



static int slic_cmdq_init(struct adapter *adapter)
@@ -1371,9 +1369,9 @@ static int slic_cmdq_init(struct adapter *adapter) 
	memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));

	memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));

	memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));

	spin_lock_init(&adapter->cmdq_all.lock.lock);

	spin_lock_init(&adapter->cmdq_free.lock.lock);

	spin_lock_init(&adapter->cmdq_done.lock.lock);

	spin_lock_init(&adapter->cmdq_all.lock);

	spin_lock_init(&adapter->cmdq_free.lock);

	spin_lock_init(&adapter->cmdq_done.lock);

	memset(&adapter->cmdqmem, 0, sizeof(struct slic_cmdqmem));

	adapter->slic_handle_ix = 1;

	for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) {
@@ -1394,11 +1392,10 @@ static void slic_cmdq_reset(struct adapter *adapter) 
	struct slic_hostcmd *hcmd;

	struct sk_buff *skb;

	u32 outstanding;

	unsigned long flags;



	spin_lock_irqsave(&adapter->cmdq_free.lock.lock,

			adapter->cmdq_free.lock.flags);

	spin_lock_irqsave(&adapter->cmdq_done.lock.lock,

			adapter->cmdq_done.lock.flags);

	spin_lock_irqsave(&adapter->cmdq_free.lock, flags);

	spin_lock_irqsave(&adapter->cmdq_done.lock, flags);

	outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count;

	outstanding -= adapter->cmdq_free.count;

	hcmd = adapter->cmdq_all.head;
@@ -1429,40 +1426,40 @@ static void slic_cmdq_reset(struct adapter *adapter) 
			"free_count %d != all count %d\n",

			adapter->cmdq_free.count, adapter->cmdq_all.count);

	}

	spin_unlock_irqrestore(&adapter->cmdq_done.lock.lock,

				adapter->cmdq_done.lock.flags);

	spin_unlock_irqrestore(&adapter->cmdq_free.lock.lock,

				adapter->cmdq_free.lock.flags);

	spin_unlock_irqrestore(&adapter->cmdq_done.lock, flags);

	spin_unlock_irqrestore(&adapter->cmdq_free.lock, flags);

}



static void slic_cmdq_getdone(struct adapter *adapter)

{

	struct slic_cmdqueue *done_cmdq = &adapter->cmdq_done;

	struct slic_cmdqueue *free_cmdq = &adapter->cmdq_free;

	unsigned long flags;



	spin_lock_irqsave(&done_cmdq->lock.lock, done_cmdq->lock.flags);

	spin_lock_irqsave(&done_cmdq->lock, flags);



	free_cmdq->head = done_cmdq->head;

	free_cmdq->count = done_cmdq->count;

	done_cmdq->head = NULL;

	done_cmdq->tail = NULL;

	done_cmdq->count = 0;

	spin_unlock_irqrestore(&done_cmdq->lock.lock, done_cmdq->lock.flags);

	spin_unlock_irqrestore(&done_cmdq->lock, flags);

}



static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter)

{

	struct slic_cmdqueue *cmdq = &adapter->cmdq_free;

	struct slic_hostcmd *cmd = NULL;

	unsigned long flags;



lock_and_retry:

	spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);

	spin_lock_irqsave(&cmdq->lock, flags);

retry:

	cmd = cmdq->head;

	if (cmd) {

		cmdq->head = cmd->next;

		cmdq->count--;

		spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);

		spin_unlock_irqrestore(&cmdq->lock, flags);

	} else {

		slic_cmdq_getdone(adapter);

		cmd = cmdq->head;
@@ -1471,8 +1468,7 @@ static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter) 
		} else {

			u32 *pageaddr;



			spin_unlock_irqrestore(&cmdq->lock.lock,

						cmdq->lock.flags);

			spin_unlock_irqrestore(&cmdq->lock, flags);

			pageaddr = slic_cmdqmem_addpage(adapter);

			if (pageaddr) {

				slic_cmdq_addcmdpage(adapter, pageaddr);
@@ -1488,14 +1484,14 @@ static void slic_cmdq_putdone_irq(struct adapter *adapter, 
{

	struct slic_cmdqueue *cmdq = &adapter->cmdq_done;



	spin_lock(&cmdq->lock.lock);

	spin_lock(&cmdq->lock);

	cmd->busy = 0;

	cmd->next = cmdq->head;

	cmdq->head = cmd;

	cmdq->count++;

	if ((adapter->xmitq_full) && (cmdq->count > 10))

		netif_wake_queue(adapter->netdev);

	spin_unlock(&cmdq->lock.lock);

	spin_unlock(&cmdq->lock);

}



static int slic_rcvqueue_fill(struct adapter *adapter)
@@ -2250,21 +2246,20 @@ static void slic_adapter_freeresources(struct adapter *adapter) 
	adapter->rcv_unicasts = 0;

}



static int slic_adapter_allocresources(struct adapter *adapter)

static int slic_adapter_allocresources(struct adapter *adapter,

				       unsigned long *flags)

{

	if (!adapter->intrregistered) {

		int retval;



		spin_unlock_irqrestore(&slic_global.driver_lock.lock,

					slic_global.driver_lock.flags);

		spin_unlock_irqrestore(&slic_global.driver_lock, *flags);



		retval = request_irq(adapter->netdev->irq,

				     &slic_interrupt,

				     IRQF_SHARED,

				     adapter->netdev->name, adapter->netdev);



		spin_lock_irqsave(&slic_global.driver_lock.lock,

					slic_global.driver_lock.flags);

		spin_lock_irqsave(&slic_global.driver_lock, *flags);



		if (retval) {

			dev_err(&adapter->netdev->dev,
@@ -2283,7 +2278,7 @@ static int slic_adapter_allocresources(struct adapter *adapter) 
 *  Perform initialization of our slic interface.

 *

 */

static int slic_if_init(struct adapter *adapter)

static int slic_if_init(struct adapter *adapter, unsigned long *flags)

{

	struct sliccard *card = adapter->card;

	struct net_device *dev = adapter->netdev;
@@ -2311,7 +2306,7 @@ static int slic_if_init(struct adapter *adapter) 
		if (dev->flags & IFF_MULTICAST)

			adapter->macopts |= MAC_MCAST;

	}

	rc = slic_adapter_allocresources(adapter);

	rc = slic_adapter_allocresources(adapter, flags);

	if (rc) {

		dev_err(&dev->dev, "slic_adapter_allocresources FAILED %x\n",

			rc);
@@ -2336,11 +2331,11 @@ static int slic_if_init(struct adapter *adapter) 
	mdelay(1);



	if (!adapter->isp_initialized) {

		unsigned long flags;

		pshmem = (struct slic_shmem *)(unsigned long)

			 adapter->phys_shmem;



		spin_lock_irqsave(&adapter->bit64reglock.lock,

					adapter->bit64reglock.flags);

		spin_lock_irqsave(&adapter->bit64reglock, flags);



#if BITS_PER_LONG == 64

		slic_reg32_write(&slic_regs->slic_addr_upper,
@@ -2352,8 +2347,7 @@ static int slic_if_init(struct adapter *adapter) 
		slic_reg32_write(&slic_regs->slic_isp, (u32)&pshmem->isr,

				FLUSH);

#endif

		spin_unlock_irqrestore(&adapter->bit64reglock.lock,

					adapter->bit64reglock.flags);

		spin_unlock_irqrestore(&adapter->bit64reglock, flags);

		adapter->isp_initialized = 1;

	}
@@ -2396,18 +2390,18 @@ static int slic_entry_open(struct net_device *dev) 
{

	struct adapter *adapter = netdev_priv(dev);

	struct sliccard *card = adapter->card;

	unsigned long flags;

	int status;



	netif_stop_queue(adapter->netdev);



	spin_lock_irqsave(&slic_global.driver_lock.lock,

				slic_global.driver_lock.flags);

	spin_lock_irqsave(&slic_global.driver_lock, flags);

	if (!adapter->activated) {

		card->adapters_activated++;

		slic_global.num_slic_ports_active++;

		adapter->activated = 1;

	}

	status = slic_if_init(adapter);

	status = slic_if_init(adapter, &flags);



	if (status != 0) {

		if (adapter->activated) {
@@ -2421,8 +2415,7 @@ static int slic_entry_open(struct net_device *dev) 
		card->master = adapter;



spin_unlock:

	spin_unlock_irqrestore(&slic_global.driver_lock.lock,

			       slic_global.driver_lock.flags);

	spin_unlock_irqrestore(&slic_global.driver_lock, flags);

	return status;

}
@@ -2481,9 +2474,9 @@ static int slic_entry_halt(struct net_device *dev) 
	struct adapter *adapter = netdev_priv(dev);

	struct sliccard *card = adapter->card;

	__iomem struct slic_regs *slic_regs = adapter->slic_regs;

	unsigned long flags;



	spin_lock_irqsave(&slic_global.driver_lock.lock,

				slic_global.driver_lock.flags);

	spin_lock_irqsave(&slic_global.driver_lock, flags);

	netif_stop_queue(adapter->netdev);

	adapter->state = ADAPT_DOWN;

	adapter->linkstate = LINK_DOWN;
@@ -2512,8 +2505,7 @@ static int slic_entry_halt(struct net_device *dev) 
		slic_card_init(card, adapter);

#endif



	spin_unlock_irqrestore(&slic_global.driver_lock.lock,

				slic_global.driver_lock.flags);

	spin_unlock_irqrestore(&slic_global.driver_lock, flags);

	return 0;

}
@@ -2663,6 +2655,7 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) 
	unsigned char oemfruformat;

	struct atk_fru *patkfru;

	union oemfru *poemfru;

	unsigned long flags;



	/* Reset everything except PCI configuration space */

	slic_soft_reset(adapter);
@@ -2693,14 +2686,12 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) 
		pshmem = (struct slic_shmem *)(unsigned long)

			 adapter->phys_shmem;



		spin_lock_irqsave(&adapter->bit64reglock.lock,

					adapter->bit64reglock.flags);

		spin_lock_irqsave(&adapter->bit64reglock, flags);

		slic_reg32_write(&slic_regs->slic_addr_upper,

				 SLIC_GET_ADDR_HIGH(&pshmem->isr), DONT_FLUSH);

		slic_reg32_write(&slic_regs->slic_isp,

				 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH);

		spin_unlock_irqrestore(&adapter->bit64reglock.lock,

					adapter->bit64reglock.flags);

		spin_unlock_irqrestore(&adapter->bit64reglock, flags);



		status = slic_config_get(adapter, phys_configl, phys_configh);

		if (status) {
@@ -2854,7 +2845,7 @@ static void slic_init_driver(void) 
{

	if (slic_first_init) {

		slic_first_init = 0;

		spin_lock_init(&slic_global.driver_lock.lock);

		spin_lock_init(&slic_global.driver_lock);

	}

}
@@ -2880,11 +2871,11 @@ static void slic_init_adapter(struct net_device *netdev, 
	adapter->chipid = chip_idx;

	adapter->port = 0;	/*adapter->functionnumber;*/

	adapter->cardindex = adapter->port;

	spin_lock_init(&adapter->upr_lock.lock);

	spin_lock_init(&adapter->bit64reglock.lock);

	spin_lock_init(&adapter->adapter_lock.lock);

	spin_lock_init(&adapter->reset_lock.lock);

	spin_lock_init(&adapter->handle_lock.lock);

	spin_lock_init(&adapter->upr_lock);

	spin_lock_init(&adapter->bit64reglock);

	spin_lock_init(&adapter->adapter_lock);

	spin_lock_init(&adapter->reset_lock);

	spin_lock_init(&adapter->handle_lock);



	adapter->card_size = 1;

	/*