coreboot-mirror
/
seabios
mirror of https://review.coreboot.org/seabios.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Add common "block command" definitions and update cdrom code. 

Introduce standard definitions and names for the "command data block"
commands used in the cdrom code.
This commit is contained in:
Kevin O'Connor 2010-02-15 11:56:07 -05:00
parent 68caaa745a
commit 7d7002512e
4 changed files with 107 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/ata.c
View File

@ -17,6 +17,7 @@
#include "boot.h" // add_bcv_hd
#include "disk.h" // struct ata_s
#include "ata.h" // ATA_CB_STAT
#include "blockcmd.h" // CDB_CMD_READ_10
#define IDE_TIMEOUT 32000 //32 seconds max for IDE ops
@ -596,9 +597,11 @@ process_ata_op(struct disk_op_s *op)
* ATAPI functions
****************************************************************/
#define CDROM_CDB_SIZE 12
// Low-level atapi command transmit function.
static int
atapi_cmd_data(struct disk_op_s *op, u8 *cmdbuf, u8 cmdlen, u16 blocksize)
int
atapi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize)
{
u8 ataid = GET_GLOBAL(op->drive_g->cntl_id);
u8 channel = ataid / 2;
@ -622,7 +625,7 @@ atapi_cmd_data(struct disk_op_s *op, u8 *cmdbuf, u8 cmdlen, u16 blocksize)
goto fail;
// Send command to device
outsw_fl(iobase1, MAKE_FLATPTR(GET_SEG(SS), cmdbuf), cmdlen / 2);
outsw_fl(iobase1, MAKE_FLATPTR(GET_SEG(SS), cdbcmd), CDROM_CDB_SIZE / 2);
int status = pause_await_not_bsy(iobase1, iobase2);
if (status < 0) {
@ -657,17 +660,12 @@ fail:
int
cdrom_read(struct disk_op_s *op)
{
u8 atacmd[12];
memset(atacmd, 0, sizeof(atacmd));
atacmd[0]=0x28; // READ command
atacmd[7]=(op->count & 0xff00) >> 8; // Sectors
atacmd[8]=(op->count & 0x00ff);
atacmd[2]=(op->lba & 0xff000000) >> 24; // LBA
atacmd[3]=(op->lba & 0x00ff0000) >> 16;
atacmd[4]=(op->lba & 0x0000ff00) >> 8;
atacmd[5]=(op->lba & 0x000000ff);
return atapi_cmd_data(op, atacmd, sizeof(atacmd), CDROM_SECTOR_SIZE);
struct cdb_rwdata_10 cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_READ_10;
cmd.lba = htonl(op->lba);
cmd.count = htons(op->count);
return atapi_cmd_data(op, &cmd, CDROM_SECTOR_SIZE);
}
// 16bit command demuxer for ATAPI cdroms.
@ -689,20 +687,6 @@ process_atapi_op(struct disk_op_s *op)
}
}
// Send a simple atapi command to a drive.
int
ata_cmd_packet(struct drive_s *drive_g, u8 *cmdbuf, u8 cmdlen
, u32 length, void *buf_fl)
{
struct disk_op_s dop;
memset(&dop, 0, sizeof(dop));
dop.drive_g = drive_g;
dop.count = 1;
dop.buf_fl = buf_fl;
return atapi_cmd_data(&dop, cmdbuf, cmdlen, length);
}
/****************************************************************
* ATA detect and init

5
src/ata.h
View File

@ -15,8 +15,7 @@ struct ata_channel_s {
// ata.c
extern struct ata_channel_s ATA_channels[CONFIG_MAX_ATA_INTERFACES];
int cdrom_read(struct disk_op_s *op);
int ata_cmd_packet(struct drive_s *drive_g, u8 *cmdbuf, u8 cmdlen
, u32 length, void *buf_fl);
int atapi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize);
void ata_setup(void);
int process_ata_op(struct disk_op_s *op);
int process_atapi_op(struct disk_op_s *op);
@ -144,6 +143,4 @@ void describe_atapi(struct drive_s *drive_g);
#define ATA_CMD_READ_NATIVE_MAX_ADDRESS 0xF8
#define ATA_CMD_SET_MAX 0xF9
#define ATA_CMD_REQUEST_SENSE 0x03
#endif // ata.h

58
src/blockcmd.h Normal file
View File

@ -0,0 +1,58 @@
// Definitions for SCSI style command data blocks.
#ifndef __BLOCKCMD_H
#define __BLOCKCMD_H
#include "types.h" // u8
#define CDB_CMD_READ_10 0x28
#define CDB_CMD_VERIFY_10 0x2f
#define CDB_CMD_WRITE_10 0x2a
struct cdb_rwdata_10 {
u8 command;
u8 flags;
u32 lba;
u8 resreved_06;
u16 count;
u8 reserved_09;
u8 pad[6];
} PACKED;
#define CDB_CMD_READ_CAPACITY 0x25
struct cdb_read_capacity {
u8 command;
u8 flags;
u8 resreved_02[8];
u8 pad[6];
} PACKED;
struct cdbres_read_capacity {
u32 sectors;
u32 blksize;
} PACKED;
#define CDB_CMD_REQUEST_SENSE 0x03
struct cdb_request_sense {
u8 command;
u8 flags;
u16 reserved_02;
u8 length;
u8 reserved_05;
u8 pad[10];
} PACKED;
struct cdbres_request_sense {
u8 errcode;
u8 segment;
u8 flags;
u32 info;
u8 additional;
u32 specific;
u8 asc;
u8 ascq;
u32 reserved_0e;
} PACKED;
#endif // blockcmd.h

69
src/cdrom.c
View File

@ -10,6 +10,7 @@
#include "bregs.h" // struct bregs
#include "biosvar.h" // GET_EBDA
#include "ata.h" // ATA_CMD_REQUEST_SENSE
#include "blockcmd.h" // CDB_CMD_REQUEST_SENSE
/****************************************************************
@ -167,6 +168,8 @@ cdemu_134b(struct bregs *regs)
if (regs->al == 0x00) {
// FIXME ElTorito Various. Should be handled accordingly to spec
SET_EBDA2(ebda_seg, cdemu.active, 0x00); // bye bye
// XXX - update floppy/hd count.
}
disk_ret(regs, DISK_RET_SUCCESS);
@ -179,47 +182,47 @@ cdemu_134b(struct bregs *regs)
// Request SENSE
static int
atapi_get_sense(struct drive_s *drive_g, u8 *asc, u8 *ascq)
atapi_get_sense(struct disk_op_s *op, u8 *asc, u8 *ascq)
{
u8 atacmd[12], buffer[18];
memset(atacmd, 0, sizeof(atacmd));
atacmd[0] = ATA_CMD_REQUEST_SENSE;
atacmd[4] = sizeof(buffer);
int ret = ata_cmd_packet(drive_g, atacmd, sizeof(atacmd), sizeof(buffer)
, MAKE_FLATPTR(GET_SEG(SS), buffer));
struct cdb_request_sense cmd;
struct cdbres_request_sense data;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_REQUEST_SENSE;
cmd.length = sizeof(data);
op->count = 1;
op->buf_fl = &data;
int ret = atapi_cmd_data(op, &cmd, sizeof(data));
if (ret)
return ret;
*asc = buffer[12];
*ascq = buffer[13];
*asc = data.asc;
*ascq = data.ascq;
return 0;
}
// Request capacity
static int
atapi_read_capacity(struct drive_s *drive_g, u32 *blksize, u32 *sectors)
atapi_read_capacity(struct disk_op_s *op, u32 *blksize, u32 *sectors)
{
u8 packet[12], buf[8];
memset(packet, 0, sizeof(packet));
packet[0] = 0x25; /* READ CAPACITY */
int ret = ata_cmd_packet(drive_g, packet, sizeof(packet), sizeof(buf)
, MAKE_FLATPTR(GET_SEG(SS), buf));
struct cdb_read_capacity cmd;
struct cdbres_read_capacity data;
memset(&cmd, 0, sizeof(cmd));
cmd.command = CDB_CMD_READ_CAPACITY;
op->count = 1;
op->buf_fl = &data;
int ret = atapi_cmd_data(op, &cmd, sizeof(data));
if (ret)
return ret;
*blksize = (((u32)buf[4] << 24) | ((u32)buf[5] << 16)
| ((u32)buf[6] << 8) | ((u32)buf[7] << 0));
*sectors = (((u32)buf[0] << 24) | ((u32)buf[1] << 16)
| ((u32)buf[2] << 8) | ((u32)buf[3] << 0));
*blksize = ntohl(data.blksize);
*sectors = ntohl(data.sectors);
return 0;
}
static int
atapi_is_ready(struct drive_s *drive_g)
atapi_is_ready(struct disk_op_s *op)
{
dprintf(6, "atapi_is_ready (drive=%p)\n", drive_g);
dprintf(6, "atapi_is_ready (drive=%p)\n", op->drive_g);
/* Retry READ CAPACITY for 5 seconds unless MEDIUM NOT PRESENT is
* reported by the device. If the device reports "IN PROGRESS",
@ -233,13 +236,13 @@ atapi_is_ready(struct drive_s *drive_g)
return -1;
}
int ret = atapi_read_capacity(drive_g, &blksize, &sectors);
int ret = atapi_read_capacity(op, &blksize, &sectors);
if (!ret)
// Success
break;
u8 asc, ascq;
ret = atapi_get_sense(drive_g, &asc, &ascq);
ret = atapi_get_sense(op, &asc, &ascq);
if (ret)
// Error - retry.
continue;
@ -259,7 +262,7 @@ atapi_is_ready(struct drive_s *drive_g)
}
}
if (blksize != GET_GLOBAL(drive_g->blksize)) {
if (blksize != GET_GLOBAL(op->drive_g->blksize)) {
printf("Unsupported sector size %u\n", blksize);
return -1;
}
@ -272,19 +275,18 @@ atapi_is_ready(struct drive_s *drive_g)
int
cdrom_boot(int cdid)
{
struct drive_s *drive_g = getDrive(EXTTYPE_CD, cdid);
if (!drive_g)
struct disk_op_s dop;
memset(&dop, 0, sizeof(dop));
dop.drive_g = getDrive(EXTTYPE_CD, cdid);
if (!dop.drive_g)
return 1;
int ret = atapi_is_ready(drive_g);
int ret = atapi_is_ready(&dop);
if (ret)
dprintf(1, "atapi_is_ready returned %d\n", ret);
// Read the Boot Record Volume Descriptor
u8 buffer[2048];
struct disk_op_s dop;
memset(&dop, 0, sizeof(dop));
dop.drive_g = drive_g;
dop.lba = 0x11;
dop.count = 1;
dop.buf_fl = MAKE_FLATPTR(GET_SEG(SS), buffer);
@ -325,7 +327,7 @@ cdrom_boot(int cdid)
u8 media = buffer[0x21];
SET_EBDA2(ebda_seg, cdemu.media, media);
SET_EBDA2(ebda_seg, cdemu.emulated_drive, ADJUST_GLOBAL_PTR(drive_g));
SET_EBDA2(ebda_seg, cdemu.emulated_drive, ADJUST_GLOBAL_PTR(dop.drive_g));
u16 boot_segment = *(u16*)&buffer[0x22];
if (!boot_segment)
@ -362,6 +364,7 @@ cdrom_boot(int cdid)
if (media < 4) {
// Floppy emulation
SET_EBDA2(ebda_seg, cdemu.emulated_extdrive, 0x00);
// XXX - get and set actual floppy count.
SETBITS_BDA(equipment_list_flags, 0x41);
switch (media) {