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