 @@ -1,41 +1,41 @@
-/*	$NetBSD: ata.c,v 1.132.8.25 2017/08/12 09:52:28 jdolecek Exp $	*/
+/*	$NetBSD: ata.c,v 1.132.8.26 2017/08/12 14:41:54 jdolecek Exp $	*/
 /*
  * Copyright (c) 1998, 2001 Manuel Bouyer.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ata.c,v 1.132.8.25 2017/08/12 09:52:28 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ata.c,v 1.132.8.26 2017/08/12 14:41:54 jdolecek Exp $");
 #include "opt_ata.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/fcntl.h>
 #include <sys/proc.h>
 #include <sys/kthread.h>
 #include <sys/errno.h>
 @@ -121,27 +121,27 @@ const struct cdevsw atabus_cdevsw = {
 	.d_flag = D_OTHER
 };
 extern struct cfdriver atabus_cd;
 static void atabus_childdetached(device_t, device_t);
 static int atabus_rescan(device_t, const char *, const int *);
 static bool atabus_resume(device_t, const pmf_qual_t *);
 static bool atabus_suspend(device_t, const pmf_qual_t *);
 static void atabusconfig_thread(void *);
 static void ata_channel_idle(struct ata_channel *);
 static void ata_activate_xfer_locked(struct ata_channel *, struct ata_xfer *);
 static void ata_channel_freeze_locked(struct ata_channel *);
 /*
  * atabus_init:
+ *
  *	Initialize ATA subsystem structures.
  */
 static int
 atabus_init(void)
+{
 	TAILQ_INIT(&atabus_initq_head);
 	mutex_init(&atabus_qlock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&atabus_qcv, "atainitq");
 	return 0;
 @@ -312,131 +312,139 @@ ata_queue_free(struct ata_queue *chq)
 	for (uint8_t i = 0; i < chq->queue_openings; i++)
 		ata_xfer_destroy(&chq->queue_xfers[i]);
 	cv_destroy(&chq->queue_busy);
 	cv_destroy(&chq->queue_drain);
 	free(chq, M_DEVBUF);
+}
 void
 ata_channel_init(struct ata_channel *chp)
+{
 	mutex_init(&chp->ch_lock, MUTEX_DEFAULT, IPL_BIO);
 	cv_init(&chp->ch_thr_idle, "atath");
+}
 /*
  * ata_channel_attach:
+ *
  *	Common parts of attaching an atabus to an ATA controller channel.
  */
 void
 ata_channel_attach(struct ata_channel *chp)
+{
 	if (chp->ch_flags & ATACH_DISABLED)
 		return;
 	KASSERT(chp->ch_queue != NULL);
 	ata_channel_init(chp);
 	chp->atabus = config_found_ia(chp->ch_atac->atac_dev, "ata", chp,
 		atabusprint);
+}
 void
 ata_channel_destroy(struct ata_channel *chp)
+{
 	mutex_destroy(&chp->ch_lock);
 	cv_destroy(&chp->ch_thr_idle);
+}
 /*
  * ata_channel_detach:
+ *
  *	Common parts of detaching an atabus to an ATA controller channel.
  */
 void
 ata_channel_detach(struct ata_channel *chp)
+{
 	if (chp->ch_flags & ATACH_DISABLED)
 		return;
 	ata_channel_destroy(chp);
+}
 static void
 atabusconfig(struct atabus_softc *atabus_sc)
+{
 	struct ata_channel *chp = atabus_sc->sc_chan;
 	struct atac_softc *atac = chp->ch_atac;
 	struct atabus_initq *atabus_initq = NULL;
-	int i, s, error;
+	int i, error;
 	/* we are in the atabus's thread context */
-	s = splbio();
+	mutex_enter(&chp->ch_lock);
 	chp->ch_flags |= ATACH_TH_RUN;
-	splx(s);
+	mutex_exit(&chp->ch_lock);
 	/*
 	 * Probe for the drives attached to controller, unless a PMP
 	 * is already known
 	 */
 	/* XXX for SATA devices we will power up all drives at once */
 	if (chp->ch_satapmp_nports == 0)
 		(*atac->atac_probe)(chp);
 	if (chp->ch_ndrives >= 2) {
 		ATADEBUG_PRINT(("atabusattach: ch_drive_type 0x%x 0x%x\n",
 		    chp->ch_drive[0].drive_type, chp->ch_drive[1].drive_type),
 		    DEBUG_PROBE);
+	}
 	/* next operations will occurs in a separate thread */
-	s = splbio();
+	mutex_enter(&chp->ch_lock);
 	chp->ch_flags &= ~ATACH_TH_RUN;
-	splx(s);
+	mutex_exit(&chp->ch_lock);
 	/* Make sure the devices probe in atabus order to avoid jitter. */
 	mutex_enter(&atabus_qlock);
 	for (;;) {
 		atabus_initq = TAILQ_FIRST(&atabus_initq_head);
 		if (atabus_initq->atabus_sc == atabus_sc)
 			break;
 		cv_wait(&atabus_qcv, &atabus_qlock);
+	}
 	mutex_exit(&atabus_qlock);
 	mutex_enter(&chp->ch_lock);
 	/* If no drives, abort here */
 	if (chp->ch_drive == NULL)
 		goto out;
 	KASSERT(chp->ch_ndrives == 0 || chp->ch_drive != NULL);
 	for (i = 0; i < chp->ch_ndrives; i++)
 		if (chp->ch_drive[i].drive_type != ATA_DRIVET_NONE)
 			break;
 	if (i == chp->ch_ndrives)
 		goto out;
 	/* Shortcut in case we've been shutdown */
 	if (chp->ch_flags & ATACH_SHUTDOWN)
 		goto out;
 	mutex_exit(&chp->ch_lock);
 	if ((error = kthread_create(PRI_NONE, 0, NULL, atabusconfig_thread,
 	    atabus_sc, &atabus_cfg_lwp,
 	    "%scnf", device_xname(atac->atac_dev))) != 0)
 		aprint_error_dev(atac->atac_dev,
 		    "unable to create config thread: error %d\n", error);
 	return;
  out:
 	mutex_exit(&chp->ch_lock);
 	mutex_enter(&atabus_qlock);
 	TAILQ_REMOVE(&atabus_initq_head, atabus_initq, atabus_initq);
 	cv_broadcast(&atabus_qcv);
 	mutex_exit(&atabus_qlock);
 	free(atabus_initq, M_DEVBUF);
 	ata_delref(chp);
 	config_pending_decr(atac->atac_dev);
+}
 /*
 @@ -568,89 +576,104 @@ atabusconfig_thread(void *arg)
 /*
  * atabus_thread:
+ *
  *	Worker thread for the ATA bus.
  */
 static void
 atabus_thread(void *arg)
+{
 	struct atabus_softc *sc = arg;
 	struct ata_channel *chp = sc->sc_chan;
 	struct ata_queue *chq = chp->ch_queue;
 	struct ata_xfer *xfer;
-	int i, s;
+	int i;
-	s = splbio();
+	mutex_enter(&chp->ch_lock);
 	chp->ch_flags |= ATACH_TH_RUN;
 	/*
 	 * Probe the drives.  Reset type to indicate to controllers
 	 * that can re-probe that all drives must be probed..
+	 *
 	 * Note: ch_ndrives may be changed during the probe.
 	 */
 	KASSERT(chp->ch_ndrives == 0 || chp->ch_drive != NULL);
 	for (i = 0; i < chp->ch_ndrives; i++) {
 		chp->ch_drive[i].drive_flags = 0;
 		chp->ch_drive[i].drive_type = ATA_DRIVET_NONE;
+	}
-	splx(s);
+	mutex_exit(&chp->ch_lock);
 	atabusconfig(sc);
-	s = splbio();
+	mutex_enter(&chp->ch_lock);
 	for (;;) {
 		if ((chp->ch_flags & (ATACH_TH_RESET | ATACH_SHUTDOWN)) == 0 &&
 		    (chq->queue_active == 0 || chq->queue_freeze == 0)) {
 			chp->ch_flags &= ~ATACH_TH_RUN;
-			(void) tsleep(&chp->ch_thread, PRIBIO, "atath", 0);
+			cv_wait(&chp->ch_thr_idle, &chp->ch_lock);
 			chp->ch_flags |= ATACH_TH_RUN;
+		}
 		if (chp->ch_flags & ATACH_SHUTDOWN) {
 			break;
+		}
 		if (chp->ch_flags & ATACH_TH_RESCAN) {
 			atabusconfig(sc);
 			chp->ch_flags &= ~ATACH_TH_RESCAN;
 			mutex_exit(&chp->ch_lock);
 			atabusconfig(sc);
 			mutex_enter(&chp->ch_lock);
+		}
 		if (chp->ch_flags & ATACH_TH_RESET) {
 			/*
 			 * ata_reset_channel() will freeze 2 times, so
 			 * unfreeze one time. Not a problem as we're at splbio
 			 */
 			mutex_exit(&chp->ch_lock);
 			ata_channel_thaw(chp);
 			ata_reset_channel(chp, AT_WAIT | chp->ch_reset_flags);
 			mutex_enter(&chp->ch_lock);
 		} else if (chq->queue_active > 0 && chq->queue_freeze == 1) {
 			/*
 			 * Caller has bumped queue_freeze, decrease it. This
 			 * flow shalt never be executed for NCQ commands.
 			 */
 			KASSERT((chp->ch_flags & ATACH_NCQ) == 0);
 			KASSERT(chq->queue_active == 1);
 			mutex_exit(&chp->ch_lock);
 			ata_channel_thaw(chp);
 			xfer = ata_queue_get_active_xfer(chp);
 			KASSERT(xfer != NULL);
 			(*xfer->c_start)(xfer->c_chp, xfer);
 			mutex_enter(&chp->ch_lock);
 		} else if (chq->queue_freeze > 1)
-			panic("ata_thread: queue_freeze");
+			panic("%s: queue_freeze", __func__);
+	}
 	splx(s);
 	chp->ch_thread = NULL;
-	wakeup(&chp->ch_flags);
+	cv_signal(&chp->ch_thr_idle);
 	mutex_exit(&chp->ch_lock);
 	kthread_exit(0);
+}
 void
 ata_thread_wake(struct ata_channel *chp)
+{
 	mutex_enter(&chp->ch_lock);
 	ata_channel_freeze_locked(chp);
 	cv_signal(&chp->ch_thr_idle);
 	mutex_exit(&chp->ch_lock);
+}
 /*
  * atabus_match:
+ *
  *	Autoconfiguration match routine.
  */
 static int
 atabus_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct ata_channel *chp = aux;
 	if (chp == NULL)
 		return (0);
 @@ -701,38 +724,36 @@ atabus_attach(device_t parent, device_t
+}
 /*
  * atabus_detach:
+ *
  *	Autoconfiguration detach routine.
  */
 static int
 atabus_detach(device_t self, int flags)
+{
 	struct atabus_softc *sc = device_private(self);
 	struct ata_channel *chp = sc->sc_chan;
 	device_t dev = NULL;
-	int s, i, error = 0;
+	int i, error = 0;
 	/* Shutdown the channel. */
-	s = splbio();		/* XXX ALSO NEED AN INTERLOCK HERE. */
+	mutex_enter(&chp->ch_lock);
 	chp->ch_flags |= ATACH_SHUTDOWN;
-	splx(s);
+	while (chp->ch_thread != NULL) {
 		cv_signal(&chp->ch_thr_idle);
-	wakeup(&chp->ch_thread);
+		cv_wait(&chp->ch_thr_idle, &chp->ch_lock);
+	}
-	while (chp->ch_thread != NULL)
+	mutex_exit(&chp->ch_lock);
 		(void) tsleep(&chp->ch_flags, PRIBIO, "atadown", 0);
 	/*
 	 * Detach atapibus and its children.
 	 */
 	if ((dev = chp->atapibus) != NULL) {
 		ATADEBUG_PRINT(("atabus_detach: %s: detaching %s\n",
 		    device_xname(self), device_xname(dev)), DEBUG_DETACH);
 		error = config_detach(dev, flags);
 		if (error)
 			goto out;
 		KASSERT(chp->atapibus == NULL);
+	}
 @@ -1653,36 +1674,46 @@ ata_kill_pending(struct ata_drive_datas
 		if (!drv_active) {
 			/* all finished */
 			break;
+		}
 		drvp->drive_flags |= ATA_DRIVE_WAITDRAIN;
 		cv_wait(&chq->queue_drain, &chp->ch_lock);
+	}
 	mutex_exit(&chp->ch_lock);
+}
 static void
 ata_channel_freeze_locked(struct ata_channel *chp)
+{
 	chp->ch_queue->queue_freeze++;
+}
 void
 ata_channel_freeze(struct ata_channel *chp)
+{
-	chp->ch_queue->queue_freeze++;		/* XXX MPSAFE */
+	mutex_enter(&chp->ch_lock);
 	ata_channel_freeze_locked(chp);
 	mutex_exit(&chp->ch_lock);
+}
 void
 ata_channel_thaw(struct ata_channel *chp)
+{
-	chp->ch_queue->queue_freeze--;		/* XXX MPSAFE */
+	mutex_enter(&chp->ch_lock);
 	chp->ch_queue->queue_freeze--;
 	mutex_exit(&chp->ch_lock);
+}
 /*
  * ata_reset_channel:
+ *
  *	Reset and ATA channel.
+ *
  *	MUST BE CALLED AT splbio()!
  */
 void
 ata_reset_channel(struct ata_channel *chp, int flags)
+{
 	struct atac_softc *atac = chp->ch_atac;
 @@ -1705,39 +1736,44 @@ ata_reset_channel(struct ata_channel *ch
 	/*
 	 * If we can poll or wait it's OK, otherwise wake up the
 	 * kernel thread to do it for us.
 	 */
 	ATADEBUG_PRINT(("ata_reset_channel flags 0x%x ch_flags 0x%x\n",
 	    flags, chp->ch_flags), DEBUG_FUNCS | DEBUG_XFERS);
 	if ((flags & (AT_POLL | AT_WAIT)) == 0) {
 		if (chp->ch_flags & ATACH_TH_RESET) {
 			/* No need to schedule a reset more than one time. */
 			ata_channel_thaw(chp);
 			return;
+		}
 		mutex_enter(&chp->ch_lock);
 		chp->ch_flags |= ATACH_TH_RESET;
 		chp->ch_reset_flags = flags & AT_RST_EMERG;
-		wakeup(&chp->ch_thread);
+		cv_signal(&chp->ch_thr_idle);
 		mutex_exit(&chp->ch_lock);
 		return;
+	}
 	(*atac->atac_bustype_ata->ata_reset_channel)(chp, flags);
 	mutex_enter(&chp->ch_lock);
 	KASSERT(chp->ch_ndrives == 0 || chp->ch_drive != NULL);
 	for (drive = 0; drive < chp->ch_ndrives; drive++)
 		chp->ch_drive[drive].state = 0;
 	chp->ch_flags &= ~ATACH_TH_RESET;
 	mutex_exit(&chp->ch_lock);
 	if (flags & AT_RST_EMERG) {
 		/* make sure that we can use polled commands */
 		ata_queue_reset(chp->ch_queue);
 	} else {
 		ata_channel_thaw(chp);
 		atastart(chp);
+	}
+}
 int
 ata_addref(struct ata_channel *chp)
+{
 	struct atac_softc *atac = chp->ch_atac;
 @@ -2293,46 +2329,47 @@ atabus_suspend(device_t dv, const pmf_qu
 	struct atabus_softc *sc = device_private(dv);
 	struct ata_channel *chp = sc->sc_chan;
 	ata_channel_idle(chp);
 	return true;
+}
 static bool
 atabus_resume(device_t dv, const pmf_qual_t *qual)
+{
 	struct atabus_softc *sc = device_private(dv);
 	struct ata_channel *chp = sc->sc_chan;
 	int s;
 	/*
 	 * XXX joerg: with wdc, the first channel unfreezes the controler.
 	 * Move this the reset and queue idling into wdc.
 	 */
-	s = splbio();
+	mutex_enter(&chp->ch_lock);
 	if (chp->ch_queue->queue_freeze == 0) {
-		splx(s);
+		mutex_exit(&chp->ch_lock);
-		return true;
+		goto out;
+	}
 	KASSERT(chp->ch_queue->queue_freeze > 0);
 	mutex_exit(&chp->ch_lock);
 	/* unfreeze the queue and reset drives */
 	ata_channel_thaw(chp);
 	/* reset channel only if there are drives attached */
 	if (chp->ch_ndrives > 0)
 		ata_reset_channel(chp, AT_WAIT);
 	splx(s);
 out:
 	return true;
+}
 static int
 atabus_rescan(device_t self, const char *ifattr, const int *locators)
+{
 	struct atabus_softc *sc = device_private(self);
 	struct ata_channel *chp = sc->sc_chan;
 	struct atabus_initq *initq;
 	int i;
 	/*
 	 * we can rescan a port multiplier atabus, even if some devices are
 @@ -2346,38 +2383,40 @@ atabus_rescan(device_t self, const char
 		KASSERT(chp->ch_ndrives == 0 || chp->ch_drive != NULL);
 		for (i = 0; i < chp->ch_ndrives; i++) {
 			if (chp->ch_drive[i].drv_softc != NULL) {
 				return EBUSY;
+			}
+		}
+	}
 	initq = malloc(sizeof(*initq), M_DEVBUF, M_WAITOK);
 	initq->atabus_sc = sc;
 	TAILQ_INSERT_TAIL(&atabus_initq_head, initq, atabus_initq);
 	config_pending_incr(sc->sc_dev);
 	mutex_enter(&chp->ch_lock);
 	chp->ch_flags |= ATACH_TH_RESCAN;
-	wakeup(&chp->ch_thread);
+	cv_signal(&chp->ch_thr_idle);
 	mutex_exit(&chp->ch_lock);
 	return 0;
+}
 void
 ata_delay(int ms, const char *msg, int flags)
+{
 	if ((flags & (AT_WAIT | AT_POLL)) == AT_POLL) {
 		/*
-		 * can't use tsleep(), we may be in interrupt context
+		 * can't use kpause(), we may be in interrupt context
 		 * or taking a crash dump
 		 */
 		delay(ms * 1000);
 	} else {
 		int pause = mstohz(ms);
 		kpause(msg, false, pause > 0 ? pause : 1, NULL);
+	}
+}
 void
 atacmd_toncq(struct ata_xfer *xfer, uint8_t *cmd, uint16_t *count,
     uint16_t *features, uint8_t *device)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ata_wdc.c,v 1.105.6.7 2017/08/12 09:52:28 jdolecek Exp $	*/
+/*	$NetBSD: ata_wdc.c,v 1.105.6.8 2017/08/12 14:41:54 jdolecek Exp $	*/
 /*
  * Copyright (c) 1998, 2001, 2003 Manuel Bouyer.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
 @@ -44,27 +44,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ata_wdc.c,v 1.105.6.7 2017/08/12 09:52:28 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ata_wdc.c,v 1.105.6.8 2017/08/12 14:41:54 jdolecek Exp $");
 #include "opt_ata.h"
 #include "opt_wdc.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/malloc.h>
 #include <sys/device.h>
 @@ -189,28 +189,27 @@ wdc_ata_bio_start(struct ata_channel *ch
 	    drvp->state, drvp->drive_flags, xfer->c_flags, chp->ch_flags),
 	    DEBUG_XFERS);
 	/* Do control operations specially. */
 	if (__predict_false(drvp->state < READY)) {
 		/*
 		 * Actually, we want to be careful not to mess with the control
 		 * state if the device is currently busy, but we can assume
 		 * that we never get to this point if that's the case.
 		 */
 		/* If it's not a polled command, we need the kernel thread */
 		if ((xfer->c_flags & C_POLL) == 0 &&
 		    (chp->ch_flags & ATACH_TH_RUN) == 0) {
-			ata_channel_freeze(chp);
+			ata_thread_wake(chp);
 			wakeup(&chp->ch_thread);
 			return;
+		}
 		/*
 		 * disable interrupts, all commands here should be quick
 		 * enough to be able to poll, and we don't go here that often
 		 */
 		if (! (wdc->cap & WDC_CAPABILITY_NO_AUXCTL))
 			bus_space_write_1(wdr->ctl_iot, wdr->ctl_ioh,
 			    wd_aux_ctlr, WDCTL_4BIT | WDCTL_IDS);
 		if (wdc->select)
 			wdc->select(chp, xfer->c_drive);
 		bus_space_write_1(wdr->cmd_iot, wdr->cmd_iohs[wd_sdh], 0,
 		    WDSD_IBM | (xfer->c_drive << 4));

 @@ -1,14 +1,14 @@
-/*	$NetBSD: mvsata.c,v 1.35.6.20 2017/08/12 09:52:28 jdolecek Exp $	*/
+/*	$NetBSD: mvsata.c,v 1.35.6.21 2017/08/12 14:41:54 jdolecek Exp $	*/
 /*
  * Copyright (c) 2008 KIYOHARA Takashi
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
 @@ -16,27 +16,27 @@
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: mvsata.c,v 1.35.6.20 2017/08/12 09:52:28 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: mvsata.c,v 1.35.6.21 2017/08/12 14:41:54 jdolecek Exp $");
 #include "opt_mvsata.h"
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/disklabel.h>
 #include <sys/errno.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 @@ -1209,28 +1209,27 @@ do_pio:
 		if (__predict_false(drvp->state < READY)) {
 			/*
 			 * Actually, we want to be careful not to mess with
 			 * the control state if the device is currently busy,
 			 * but we can assume that we never get to this point
 			 * if that's the case.
 			 */
 			/*
 			 * If it's not a polled command, we need the kernel
 			 * thread
 			 */
 			if ((xfer->c_flags & C_POLL) == 0 &&
 			    (chp->ch_flags & ATACH_TH_RUN) == 0) {
-				ata_channel_freeze(chp);
+				ata_thread_wake(chp);
 				wakeup(&chp->ch_thread);
 				return;
+			}
 			if (mvsata_bio_ready(mvport, ata_bio, xfer->c_drive,
 			    (xfer->c_flags & C_POLL) ? AT_POLL : 0) != 0) {
 				mvsata_bio_done(chp, xfer);
 				return;
+			}
+		}
 		/* Initiate command! */
 		MVSATA_WDC_WRITE_1(mvport, SRB_H, WDSD_IBM);
 		switch(wdc_wait_for_ready(chp, ATA_DELAY, wait_flags, &tfd)) {
 		case WDCWAIT_OK:
 @@ -1901,28 +1900,27 @@ mvsata_atapi_start(struct ata_channel *c
 	if (mvport->port_edmamode_curr != nodma)
 		mvsata_edma_disable(mvport, 10 /* ms */, wait_flags);
 	mvsata_pmp_select(mvport, xfer->c_drive);
 	if ((xfer->c_flags & C_DMA) && (drvp->n_xfers <= NXFER))
 		drvp->n_xfers++;
 	/* Do control operations specially. */
 	if (__predict_false(drvp->state < READY)) {
 		/* If it's not a polled command, we need the kernel thread */
 		if ((sc_xfer->xs_control & XS_CTL_POLL) == 0 &&
 		    (chp->ch_flags & ATACH_TH_RUN) == 0) {
-			ata_channel_freeze(chp);
+			ata_thread_wake(chp);
 			wakeup(&chp->ch_thread);
 			return;
+		}
 		/*
 		 * disable interrupts, all commands here should be quick
 		 * enough to be able to poll, and we don't go here that often
 		 */
 		MVSATA_WDC_WRITE_1(mvport, SRB_CAS, WDCTL_4BIT | WDCTL_IDS);
 		MVSATA_WDC_WRITE_1(mvport, SRB_H, WDSD_IBM);
 		/* Don't try to set mode if controller can't be adjusted */
 		if (atac->atac_set_modes == NULL)
 			goto ready;
 		/* Also don't try if the drive didn't report its mode */

 @@ -1,41 +1,41 @@
-/*	$NetBSD: atapi_wdc.c,v 1.123.4.11 2017/08/12 09:52:28 jdolecek Exp $	*/
+/*	$NetBSD: atapi_wdc.c,v 1.123.4.12 2017/08/12 14:41:54 jdolecek Exp $	*/
 /*
  * Copyright (c) 1998, 2001 Manuel Bouyer.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: atapi_wdc.c,v 1.123.4.11 2017/08/12 09:52:28 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: atapi_wdc.c,v 1.123.4.12 2017/08/12 14:41:54 jdolecek Exp $");
 #ifndef ATADEBUG
 #define ATADEBUG
 #endif /* ATADEBUG */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/malloc.h>
 #include <sys/device.h>
 @@ -486,28 +486,27 @@ wdc_atapi_start(struct ata_channel *chp,
 	ATADEBUG_PRINT(("wdc_atapi_start %s:%d:%d, scsi flags 0x%x \n",
 	    device_xname(atac->atac_dev), chp->ch_channel, drvp->drive,
 	    sc_xfer->xs_control), DEBUG_XFERS);
 #if NATA_DMA
 	if ((xfer->c_flags & C_DMA) && (drvp->n_xfers <= NXFER))
 		drvp->n_xfers++;
 #endif
 	/* Do control operations specially. */
 	if (__predict_false(drvp->state < READY)) {
 		/* If it's not a polled command, we need the kernel thread */
 		if ((sc_xfer->xs_control & XS_CTL_POLL) == 0 &&
 		    (chp->ch_flags & ATACH_TH_RUN) == 0) {
-			ata_channel_freeze(chp);
+			ata_thread_wake(chp);
 			wakeup(&chp->ch_thread);
 			return;
+		}
 		/*
 		 * disable interrupts, all commands here should be quick
 		 * enough to be able to poll, and we don't go here that often
 		 */
 		bus_space_write_1(wdr->ctl_iot, wdr->ctl_ioh, wd_aux_ctlr,
 		     WDCTL_4BIT | WDCTL_IDS);
 		if (wdc->select)
 			wdc->select(chp, xfer->c_drive);
 		bus_space_write_1(wdr->cmd_iot, wdr->cmd_iohs[wd_sdh], 0,
 		    WDSD_IBM | (xfer->c_drive << 4));
 		/* Don't try to set mode if controller can't be adjusted */

 @@ -5,28 +5,26 @@ siisata - fix all new XXX and unmergable
 test wd* at umass?, confirm the ata_channel kludge works
 do proper NCQ error recovery
 - update mvsata to do same as ahcisata/siisata (read log ext, timeouts, et.al)
 do biodone() in wddone() starting the dump to not leak bufs when dumping from
 active system? make sure to not trigger atastart()
 - call ata_kill_active() + ata_kill_pending() when dumping
 kill active transfers after software drive reset - race timeout vs.
 error recovery
 atabus_thread() protect run by mutex/condvar
 Other random notes (do outside the NCQ branch):
 -----------------------------------------------------
 implement support for PM FIS-based switching, remove restriction in atastart()
 for hw which supports it, adjust error handling in controller drivers to handle
 xfers for several different drives
 maybe do device error handling in not-interrupt-context (maybe this should be
 done on a mpata branch?)
 queue is allocated regardless if there are any drives, fix?
 change wd(4) to use dksubr

 @@ -1,14 +1,14 @@
-/*	$NetBSD: atavar.h,v 1.92.8.22 2017/08/12 09:52:28 jdolecek Exp $	*/
+/*	$NetBSD: atavar.h,v 1.92.8.23 2017/08/12 14:41:54 jdolecek Exp $	*/
 /*
  * Copyright (c) 1998, 2001 Manuel Bouyer.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
 @@ -407,26 +407,27 @@ struct ata_channel {
 	/* ATAPI children */
 	device_t atapibus;
 	struct scsipi_channel ch_atapi_channel;
 	/*
 	 * Channel queues.  May be the same for all channels, if hw
 	 * channels are not independent.
 	 */
 	struct ata_queue *ch_queue;
 	/* The channel kernel thread */
 	struct lwp *ch_thread;
 	kcondvar_t ch_thr_idle;		/* thread waiting for work */
 	/* Number of sata PMP ports, if any */
 	int ch_satapmp_nports;
 };
 /*
  * ATA controller softc.
+ *
  * This contains a bunch of generic info that all ATA controllers need
  * to have.
+ *
  * XXX There is still some lingering wdc-centricity here.
  */
 @@ -505,26 +506,27 @@ struct ata_xfer *ata_get_xfer_ext(struct
 #define ata_get_xfer(chp) ata_get_xfer_ext((chp), C_WAIT, 0);
 void	ata_free_xfer(struct ata_channel *, struct ata_xfer *);
 void	ata_deactivate_xfer(struct ata_channel *, struct ata_xfer *);
 void	ata_exec_xfer(struct ata_channel *, struct ata_xfer *);
 void	ata_timeout(void *);
 bool	ata_timo_xfer_check(struct ata_xfer *);
 void	ata_kill_pending(struct ata_drive_datas *);
 void	ata_kill_active(struct ata_channel *, int, int);
 void	ata_reset_channel(struct ata_channel *, int);
 void	ata_channel_freeze(struct ata_channel *);
 void	ata_channel_thaw(struct ata_channel *);
 void	ata_channel_start(struct ata_channel *, int);
 void	ata_thread_wake(struct ata_channel *);
 int	ata_addref(struct ata_channel *);
 void	ata_delref(struct ata_channel *);
 void	atastart(struct ata_channel *);
 void	ata_print_modes(struct ata_channel *);
 #if NATA_DMA
 int	ata_downgrade_mode(struct ata_drive_datas *, int);
 #endif
 void	ata_probe_caps(struct ata_drive_datas *);
 #if NATA_DMA
 void	ata_dmaerr(struct ata_drive_datas *, int);
 #endif