Emulation/switch-coreboot
1
0
Fork 0
mirror of https://github.com/fail0verflow/switch-coreboot.git synced 2025-05-04 01:39:18 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Backport from Etherboot-5.1.8. Has problems when probing for second disk.

Browse source
This commit is contained in:
Greg Watson 2003-06-06 20:11:11 +00:00
parent adea9f37a8
commit 1c8cce6646
1 changed files with 475 additions and 492 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

949
src/pc80/ide/ide.c
View file

@ -1,6 +1,13 @@
#define BSY_SET_DURING_SPINUP 1
/* /*
* UBL, The Universal Talkware Boot Loader * UBL, The Universal Talkware Boot Loader
* Copyright (C) 2000 Universal Talkware Inc. * Copyright (C) 2000 Universal Talkware Inc.
* Copyright (C) 2002 Eric Biederman
*
* 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, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -11,521 +18,497 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
* *
* Note: Parts of this code grew out of the Openbios effort that was
* abandoned. Without the info that we were able to learn from
* OpenBios this program would have never worked. We are forever
* grateful for those who came before us.
* *
* This code can be retrieved in a machine/human readable form at:
*
* http://www.talkware.net/GPL/UBL
*
* Anyone making changes to this code please send them to us so we
* can include them in the standard release.
*
*
* $Id$
*/ */
#include <arch/io.h> #include <arch/io.h>
#include <printk.h> #include <printk.h>
#include <string.h> #include <string.h>
#include <timer.h>
#include <pci.h>
#include <pc80/ide.h> #include <pc80/ide.h>
#include <arch/io.h>
static __inline__ int wait_for_notbusy(unsigned base) struct controller controller;
struct harddisk_info harddisk_info[NUM_HD];
static int await_ide(int (*done)(struct controller *ctrl),
struct controller *ctrl, unsigned long timeout)
{ {
unsigned i = 0; int result;
for(;;) {
do { result = done(ctrl);
if (((inb_p(IDE_REG_ERROR(base)) & 0x80) != 0x80) && if (result) {
((inb_p(IDE_REG_STATUS(base)) & 0x80) != 0x80))
{
return 0; return 0;
} }
i++; if ((timeout == 0) || (ticks_since_boot() > timeout)) {
} while (i != 0); break;
return 1;
}
static __inline__ int wait_for_dataready(unsigned base)
{
unsigned i = 0;
do {
if (((inb_p(IDE_REG_ERROR(base)) & 0x80) != 0x80) &&
((inb_p(IDE_REG_STATUS(base)) & 0x88) != 0x88))
{
return 0;
} }
i++; udelay(1000); /* Added to avoid spinning GRW */
} while (i != 0); }
return -1;
return 1;
} }
static __inline__ int write_command( /* The maximum time any IDE command can last 31 seconds,
unsigned base, * So if any IDE commands takes this long we know we have problems.
ide_command_t command, */
ide_cmd_param_t * params) #define IDE_TIMEOUT (32*get_hz())
static int not_bsy(struct controller *ctrl)
{
return !(inb(IDE_REG_STATUS(ctrl)) & IDE_STATUS_BSY);
}
#if !BSY_SET_DURING_SPINUP
static int timeout(struct controller *ctrl)
{ {
if (wait_for_notbusy(base) != 0)
return 1;
outb_p(params->precomp, IDE_REG_PRECOMP(base));
outb_p(params->sector_count, IDE_REG_SECTOR_COUNT(base));
outb_p(params->sector_number, IDE_REG_SECTOR_NUMBER(base));
outb_p(params->cylinder & 0xFF, IDE_REG_CYLINDER_LSB(base));
outb_p((params->cylinder >> 8) & 0x03, IDE_REG_CYLINDER_MSB(base));
outb_p(params->drivehead, IDE_REG_DRIVEHEAD(base));
if (wait_for_notbusy(base) != 0)
return 1;
outb_p(command, IDE_REG_COMMAND(base));
return 0; return 0;
} }
#endif
int ide_shutdown(void) static int ide_software_reset(struct controller *ctrl)
{ {
outb_p(IDE_CMD_STANDBY_IMMEDIATE, IDE_REG_COMMAND(IDE_BASE1)); /* Wait a little bit in case this is immediately after
outb_p(IDE_CMD_STANDBY_IMMEDIATE2, IDE_REG_COMMAND(IDE_BASE1)); * hardware reset.
return 0; */
} udelay(2000);
/* A software reset should not be delivered while the bsy bit
int ide_read_data(unsigned base, void * buf, size_t size) * is set. If the bsy bit does not clear in a reasonable
{ * amount of time give up.
register unsigned short * ptr = (unsigned short *) buf; */
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
if (wait_for_dataready(base)) {
printk_info("data not ready...\n");
return 1;
}
while (size > 1) {
*ptr++ = inw_p(IDE_REG_DATA(base));
size -= sizeof(unsigned short);
}
return 0;
}
int ide_write_data(unsigned base, void * buf, size_t size)
{
register unsigned short * ptr = (unsigned short *) buf;
if (wait_for_dataready(base))
return 1;
while (size > 1) {
outw_p(*ptr, IDE_REG_DATA(base));
ptr++;
size -= sizeof(unsigned short);
}
return 0;
}
harddisk_info_t harddisk_info[NUM_HD];
static char buffer[512];
static int init_drive(unsigned base, int driveno)
{
volatile int delay;
ide_cmd_param_t cmd = IDE_DEFAULT_COMMAND;
unsigned char command_val;
unsigned short* drive_info;
harddisk_info[driveno].controller_port = base;
harddisk_info[driveno].num_heads = 0u;
harddisk_info[driveno].num_cylinders = 0u;
harddisk_info[driveno].num_sectors_per_track = 0u;
harddisk_info[driveno].num_sectors = 0ul;
harddisk_info[driveno].address_mode = IDE_DH_CHS;
harddisk_info[driveno].drive_exists = 0;
cmd.drivehead = IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS |
IDE_DH_DRIVE(driveno);
write_command(base, IDE_CMD_GET_INFO, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
/* Well, if that command didn't work, we probably don't have drive. */
printk_info("Drive %d: detect FAILED\n", driveno);
return 1;
}
ide_read_data(base, buffer, IDE_SECTOR_SIZE);
/* Now suck the data out */
drive_info = (unsigned short*)buffer;
harddisk_info[driveno].num_heads = drive_info[3];
harddisk_info[driveno].num_cylinders = drive_info[1];
harddisk_info[driveno].num_sectors_per_track = drive_info[6];
harddisk_info[driveno].num_sectors = *((unsigned int*)&(drive_info[60]));
memcpy(harddisk_info[driveno].model_number, ((unsigned short*)&(drive_info[27])), 40);
harddisk_info[driveno].drive_exists = 1;
printk_info("%s \n", harddisk_info[driveno].model_number);
printk_info("%s: sectors_per_track=[%d], num_heads=[%d], num_cylinders=[%d]\n",
__FUNCTION__,
harddisk_info[driveno].num_sectors_per_track,
harddisk_info[driveno].num_heads,
harddisk_info[driveno].num_cylinders);
#define HD harddisk_info[driveno]
if(drive_info[49] != 0) {
printk_info("IDE%d %d/%d/%d cap: %04x\n",
(int)driveno,
(int)HD.num_heads, (int)HD.num_cylinders,
(int)HD.num_sectors_per_track,
(int) drive_info[49]);
}
if (drive_info[49] & 0x200) { /* bit 9 of capability word is lba supported bit */
harddisk_info[driveno].address_mode = IDE_DH_LBA;
} else {
harddisk_info[driveno].address_mode = IDE_DH_CHS;
}
// harddisk_info[driveno].address_mode = IDE_DH_CHS;
/* Set up the Extended control register */
if (harddisk_info[driveno].num_heads > 8) {
command_val = 0x0A;
} else {
command_val = 0x02;
}
outb_p(command_val, IDE_REG_CONTROL(base));
/* Execute the drive diagnostics command */
write_command(base, IDE_CMD_DRIVE_DIAG, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
return 1;
}
/* Reset the bus (again) */
outb_p(cmd.drivehead, IDE_REG_DRIVEHEAD(base));
outb_p(0x04, IDE_REG_CONTROL(base));
for (delay = 0x100; delay > 0; --delay);
outb_p(command_val, IDE_REG_CONTROL(base));
/* Now do a drive recalibrate */
write_command(base, IDE_CMD_RECALIBRATE, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
return 1;
}
(void)wait_for_notbusy(base);
/* Set device parameters */
cmd.sector_count = harddisk_info[driveno].num_sectors_per_track;
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(harddisk_info[driveno].num_heads) |
IDE_DH_DRIVE(driveno) |
harddisk_info[driveno].address_mode;
write_command(base, IDE_CMD_SET_PARAMS, &cmd);
/* Set multiple mode */
cmd.sector_count = 0x10; /* Single-word DMA, mode 0 */
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(0) |
IDE_DH_DRIVE(driveno) |
harddisk_info[driveno].address_mode;
write_command(base, IDE_CMD_SET_MULTIMODE, &cmd);
/* Make sure command is still OK */
outb_p(command_val, IDE_REG_CONTROL(base));
/* Set parameters _again_ */
cmd.sector_count = harddisk_info[driveno].num_sectors_per_track;
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(harddisk_info[driveno].num_heads) |
IDE_DH_DRIVE(driveno) |
harddisk_info[driveno].address_mode;
write_command(base, IDE_CMD_SET_PARAMS, &cmd);
/* Make sure command is still OK */
outb_p(command_val, IDE_REG_CONTROL(base));
#if 0
/* Exercise the drive to see if it works OK */
printk_info("Exercising HardDisk- buffer=0x%08lX\n", (unsigned long) buffer);
outb_p(0x42, 0xeb);
while (1) {
for (idx = 0; idx < harddisk_info[driveno].num_sectors; ++idx) {
outb_p(idx & 0xFF, 0x80);
retval = ide_read_sector(driveno, buffer, idx);
if (retval != 0) {
printk_info("readsector(driveno=%d, sector=%lu) returned %d!\n",
driveno, (unsigned long) idx, retval);
}
}
printk_info("Exercise complete!\n");
outb(0x42, 0xeb);
}
#endif /* 0 */
return 0;
}
static int init_controller(unsigned base, int basedrive) {
volatile int delay;
/* First, check to see if the controller even exists */
outb_p(0x5, IDE_REG_SECTOR_COUNT(base));
if (inb_p(IDE_REG_SECTOR_COUNT(base)) != 0x5) {
printk_info("Controller %d: detect FAILED (1)\n", basedrive / 2);
return -1; return -1;
} }
outb_p(0xA, IDE_REG_SECTOR_COUNT(base));
if (inb_p(IDE_REG_SECTOR_COUNT(base)) != 0xA) { /* Disable Interrupts and reset the ide bus */
printk_info("Controller %d: detect FAILED (2)\n", basedrive / 2); outb(IDE_CTRL_HD15 | IDE_CTRL_SRST | IDE_CTRL_NIEN,
return -2; IDE_REG_DEVICE_CONTROL(ctrl));
udelay(5);
outb(IDE_CTRL_HD15 | IDE_CTRL_NIEN, IDE_REG_DEVICE_CONTROL(ctrl));
udelay(2000);
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
return -1;
} }
/* Reset the system */
outb_p(0x4, IDE_REG_CONTROL(base));
for (delay = 0x100; delay > 0; --delay);
outb_p(0x0, IDE_REG_CONTROL(base));
/* Now initialize the individual drives */
init_drive(base, basedrive);
init_drive(base, basedrive+1);
return 0; return 0;
} }
static void pio_set_registers(
struct controller *ctrl, const struct ide_pio_command *cmd)
{
uint8_t device;
/* Disable Interrupts */
outb(IDE_CTRL_HD15 | IDE_CTRL_NIEN, IDE_REG_DEVICE_CONTROL(ctrl));
/* Possibly switch selected device */
device = inb(IDE_REG_DEVICE(ctrl));
outb(cmd->device, IDE_REG_DEVICE(ctrl));
if ((device & (1UL << 4)) != (cmd->device & (1UL << 4))) {
/* Allow time for the selected drive to switch,
* The linux ide code suggests 50ms is the right
* amount of time to use here.
*/
udelay(50000);
}
outb(cmd->feature, IDE_REG_FEATURE(ctrl));
outb(cmd->sector_count2, IDE_REG_SECTOR_COUNT(ctrl));
outb(cmd->sector_count, IDE_REG_SECTOR_COUNT(ctrl));
outb(cmd->lba_low2, IDE_REG_LBA_LOW(ctrl));
outb(cmd->lba_low, IDE_REG_LBA_LOW(ctrl));
outb(cmd->lba_mid2, IDE_REG_LBA_MID(ctrl));
outb(cmd->lba_mid, IDE_REG_LBA_MID(ctrl));
outb(cmd->lba_high2, IDE_REG_LBA_HIGH(ctrl));
outb(cmd->lba_high, IDE_REG_LBA_HIGH(ctrl));
outb(cmd->command, IDE_REG_COMMAND(ctrl));
}
static int pio_non_data(struct controller *ctrl, const struct ide_pio_command *cmd)
{
/* Wait until the busy bit is clear */
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
return -1;
}
pio_set_registers(ctrl, cmd);
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
return -1;
}
/* FIXME is there more error checking I could do here? */
return 0;
}
static int pio_data_in(struct controller *ctrl, const struct ide_pio_command *cmd,
void *buffer, size_t bytes)
{
unsigned int status;
/* FIXME handle commands with multiple blocks */
/* Wait until the busy bit is clear */
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
return -1;
}
/* How do I tell if INTRQ is asserted? */
pio_set_registers(ctrl, cmd);
if (await_ide(not_bsy, ctrl, ticks_since_boot() + IDE_TIMEOUT) < 0) {
return -1;
}
status = inb(IDE_REG_STATUS(ctrl));
if (!(status & IDE_STATUS_DRQ)) {
return -1;
}
insw(IDE_REG_DATA(ctrl), buffer, bytes/2);
status = inb(IDE_REG_STATUS(ctrl));
if (status & IDE_STATUS_ERR) {
return -1;
}
return 0;
}
static inline int ide_read_sector_chs(
struct harddisk_info *info, void *buffer, unsigned long sector)
{
struct ide_pio_command cmd;
unsigned int track;
unsigned int offset;
unsigned int cylinder;
memset(&cmd, 0, sizeof(cmd));
cmd.sector_count = 1;
track = sector / info->sectors_per_track;
/* Sector number */
offset = 1 + (sector % info->sectors_per_track);
cylinder = track / info->heads;
cmd.lba_low = offset;
cmd.lba_mid = cylinder & 0xff;
cmd.lba_high = (cylinder >> 8) & 0xff;
cmd.device = IDE_DH_DEFAULT |
IDE_DH_HEAD(track % info->heads) |
info->slave |
IDE_DH_CHS;
cmd.command = IDE_CMD_READ_SECTORS;
return pio_data_in(info->ctrl, &cmd, buffer, IDE_SECTOR_SIZE);
}
static inline int ide_read_sector_lba(
struct harddisk_info *info, void *buffer, unsigned long sector)
{
struct ide_pio_command cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.sector_count = 1;
cmd.lba_low = sector & 0xff;
cmd.lba_mid = (sector >> 8) & 0xff;
cmd.lba_high = (sector >> 16) & 0xff;
cmd.device = IDE_DH_DEFAULT |
((sector >> 24) & 0x0f) |
info->slave |
IDE_DH_LBA;
cmd.command = IDE_CMD_READ_SECTORS;
return pio_data_in(info->ctrl, &cmd, buffer, IDE_SECTOR_SIZE);
}
static inline int ide_read_sector_lba48(
struct harddisk_info *info, void *buffer, sector_t sector)
{
struct ide_pio_command cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.sector_count = 1;
cmd.lba_low = sector & 0xff;
cmd.lba_mid = (sector >> 8) & 0xff;
cmd.lba_high = (sector >> 16) & 0xff;
cmd.lba_low2 = (sector >> 24) & 0xff;
cmd.lba_mid2 = (sector >> 32) & 0xff;
cmd.lba_high2 = (sector >> 40) & 0xff;
cmd.device = info->slave | IDE_DH_LBA;
cmd.command = IDE_CMD_READ_SECTORS_EXT;
return pio_data_in(info->ctrl, &cmd, buffer, IDE_SECTOR_SIZE);
}
int ide_read_sector(int driveno, void * buf, unsigned int sector,
int byte_offset, int n_bytes)
{
struct harddisk_info *info = &harddisk_info[driveno];
int result;
/* Report the buffer is empty */
if (sector > info->sectors) {
return -1;
}
if (info->address_mode == ADDRESS_MODE_CHS) {
result = ide_read_sector_chs(info, buf, sector);
}
else if (info->address_mode == ADDRESS_MODE_LBA) {
result = ide_read_sector_lba(info, buf, sector);
}
else if (info->address_mode == ADDRESS_MODE_LBA48) {
result = ide_read_sector_lba48(info, buf, sector);
}
else {
result = -1;
}
return result;
}
static int init_drive(struct harddisk_info *info, struct controller *ctrl, int slave, int basedrive)
{
uint16_t* drive_info;
struct ide_pio_command cmd;
unsigned char disk_buffer[DISK_BUFFER_SIZE];
int i;
info->ctrl = ctrl;
info->heads = 0u;
info->cylinders = 0u;
info->sectors_per_track = 0u;
info->address_mode = IDE_DH_CHS;
info->sectors = 0ul;
info->drive_exists = 0;
info->slave_absent = 0;
info->slave = slave?IDE_DH_SLAVE: IDE_DH_MASTER;
info->basedrive = basedrive;
printk_info("Testing for disk %d\n", info->basedrive);
/* Select the drive that we are testing */
outb(IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS | info->slave,
IDE_REG_DEVICE(ctrl));
udelay(50000);
/* Test to see if the drive registers exist,
* In many cases this quickly rules out a missing drive.
*/
for(i = 0; i < 4; i++) {
outb(0xaa + i, (ctrl->cmd_base) + 2 + i);
}
for(i = 0; i < 4; i++) {
if (inb((ctrl->cmd_base) + 2 + i) != 0xaa + i) {
return 1;
}
}
for(i = 0; i < 4; i++) {
outb(0x55 + i, (ctrl->cmd_base) + 2 + i);
}
for(i = 0; i < 4; i++) {
if (inb((ctrl->cmd_base) + 2 + i) != 0x55 + i) {
return 1;
}
}
printk_info("Probing for disk %d\n", info->basedrive);
memset(&cmd, 0, sizeof(cmd));
cmd.device = IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS | info->slave;
cmd.command = IDE_CMD_IDENTIFY_DEVICE;
if (pio_data_in(ctrl, &cmd, disk_buffer, IDE_SECTOR_SIZE) < 0) {
/* Well, if that command didn't work, we probably don't have drive. */
return 1;
}
/* Now suck the data out */
drive_info = (uint16_t *)disk_buffer;
if (drive_info[2] == 0x37C8) {
/* If the response is incomplete spin up the drive... */
memset(&cmd, 0, sizeof(cmd));
cmd.device = IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS |
info->slave;
cmd.feature = IDE_FEATURE_STANDBY_SPINUP_DRIVE;
if (pio_non_data(ctrl, &cmd) < 0) {
/* If the command doesn't work give up on the drive */
return 1;
}
}
if ((drive_info[2] == 0x37C8) || (drive_info[2] == 0x8C73)) {
/* The response is incomplete retry the drive info command */
memset(&cmd, 0, sizeof(cmd));
cmd.device = IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS |
info->slave;
cmd.command = IDE_CMD_IDENTIFY_DEVICE;
if(pio_data_in(ctrl, &cmd, disk_buffer, IDE_SECTOR_SIZE) < 0) {
/* If the command didn't work give up on the drive. */
return 1;
}
}
if ((drive_info[2] != 0x37C8) &&
(drive_info[2] != 0x738C) &&
(drive_info[2] != 0x8C73) &&
(drive_info[2] != 0xC837) &&
(drive_info[2] != 0x0000)) {
printk_info("Invalid IDE Configuration: %hx\n", drive_info[2]);
return 1;
}
for(i = 27; i < 47; i++) {
info->model_number[((i-27)<< 1)] = (drive_info[i] >> 8) & 0xff;
info->model_number[((i-27)<< 1)+1] = drive_info[i] & 0xff;
}
info->model_number[40] = '\0';
info->drive_exists = 1;
/* See if LBA is supported */
if (drive_info[49] & (1 << 9)) {
info->address_mode = ADDRESS_MODE_LBA;
info->sectors = (drive_info[61] << 16) | (drive_info[60]);
/* Enable LBA48 mode if it is present */
if (drive_info[83] & (1 <<10)) {
/* Should LBA48 depend on LBA? */
printk_info("LBA48 mode\n");
info->address_mode = ADDRESS_MODE_LBA48;
info->sectors =
(((sector_t)drive_info[103]) << 48) |
(((sector_t)drive_info[102]) << 32) |
(((sector_t)drive_info[101]) << 16) |
(((sector_t)drive_info[100]) << 0);
}
} else {
info->address_mode = ADDRESS_MODE_CHS;
info->heads = drive_info[3];
info->cylinders = drive_info[1];
info->sectors_per_track = drive_info[6];
info->sectors =
info->sectors_per_track *
info->heads *
info->cylinders;
printk_info("%s sectors_per_track=[%d], heads=[%d], cylinders=[%d]\n",
__FUNCTION__,
info->sectors_per_track,
info->heads,
info->cylinders);
}
/* See if we have a slave */
if (!info->slave && (((drive_info[93] >> 14) & 3) == 1)) {
info->slave_absent = !(drive_info[93] & (1 << 5));
}
/* See if we need to put the device in CFA power mode 1 */
if ((drive_info[160] & ((1 << 15) | (1 << 13)| (1 << 12))) ==
((1 << 15) | (1 << 13)| (1 << 12))) {
memset(&cmd, 0, sizeof(cmd));
cmd.device = IDE_DH_DEFAULT | IDE_DH_HEAD(0) | IDE_DH_CHS | info->slave;
cmd.feature = IDE_FEATURE_CFA_ENABLE_POWER_MODE1;
if (pio_non_data(ctrl, &cmd) < 0) {
/* If I need to power up the drive, and I can't
* give up.
*/
printk_info("Cannot power up CFA device\n");
return 1;
}
}
printk_info("disk%d %dk cap: %hx\n",
info->basedrive,
(unsigned long)(info->sectors >> 1),
drive_info[49]);
return 0;
}
static int init_controller(struct controller *ctrl, int basedrive)
{
struct harddisk_info *info;
/* Put the drives ide channel in a know state and wait
* for the drives to spinup.
*
* In practice IDE disks tend not to respond to commands until
* they have spun up. This makes IDE hard to deal with
* immediately after power up, as the delays can be quite
* long, so we must be very careful here.
*
* There are two pathological cases that must be dealt with:
*
* - The BSY bit not being set while the IDE drives spin up.
* In this cases only a hard coded delay will work. As
* I have not reproduced it, and this is out of spec for
* IDE drives the work around can be enabled by setting
* BSY_SET_DURING_SPINUP to 0.
*
* - The BSY bit floats high when no drives are plugged in.
* This case will not be detected except by timing out but
* we avoid the problems by only probing devices we are
* supposed to boot from. If we don't do the probe we
* will not experience the problem.
*
* So speed wise I am only slow if the BSY bit is not set
* or not reported by the IDE controller during spinup, which
* is quite rare.
*
*/
#if !BSY_SET_DURING_SPINUP
if (await_ide(timeout, ctrl, IDE_TIMEOUT) < 0) {
return -1;
}
#endif
if (ide_software_reset(ctrl) < 0) {
return -1;
}
/* Note: I have just done a software reset. It may be
* reasonable to just read the boot time signatures
* off of the drives to see if they are present.
*
* For now I will go with just sending commands to the drives
* and assuming filtering out missing drives by detecting registers
* that won't set and commands that fail to execute properly.
*/
/* Now initialize the individual drives */
info = &harddisk_info[basedrive];
init_drive(info, ctrl, 0, basedrive & 1);
/* at the moment this only works for the first drive */
#if 0
if (info->drive_exists && !info->slave_absent) {
basedrive++;
info++;
init_drive(info, ctrl, 1, basedrive & 1);
}
#endif
return 0;
}
int ide_init(void) int ide_init(void)
{ {
outb_p(0x42, 0xEB); struct harddisk_info *info;
printk_info ("I am now initializing the ide system\n"); int index;
int drives = 0;
if (init_controller(IDE_BASE1, 0) < 0) { /* Intialize the harddisk_info structures */
printk_info ("Initializing the main controller failed!\n"); memset(harddisk_info, 0, sizeof(harddisk_info));
/* error return error */
return -1;
};
#if (NUM_HD > 3)
init_controller(IDE_BASE2, 2);
#endif
#if (NUM_HD > 5)
init_controller(IDE_BASE3, 4);
#endif
#if (NUM_HD > 7)
init_controller(IDE_BASE4, 6);
#endif
return 0;
}
/* read a sector or a partial sector */
int ide_read_sector(int drive, void * buffer, unsigned int block, int byte_offset,
int n_bytes) {
ide_cmd_param_t cmd = IDE_DEFAULT_COMMAND;
unsigned base;
unsigned char sect_buffer[IDE_SECTOR_SIZE];
unsigned int track;
int status;
int address_mode = harddisk_info[drive].address_mode;
//int i;
printk_info("%s: drive[%d], buffer[%08x], block[%08x], offset[%d], n_bytes[%d]\n",
__FUNCTION__, drive, buffer, block, byte_offset, n_bytes);
printk_info("%s: block(%08x) to addr(%08x)\r", __FUNCTION__, block, (int)buffer);
if ((drive < 0) || (drive >= NUM_HD) ||
(harddisk_info[drive].drive_exists == 0))
{
printk_info("unknown drive\n");
return 1;
}
base = harddisk_info[drive].controller_port;
if (harddisk_info[drive].num_heads > 8) {
outb_p(0xA, IDE_REG_CONTROL(base));
} else {
outb_p(0x2, IDE_REG_CONTROL(base));
}
cmd.sector_count = 1;
if (address_mode == IDE_DH_CHS) {
track = block / harddisk_info[drive].num_sectors_per_track;
cmd.sector_number = 1+(block % harddisk_info[drive].num_sectors_per_track);
cmd.cylinder = track / harddisk_info[drive].num_heads;
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(track % harddisk_info[drive].num_heads) |
IDE_DH_DRIVE(drive) |
IDE_DH_CHS;
printk_info("%s: CHS: track=[%d], sector_number=[%d], cylinder=[%d]\n", __FUNCTION__, track, cmd.sector_number, cmd.cylinder);
/*
*/
} else {
#if 1
cmd.sector_number = block & 0xff; /* lower byte of block (lba) */
cmd.cylinder = (block >> 8) & 0xffff; /* middle 2 bytes of block (lba) */
cmd.drivehead = IDE_DH_DEFAULT | /* set bits that must be on */
((block >> 24) & 0x0f) | /* lower nibble of byte 3 of block */
IDE_DH_DRIVE(drive) |
IDE_DH_LBA;
#else
cmd.sector_number = (block >> 24) & 0xff; /* byte 0 of block (lba) */
cmd.cylinder = (block >> 8) & 0xffff; /* bytes 1 & 2 of block (lba) */
cmd.drivehead = IDE_DH_DEFAULT | /* set bits that must be on */
((block >> 4) & 0x0f) | /* upper nibble of byte 3 of block */
IDE_DH_DRIVE(drive) |
IDE_DH_LBA;
#endif
printk_info("%s: LBA: drivehead[%0x], cylinder[%04x], sector[%0x], block[%8x]\n",
__FUNCTION__, cmd.drivehead, cmd.cylinder, cmd.sector_number, block & 0x0fffffff);
/*
*/
}
write_command(base, IDE_CMD_READ_MULTI_RETRY, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
printk_info("ide not ready...\n");
return 1;
}
if (n_bytes != IDE_SECTOR_SIZE) {
status = ide_read_data(base, sect_buffer, IDE_SECTOR_SIZE);
if (status == 0) {
memcpy(buffer, sect_buffer+byte_offset, n_bytes);
}
} else {
status = ide_read_data(base, buffer, IDE_SECTOR_SIZE);
}
return status;
}
#ifdef DANGER_IDE_WRITE
/* write a sector or a partial sector */
int ide_write_sector(int drive, void * buffer, unsigned int block ) {
ide_cmd_param_t cmd = IDE_DEFAULT_COMMAND;
unsigned base;
unsigned int track;
int status;
int address_mode = harddisk_info[drive].address_mode;
//int i;
printk_info("%s: drive[%d], buffer[%08x], block[%08x]\n",
__FUNCTION__, drive, buffer, block);
printk_info("%s: block(%08x) from addr(%08x)\r", __FUNCTION__, block, (int)buffer);
if ((drive < 0) || (drive >= NUM_HD) ||
(harddisk_info[drive].drive_exists == 0))
{
printk_info("unknown drive\n");
return 1;
}
base = harddisk_info[drive].controller_port;
if (harddisk_info[drive].num_heads > 8) {
outb_p(0xA, IDE_REG_CONTROL(base));
} else {
outb_p(0x2, IDE_REG_CONTROL(base));
}
cmd.sector_count = 1;
if (address_mode == IDE_DH_CHS) {
track = block / harddisk_info[drive].num_sectors_per_track;
cmd.sector_number = 1+(block % harddisk_info[drive].num_sectors_per_track);
cmd.cylinder = track / harddisk_info[drive].num_heads;
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(track % harddisk_info[drive].num_heads) |
IDE_DH_DRIVE(drive) |
IDE_DH_CHS;
printk_info("%s: CHS: track=[%d], sector_number=[%d], cylinder=[%d]\n", __FUNCTION__, track, cmd.sector_number, cmd.cylinder);
/*
*/
} else {
#if 1
cmd.sector_number = block & 0xff; /* lower byte of block (lba) */
cmd.cylinder = (block >> 8) & 0xffff; /* middle 2 bytes of block (lba) */
cmd.drivehead = IDE_DH_DEFAULT | /* set bits that must be on */
((block >> 24) & 0x0f) | /* lower nibble of byte 3 of block */
IDE_DH_DRIVE(drive) |
IDE_DH_LBA;
#else
cmd.sector_number = (block >> 24) & 0xff; /* byte 0 of block (lba) */
cmd.cylinder = (block >> 8) & 0xffff; /* bytes 1 & 2 of block (lba) */
cmd.drivehead = IDE_DH_DEFAULT | /* set bits that must be on */
((block >> 4) & 0x0f) | /* upper nibble of byte 3 of block */
IDE_DH_DRIVE(drive) |
IDE_DH_LBA;
#endif
printk_info("%s: LBA: drivehead[%0x], cylinder[%04x], sector[%0x], block[%8x]\n",
__FUNCTION__, cmd.drivehead, cmd.cylinder, cmd.sector_number, block & 0x0fffffff);
/*
*/
}
write_command(base, IDE_CMD_WRITE_MULTI_RETRY, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
printk_info("ide not ready...\n");
return 1;
}
status = ide_write_data(base, buffer, IDE_SECTOR_SIZE);
return status;
}
#endif
for(index = 0; index < 1; index++) {
#if 0 #if 0
/* read a sector or a partial sector */ /* IDE normal pci mode */
int ide_read_sector(int drive, void * buffer, unsigned int block, int byte_offset, unsigned cmd_reg, ctrl_reg;
int n_bytes) { uint32_t cmd_base, ctrl_base;
ide_cmd_param_t cmd = IDE_DEFAULT_COMMAND; if (index < 2) {
unsigned base; cmd_reg = PCI_BASE_ADDRESS_0;
unsigned char sect_buffer[IDE_SECTOR_SIZE]; ctrl_reg = PCI_BASE_ADDRESS_1;
unsigned int track;
int status;
if ((drive < 0) || (drive >= NUM_HD) ||
(harddisk_info[drive].drive_exists == 0))
{
return 1;
}
base = harddisk_info[drive].controller_port;
if (harddisk_info[drive].num_heads > 8) {
outb_p(0xA, IDE_REG_CONTROL(base));
} else { } else {
outb_p(0x2, IDE_REG_CONTROL(base)); cmd_reg = PCI_BASE_ADDRESS_2;
ctrl_reg = PCI_BASE_ADDRESS_3;
} }
pcibios_read_config_dword(0, 0, cmd_reg, &cmd_base);
pcibios_read_config_dword(0, 0, ctrl_reg, &ctrl_base);
controller.cmd_base = cmd_base & ~3;
controller.ctrl_base = ctrl_base & ~3;
track = block / harddisk_info[drive].num_sectors_per_track;
cmd.sector_count = 1;
cmd.sector_number = 1+(block % harddisk_info[drive].num_sectors_per_track);
cmd.cylinder = track % harddisk_info[drive].num_heads;
cmd.drivehead = IDE_DH_DEFAULT |
IDE_DH_HEAD(track / harddisk_info[drive].num_heads) |
IDE_DH_DRIVE(drive) |
IDE_DH_CHS;
printk_info("%s: track=[%d], sector_number=[%d], cylinder=[%d]\n",
__FUNCTION__, track, cmd.sector_number, cmd.cylinder);
write_command(base, IDE_CMD_READ_MULTI_RETRY, &cmd);
if ((inb_p(IDE_REG_STATUS(base)) & 1) != 0) {
return 1;
}
if (n_bytes != IDE_SECTOR_SIZE) {
status = ide_read_data(base, sect_buffer, IDE_SECTOR_SIZE);
if (status == 0) {
memcpy(buffer, sect_buffer+byte_offset, n_bytes);
}
} else {
status = ide_read_data(base, buffer, IDE_SECTOR_SIZE);
}
printk_info("%s: status = [%d]\n", __FUNCTION__, status);
return status;
}
#endif #endif
uint16_t base;
base = (index < 1)?IDE_BASE0:IDE_BASE1;
controller.cmd_base = base;
controller.ctrl_base = base + IDE_REG_EXTENDED_OFFSET;
printk_info("init_controller %d at (%x, %x)\n", index, controller.cmd_base, controller.ctrl_base);
if (init_controller(&controller, index << 1) < 0) {
/* nothing behind the controller */
continue;
}
drives++;
}
return drives > 0 ? 0 : -1;
}