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.

4 files changed, 107 insertions, 65 deletions

diff --git a/src/ata.c b/src/ata.c
index ed7ef28..a27da56 100644
--- a/src/ata.c
+++ b/src/ata.c
@@ -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
diff --git a/src/ata.h b/src/ata.h
index d217280..ede5f17 100644
--- a/src/ata.h
+++ b/src/ata.h
@@ -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
diff --git a/src/blockcmd.h b/src/blockcmd.h
new file mode 100644
index 0000000..28a4889
--- /dev/null
+++ b/src/blockcmd.h
@@ -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
diff --git a/src/cdrom.c b/src/cdrom.c
index 883bffa..4e70729 100644
--- a/src/cdrom.c
+++ b/src/cdrom.c
@@ -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) {