 @@ -1,14 +1,14 @@
-/*	$NetBSD: ata.c,v 1.99 2008/06/12 21:46:35 cegger Exp $	*/
+/*	$NetBSD: ata.c,v 1.100 2008/10/01 18:23:55 bouyer 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.
  * 3. All advertising materials mentioning features or use of this software
 @@ -20,27 +20,27 @@
  * 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.99 2008/06/12 21:46:35 cegger Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ata.c,v 1.100 2008/10/01 18:23:55 bouyer 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/pool.h>
 #include <sys/kthread.h>
 @@ -79,47 +79,51 @@ int atadebug_mask = 0;
 #endif
 POOL_INIT(ata_xfer_pool, sizeof(struct ata_xfer), 0, 0, 0, "ataspl", NULL,
     IPL_BIO);
 /*
  * A queue of atabus instances, used to ensure the same bus probe order
  * for a given hardware configuration at each boot.
  */
 struct atabus_initq_head atabus_initq_head =
     TAILQ_HEAD_INITIALIZER(atabus_initq_head);
 struct simplelock atabus_interlock = SIMPLELOCK_INITIALIZER;
 /* kernel thread probing devices on a atabus. Only one probing at once */
 struct lwp *atabus_configlwp;
 /*****************************************************************************
  * ATA bus layer.
+ *
  * ATA controllers attach an atabus instance, which handles probing the bus
  * for drives, etc.
  *****************************************************************************/
 dev_type_open(atabusopen);
 dev_type_close(atabusclose);
 dev_type_ioctl(atabusioctl);
 const struct cdevsw atabus_cdevsw = {
 	atabusopen, atabusclose, noread, nowrite, atabusioctl,
 	nostop, notty, nopoll, nommap, nokqfilter, D_OTHER
 };
 extern struct cfdriver atabus_cd;
 static void atabus_childdetached(device_t, device_t);
 static bool atabus_resume(device_t PMF_FN_PROTO);
 static bool atabus_suspend(device_t PMF_FN_PROTO);
 static void atabusconfig_thread(void *);
 /*
  * atabusprint:
+ *
  *	Autoconfiguration print routine used by ATA controllers when
  *	attaching an atabus instance.
  */
 int
 atabusprint(void *aux, const char *pnp)
+{
 	struct ata_channel *chan = aux;
 	if (pnp)
 @@ -164,59 +168,107 @@ ata_channel_attach(struct ata_channel *c
 	chp->ch_queue->queue_freeze = 0;
 	chp->ch_queue->queue_flags = 0;
 	chp->ch_queue->active_xfer = NULL;
 	chp->atabus = config_found_ia(chp->ch_atac->atac_dev, "ata", chp,
 		atabusprint);
+}
 static void
 atabusconfig(struct atabus_softc *atabus_sc)
+{
 	struct ata_channel *chp = atabus_sc->sc_chan;
 	struct atac_softc *atac = chp->ch_atac;
 	int i, s;
 	struct atabus_initq *atabus_initq = NULL;
 	int i, s, error;
 	/* we are in the atabus's thread context */
 	s = splbio();
 	chp->ch_flags |= ATACH_TH_RUN;
 	splx(s);
 	/* Probe for the drives. */
 	/* XXX for SATA devices we will power up all drives at once */
 	(*atac->atac_probe)(chp);
 	ATADEBUG_PRINT(("atabusattach: ch_drive_flags 0x%x 0x%x\n",
 	    chp->ch_drive[0].drive_flags, chp->ch_drive[1].drive_flags),
 	    DEBUG_PROBE);
 	/* next operations will occurs in a separate thread */
 	s = splbio();
 	chp->ch_flags &= ~ATACH_TH_RUN;
 	splx(s);
 	/* Make sure the devices probe in atabus order to avoid jitter. */
 	simple_lock(&atabus_interlock);
 	while(1) {
 		atabus_initq = TAILQ_FIRST(&atabus_initq_head);
 		if (atabus_initq->atabus_sc == atabus_sc)
 			break;
 		ltsleep(&atabus_initq_head, PRIBIO, "ata_initq", 0,
 		    &atabus_interlock);
+	}
 	simple_unlock(&atabus_interlock);
 	/* If no drives, abort here */
 	for (i = 0; i < chp->ch_ndrive; i++)
 		if ((chp->ch_drive[i].drive_flags & DRIVE) != 0)
 			break;
 	if (i == chp->ch_ndrive)
 		goto out;
 	/* Shortcut in case we've been shutdown */
 	if (chp->ch_flags & ATACH_SHUTDOWN)
 		goto out;
 	/* Make sure the devices probe in atabus order to avoid jitter. */
 	if ((error = kthread_create(PRI_NONE, 0, NULL, atabusconfig_thread,
 	    atabus_sc, &atabus_configlwp,
 	    "%scnf", device_xname(atac->atac_dev))) != 0)
 		aprint_error_dev(atac->atac_dev,
 		    "unable to create config thread: error %d\n", error);
 	return;
  out:
 	simple_lock(&atabus_interlock);
-	while(1) {
+	TAILQ_REMOVE(&atabus_initq_head, atabus_initq, atabus_initq);
 		atabus_initq = TAILQ_FIRST(&atabus_initq_head);
 		if (atabus_initq->atabus_sc == atabus_sc)
 			break;
 		ltsleep(&atabus_initq_head, PRIBIO, "ata_initq", 0,
 		    &atabus_interlock);
 	simple_unlock(&atabus_interlock);
 	free(atabus_initq, M_DEVBUF);
 	wakeup(&atabus_initq_head);
 	ata_delref(chp);
 	config_pending_decr();
+}
 /*
  * atabus_configthread: finish attach of atabus's childrens, in a separate
  * kernel thread.
  */
 static void
 atabusconfig_thread(void *arg)
+{
 	struct atabus_softc *atabus_sc = arg;
 	struct ata_channel *chp = atabus_sc->sc_chan;
 	struct atac_softc *atac = chp->ch_atac;
 	int i, s;
 	struct atabus_initq *atabus_initq = NULL;
 	simple_lock(&atabus_interlock);
 	atabus_initq = TAILQ_FIRST(&atabus_initq_head);
 	simple_unlock(&atabus_interlock);
 	KASSERT(atabus_initq->atabus_sc == atabus_sc);
 	/*
 	 * Attach an ATAPI bus, if needed.
 	 */
 	for (i = 0; i < chp->ch_ndrive; i++) {
 		if (chp->ch_drive[i].drive_flags & DRIVE_ATAPI) {
 #if NATAPIBUS > 0
 			(*atac->atac_atapibus_attach)(atabus_sc);
 #else
 			/*
 			 * Fake the autoconfig "not configured" message
 			 */
 			aprint_normal("atapibus at %s not configured\n",
 			    device_xname(atac->atac_dev));
 @@ -268,48 +320,37 @@ atabusconfig(struct atabus_softc *atabus
 	/*
 	 * reset drive_flags for unattached devices, reset state for attached
 	 * ones
 	 */
 	s = splbio();
 	for (i = 0; i < chp->ch_ndrive; i++) {
 		if (chp->ch_drive[i].drv_softc == NULL)
 			chp->ch_drive[i].drive_flags = 0;
 		else
 			chp->ch_drive[i].state = 0;
+	}
 	splx(s);
  out:
 	if (atabus_initq == NULL) {
 		simple_lock(&atabus_interlock);
 		while(1) {
 			atabus_initq = TAILQ_FIRST(&atabus_initq_head);
 			if (atabus_initq->atabus_sc == atabus_sc)
 				break;
 			ltsleep(&atabus_initq_head, PRIBIO, "ata_initq", 0,
 			    &atabus_interlock);
 		simple_unlock(&atabus_interlock);
 	simple_lock(&atabus_interlock);
 	TAILQ_REMOVE(&atabus_initq_head, atabus_initq, atabus_initq);
 	simple_unlock(&atabus_interlock);
 	free(atabus_initq, M_DEVBUF);
 	wakeup(&atabus_initq_head);
 	ata_delref(chp);
 	config_pending_decr();
 	kthread_exit(0);
+}
 /*
  * 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_xfer *xfer;
 @@ -971,26 +1012,28 @@ ata_reset_channel(struct ata_channel *ch
 		printf("ata_reset_channel: not at splbio()\n");
 		panic("ata_reset_channel");
+	}
 	splx(spl2);
 	splx(spl1);
 #endif /* ATA_DEBUG */
 	chp->ch_queue->queue_freeze++;
 	/*
 	 * 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. */
 			chp->ch_queue->queue_freeze--;
 			return;
+		}
 		chp->ch_flags |= ATACH_TH_RESET;
 		chp->ch_reset_flags = flags & (AT_RST_EMERG | AT_RST_NOCMD);
 		wakeup(&chp->ch_thread);
 		return;
+	}
 	(*atac->atac_bustype_ata->ata_reset_channel)(chp, flags);