ata: merge the ata_piix driver
authorDave Liu <r63238@freescale.com>
Wed, 26 Mar 2008 14:47:06 +0000 (22:47 +0800)
committerWolfgang Denk <wd@denx.de>
Wed, 26 Mar 2008 22:38:48 +0000 (23:38 +0100)
move the cmd_sata.c from common/ to drivers/ata_piix.c,
the cmd_sata.c have some part of ata_piix controller drivers.
consolidate the driver to have better framework.

Signed-off-by: Dave Liu <daveliu@freescale.com>
common/Makefile
common/cmd_sata.c [deleted file]
drivers/block/ata_piix.c
include/configs/sc520_cdp.h
include/sata.h

index 1c81fcfe4f4c5fd01152a24d9202eec3229208bc..5c93abb1927aa0135246e4196347b94b2a4b1acc 100644 (file)
@@ -88,7 +88,6 @@ COBJS-y += cmd_pcmcia.o
 COBJS-$(CONFIG_CMD_PORTIO) += cmd_portio.o
 COBJS-$(CONFIG_CMD_REGINFO) += cmd_reginfo.o
 COBJS-$(CONFIG_CMD_REISER) += cmd_reiser.o
-COBJS-y += cmd_sata.o
 COBJS-$(CONFIG_CMD_SCSI) += cmd_scsi.o
 COBJS-$(CONFIG_CMD_SETEXPR) += cmd_setexpr.o
 COBJS-$(CONFIG_CMD_SPI) += cmd_spi.o
diff --git a/common/cmd_sata.c b/common/cmd_sata.c
deleted file mode 100644 (file)
index bd4c11f..0000000
+++ /dev/null
@@ -1,712 +0,0 @@
-/*
- * Copyright (C) Procsys. All rights reserved.
- * Author: Mushtaq Khan <mushtaq_k@procsys.com>
- *                     <mushtaqk_921@yahoo.co.in>
- *
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
- * MA 02111-1307 USA
- *
- * with the reference to libata in kernel 2.4.32
- *
- */
-
-/*
- * File contains SATA read-write and other utility functions.
- */
-#include <common.h>
-#include <asm/io.h>
-#include <pci.h>
-#include <command.h>
-#include <config.h>
-#include <ide.h>
-#include <ata.h>
-
-#ifdef CFG_SATA_SUPPORTED
-/*For debug prints set macro DEBUG_SATA to 1 */
-#define DEBUG_SATA 0
-/*Macro for SATA library specific declarations */
-#define SATA_DECL
-#include <sata.h>
-#undef SATA_DECL
-
-static u8 __inline__
-sata_inb (unsigned long ioaddr)
-{
-       return inb (ioaddr);
-}
-
-static void __inline__
-sata_outb (unsigned char val, unsigned long ioaddr)
-{
-       outb (val, ioaddr);
-}
-
-static void
-output_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
-{
-       outsw (ioaddr->data_addr, sect_buf, words << 1);
-}
-
-static int
-input_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
-{
-       insw (ioaddr->data_addr, sect_buf, words << 1);
-       return 0;
-}
-
-static void
-sata_cpy (unsigned char *dst, unsigned char *src, unsigned int len)
-{
-       unsigned char *end, *last;
-
-       last = dst;
-       end = src + len - 1;
-
-       /* reserve space for '\0' */
-       if (len < 2)
-               goto OUT;
-
-       /* skip leading white space */
-       while ((*src) && (src < end) && (*src == ' '))
-               ++src;
-
-       /* copy string, omitting trailing white space */
-       while ((*src) && (src < end)) {
-               *dst++ = *src;
-               if (*src++ != ' ')
-                       last = dst;
-       }
-      OUT:
-       *last = '\0';
-}
-
-int
-sata_bus_softreset (int num)
-{
-       u8 dev = 0, status = 0, i;
-
-       port[num].dev_mask = 0;
-
-       for (i = 0; i < CFG_SATA_DEVS_PER_BUS; i++) {
-               if (!(sata_devchk (&port[num].ioaddr, i))) {
-                       PRINTF ("dev_chk failed for dev#%d\n", i);
-               } else {
-                       port[num].dev_mask |= (1 << i);
-                       PRINTF ("dev_chk passed for dev#%d\n", i);
-               }
-       }
-
-       if (!(port[num].dev_mask)) {
-               printf ("no devices on port%d\n", num);
-               return 1;
-       }
-
-       dev_select (&port[num].ioaddr, dev);
-
-       port[num].ctl_reg = 0x08;       /*Default value of control reg */
-       sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
-       udelay (10);
-       sata_outb (port[num].ctl_reg | ATA_SRST, port[num].ioaddr.ctl_addr);
-       udelay (10);
-       sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
-
-       /* spec mandates ">= 2ms" before checking status.
-        * We wait 150ms, because that was the magic delay used for
-        * ATAPI devices in Hale Landis's ATADRVR, for the period of time
-        * between when the ATA command register is written, and then
-        * status is checked.  Because waiting for "a while" before
-        * checking status is fine, post SRST, we perform this magic
-        * delay here as well.
-        */
-       msleep (150);
-       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 300);
-       while ((status & ATA_BUSY)) {
-               msleep (100);
-               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 3);
-       }
-
-       if (status & ATA_BUSY)
-               printf ("ata%u is slow to respond,plz be patient\n", port);
-
-       while ((status & ATA_BUSY)) {
-               msleep (100);
-               status = sata_chk_status (&port[num].ioaddr);
-       }
-
-       if (status & ATA_BUSY) {
-               printf ("ata%u failed to respond : ", port);
-               printf ("bus reset failed\n");
-               return 1;
-       }
-       return 0;
-}
-
-void
-sata_identify (int num, int dev)
-{
-       u8 cmd = 0, status = 0, devno = num * CFG_SATA_DEVS_PER_BUS + dev;
-       u16 iobuf[ATA_SECT_SIZE];
-       u64 n_sectors = 0;
-       u8 mask = 0;
-
-       memset (iobuf, 0, sizeof (iobuf));
-       hd_driveid_t *iop = (hd_driveid_t *) iobuf;
-
-       if (dev == 0)
-               mask = 0x01;
-       else
-               mask = 0x02;
-
-       if (!(port[num].dev_mask & mask)) {
-               printf ("dev%d is not present on port#%d\n", dev, num);
-               return;
-       }
-
-       printf ("port=%d dev=%d\n", num, dev);
-
-       dev_select (&port[num].ioaddr, dev);
-
-       status = 0;
-       cmd = ATA_CMD_IDENT;    /*Device Identify Command */
-       sata_outb (cmd, port[num].ioaddr.command_addr);
-       sata_inb (port[num].ioaddr.altstatus_addr);
-       udelay (10);
-
-       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 1000);
-       if (status & ATA_ERR) {
-               printf ("\ndevice not responding\n");
-               port[num].dev_mask &= ~mask;
-               return;
-       }
-
-       input_data (&port[num].ioaddr, (ulong *) iobuf, ATA_SECTORWORDS);
-
-       PRINTF ("\nata%u: dev %u cfg 49:%04x 82:%04x 83:%04x 84:%04x85:%04x"
-               "86:%04x" "87:%04x 88:%04x\n", num, dev, iobuf[49],
-               iobuf[82], iobuf[83], iobuf[84], iobuf[85], iobuf[86],
-               iobuf[87], iobuf[88]);
-
-       /* we require LBA and DMA support (bits 8 & 9 of word 49) */
-       if (!ata_id_has_dma (iobuf) || !ata_id_has_lba (iobuf)) {
-               PRINTF ("ata%u: no dma/lba\n", num);
-       }
-       ata_dump_id (iobuf);
-
-       if (ata_id_has_lba48 (iobuf)) {
-               n_sectors = ata_id_u64 (iobuf, 100);
-       } else {
-               n_sectors = ata_id_u32 (iobuf, 60);
-       }
-       PRINTF ("no. of sectors %u\n", ata_id_u64 (iobuf, 100));
-       PRINTF ("no. of sectors %u\n", ata_id_u32 (iobuf, 60));
-
-       if (n_sectors == 0) {
-               port[num].dev_mask &= ~mask;
-               return;
-       }
-
-       sata_cpy (sata_dev_desc[devno].revision, iop->fw_rev,
-                 sizeof (sata_dev_desc[devno].revision));
-       sata_cpy (sata_dev_desc[devno].vendor, iop->model,
-                 sizeof (sata_dev_desc[devno].vendor));
-       sata_cpy (sata_dev_desc[devno].product, iop->serial_no,
-                 sizeof (sata_dev_desc[devno].product));
-       strswab (sata_dev_desc[devno].revision);
-       strswab (sata_dev_desc[devno].vendor);
-
-       if ((iop->config & 0x0080) == 0x0080) {
-               sata_dev_desc[devno].removable = 1;
-       } else {
-               sata_dev_desc[devno].removable = 0;
-       }
-
-       sata_dev_desc[devno].lba = iop->lba_capacity;
-       PRINTF ("lba=0x%x", sata_dev_desc[devno].lba);
-
-#ifdef CONFIG_LBA48
-       if (iop->command_set_2 & 0x0400) {
-               sata_dev_desc[devno].lba48 = 1;
-               lba = (unsigned long long) iop->lba48_capacity[0] |
-                   ((unsigned long long) iop->lba48_capacity[1] << 16) |
-                   ((unsigned long long) iop->lba48_capacity[2] << 32) |
-                   ((unsigned long long) iop->lba48_capacity[3] << 48);
-       } else {
-               sata_dev_desc[devno].lba48 = 0;
-       }
-#endif
-
-       /* assuming HD */
-       sata_dev_desc[devno].type = DEV_TYPE_HARDDISK;
-       sata_dev_desc[devno].blksz = ATA_BLOCKSIZE;
-       sata_dev_desc[devno].lun = 0;   /* just to fill something in... */
-}
-
-void
-set_Feature_cmd (int num, int dev)
-{
-       u8 mask = 0x00, status = 0;
-
-       if (dev == 0)
-               mask = 0x01;
-       else
-               mask = 0x02;
-
-       if (!(port[num].dev_mask & mask)) {
-               PRINTF ("dev%d is not present on port#%d\n", dev, num);
-               return;
-       }
-
-       dev_select (&port[num].ioaddr, dev);
-
-       sata_outb (SETFEATURES_XFER, port[num].ioaddr.feature_addr);
-       sata_outb (XFER_PIO_4, port[num].ioaddr.nsect_addr);
-       sata_outb (0, port[num].ioaddr.lbal_addr);
-       sata_outb (0, port[num].ioaddr.lbam_addr);
-       sata_outb (0, port[num].ioaddr.lbah_addr);
-
-       sata_outb (ATA_DEVICE_OBS, port[num].ioaddr.device_addr);
-       sata_outb (ATA_CMD_SETF, port[num].ioaddr.command_addr);
-
-       udelay (50);
-       msleep (150);
-
-       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 5000);
-       if ((status & (ATA_STAT_BUSY | ATA_STAT_ERR))) {
-               printf ("Error  : status 0x%02x\n", status);
-               port[num].dev_mask &= ~mask;
-       }
-}
-
-void
-sata_port (struct sata_ioports *ioport)
-{
-       ioport->data_addr = ioport->cmd_addr + ATA_REG_DATA;
-       ioport->error_addr = ioport->cmd_addr + ATA_REG_ERR;
-       ioport->feature_addr = ioport->cmd_addr + ATA_REG_FEATURE;
-       ioport->nsect_addr = ioport->cmd_addr + ATA_REG_NSECT;
-       ioport->lbal_addr = ioport->cmd_addr + ATA_REG_LBAL;
-       ioport->lbam_addr = ioport->cmd_addr + ATA_REG_LBAM;
-       ioport->lbah_addr = ioport->cmd_addr + ATA_REG_LBAH;
-       ioport->device_addr = ioport->cmd_addr + ATA_REG_DEVICE;
-       ioport->status_addr = ioport->cmd_addr + ATA_REG_STATUS;
-       ioport->command_addr = ioport->cmd_addr + ATA_REG_CMD;
-}
-
-int
-sata_devchk (struct sata_ioports *ioaddr, int dev)
-{
-       u8 nsect, lbal;
-
-       dev_select (ioaddr, dev);
-
-       sata_outb (0x55, ioaddr->nsect_addr);
-       sata_outb (0xaa, ioaddr->lbal_addr);
-
-       sata_outb (0xaa, ioaddr->nsect_addr);
-       sata_outb (0x55, ioaddr->lbal_addr);
-
-       sata_outb (0x55, ioaddr->nsect_addr);
-       sata_outb (0xaa, ioaddr->lbal_addr);
-
-       nsect = sata_inb (ioaddr->nsect_addr);
-       lbal = sata_inb (ioaddr->lbal_addr);
-
-       if ((nsect == 0x55) && (lbal == 0xaa))
-               return 1;       /* we found a device */
-       else
-               return 0;       /* nothing found */
-}
-
-void
-dev_select (struct sata_ioports *ioaddr, int dev)
-{
-       u8 tmp = 0;
-
-       if (dev == 0)
-               tmp = ATA_DEVICE_OBS;
-       else
-               tmp = ATA_DEVICE_OBS | ATA_DEV1;
-
-       sata_outb (tmp, ioaddr->device_addr);
-       sata_inb (ioaddr->altstatus_addr);
-       udelay (5);
-}
-
-u8
-sata_busy_wait (struct sata_ioports *ioaddr, int bits, unsigned int max)
-{
-       u8 status;
-
-       do {
-               udelay (1000);
-               status = sata_chk_status (ioaddr);
-               max--;
-       } while ((status & bits) && (max > 0));
-
-       return status;
-}
-
-u8
-sata_chk_status (struct sata_ioports * ioaddr)
-{
-       return sata_inb (ioaddr->status_addr);
-}
-
-void
-msleep (int count)
-{
-       int i;
-
-       for (i = 0; i < count; i++)
-               udelay (1000);
-}
-
-ulong
-sata_read (int device, ulong blknr,lbaint_t blkcnt, void * buff)
-{
-       ulong n = 0, *buffer = (ulong *)buff;
-       u8 dev = 0, num = 0, mask = 0, status = 0;
-
-#ifdef CONFIG_LBA48
-       unsigned char lba48 = 0;
-
-       if (blknr & 0x0000fffff0000000) {
-               if (!sata_dev_desc[devno].lba48) {
-                       printf ("Drive doesn't support 48-bit addressing\n");
-                       return 0;
-               }
-               /* more than 28 bits used, use 48bit mode */
-               lba48 = 1;
-       }
-#endif
-       /*Port Number */
-       num = device / CFG_SATA_DEVS_PER_BUS;
-       /*dev on the port */
-       if (device >= CFG_SATA_DEVS_PER_BUS)
-               dev = device - CFG_SATA_DEVS_PER_BUS;
-       else
-               dev = device;
-
-       if (dev == 0)
-               mask = 0x01;
-       else
-               mask = 0x02;
-
-       if (!(port[num].dev_mask & mask)) {
-               printf ("dev%d is not present on port#%d\n", dev, num);
-               return 0;
-       }
-
-       /* Select device */
-       dev_select (&port[num].ioaddr, dev);
-
-       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
-       if (status & ATA_BUSY) {
-               printf ("ata%u failed to respond\n", port[num].port_no);
-               return n;
-       }
-       while (blkcnt-- > 0) {
-               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
-               if (status & ATA_BUSY) {
-                       printf ("ata%u failed to respond\n", 0);
-                       return n;
-               }
-#ifdef CONFIG_LBA48
-               if (lba48) {
-                       /* write high bits */
-                       sata_outb (0, port[num].ioaddr.nsect_addr);
-                       sata_outb ((blknr >> 24) & 0xFF,
-                                  port[num].ioaddr.lbal_addr);
-                       sata_outb ((blknr >> 32) & 0xFF,
-                                  port[num].ioaddr.lbam_addr);
-                       sata_outb ((blknr >> 40) & 0xFF,
-                                  port[num].ioaddr.lbah_addr);
-               }
-#endif
-               sata_outb (1, port[num].ioaddr.nsect_addr);
-               sata_outb (((blknr) >> 0) & 0xFF,
-                          port[num].ioaddr.lbal_addr);
-               sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
-               sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
-
-#ifdef CONFIG_LBA48
-               if (lba48) {
-                       sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
-                       sata_outb (ATA_CMD_READ_EXT,
-                                  port[num].ioaddr.command_addr);
-               } else
-#endif
-               {
-                       sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
-                                  port[num].ioaddr.device_addr);
-                       sata_outb (ATA_CMD_READ,
-                                  port[num].ioaddr.command_addr);
-               }
-
-               msleep (50);
-               /*may take up to 4 sec */
-               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
-
-               if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
-                   != ATA_STAT_DRQ) {
-                       u8 err = 0;
-
-                       printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
-                               device, (ulong) blknr, status);
-                       err = sata_inb (port[num].ioaddr.error_addr);
-                       printf ("Error reg = 0x%x\n", err);
-                       return (n);
-               }
-               input_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
-               sata_inb (port[num].ioaddr.altstatus_addr);
-               udelay (50);
-
-               ++n;
-               ++blknr;
-               buffer += ATA_SECTORWORDS;
-       }
-       return n;
-}
-
-ulong
-sata_write (int device, ulong blknr,lbaint_t blkcnt, void * buff)
-{
-       ulong n = 0, *buffer = (ulong *)buff;
-       unsigned char status = 0, num = 0, dev = 0, mask = 0;
-
-#ifdef CONFIG_LBA48
-       unsigned char lba48 = 0;
-
-       if (blknr & 0x0000fffff0000000) {
-               if (!sata_dev_desc[devno].lba48) {
-                       printf ("Drive doesn't support 48-bit addressing\n");
-                       return 0;
-               }
-               /* more than 28 bits used, use 48bit mode */
-               lba48 = 1;
-       }
-#endif
-       /*Port Number */
-       num = device / CFG_SATA_DEVS_PER_BUS;
-       /*dev on the Port */
-       if (device >= CFG_SATA_DEVS_PER_BUS)
-               dev = device - CFG_SATA_DEVS_PER_BUS;
-       else
-               dev = device;
-
-       if (dev == 0)
-               mask = 0x01;
-       else
-               mask = 0x02;
-
-       /* Select device */
-       dev_select (&port[num].ioaddr, dev);
-
-       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
-       if (status & ATA_BUSY) {
-               printf ("ata%u failed to respond\n", port[num].port_no);
-               return n;
-       }
-
-       while (blkcnt-- > 0) {
-               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
-               if (status & ATA_BUSY) {
-                       printf ("ata%u failed to respond\n",
-                               port[num].port_no);
-                       return n;
-               }
-#ifdef CONFIG_LBA48
-               if (lba48) {
-                       /* write high bits */
-                       sata_outb (0, port[num].ioaddr.nsect_addr);
-                       sata_outb ((blknr >> 24) & 0xFF,
-                                  port[num].ioaddr.lbal_addr);
-                       sata_outb ((blknr >> 32) & 0xFF,
-                                  port[num].ioaddr.lbam_addr);
-                       sata_outb ((blknr >> 40) & 0xFF,
-                                  port[num].ioaddr.lbah_addr);
-               }
-#endif
-               sata_outb (1, port[num].ioaddr.nsect_addr);
-               sata_outb ((blknr >> 0) & 0xFF, port[num].ioaddr.lbal_addr);
-               sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
-               sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
-#ifdef CONFIG_LBA48
-               if (lba48) {
-                       sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
-                       sata_outb (ATA_CMD_WRITE_EXT,
-                                  port[num].ioaddr.command_addr);
-               } else
-#endif
-               {
-                       sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
-                                  port[num].ioaddr.device_addr);
-                       sata_outb (ATA_CMD_WRITE,
-                                  port[num].ioaddr.command_addr);
-               }
-
-               msleep (50);
-               /*may take up to 4 sec */
-               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
-               if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
-                   != ATA_STAT_DRQ) {
-                       printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
-                               device, (ulong) blknr, status);
-                       return (n);
-               }
-
-               output_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
-               sata_inb (port[num].ioaddr.altstatus_addr);
-               udelay (50);
-
-               ++n;
-               ++blknr;
-               buffer += ATA_SECTORWORDS;
-       }
-       return n;
-}
-
-block_dev_desc_t *sata_get_dev (int dev);
-
-block_dev_desc_t *
-sata_get_dev (int dev)
-{
-       return ((block_dev_desc_t *) & sata_dev_desc[dev]);
-}
-
-int
-do_sata (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
-{
-
-       switch (argc) {
-       case 0:
-       case 1:
-               printf ("Usage:\n%s\n", cmdtp->usage);
-               return 1;
-       case 2:
-               if (strncmp (argv[1], "init", 4) == 0) {
-                       int rcode = 0;
-
-                       rcode = init_sata ();
-                       if (rcode)
-                               printf ("Sata initialization Failed\n");
-                       return rcode;
-               } else if (strncmp (argv[1], "inf", 3) == 0) {
-                       int i;
-
-                       putc ('\n');
-                       for (i = 0; i < CFG_SATA_MAXDEVICES; ++i) {
-                               /*List only known devices */
-                               if (sata_dev_desc[i].type ==
-                                   DEV_TYPE_UNKNOWN)
-                                       continue;
-                               printf ("sata dev %d: ", i);
-                               dev_print (&sata_dev_desc[i]);
-                       }
-                       return 0;
-               }
-               printf ("Usage:\n%s\n", cmdtp->usage);
-               return 1;
-       case 3:
-               if (strcmp (argv[1], "dev") == 0) {
-                       int dev = (int) simple_strtoul (argv[2], NULL, 10);
-
-                       if (dev >= CFG_SATA_MAXDEVICES) {
-                               printf ("\nSata dev %d not available\n",
-                                       dev);
-                               return 1;
-                       }
-                       printf ("\nSATA dev %d: ", dev);
-                       dev_print (&sata_dev_desc[dev]);
-                       if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN)
-                               return 1;
-                       curr_dev = dev;
-                       return 0;
-               } else if (strcmp (argv[1], "part") == 0) {
-                       int dev = (int) simple_strtoul (argv[2], NULL, 10);
-
-                       if (dev >= CFG_SATA_MAXDEVICES) {
-                               printf ("\nSata dev %d not available\n",
-                                       dev);
-                               return 1;
-                       }
-                       PRINTF ("\nSATA dev %d: ", dev);
-                       if (sata_dev_desc[dev].part_type !=
-                           PART_TYPE_UNKNOWN) {
-                               print_part (&sata_dev_desc[dev]);
-                       } else {
-                               printf ("\nSata dev %d partition type "
-                                       "unknown\n", dev);
-                               return 1;
-                       }
-                       return 0;
-               }
-               printf ("Usage:\n%s\n", cmdtp->usage);
-               return 1;
-       default:
-               if (argc < 5) {
-                       printf ("Usage:\n%s\n", cmdtp->usage);
-                       return 1;
-               }
-               if (strcmp (argv[1], "read") == 0) {
-                       ulong addr = simple_strtoul (argv[2], NULL, 16);
-                       ulong cnt = simple_strtoul (argv[4], NULL, 16);
-                       ulong n;
-                       lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
-
-                       memset ((int *) addr, 0, cnt * 512);
-                       printf ("\nSATA read: dev %d blk # %ld,"
-                               "count %ld ... ", curr_dev, blk, cnt);
-                       n = sata_read (curr_dev, blk, cnt, (ulong *) addr);
-                       /* flush cache after read */
-                       flush_cache (addr, cnt * 512);
-                       printf ("%ld blocks read: %s\n", n,
-                               (n == cnt) ? "OK" : "ERR");
-                       if (n == cnt)
-                               return 1;
-                       else
-                               return 0;
-               } else if (strcmp (argv[1], "write") == 0) {
-                       ulong addr = simple_strtoul (argv[2], NULL, 16);
-                       ulong cnt = simple_strtoul (argv[4], NULL, 16);
-                       ulong n;
-                       lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
-
-                       printf ("\nSata write: dev %d blk # %ld,"
-                               "count %ld ... ", curr_dev, blk, cnt);
-                       n = sata_write (curr_dev, blk, cnt, (ulong *) addr);
-                       printf ("%ld blocks written: %s\n", n,
-                               (n == cnt) ? "OK" : "ERR");
-                       if (n == cnt)
-                               return 1;
-                       else
-                               return 0;
-               } else {
-                       printf ("Usage:\n%s\n", cmdtp->usage);
-                       return 1;
-               }
-       }                       /*End OF SWITCH */
-}
-
-U_BOOT_CMD (sata, 5, 1, do_sata,
-           "sata init\n"
-           "sata info\n"
-           "sata part device\n"
-           "sata dev device\n"
-           "sata read  addr blk# cnt\n"
-           "sata write  addr blk# cnt\n", "cmd for init,rw and dev-info\n");
-
-#endif
index 42456d7be334dab74d67df839d3c1c040cc1cee2..806ec1a3fcbbc0a050292965e9828dcf5ab8db47 100644 (file)
  */
 
 #include <common.h>
+#include <asm/io.h>
 #include <pci.h>
 #include <command.h>
 #include <config.h>
 #include <asm/byteorder.h>
+#include <part.h>
 #include <ide.h>
 #include <ata.h>
 
@@ -37,9 +39,9 @@
 
 #define DEBUG_SATA 0           /*For debug prints set DEBUG_SATA to 1 */
 
+#define SATA_DECL
 #define DRV_DECL               /*For file specific declarations */
 #include <sata.h>
-#undef DRV_DECL
 
 /*Macros realted to PCI*/
 #define PCI_SATA_BUS   0x00
@@ -213,4 +215,672 @@ init_sata (void)
        }
        return 0;
 }
+
+static u8 __inline__
+sata_inb (unsigned long ioaddr)
+{
+       return inb (ioaddr);
+}
+
+static void __inline__
+sata_outb (unsigned char val, unsigned long ioaddr)
+{
+       outb (val, ioaddr);
+}
+
+static void
+output_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
+{
+       outsw (ioaddr->data_addr, sect_buf, words << 1);
+}
+
+static int
+input_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
+{
+       insw (ioaddr->data_addr, sect_buf, words << 1);
+       return 0;
+}
+
+static void
+sata_cpy (unsigned char *dst, unsigned char *src, unsigned int len)
+{
+       unsigned char *end, *last;
+
+       last = dst;
+       end = src + len - 1;
+
+       /* reserve space for '\0' */
+       if (len < 2)
+               goto OUT;
+
+       /* skip leading white space */
+       while ((*src) && (src < end) && (*src == ' '))
+               ++src;
+
+       /* copy string, omitting trailing white space */
+       while ((*src) && (src < end)) {
+               *dst++ = *src;
+               if (*src++ != ' ')
+                       last = dst;
+       }
+      OUT:
+       *last = '\0';
+}
+
+int
+sata_bus_softreset (int num)
+{
+       u8 dev = 0, status = 0, i;
+
+       port[num].dev_mask = 0;
+
+       for (i = 0; i < CFG_SATA_DEVS_PER_BUS; i++) {
+               if (!(sata_devchk (&port[num].ioaddr, i))) {
+                       PRINTF ("dev_chk failed for dev#%d\n", i);
+               } else {
+                       port[num].dev_mask |= (1 << i);
+                       PRINTF ("dev_chk passed for dev#%d\n", i);
+               }
+       }
+
+       if (!(port[num].dev_mask)) {
+               printf ("no devices on port%d\n", num);
+               return 1;
+       }
+
+       dev_select (&port[num].ioaddr, dev);
+
+       port[num].ctl_reg = 0x08;       /*Default value of control reg */
+       sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
+       udelay (10);
+       sata_outb (port[num].ctl_reg | ATA_SRST, port[num].ioaddr.ctl_addr);
+       udelay (10);
+       sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
+
+       /* spec mandates ">= 2ms" before checking status.
+        * We wait 150ms, because that was the magic delay used for
+        * ATAPI devices in Hale Landis's ATADRVR, for the period of time
+        * between when the ATA command register is written, and then
+        * status is checked.  Because waiting for "a while" before
+        * checking status is fine, post SRST, we perform this magic
+        * delay here as well.
+        */
+       msleep (150);
+       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 300);
+       while ((status & ATA_BUSY)) {
+               msleep (100);
+               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 3);
+       }
+
+       if (status & ATA_BUSY)
+               printf ("ata%u is slow to respond,plz be patient\n", port);
+
+       while ((status & ATA_BUSY)) {
+               msleep (100);
+               status = sata_chk_status (&port[num].ioaddr);
+       }
+
+       if (status & ATA_BUSY) {
+               printf ("ata%u failed to respond : ", port);
+               printf ("bus reset failed\n");
+               return 1;
+       }
+       return 0;
+}
+
+void
+sata_identify (int num, int dev)
+{
+       u8 cmd = 0, status = 0, devno = num * CFG_SATA_DEVS_PER_BUS + dev;
+       u16 iobuf[ATA_SECT_SIZE];
+       u64 n_sectors = 0;
+       u8 mask = 0;
+
+       memset (iobuf, 0, sizeof (iobuf));
+       hd_driveid_t *iop = (hd_driveid_t *) iobuf;
+
+       if (dev == 0)
+               mask = 0x01;
+       else
+               mask = 0x02;
+
+       if (!(port[num].dev_mask & mask)) {
+               printf ("dev%d is not present on port#%d\n", dev, num);
+               return;
+       }
+
+       printf ("port=%d dev=%d\n", num, dev);
+
+       dev_select (&port[num].ioaddr, dev);
+
+       status = 0;
+       cmd = ATA_CMD_IDENT;    /*Device Identify Command */
+       sata_outb (cmd, port[num].ioaddr.command_addr);
+       sata_inb (port[num].ioaddr.altstatus_addr);
+       udelay (10);
+
+       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 1000);
+       if (status & ATA_ERR) {
+               printf ("\ndevice not responding\n");
+               port[num].dev_mask &= ~mask;
+               return;
+       }
+
+       input_data (&port[num].ioaddr, (ulong *) iobuf, ATA_SECTORWORDS);
+
+       PRINTF ("\nata%u: dev %u cfg 49:%04x 82:%04x 83:%04x 84:%04x85:%04x"
+               "86:%04x" "87:%04x 88:%04x\n", num, dev, iobuf[49],
+               iobuf[82], iobuf[83], iobuf[84], iobuf[85], iobuf[86],
+               iobuf[87], iobuf[88]);
+
+       /* we require LBA and DMA support (bits 8 & 9 of word 49) */
+       if (!ata_id_has_dma (iobuf) || !ata_id_has_lba (iobuf)) {
+               PRINTF ("ata%u: no dma/lba\n", num);
+       }
+       ata_dump_id (iobuf);
+
+       if (ata_id_has_lba48 (iobuf)) {
+               n_sectors = ata_id_u64 (iobuf, 100);
+       } else {
+               n_sectors = ata_id_u32 (iobuf, 60);
+       }
+       PRINTF ("no. of sectors %u\n", ata_id_u64 (iobuf, 100));
+       PRINTF ("no. of sectors %u\n", ata_id_u32 (iobuf, 60));
+
+       if (n_sectors == 0) {
+               port[num].dev_mask &= ~mask;
+               return;
+       }
+
+       sata_cpy (sata_dev_desc[devno].revision, iop->fw_rev,
+                 sizeof (sata_dev_desc[devno].revision));
+       sata_cpy (sata_dev_desc[devno].vendor, iop->model,
+                 sizeof (sata_dev_desc[devno].vendor));
+       sata_cpy (sata_dev_desc[devno].product, iop->serial_no,
+                 sizeof (sata_dev_desc[devno].product));
+       strswab (sata_dev_desc[devno].revision);
+       strswab (sata_dev_desc[devno].vendor);
+
+       if ((iop->config & 0x0080) == 0x0080) {
+               sata_dev_desc[devno].removable = 1;
+       } else {
+               sata_dev_desc[devno].removable = 0;
+       }
+
+       sata_dev_desc[devno].lba = iop->lba_capacity;
+       PRINTF ("lba=0x%x", sata_dev_desc[devno].lba);
+
+#ifdef CONFIG_LBA48
+       if (iop->command_set_2 & 0x0400) {
+               sata_dev_desc[devno].lba48 = 1;
+               lba = (unsigned long long) iop->lba48_capacity[0] |
+                   ((unsigned long long) iop->lba48_capacity[1] << 16) |
+                   ((unsigned long long) iop->lba48_capacity[2] << 32) |
+                   ((unsigned long long) iop->lba48_capacity[3] << 48);
+       } else {
+               sata_dev_desc[devno].lba48 = 0;
+       }
+#endif
+
+       /* assuming HD */
+       sata_dev_desc[devno].type = DEV_TYPE_HARDDISK;
+       sata_dev_desc[devno].blksz = ATA_BLOCKSIZE;
+       sata_dev_desc[devno].lun = 0;   /* just to fill something in... */
+}
+
+void
+set_Feature_cmd (int num, int dev)
+{
+       u8 mask = 0x00, status = 0;
+
+       if (dev == 0)
+               mask = 0x01;
+       else
+               mask = 0x02;
+
+       if (!(port[num].dev_mask & mask)) {
+               PRINTF ("dev%d is not present on port#%d\n", dev, num);
+               return;
+       }
+
+       dev_select (&port[num].ioaddr, dev);
+
+       sata_outb (SETFEATURES_XFER, port[num].ioaddr.feature_addr);
+       sata_outb (XFER_PIO_4, port[num].ioaddr.nsect_addr);
+       sata_outb (0, port[num].ioaddr.lbal_addr);
+       sata_outb (0, port[num].ioaddr.lbam_addr);
+       sata_outb (0, port[num].ioaddr.lbah_addr);
+
+       sata_outb (ATA_DEVICE_OBS, port[num].ioaddr.device_addr);
+       sata_outb (ATA_CMD_SETF, port[num].ioaddr.command_addr);
+
+       udelay (50);
+       msleep (150);
+
+       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 5000);
+       if ((status & (ATA_STAT_BUSY | ATA_STAT_ERR))) {
+               printf ("Error  : status 0x%02x\n", status);
+               port[num].dev_mask &= ~mask;
+       }
+}
+
+void
+sata_port (struct sata_ioports *ioport)
+{
+       ioport->data_addr = ioport->cmd_addr + ATA_REG_DATA;
+       ioport->error_addr = ioport->cmd_addr + ATA_REG_ERR;
+       ioport->feature_addr = ioport->cmd_addr + ATA_REG_FEATURE;
+       ioport->nsect_addr = ioport->cmd_addr + ATA_REG_NSECT;
+       ioport->lbal_addr = ioport->cmd_addr + ATA_REG_LBAL;
+       ioport->lbam_addr = ioport->cmd_addr + ATA_REG_LBAM;
+       ioport->lbah_addr = ioport->cmd_addr + ATA_REG_LBAH;
+       ioport->device_addr = ioport->cmd_addr + ATA_REG_DEVICE;
+       ioport->status_addr = ioport->cmd_addr + ATA_REG_STATUS;
+       ioport->command_addr = ioport->cmd_addr + ATA_REG_CMD;
+}
+
+int
+sata_devchk (struct sata_ioports *ioaddr, int dev)
+{
+       u8 nsect, lbal;
+
+       dev_select (ioaddr, dev);
+
+       sata_outb (0x55, ioaddr->nsect_addr);
+       sata_outb (0xaa, ioaddr->lbal_addr);
+
+       sata_outb (0xaa, ioaddr->nsect_addr);
+       sata_outb (0x55, ioaddr->lbal_addr);
+
+       sata_outb (0x55, ioaddr->nsect_addr);
+       sata_outb (0xaa, ioaddr->lbal_addr);
+
+       nsect = sata_inb (ioaddr->nsect_addr);
+       lbal = sata_inb (ioaddr->lbal_addr);
+
+       if ((nsect == 0x55) && (lbal == 0xaa))
+               return 1;       /* we found a device */
+       else
+               return 0;       /* nothing found */
+}
+
+void
+dev_select (struct sata_ioports *ioaddr, int dev)
+{
+       u8 tmp = 0;
+
+       if (dev == 0)
+               tmp = ATA_DEVICE_OBS;
+       else
+               tmp = ATA_DEVICE_OBS | ATA_DEV1;
+
+       sata_outb (tmp, ioaddr->device_addr);
+       sata_inb (ioaddr->altstatus_addr);
+       udelay (5);
+}
+
+u8
+sata_busy_wait (struct sata_ioports *ioaddr, int bits, unsigned int max)
+{
+       u8 status;
+
+       do {
+               udelay (1000);
+               status = sata_chk_status (ioaddr);
+               max--;
+       } while ((status & bits) && (max > 0));
+
+       return status;
+}
+
+u8
+sata_chk_status (struct sata_ioports * ioaddr)
+{
+       return sata_inb (ioaddr->status_addr);
+}
+
+void
+msleep (int count)
+{
+       int i;
+
+       for (i = 0; i < count; i++)
+               udelay (1000);
+}
+
+ulong
+sata_read (int device, ulong blknr,lbaint_t blkcnt, void * buff)
+{
+       ulong n = 0, *buffer = (ulong *)buff;
+       u8 dev = 0, num = 0, mask = 0, status = 0;
+
+#ifdef CONFIG_LBA48
+       unsigned char lba48 = 0;
+
+       if (blknr & 0x0000fffff0000000) {
+               if (!sata_dev_desc[devno].lba48) {
+                       printf ("Drive doesn't support 48-bit addressing\n");
+                       return 0;
+               }
+               /* more than 28 bits used, use 48bit mode */
+               lba48 = 1;
+       }
+#endif
+       /*Port Number */
+       num = device / CFG_SATA_DEVS_PER_BUS;
+       /*dev on the port */
+       if (device >= CFG_SATA_DEVS_PER_BUS)
+               dev = device - CFG_SATA_DEVS_PER_BUS;
+       else
+               dev = device;
+
+       if (dev == 0)
+               mask = 0x01;
+       else
+               mask = 0x02;
+
+       if (!(port[num].dev_mask & mask)) {
+               printf ("dev%d is not present on port#%d\n", dev, num);
+               return 0;
+       }
+
+       /* Select device */
+       dev_select (&port[num].ioaddr, dev);
+
+       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
+       if (status & ATA_BUSY) {
+               printf ("ata%u failed to respond\n", port[num].port_no);
+               return n;
+       }
+       while (blkcnt-- > 0) {
+               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
+               if (status & ATA_BUSY) {
+                       printf ("ata%u failed to respond\n", 0);
+                       return n;
+               }
+#ifdef CONFIG_LBA48
+               if (lba48) {
+                       /* write high bits */
+                       sata_outb (0, port[num].ioaddr.nsect_addr);
+                       sata_outb ((blknr >> 24) & 0xFF,
+                                  port[num].ioaddr.lbal_addr);
+                       sata_outb ((blknr >> 32) & 0xFF,
+                                  port[num].ioaddr.lbam_addr);
+                       sata_outb ((blknr >> 40) & 0xFF,
+                                  port[num].ioaddr.lbah_addr);
+               }
+#endif
+               sata_outb (1, port[num].ioaddr.nsect_addr);
+               sata_outb (((blknr) >> 0) & 0xFF,
+                          port[num].ioaddr.lbal_addr);
+               sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
+               sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
+
+#ifdef CONFIG_LBA48
+               if (lba48) {
+                       sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
+                       sata_outb (ATA_CMD_READ_EXT,
+                                  port[num].ioaddr.command_addr);
+               } else
+#endif
+               {
+                       sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
+                                  port[num].ioaddr.device_addr);
+                       sata_outb (ATA_CMD_READ,
+                                  port[num].ioaddr.command_addr);
+               }
+
+               msleep (50);
+               /*may take up to 4 sec */
+               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
+
+               if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
+                   != ATA_STAT_DRQ) {
+                       u8 err = 0;
+
+                       printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
+                               device, (ulong) blknr, status);
+                       err = sata_inb (port[num].ioaddr.error_addr);
+                       printf ("Error reg = 0x%x\n", err);
+                       return (n);
+               }
+               input_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
+               sata_inb (port[num].ioaddr.altstatus_addr);
+               udelay (50);
+
+               ++n;
+               ++blknr;
+               buffer += ATA_SECTORWORDS;
+       }
+       return n;
+}
+
+ulong
+sata_write (int device, ulong blknr,lbaint_t blkcnt, void * buff)
+{
+       ulong n = 0, *buffer = (ulong *)buff;
+       unsigned char status = 0, num = 0, dev = 0, mask = 0;
+
+#ifdef CONFIG_LBA48
+       unsigned char lba48 = 0;
+
+       if (blknr & 0x0000fffff0000000) {
+               if (!sata_dev_desc[devno].lba48) {
+                       printf ("Drive doesn't support 48-bit addressing\n");
+                       return 0;
+               }
+               /* more than 28 bits used, use 48bit mode */
+               lba48 = 1;
+       }
+#endif
+       /*Port Number */
+       num = device / CFG_SATA_DEVS_PER_BUS;
+       /*dev on the Port */
+       if (device >= CFG_SATA_DEVS_PER_BUS)
+               dev = device - CFG_SATA_DEVS_PER_BUS;
+       else
+               dev = device;
+
+       if (dev == 0)
+               mask = 0x01;
+       else
+               mask = 0x02;
+
+       /* Select device */
+       dev_select (&port[num].ioaddr, dev);
+
+       status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
+       if (status & ATA_BUSY) {
+               printf ("ata%u failed to respond\n", port[num].port_no);
+               return n;
+       }
+
+       while (blkcnt-- > 0) {
+               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
+               if (status & ATA_BUSY) {
+                       printf ("ata%u failed to respond\n",
+                               port[num].port_no);
+                       return n;
+               }
+#ifdef CONFIG_LBA48
+               if (lba48) {
+                       /* write high bits */
+                       sata_outb (0, port[num].ioaddr.nsect_addr);
+                       sata_outb ((blknr >> 24) & 0xFF,
+                                  port[num].ioaddr.lbal_addr);
+                       sata_outb ((blknr >> 32) & 0xFF,
+                                  port[num].ioaddr.lbam_addr);
+                       sata_outb ((blknr >> 40) & 0xFF,
+                                  port[num].ioaddr.lbah_addr);
+               }
+#endif
+               sata_outb (1, port[num].ioaddr.nsect_addr);
+               sata_outb ((blknr >> 0) & 0xFF, port[num].ioaddr.lbal_addr);
+               sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
+               sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
+#ifdef CONFIG_LBA48
+               if (lba48) {
+                       sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
+                       sata_outb (ATA_CMD_WRITE_EXT,
+                                  port[num].ioaddr.command_addr);
+               } else
+#endif
+               {
+                       sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
+                                  port[num].ioaddr.device_addr);
+                       sata_outb (ATA_CMD_WRITE,
+                                  port[num].ioaddr.command_addr);
+               }
+
+               msleep (50);
+               /*may take up to 4 sec */
+               status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
+               if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
+                   != ATA_STAT_DRQ) {
+                       printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
+                               device, (ulong) blknr, status);
+                       return (n);
+               }
+
+               output_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
+               sata_inb (port[num].ioaddr.altstatus_addr);
+               udelay (50);
+
+               ++n;
+               ++blknr;
+               buffer += ATA_SECTORWORDS;
+       }
+       return n;
+}
+
+block_dev_desc_t *sata_get_dev (int dev);
+
+block_dev_desc_t *
+sata_get_dev (int dev)
+{
+       return ((block_dev_desc_t *) & sata_dev_desc[dev]);
+}
+
+int
+do_sata (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
+{
+
+       switch (argc) {
+       case 0:
+       case 1:
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       case 2:
+               if (strncmp (argv[1], "init", 4) == 0) {
+                       int rcode = 0;
+
+                       rcode = init_sata ();
+                       if (rcode)
+                               printf ("Sata initialization Failed\n");
+                       return rcode;
+               } else if (strncmp (argv[1], "inf", 3) == 0) {
+                       int i;
+
+                       putc ('\n');
+                       for (i = 0; i < CFG_SATA_MAXDEVICES; ++i) {
+                               /*List only known devices */
+                               if (sata_dev_desc[i].type ==
+                                   DEV_TYPE_UNKNOWN)
+                                       continue;
+                               printf ("sata dev %d: ", i);
+                               dev_print (&sata_dev_desc[i]);
+                       }
+                       return 0;
+               }
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       case 3:
+               if (strcmp (argv[1], "dev") == 0) {
+                       int dev = (int) simple_strtoul (argv[2], NULL, 10);
+
+                       if (dev >= CFG_SATA_MAXDEVICES) {
+                               printf ("\nSata dev %d not available\n",
+                                       dev);
+                               return 1;
+                       }
+                       printf ("\nSATA dev %d: ", dev);
+                       dev_print (&sata_dev_desc[dev]);
+                       if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN)
+                               return 1;
+                       curr_dev = dev;
+                       return 0;
+               } else if (strcmp (argv[1], "part") == 0) {
+                       int dev = (int) simple_strtoul (argv[2], NULL, 10);
+
+                       if (dev >= CFG_SATA_MAXDEVICES) {
+                               printf ("\nSata dev %d not available\n",
+                                       dev);
+                               return 1;
+                       }
+                       PRINTF ("\nSATA dev %d: ", dev);
+                       if (sata_dev_desc[dev].part_type !=
+                           PART_TYPE_UNKNOWN) {
+                               print_part (&sata_dev_desc[dev]);
+                       } else {
+                               printf ("\nSata dev %d partition type "
+                                       "unknown\n", dev);
+                               return 1;
+                       }
+                       return 0;
+               }
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       default:
+               if (argc < 5) {
+                       printf ("Usage:\n%s\n", cmdtp->usage);
+                       return 1;
+               }
+               if (strcmp (argv[1], "read") == 0) {
+                       ulong addr = simple_strtoul (argv[2], NULL, 16);
+                       ulong cnt = simple_strtoul (argv[4], NULL, 16);
+                       ulong n;
+                       lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
+
+                       memset ((int *) addr, 0, cnt * 512);
+                       printf ("\nSATA read: dev %d blk # %ld,"
+                               "count %ld ... ", curr_dev, blk, cnt);
+                       n = sata_read (curr_dev, blk, cnt, (ulong *) addr);
+                       /* flush cache after read */
+                       flush_cache (addr, cnt * 512);
+                       printf ("%ld blocks read: %s\n", n,
+                               (n == cnt) ? "OK" : "ERR");
+                       if (n == cnt)
+                               return 1;
+                       else
+                               return 0;
+               } else if (strcmp (argv[1], "write") == 0) {
+                       ulong addr = simple_strtoul (argv[2], NULL, 16);
+                       ulong cnt = simple_strtoul (argv[4], NULL, 16);
+                       ulong n;
+                       lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
+
+                       printf ("\nSata write: dev %d blk # %ld,"
+                               "count %ld ... ", curr_dev, blk, cnt);
+                       n = sata_write (curr_dev, blk, cnt, (ulong *) addr);
+                       printf ("%ld blocks written: %s\n", n,
+                               (n == cnt) ? "OK" : "ERR");
+                       if (n == cnt)
+                               return 1;
+                       else
+                               return 0;
+               } else {
+                       printf ("Usage:\n%s\n", cmdtp->usage);
+                       return 1;
+               }
+       }                       /*End OF SWITCH */
+}
+
+U_BOOT_CMD (sata, 5, 1, do_sata,
+           "sata init\n"
+           "sata info\n"
+           "sata part device\n"
+           "sata dev device\n"
+           "sata read  addr blk# cnt\n"
+           "sata write  addr blk# cnt\n", "cmd for init,rw and dev-info\n");
+
 #endif
index 8491d97ae421607a70736e694d5f7ff876be6f44..58d656cbf081930ee6526b3d61448a7726cae107 100644 (file)
 /************************************************************
 *SATA/Native Stuff
 ************************************************************/
-#define CFG_SATA_SUPPORTED      1
 #define CFG_SATA_MAXBUS         2       /*Max Sata buses supported */
 #define CFG_SATA_DEVS_PER_BUS   2      /*Max no. of devices per bus/port */
 #define CFG_SATA_MAXDEVICES     (CFG_SATA_MAXBUS* CFG_SATA_DEVS_PER_BUS)
index 165b471b289ab011ac162d16f65ba3d7737d3278..bb1acb3878e16a5eb098c907dbc3bf8cca37776a 100644 (file)
@@ -77,32 +77,16 @@ u8 sata_chk_status (struct sata_ioports *ioaddr);
 ulong sata_read (int device, ulong blknr,lbaint_t blkcnt, void * buffer);
 ulong sata_write (int device,ulong blknr, lbaint_t blkcnt, void * buffer);
 void msleep (int count);
-#else
-extern int sata_bus_softreset (int num);
-extern void sata_identify (int num, int dev);
-extern void sata_port (struct sata_ioports *ioport);
-extern void set_Feature_cmd (int num, int dev);
-extern ulong sata_read (int device, ulong blknr,
-                       lbaint_t blkcnt, void * buffer);
-extern ulong sata_write (int device, ulong blknr,
-                       lbaint_t blkcnt, void * buffer);
-extern void msleep (int count);
 #endif
 
 /************DRIVER SPECIFIC DEFINITIONS AND DECLARATIONS**************/
 
 #ifdef DRV_DECL                        /*Driver specific declaration */
 int init_sata (void);
-#else
-extern int init_sata (void);
 #endif
 
 #ifdef DRV_DECL                        /*Defines Driver Specific variables */
 struct sata_port port[CFG_SATA_MAXBUS];
 block_dev_desc_t sata_dev_desc[CFG_SATA_MAXDEVICES];
 int curr_dev = -1;
-#else
-extern struct sata_port port[CFG_SATA_MAXBUS];
-extern block_dev_desc_t sata_dev_desc[CFG_SATA_MAXDEVICES];
-extern int curr_dev;
 #endif