Commit 2a727f60 authored by Arnd Bergmann's avatar Arnd Bergmann Committed by Bjorn Helgaas
Browse files

PCI: ibmphp: Turn semaphores into completions or mutexes 



The sem_exit variable is conceptually a completion, so it should be called
that.

Similarly, the semOperations semaphore is a simple mutex, and can be
changed into that, respectively.

With both converted, the ibmphp_hpc_initvars() function is no longer used
and can be removed.

Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
Signed-off-by: default avatarBjorn Helgaas <bhelgaas@google.com>
parent 25bd879e

drivers/pci/hotplug/ibmphp.h

+0 −1
Original line number Diff line number Diff line
@@ -378,7 +378,6 @@ int ibmphp_add_pfmem_from_mem(struct resource_node *); 
struct bus_node *ibmphp_find_res_bus(u8);

void ibmphp_print_test(void);	/* for debugging purposes */



void ibmphp_hpc_initvars(void);

int ibmphp_hpc_readslot(struct slot *, u8, u8 *);

int ibmphp_hpc_writeslot(struct slot *, u8);

void ibmphp_lock_operations(void);

drivers/pci/hotplug/ibmphp_core.c

+0 −2
Original line number Diff line number Diff line
@@ -1277,8 +1277,6 @@ static int __init ibmphp_init(void) 


	ibmphp_debug = debug;



	ibmphp_hpc_initvars();



	for (i = 0; i < 16; i++)

		irqs[i] = 0;

drivers/pci/hotplug/ibmphp_hpc.c

+14 −33
Original line number Diff line number Diff line
@@ -15,13 +15,13 @@ 


#include <linux/wait.h>

#include <linux/time.h>

#include <linux/completion.h>

#include <linux/delay.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <linux/init.h>

#include <linux/mutex.h>

#include <linux/sched.h>

#include <linux/semaphore.h>

#include <linux/kthread.h>

#include "ibmphp.h"
@@ -88,10 +88,10 @@ static int to_debug = 0; 
//----------------------------------------------------------------------------

// global variables

//----------------------------------------------------------------------------

static struct mutex sem_hpcaccess;	// lock access to HPC

static struct semaphore semOperations;	// lock all operations and

static DEFINE_MUTEX(sem_hpcaccess);	// lock access to HPC

static DEFINE_MUTEX(operations_mutex);	// lock all operations and

					// access to data structures

static struct semaphore sem_exit;	// make sure polling thread goes away

static DECLARE_COMPLETION(exit_complete); // make sure polling thread goes away

static struct task_struct *ibmphp_poll_thread;

//----------------------------------------------------------------------------

// local function prototypes
@@ -109,23 +109,6 @@ static int hpc_wait_ctlr_notworking(int, struct controller *, void __iomem *, u8 
//----------------------------------------------------------------------------





/*----------------------------------------------------------------------

* Name:    ibmphp_hpc_initvars

*

* Action:  initialize semaphores and variables

*---------------------------------------------------------------------*/

void __init ibmphp_hpc_initvars(void)

{

	debug("%s - Entry\n", __func__);



	mutex_init(&sem_hpcaccess);

	sema_init(&semOperations, 1);

	sema_init(&sem_exit, 0);

	to_debug = 0;



	debug("%s - Exit\n", __func__);

}



/*----------------------------------------------------------------------

* Name:    i2c_ctrl_read

*
@@ -780,7 +763,7 @@ void free_hpc_access(void) 
*---------------------------------------------------------------------*/

void ibmphp_lock_operations(void)

{

	down(&semOperations);

	mutex_lock(&operations_mutex);

	to_debug = 1;

}
@@ -790,7 +773,7 @@ void ibmphp_lock_operations(void) 
void ibmphp_unlock_operations(void)

{

	debug("%s - Entry\n", __func__);

	up(&semOperations);

	mutex_unlock(&operations_mutex);

	to_debug = 0;

	debug("%s - Exit\n", __func__);

}
@@ -816,7 +799,7 @@ static int poll_hpc(void *data) 


	while (!kthread_should_stop()) {

		/* try to get the lock to do some kind of hardware access */

		down(&semOperations);

		mutex_lock(&operations_mutex);



		switch (poll_state) {

		case POLL_LATCH_REGISTER:
@@ -871,13 +854,13 @@ static int poll_hpc(void *data) 
			break;

		case POLL_SLEEP:

			/* don't sleep with a lock on the hardware */

			up(&semOperations);

			mutex_unlock(&operations_mutex);

			msleep(POLL_INTERVAL_SEC * 1000);



			if (kthread_should_stop())

				goto out_sleep;



			down(&semOperations);

			mutex_lock(&operations_mutex);



			if (poll_count >= POLL_LATCH_CNT) {

				poll_count = 0;
@@ -887,12 +870,12 @@ static int poll_hpc(void *data) 
			break;

		}

		/* give up the hardware semaphore */

		up(&semOperations);

		mutex_unlock(&operations_mutex);

		/* sleep for a short time just for good measure */

out_sleep:

		msleep(100);

	}

	up(&sem_exit);

	complete(&exit_complete);

	debug("%s - Exit\n", __func__);

	return 0;

}
@@ -1060,9 +1043,9 @@ void __exit ibmphp_hpc_stop_poll_thread(void) 
	debug("after locking operations\n");



	// wait for poll thread to exit

	debug("before sem_exit down\n");

	down(&sem_exit);

	debug("after sem_exit down\n");

	debug("before exit_complete down\n");

	wait_for_completion(&exit_complete);

	debug("after exit_completion down\n");



	// cleanup

	debug("before free_hpc_access\n");
@@ -1070,8 +1053,6 @@ void __exit ibmphp_hpc_stop_poll_thread(void) 
	debug("after free_hpc_access\n");

	ibmphp_unlock_operations();

	debug("after unlock operations\n");

	up(&sem_exit);

	debug("after sem exit up\n");



	debug("%s - Exit\n", __func__);

}