ata-all.c revision 146318 
1/*-
2 * Copyright (c) 1998 - 2005 S�ren Schmidt <sos@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer,
10 *    without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 *    derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/dev/ata/ata-all.c 146318 2005-05-17 12:31:54Z sos $");
31
32#include "opt_ata.h"
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/ata.h>
36#include <sys/kernel.h>
37#include <sys/module.h>
38#include <sys/endian.h>
39#include <sys/ctype.h>
40#include <sys/conf.h>
41#include <sys/bus.h>
42#include <sys/bio.h>
43#include <sys/malloc.h>
44#include <sys/sysctl.h>
45#include <sys/sema.h>
46#include <sys/taskqueue.h>
47#include <vm/uma.h>
48#include <machine/stdarg.h>
49#include <machine/resource.h>
50#include <machine/bus.h>
51#include <sys/rman.h>
52#ifdef __alpha__
53#include <machine/md_var.h>
54#endif
55#include <dev/ata/ata-all.h>
56#include <ata_if.h>
57
58/* device structure */
59static  d_ioctl_t       ata_ioctl;
60static struct cdevsw ata_cdevsw = {
61	.d_version =    D_VERSION,
62	.d_flags =      D_NEEDGIANT, /* we need this as newbus isn't mpsafe */
63	.d_ioctl =      ata_ioctl,
64	.d_name =       "ata",
65};
66
67/* prototypes */
68static void ata_interrupt(void *);
69static void ata_boot_attach(void);
70static device_t ata_add_child(device_t, struct ata_device *, int);
71static void bswap(int8_t *, int);
72static void btrim(int8_t *, int);
73static void bpack(int8_t *, int8_t *, int);
74
75/* global vars */
76MALLOC_DEFINE(M_ATA, "ATA generic", "ATA driver generic layer");
77int (*ata_raid_ioctl_func)(u_long cmd, caddr_t data) = NULL;
78devclass_t ata_devclass;
79uma_zone_t ata_request_zone;
80uma_zone_t ata_composite_zone;
81int ata_wc = 1;
82
83/* local vars */
84static struct intr_config_hook *ata_delayed_attach = NULL;
85static int ata_dma = 1;
86static int atapi_dma = 1;
87
88/* sysctl vars */
89SYSCTL_NODE(_hw, OID_AUTO, ata, CTLFLAG_RD, 0, "ATA driver parameters");
90TUNABLE_INT("hw.ata.ata_dma", &ata_dma);
91SYSCTL_INT(_hw_ata, OID_AUTO, ata_dma, CTLFLAG_RDTUN, &ata_dma, 0,
92	   "ATA disk DMA mode control");
93TUNABLE_INT("hw.ata.atapi_dma", &atapi_dma);
94SYSCTL_INT(_hw_ata, OID_AUTO, atapi_dma, CTLFLAG_RDTUN, &atapi_dma, 0,
95	   "ATAPI device DMA mode control");
96TUNABLE_INT("hw.ata.wc", &ata_wc);
97SYSCTL_INT(_hw_ata, OID_AUTO, wc, CTLFLAG_RDTUN, &ata_wc, 0,
98	   "ATA disk write caching");
99
100/*
101 * newbus device interface related functions
102 */
103int
104ata_probe(device_t dev)
105{
106    return 0;
107}
108
109int
110ata_attach(device_t dev)
111{
112    struct ata_channel *ch = device_get_softc(dev);
113    int error, rid;
114
115    /* check that we have a virgin channel to attach */
116    if (ch->r_irq)
117	return EEXIST;
118
119    /* initialize the softc basics */
120    ch->dev = dev;
121    ch->state = ATA_IDLE;
122    bzero(&ch->state_mtx, sizeof(struct mtx));
123    mtx_init(&ch->state_mtx, "ATA state lock", NULL, MTX_DEF);
124    bzero(&ch->queue_mtx, sizeof(struct mtx));
125    mtx_init(&ch->queue_mtx, "ATA queue lock", NULL, MTX_DEF);
126    TAILQ_INIT(&ch->ata_queue);
127
128    /* reset the controller HW, the channel and device(s) */
129    while (ATA_LOCKING(dev, ATA_LF_LOCK) != ch->unit)
130	tsleep(&error, PRIBIO, "ataatch", 1);
131    ATA_RESET(dev);
132    ATA_LOCKING(dev, ATA_LF_UNLOCK);
133
134    /* setup interrupt delivery */
135    rid = ATA_IRQ_RID;
136    ch->r_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
137				       RF_SHAREABLE | RF_ACTIVE);
138    if (!ch->r_irq) {
139	device_printf(dev, "unable to allocate interrupt\n");
140	return ENXIO;
141    }
142    if ((error = bus_setup_intr(dev, ch->r_irq, ATA_INTR_FLAGS,
143				ata_interrupt, ch, &ch->ih))) {
144	device_printf(dev, "unable to setup interrupt\n");
145	return error;
146    }
147
148    /* probe and attach devices on this channel unless we are in early boot */
149    if (!ata_delayed_attach)
150	ata_identify(dev);
151    return 0;
152}
153
154int
155ata_detach(device_t dev)
156{
157    struct ata_channel *ch = device_get_softc(dev);
158    device_t *children;
159    int nchildren, i;
160
161    /* check that we have a vaild channel to detach */
162    if (!ch->r_irq)
163	return ENXIO;
164
165    /* detach & delete all children */
166    if (!device_get_children(dev, &children, &nchildren)) {
167	for (i = 0; i < nchildren; i++)
168	    if (children[i])
169		device_delete_child(dev, children[i]);
170	free(children, M_TEMP);
171    }
172
173    /* release resources */
174    bus_teardown_intr(dev, ch->r_irq, ch->ih);
175    bus_release_resource(dev, SYS_RES_IRQ, ATA_IRQ_RID, ch->r_irq);
176    ch->r_irq = NULL;
177    mtx_destroy(&ch->state_mtx);
178    mtx_destroy(&ch->queue_mtx);
179    return 0;
180}
181
182int
183ata_reinit(device_t dev)
184{
185    struct ata_channel *ch = device_get_softc(dev);
186    device_t *children;
187    int nchildren, i;
188
189    /* check that we have a vaild channel to reinit */
190    if (!ch || !ch->r_irq)
191	return ENXIO;
192
193    if (bootverbose)
194	device_printf(dev, "reiniting channel ..\n");
195
196    /* poll for locking the channel */
197    while (ATA_LOCKING(dev, ATA_LF_LOCK) != ch->unit)
198	tsleep(&dev, PRIBIO, "atarini", 1);
199
200    /* unconditionally grap the channel lock */
201    mtx_lock(&ch->state_mtx);
202    ch->state = ATA_STALL_QUEUE;
203    mtx_unlock(&ch->state_mtx);
204
205    /* reset the controller HW, the channel and device(s) */
206    ATA_RESET(dev);
207
208    /* reinit the children and delete any that fails */
209    if (!device_get_children(dev, &children, &nchildren)) {
210	mtx_lock(&Giant);       /* newbus suckage it needs Giant */
211	for (i = 0; i < nchildren; i++) {
212	    if (children[i] && device_is_attached(children[i]))
213		if (ATA_REINIT(children[i])) {
214		    /*
215		     * if we have a running request and its device matches
216		     * this child we need to inform the request that the
217		     * device is gone and remove it from ch->running
218		     */
219		    if (ch->running && ch->running->dev == children[i]) {
220			device_printf(ch->running->dev,
221				      "FAILURE - device detached\n");
222			ch->running->dev = NULL;
223			ch->running = NULL;
224		    }
225		    device_delete_child(dev, children[i]);
226		}
227	}
228	free(children, M_TEMP);
229	mtx_unlock(&Giant);     /* newbus suckage dealt with, release Giant */
230    }
231
232    /* catch request in ch->running if we havn't already */
233    ata_catch_inflight(dev);
234
235    /* we're done release the channel for new work */
236    mtx_lock(&ch->state_mtx);
237    ch->state = ATA_IDLE;
238    mtx_unlock(&ch->state_mtx);
239    ATA_LOCKING(dev, ATA_LF_UNLOCK);
240
241    if (bootverbose)
242	device_printf(dev, "reinit done ..\n");
243
244    /* kick off requests on the queue */
245    ata_start(dev);
246    return 0;
247}
248
249int
250ata_suspend(device_t dev)
251{
252    struct ata_channel *ch;
253
254    /* check for valid device */
255    if (!dev || !(ch = device_get_softc(dev)))
256	return ENXIO;
257
258    /* wait for the channel to be IDLE before entering suspend mode */
259    while (1) {
260	mtx_lock(&ch->state_mtx);
261	if (ch->state == ATA_IDLE) {
262	    ch->state = ATA_ACTIVE;
263	    mtx_unlock(&ch->state_mtx);
264	    break;
265	}
266	mtx_unlock(&ch->state_mtx);
267	tsleep(ch, PRIBIO, "atasusp", hz/10);
268    }
269    ATA_LOCKING(dev, ATA_LF_UNLOCK);
270    return 0;
271}
272
273int
274ata_resume(device_t dev)
275{
276    struct ata_channel *ch;
277    int error;
278
279    /* check for valid device */
280    if (!dev || !(ch = device_get_softc(dev)))
281	return ENXIO;
282
283    /* reinit the devices, we dont know what mode/state they are in */
284    error = ata_reinit(dev);
285
286    /* kick off requests on the queue */
287    ata_start(dev);
288    return error;
289}
290
291static void
292ata_interrupt(void *data)
293{
294    struct ata_channel *ch = (struct ata_channel *)data;
295    struct ata_request *request;
296
297    mtx_lock(&ch->state_mtx);
298    do {
299	/* do we have a running request */
300	if (!(request = ch->running) || (request->flags & ATA_R_TIMEOUT))
301	    break;
302
303	ATA_DEBUG_RQ(request, "interrupt");
304
305	/* ignore interrupt if device is busy */
306	if (ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_BUSY) {
307	    DELAY(100);
308	    if (ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_BUSY)
309		break;
310	}
311
312	/* check for the right state */
313	if (ch->state != ATA_ACTIVE && ch->state != ATA_STALL_QUEUE) {
314	    device_printf(request->dev,
315			  "interrupt state=%d unexpected\n", ch->state);
316	    break;
317	}
318
319	/*
320	 * we have the HW locks, so end the tranaction for this request
321	 * if it finishes immediately otherwise wait for next interrupt
322	 */
323	if (ch->hw.end_transaction(request) == ATA_OP_FINISHED) {
324	    ch->running = NULL;
325	    if (ch->state == ATA_ACTIVE)
326		ch->state = ATA_IDLE;
327	    mtx_unlock(&ch->state_mtx);
328	    ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
329	    ata_finish(request);
330	    return;
331	}
332    } while (0);
333    mtx_unlock(&ch->state_mtx);
334}
335
336/*
337 * device related interfaces
338 */
339static int
340ata_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
341	  int32_t flag, struct thread *td)
342{
343    device_t device, *children;
344    struct ata_ioc_devices *devices = (struct ata_ioc_devices *)data;
345    int *value = (int *)data;
346    int i, nchildren, error = ENOTTY;
347
348    switch (cmd) {
349    case IOCATAGMAXCHANNEL:
350	*value = devclass_get_maxunit(ata_devclass);
351	error = 0;
352	break;
353
354    case IOCATAREINIT:
355	if (*value > devclass_get_maxunit(ata_devclass) ||
356	    !(device = devclass_get_device(ata_devclass, *value)))
357	    return ENXIO;
358	error = ata_reinit(device);
359	ata_start(device);
360	break;
361
362    case IOCATAATTACH:
363	if (*value > devclass_get_maxunit(ata_devclass) ||
364	    !(device = devclass_get_device(ata_devclass, *value)))
365	    return ENXIO;
366	/* XXX SOS should enable channel HW on controller */
367	error = ata_attach(device);
368	break;
369
370    case IOCATADETACH:
371	if (*value > devclass_get_maxunit(ata_devclass) ||
372	    !(device = devclass_get_device(ata_devclass, *value)))
373	    return ENXIO;
374	error = ata_detach(device);
375	/* XXX SOS should disable channel HW on controller */
376	break;
377
378    case IOCATADEVICES:
379	if (devices->channel > devclass_get_maxunit(ata_devclass) ||
380	    !(device = devclass_get_device(ata_devclass, devices->channel)))
381	    return ENXIO;
382	bzero(devices->name[0], 32);
383	bzero(&devices->params[0], sizeof(struct ata_params));
384	bzero(devices->name[1], 32);
385	bzero(&devices->params[1], sizeof(struct ata_params));
386	if (!device_get_children(device, &children, &nchildren)) {
387	    for (i = 0; i < nchildren; i++) {
388		if (children[i] && device_is_attached(children[i])) {
389		    struct ata_device *atadev = device_get_softc(children[i]);
390
391		    if (atadev->unit == ATA_MASTER) {
392			strncpy(devices->name[0],
393				device_get_nameunit(children[i]), 32);
394			bcopy(&atadev->param, &devices->params[0],
395			      sizeof(struct ata_params));
396		    }
397		    if (atadev->unit == ATA_SLAVE) {
398			strncpy(devices->name[1],
399				device_get_nameunit(children[i]), 32);
400			bcopy(&atadev->param, &devices->params[1],
401			      sizeof(struct ata_params));
402		    }
403		}
404	    }
405	    free(children, M_TEMP);
406	    error = 0;
407	}
408	else
409	    error = ENODEV;
410	break;
411
412    default:
413	if (ata_raid_ioctl_func)
414	    error = ata_raid_ioctl_func(cmd, data);
415    }
416    return error;
417}
418
419int
420ata_device_ioctl(device_t dev, u_long cmd, caddr_t data)
421{
422    struct ata_device *atadev = device_get_softc(dev);
423    struct ata_ioc_request *ioc_request = (struct ata_ioc_request *)data;
424    struct ata_params *params = (struct ata_params *)data;
425    int *mode = (int *)data;
426    struct ata_request *request;
427    caddr_t buf;
428    int error;
429
430    switch (cmd) {
431    case IOCATAREQUEST:
432	if (!(buf = malloc(ioc_request->count, M_ATA, M_NOWAIT))) {
433	    return ENOMEM;
434	}
435	if (!(request = ata_alloc_request())) {
436	    free(buf, M_ATA);
437	    return  ENOMEM;
438	}
439	if (ioc_request->flags & ATA_CMD_WRITE) {
440	    error = copyin(ioc_request->data, buf, ioc_request->count);
441	    if (error) {
442		free(buf, M_ATA);
443		ata_free_request(request);
444		return error;
445	    }
446	}
447	request->dev = dev;
448	if (ioc_request->flags & ATA_CMD_ATAPI) {
449	    request->flags = ATA_R_ATAPI;
450	    bcopy(ioc_request->u.atapi.ccb, request->u.atapi.ccb, 16);
451	}
452	else {
453	    request->u.ata.command = ioc_request->u.ata.command;
454	    request->u.ata.feature = ioc_request->u.ata.feature;
455	    request->u.ata.lba = ioc_request->u.ata.lba;
456	    request->u.ata.count = ioc_request->u.ata.count;
457	}
458	request->timeout = ioc_request->timeout;
459	request->data = buf;
460	request->bytecount = ioc_request->count;
461	request->transfersize = request->bytecount;
462	if (ioc_request->flags & ATA_CMD_CONTROL)
463	    request->flags |= ATA_R_CONTROL;
464	if (ioc_request->flags & ATA_CMD_READ)
465	    request->flags |= ATA_R_READ;
466	if (ioc_request->flags & ATA_CMD_WRITE)
467	    request->flags |= ATA_R_WRITE;
468	ata_queue_request(request);
469	if (!(request->flags & ATA_R_ATAPI)) {
470	    ioc_request->u.ata.command = request->u.ata.command;
471	    ioc_request->u.ata.feature = request->u.ata.feature;
472	    ioc_request->u.ata.lba = request->u.ata.lba;
473	    ioc_request->u.ata.count = request->u.ata.count;
474	}
475	ioc_request->error = request->result;
476	if (ioc_request->flags & ATA_CMD_READ)
477	    error = copyout(buf, ioc_request->data, ioc_request->count);
478	else
479	    error = 0;
480	free(buf, M_ATA);
481	ata_free_request(request);
482	return error;
483
484    case IOCATAGPARM:
485	bcopy(&atadev->param, params, sizeof(struct ata_params));
486	return 0;
487
488    case IOCATASMODE:
489	atadev->mode = *mode;
490	ATA_SETMODE(device_get_parent(dev), dev);
491	return 0;
492
493    case IOCATAGMODE:
494	*mode = atadev->mode;
495	return 0;
496    default:
497	return ENOTTY;
498    }
499}
500
501static void
502ata_boot_attach(void)
503{
504    struct ata_channel *ch;
505    int ctlr;
506
507    /* release the hook that got us here, only needed during boot */
508    if (ata_delayed_attach) {
509	config_intrhook_disestablish(ata_delayed_attach);
510	free(ata_delayed_attach, M_TEMP);
511	ata_delayed_attach = NULL;
512    }
513
514    /* kick of probe and attach on all channels */
515    for (ctlr = 0; ctlr < devclass_get_maxunit(ata_devclass); ctlr++) {
516	if ((ch = devclass_get_softc(ata_devclass, ctlr))) {
517	    ata_identify(ch->dev);
518	}
519    }
520}
521
522
523/*
524 * misc support functions
525 */
526static device_t
527ata_add_child(device_t parent, struct ata_device *atadev, int unit)
528{
529    device_t child;
530
531    if ((child = device_add_child(parent, NULL, unit))) {
532	device_set_softc(child, atadev);
533	device_quiet(child);
534	atadev->dev = child;
535	atadev->max_iosize = DEV_BSIZE;
536	atadev->mode = ATA_PIO_MAX;
537    }
538    return child;
539}
540
541static int
542ata_getparam(device_t parent, struct ata_device *atadev)
543{
544    struct ata_channel *ch = device_get_softc(parent);
545    struct ata_request *request;
546    u_int8_t command = 0;
547    int error = ENOMEM, retries = 2;
548
549    if (ch->devices &
550	(atadev->unit == ATA_MASTER ? ATA_ATA_MASTER : ATA_ATA_SLAVE))
551	command = ATA_ATA_IDENTIFY;
552    if (ch->devices &
553	(atadev->unit == ATA_MASTER ? ATA_ATAPI_MASTER : ATA_ATAPI_SLAVE))
554	command = ATA_ATAPI_IDENTIFY;
555    if (!command)
556	return ENXIO;
557
558    while (retries-- > 0 && error) {
559	if (!(request = ata_alloc_request()))
560	    break;
561	request->dev = atadev->dev;
562	request->timeout = 1;
563	request->retries = 0;
564	request->u.ata.command = command;
565	request->flags = (ATA_R_READ|ATA_R_AT_HEAD|ATA_R_DIRECT|ATA_R_QUIET);
566	request->data = (void *)&atadev->param;
567	request->bytecount = sizeof(struct ata_params);
568	request->donecount = 0;
569	request->transfersize = DEV_BSIZE;
570	ata_queue_request(request);
571	error = request->result;
572	ata_free_request(request);
573    }
574
575    if (!error && (isprint(atadev->param.model[0]) ||
576		   isprint(atadev->param.model[1]))) {
577	struct ata_params *atacap = &atadev->param;
578	char buffer[64];
579#if BYTE_ORDER == BIG_ENDIAN
580	int16_t *ptr;
581
582	for (ptr = (int16_t *)atacap;
583	     ptr < (int16_t *)atacap + sizeof(struct ata_params)/2; ptr++) {
584	    *ptr = bswap16(*ptr);
585	}
586#endif
587	if (!(!strncmp(atacap->model, "FX", 2) ||
588	      !strncmp(atacap->model, "NEC", 3) ||
589	      !strncmp(atacap->model, "Pioneer", 7) ||
590	      !strncmp(atacap->model, "SHARP", 5))) {
591	    bswap(atacap->model, sizeof(atacap->model));
592	    bswap(atacap->revision, sizeof(atacap->revision));
593	    bswap(atacap->serial, sizeof(atacap->serial));
594	}
595	btrim(atacap->model, sizeof(atacap->model));
596	bpack(atacap->model, atacap->model, sizeof(atacap->model));
597	btrim(atacap->revision, sizeof(atacap->revision));
598	bpack(atacap->revision, atacap->revision, sizeof(atacap->revision));
599	btrim(atacap->serial, sizeof(atacap->serial));
600	bpack(atacap->serial, atacap->serial, sizeof(atacap->serial));
601	sprintf(buffer, "%.40s/%.8s", atacap->model, atacap->revision);
602	device_set_desc_copy(atadev->dev, buffer);
603	if (bootverbose)
604	    printf("ata%d-%s: pio=%s wdma=%s udma=%s cable=%s wire\n",
605		   ch->unit, atadev->unit == ATA_MASTER ? "master":"slave",
606		   ata_mode2str(ata_pmode(atacap)),
607		   ata_mode2str(ata_wmode(atacap)),
608		   ata_mode2str(ata_umode(atacap)),
609		   (atacap->hwres & ATA_CABLE_ID) ? "80":"40");
610
611	if (atadev->param.config & ATA_PROTO_ATAPI) {
612	    if (atapi_dma && ch->dma &&
613		(atadev->param.config & ATA_DRQ_MASK) != ATA_DRQ_INTR &&
614		ata_umode(&atadev->param) >= ATA_UDMA2)
615		atadev->mode = ATA_DMA_MAX;
616	}
617	else {
618	    if (ata_dma && ch->dma)
619		atadev->mode = ATA_DMA_MAX;
620	}
621    }
622    else {
623	if (!error)
624	    error = ENXIO;
625    }
626    return error;
627}
628
629int
630ata_identify(device_t dev)
631{
632    struct ata_channel *ch = device_get_softc(dev);
633    struct ata_device *master = NULL, *slave = NULL;
634    device_t master_child = NULL, slave_child = NULL;
635    int master_unit = -1, slave_unit = -1;
636
637    if (ch->devices & (ATA_ATA_MASTER | ATA_ATAPI_MASTER)) {
638	if (!(master = malloc(sizeof(struct ata_device),
639			      M_ATA, M_NOWAIT | M_ZERO))) {
640	    device_printf(dev, "out of memory\n");
641	    return ENOMEM;
642	}
643	master->unit = ATA_MASTER;
644    }
645    if (ch->devices & (ATA_ATA_SLAVE | ATA_ATAPI_SLAVE)) {
646	if (!(slave = malloc(sizeof(struct ata_device),
647			     M_ATA, M_NOWAIT | M_ZERO))) {
648	    free(master, M_ATA);
649	    device_printf(dev, "out of memory\n");
650	    return ENOMEM;
651	}
652	slave->unit = ATA_SLAVE;
653    }
654
655#ifdef ATA_STATIC_ID
656    if (ch->devices & ATA_ATA_MASTER)
657	master_unit = (device_get_unit(dev) << 1);
658#endif
659    if (master && !(master_child = ata_add_child(dev, master, master_unit))) {
660	free(master, M_ATA);
661	master = NULL;
662    }
663#ifdef ATA_STATIC_ID
664    if (ch->devices & ATA_ATA_SLAVE)
665	slave_unit = (device_get_unit(dev) << 1) + 1;
666#endif
667    if (slave && !(slave_child = ata_add_child(dev, slave, slave_unit))) {
668	free(slave, M_ATA);
669	slave = NULL;
670    }
671
672    if (slave && ata_getparam(dev, slave)) {
673	device_delete_child(dev, slave_child);
674	free(slave, M_ATA);
675    }
676    if (master && ata_getparam(dev, master)) {
677	device_delete_child(dev, master_child);
678	free(master, M_ATA);
679    }
680
681    bus_generic_probe(dev);
682    bus_generic_attach(dev);
683    return 0;
684}
685
686void
687ata_default_registers(device_t dev)
688{
689    struct ata_channel *ch = device_get_softc(dev);
690
691    /* fill in the defaults from whats setup already */
692    ch->r_io[ATA_ERROR].res = ch->r_io[ATA_FEATURE].res;
693    ch->r_io[ATA_ERROR].offset = ch->r_io[ATA_FEATURE].offset;
694    ch->r_io[ATA_IREASON].res = ch->r_io[ATA_COUNT].res;
695    ch->r_io[ATA_IREASON].offset = ch->r_io[ATA_COUNT].offset;
696    ch->r_io[ATA_STATUS].res = ch->r_io[ATA_COMMAND].res;
697    ch->r_io[ATA_STATUS].offset = ch->r_io[ATA_COMMAND].offset;
698    ch->r_io[ATA_ALTSTAT].res = ch->r_io[ATA_CONTROL].res;
699    ch->r_io[ATA_ALTSTAT].offset = ch->r_io[ATA_CONTROL].offset;
700}
701
702u_int8_t
703ata_modify_if_48bit(struct ata_request *request)
704{
705    struct ata_device *atadev = device_get_softc(request->dev);
706    u_int8_t command = request->u.ata.command;
707
708    atadev->flags &= ~ATA_D_48BIT_ACTIVE;
709
710    if ((request->u.ata.lba >= ATA_MAX_28BIT_LBA ||
711	 request->u.ata.count > 256) &&
712	atadev->param.support.command2 & ATA_SUPPORT_ADDRESS48) {
713
714	/* translate command into 48bit version */
715	switch (command) {
716	case ATA_READ:
717	    command = ATA_READ48; break;
718	case ATA_READ_MUL:
719	    command = ATA_READ_MUL48; break;
720	case ATA_READ_DMA:
721	    command = ATA_READ_DMA48; break;
722	case ATA_READ_DMA_QUEUED:
723	    command = ATA_READ_DMA_QUEUED48; break;
724	case ATA_WRITE:
725	    command = ATA_WRITE48; break;
726	case ATA_WRITE_MUL:
727	    command = ATA_WRITE_MUL48; break;
728	case ATA_WRITE_DMA:
729	    command = ATA_WRITE_DMA48; break;
730	case ATA_WRITE_DMA_QUEUED:
731	    command = ATA_WRITE_DMA_QUEUED48; break;
732	case ATA_FLUSHCACHE:
733	    command = ATA_FLUSHCACHE48; break;
734	default:
735	    return command;
736	}
737	atadev->flags |= ATA_D_48BIT_ACTIVE;
738    }
739    return command;
740}
741
742void
743ata_udelay(int interval)
744{
745    /* for now just use DELAY, the timer/sleep subsytems are not there yet */
746    if (1 || interval < (1000000/hz) || ata_delayed_attach)
747	DELAY(interval);
748    else
749	tsleep(&interval, PRIBIO, "ataslp", interval/(1000000/hz));
750}
751
752char *
753ata_mode2str(int mode)
754{
755    switch (mode) {
756    case ATA_PIO0: return "PIO0";
757    case ATA_PIO1: return "PIO1";
758    case ATA_PIO2: return "PIO2";
759    case ATA_PIO3: return "PIO3";
760    case ATA_PIO4: return "PIO4";
761    case ATA_WDMA0: return "WDMA0";
762    case ATA_WDMA1: return "WDMA1";
763    case ATA_WDMA2: return "WDMA2";
764    case ATA_UDMA0: return "UDMA16";
765    case ATA_UDMA1: return "UDMA25";
766    case ATA_UDMA2: return "UDMA33";
767    case ATA_UDMA3: return "UDMA40";
768    case ATA_UDMA4: return "UDMA66";
769    case ATA_UDMA5: return "UDMA100";
770    case ATA_UDMA6: return "UDMA133";
771    case ATA_SA150: return "SATA150";
772    default:
773	if (mode & ATA_DMA_MASK)
774	    return "BIOSDMA";
775	else
776	    return "BIOSPIO";
777    }
778}
779
780int
781ata_pmode(struct ata_params *ap)
782{
783    if (ap->atavalid & ATA_FLAG_64_70) {
784	if (ap->apiomodes & 0x02)
785	    return ATA_PIO4;
786	if (ap->apiomodes & 0x01)
787	    return ATA_PIO3;
788    }
789    if (ap->mwdmamodes & 0x04)
790	return ATA_PIO4;
791    if (ap->mwdmamodes & 0x02)
792	return ATA_PIO3;
793    if (ap->mwdmamodes & 0x01)
794	return ATA_PIO2;
795    if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x200)
796	return ATA_PIO2;
797    if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x100)
798	return ATA_PIO1;
799    if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x000)
800	return ATA_PIO0;
801    return ATA_PIO0;
802}
803
804int
805ata_wmode(struct ata_params *ap)
806{
807    if (ap->mwdmamodes & 0x04)
808	return ATA_WDMA2;
809    if (ap->mwdmamodes & 0x02)
810	return ATA_WDMA1;
811    if (ap->mwdmamodes & 0x01)
812	return ATA_WDMA0;
813    return -1;
814}
815
816int
817ata_umode(struct ata_params *ap)
818{
819    if (ap->atavalid & ATA_FLAG_88) {
820	if (ap->udmamodes & 0x40)
821	    return ATA_UDMA6;
822	if (ap->udmamodes & 0x20)
823	    return ATA_UDMA5;
824	if (ap->udmamodes & 0x10)
825	    return ATA_UDMA4;
826	if (ap->udmamodes & 0x08)
827	    return ATA_UDMA3;
828	if (ap->udmamodes & 0x04)
829	    return ATA_UDMA2;
830	if (ap->udmamodes & 0x02)
831	    return ATA_UDMA1;
832	if (ap->udmamodes & 0x01)
833	    return ATA_UDMA0;
834    }
835    return -1;
836}
837
838int
839ata_limit_mode(device_t dev, int mode, int maxmode)
840{
841    struct ata_device *atadev = device_get_softc(dev);
842
843    if (maxmode && mode > maxmode)
844	mode = maxmode;
845
846    if (mode >= ATA_UDMA0 && ata_umode(&atadev->param) > 0)
847	return min(mode, ata_umode(&atadev->param));
848
849    if (mode >= ATA_WDMA0 && ata_wmode(&atadev->param) > 0)
850	return min(mode, ata_wmode(&atadev->param));
851
852    if (mode > ata_pmode(&atadev->param))
853	return min(mode, ata_pmode(&atadev->param));
854
855    return mode;
856}
857
858static void
859bswap(int8_t *buf, int len)
860{
861    u_int16_t *ptr = (u_int16_t*)(buf + len);
862
863    while (--ptr >= (u_int16_t*)buf)
864	*ptr = ntohs(*ptr);
865}
866
867static void
868btrim(int8_t *buf, int len)
869{
870    int8_t *ptr;
871
872    for (ptr = buf; ptr < buf+len; ++ptr)
873	if (!*ptr || *ptr == '_')
874	    *ptr = ' ';
875    for (ptr = buf + len - 1; ptr >= buf && *ptr == ' '; --ptr)
876	*ptr = 0;
877}
878
879static void
880bpack(int8_t *src, int8_t *dst, int len)
881{
882    int i, j, blank;
883
884    for (i = j = blank = 0 ; i < len; i++) {
885	if (blank && src[i] == ' ') continue;
886	if (blank && src[i] != ' ') {
887	    dst[j++] = src[i];
888	    blank = 0;
889	    continue;
890	}
891	if (src[i] == ' ') {
892	    blank = 1;
893	    if (i == 0)
894		continue;
895	}
896	dst[j++] = src[i];
897    }
898    if (j < len)
899	dst[j] = 0x00;
900}
901
902
903/*
904 * module handeling
905 */
906static int
907ata_module_event_handler(module_t mod, int what, void *arg)
908{
909    static struct cdev *atacdev;
910
911    switch (what) {
912    case MOD_LOAD:
913	/* register controlling device */
914	atacdev = make_dev(&ata_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0600, "ata");
915
916	if (cold) {
917	    /* register boot attach to be run when interrupts are enabled */
918	    if (!(ata_delayed_attach = (struct intr_config_hook *)
919				       malloc(sizeof(struct intr_config_hook),
920					      M_TEMP, M_NOWAIT | M_ZERO))) {
921		printf("ata: malloc of delayed attach hook failed\n");
922		return EIO;
923	    }
924	    ata_delayed_attach->ich_func = (void*)ata_boot_attach;
925	    if (config_intrhook_establish(ata_delayed_attach) != 0) {
926		printf("ata: config_intrhook_establish failed\n");
927		free(ata_delayed_attach, M_TEMP);
928	    }
929	}
930	return 0;
931
932    case MOD_UNLOAD:
933	/* deregister controlling device */
934	destroy_dev(atacdev);
935	return 0;
936
937    default:
938	return EOPNOTSUPP;
939    }
940}
941
942static moduledata_t ata_moduledata = { "ata", ata_module_event_handler, NULL };
943DECLARE_MODULE(ata, ata_moduledata, SI_SUB_CONFIGURE, SI_ORDER_SECOND);
944MODULE_VERSION(ata, 1);
945
946static void
947ata_init(void)
948{
949    ata_request_zone = uma_zcreate("ata_request", sizeof(struct ata_request),
950				   NULL, NULL, NULL, NULL, 0, 0);
951    ata_composite_zone = uma_zcreate("ata_composite",
952				     sizeof(struct ata_composite),
953				     NULL, NULL, NULL, NULL, 0, 0);
954}
955SYSINIT(ata_register, SI_SUB_DRIVERS, SI_ORDER_SECOND, ata_init, NULL);
956
957static void
958ata_uninit(void)
959{
960    uma_zdestroy(ata_composite_zone);
961    uma_zdestroy(ata_request_zone);
962}
963SYSUNINIT(ata_unregister, SI_SUB_DRIVERS, SI_ORDER_SECOND, ata_uninit, NULL);
964