xref: /freebsd/sys/dev/usb/usb_process.c (revision 4d846d260e2b9a3d4d0a701462568268cbfe7a5b)
102ac6454SAndrew Thompson /* $FreeBSD$ */
202ac6454SAndrew Thompson /*-
3*4d846d26SWarner Losh  * SPDX-License-Identifier: BSD-2-Clause
4718cf2ccSPedro F. Giffuni  *
502ac6454SAndrew Thompson  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
602ac6454SAndrew Thompson  *
702ac6454SAndrew Thompson  * Redistribution and use in source and binary forms, with or without
802ac6454SAndrew Thompson  * modification, are permitted provided that the following conditions
902ac6454SAndrew Thompson  * are met:
1002ac6454SAndrew Thompson  * 1. Redistributions of source code must retain the above copyright
1102ac6454SAndrew Thompson  *    notice, this list of conditions and the following disclaimer.
1202ac6454SAndrew Thompson  * 2. Redistributions in binary form must reproduce the above copyright
1302ac6454SAndrew Thompson  *    notice, this list of conditions and the following disclaimer in the
1402ac6454SAndrew Thompson  *    documentation and/or other materials provided with the distribution.
1502ac6454SAndrew Thompson  *
1602ac6454SAndrew Thompson  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1702ac6454SAndrew Thompson  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1802ac6454SAndrew Thompson  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1902ac6454SAndrew Thompson  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
2002ac6454SAndrew Thompson  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2102ac6454SAndrew Thompson  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2202ac6454SAndrew Thompson  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2302ac6454SAndrew Thompson  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2402ac6454SAndrew Thompson  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2502ac6454SAndrew Thompson  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2602ac6454SAndrew Thompson  * SUCH DAMAGE.
2702ac6454SAndrew Thompson  */
2802ac6454SAndrew Thompson 
29d2b99310SHans Petter Selasky #ifdef USB_GLOBAL_INCLUDE_FILE
30d2b99310SHans Petter Selasky #include USB_GLOBAL_INCLUDE_FILE
31d2b99310SHans Petter Selasky #else
32ed6d949aSAndrew Thompson #include <sys/stdint.h>
33ed6d949aSAndrew Thompson #include <sys/stddef.h>
34ed6d949aSAndrew Thompson #include <sys/param.h>
35ed6d949aSAndrew Thompson #include <sys/queue.h>
36ed6d949aSAndrew Thompson #include <sys/types.h>
37ed6d949aSAndrew Thompson #include <sys/systm.h>
38ed6d949aSAndrew Thompson #include <sys/kernel.h>
39ed6d949aSAndrew Thompson #include <sys/bus.h>
40ed6d949aSAndrew Thompson #include <sys/module.h>
41ed6d949aSAndrew Thompson #include <sys/lock.h>
42ed6d949aSAndrew Thompson #include <sys/mutex.h>
43ed6d949aSAndrew Thompson #include <sys/condvar.h>
44ed6d949aSAndrew Thompson #include <sys/sysctl.h>
45ed6d949aSAndrew Thompson #include <sys/sx.h>
46ed6d949aSAndrew Thompson #include <sys/unistd.h>
47ed6d949aSAndrew Thompson #include <sys/callout.h>
48ed6d949aSAndrew Thompson #include <sys/malloc.h>
49ed6d949aSAndrew Thompson #include <sys/priv.h>
50ed6d949aSAndrew Thompson 
51ed6d949aSAndrew Thompson #include <dev/usb/usb.h>
52ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
53ed6d949aSAndrew Thompson #include <dev/usb/usbdi_util.h>
5402ac6454SAndrew Thompson #include <dev/usb/usb_process.h>
55ff182db6SHans Petter Selasky 
56ff182db6SHans Petter Selasky #define	USB_DEBUG_VAR usb_proc_debug
5702ac6454SAndrew Thompson #include <dev/usb/usb_debug.h>
5802ac6454SAndrew Thompson #include <dev/usb/usb_util.h>
5902ac6454SAndrew Thompson 
6002ac6454SAndrew Thompson #include <sys/proc.h>
6102ac6454SAndrew Thompson #include <sys/kthread.h>
6202ac6454SAndrew Thompson #include <sys/sched.h>
63d2b99310SHans Petter Selasky #endif			/* USB_GLOBAL_INCLUDE_FILE */
6402ac6454SAndrew Thompson 
65532b1952SAndrew Thompson static struct proc *usbproc;
6651e8c0d6SAndrew Thompson static int usb_pcount;
6702ac6454SAndrew Thompson #define	USB_THREAD_CREATE(f, s, p, ...) \
68532b1952SAndrew Thompson 		kproc_kthread_add((f), (s), &usbproc, (p), RFHIGHPID, \
69532b1952SAndrew Thompson 		    0, "usb", __VA_ARGS__)
7087a133a7SHans Petter Selasky #define	USB_THREAD_SUSPEND_CHECK() kthread_suspend_check()
71532b1952SAndrew Thompson #define	USB_THREAD_SUSPEND(p)   kthread_suspend(p,0)
72532b1952SAndrew Thompson #define	USB_THREAD_EXIT(err)	kthread_exit()
7302ac6454SAndrew Thompson 
74ed6d949aSAndrew Thompson #ifdef USB_DEBUG
75a593f6b8SAndrew Thompson static int usb_proc_debug;
7602ac6454SAndrew Thompson 
77f8d2b1f3SPawel Biernacki static SYSCTL_NODE(_hw_usb, OID_AUTO, proc, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
78f8d2b1f3SPawel Biernacki     "USB process");
79af3b2549SHans Petter Selasky SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RWTUN, &usb_proc_debug, 0,
8002ac6454SAndrew Thompson     "Debug level");
8102ac6454SAndrew Thompson #endif
8202ac6454SAndrew Thompson 
8302ac6454SAndrew Thompson /*------------------------------------------------------------------------*
84760bc48eSAndrew Thompson  *	usb_process
8502ac6454SAndrew Thompson  *
8602ac6454SAndrew Thompson  * This function is the USB process dispatcher.
8702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
8802ac6454SAndrew Thompson static void
89760bc48eSAndrew Thompson usb_process(void *arg)
9002ac6454SAndrew Thompson {
91760bc48eSAndrew Thompson 	struct usb_process *up = arg;
92760bc48eSAndrew Thompson 	struct usb_proc_msg *pm;
9302ac6454SAndrew Thompson 	struct thread *td;
9402ac6454SAndrew Thompson 
9587a133a7SHans Petter Selasky 	/* in case of attach error, check for suspended */
9687a133a7SHans Petter Selasky 	USB_THREAD_SUSPEND_CHECK();
9787a133a7SHans Petter Selasky 
9802ac6454SAndrew Thompson 	/* adjust priority */
9902ac6454SAndrew Thompson 	td = curthread;
10002ac6454SAndrew Thompson 	thread_lock(td);
10102ac6454SAndrew Thompson 	sched_prio(td, up->up_prio);
10202ac6454SAndrew Thompson 	thread_unlock(td);
10302ac6454SAndrew Thompson 
1040eb8d462SHans Petter Selasky 	USB_MTX_LOCK(up->up_mtx);
10502ac6454SAndrew Thompson 
10602ac6454SAndrew Thompson 	up->up_curtd = td;
10702ac6454SAndrew Thompson 
10802ac6454SAndrew Thompson 	while (1) {
10902ac6454SAndrew Thompson 		if (up->up_gone)
11002ac6454SAndrew Thompson 			break;
11102ac6454SAndrew Thompson 
11202ac6454SAndrew Thompson 		/*
11302ac6454SAndrew Thompson 		 * NOTE to reimplementors: dequeueing a command from the
11402ac6454SAndrew Thompson 		 * "used" queue and executing it must be atomic, with regard
11502ac6454SAndrew Thompson 		 * to the "up_mtx" mutex. That means any attempt to queue a
11602ac6454SAndrew Thompson 		 * command by another thread must be blocked until either:
11702ac6454SAndrew Thompson 		 *
11802ac6454SAndrew Thompson 		 * 1) the command sleeps
11902ac6454SAndrew Thompson 		 *
12002ac6454SAndrew Thompson 		 * 2) the command returns
12102ac6454SAndrew Thompson 		 *
12202ac6454SAndrew Thompson 		 * Here is a practical example that shows how this helps
12302ac6454SAndrew Thompson 		 * solving a problem:
12402ac6454SAndrew Thompson 		 *
12502ac6454SAndrew Thompson 		 * Assume that you want to set the baud rate on a USB serial
12602ac6454SAndrew Thompson 		 * device. During the programming of the device you don't
12702ac6454SAndrew Thompson 		 * want to receive nor transmit any data, because it will be
12802ac6454SAndrew Thompson 		 * garbage most likely anyway. The programming of our USB
12902ac6454SAndrew Thompson 		 * device takes 20 milliseconds and it needs to call
13002ac6454SAndrew Thompson 		 * functions that sleep.
13102ac6454SAndrew Thompson 		 *
13202ac6454SAndrew Thompson 		 * Non-working solution: Before we queue the programming
13302ac6454SAndrew Thompson 		 * command, we stop transmission and reception of data. Then
13402ac6454SAndrew Thompson 		 * we queue a programming command. At the end of the
13502ac6454SAndrew Thompson 		 * programming command we enable transmission and reception
13602ac6454SAndrew Thompson 		 * of data.
13702ac6454SAndrew Thompson 		 *
13802ac6454SAndrew Thompson 		 * Problem: If a second programming command is queued while the
13902ac6454SAndrew Thompson 		 * first one is sleeping, we end up enabling transmission
14002ac6454SAndrew Thompson 		 * and reception of data too early.
14102ac6454SAndrew Thompson 		 *
14202ac6454SAndrew Thompson 		 * Working solution: Before we queue the programming command,
14302ac6454SAndrew Thompson 		 * we stop transmission and reception of data. Then we queue
14402ac6454SAndrew Thompson 		 * a programming command. Then we queue a second command
14502ac6454SAndrew Thompson 		 * that only enables transmission and reception of data.
14602ac6454SAndrew Thompson 		 *
14702ac6454SAndrew Thompson 		 * Why it works: If a second programming command is queued
14802ac6454SAndrew Thompson 		 * while the first one is sleeping, then the queueing of a
14902ac6454SAndrew Thompson 		 * second command to enable the data transfers, will cause
15002ac6454SAndrew Thompson 		 * the previous one, which is still on the queue, to be
15102ac6454SAndrew Thompson 		 * removed from the queue, and re-inserted after the last
15202ac6454SAndrew Thompson 		 * baud rate programming command, which then gives the
15302ac6454SAndrew Thompson 		 * desired result.
15402ac6454SAndrew Thompson 		 */
15502ac6454SAndrew Thompson 		pm = TAILQ_FIRST(&up->up_qhead);
15602ac6454SAndrew Thompson 
15702ac6454SAndrew Thompson 		if (pm) {
15802ac6454SAndrew Thompson 			DPRINTF("Message pm=%p, cb=%p (enter)\n",
15902ac6454SAndrew Thompson 			    pm, pm->pm_callback);
16002ac6454SAndrew Thompson 
16102ac6454SAndrew Thompson 			(pm->pm_callback) (pm);
16202ac6454SAndrew Thompson 
16302ac6454SAndrew Thompson 			if (pm == TAILQ_FIRST(&up->up_qhead)) {
16402ac6454SAndrew Thompson 				/* nothing changed */
16502ac6454SAndrew Thompson 				TAILQ_REMOVE(&up->up_qhead, pm, pm_qentry);
16602ac6454SAndrew Thompson 				pm->pm_qentry.tqe_prev = NULL;
16702ac6454SAndrew Thompson 			}
16802ac6454SAndrew Thompson 			DPRINTF("Message pm=%p (leave)\n", pm);
16902ac6454SAndrew Thompson 
17002ac6454SAndrew Thompson 			continue;
17102ac6454SAndrew Thompson 		}
172c0f71e31SHans Petter Selasky 		/* end of messages - check if anyone is waiting for sync */
17302ac6454SAndrew Thompson 		if (up->up_dsleep) {
17402ac6454SAndrew Thompson 			up->up_dsleep = 0;
1758437751dSAndrew Thompson 			cv_broadcast(&up->up_drain);
17602ac6454SAndrew Thompson 		}
17702ac6454SAndrew Thompson 		up->up_msleep = 1;
1788437751dSAndrew Thompson 		cv_wait(&up->up_cv, up->up_mtx);
17902ac6454SAndrew Thompson 	}
18002ac6454SAndrew Thompson 
18102ac6454SAndrew Thompson 	up->up_ptr = NULL;
1828437751dSAndrew Thompson 	cv_signal(&up->up_cv);
1830eb8d462SHans Petter Selasky 	USB_MTX_UNLOCK(up->up_mtx);
18451e8c0d6SAndrew Thompson 	/* Clear the proc pointer if this is the last thread. */
18551e8c0d6SAndrew Thompson 	if (--usb_pcount == 0)
18651e8c0d6SAndrew Thompson 		usbproc = NULL;
18702ac6454SAndrew Thompson 
18802ac6454SAndrew Thompson 	USB_THREAD_EXIT(0);
18902ac6454SAndrew Thompson }
19002ac6454SAndrew Thompson 
19102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
192a593f6b8SAndrew Thompson  *	usb_proc_create
19302ac6454SAndrew Thompson  *
19402ac6454SAndrew Thompson  * This function will create a process using the given "prio" that can
19502ac6454SAndrew Thompson  * execute callbacks. The mutex pointed to by "p_mtx" will be applied
19602ac6454SAndrew Thompson  * before calling the callbacks and released after that the callback
19702ac6454SAndrew Thompson  * has returned. The structure pointed to by "up" is assumed to be
19802ac6454SAndrew Thompson  * zeroed before this function is called.
19902ac6454SAndrew Thompson  *
20002ac6454SAndrew Thompson  * Return values:
20102ac6454SAndrew Thompson  *    0: success
20202ac6454SAndrew Thompson  * Else: failure
20302ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
20402ac6454SAndrew Thompson int
205a593f6b8SAndrew Thompson usb_proc_create(struct usb_process *up, struct mtx *p_mtx,
20602ac6454SAndrew Thompson     const char *pmesg, uint8_t prio)
20702ac6454SAndrew Thompson {
20802ac6454SAndrew Thompson 	up->up_mtx = p_mtx;
20902ac6454SAndrew Thompson 	up->up_prio = prio;
21002ac6454SAndrew Thompson 
21102ac6454SAndrew Thompson 	TAILQ_INIT(&up->up_qhead);
21202ac6454SAndrew Thompson 
213532b1952SAndrew Thompson 	cv_init(&up->up_cv, "-");
214532b1952SAndrew Thompson 	cv_init(&up->up_drain, "usbdrain");
21502ac6454SAndrew Thompson 
216760bc48eSAndrew Thompson 	if (USB_THREAD_CREATE(&usb_process, up,
2171bdfff22SAndriy Gapon 	    &up->up_ptr, "%s", pmesg)) {
21802ac6454SAndrew Thompson 		DPRINTFN(0, "Unable to create USB process.");
21902ac6454SAndrew Thompson 		up->up_ptr = NULL;
22002ac6454SAndrew Thompson 		goto error;
22102ac6454SAndrew Thompson 	}
22251e8c0d6SAndrew Thompson 	usb_pcount++;
22302ac6454SAndrew Thompson 	return (0);
22402ac6454SAndrew Thompson 
22502ac6454SAndrew Thompson error:
226a593f6b8SAndrew Thompson 	usb_proc_free(up);
22702ac6454SAndrew Thompson 	return (ENOMEM);
22802ac6454SAndrew Thompson }
22902ac6454SAndrew Thompson 
23002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
231a593f6b8SAndrew Thompson  *	usb_proc_free
23202ac6454SAndrew Thompson  *
23302ac6454SAndrew Thompson  * NOTE: If the structure pointed to by "up" is all zero, this
23402ac6454SAndrew Thompson  * function does nothing.
23502ac6454SAndrew Thompson  *
23602ac6454SAndrew Thompson  * NOTE: Messages that are pending on the process queue will not be
23702ac6454SAndrew Thompson  * removed nor called.
23802ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
23902ac6454SAndrew Thompson void
240a593f6b8SAndrew Thompson usb_proc_free(struct usb_process *up)
24102ac6454SAndrew Thompson {
24202ac6454SAndrew Thompson 	/* check if not initialised */
24302ac6454SAndrew Thompson 	if (up->up_mtx == NULL)
24402ac6454SAndrew Thompson 		return;
24502ac6454SAndrew Thompson 
246a593f6b8SAndrew Thompson 	usb_proc_drain(up);
24702ac6454SAndrew Thompson 
2488437751dSAndrew Thompson 	cv_destroy(&up->up_cv);
2498437751dSAndrew Thompson 	cv_destroy(&up->up_drain);
25002ac6454SAndrew Thompson 
25102ac6454SAndrew Thompson 	/* make sure that we do not enter here again */
25202ac6454SAndrew Thompson 	up->up_mtx = NULL;
25302ac6454SAndrew Thompson }
25402ac6454SAndrew Thompson 
25502ac6454SAndrew Thompson /*------------------------------------------------------------------------*
256a593f6b8SAndrew Thompson  *	usb_proc_msignal
25702ac6454SAndrew Thompson  *
25802ac6454SAndrew Thompson  * This function will queue one of the passed USB process messages on
25902ac6454SAndrew Thompson  * the USB process queue. The first message that is not already queued
26002ac6454SAndrew Thompson  * will get queued. If both messages are already queued the one queued
26102ac6454SAndrew Thompson  * last will be removed from the queue and queued in the end. The USB
26202ac6454SAndrew Thompson  * process mutex must be locked when calling this function. This
26302ac6454SAndrew Thompson  * function exploits the fact that a process can only do one callback
26402ac6454SAndrew Thompson  * at a time. The message that was queued is returned.
26502ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
26602ac6454SAndrew Thompson void   *
267a593f6b8SAndrew Thompson usb_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1)
26802ac6454SAndrew Thompson {
269760bc48eSAndrew Thompson 	struct usb_proc_msg *pm0 = _pm0;
270760bc48eSAndrew Thompson 	struct usb_proc_msg *pm1 = _pm1;
271760bc48eSAndrew Thompson 	struct usb_proc_msg *pm2;
272f9cb546cSAndrew Thompson 	usb_size_t d;
27302ac6454SAndrew Thompson 	uint8_t t;
27402ac6454SAndrew Thompson 
2750eb8d462SHans Petter Selasky 	/* check if gone or in polling mode, return dummy value */
2760eb8d462SHans Petter Selasky 	if (up->up_gone != 0 ||
2770eb8d462SHans Petter Selasky 	    USB_IN_POLLING_MODE_FUNC() != 0)
27802ac6454SAndrew Thompson 		return (_pm0);
27902ac6454SAndrew Thompson 
2800eb8d462SHans Petter Selasky 	USB_MTX_ASSERT(up->up_mtx, MA_OWNED);
28102ac6454SAndrew Thompson 
28202ac6454SAndrew Thompson 	t = 0;
28302ac6454SAndrew Thompson 
28402ac6454SAndrew Thompson 	if (pm0->pm_qentry.tqe_prev) {
28502ac6454SAndrew Thompson 		t |= 1;
28602ac6454SAndrew Thompson 	}
28702ac6454SAndrew Thompson 	if (pm1->pm_qentry.tqe_prev) {
28802ac6454SAndrew Thompson 		t |= 2;
28902ac6454SAndrew Thompson 	}
29002ac6454SAndrew Thompson 	if (t == 0) {
29102ac6454SAndrew Thompson 		/*
29202ac6454SAndrew Thompson 		 * No entries are queued. Queue "pm0" and use the existing
29302ac6454SAndrew Thompson 		 * message number.
29402ac6454SAndrew Thompson 		 */
29502ac6454SAndrew Thompson 		pm2 = pm0;
29602ac6454SAndrew Thompson 	} else if (t == 1) {
29702ac6454SAndrew Thompson 		/* Check if we need to increment the message number. */
29802ac6454SAndrew Thompson 		if (pm0->pm_num == up->up_msg_num) {
29902ac6454SAndrew Thompson 			up->up_msg_num++;
30002ac6454SAndrew Thompson 		}
30102ac6454SAndrew Thompson 		pm2 = pm1;
30202ac6454SAndrew Thompson 	} else if (t == 2) {
30302ac6454SAndrew Thompson 		/* Check if we need to increment the message number. */
30402ac6454SAndrew Thompson 		if (pm1->pm_num == up->up_msg_num) {
30502ac6454SAndrew Thompson 			up->up_msg_num++;
30602ac6454SAndrew Thompson 		}
30702ac6454SAndrew Thompson 		pm2 = pm0;
30802ac6454SAndrew Thompson 	} else if (t == 3) {
30902ac6454SAndrew Thompson 		/*
31002ac6454SAndrew Thompson 		 * Both entries are queued. Re-queue the entry closest to
31102ac6454SAndrew Thompson 		 * the end.
31202ac6454SAndrew Thompson 		 */
31302ac6454SAndrew Thompson 		d = (pm1->pm_num - pm0->pm_num);
31402ac6454SAndrew Thompson 
31502ac6454SAndrew Thompson 		/* Check sign after subtraction */
31602ac6454SAndrew Thompson 		if (d & 0x80000000) {
31702ac6454SAndrew Thompson 			pm2 = pm0;
31802ac6454SAndrew Thompson 		} else {
31902ac6454SAndrew Thompson 			pm2 = pm1;
32002ac6454SAndrew Thompson 		}
32102ac6454SAndrew Thompson 
32202ac6454SAndrew Thompson 		TAILQ_REMOVE(&up->up_qhead, pm2, pm_qentry);
32302ac6454SAndrew Thompson 	} else {
32402ac6454SAndrew Thompson 		pm2 = NULL;		/* panic - should not happen */
32502ac6454SAndrew Thompson 	}
32602ac6454SAndrew Thompson 
32702ac6454SAndrew Thompson 	DPRINTF(" t=%u, num=%u\n", t, up->up_msg_num);
32802ac6454SAndrew Thompson 
32902ac6454SAndrew Thompson 	/* Put message last on queue */
33002ac6454SAndrew Thompson 
33102ac6454SAndrew Thompson 	pm2->pm_num = up->up_msg_num;
33202ac6454SAndrew Thompson 	TAILQ_INSERT_TAIL(&up->up_qhead, pm2, pm_qentry);
33302ac6454SAndrew Thompson 
33402ac6454SAndrew Thompson 	/* Check if we need to wakeup the USB process. */
33502ac6454SAndrew Thompson 
33602ac6454SAndrew Thompson 	if (up->up_msleep) {
33702ac6454SAndrew Thompson 		up->up_msleep = 0;	/* save "cv_signal()" calls */
3388437751dSAndrew Thompson 		cv_signal(&up->up_cv);
33902ac6454SAndrew Thompson 	}
34002ac6454SAndrew Thompson 	return (pm2);
34102ac6454SAndrew Thompson }
34202ac6454SAndrew Thompson 
34302ac6454SAndrew Thompson /*------------------------------------------------------------------------*
344a593f6b8SAndrew Thompson  *	usb_proc_is_gone
34502ac6454SAndrew Thompson  *
34602ac6454SAndrew Thompson  * Return values:
34702ac6454SAndrew Thompson  *    0: USB process is running
34802ac6454SAndrew Thompson  * Else: USB process is tearing down
34902ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
35002ac6454SAndrew Thompson uint8_t
351a593f6b8SAndrew Thompson usb_proc_is_gone(struct usb_process *up)
35202ac6454SAndrew Thompson {
35302ac6454SAndrew Thompson 	if (up->up_gone)
35402ac6454SAndrew Thompson 		return (1);
35502ac6454SAndrew Thompson 
3560c38ca8cSHans Petter Selasky 	/*
3570c38ca8cSHans Petter Selasky 	 * Allow calls when up_mtx is NULL, before the USB process
3580c38ca8cSHans Petter Selasky 	 * structure is initialised.
3590c38ca8cSHans Petter Selasky 	 */
3600c38ca8cSHans Petter Selasky 	if (up->up_mtx != NULL)
3610eb8d462SHans Petter Selasky 		USB_MTX_ASSERT(up->up_mtx, MA_OWNED);
36202ac6454SAndrew Thompson 	return (0);
36302ac6454SAndrew Thompson }
36402ac6454SAndrew Thompson 
36502ac6454SAndrew Thompson /*------------------------------------------------------------------------*
366a593f6b8SAndrew Thompson  *	usb_proc_mwait
36702ac6454SAndrew Thompson  *
36802ac6454SAndrew Thompson  * This function will return when the USB process message pointed to
36902ac6454SAndrew Thompson  * by "pm" is no longer on a queue. This function must be called
37002ac6454SAndrew Thompson  * having "up->up_mtx" locked.
37102ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
37202ac6454SAndrew Thompson void
373a593f6b8SAndrew Thompson usb_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
37402ac6454SAndrew Thompson {
375760bc48eSAndrew Thompson 	struct usb_proc_msg *pm0 = _pm0;
376760bc48eSAndrew Thompson 	struct usb_proc_msg *pm1 = _pm1;
37702ac6454SAndrew Thompson 
37802ac6454SAndrew Thompson 	/* check if gone */
37902ac6454SAndrew Thompson 	if (up->up_gone)
38002ac6454SAndrew Thompson 		return;
38102ac6454SAndrew Thompson 
3820eb8d462SHans Petter Selasky 	USB_MTX_ASSERT(up->up_mtx, MA_OWNED);
38302ac6454SAndrew Thompson 
38402ac6454SAndrew Thompson 	if (up->up_curtd == curthread) {
38502ac6454SAndrew Thompson 		/* Just remove the messages from the queue. */
38602ac6454SAndrew Thompson 		if (pm0->pm_qentry.tqe_prev) {
38702ac6454SAndrew Thompson 			TAILQ_REMOVE(&up->up_qhead, pm0, pm_qentry);
38802ac6454SAndrew Thompson 			pm0->pm_qentry.tqe_prev = NULL;
38902ac6454SAndrew Thompson 		}
39002ac6454SAndrew Thompson 		if (pm1->pm_qentry.tqe_prev) {
39102ac6454SAndrew Thompson 			TAILQ_REMOVE(&up->up_qhead, pm1, pm_qentry);
39202ac6454SAndrew Thompson 			pm1->pm_qentry.tqe_prev = NULL;
39302ac6454SAndrew Thompson 		}
39402ac6454SAndrew Thompson 	} else
39502ac6454SAndrew Thompson 		while (pm0->pm_qentry.tqe_prev ||
39602ac6454SAndrew Thompson 		    pm1->pm_qentry.tqe_prev) {
39702ac6454SAndrew Thompson 			/* check if config thread is gone */
39802ac6454SAndrew Thompson 			if (up->up_gone)
39902ac6454SAndrew Thompson 				break;
40002ac6454SAndrew Thompson 			up->up_dsleep = 1;
4018437751dSAndrew Thompson 			cv_wait(&up->up_drain, up->up_mtx);
40202ac6454SAndrew Thompson 		}
40302ac6454SAndrew Thompson }
40402ac6454SAndrew Thompson 
40502ac6454SAndrew Thompson /*------------------------------------------------------------------------*
406a593f6b8SAndrew Thompson  *	usb_proc_drain
40702ac6454SAndrew Thompson  *
40802ac6454SAndrew Thompson  * This function will tear down an USB process, waiting for the
40902ac6454SAndrew Thompson  * currently executing command to return.
41002ac6454SAndrew Thompson  *
41102ac6454SAndrew Thompson  * NOTE: If the structure pointed to by "up" is all zero,
41202ac6454SAndrew Thompson  * this function does nothing.
41302ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
41402ac6454SAndrew Thompson void
415a593f6b8SAndrew Thompson usb_proc_drain(struct usb_process *up)
41602ac6454SAndrew Thompson {
41702ac6454SAndrew Thompson 	/* check if not initialised */
41802ac6454SAndrew Thompson 	if (up->up_mtx == NULL)
41902ac6454SAndrew Thompson 		return;
42002ac6454SAndrew Thompson 	/* handle special case with Giant */
42102ac6454SAndrew Thompson 	if (up->up_mtx != &Giant)
4220eb8d462SHans Petter Selasky 		USB_MTX_ASSERT(up->up_mtx, MA_NOTOWNED);
42302ac6454SAndrew Thompson 
4240eb8d462SHans Petter Selasky 	USB_MTX_LOCK(up->up_mtx);
42502ac6454SAndrew Thompson 
42602ac6454SAndrew Thompson 	/* Set the gone flag */
42702ac6454SAndrew Thompson 
42802ac6454SAndrew Thompson 	up->up_gone = 1;
42902ac6454SAndrew Thompson 
43002ac6454SAndrew Thompson 	while (up->up_ptr) {
43102ac6454SAndrew Thompson 		/* Check if we need to wakeup the USB process */
43202ac6454SAndrew Thompson 
43302ac6454SAndrew Thompson 		if (up->up_msleep || up->up_csleep) {
43402ac6454SAndrew Thompson 			up->up_msleep = 0;
43502ac6454SAndrew Thompson 			up->up_csleep = 0;
4368437751dSAndrew Thompson 			cv_signal(&up->up_cv);
43702ac6454SAndrew Thompson 		}
438433ded8bSHans Petter Selasky #ifndef EARLY_AP_STARTUP
43902ac6454SAndrew Thompson 		/* Check if we are still cold booted */
44002ac6454SAndrew Thompson 		if (cold) {
44102ac6454SAndrew Thompson 			USB_THREAD_SUSPEND(up->up_ptr);
44202ac6454SAndrew Thompson 			printf("WARNING: A USB process has "
443767cb2e2SAndrew Thompson 			    "been left suspended\n");
44402ac6454SAndrew Thompson 			break;
44502ac6454SAndrew Thompson 		}
446433ded8bSHans Petter Selasky #endif
4478437751dSAndrew Thompson 		cv_wait(&up->up_cv, up->up_mtx);
44802ac6454SAndrew Thompson 	}
44902ac6454SAndrew Thompson 	/* Check if someone is waiting - should not happen */
45002ac6454SAndrew Thompson 
45102ac6454SAndrew Thompson 	if (up->up_dsleep) {
45202ac6454SAndrew Thompson 		up->up_dsleep = 0;
4538437751dSAndrew Thompson 		cv_broadcast(&up->up_drain);
45402ac6454SAndrew Thompson 		DPRINTF("WARNING: Someone is waiting "
45502ac6454SAndrew Thompson 		    "for USB process drain!\n");
45602ac6454SAndrew Thompson 	}
4570eb8d462SHans Petter Selasky 	USB_MTX_UNLOCK(up->up_mtx);
45802ac6454SAndrew Thompson }
459cb18f7d1SAlfred Perlstein 
460cb18f7d1SAlfred Perlstein /*------------------------------------------------------------------------*
461cb18f7d1SAlfred Perlstein  *	usb_proc_rewakeup
462cb18f7d1SAlfred Perlstein  *
4636bccea7cSRebecca Cran  * This function is called to re-wakeup the given USB
464cb18f7d1SAlfred Perlstein  * process. This usually happens after that the USB system has been in
465cb18f7d1SAlfred Perlstein  * polling mode, like during a panic. This function must be called
466cb18f7d1SAlfred Perlstein  * having "up->up_mtx" locked.
467cb18f7d1SAlfred Perlstein  *------------------------------------------------------------------------*/
468cb18f7d1SAlfred Perlstein void
469cb18f7d1SAlfred Perlstein usb_proc_rewakeup(struct usb_process *up)
470cb18f7d1SAlfred Perlstein {
471cb18f7d1SAlfred Perlstein 	/* check if not initialised */
472cb18f7d1SAlfred Perlstein 	if (up->up_mtx == NULL)
473cb18f7d1SAlfred Perlstein 		return;
474cb18f7d1SAlfred Perlstein 	/* check if gone */
475cb18f7d1SAlfred Perlstein 	if (up->up_gone)
476cb18f7d1SAlfred Perlstein 		return;
477cb18f7d1SAlfred Perlstein 
4780eb8d462SHans Petter Selasky 	USB_MTX_ASSERT(up->up_mtx, MA_OWNED);
479cb18f7d1SAlfred Perlstein 
480cb18f7d1SAlfred Perlstein 	if (up->up_msleep == 0) {
481cb18f7d1SAlfred Perlstein 		/* re-wakeup */
482cb18f7d1SAlfred Perlstein 		cv_signal(&up->up_cv);
483cb18f7d1SAlfred Perlstein 	}
484cb18f7d1SAlfred Perlstein }
485d008478eSHans Petter Selasky 
486d008478eSHans Petter Selasky /*------------------------------------------------------------------------*
487d008478eSHans Petter Selasky  *	usb_proc_is_called_from
488d008478eSHans Petter Selasky  *
489d008478eSHans Petter Selasky  * This function will return non-zero if called from inside the USB
490d008478eSHans Petter Selasky  * process passed as first argument. Else this function returns zero.
491d008478eSHans Petter Selasky  *------------------------------------------------------------------------*/
492d008478eSHans Petter Selasky int
493d008478eSHans Petter Selasky usb_proc_is_called_from(struct usb_process *up)
494d008478eSHans Petter Selasky {
495d008478eSHans Petter Selasky 	return (up->up_curtd == curthread);
496d008478eSHans Petter Selasky }
497