/*      $NetBSD: satapmp_subr.c,v 1.16 2020/04/13 10:49:34 jdolecek Exp $       */

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

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: satapmp_subr.c,v 1.16 2020/04/13 10:49:34 jdolecek Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/proc.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/intr.h>

#include <dev/ata/ataconf.h>
#include <dev/ata/atareg.h>
#include <dev/ata/atavar.h>

#include <dev/ata/satapmpvar.h>
#include <dev/ata/satapmpreg.h>
#include <dev/ata/satavar.h>
#include <dev/ata/satareg.h>

static int
satapmp_read_8(struct ata_channel *chp, int port, int reg, uint64_t *value,
   struct ata_xfer *xfer)
{
       struct atac_softc *atac = chp->ch_atac;
       struct ata_drive_datas *drvp;
       int error = 0;

       KASSERT(port < PMP_MAX_DRIVES);
       KASSERT(reg < PMP_GSCR_NREGS);
       KASSERT(chp->ch_ndrives >= PMP_MAX_DRIVES);
       drvp = &chp->ch_drive[PMP_PORT_CTL];
       KASSERT(drvp->drive == PMP_PORT_CTL);
       ata_channel_lock_owned(chp);

       memset(xfer, 0, sizeof(*xfer));
       xfer->c_ata_c.r_command = PMPC_READ_PORT;
       xfer->c_ata_c.r_features = reg;
       xfer->c_ata_c.r_device = port;
       xfer->c_ata_c.timeout = 3000; /* 3s */
       xfer->c_ata_c.r_st_bmask = 0;
       xfer->c_ata_c.r_st_pmask = WDCS_DRDY;
       xfer->c_ata_c.flags = AT_LBA48 | AT_READREG | AT_WAIT;

       ata_channel_unlock(chp);

       (*atac->atac_bustype_ata->ata_exec_command)(drvp, xfer);
       ata_wait_cmd(chp, xfer);

       if (xfer->c_ata_c.flags & (AT_TIMEOU | AT_DF)) {
               aprint_error_dev(chp->atabus,
                   "PMP port %d register %d read failed, flags 0x%x\n",
                   port, reg, xfer->c_ata_c.flags);
               error = EIO;
               goto out;
       }
       if (xfer->c_ata_c.flags & AT_ERROR) {
               aprint_verbose_dev(chp->atabus,
                   "PMP port %d register %d read failed, error 0x%x\n",
                   port, reg, xfer->c_ata_c.r_error);
               error = EIO;
               goto out;
       }

       *value = ((uint64_t)((xfer->c_ata_c.r_lba >> 24) & 0xffffff) << 40) |
               ((uint64_t)((xfer->c_ata_c.r_count >> 8) & 0xff) << 32) |
               ((uint64_t)((xfer->c_ata_c.r_lba >> 0) & 0xffffff) << 8) |
               ((uint64_t)((xfer->c_ata_c.r_count >> 0) & 0xff) << 0);

out:
       ata_channel_lock(chp);
       return error;
}

static inline int
satapmp_read(struct ata_channel *chp, int port, int reg, uint32_t *value,
   struct ata_xfer *xfer)
{
       uint64_t value64;
       int ret;

       ret = satapmp_read_8(chp, port, reg, &value64, xfer);
       if (ret)
               return ret;

       *value = value64 & 0xffffffff;
       return ret;
}

static int
satapmp_write_8(struct ata_channel *chp, int port, int reg, uint64_t value,
   struct ata_xfer *xfer)
{
       struct atac_softc *atac = chp->ch_atac;
       struct ata_drive_datas *drvp;
       int error = 0;

       KASSERT(port < PMP_MAX_DRIVES);
       KASSERT(reg < PMP_GSCR_NREGS);
       KASSERT(chp->ch_ndrives >= PMP_MAX_DRIVES);
       drvp = &chp->ch_drive[PMP_PORT_CTL];
       KASSERT(drvp->drive == PMP_PORT_CTL);
       ata_channel_lock_owned(chp);

       memset(xfer, 0, sizeof(*xfer));
       xfer->c_ata_c.r_command = PMPC_WRITE_PORT;
       xfer->c_ata_c.r_features = reg;
       xfer->c_ata_c.r_device = port;
       xfer->c_ata_c.r_lba = (((value >> 40) & 0xffffff) << 24) |
                     (((value >>  8) & 0xffffff) <<  0);
       xfer->c_ata_c.r_count = (((value >> 32) & 0xff) << 8) |
                       (((value >>  0) & 0xff) << 0);
       xfer->c_ata_c.timeout = 3000; /* 3s */
       xfer->c_ata_c.r_st_bmask = 0;
       xfer->c_ata_c.r_st_pmask = WDCS_DRDY;
       xfer->c_ata_c.flags = AT_LBA48 | AT_WAIT;

       ata_channel_unlock(chp);

       (*atac->atac_bustype_ata->ata_exec_command)(drvp, xfer);
       ata_wait_cmd(chp, xfer);

       if (xfer->c_ata_c.flags & (AT_TIMEOU | AT_DF)) {
               aprint_error_dev(chp->atabus,
                   "PMP port %d register %d write failed, flags 0x%x\n",
                   port, reg, xfer->c_ata_c.flags);
               error = EIO;
               goto out;
       }
       if (xfer->c_ata_c.flags & AT_ERROR) {
               aprint_verbose_dev(chp->atabus,
                   "PMP port %d register %d write failed, error 0x%x\n",
                   port, reg, xfer->c_ata_c.r_error);
               error = EIO;
               goto out;
       }

out:
       ata_channel_lock(chp);
       return error;
}

static inline int
satapmp_write(struct ata_channel *chp, int port, int reg, uint32_t value,
   struct ata_xfer *xfer)
{
       return satapmp_write_8(chp, port, reg, value, xfer);
}

/*
* Reset one port's PHY and bring it online
* XXX duplicate of sata_reset_interface()
*/
static uint32_t
satapmp_reset_device_port(struct ata_channel *chp, int port,
   struct ata_xfer *xfer)
{
       uint32_t scontrol, sstatus;
       int i;

       ata_channel_lock_owned(chp);

       /* bring the PHY online */
       scontrol = SControl_IPM_NONE | SControl_SPD_ANY | SControl_DET_INIT;
       if (satapmp_write(chp, port, PMP_PSCR_SControl, scontrol, xfer) != 0)
               return 0;

       ata_delay(chp, 50, "sataup", AT_WAIT);
       scontrol &= ~SControl_DET_INIT;
       if (satapmp_write(chp, port, PMP_PSCR_SControl, scontrol, xfer) != 0)
               return 0;
       ata_delay(chp, 50, "sataup", AT_WAIT);

       /* wait up to 1s for device to come up */
       for (i = 0; i < 100; i++) {

               if (satapmp_read(chp, port, PMP_PSCR_SStatus, &sstatus,
                   xfer) != 0)
                       return 0;
               if ((sstatus & SStatus_DET_mask) == SStatus_DET_DEV)
                       break;
               ata_delay(chp, 10, "sataup", AT_WAIT);
       }

       switch (sstatus & SStatus_DET_mask) {
       case SStatus_DET_NODEV:
               /* No Device; be silent.  */
               break;
       case SStatus_DET_DEV_NE:
               aprint_error("%s PMP port %d: device connected, but "
                   "communication not established\n",
                   device_xname(chp->atabus), port);
               break;
       case SStatus_DET_OFFLINE:
               aprint_error("%s PMP port %d: PHY offline\n",
                   device_xname(chp->atabus), port);
               break;
       case SStatus_DET_DEV:
               aprint_normal("%s PMP port %d: device present, speed: %s\n",
                   device_xname(chp->atabus), port, sata_speed(sstatus));
               break;
       default:
               aprint_error("%s PMP port %d: unknown SStatus: 0x%08x\n",
                   device_xname(chp->atabus), port, sstatus);
       }
       return(sstatus & SStatus_DET_mask);
}

static void __noinline
satapmp_rescan(struct ata_channel *chp, struct ata_xfer *xfer)
{
       int i;
       uint32_t sig;

       KASSERT(chp->ch_satapmp_nports <= PMP_PORT_CTL);
       KASSERT(chp->ch_satapmp_nports <= chp->ch_ndrives);
       ata_channel_lock_owned(chp);

       for (i = 0; i < chp->ch_satapmp_nports; i++) {
               if (chp->ch_drive[i].drive_type != ATA_DRIVET_NONE ||
                   satapmp_reset_device_port(chp, i, xfer)
                   != SStatus_DET_DEV) {
                       continue;
               }
               if (satapmp_write(chp, i, PMP_PSCR_SError, 0xffffffff, xfer)
                   != 0) {
                       aprint_error("%s PMP port %d: can't write SError\n",
                           device_xname(chp->atabus), i);
                       continue;
               }

               ata_channel_lock_owned(chp);
               chp->ch_atac->atac_bustype_ata->ata_reset_drive(
                   &chp->ch_drive[i], AT_WAIT, &sig);

               sata_interpret_sig(chp, i, sig);
       }
}

void
satapmp_attach(struct ata_channel *chp)
{
       uint32_t id, rev, inf;
       struct ata_xfer *xfer;

       xfer = ata_get_xfer(chp, false);
       if (xfer == NULL) {
               aprint_normal_dev(chp->atabus, "no available xfer\n");
               return;
       }

       ata_channel_lock(chp);

       if (satapmp_read(chp, PMP_PORT_CTL, PMP_GSCR_ID, &id, xfer) != 0 ||
           satapmp_read(chp, PMP_PORT_CTL, PMP_GSCR_REV, &rev, xfer) != 0 ||
           satapmp_read(chp, PMP_PORT_CTL, PMP_GSCR_INF, &inf, xfer) != 0) {
               aprint_normal_dev(chp->atabus, "can't read PMP registers\n");
               goto out;
       }

       aprint_normal("%s at %s channel %d: SATA port multiplier, %d ports\n",
           device_xname(chp->atabus),
           device_xname(chp->ch_atac->atac_dev), chp->ch_channel,
           PMP_INF_NPORTS(inf));
       aprint_verbose_dev(chp->atabus,
           "vendor 0x%04x, product 0x%04x",
           PMP_ID_VEND(id), PMP_ID_DEV(id));
       if (rev & PMP_REV_SPEC_11) {
               aprint_verbose(", revision 1.1");
       } else if (rev & PMP_REV_SPEC_10) {
               aprint_verbose(", revision 1.0");
       } else {
               aprint_verbose(", unknown revision 0x%x", rev & 0x0f);
       }
       aprint_verbose(", level %d\n", PMP_REV_LEVEL(rev));

       chp->ch_satapmp_nports = PMP_INF_NPORTS(inf);

       /* reset and bring up PHYs */
       satapmp_rescan(chp, xfer);

out:
       ata_channel_unlock(chp);
       ata_free_xfer(chp, xfer);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.