WebSVN – freemyipod – Diff – /embios/trunk/target/ipodclassic/storage_ata.c

 #ifdef ATA_HAVE_BBT
 #include "panic.h"
 uint16_t ata_bbt[ATA_BBT_PAGES][0x20];
 uint32_t ata_virtual_sectors;
+uint32_t ata_last_offset;
+uint64_t ata_last_phys;
 int ata_rw_sectors_internal(uint64_t sector, uint32_t count, void* buffer, bool write);
 void ata_bbt_read_sectors(uint32_t sector, uint32_t count, void* buffer)
+{
             param |= 0x40;
+        }
+    }
     ata_dma = param ? true : false;
     PASS_RC(ata_set_feature(0xef, param), 2, 1);
-    if (ata_identify_data[82] & BIT(5)) PASS_RC(ata_set_feature(0x82, 0), 2, 2);
+    if (ata_identify_data[82] & BIT(5)) PASS_RC(ata_set_feature(0x02, 0), 2, 2);
-    if (ata_identify_data[82] & BIT(6)) PASS_RC(ata_set_feature(0xaa, 0), 2, 3);
+    if (ata_identify_data[82] & BIT(6)) PASS_RC(ata_set_feature(0x55, 0), 2, 3);
     ATA_PIO_TIME = piotime;
     ATA_MDMA_TIME = mdmatime;
     ATA_UDMA_TIME = udmatime;
     ata_powered = true;
     ata_set_active();
     while (!(ATA_CONTROL & BIT(1))) yield();
     clockgate_enable(5, false);
     i2c_sendbyte(0, 0xe6, 0x1b, 0);
+}
+int ata_rw_chunk(uint64_t sector, uint32_t cnt, void* buffer, bool write)
+{
+    PASS_RC(ata_wait_for_rdy(100000), 2, 0);
+    ata_write_cbr(&ATA_PIO_DVR, 0);
+    if (ata_lba48)
+    {
+        ata_write_cbr(&ATA_PIO_SCR, cnt >> 5);
+        ata_write_cbr(&ATA_PIO_SCR, (cnt << 3) & 0xff);
+        ata_write_cbr(&ATA_PIO_LHR, (sector >> 37) & 0xff);
+        ata_write_cbr(&ATA_PIO_LMR, (sector >> 29) & 0xff);
+        ata_write_cbr(&ATA_PIO_LLR, (sector >> 21) & 0xff);
+        ata_write_cbr(&ATA_PIO_LHR, (sector >> 13) & 0xff);
+        ata_write_cbr(&ATA_PIO_LMR, (sector >> 5) & 0xff);
+        ata_write_cbr(&ATA_PIO_LLR, (sector << 3) & 0xff);
+        ata_write_cbr(&ATA_PIO_DVR, BIT(6));
+        if (write) ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0x35 : 0x39);
+        else ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0x25 : 0x29);
+    }
+    else
+    {
+        ata_write_cbr(&ATA_PIO_SCR, (cnt << 3) & 0xff);
+        ata_write_cbr(&ATA_PIO_LHR, (sector >> 13) & 0xff);
+        ata_write_cbr(&ATA_PIO_LMR, (sector >> 5) & 0xff);
+        ata_write_cbr(&ATA_PIO_LLR, (sector << 3) & 0xff);
+        ata_write_cbr(&ATA_PIO_DVR, BIT(6) | ((sector >> 21) & 0xf));
+        if (write) ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0xca : 0x30);
+        else ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0xc8 : 0xc4);
+    }
+    if (ata_dma)
+    {
+        PASS_RC(ata_wait_for_start_of_transfer(500000), 2, 1);
+        if (write)
+        {
+            ATA_SBUF_START = buffer;
+            ATA_SBUF_SIZE = SECTOR_SIZE * cnt;
+            ATA_CFG |= BIT(4);
+        }
+        else
+        {
+            ATA_TBUF_START = buffer;
+            ATA_TBUF_SIZE = SECTOR_SIZE * cnt;
+            ATA_CFG &= ~BIT(4);
+        }
+        ATA_XFR_NUM = SECTOR_SIZE * cnt - 1;
+        ATA_CFG |= ata_dma_flags;
+        ATA_CFG &= ~(BIT(7) | BIT(8));
+        wakeup_wait(&ata_wakeup, TIMEOUT_NONE);
+        ATA_IRQ = BITRANGE(0, 4);
+        ATA_IRQ_MASK = BIT(0);
+        ATA_COMMAND = BIT(0);
+        if (wakeup_wait(&ata_wakeup, 500000) == THREAD_TIMEOUT)
+        {
+            ATA_COMMAND = BIT(1);
+            ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
+            RET_ERR(2);
+        }
+        ATA_COMMAND = BIT(1);
+        ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
+    }
+    else
+    {
+        cnt *= SECTOR_SIZE / 512;
+        while (cnt--)
+        {
+            int i;
+            PASS_RC(ata_wait_for_start_of_transfer(500000), 2, 1);
+            if (write)
+                for (i = 0; i < 256; i++)
+                    ata_write_cbr(&ATA_PIO_DTR, ((uint16_t*)buffer)[i]);
+            else
+                for (i = 0; i < 256; i++)
+                    ((uint16_t*)buffer)[i] = ata_read_cbr(&ATA_PIO_DTR);
+            buffer += 512;
+        }
+    }
+    PASS_RC(ata_wait_for_end_of_transfer(100000), 2, 3);
+    return 0;
+}
 int ata_rw_sectors(uint64_t sector, uint32_t count, void* buffer, bool write)
+{
 #ifdef ATA_HAVE_BBT
     if (sector + count > ata_virtual_sectors) RET_ERR(0);
     while (count)
+    {
+        uint32_t offset;
         uint32_t l0idx = sector >> 15;
         uint32_t l0offs = sector & 0x7fff;
         uint32_t cnt = MIN(count, 0x8000 - l0offs);
         uint32_t l0data = ata_bbt[0][l0idx << 1];
         uint32_t base = ata_bbt[0][(l0idx << 1) | 1] << 12;
-        uint32_t phys;
-        if (l0data < 0x8000) phys = sector + l0data + base;
+        if (l0data < 0x8000) offset = l0data + base;
         else
+        {
             uint32_t l1idx = (sector >> 10) & 0x1f;
             uint32_t l1offs = sector & 0x3ff;
             cnt = MIN(count, 0x400 - l1offs);
             uint32_t l1data = ata_bbt[l0data & 0x7fff][l1idx];
-            if (l1data < 0x8000) phys = sector + l1data + base;
+            if (l1data < 0x8000) offset = l1data + base;
             else
+            {
                 uint32_t l2idx = (sector >> 5) & 0x1f;
                 uint32_t l2offs = sector & 0x1f;
                 cnt = MIN(count, 0x20 - l2offs);
                 uint32_t l2data = ata_bbt[l1data & 0x7fff][l2idx];
-                if (l2data < 0x8000) phys = sector + l2data + base;
+                if (l2data < 0x8000) offset = l2data + base;
                 else
+                {
                     uint32_t l3idx = sector & 0x1f;
-                    phys = ata_bbt[l2data & 0x7fff][l3idx];
+                    uint32_t l3data = ata_bbt[l2data & 0x7fff][l3idx];
                     for (cnt = 1; cnt < count && l3idx + cnt < 0x20; cnt++)
-                        if (ata_bbt[l2data & 0x7fff][l3idx + cnt] != phys)
+                        if (ata_bbt[l2data & 0x7fff][l3idx + cnt] != l3data)
                             break;
-                    phys += sector + base;
+                    offset = l3data + base;
+                }
+            }
+        }
+        uint64_t phys = sector + offset;
+        if (offset != ata_last_offset && phys - ata_last_phys < 64) ata_soft_reset();
+        ata_last_offset = offset;
+        ata_last_phys = phys + cnt;
         PASS_RC(ata_rw_sectors_internal(phys, cnt, buffer, write), 0, 0);
         buffer += cnt * SECTOR_SIZE;
         sector += cnt;
         count -= cnt;
+    }
     else if (ata_dma) invalidate_dcache();
     ATA_COMMAND = BIT(1);
     while (count)
+    {
         uint32_t cnt = MIN(ata_lba48 ? 8192 : 32, count);
-        PASS_RC(ata_wait_for_rdy(100000), 2, 1);
-        ata_write_cbr(&ATA_PIO_DVR, 0);
-        if (ata_lba48)
-        {
-            ata_write_cbr(&ATA_PIO_SCR, cnt >> 5);
-            ata_write_cbr(&ATA_PIO_SCR, (cnt << 3) & 0xff);
-            ata_write_cbr(&ATA_PIO_LHR, (sector >> 37) & 0xff);
-            ata_write_cbr(&ATA_PIO_LMR, (sector >> 29) & 0xff);
-            ata_write_cbr(&ATA_PIO_LLR, (sector >> 21) & 0xff);
-            ata_write_cbr(&ATA_PIO_LHR, (sector >> 13) & 0xff);
-            ata_write_cbr(&ATA_PIO_LMR, (sector >> 5) & 0xff);
-            ata_write_cbr(&ATA_PIO_LLR, (sector << 3) & 0xff);
-            ata_write_cbr(&ATA_PIO_DVR, BIT(6));
-            if (write) ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0x35 : 0x39);
-            else ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0x25 : 0x29);
-        }
-        else
-        {
-            ata_write_cbr(&ATA_PIO_SCR, (cnt << 3) & 0xff);
-            ata_write_cbr(&ATA_PIO_LHR, (sector >> 13) & 0xff);
-            ata_write_cbr(&ATA_PIO_LMR, (sector >> 5) & 0xff);
-            ata_write_cbr(&ATA_PIO_LLR, (sector << 3) & 0xff);
-            ata_write_cbr(&ATA_PIO_DVR, BIT(6) | ((sector >> 21) & 0xf));
-            if (write) ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0xca : 0x30);
-            else ata_write_cbr(&ATA_PIO_CSD, ata_dma ? 0xc8 : 0xc4);
-        }
-        sector += cnt;
+        int rc = -1;
-        count -= cnt;
+        int tries = 3;
-        if (ata_dma)
+        while (tries-- && rc)
+        {
-            PASS_RC(ata_wait_for_start_of_transfer(1500000), 2, 2);
-            if (write)
-            {
-                ATA_SBUF_START = buffer;
+            rc = ata_rw_chunk(sector, cnt, buffer, write);
-                ATA_SBUF_SIZE = SECTOR_SIZE * cnt;
-                ATA_CFG |= BIT(4);
+            if (rc) ata_soft_reset();
-            }
-            else
-            {
-                ATA_TBUF_START = buffer;
-                ATA_TBUF_SIZE = SECTOR_SIZE * cnt;
-                ATA_CFG &= ~BIT(4);
-            }
-            ATA_XFR_NUM = SECTOR_SIZE * cnt - 1;
-            ATA_CFG |= ata_dma_flags;
-            ATA_CFG &= ~(BIT(7) | BIT(8));
-            wakeup_wait(&ata_wakeup, TIMEOUT_NONE);
-            ATA_IRQ = BITRANGE(0, 4);
-            ATA_IRQ_MASK = BIT(0);
-            ATA_COMMAND = BIT(0);
-            if (wakeup_wait(&ata_wakeup, 1500000) == THREAD_TIMEOUT)
-            {
-                ATA_COMMAND = BIT(1);
-                ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
-                RET_ERR(3);
-            }
-            ATA_COMMAND = BIT(1);
-            ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
-            buffer += SECTOR_SIZE * cnt;
+        }
-        else
+        if (rc)
+        {
-            cnt *= SECTOR_SIZE / 512;
+            void* buf = buffer;
-            while (cnt--)
+            int sect;
+            for (sect = sector; sect < sector + cnt; sect++)
+            {
-                int i;
+                rc = -1;
+                tries = 3;
-                PASS_RC(ata_wait_for_start_of_transfer(1500000), 2, 2);
+                while (tries-- && rc)
-                if (write)
+                {
-                    for (i = 0; i < 256; i++)
+                    rc = ata_rw_chunk(sect, 1, buf, write);
-                        ata_write_cbr(&ATA_PIO_DTR, ((uint16_t*)buffer)[i]);
+                    if (rc) ata_soft_reset();
-                else
+                }
-                    for (i = 0; i < 256; i++)
+                if (rc) break;
-                        ((uint16_t*)buffer)[i] = ata_read_cbr(&ATA_PIO_DTR);
-                buffer += 512;
+                buf += SECTOR_SIZE;
+            }
+        }
-        PASS_RC(ata_wait_for_end_of_transfer(100000), 2, 3);
+        PASS_RC(rc, 1, 1);
+        buffer += SECTOR_SIZE * cnt;
+        sector += cnt;
+        count -= cnt;
+    }
     ata_set_active();
     return 0;
+}
     if (!ata_powered) ata_power_up();
     ata_set_active();
     ata_write_cbr(&ATA_PIO_DAD, BIT(1) | BIT(2));
     sleep(10);
     ata_write_cbr(&ATA_PIO_DAD, 0);
-    PASS_RC_MTX(ata_wait_for_rdy(5000000), 0, 0, &ata_mutex);
+    PASS_RC_MTX(ata_wait_for_rdy(60000000), 0, 0, &ata_mutex);
     ata_set_active();
     mutex_unlock(&ata_mutex);
+}
 int ata_read_sectors(IF_MD2(int drive,) unsigned long start, int incount,
                      void* inbuf)
+{
     mutex_lock(&ata_mutex, TIMEOUT_BLOCK);
-    int tries = 1;
-    int rc = -1;
-    while (tries-- && rc)
-    {
-        rc = ata_rw_sectors(start, incount, inbuf, false);
+    int rc = ata_rw_sectors(start, incount, inbuf, false);
-        if (rc) ata_soft_reset();
-    }
     mutex_unlock(&ata_mutex);
     return rc;
+}
 int ata_write_sectors(IF_MD2(int drive,) unsigned long start, int count,
                       const void* outbuf)
+{
     mutex_lock(&ata_mutex, TIMEOUT_BLOCK);
-    int tries = 1;
-    int rc = -1;
-    while (tries-- && rc)
-    {
-        rc = ata_rw_sectors(start, count, (void*)((uint32_t)outbuf), true);
+    int rc = ata_rw_sectors(start, count, (void*)((uint32_t)outbuf), true);
-        if (rc) ata_soft_reset();
-    }
     mutex_unlock(&ata_mutex);
     return rc;
+}
 void ata_spindown(int seconds)
 {
     ata_sleep_timeout = seconds * 1000000;
 }
 void ata_sleep(void)
+{
     mutex_lock(&ata_mutex, TIMEOUT_BLOCK);
     ata_power_down();
     if (!memcmp(buf, "emBIbbth", 8))
+    {
         ata_virtual_sectors = buf[0x1fe];
         uint32_t count = buf[0x1ff];
         if (count > (ATA_BBT_PAGES >> 6))
-            panicf(PANIC_KILLTHREAD, "ATA: BBT too big!\n");
+            panicf(PANIC_KILLTHREAD, "ATA: BBT too big! (%d pages, limit: %d)\n", count << 6, ATA_BBT_PAGES);
         uint32_t i;
         uint32_t cnt;
         for (i = 0; i < count; i += cnt)
+        {
             uint32_t phys = buf[0x200 + i];

Subversion Repositories freemyipod

(root)/embios/trunk/target/ipodclassic/storage_ata.c @ 337 – Rev 328 → 337