sys/dev/disk/ata/ata-all.c

   1 /*-
   2  * Copyright (c) 1998,1999,2000,2001,2002 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  * $FreeBSD: src/sys/dev/ata/ata-all.c,v 1.50.2.45 2003/03/12 14:47:12 sos Exp $
  29  * $DragonFly: src/sys/dev/disk/ata/ata-all.c,v 1.38 2007/05/01 17:16:23 dillon Exp $
  30  */
  31
  32 #include "opt_ata.h"
  33 #include "use_ata.h"
  34 #include "use_atadisk.h"
  35 #include "use_atapicd.h"
  36 #include "use_atapifd.h"
  37 #include "use_atapist.h"
  38 #include "use_atapicam.h"
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/ata.h>
  42 #include <sys/kernel.h>
  43 #include <sys/conf.h>
  44 #include <sys/disk.h>
  45 #include <sys/module.h>
  46 #include <sys/bus.h>
  47 #include <sys/buf.h>
  48 #include <sys/malloc.h>
  49 #include <sys/devicestat.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/thread2.h>
  52 #include <sys/rman.h>
  53
  54 #include <machine/stdarg.h>
  55 #include <machine/clock.h>
  56
  57 #include "ata-all.h"
  58 #include "ata-disk.h"
  59 #include "ata-raid.h"
  60 #include "atapi-all.h"
  61
  62 union ata_request {
  63         struct ad_request       ad;
  64         struct atapi_request    atapi;
  65 };
  66
  67 /* device structures */
  68 static  d_ioctl_t       ataioctl;
  69 static struct dev_ops ata_ops = {
  70         { "ata", 159, 0 },
  71         .d_open =       nullopen,
  72         .d_close =      nullclose,
  73         .d_ioctl =      ataioctl,
  74 };
  75
  76 /* prototypes */
  77 #if 0
  78 static void ata_boot_attach(void);
  79 #endif
  80 static void ata_intr(void *);
  81 static int ata_getparam(struct ata_device *, u_int8_t);
  82 static int ata_service(struct ata_channel *);
  83 static void bswap(int8_t *, int);
  84 static void btrim(int8_t *, int);
  85 static void bpack(int8_t *, int8_t *, int);
  86 static void ata_change_mode(struct ata_device *, int);
  87 static u_int8_t ata_enclosure_sensor(struct ata_device *, int, u_int8_t, u_int8_t);
  88 static int ata_enclosure_status(struct ata_device *, int *, int *, int *, int *);
  89
  90 /* sysctl vars */
  91 SYSCTL_NODE(_hw, OID_AUTO, ata, CTLFLAG_RD, 0, "ATA driver parameters");
  92
  93 int ata_mpipe_size = 4;
  94 TUNABLE_INT("hw.ata.mpipe_size", &ata_mpipe_size);
  95 SYSCTL_INT(_hw_ata, OID_AUTO, mpipe_size, CTLFLAG_RW, &ata_mpipe_size, 0,
  96            "ATA global I/O pipeline max size");
  97
  98
  99 /* global vars */
 100 devclass_t ata_devclass;
 101
 102 /* local vars */
 103 static MALLOC_DEFINE(M_ATA, "ATA generic", "ATA driver generic layer");
 104
 105 /* misc defines */
 106 #define DEV_ATAPIALL    NATAPICD > 0 || NATAPIFD > 0 || \
 107                         NATAPIST > 0 || NATAPICAM > 0
 108
 109 int
 110 ata_probe(device_t dev)
 111 {
 112     struct ata_channel *ch;
 113     int rid;
 114
 115     if (!dev || !(ch = device_get_softc(dev)))
 116         return ENXIO;
 117
 118     if (ch->r_io || ch->r_altio || ch->r_irq)
 119         return EEXIST;
 120
 121     /* initialize the softc basics */
 122     ch->active = ATA_IDLE;
 123     ch->dev = dev;
 124
 125     rid = ATA_IOADDR_RID;
 126     ch->r_io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
 127                                   ATA_IOSIZE, RF_ACTIVE);
 128     if (!ch->r_io)
 129         goto failure;
 130
 131     rid = ATA_ALTADDR_RID;
 132     ch->r_altio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
 133                                      ATA_ALTIOSIZE, RF_ACTIVE);
 134     if (!ch->r_altio)
 135         goto failure;
 136
 137     rid = ATA_BMADDR_RID;
 138     ch->r_bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
 139                                     ATA_BMIOSIZE, RF_ACTIVE);
 140     if (bootverbose)
 141         ata_printf(ch, -1, "iobase=0x%04x altiobase=0x%04x bmaddr=0x%04x\n",
 142                    (int)rman_get_start(ch->r_io),
 143                    (int)rman_get_start(ch->r_altio),
 144                    (ch->r_bmio) ? (int)rman_get_start(ch->r_bmio) : 0);
 145
 146     ata_reset(ch);
 147
 148     ch->device[MASTER].channel = ch;
 149     ch->device[MASTER].unit = ATA_MASTER;
 150     ch->device[MASTER].mode = ATA_PIO;
 151     ch->device[SLAVE].channel = ch;
 152     ch->device[SLAVE].unit = ATA_SLAVE;
 153     ch->device[SLAVE].mode = ATA_PIO;
 154     TAILQ_INIT(&ch->ata_queue);
 155     TAILQ_INIT(&ch->atapi_queue);
 156
 157     mpipe_init(&ch->req_mpipe, M_ATA, sizeof(union ata_request),
 158                 4, ata_mpipe_size, 0, NULL);
 159     mpipe_init(&ch->dma_mpipe, M_DEVBUF, PAGE_SIZE,
 160                 4, ata_mpipe_size, MPF_NOZERO, NULL);
 161
 162     return 0;
 163
 164 failure:
 165     if (ch->r_io)
 166         bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ch->r_io);
 167     if (ch->r_altio)
 168         bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, ch->r_altio);
 169     if (ch->r_bmio)
 170         bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, ch->r_bmio);
 171     if (bootverbose)
 172         ata_printf(ch, -1, "probe allocation failed\n");
 173     return ENXIO;
 174 }
 175
 176 int
 177 ata_attach(device_t dev)
 178 {
 179     struct ata_channel *ch;
 180     int error, rid;
 181
 182     if (!dev || !(ch = device_get_softc(dev)))
 183         return ENXIO;
 184
 185     rid = ATA_IRQ_RID;
 186     ch->r_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
 187                                    RF_SHAREABLE | RF_ACTIVE);
 188     if (!ch->r_irq) {
 189         ata_printf(ch, -1, "unable to allocate interrupt\n");
 190         return ENXIO;
 191     }
 192
 193     /*
 194      * Traditional ata registers are sensitive to when they can be accessed
 195      * in the face of e.g. ongoing DMA.  Do not allow the interrupt to be
 196      * polled.
 197      */
 198     if ((error = bus_setup_intr(dev, ch->r_irq, INTR_NOPOLL,
 199                                 ata_intr, ch, &ch->ih, NULL))) {
 200         ata_printf(ch, -1, "unable to setup interrupt\n");
 201         return error;
 202     }
 203
 204     /*
 205      * do not attach devices if we are in early boot, this is done later
 206      * when interrupts are enabled by a hook into the boot process.
 207      * otherwise attach what the probe has found in ch->devices.
 208      */
 209     crit_enter();
 210
 211     if (ch->devices & ATA_ATA_SLAVE)
 212         if (ata_getparam(&ch->device[SLAVE], ATA_C_ATA_IDENTIFY))
 213             ch->devices &= ~ATA_ATA_SLAVE;
 214     if (ch->devices & ATA_ATAPI_SLAVE)
 215         if (ata_getparam(&ch->device[SLAVE], ATA_C_ATAPI_IDENTIFY))
 216             ch->devices &= ~ATA_ATAPI_SLAVE;
 217     if (ch->devices & ATA_ATA_MASTER)
 218         if (ata_getparam(&ch->device[MASTER], ATA_C_ATA_IDENTIFY))
 219             ch->devices &= ~ATA_ATA_MASTER;
 220     if (ch->devices & ATA_ATAPI_MASTER)
 221         if (ata_getparam(&ch->device[MASTER], ATA_C_ATAPI_IDENTIFY))
 222             ch->devices &= ~ATA_ATAPI_MASTER;
 223 #if NATADISK > 0
 224     if (ch->devices & ATA_ATA_MASTER)
 225         ad_attach(&ch->device[MASTER], 0);
 226     if (ch->devices & ATA_ATA_SLAVE)
 227         ad_attach(&ch->device[SLAVE], 0);
 228 #endif
 229 #if DEV_ATAPIALL
 230     if (ch->devices & ATA_ATAPI_MASTER)
 231         atapi_attach(&ch->device[MASTER], 0);
 232     if (ch->devices & ATA_ATAPI_SLAVE)
 233         atapi_attach(&ch->device[SLAVE], 0);
 234 #endif
 235 #if NATAPICAM > 0
 236     atapi_cam_attach_bus(ch);
 237 #endif
 238     crit_exit();
 239     return 0;
 240 }
 241
 242 int
 243 ata_detach(device_t dev)
 244 {
 245     struct ata_channel *ch;
 246
 247     if (!dev || !(ch = device_get_softc(dev)) ||
 248         !ch->r_io || !ch->r_altio || !ch->r_irq)
 249         return ENXIO;
 250
 251     /* make sure channel is not busy */
 252     crit_enter();
 253     ATA_SLEEPLOCK_CH(ch, ATA_CONTROL);
 254 #if NATADISK > 0
 255     if (ch->devices & ATA_ATA_MASTER && ch->device[MASTER].driver)
 256         ad_detach(&ch->device[MASTER], 1);
 257     if (ch->devices & ATA_ATA_SLAVE && ch->device[SLAVE].driver)
 258         ad_detach(&ch->device[SLAVE], 1);
 259 #endif
 260 #if DEV_ATAPIALL
 261     if (ch->devices & ATA_ATAPI_MASTER && ch->device[MASTER].driver)
 262         atapi_detach(&ch->device[MASTER]);
 263     if (ch->devices & ATA_ATAPI_SLAVE && ch->device[SLAVE].driver)
 264         atapi_detach(&ch->device[SLAVE]);
 265 #endif
 266 #if NATAPICAM > 0
 267     atapi_cam_detach_bus(ch);
 268 #endif
 269     crit_exit();
 270
 271     if (ch->device[MASTER].param) {
 272         kfree(ch->device[MASTER].param, M_ATA);
 273         ch->device[MASTER].param = NULL;
 274     }
 275     if (ch->device[SLAVE].param) {
 276         kfree(ch->device[SLAVE].param, M_ATA);
 277         ch->device[SLAVE].param = NULL;
 278     }
 279     ch->device[MASTER].driver = NULL;
 280     ch->device[SLAVE].driver = NULL;
 281     ch->device[MASTER].mode = ATA_PIO;
 282     ch->device[SLAVE].mode = ATA_PIO;
 283     ch->devices = 0;
 284     ata_dmafreetags(ch);
 285
 286     bus_teardown_intr(dev, ch->r_irq, ch->ih);
 287     bus_release_resource(dev, SYS_RES_IRQ, ATA_IRQ_RID, ch->r_irq);
 288     if (ch->r_bmio)
 289         bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, ch->r_bmio);
 290     bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, ch->r_altio);
 291     bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ch->r_io);
 292     ch->r_io = NULL;
 293     ch->r_altio = NULL;
 294     ch->r_bmio = NULL;
 295     ch->r_irq = NULL;
 296     mpipe_done(&ch->req_mpipe);
 297     mpipe_done(&ch->dma_mpipe);
 298
 299     ATA_UNLOCK_CH(ch);
 300     return 0;
 301 }
 302
 303 int
 304 ata_suspend(device_t dev)
 305 {
 306     struct ata_channel *ch;
 307
 308     if (dev == NULL || (ch = device_get_softc(dev)) == NULL)
 309         return ENXIO;
 310
 311     /* wait for the channel to be IDLE or detached before suspending */
 312     while (ch->r_irq) {
 313         crit_enter();
 314         if (ch->active == ATA_IDLE) {
 315             ch->active = ATA_CONTROL;
 316             crit_exit();
 317             break;
 318         }
 319         crit_exit();
 320         tsleep(ch, 0, "atasusp", hz / 10);
 321     }
 322     return 0;
 323 }
 324
 325 int
 326 ata_resume(device_t dev)
 327 {
 328     return ata_reinit(device_get_softc(dev));
 329 }
 330
 331 static int
 332 ataioctl(struct dev_ioctl_args *ap)
 333 {
 334     struct ata_cmd *iocmd = (struct ata_cmd *)ap->a_data;
 335     struct ata_channel *ch;
 336     device_t device = devclass_get_device(ata_devclass, iocmd->channel);
 337     int error;
 338
 339     if (ap->a_cmd != IOCATA)
 340         return ENOTTY;
 341
 342     if (iocmd->channel < -1 || iocmd->device < -1 || iocmd->device > SLAVE)
 343         return ENXIO;
 344
 345     switch (iocmd->cmd) {
 346         case ATAATTACH:
 347             /* should enable channel HW on controller that can SOS XXX */
 348             error = ata_probe(device);
 349             if (!error)
 350                 error = ata_attach(device);
 351             return error;
 352
 353         case ATADETACH:
 354             error = ata_detach(device);
 355             /* should disable channel HW on controller that can SOS XXX */
 356             return error;
 357
 358         case ATAREINIT:
 359             if (!device || !(ch = device_get_softc(device)))
 360                 return ENXIO;
 361             crit_enter();       /* interlock non-atomic channel lock */
 362             ATA_SLEEPLOCK_CH(ch, ATA_ACTIVE);
 363             if ((error = ata_reinit(ch)))
 364                 ATA_UNLOCK_CH(ch);
 365             crit_exit();
 366             return error;
 367
 368         case ATAGMODE:
 369             if (!device || !(ch = device_get_softc(device)))
 370                 return ENXIO;
 371
 372             if ((iocmd->device == MASTER || iocmd->device == -1) &&
 373                 ch->device[MASTER].driver)
 374                 iocmd->u.mode.mode[MASTER] = ch->device[MASTER].mode;
 375             else
 376                 iocmd->u.mode.mode[MASTER] = -1;
 377
 378             if ((iocmd->device == SLAVE || iocmd->device == -1) &&
 379                 ch->device[SLAVE].param)
 380                 iocmd->u.mode.mode[SLAVE] = ch->device[SLAVE].mode;
 381             else
 382                 iocmd->u.mode.mode[SLAVE] = -1;
 383             return 0;
 384
 385         case ATASMODE:
 386             if (!device || !(ch = device_get_softc(device)))
 387                 return ENXIO;
 388
 389             if ((iocmd->device == MASTER || iocmd->device == -1) &&
 390                 iocmd->u.mode.mode[MASTER] >= 0 && ch->device[MASTER].param) {
 391                 ata_change_mode(&ch->device[MASTER],iocmd->u.mode.mode[MASTER]);
 392                 iocmd->u.mode.mode[MASTER] = ch->device[MASTER].mode;
 393             }
 394             else
 395                 iocmd->u.mode.mode[MASTER] = -1;
 396
 397             if ((iocmd->device == SLAVE || iocmd->device == -1) &&
 398                 iocmd->u.mode.mode[SLAVE] >= 0 && ch->device[SLAVE].param) {
 399                 ata_change_mode(&ch->device[SLAVE], iocmd->u.mode.mode[SLAVE]);
 400                 iocmd->u.mode.mode[SLAVE] = ch->device[SLAVE].mode;
 401             }
 402             else
 403                 iocmd->u.mode.mode[SLAVE] = -1;
 404             return 0;
 405
 406         case ATAGPARM:
 407             if (!device || !(ch = device_get_softc(device)))
 408                 return ENXIO;
 409
 410             iocmd->u.param.type[MASTER] =
 411                 ch->devices & (ATA_ATA_MASTER | ATA_ATAPI_MASTER);
 412             iocmd->u.param.type[SLAVE] =
 413                 ch->devices & (ATA_ATA_SLAVE | ATA_ATAPI_SLAVE);
 414
 415             if (ch->device[MASTER].name)
 416                 strcpy(iocmd->u.param.name[MASTER], ch->device[MASTER].name);
 417             if (ch->device[SLAVE].name)
 418                 strcpy(iocmd->u.param.name[SLAVE], ch->device[SLAVE].name);
 419
 420             if (ch->device[MASTER].param)
 421                 bcopy(ch->device[MASTER].param, &iocmd->u.param.params[MASTER],
 422                       sizeof(struct ata_params));
 423             if (ch->device[SLAVE].param)
 424                 bcopy(ch->device[SLAVE].param, &iocmd->u.param.params[SLAVE],
 425                       sizeof(struct ata_params));
 426             return 0;
 427
 428         case ATAENCSTAT: {
 429             struct ata_device *atadev;
 430
 431             if (!device || !(ch = device_get_softc(device)))
 432                 return ENXIO;
 433
 434             if (iocmd->device == SLAVE)
 435                 atadev = &ch->device[SLAVE];
 436             else
 437                 atadev = &ch->device[MASTER];
 438
 439             return ata_enclosure_status(atadev,
 440                                         &iocmd->u.enclosure.fan,
 441                                         &iocmd->u.enclosure.temp,
 442                                         &iocmd->u.enclosure.v05,
 443                                         &iocmd->u.enclosure.v12);
 444         }
 445
 446 #if NATADISK > 0
 447         case ATARAIDREBUILD:
 448             return ata_raid_rebuild(iocmd->channel);
 449
 450         case ATARAIDCREATE:
 451             return ata_raid_create(&iocmd->u.raid_setup);
 452
 453         case ATARAIDDELETE:
 454             return ata_raid_delete(iocmd->channel);
 455
 456         case ATARAIDSTATUS:
 457             return ata_raid_status(iocmd->channel, &iocmd->u.raid_status);
 458 #endif
 459 #if DEV_ATAPIALL
 460         case ATAPICMD: {
 461             struct ata_device *atadev;
 462             caddr_t buf;
 463
 464             if (!device || !(ch = device_get_softc(device)))
 465                 return ENXIO;
 466
 467             if (!(atadev = &ch->device[iocmd->device]) ||
 468                 !(ch->devices & (iocmd->device == MASTER ?
 469                                  ATA_ATAPI_MASTER : ATA_ATAPI_SLAVE)))
 470                 return ENODEV;
 471
 472             buf = kmalloc(iocmd->u.atapi.count, M_ATA, M_INTWAIT);
 473
 474             if (iocmd->u.atapi.flags & ATAPI_CMD_WRITE) {
 475                 error = copyin(iocmd->u.atapi.data, buf, iocmd->u.atapi.count);
 476                 if (error)
 477                     return error;
 478             }
 479             error = atapi_queue_cmd(atadev, iocmd->u.atapi.ccb,
 480                                     buf, iocmd->u.atapi.count,
 481                                     (iocmd->u.atapi.flags == ATAPI_CMD_READ ?
 482                                      ATPR_F_READ : 0) | ATPR_F_QUIET,
 483                                     iocmd->u.atapi.timeout, NULL, NULL);
 484             if (error) {
 485                 iocmd->u.atapi.error = error;
 486                 bcopy(&atadev->result, iocmd->u.atapi.sense_data,
 487                       sizeof(struct atapi_reqsense));
 488                 error = 0;
 489             }
 490             else if (iocmd->u.atapi.flags & ATAPI_CMD_READ)
 491                 error = copyout(buf, iocmd->u.atapi.data, iocmd->u.atapi.count);
 492
 493             kfree(buf, M_ATA);
 494             return error;
 495         }
 496 #endif
 497         default:
 498             break;
 499     }
 500     return ENOTTY;
 501 }
 502
 503 static int
 504 ata_getparam(struct ata_device *atadev, u_int8_t command)
 505 {
 506     struct ata_params *ata_parm;
 507     int retry = 0;
 508
 509     ata_parm = kmalloc(sizeof(struct ata_params), M_ATA, M_INTWAIT);
 510
 511     /* apparently some devices needs this repeated */
 512     do {
 513         if (ata_command(atadev, command, 0, 0, 0, ATA_IMMEDIATE)) {
 514             ata_prtdev(atadev, "%s identify failed\n",
 515                        command == ATA_C_ATAPI_IDENTIFY ? "ATAPI" : "ATA");
 516             kfree(ata_parm, M_ATA);
 517             return -1;
 518         }
 519         if (retry++ > 4) {
 520             ata_prtdev(atadev, "%s identify retries exceeded\n",
 521                        command == ATA_C_ATAPI_IDENTIFY ? "ATAPI" : "ATA");
 522             kfree(ata_parm, M_ATA);
 523             return -1;
 524         }
 525     } while (ata_wait(atadev, ((command == ATA_C_ATAPI_IDENTIFY) ?
 526                                ATA_S_DRQ : (ATA_S_READY|ATA_S_DSC|ATA_S_DRQ))));
 527     ATA_INSW(atadev->channel->r_io, ATA_DATA, (int16_t *)ata_parm,
 528              sizeof(struct ata_params)/sizeof(int16_t));
 529
 530     if (command == ATA_C_ATA_IDENTIFY ||
 531         !((ata_parm->model[0] == 'N' && ata_parm->model[1] == 'E') ||
 532           (ata_parm->model[0] == 'F' && ata_parm->model[1] == 'X') ||
 533           (ata_parm->model[0] == 'P' && ata_parm->model[1] == 'i')))
 534         bswap(ata_parm->model, sizeof(ata_parm->model));
 535     btrim(ata_parm->model, sizeof(ata_parm->model));
 536     bpack(ata_parm->model, ata_parm->model, sizeof(ata_parm->model));
 537     bswap(ata_parm->revision, sizeof(ata_parm->revision));
 538     btrim(ata_parm->revision, sizeof(ata_parm->revision));
 539     bpack(ata_parm->revision, ata_parm->revision, sizeof(ata_parm->revision));
 540     bswap(ata_parm->serial, sizeof(ata_parm->serial));
 541     btrim(ata_parm->serial, sizeof(ata_parm->serial));
 542     bpack(ata_parm->serial, ata_parm->serial, sizeof(ata_parm->serial));
 543     atadev->param = ata_parm;
 544     return 0;
 545 }
 546
 547 #if 0
 548
 549 static void
 550 ata_boot_attach(void)
 551 {
 552     struct ata_channel *ch;
 553     int ctlr;
 554
 555     crit_enter();
 556
 557     /*
 558      * run through all ata devices and look for real ATA & ATAPI devices
 559      * using the hints we found in the early probe, this avoids some of
 560      * the delays probing of non-exsistent devices can cause.
 561      */
 562     for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) {
 563         if (!(ch = devclass_get_softc(ata_devclass, ctlr)))
 564             continue;
 565         if (ch->devices & ATA_ATA_SLAVE)
 566             if (ata_getparam(&ch->device[SLAVE], ATA_C_ATA_IDENTIFY))
 567                 ch->devices &= ~ATA_ATA_SLAVE;
 568         if (ch->devices & ATA_ATAPI_SLAVE)
 569             if (ata_getparam(&ch->device[SLAVE], ATA_C_ATAPI_IDENTIFY))
 570                 ch->devices &= ~ATA_ATAPI_SLAVE;
 571         if (ch->devices & ATA_ATA_MASTER)
 572             if (ata_getparam(&ch->device[MASTER], ATA_C_ATA_IDENTIFY))
 573                 ch->devices &= ~ATA_ATA_MASTER;
 574         if (ch->devices & ATA_ATAPI_MASTER)
 575             if (ata_getparam(&ch->device[MASTER], ATA_C_ATAPI_IDENTIFY))
 576                 ch->devices &= ~ATA_ATAPI_MASTER;
 577     }
 578
 579 #if NATADISK > 0
 580     /* now we know whats there, do the real attach, first the ATA disks */
 581     for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) {
 582         if (!(ch = devclass_get_softc(ata_devclass, ctlr)))
 583             continue;
 584         if (ch->devices & ATA_ATA_MASTER)
 585             ad_attach(&ch->device[MASTER], 0);
 586         if (ch->devices & ATA_ATA_SLAVE)
 587             ad_attach(&ch->device[SLAVE], 0);
 588     }
 589     ata_raid_attach();
 590 #endif
 591 #if DEV_ATAPIALL
 592     /* then the atapi devices */
 593     for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) {
 594         if (!(ch = devclass_get_softc(ata_devclass, ctlr)))
 595             continue;
 596         if (ch->devices & ATA_ATAPI_MASTER)
 597             atapi_attach(&ch->device[MASTER], 0);
 598         if (ch->devices & ATA_ATAPI_SLAVE)
 599             atapi_attach(&ch->device[SLAVE], 0);
 600 #if NATAPICAM > 0
 601         atapi_cam_attach_bus(ch);
 602 #endif
 603     }
 604 #endif
 605     crit_exit();
 606 }
 607
 608 #endif
 609
 610 static void
 611 ata_intr(void *data)
 612 {
 613     struct ata_channel *ch = (struct ata_channel *)data;
 614     /*
 615      * on PCI systems we might share an interrupt line with another
 616      * device or our twin ATA channel, so call ch->intr_func to figure
 617      * out if it is really an interrupt we should process here
 618      */
 619     if (ch->intr_func && ch->intr_func(ch))
 620         return;
 621
 622     /* if drive is busy it didn't interrupt */
 623     if (ATA_INB(ch->r_altio, ATA_ALTSTAT) & ATA_S_BUSY) {
 624         DELAY(100);
 625         if (!(ATA_INB(ch->r_altio, ATA_ALTSTAT) & ATA_S_DRQ))
 626             return;
 627     }
 628
 629     /* clear interrupt and get status */
 630     ch->status = ATA_INB(ch->r_io, ATA_STATUS);
 631
 632     if (ch->status & ATA_S_ERROR)
 633         ch->error = ATA_INB(ch->r_io, ATA_ERROR);
 634
 635     /* find & call the responsible driver to process this interrupt */
 636     switch (ch->active) {
 637 #if NATADISK > 0
 638     case ATA_ACTIVE_ATA:
 639         if (!ch->running || ad_interrupt(ch->running) == ATA_OP_CONTINUES)
 640             return;
 641         break;
 642 #endif
 643 #if DEV_ATAPIALL
 644     case ATA_ACTIVE_ATAPI:
 645         if (!ch->running || atapi_interrupt(ch->running) == ATA_OP_CONTINUES)
 646             return;
 647         break;
 648 #endif
 649     case ATA_WAIT_INTR:
 650     case ATA_WAIT_INTR | ATA_CONTROL:
 651         wakeup((caddr_t)ch);
 652         break;
 653
 654     case ATA_WAIT_READY:
 655     case ATA_WAIT_READY | ATA_CONTROL:
 656         break;
 657
 658     case ATA_IDLE:
 659         if (ch->flags & ATA_QUEUED) {
 660             ch->active = ATA_ACTIVE;
 661             if (ata_service(ch) == ATA_OP_CONTINUES)
 662                 return;
 663         }
 664         /* FALLTHROUGH */
 665
 666     default:
 667 #ifdef ATA_DEBUG
 668     {
 669         static int intr_count = 0;
 670
 671         if (intr_count++ < 10)
 672             ata_printf(ch, -1, "unwanted interrupt #%d active=%02x s=%02x\n",
 673                        intr_count, ch->active, ch->status);
 674     }
 675 #endif
 676         break;
 677     }
 678     ch->active &= ATA_CONTROL;
 679     if (ch->active & ATA_CONTROL)
 680         return;
 681     ch->running = NULL;
 682     ata_start(ch);
 683     return;
 684 }
 685
 686 void
 687 ata_start(struct ata_channel *ch)
 688 {
 689 #if NATADISK > 0
 690     struct ad_request *ad_request;
 691 #endif
 692 #if DEV_ATAPIALL
 693     struct atapi_request *atapi_request;
 694 #endif
 695
 696     crit_enter();       /* interlock non-atomic channel lock */
 697     if (!ATA_LOCK_CH(ch, ATA_ACTIVE)) {
 698         crit_exit();
 699         return;
 700     }
 701
 702 #if NATADISK > 0
 703     /* find & call the responsible driver if anything on the ATA queue */
 704     if (TAILQ_EMPTY(&ch->ata_queue)) {
 705         if (ch->devices & (ATA_ATA_MASTER) && ch->device[MASTER].driver)
 706             ad_start(&ch->device[MASTER]);
 707         if (ch->devices & (ATA_ATA_SLAVE) && ch->device[SLAVE].driver)
 708             ad_start(&ch->device[SLAVE]);
 709     }
 710     if ((ad_request = TAILQ_FIRST(&ch->ata_queue))) {
 711         TAILQ_REMOVE(&ch->ata_queue, ad_request, chain);
 712         ch->active = ATA_ACTIVE_ATA;
 713         ch->running = ad_request;
 714
 715         /*
 716          * The donecount had better be 0 here because the channel may not
 717          * have retained the setup for the request (if a retry).
 718          */
 719         KKASSERT(ad_request->donecount == 0);
 720         if (ad_transfer(ad_request) == ATA_OP_CONTINUES) {
 721             crit_exit();
 722             return;
 723         }
 724     }
 725
 726 #endif
 727 #if DEV_ATAPIALL
 728     /* find & call the responsible driver if anything on the ATAPI queue */
 729     if (TAILQ_EMPTY(&ch->atapi_queue)) {
 730         if (ch->devices & (ATA_ATAPI_MASTER) && ch->device[MASTER].driver)
 731             atapi_start(&ch->device[MASTER]);
 732         if (ch->devices & (ATA_ATAPI_SLAVE) && ch->device[SLAVE].driver)
 733             atapi_start(&ch->device[SLAVE]);
 734     }
 735     if ((atapi_request = TAILQ_FIRST(&ch->atapi_queue))) {
 736         TAILQ_REMOVE(&ch->atapi_queue, atapi_request, chain);
 737         ch->active = ATA_ACTIVE_ATAPI;
 738         ch->running = atapi_request;
 739         if (atapi_transfer(atapi_request) == ATA_OP_CONTINUES) {
 740             crit_exit();
 741             return;
 742         }
 743     }
 744 #endif
 745     ATA_UNLOCK_CH(ch);
 746     crit_exit();
 747 }
 748
 749 void
 750 ata_reset(struct ata_channel *ch)
 751 {
 752     u_int8_t lsb, msb, ostat0, ostat1;
 753     u_int8_t stat0 = 0, stat1 = 0;
 754     int mask = 0, timeout;
 755
 756     /* do we have any signs of ATA/ATAPI HW being present ? */
 757     ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
 758     DELAY(10);
 759     ostat0 = ATA_INB(ch->r_io, ATA_STATUS);
 760     if ((ostat0 & 0xf8) != 0xf8 && ostat0 != 0xa5) {
 761         stat0 = ATA_S_BUSY;
 762         mask |= 0x01;
 763     }
 764     ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
 765     DELAY(10);
 766     ostat1 = ATA_INB(ch->r_io, ATA_STATUS);
 767     if ((ostat1 & 0xf8) != 0xf8 && ostat1 != 0xa5) {
 768         stat1 = ATA_S_BUSY;
 769         mask |= 0x02;
 770     }
 771
 772     ch->devices = 0;
 773     if (!mask)
 774         return;
 775
 776     /* in some setups we dont want to test for a slave */
 777     if (ch->flags & ATA_NO_SLAVE) {
 778         stat1 = 0x0;
 779         mask &= ~0x02;
 780     }
 781
 782     if (bootverbose)
 783         ata_printf(ch, -1, "mask=%02x ostat0=%02x ostat2=%02x\n",
 784                    mask, ostat0, ostat1);
 785
 786     /* reset channel */
 787     ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
 788     DELAY(10);
 789     ATA_OUTB(ch->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_RESET);
 790     DRIVERSLEEP(10000);
 791     ATA_OUTB(ch->r_altio, ATA_ALTSTAT, ATA_A_IDS);
 792     DRIVERSLEEP(100000);
 793     ATA_INB(ch->r_io, ATA_ERROR);
 794
 795     /* wait for BUSY to go inactive */
 796     for (timeout = 0; timeout < 3100; timeout++) {
 797         if (stat0 & ATA_S_BUSY) {
 798             ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
 799             DELAY(10);
 800
 801             /* check for ATAPI signature while its still there */
 802             lsb = ATA_INB(ch->r_io, ATA_CYL_LSB);
 803             msb = ATA_INB(ch->r_io, ATA_CYL_MSB);
 804             stat0 = ATA_INB(ch->r_io, ATA_STATUS);
 805             if (!(stat0 & ATA_S_BUSY)) {
 806                 if (bootverbose)
 807                     ata_printf(ch, ATA_MASTER, "ATAPI %02x %02x\n", lsb, msb);
 808                 if (lsb == ATAPI_MAGIC_LSB && msb == ATAPI_MAGIC_MSB)
 809                     ch->devices |= ATA_ATAPI_MASTER;
 810             }
 811         }
 812         if (stat1 & ATA_S_BUSY) {
 813             ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
 814             DELAY(10);
 815
 816             /* check for ATAPI signature while its still there */
 817             lsb = ATA_INB(ch->r_io, ATA_CYL_LSB);
 818             msb = ATA_INB(ch->r_io, ATA_CYL_MSB);
 819             stat1 = ATA_INB(ch->r_io, ATA_STATUS);
 820             if (!(stat1 & ATA_S_BUSY)) {
 821                 if (bootverbose)
 822                     ata_printf(ch, ATA_SLAVE, "ATAPI %02x %02x\n", lsb, msb);
 823                 if (lsb == ATAPI_MAGIC_LSB && msb == ATAPI_MAGIC_MSB)
 824                     ch->devices |= ATA_ATAPI_SLAVE;
 825             }
 826         }
 827         if (mask == 0x01)      /* wait for master only */
 828             if (!(stat0 & ATA_S_BUSY))
 829                 break;
 830         if (mask == 0x02)      /* wait for slave only */
 831             if (!(stat1 & ATA_S_BUSY))
 832                 break;
 833         if (mask == 0x03)      /* wait for both master & slave */
 834             if (!(stat0 & ATA_S_BUSY) && !(stat1 & ATA_S_BUSY))
 835                 break;
 836         DRIVERSLEEP(10000);
 837     }
 838     /*
 839      * some devices release BUSY before they are ready to accept commands.
 840      * We must wait at least 50ms before attempting to issue a command after
 841      * BUSY is released.
 842      */
 843     DRIVERSLEEP(50000);
 844     ATA_OUTB(ch->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
 845
 846     if (stat0 & ATA_S_BUSY)
 847         mask &= ~0x01;
 848     if (stat1 & ATA_S_BUSY)
 849         mask &= ~0x02;
 850     if (bootverbose)
 851         ata_printf(ch, -1, "mask=%02x stat0=%02x stat1=%02x\n",
 852                    mask, stat0, stat1);
 853     if (!mask)
 854         return;
 855
 856     if (mask & 0x01 && ostat0 != 0x00 && !(ch->devices & ATA_ATAPI_MASTER)) {
 857         ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
 858         DELAY(10);
 859         ATA_OUTB(ch->r_io, ATA_ERROR, 0x58);
 860         ATA_OUTB(ch->r_io, ATA_CYL_LSB, 0xa5);
 861         lsb = ATA_INB(ch->r_io, ATA_ERROR);
 862         msb = ATA_INB(ch->r_io, ATA_CYL_LSB);
 863         if (bootverbose)
 864             ata_printf(ch, ATA_MASTER, "ATA %02x %02x\n", lsb, msb);
 865         if (lsb != 0x58 && msb == 0xa5)
 866             ch->devices |= ATA_ATA_MASTER;
 867     }
 868     if (mask & 0x02 && ostat1 != 0x00 && !(ch->devices & ATA_ATAPI_SLAVE)) {
 869         ATA_OUTB(ch->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
 870         DELAY(10);
 871         ATA_OUTB(ch->r_io, ATA_ERROR, 0x58);
 872         ATA_OUTB(ch->r_io, ATA_CYL_LSB, 0xa5);
 873         lsb = ATA_INB(ch->r_io, ATA_ERROR);
 874         msb = ATA_INB(ch->r_io, ATA_CYL_LSB);
 875         if (bootverbose)
 876             ata_printf(ch, ATA_SLAVE, "ATA %02x %02x\n", lsb, msb);
 877         if (lsb != 0x58 && msb == 0xa5)
 878             ch->devices |= ATA_ATA_SLAVE;
 879     }
 880     if (bootverbose)
 881         ata_printf(ch, -1, "devices=%02x\n", ch->devices);
 882 }
 883
 884 int
 885 ata_reinit(struct ata_channel *ch)
 886 {
 887     int devices, misdev, newdev;
 888
 889     if (!ch->r_io || !ch->r_altio || !ch->r_irq)
 890         return ENXIO;
 891
 892     ATA_FORCELOCK_CH(ch, ATA_CONTROL);
 893     ch->running = NULL;
 894     devices = ch->devices;
 895     ata_printf(ch, -1, "resetting devices .. ");
 896     ata_reset(ch);
 897
 898     if ((misdev = devices & ~ch->devices)) {
 899         if (misdev)
 900             kprintf("\n");
 901 #if NATADISK > 0
 902         if (misdev & ATA_ATA_MASTER && ch->device[MASTER].driver)
 903             ad_detach(&ch->device[MASTER], 0);
 904         if (misdev & ATA_ATA_SLAVE && ch->device[SLAVE].driver)
 905             ad_detach(&ch->device[SLAVE], 0);
 906 #endif
 907 #if DEV_ATAPIALL
 908         if (misdev & ATA_ATAPI_MASTER && ch->device[MASTER].driver)
 909             atapi_detach(&ch->device[MASTER]);
 910         if (misdev & ATA_ATAPI_SLAVE && ch->device[SLAVE].driver)
 911             atapi_detach(&ch->device[SLAVE]);
 912 #endif
 913         if (misdev & ATA_ATA_MASTER || misdev & ATA_ATAPI_MASTER) {
 914             if (ch->device[MASTER].param)
 915                 kfree(ch->device[MASTER].param, M_ATA);
 916             ch->device[MASTER].param = NULL;
 917         }
 918         if (misdev & ATA_ATA_SLAVE || misdev & ATA_ATAPI_SLAVE) {
 919             if (ch->device[SLAVE].param)
 920                 kfree(ch->device[SLAVE].param, M_ATA);
 921             ch->device[SLAVE].param = NULL;
 922         }
 923     }
 924     if ((newdev = ~devices & ch->devices)) {
 925         if (newdev & ATA_ATA_MASTER)
 926             if (ata_getparam(&ch->device[MASTER], ATA_C_ATA_IDENTIFY))
 927                 ch->devices &= ~ATA_ATA_MASTER;
 928         if (newdev & ATA_ATA_SLAVE)
 929             if (ata_getparam(&ch->device[SLAVE], ATA_C_ATA_IDENTIFY))
 930                 ch->devices &= ~ATA_ATA_SLAVE;
 931         if (newdev & ATA_ATAPI_MASTER)
 932             if (ata_getparam(&ch->device[MASTER], ATA_C_ATAPI_IDENTIFY))
 933                 ch->devices &= ~ATA_ATAPI_MASTER;
 934         if (newdev & ATA_ATAPI_SLAVE)
 935             if (ata_getparam(&ch->device[SLAVE], ATA_C_ATAPI_IDENTIFY))
 936                 ch->devices &= ~ATA_ATAPI_SLAVE;
 937     }
 938     newdev = ~devices & ch->devices;
 939     if (!misdev && newdev)
 940         kprintf("\n");
 941 #if NATADISK > 0
 942     if (newdev & ATA_ATA_MASTER && !ch->device[MASTER].driver)
 943         ad_attach(&ch->device[MASTER], 1);
 944     else if (ch->devices & ATA_ATA_MASTER && ch->device[MASTER].driver) {
 945         ata_getparam(&ch->device[MASTER], ATA_C_ATA_IDENTIFY);
 946         ad_reinit(&ch->device[MASTER]);
 947     }
 948     if (newdev & ATA_ATA_SLAVE && !ch->device[SLAVE].driver)
 949         ad_attach(&ch->device[SLAVE], 1);
 950     else if (ch->devices & (ATA_ATA_SLAVE) && ch->device[SLAVE].driver) {
 951         ata_getparam(&ch->device[SLAVE], ATA_C_ATA_IDENTIFY);
 952         ad_reinit(&ch->device[SLAVE]);
 953     }
 954 #endif
 955 #if DEV_ATAPIALL
 956     if (newdev & ATA_ATAPI_MASTER && !ch->device[MASTER].driver)
 957         atapi_attach(&ch->device[MASTER], 1);
 958     else if (ch->devices & (ATA_ATAPI_MASTER) && ch->device[MASTER].driver) {
 959         ata_getparam(&ch->device[MASTER], ATA_C_ATAPI_IDENTIFY);
 960         atapi_reinit(&ch->device[MASTER]);
 961     }
 962     if (newdev & ATA_ATAPI_SLAVE && !ch->device[SLAVE].driver)
 963         atapi_attach(&ch->device[SLAVE], 1);
 964     else if (ch->devices & (ATA_ATAPI_SLAVE) && ch->device[SLAVE].driver) {
 965         ata_getparam(&ch->device[SLAVE], ATA_C_ATAPI_IDENTIFY);
 966         atapi_reinit(&ch->device[SLAVE]);
 967     }
 968 #endif
 969 #if NATAPICAM > 0
 970     if (ch->devices & (ATA_ATAPI_MASTER | ATA_ATAPI_SLAVE))
 971         atapi_cam_reinit_bus(ch);
 972 #endif
 973     kprintf("done\n");
 974     ATA_UNLOCK_CH(ch);
 975     ata_start(ch);
 976     return 0;
 977 }
 978
 979 static int
 980 ata_service(struct ata_channel *ch)
 981 {
 982     /* do we have a SERVICE request from the drive ? */
 983     if ((ch->status & (ATA_S_SERVICE|ATA_S_ERROR|ATA_S_DRQ)) == ATA_S_SERVICE) {
 984         ATA_OUTB(ch->r_bmio, ATA_BMSTAT_PORT,
 985                  ata_dmastatus(ch) | ATA_BMSTAT_INTERRUPT);
 986 #if NATADISK > 0
 987         if ((ATA_INB(ch->r_io, ATA_DRIVE) & ATA_SLAVE) == ATA_MASTER) {
 988             if ((ch->devices & ATA_ATA_MASTER) && ch->device[MASTER].driver)
 989                 return ad_service((struct ad_softc *)
 990                                   ch->device[MASTER].driver, 0);
 991         }
 992         else {
 993             if ((ch->devices & ATA_ATA_SLAVE) && ch->device[SLAVE].driver)
 994                 return ad_service((struct ad_softc *)
 995                                   ch->device[SLAVE].driver, 0);
 996         }
 997 #endif
 998     }
 999     return ATA_OP_FINISHED;
1000 }
1001
1002 int
1003 ata_wait(struct ata_device *atadev, u_int8_t mask)
1004 {
1005     int timeout = 0;
1006
1007     DELAY(1);
1008     while (timeout < 5000000) { /* timeout 5 secs */
1009         atadev->channel->status = ATA_INB(atadev->channel->r_io, ATA_STATUS);
1010
1011         /* if drive fails status, reselect the drive just to be sure */
1012         if (atadev->channel->status == 0xff) {
1013             ata_prtdev(atadev, "no status, reselecting device\n");
1014             ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM|atadev->unit);
1015             DELAY(10);
1016             atadev->channel->status = ATA_INB(atadev->channel->r_io,ATA_STATUS);
1017             if (atadev->channel->status == 0xff)
1018                 return -1;
1019         }
1020
1021         /* are we done ? */
1022         if (!(atadev->channel->status & ATA_S_BUSY))
1023             break;
1024
1025         if (timeout > 1000) {
1026             timeout += 1000;
1027             DELAY(1000);
1028         }
1029         else {
1030             timeout += 10;
1031             DELAY(10);
1032         }
1033     }
1034     if (atadev->channel->status & ATA_S_ERROR)
1035         atadev->channel->error = ATA_INB(atadev->channel->r_io, ATA_ERROR);
1036     if (timeout >= 5000000)
1037         return -1;
1038     if (!mask)
1039         return (atadev->channel->status & ATA_S_ERROR);
1040
1041     /* Wait 50 msec for bits wanted. */
1042     timeout = 5000;
1043     while (timeout--) {
1044         atadev->channel->status = ATA_INB(atadev->channel->r_io, ATA_STATUS);
1045         if ((atadev->channel->status & mask) == mask) {
1046             if (atadev->channel->status & ATA_S_ERROR)
1047                 atadev->channel->error=ATA_INB(atadev->channel->r_io,ATA_ERROR);
1048             return (atadev->channel->status & ATA_S_ERROR);
1049         }
1050         DELAY (10);
1051     }
1052     return -1;
1053 }
1054
1055 int
1056 ata_command(struct ata_device *atadev, u_int8_t command,
1057            u_int64_t lba, u_int16_t count, u_int8_t feature, int flags)
1058 {
1059     int error = 0;
1060 #ifdef ATA_DEBUG
1061     ata_prtdev(atadev, "ata_command: addr=%04lx, cmd=%02x, "
1062                "lba=%lld, count=%d, feature=%d, flags=%02x\n",
1063                rman_get_start(atadev->channel->r_io),
1064                command, lba, count, feature, flags);
1065 #endif
1066
1067     /* select device */
1068     ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
1069
1070     /* disable interrupt from device */
1071     if (atadev->channel->flags & ATA_QUEUED)
1072         ATA_OUTB(atadev->channel->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_4BIT);
1073
1074     /* ready to issue command ? */
1075     if (ata_wait(atadev, 0) < 0) {
1076         ata_prtdev(atadev, "timeout sending command=%02x s=%02x e=%02x\n",
1077                    command, atadev->channel->status, atadev->channel->error);
1078         return -1;
1079     }
1080
1081     /* only use 48bit addressing if needed because of the overhead */
1082     if ((lba >= 268435455 || count > 256) && atadev->param &&
1083         atadev->param->support.address48) {
1084         ATA_OUTB(atadev->channel->r_io, ATA_FEATURE, (feature>>8) & 0xff);
1085         ATA_OUTB(atadev->channel->r_io, ATA_FEATURE, feature);
1086         ATA_OUTB(atadev->channel->r_io, ATA_COUNT, (count>>8) & 0xff);
1087         ATA_OUTB(atadev->channel->r_io, ATA_COUNT, count & 0xff);
1088         ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, (lba>>24) & 0xff);
1089         ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, lba & 0xff);
1090         ATA_OUTB(atadev->channel->r_io, ATA_CYL_LSB, (lba>>32) & 0xff);
1091         ATA_OUTB(atadev->channel->r_io, ATA_CYL_LSB, (lba>>8) & 0xff);
1092         ATA_OUTB(atadev->channel->r_io, ATA_CYL_MSB, (lba>>40) & 0xff);
1093         ATA_OUTB(atadev->channel->r_io, ATA_CYL_MSB, (lba>>16) & 0xff);
1094         ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_LBA | atadev->unit);
1095
1096         /* translate command into 48bit version */
1097         switch (command) {
1098         case ATA_C_READ:
1099             command = ATA_C_READ48; break;
1100         case ATA_C_READ_MUL:
1101             command = ATA_C_READ_MUL48; break;
1102         case ATA_C_READ_DMA:
1103             command = ATA_C_READ_DMA48; break;
1104         case ATA_C_READ_DMA_QUEUED:
1105             command = ATA_C_READ_DMA_QUEUED48; break;
1106         case ATA_C_WRITE:
1107             command = ATA_C_WRITE48; break;
1108         case ATA_C_WRITE_MUL:
1109             command = ATA_C_WRITE_MUL48; break;
1110         case ATA_C_WRITE_DMA:
1111             command = ATA_C_WRITE_DMA48; break;
1112         case ATA_C_WRITE_DMA_QUEUED:
1113             command = ATA_C_WRITE_DMA_QUEUED48; break;
1114         case ATA_C_FLUSHCACHE:
1115             command = ATA_C_FLUSHCACHE48; break;
1116         default:
1117             ata_prtdev(atadev, "can't translate cmd to 48bit version\n");
1118             return -1;
1119         }
1120     }
1121     else {
1122         ATA_OUTB(atadev->channel->r_io, ATA_FEATURE, feature);
1123         ATA_OUTB(atadev->channel->r_io, ATA_COUNT, count);
1124         ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, lba & 0xff);
1125         ATA_OUTB(atadev->channel->r_io, ATA_CYL_LSB, (lba>>8) & 0xff);
1126         ATA_OUTB(atadev->channel->r_io, ATA_CYL_MSB, (lba>>16) & 0xff);
1127         if (atadev->flags & ATA_D_USE_CHS)
1128             ATA_OUTB(atadev->channel->r_io, ATA_DRIVE,
1129                      ATA_D_IBM | atadev->unit | ((lba>>24) & 0xf));
1130         else
1131             ATA_OUTB(atadev->channel->r_io, ATA_DRIVE,
1132                      ATA_D_IBM | ATA_D_LBA | atadev->unit | ((lba>>24) &0xf));
1133     }
1134
1135     switch (flags & ATA_WAIT_MASK) {
1136     case ATA_IMMEDIATE:
1137         ATA_OUTB(atadev->channel->r_io, ATA_CMD, command);
1138
1139         /* enable interrupt */
1140         if (atadev->channel->flags & ATA_QUEUED)
1141             ATA_OUTB(atadev->channel->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
1142         break;
1143
1144     case ATA_WAIT_INTR:
1145         atadev->channel->active |= ATA_WAIT_INTR;
1146         ATA_OUTB(atadev->channel->r_io, ATA_CMD, command);
1147
1148         /* enable interrupt */
1149         if (atadev->channel->flags & ATA_QUEUED)
1150             ATA_OUTB(atadev->channel->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
1151
1152         if (tsleep((caddr_t)atadev->channel, 0, "atacmd", 10 * hz)) {
1153             ata_prtdev(atadev, "timeout waiting for interrupt\n");
1154             atadev->channel->active &= ~ATA_WAIT_INTR;
1155             error = -1;
1156         }
1157         break;
1158
1159     case ATA_WAIT_READY:
1160         atadev->channel->active |= ATA_WAIT_READY;
1161         ATA_OUTB(atadev->channel->r_io, ATA_CMD, command);
1162         if (ata_wait(atadev, ATA_S_READY) < 0) {
1163             ata_prtdev(atadev, "timeout waiting for cmd=%02x s=%02x e=%02x\n",
1164                        command, atadev->channel->status,atadev->channel->error);
1165             error = -1;
1166         }
1167         atadev->channel->active &= ~ATA_WAIT_READY;
1168         break;
1169     }
1170     return error;
1171 }
1172
1173 static void
1174 ata_enclosure_start(struct ata_device *atadev)
1175 {
1176     ATA_INB(atadev->channel->r_io, ATA_DRIVE);
1177     DELAY(1);
1178     ATA_INB(atadev->channel->r_io, ATA_DRIVE);
1179     DELAY(1);
1180     ATA_INB(atadev->channel->r_io, ATA_CMD);
1181     DELAY(1);
1182     ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
1183     DELAY(1);
1184     ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
1185     DELAY(1);
1186     ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
1187     DELAY(1);
1188     ATA_INB(atadev->channel->r_io, ATA_COUNT);
1189     DELAY(1);
1190     ATA_INB(atadev->channel->r_io, ATA_DRIVE);
1191     DELAY(1);
1192 }
1193
1194 static void
1195 ata_enclosure_end(struct ata_device *atadev)
1196 {
1197     ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
1198     DELAY(1);
1199 }
1200
1201 static void
1202 ata_enclosure_chip_start(struct ata_device *atadev)
1203 {
1204     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x0b);
1205     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x0a);
1206     DELAY(25);
1207     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x08);
1208 }
1209
1210 static void
1211 ata_enclosure_chip_end(struct ata_device *atadev)
1212 {
1213     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x08);
1214     DELAY(64);
1215     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x0a);
1216     DELAY(25);
1217     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x0b);
1218     DELAY(64);
1219 }
1220
1221 static u_int8_t
1222 ata_enclosure_chip_rdbit(struct ata_device *atadev)
1223 {
1224     u_int8_t val;
1225
1226     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0);
1227     DELAY(64);
1228     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x02);
1229     DELAY(25);
1230     val = ATA_INB(atadev->channel->r_io, ATA_SECTOR) & 0x01;
1231     DELAY(38);
1232     return val;
1233 }
1234
1235 static void
1236 ata_enclosure_chip_wrbit(struct ata_device *atadev, u_int8_t data)
1237 {
1238     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x08 | (data & 0x01));
1239     DELAY(64);
1240     ATA_OUTB(atadev->channel->r_io, ATA_SECTOR, 0x08 | 0x02 | (data & 0x01));
1241     DELAY(64);
1242 }
1243
1244 static u_int8_t
1245 ata_enclosure_chip_rw(struct ata_device *atadev, int rw, u_int8_t val)
1246 {
1247     int i;
1248
1249     if (rw) {
1250         for (i = 0; i < 8; i++)
1251             ata_enclosure_chip_wrbit(atadev, (val & (0x80 >> i)) ? 1 : 0);
1252     }
1253     else {
1254         for (i = 0; i < 8; i++)
1255             val = (val << 1) | ata_enclosure_chip_rdbit(atadev);
1256     }
1257     ata_enclosure_chip_wrbit(atadev, 0);
1258     return val;
1259 }
1260
1261 static u_int8_t
1262 ata_enclosure_sensor(struct ata_device *atadev,
1263                      int rw, u_int8_t idx, u_int8_t data)
1264 {
1265     ata_enclosure_start(atadev);
1266     ata_enclosure_chip_start(atadev);
1267     ata_enclosure_chip_rw(atadev, 1, 0x5a);
1268     ata_enclosure_chip_rw(atadev, 1, idx);
1269     if (rw) {
1270         ata_enclosure_chip_rw(atadev, 1, data);
1271     }
1272     else {
1273         ata_enclosure_chip_end(atadev);
1274         ata_enclosure_chip_start(atadev);
1275         ata_enclosure_chip_rw(atadev, 1, 0x5b);
1276         data = ata_enclosure_chip_rw(atadev, 0, 0);
1277     }
1278     ata_enclosure_chip_end(atadev);
1279     ata_enclosure_end(atadev);
1280     return data;
1281 }
1282
1283 static int
1284 ata_enclosure_status(struct ata_device *atadev,
1285                      int *fan, int *temp, int *v05, int *v12)
1286 {
1287     u_int8_t id1, id2, cnt, div;
1288     int error = ENXIO;
1289
1290     if (atadev->flags & ATA_D_ENC_PRESENT) {
1291         ATA_SLEEPLOCK_CH(atadev->channel, ATA_CONTROL);
1292         ata_enclosure_sensor(atadev, 1, 0x4e, 0);
1293         id1 = ata_enclosure_sensor(atadev, 0, 0x4f, 0);
1294         ata_enclosure_sensor(atadev, 1, 0x4e, 0x80);
1295         id2 = ata_enclosure_sensor(atadev, 0, 0x4f, 0);
1296         if (id1 == 0xa3 && id2 == 0x5c) {
1297             div = 1 << (((ata_enclosure_sensor(atadev, 0, 0x5d, 0)&0x20)>>3)+
1298                         ((ata_enclosure_sensor(atadev, 0, 0x47, 0)&0x30)>>4)+1);
1299             cnt = ata_enclosure_sensor(atadev, 0, 0x28, 0);
1300             if (cnt == 0xff)
1301                 *fan = 0;
1302             else
1303                 *fan = 1350000 / cnt / div;
1304             ata_enclosure_sensor(atadev, 1, 0x4e, 0x01);
1305             *temp = (ata_enclosure_sensor(atadev, 0, 0x50, 0) * 10) +
1306                     (ata_enclosure_sensor(atadev, 0, 0x50, 0) & 0x80 ? 5 : 0);
1307             *v05 = ata_enclosure_sensor(atadev, 0, 0x23, 0) * 27;
1308             *v12 = ata_enclosure_sensor(atadev, 0, 0x24, 0) * 61;
1309             error = 0;
1310         }
1311         ATA_UNLOCK_CH(atadev->channel);
1312     }
1313     return error;
1314 }
1315
1316 void
1317 ata_enclosure_print(struct ata_device *atadev)
1318 {
1319     u_int8_t id, st;
1320     int fan, temp, v05, v12;
1321
1322     ATA_SLEEPLOCK_CH(atadev->channel, ATA_CONTROL);
1323     ata_enclosure_start(atadev);
1324     id = ATA_INB(atadev->channel->r_io, ATA_DRIVE);
1325     DELAY(1);
1326     st = ATA_INB(atadev->channel->r_io, ATA_COUNT);
1327     DELAY(1);
1328     ata_enclosure_end(atadev);
1329     ATA_UNLOCK_CH(atadev->channel);
1330
1331     switch (id & 0x93) {
1332     case 0x00:
1333         ata_prtdev(atadev, "Universal enclosure");
1334         break;
1335     case 0x01:
1336         ata_prtdev(atadev, "FastSwap enclosure");
1337         break;
1338     case 0x10:
1339     case 0x11:
1340         ata_prtdev(atadev, "SuperSwap enclosure");
1341         break;
1342     default:
1343         atadev->flags &= ~ATA_D_ENC_PRESENT;
1344         return;
1345     }
1346     atadev->flags |= ATA_D_ENC_PRESENT;
1347
1348     if (ata_enclosure_status(atadev, &fan, &temp, &v05, &v12))
1349         kprintf(" detected\n");
1350     else
1351         kprintf(" [FAN:%drpm TEMP:%d.%01dC %d.%03dV %d.%03dV]\n",
1352                fan, temp/10, temp%10, v05/1000, v05%1000, v12/1000, v12%1000);
1353 }
1354
1355 void
1356 ata_enclosure_leds(struct ata_device *atadev, u_int8_t color)
1357 {
1358     if (atadev->flags & ATA_D_ENC_PRESENT) {
1359         u_int8_t reg;
1360
1361         ata_enclosure_start(atadev);
1362         reg = ATA_INB(atadev->channel->r_io, ATA_COUNT);
1363         DELAY(1);
1364         ATA_OUTB(atadev->channel->r_io, ATA_COUNT,
1365                  (color & ATA_LED_MASK) | (reg & ~ATA_LED_MASK));
1366         DELAY(1);
1367         ata_enclosure_end(atadev);
1368     }
1369 }
1370
1371 static void
1372 ata_change_mode(struct ata_device *atadev, int mode)
1373 {
1374     int umode, wmode, pmode;
1375
1376     umode = ata_umode(atadev->param);
1377     wmode = ata_wmode(atadev->param);
1378     pmode = ata_pmode(atadev->param);
1379
1380     switch (mode & ATA_DMA_MASK) {
1381     case ATA_UDMA:
1382         if ((mode & ATA_MODE_MASK) < umode)
1383             umode = mode & ATA_MODE_MASK;
1384         break;
1385     case ATA_WDMA:
1386         if ((mode & ATA_MODE_MASK) < wmode)
1387             wmode = mode & ATA_MODE_MASK;
1388         umode = -1;
1389         break;
1390     default:
1391         if (((mode & ATA_MODE_MASK) - ATA_PIO0) < pmode)
1392             pmode = (mode & ATA_MODE_MASK) - ATA_PIO0;
1393         umode = -1;
1394         wmode = -1;
1395     }
1396
1397     crit_enter();       /* interlock non-atomic channel lock */
1398     ATA_SLEEPLOCK_CH(atadev->channel, ATA_ACTIVE);
1399     ata_dmainit(atadev, pmode, wmode, umode);
1400     ATA_UNLOCK_CH(atadev->channel);
1401     crit_exit();
1402     ata_start(atadev->channel); /* XXX SOS */
1403 }
1404
1405 int
1406 ata_printf(struct ata_channel *ch, int device, const char * fmt, ...)
1407 {
1408     __va_list ap;
1409     int ret;
1410
1411     if (device == -1)
1412         ret = kprintf("ata%d: ", device_get_unit(ch->dev));
1413     else {
1414         if (ch->device[ATA_DEV(device)].name)
1415             ret = kprintf("%s: ", ch->device[ATA_DEV(device)].name);
1416         else
1417             ret = kprintf("ata%d-%s: ", device_get_unit(ch->dev),
1418                          (device == ATA_MASTER) ? "master" : "slave");
1419     }
1420     __va_start(ap, fmt);
1421     ret += kvprintf(fmt, ap);
1422     __va_end(ap);
1423     return ret;
1424 }
1425
1426 int
1427 ata_prtdev(struct ata_device *atadev, const char * fmt, ...)
1428 {
1429     __va_list ap;
1430     int ret;
1431
1432     if (atadev->name)
1433         ret = kprintf("%s: ", atadev->name);
1434     else
1435         ret = kprintf("ata%d-%s: ", device_get_unit(atadev->channel->dev),
1436                      (atadev->unit == ATA_MASTER) ? "master" : "slave");
1437     __va_start(ap, fmt);
1438     ret += kvprintf(fmt, ap);
1439     __va_end(ap);
1440     return ret;
1441 }
1442
1443 void
1444 ata_set_name(struct ata_device *atadev, char *name, int lun)
1445 {
1446     atadev->name = kmalloc(strlen(name) + 4, M_ATA, M_INTWAIT);
1447     ksprintf(atadev->name, "%s%d", name, lun);
1448 }
1449
1450 void
1451 ata_free_name(struct ata_device *atadev)
1452 {
1453     if (atadev->name)
1454         kfree(atadev->name, M_ATA);
1455     atadev->name = NULL;
1456 }
1457
1458 int
1459 ata_get_lun(u_int32_t *map)
1460 {
1461     int lun = ffs(~*map) - 1;
1462
1463     *map |= (1 << lun);
1464     return lun;
1465 }
1466
1467 int
1468 ata_test_lun(u_int32_t *map, int lun)
1469 {
1470     return (*map & (1 << lun));
1471 }
1472
1473 void
1474 ata_free_lun(u_int32_t *map, int lun)
1475 {
1476     *map &= ~(1 << lun);
1477 }
1478
1479 char *
1480 ata_mode2str(int mode)
1481 {
1482     switch (mode) {
1483     case ATA_PIO: return "BIOSPIO";
1484     case ATA_PIO0: return "PIO0";
1485     case ATA_PIO1: return "PIO1";
1486     case ATA_PIO2: return "PIO2";
1487     case ATA_PIO3: return "PIO3";
1488     case ATA_PIO4: return "PIO4";
1489     case ATA_DMA: return "BIOSDMA";
1490     case ATA_WDMA2: return "WDMA2";
1491     case ATA_UDMA2: return "UDMA33";
1492     case ATA_UDMA4: return "UDMA66";
1493     case ATA_UDMA5: return "UDMA100";
1494     case ATA_UDMA6: return "UDMA133";
1495     default: return "???";
1496     }
1497 }
1498
1499 int
1500 ata_pmode(struct ata_params *ap)
1501 {
1502     if (ap->atavalid & ATA_FLAG_64_70) {
1503         if (ap->apiomodes & 2)
1504             return 4;
1505         if (ap->apiomodes & 1)
1506             return 3;
1507     }
1508     if (ap->retired_piomode == 2)
1509         return 2;
1510     if (ap->retired_piomode == 1)
1511         return 1;
1512     if (ap->retired_piomode == 0)
1513         return 0;
1514     return -1;
1515 }
1516
1517 int
1518 ata_wmode(struct ata_params *ap)
1519 {
1520     if (ap->mwdmamodes & 0x04)
1521         return 2;
1522     if (ap->mwdmamodes & 0x02)
1523         return 1;
1524     if (ap->mwdmamodes & 0x01)
1525         return 0;
1526     return -1;
1527 }
1528
1529 int
1530 ata_umode(struct ata_params *ap)
1531 {
1532     if (ap->atavalid & ATA_FLAG_88) {
1533         if (ap->udmamodes & 0x40)
1534             return 6;
1535         if (ap->udmamodes & 0x20)
1536             return 5;
1537         if (ap->udmamodes & 0x10)
1538             return 4;
1539         if (ap->udmamodes & 0x08)
1540             return 3;
1541         if (ap->udmamodes & 0x04)
1542             return 2;
1543         if (ap->udmamodes & 0x02)
1544             return 1;
1545         if (ap->udmamodes & 0x01)
1546             return 0;
1547     }
1548     return -1;
1549 }
1550
1551 static void
1552 bswap(int8_t *buf, int len)
1553 {
1554     u_int16_t *ptr = (u_int16_t*)(buf + len);
1555
1556     while (--ptr >= (u_int16_t*)buf)
1557         *ptr = ntohs(*ptr);
1558 }
1559
1560 static void
1561 btrim(int8_t *buf, int len)
1562 {
1563     int8_t *ptr;
1564
1565     for (ptr = buf; ptr < buf+len; ++ptr)
1566         if (!*ptr)
1567             *ptr = ' ';
1568     for (ptr = buf + len - 1; ptr >= buf && *ptr == ' '; --ptr)
1569         *ptr = 0;
1570 }
1571
1572 static void
1573 bpack(int8_t *src, int8_t *dst, int len)
1574 {
1575     int i, j, blank;
1576
1577     for (i = j = blank = 0 ; i < len; i++) {
1578         if (blank && src[i] == ' ') continue;
1579         if (blank && src[i] != ' ') {
1580             dst[j++] = src[i];
1581             blank = 0;
1582             continue;
1583         }
1584         if (src[i] == ' ') {
1585             blank = 1;
1586             if (i == 0)
1587                 continue;
1588         }
1589         dst[j++] = src[i];
1590     }
1591     if (j < len)
1592         dst[j] = 0x00;
1593 }
1594
1595 static void
1596 ata_init(void)
1597 {
1598     /* register controlling device */
1599     dev_ops_add(&ata_ops, 0, 0);
1600     make_dev(&ata_ops, 0, UID_ROOT, GID_OPERATOR, 0600, "ata");
1601 }
1602 SYSINIT(atadev, SI_SUB_DRIVERS, SI_ORDER_SECOND, ata_init, NULL)