/*      $NetBSD: wdc.c,v 1.4 2019/01/08 19:15:27 christos Exp $ */

/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Manuel Bouyer.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/param.h>
#include <sys/types.h>
#include <sys/disklabel.h>
#include <sys/bootblock.h>

#include <lib/libsa/stand.h>
#include <lib/libkern/libkern.h>

#include "boot.h"
#include "wdvar.h"

#define WDCDELAY        100
#define WDCNDELAY_RST   31000 * 10

static int __wdcwait_reset(struct wdc_channel *, int);
static char *mkident(uint8_t *, int);
static int wdcprobe(struct wdc_channel *);
static int wdc_wait_for_ready(struct wdc_channel *);
static int wdc_read_block(struct wdc_channel *, struct wdc_command *);
static int wdccommand(struct wdc_channel *, struct wdc_command *);
static int wdccommandext(struct wdc_channel *, struct wdc_command *);
static int _wdc_exec_identify(struct wdc_channel *, int, void *);

static struct wdc_channel ch;

/*
* Reset the controller.
*/
static int
__wdcwait_reset(struct wdc_channel *chp, int drv_mask)
{
       int timeout;
       uint8_t st0, st1;

       /* wait for BSY to deassert */
       for (timeout = 0; timeout < WDCNDELAY_RST; timeout++) {
               WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM); /* master */
               delay(10);
               st0 = WDC_READ_REG(chp, wd_status);
               WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM | 0x10); /* slave */
               delay(10);
               st1 = WDC_READ_REG(chp, wd_status);

               if ((drv_mask & 0x01) == 0) {
                       /* no master */
                       if ((drv_mask & 0x02) != 0 && (st1 & WDCS_BSY) == 0) {
                               /* No master, slave is ready, it's done */
                               goto end;
                       }
               } else if ((drv_mask & 0x02) == 0) {
                       /* no slave */
                       if ((drv_mask & 0x01) != 0 && (st0 & WDCS_BSY) == 0) {
                               /* No slave, master is ready, it's done */
                               goto end;
                       }
               } else {
                       /* Wait for both master and slave to be ready */
                       if ((st0 & WDCS_BSY) == 0 && (st1 & WDCS_BSY) == 0) {
                               goto end;
                       }
               }

               delay(WDCDELAY);
       }

       /* Reset timed out. Maybe it's because drv_mask was not right */
       if (st0 & WDCS_BSY)
               drv_mask &= ~0x01;
       if (st1 & WDCS_BSY)
               drv_mask &= ~0x02;

end:
       return drv_mask;
}

static char *
mkident(uint8_t *src, int len)
{
       static char local[40];
       uint8_t *end;
       char *dst, *last;

       if (len > sizeof(local))
               len = sizeof(local);
       dst = last = local;
       end = src + len - 1;

       /* reserve space for '\0' */
       if (len < 2)
               goto out;
       /* skip leading white space */
       while (*src != '\0' && src < end && *src == ' ')
               ++src;
       /* copy string, omitting trailing white space */
       while (*src != '\0' && src < end) {
               *dst++ = *src;
               if (*src++ != ' ')
                       last = dst;
       }
out:
       *last = '\0';
       return local;
}

/* Test to see controller with at last one attached drive is there.
* Returns a bit for each possible drive found (0x01 for drive 0,
* 0x02 for drive 1).
* Logic:
* - If a status register is at 0xff, assume there is no drive here
*   (ISA has pull-up resistors).  Similarly if the status register has
*   the value we last wrote to the bus (for IDE interfaces without pullups).
*   If no drive at all -> return.
* - reset the controller, wait for it to complete (may take up to 31s !).
*   If timeout -> return.
*/
static int
wdcprobe(struct wdc_channel *chp)
{
       uint8_t st0, st1;
       uint8_t drives = 0x03;
       uint8_t drive, cl, ch;
       uint8_t ident[DEV_BSIZE];

       /*
        * Sanity check to see if the wdc channel responds at all.
        */
       WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM);
       delay(10);
       st0 = WDC_READ_REG(chp, wd_status);
       WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM | 0x10);
       delay(10);
       st1 = WDC_READ_REG(chp, wd_status);

       if (st0 == 0xff || st0 == WDSD_IBM)
               drives &= ~0x01;
       if (st1 == 0xff || st1 == (WDSD_IBM | 0x10))
               drives &= ~0x02;
       if (drives == 0)
               return 0;

       if (!(st0 & WDCS_DRDY))
               drives &= ~0x01;
       if (!(st1 & WDCS_DRDY))
               drives &= ~0x02;
       if (drives == 0)
               return 0;

       /* assert SRST, wait for reset to complete */
       WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM);
       delay(10);
       WDC_WRITE_CTLREG(chp, wd_aux_ctlr, WDCTL_RST | WDCTL_IDS);
       delay(1000);
       WDC_WRITE_CTLREG(chp, wd_aux_ctlr, WDCTL_IDS);
       delay(1000);
       (void) WDC_READ_REG(chp, wd_error);
       WDC_WRITE_CTLREG(chp, wd_aux_ctlr, WDCTL_4BIT);
       delay(10);

       drives = __wdcwait_reset(chp, drives);

       /* if reset failed, there's nothing here */
       if (drives == 0)
               return 0;

       /*
        * Test presence of drives. First test register signatures looking for
        * ATAPI devices. If it's not an ATAPI and reset said there may be
        * something here assume it's ATA or OLD. Ghost will be killed later in
        * attach routine.
        */
       for (drive = 0; drive < 2; drive++) {
               if ((drives & (1 << drive)) == 0)
                       continue;

               /*
                * ATAPI device not support...
                */
               WDC_WRITE_REG(chp, wd_sdh, WDSD_IBM | (drive << 4));
               cl = WDC_READ_REG(chp, wd_cyl_lo);
               ch = WDC_READ_REG(chp, wd_cyl_hi);
               if (cl == 0x14 && ch == 0xeb) {
                       drives &= ~(1 << drive);
                       continue;
               }

               if (_wdc_exec_identify(chp, drive, ident) == 0) {
                       struct ataparams *prms = (struct ataparams *)ident;
                       char *model;

                       model =
                           mkident(prms->atap_model, sizeof(prms->atap_model));
                       printf("/dev/disk/ide/0/%s/0: <%s>\n",
                           (drive == 0) ? "master" : "slave", model);
               } else
                       printf("/dev/disk/ide/0/%s/0: identify failed\n",
                           (drive == 0) ? "master" : "slave");
       }
       return drives;
}

/*
* Wait until the device is ready.
*/
int
wdc_wait_for_ready(struct wdc_channel *chp)
{
       u_int timeout;

       for (timeout = WDC_TIMEOUT; timeout > 0; --timeout) {
               if ((WDC_READ_REG(chp, wd_status) & (WDCS_BSY | WDCS_DRDY))
                               == WDCS_DRDY)
                       return 0;
       }
       return ENXIO;
}

/*
* Read one block off the device.
*/
int
wdc_read_block(struct wdc_channel *chp, struct wdc_command *wd_c)
{
       int i;
       uint16_t *ptr = (uint16_t *)wd_c->data;

       if (ptr == NULL)
               return EIO;

       if (wd_c->r_command == WDCC_IDENTIFY)
               for (i = wd_c->bcount; i > 0; i -= sizeof(uint16_t))
                       *ptr++ = WDC_READ_DATA(chp);
       else
               for (i = wd_c->bcount; i > 0; i -= sizeof(uint16_t))
                       *ptr++ = WDC_READ_DATA_STREAM(chp);

       return 0;
}

/*
* Send a command to the device (CHS and LBA addressing).
*/
int
wdccommand(struct wdc_channel *chp, struct wdc_command *wd_c)
{

#if 0
       DPRINTF(("wdccommand(%d, %d, %d, %d, %d, %d)\n",
           wd_c->drive, wd_c->r_command, wd_c->r_cyl,
           wd_c->r_head, wd_c->r_sector, wd_c->bcount));
#endif

       WDC_WRITE_REG(chp, wd_features, wd_c->r_features);
       WDC_WRITE_REG(chp, wd_seccnt, wd_c->r_count);
       WDC_WRITE_REG(chp, wd_sector, wd_c->r_sector);
       WDC_WRITE_REG(chp, wd_cyl_lo, wd_c->r_cyl);
       WDC_WRITE_REG(chp, wd_cyl_hi, wd_c->r_cyl >> 8);
       WDC_WRITE_REG(chp, wd_sdh,
           WDSD_IBM | (wd_c->drive << 4) | wd_c->r_head);
       WDC_WRITE_REG(chp, wd_command, wd_c->r_command);

       if (wdc_wait_for_ready(chp) != 0)
               return ENXIO;

       if (WDC_READ_REG(chp, wd_status) & WDCS_ERR) {
               printf("/dev/disk/ide/0/%s/0: error %x\n",
                   (wd_c->drive == 0) ? "master" : "slave",
                   WDC_READ_REG(chp, wd_error));
               return ENXIO;
       }

       return 0;
}

/*
* Send a command to the device (LBA48 addressing).
*/
int
wdccommandext(struct wdc_channel *chp, struct wdc_command *wd_c)
{

#if 0
       DPRINTF(("%s(%d, %x, %" PRId64 ", %d)\n", __func__,
           wd_c->drive, wd_c->r_command,
           wd_c->r_blkno, wd_c->r_count));
#endif

       /* Select drive, head, and addressing mode. */
       WDC_WRITE_REG(chp, wd_sdh, (wd_c->drive << 4) | WDSD_LBA);

       /* previous */
       WDC_WRITE_REG(chp, wd_features, 0);
       WDC_WRITE_REG(chp, wd_seccnt, wd_c->r_count >> 8);
       WDC_WRITE_REG(chp, wd_lba_hi, wd_c->r_blkno >> 40);
       WDC_WRITE_REG(chp, wd_lba_mi, wd_c->r_blkno >> 32);
       WDC_WRITE_REG(chp, wd_lba_lo, wd_c->r_blkno >> 24);

       /* current */
       WDC_WRITE_REG(chp, wd_features, 0);
       WDC_WRITE_REG(chp, wd_seccnt, wd_c->r_count);
       WDC_WRITE_REG(chp, wd_lba_hi, wd_c->r_blkno >> 16);
       WDC_WRITE_REG(chp, wd_lba_mi, wd_c->r_blkno >> 8);
       WDC_WRITE_REG(chp, wd_lba_lo, wd_c->r_blkno);

       /* Send command. */
       WDC_WRITE_REG(chp, wd_command, wd_c->r_command);

       if (wdc_wait_for_ready(chp) != 0)
               return ENXIO;

       if (WDC_READ_REG(chp, wd_status) & WDCS_ERR) {
               printf("/dev/disk/ide/0/%s/0: error %x\n",
                   (wd_c->drive == 0) ? "master" : "slave",
                   WDC_READ_REG(chp, wd_error));
               return ENXIO;
       }

       return 0;
}

static int
_wdc_exec_identify(struct wdc_channel *chp, int drive, void *data)
{
       struct wdc_command wd_c;
       int error;

       memset(&wd_c, 0, sizeof(wd_c));

       wd_c.drive = drive;
       wd_c.r_command = WDCC_IDENTIFY;
       wd_c.bcount = DEV_BSIZE;
       wd_c.data = data;

       if ((error = wdccommand(chp, &wd_c)) != 0)
               return error;

       return wdc_read_block(chp, &wd_c);
}

/*
* Initialize the device.
*/
int
wdc_init(int addr)
{
       struct wdc_channel tmp;
       int i;

       memset(&ch, 0, sizeof(ch));

       /* set up cmd/ctl registers */
       tmp.c_cmdbase = addr;
#define WDC_ISA_AUXREG_OFFSET   0x206
       tmp.c_ctlbase = addr + WDC_ISA_AUXREG_OFFSET;
       tmp.c_data = addr + wd_data;
       for (i = 0; i < WDC_NPORTS; i++)
               tmp.c_cmdreg[i] = tmp.c_cmdbase + i;
       /* set up shadow registers */
       tmp.c_cmdreg[wd_status]   = tmp.c_cmdreg[wd_command];
       tmp.c_cmdreg[wd_features] = tmp.c_cmdreg[wd_precomp];

       if (wdcprobe(&tmp) == 0)
               return ENXIO;
       ch = tmp;
       return 0;
}

/*
* Issue 'device identify' command.
*/
int
wdc_exec_identify(struct wd_softc *wd, void *data)
{
       struct wdc_channel *chp;

       if (wd->sc_ctlr != 0)
               return ENOTSUP;
       if (ch.c_cmdbase == 0)
               return ENOENT;
       chp = &ch;

       return _wdc_exec_identify(chp, wd->sc_unit, data);
}

/*
* Issue 'read' command.
*/
int
wdc_exec_read(struct wd_softc *wd, uint8_t cmd, daddr_t blkno, void *data)
{
       struct wdc_command wd_c;
       struct wdc_channel *chp;
       int error;
       bool lba, lba48;

       if (wd->sc_ctlr != 0)
               return ENOTSUP;
       if (ch.c_cmdbase == 0)
               return ENOENT;
       chp = &ch;

       memset(&wd_c, 0, sizeof(wd_c));
       lba   = false;
       lba48 = false;

       wd_c.data = data;
       wd_c.r_count = 1;
       wd_c.r_features = 0;
       wd_c.drive = wd->sc_unit;
       wd_c.bcount = wd->sc_label.d_secsize;

       if ((wd->sc_flags & WDF_LBA48) != 0 && blkno > wd->sc_capacity28)
               lba48 = true;
       else if ((wd->sc_flags & WDF_LBA) != 0)
               lba = true;

       if (lba48) {
               /* LBA48 */
               wd_c.r_command = atacmd_to48(cmd);
               wd_c.r_blkno = blkno;
       } else if (lba) {
               /* LBA */
               wd_c.r_command = cmd;
               wd_c.r_sector = (blkno >> 0) & 0xff;
               wd_c.r_cyl = (blkno >> 8) & 0xffff;
               wd_c.r_head = (blkno >> 24) & 0x0f;
               wd_c.r_head |= WDSD_LBA;
       } else {
               /* CHS */
               wd_c.r_command = cmd;
               wd_c.r_sector = blkno % wd->sc_label.d_nsectors;
               wd_c.r_sector++;    /* Sectors begin with 1, not 0. */
               blkno /= wd->sc_label.d_nsectors;
               wd_c.r_head = blkno % wd->sc_label.d_ntracks;
               blkno /= wd->sc_label.d_ntracks;
               wd_c.r_cyl = blkno;
               wd_c.r_head |= WDSD_CHS;
       }

       if (lba48)
               error = wdccommandext(chp, &wd_c);
       else
               error = wdccommand(chp, &wd_c);

       if (error != 0)
               return error;

       return wdc_read_block(chp, &wd_c);
}