mirror of
https://github.com/Rockbox/rockbox.git
synced 2025-12-06 21:25:03 -05:00
44b5220f22
The goal of this was to have the ipod6g's ata driver report proper vendor/model information from storage_info() Change-Id: I64c1aee87c817cac23c90e062333a4ba3545dfaf
325 lines
8.8 KiB
C
325 lines
8.8 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
*
|
|
* Copyright (C) 2024 Solomon Peachy
|
|
*
|
|
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/* This is intended to be #included into the ATA driver */
|
|
|
|
static sector_t total_sectors;
|
|
static uint32_t log_sector_size;
|
|
static uint16_t identify_info[ATA_IDENTIFY_WORDS] STORAGE_ALIGN_ATTR;
|
|
#ifdef HAVE_LBA48
|
|
static bool ata_lba48 = false; /* set for 48 bit addressing */
|
|
#endif
|
|
static bool canflush = true;
|
|
static int spinup_time = 0;
|
|
static struct mutex ata_mutex SHAREDBSS_ATTR;
|
|
|
|
int ata_spinup_time(void)
|
|
{
|
|
return spinup_time;
|
|
}
|
|
|
|
#ifdef STORAGE_GET_INFO
|
|
void ata_get_info(IF_MD(int drive,)struct storage_info *info)
|
|
{
|
|
unsigned short *src,*dest;
|
|
static char vendor[8];
|
|
static char product[16];
|
|
static char revision[4];
|
|
#ifdef HAVE_MULTIDRIVE
|
|
(void)drive; /* unused for now */
|
|
#endif
|
|
int i;
|
|
|
|
info->sector_size = log_sector_size;
|
|
info->num_sectors = total_sectors;
|
|
|
|
src = (unsigned short*)&identify_info[27];
|
|
dest = (unsigned short*)vendor;
|
|
for (i=0;i<4;i++)
|
|
dest[i] = htobe16(src[i]);
|
|
info->vendor=vendor;
|
|
|
|
src = (unsigned short*)&identify_info[31];
|
|
dest = (unsigned short*)product;
|
|
for (i=0;i<8;i++)
|
|
dest[i] = htobe16(src[i]);
|
|
info->product=product;
|
|
|
|
src = (unsigned short*)&identify_info[23];
|
|
dest = (unsigned short*)revision;
|
|
for (i=0;i<2;i++)
|
|
dest[i] = htobe16(src[i]);
|
|
info->revision=revision;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef MAX_PHYS_SECTOR_SIZE
|
|
|
|
#ifdef MAX_VARIABLE_LOG_SECTOR
|
|
#define __MAX_VARIABLE_LOG_SECTOR MAX_VARIABLE_LOG_SECTOR
|
|
#else
|
|
#define __MAX_VARIABLE_LOG_SECTOR SECTOR_SIZE
|
|
#endif
|
|
|
|
#ifndef STORAGE_ALIGN_ATTR
|
|
#define STORAGE_ALIGN_ATTR __attribute__((aligned(sizeof(uint32_t))))
|
|
#endif
|
|
|
|
struct sector_cache_entry {
|
|
unsigned char data[MAX_PHYS_SECTOR_SIZE];
|
|
sector_t sectornum; /* logical sector */
|
|
bool inuse;
|
|
};
|
|
/* buffer for reading and writing large physical sectors */
|
|
static struct sector_cache_entry sector_cache STORAGE_ALIGN_ATTR;
|
|
static uint16_t phys_sector_mult = 1;
|
|
|
|
static int ata_transfer_sectors(uint64_t start,
|
|
int incount,
|
|
void* inbuf,
|
|
int write);
|
|
|
|
static int cache_sector(sector_t sector)
|
|
{
|
|
int rc;
|
|
|
|
/* round down to physical sector boundary */
|
|
sector &= ~(phys_sector_mult - 1);
|
|
|
|
/* check whether the sector is already cached */
|
|
if (sector_cache.inuse && (sector_cache.sectornum == sector))
|
|
return 0;
|
|
|
|
/* not found: read the sector */
|
|
sector_cache.inuse = false;
|
|
rc = ata_transfer_sectors(sector, phys_sector_mult, sector_cache.data, false);
|
|
if (!rc)
|
|
{
|
|
sector_cache.sectornum = sector;
|
|
sector_cache.inuse = true;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static inline int flush_current_sector(void)
|
|
{
|
|
return ata_transfer_sectors(sector_cache.sectornum, phys_sector_mult,
|
|
sector_cache.data, true);
|
|
}
|
|
|
|
int ata_read_sectors(IF_MD(int drive,)
|
|
sector_t start,
|
|
int incount,
|
|
void* inbuf)
|
|
{
|
|
int rc = 0;
|
|
int offset;
|
|
|
|
#ifdef HAVE_MULTIDRIVE
|
|
(void)drive; /* unused for now */
|
|
#endif
|
|
mutex_lock(&ata_mutex);
|
|
|
|
offset = start & (phys_sector_mult - 1);
|
|
|
|
if (offset) /* first partial physical sector */
|
|
{
|
|
int partcount = MIN(incount, phys_sector_mult - offset);
|
|
|
|
rc = cache_sector(start);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 1;
|
|
goto error;
|
|
}
|
|
memcpy(inbuf, sector_cache.data + offset * log_sector_size,
|
|
partcount * log_sector_size);
|
|
|
|
start += partcount;
|
|
inbuf += partcount * log_sector_size;
|
|
incount -= partcount;
|
|
}
|
|
offset = incount & (phys_sector_mult - 1);
|
|
incount -= offset;
|
|
|
|
if (incount) /* all complete physical sectors */
|
|
{
|
|
rc = ata_transfer_sectors(start, incount, inbuf, false);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 2;
|
|
goto error;
|
|
}
|
|
start += incount;
|
|
inbuf += incount * log_sector_size;
|
|
}
|
|
|
|
if (offset) /* Trailing partial logical sector */
|
|
{
|
|
rc = cache_sector(start);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 3;
|
|
goto error;
|
|
}
|
|
memcpy(inbuf, sector_cache.data, offset * log_sector_size);
|
|
}
|
|
|
|
error:
|
|
mutex_unlock(&ata_mutex);
|
|
|
|
return rc;
|
|
}
|
|
|
|
int ata_write_sectors(IF_MD(int drive,)
|
|
sector_t start,
|
|
int count,
|
|
const void* buf)
|
|
{
|
|
int rc = 0;
|
|
int offset;
|
|
|
|
#ifdef HAVE_MULTIDRIVE
|
|
(void)drive; /* unused for now */
|
|
#endif
|
|
mutex_lock(&ata_mutex);
|
|
|
|
offset = start & (phys_sector_mult - 1);
|
|
|
|
if (offset) /* first partial physical sector */
|
|
{
|
|
int partcount = MIN(count, phys_sector_mult - offset);
|
|
|
|
rc = cache_sector(start);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 1;
|
|
goto error;
|
|
}
|
|
memcpy(sector_cache.data + offset * log_sector_size, buf,
|
|
partcount * log_sector_size);
|
|
rc = flush_current_sector();
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 2;
|
|
goto error;
|
|
}
|
|
start += partcount;
|
|
buf += partcount * log_sector_size;
|
|
count -= partcount;
|
|
}
|
|
|
|
offset = count & (phys_sector_mult - 1);
|
|
count -= offset;
|
|
|
|
if (count) /* all complete physical sectors */
|
|
{
|
|
rc = ata_transfer_sectors(start, count, (void*)buf, true);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 3;
|
|
goto error;
|
|
}
|
|
start += count;
|
|
buf += count * log_sector_size;
|
|
}
|
|
|
|
if (offset) /* Trailing partial logical sector */
|
|
{
|
|
rc = cache_sector(start);
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 4;
|
|
goto error;
|
|
}
|
|
memcpy(sector_cache.data, buf, offset * log_sector_size);
|
|
rc = flush_current_sector();
|
|
if (rc)
|
|
{
|
|
rc = rc * 10 - 5;
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
error:
|
|
mutex_unlock(&ata_mutex);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int ata_get_phys_sector_mult(void)
|
|
{
|
|
int rc = 0;
|
|
|
|
/* Find out the physical sector size */
|
|
if((identify_info[106] & 0xe000) == 0x6000) /* B14, B13 */
|
|
phys_sector_mult = BIT_N(identify_info[106] & 0x000f);
|
|
else
|
|
phys_sector_mult = 1;
|
|
|
|
DEBUGF("ata: %d logical sectors per phys sector", phys_sector_mult);
|
|
|
|
if((identify_info[209] & 0xc000) == 0x4000) { /* B14 */
|
|
if (identify_info[209] & 0x3fff) {
|
|
panicf("ata: Unaligned logical/physical sector mapping");
|
|
// XXX we can probably handle this by adding a fixed offset
|
|
// to all operations and subtracting this from the reported
|
|
// size. But we don't do tihs until we find a real-world need.
|
|
}
|
|
}
|
|
|
|
if (phys_sector_mult > 1)
|
|
{
|
|
/* Check if drive really needs emulation - if we can access
|
|
sector 1 then assume the drive supports "512e" and will handle
|
|
it better than us, so ignore the large physical sectors.
|
|
|
|
The exception here is if the device is partitioned to use
|
|
larger-than-logical "virtual" sectors; in that case we will
|
|
use whichever one (ie physical/"virtual") is larger.
|
|
*/
|
|
char throwaway[__MAX_VARIABLE_LOG_SECTOR];
|
|
rc = ata_transfer_sectors(1, 1, &throwaway, false);
|
|
if (rc == 0)
|
|
phys_sector_mult = 1;
|
|
}
|
|
|
|
if (phys_sector_mult > (MAX_PHYS_SECTOR_SIZE/log_sector_size))
|
|
panicf("Unsupported physical sector size: %ld",
|
|
phys_sector_mult * log_sector_size);
|
|
|
|
memset(§or_cache, 0, sizeof(sector_cache));
|
|
|
|
return 0;
|
|
}
|
|
|
|
void ata_set_phys_sector_mult(unsigned int mult)
|
|
{
|
|
unsigned int max = MAX_PHYS_SECTOR_SIZE/log_sector_size;
|
|
/* virtual sector could be larger than pyhsical sector */
|
|
if (!mult || mult > max)
|
|
mult = max;
|
|
/* It needs to be at _least_ the size of the real multiplier */
|
|
if (mult > phys_sector_mult)
|
|
phys_sector_mult = mult;
|
|
}
|
|
|
|
#endif /* MAX_PHYS_SECTOR_SIZE */
|