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

Commit c61dace9 authored by Paul Mackerras's avatar Paul Mackerras
Browse files

[POWERPC] Convert adb.c to use kthread API and not spin on ADB requests 



This converts adb.c to use the kthread API.

It also changes adb_request so that if the ADBREQ_SYNC flag is
specified, we now sleep waiting for the request to finish using an
on-stack completion rather than spinning.  To implement this, we now
require that if the ADBREQ_SYNC flag is set, the `done' parameter must
be NULL.  All of the existing callers of adb_request that pass
ADBREQ_SYNC appear to be in process context and have done == NULL.
Doing this allows us to get rid of an awful hack in adb_request()
where we used to test whether the request was coming from the adb
probe task and use a completion if it was, and otherwise spin.

This also gets rid of a static request block that was used if the req
parameter to adb_request was NULL.  None of the callers do that any
more, so the static request block is no longer necessary.

Signed-off-by: default avatarPaul Mackerras <paulus@samba.org>
parent 33f6e794

drivers/macintosh/adb.c

+21 −57
Original line number Original line Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <linux/spinlock.h>

#include <linux/spinlock.h>

#include <linux/completion.h>

#include <linux/completion.h>

#include <linux/device.h>

#include <linux/device.h>

#include <linux/kthread.h>





#include <asm/uaccess.h>

#include <asm/uaccess.h>

#include <asm/semaphore.h>

#include <asm/semaphore.h>
@@ -82,9 +83,7 @@ struct adb_driver *adb_controller; 
BLOCKING_NOTIFIER_HEAD(adb_client_list);

BLOCKING_NOTIFIER_HEAD(adb_client_list);

static int adb_got_sleep;

static int adb_got_sleep;

static int adb_inited;

static int adb_inited;

static pid_t adb_probe_task_pid;

static DECLARE_MUTEX(adb_probe_mutex);

static DECLARE_MUTEX(adb_probe_mutex);

static struct completion adb_probe_task_comp;

static int sleepy_trackpad;

static int sleepy_trackpad;

static int autopoll_devs;

static int autopoll_devs;

int __adb_probe_sync;

int __adb_probe_sync;
@@ -126,16 +125,6 @@ static void printADBreply(struct adb_request *req) 
}

}

#endif

#endif







static __inline__ void adb_wait_ms(unsigned int ms)

{

	if (current->pid && adb_probe_task_pid &&

	  adb_probe_task_pid == current->pid)

		msleep(ms);

	else

		mdelay(ms);

}



static int adb_scan_bus(void)

static int adb_scan_bus(void)

{

{

	int i, highFree=0, noMovement;

	int i, highFree=0, noMovement;
@@ -240,13 +229,10 @@ static int adb_scan_bus(void) 
static int

static int

adb_probe_task(void *x)

adb_probe_task(void *x)

{

{

	strcpy(current->comm, "kadbprobe");



	printk(KERN_INFO "adb: starting probe task...\n");

	printk(KERN_INFO "adb: starting probe task...\n");

	do_adb_reset_bus();

	do_adb_reset_bus();

	printk(KERN_INFO "adb: finished probe task...\n");

	printk(KERN_INFO "adb: finished probe task...\n");





	adb_probe_task_pid = 0;

	up(&adb_probe_mutex);

	up(&adb_probe_mutex);





	return 0;

	return 0;
@@ -255,7 +241,7 @@ adb_probe_task(void *x) 
static void

static void

__adb_probe_task(struct work_struct *bullshit)

__adb_probe_task(struct work_struct *bullshit)

{

{

	adb_probe_task_pid = kernel_thread(adb_probe_task, NULL, SIGCHLD | CLONE_KERNEL);

	kthread_run(adb_probe_task, NULL, "kadbprobe");

}

}





static DECLARE_WORK(adb_reset_work, __adb_probe_task);

static DECLARE_WORK(adb_reset_work, __adb_probe_task);
@@ -341,7 +327,6 @@ int __init adb_init(void) 
			sleepy_trackpad = 1;

			sleepy_trackpad = 1;

#endif /* CONFIG_PPC */

#endif /* CONFIG_PPC */





		init_completion(&adb_probe_task_comp);

		adbdev_init();

		adbdev_init();

		adb_reset_bus();

		adb_reset_bus();

	}

	}
@@ -366,7 +351,7 @@ do_adb_reset_bus(void) 




	if (sleepy_trackpad) {

	if (sleepy_trackpad) {

		/* Let the trackpad settle down */

		/* Let the trackpad settle down */

		adb_wait_ms(500);

		msleep(500);

	}

	}





	down(&adb_handler_sem);

	down(&adb_handler_sem);
@@ -382,7 +367,7 @@ do_adb_reset_bus(void) 




	if (sleepy_trackpad) {

	if (sleepy_trackpad) {

		/* Let the trackpad settle down */

		/* Let the trackpad settle down */

		adb_wait_ms(1500);

		msleep(1500);

	}

	}





	if (!ret) {

	if (!ret) {
@@ -406,41 +391,27 @@ adb_poll(void) 
	adb_controller->poll();

	adb_controller->poll();

}

}





static void

static void adb_sync_req_done(struct adb_request *req)

adb_probe_wakeup(struct adb_request *req)

{

{

	complete(&adb_probe_task_comp);

	struct completion *comp = req->arg;

}





/* Static request used during probe */

	complete(comp);

static struct adb_request adb_sreq;

}

static unsigned long adb_sreq_lock; // Use semaphore ! */ 





int

int

adb_request(struct adb_request *req, void (*done)(struct adb_request *),

adb_request(struct adb_request *req, void (*done)(struct adb_request *),

	    int flags, int nbytes, ...)

	    int flags, int nbytes, ...)

{

{

	va_list list;

	va_list list;

	int i, use_sreq;

	int i;

	int rc;

	int rc;

	struct completion comp;





	if ((adb_controller == NULL) || (adb_controller->send_request == NULL))

	if ((adb_controller == NULL) || (adb_controller->send_request == NULL))

		return -ENXIO;

		return -ENXIO;

	if (nbytes < 1)

	if (nbytes < 1)

		return -EINVAL;

		return -EINVAL;

	if (req == NULL && (flags & ADBREQ_NOSEND))

		return -EINVAL;





	if (req == NULL) {

		if (test_and_set_bit(0,&adb_sreq_lock)) {

			printk("adb.c: Warning: contention on static request !\n");

			return -EPERM;

		}

		req = &adb_sreq;

		flags |= ADBREQ_SYNC;

		use_sreq = 1;

	} else

		use_sreq = 0;

	req->nbytes = nbytes+1;

	req->nbytes = nbytes+1;

	req->done = done;

	req->done = done;

	req->reply_expected = flags & ADBREQ_REPLY;

	req->reply_expected = flags & ADBREQ_REPLY;
@@ -453,25 +424,18 @@ adb_request(struct adb_request *req, void (*done)(struct adb_request *), 
	if (flags & ADBREQ_NOSEND)

	if (flags & ADBREQ_NOSEND)

		return 0;

		return 0;





	/* Synchronous requests send from the probe thread cause it to

	/* Synchronous requests block using an on-stack completion */

	 * block. Beware that the "done" callback will be overriden !

	if (flags & ADBREQ_SYNC) {

	 */

		WARN_ON(done);

	if ((flags & ADBREQ_SYNC) &&

		req->done = adb_sync_req_done;

	    (current->pid && adb_probe_task_pid &&

		req->arg = &comp;

	    adb_probe_task_pid == current->pid)) {

		init_completion(&comp);

		req->done = adb_probe_wakeup;

		rc = adb_controller->send_request(req, 0);

		if (rc || req->complete)

			goto bail;

		wait_for_completion(&adb_probe_task_comp);

		rc = 0;

		goto bail;

	}

	}





	rc = adb_controller->send_request(req, flags & ADBREQ_SYNC);

	rc = adb_controller->send_request(req, 0);

bail:



	if (use_sreq)

	if ((flags & ADBREQ_SYNC) && !rc && !req->complete)

		clear_bit(0, &adb_sreq_lock);

		wait_for_completion(&comp);





	return rc;

	return rc;

}

}