diff --git a/src/devices/disk/zip.c b/src/devices/disk/zip.c index 22daf73..102a3da 100644 --- a/src/devices/disk/zip.c +++ b/src/devices/disk/zip.c @@ -9,7 +9,7 @@ * Implementation of the Iomega ZIP drive with SCSI(-like) * commands, for both ATAPI and SCSI usage. * - * Version: @(#)zip.c 1.0.23 2018/10/25 + * Version: @(#)zip.c 1.0.24 2018/10/26 * * Authors: Fred N. van Kempen, * Miran Grca, @@ -75,9 +75,8 @@ int zip_do_log = ENABLE_ZIP_LOG; zip_drive_t zip_drives[ZIP_NUM]; -/* Table of all SCSI commands and their flags, needed for the new disc change / not ready handler. */ -const uint8_t zip_command_flags[0x100] = -{ +/* Table of all SCSI commands and their flags. */ +static const uint8_t command_flags[0x100] = { IMPLEMENTED | CHECK_READY | NONDATA, /* 0x00 */ IMPLEMENTED | ALLOW_UA | NONDATA | SCSI_ONLY, /* 0x01 */ 0, @@ -146,19 +145,19 @@ const uint8_t zip_command_flags[0x100] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; -static uint64_t zip_mode_sense_page_flags = (GPMODEP_R_W_ERROR_PAGE | - GPMODEP_DISCONNECT_PAGE | - GPMODEP_IOMEGA_PAGE | - GPMODEP_ALL_PAGES); -static uint64_t zip_250_mode_sense_page_flags = (GPMODEP_R_W_ERROR_PAGE | - GPMODEP_FLEXIBLE_DISK_PAGE | - GPMODEP_CACHING_PAGE | - GPMODEP_IOMEGA_PAGE | - GPMODEP_ALL_PAGES); +static uint64_t mode_sense_page_flags = (GPMODEP_R_W_ERROR_PAGE | + GPMODEP_DISCONNECT_PAGE | + GPMODEP_IOMEGA_PAGE | + GPMODEP_ALL_PAGES); +static uint64_t mode_sense_page_flags250 = (GPMODEP_R_W_ERROR_PAGE | + GPMODEP_FLEXIBLE_DISK_PAGE | + GPMODEP_CACHING_PAGE | + GPMODEP_IOMEGA_PAGE | + GPMODEP_ALL_PAGES); -static const mode_sense_pages_t zip_mode_sense_pages_default = -{ { +static const mode_sense_pages_t mode_sense_pages_default = { + { { 0, 0 }, { GPMODE_R_W_ERROR_PAGE, 0x0a, 0xc8, 22, 0, 0, 0, 0, 90, 0, 0x50, 0x20 }, { GPMODE_DISCONNECT_PAGE, 0x0e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, @@ -209,59 +208,8 @@ static const mode_sense_pages_t zip_mode_sense_pages_default = { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0xff, 0x0f } } }; -static const mode_sense_pages_t zip_250_mode_sense_pages_default = -{ { - { 0, 0 }, - { GPMODE_R_W_ERROR_PAGE, 0x06, 0xc8, 0x64, 0, 0, 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - {GPMODE_FLEXIBLE_DISK_PAGE, 0x1e, 0x80, 0, 0x40, 0x20, 2, 0, 0, 0xef, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0b, 0x7d, 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { GPMODE_CACHING_PAGE, 0x0a, 4, 0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff, 0xff }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0x3c, 0x0f } -} }; - -static const mode_sense_pages_t zip_mode_sense_pages_default_scsi = -{ { +static const mode_sense_pages_t mode_sense_pages_default_scsi = { + { { 0, 0 }, { GPMODE_R_W_ERROR_PAGE, 0x0a, 0xc8, 22, 0, 0, 0, 0, 90, 0, 0x50, 0x20 }, { GPMODE_DISCONNECT_PAGE, 0x0e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, @@ -312,60 +260,8 @@ static const mode_sense_pages_t zip_mode_sense_pages_default_scsi = { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0xff, 0x0f } } }; -static const mode_sense_pages_t zip_250_mode_sense_pages_default_scsi = -{ { - { 0, 0 }, - { GPMODE_R_W_ERROR_PAGE, 0x06, 0xc8, 0x64, 0, 0, 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - {GPMODE_FLEXIBLE_DISK_PAGE, 0x1e, 0x80, 0, 0x40, 0x20, 2, 0, 0, 0xef, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0b, 0x7d, 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { GPMODE_CACHING_PAGE, 0x0a, 4, 0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff, 0xff }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { 0, 0 }, - { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0x3c, 0x0f } -} }; - -static const mode_sense_pages_t zip_mode_sense_pages_changeable = -{ { +static const mode_sense_pages_t mode_sense_pages_changeable = { + { { 0, 0 }, { GPMODE_R_W_ERROR_PAGE, 0x0a, 0xFF, 0xFF, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF }, @@ -417,8 +313,111 @@ static const mode_sense_pages_t zip_mode_sense_pages_changeable = { GPMODE_IOMEGA_PAGE, 0x04, 0xff, 0xff, 0xff, 0xff } } }; -static const mode_sense_pages_t zip_250_mode_sense_pages_changeable = -{ { +static const mode_sense_pages_t mode_sense_pages_default250 = { + { + { 0, 0 }, + { GPMODE_R_W_ERROR_PAGE, 0x06, 0xc8, 0x64, 0, 0, 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + {GPMODE_FLEXIBLE_DISK_PAGE, 0x1e, 0x80, 0, 0x40, 0x20, 2, 0, 0, 0xef, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0b, 0x7d, 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { GPMODE_CACHING_PAGE, 0x0a, 4, 0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff, 0xff }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0x3c, 0x0f } +} }; + +static const mode_sense_pages_t mode_sense_pages_default250_scsi = { + { + { 0, 0 }, + { GPMODE_R_W_ERROR_PAGE, 0x06, 0xc8, 0x64, 0, 0, 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + {GPMODE_FLEXIBLE_DISK_PAGE, 0x1e, 0x80, 0, 0x40, 0x20, 2, 0, 0, 0xef, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0b, 0x7d, 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { GPMODE_CACHING_PAGE, 0x0a, 4, 0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff, 0xff }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { 0, 0 }, + { GPMODE_IOMEGA_PAGE, 0x04, 0x5c, 0x0f, 0x3c, 0x0f } +} }; + +static const mode_sense_pages_t mode_sense_pages_changeable250 = { + { { 0, 0 }, { GPMODE_R_W_ERROR_PAGE, 0x06, 0xFF, 0xFF, 0, 0, 0, 0 }, { 0, 0 }, @@ -470,7 +469,7 @@ static const mode_sense_pages_t zip_250_mode_sense_pages_changeable = } }; -static void zip_command_complete(zip_t *dev); +static void command_complete(zip_t *dev); static void zip_init(zip_t *dev); static void zip_callback(void *p); @@ -522,7 +521,7 @@ zip_load(zip_t *dev, const wchar_t *fn) fseek(dev->drv->f, 0, SEEK_END); size = ftell(dev->drv->f); - if ((size == ((ZIP_250_SECTORS << 9) + 0x1000)) || (size == ((ZIP_SECTORS << 9) + 0x1000))) { + if ((size == ((ZIP_SECTORS_250 << 9) + 0x1000)) || (size == ((ZIP_SECTORS << 9) + 0x1000))) { /* This is a ZDI image. */ size -= 0x1000; dev->drv->base = 0x1000; @@ -530,9 +529,9 @@ zip_load(zip_t *dev, const wchar_t *fn) dev->drv->base = 0; if (dev->drv->is_250) { - if ((size != (ZIP_250_SECTORS << 9)) && (size != (ZIP_SECTORS << 9))) { + if ((size != (ZIP_SECTORS_250 << 9)) && (size != (ZIP_SECTORS << 9))) { DEBUG("File is incorrect size for a ZIP image\nMust be exactly %i or %i bytes\n", - ZIP_250_SECTORS << 9, ZIP_SECTORS << 9); + ZIP_SECTORS_250 << 9, ZIP_SECTORS << 9); fclose(dev->drv->f); dev->drv->f = NULL; dev->drv->medium_size = 0; @@ -584,7 +583,6 @@ zip_disk_reload(zip_t *dev) void zip_disk_close(zip_t *dev) { -ERRLOG("ZIP: disk_close: dev=%08lx drv=%08lx\n", dev, dev->drv); if (dev->drv->f) { fclose(dev->drv->f); dev->drv->f = NULL; @@ -598,7 +596,7 @@ ERRLOG("ZIP: disk_close: dev=%08lx drv=%08lx\n", dev, dev->drv); static void -zip_set_callback(zip_t *dev) +set_callback(zip_t *dev) { if (dev->drv->bus_type != ZIP_BUS_SCSI) ide_set_callback(dev->drv->bus_id.ide_channel >> 1, dev->callback); @@ -606,26 +604,27 @@ zip_set_callback(zip_t *dev) static void -zip_set_signature(void *p) +set_signature(void *p) { - zip_t *dev = (zip_t *) p; + zip_t *dev = (zip_t *)p; if (dev->id >= ZIP_NUM) return; + dev->phase = 1; dev->request_length = 0xEB14; } static int -zip_supports_pio(zip_t *dev) +supports_pio(zip_t *dev) { return (dev->drv->bus_mode & 1); } static int -zip_supports_dma(zip_t *dev) +supports_dma(zip_t *dev) { return (dev->drv->bus_mode & 2); } @@ -633,17 +632,17 @@ zip_supports_dma(zip_t *dev) /* Returns: 0 for none, 1 for PIO, 2 for DMA. */ static int -zip_current_mode(zip_t *dev) +current_mode(zip_t *dev) { - if (!zip_supports_pio(dev) && !zip_supports_dma(dev)) + if (!supports_pio(dev) && !supports_dma(dev)) return 0; - if (zip_supports_pio(dev) && !zip_supports_dma(dev)) { + if (supports_pio(dev) && !supports_dma(dev)) { DEBUG("ZIP %i: Drive does not support DMA, setting to PIO\n", dev->id); return 1; } - if (!zip_supports_pio(dev) && zip_supports_dma(dev)) + if (!supports_pio(dev) && supports_dma(dev)) return 2; - if (zip_supports_pio(dev) && zip_supports_dma(dev)) { + if (supports_pio(dev) && supports_dma(dev)) { DEBUG("ZIP %i: Drive supports both, setting to %s\n", dev->id, (dev->features & 1) ? "DMA" : "PIO"); return (dev->features & 1) ? 2 : 1; } @@ -654,7 +653,7 @@ zip_current_mode(zip_t *dev) /* Translates ATAPI status (ERR_STAT flag) to SCSI status. */ static int -zip_err_stat_to_scsi(void *p) +err_stat_to_scsi(void *p) { zip_t *dev = (zip_t *) p; @@ -692,78 +691,93 @@ zip_atapi_phase_to_scsi(zip_t *dev) static void -zip_mode_sense_load(zip_t *dev) +mode_sense_load(zip_t *dev) { - wchar_t file_name[512]; - FILE *f; + wchar_t temp[512]; + FILE *fp; int i; memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t)); + for (i = 0; i < 0x3f; i++) { if (dev->drv->is_250) { - if (zip_250_mode_sense_pages_default.pages[i][1] != 0) { + if (mode_sense_pages_default250.pages[i][1] != 0) { if (zip_drives[dev->id].bus_type == ZIP_BUS_SCSI) { memcpy(dev->ms_pages_saved.pages[i], - zip_250_mode_sense_pages_default_scsi.pages[i], - zip_250_mode_sense_pages_default_scsi.pages[i][1] + 2); + mode_sense_pages_default250_scsi.pages[i], + mode_sense_pages_default250_scsi.pages[i][1] + 2); } else { memcpy(dev->ms_pages_saved.pages[i], - zip_250_mode_sense_pages_default.pages[i], - zip_250_mode_sense_pages_default.pages[i][1] + 2); + mode_sense_pages_default250.pages[i], + mode_sense_pages_default250.pages[i][1] + 2); } } } else { - if (zip_mode_sense_pages_default.pages[i][1] != 0) { + if (mode_sense_pages_default.pages[i][1] != 0) { if (dev->drv->bus_type == ZIP_BUS_SCSI) { memcpy(dev->ms_pages_saved.pages[i], - zip_mode_sense_pages_default_scsi.pages[i], - zip_mode_sense_pages_default_scsi.pages[i][1] + 2); + mode_sense_pages_default_scsi.pages[i], + mode_sense_pages_default_scsi.pages[i][1] + 2); } else { memcpy(dev->ms_pages_saved.pages[i], - zip_mode_sense_pages_default.pages[i], - zip_mode_sense_pages_default.pages[i][1] + 2); + mode_sense_pages_default.pages[i], + mode_sense_pages_default.pages[i][1] + 2); } } } } - memset(file_name, 0, 512 * sizeof(wchar_t)); + + memset(temp, 0, sizeof(temp)); if (dev->drv->bus_type == ZIP_BUS_SCSI) - swprintf(file_name, 512, L"scsi_zip_%02i_mode_sense_bin", dev->id); + swprintf(temp, sizeof_w(temp), + L"scsi_zip_%02i_mode_sense_bin", dev->id); else - swprintf(file_name, 512, L"zip_%02i_mode_sense_bin", dev->id); - f = plat_fopen(nvr_path(file_name), L"rb"); - if (f) - fclose(f); + swprintf(temp, sizeof_w(temp), + L"zip_%02i_mode_sense_bin", dev->id); + + fp = plat_fopen(nvr_path(temp), L"rb"); + if (fp != NULL) { + /* Nothing to read, not used by ZIP. */ + + (void)fclose(fp); + } } static void -zip_mode_sense_save(zip_t *dev) +mode_sense_save(zip_t *dev) { - wchar_t file_name[512]; - FILE *f; + wchar_t temp[512]; + FILE *fp; - memset(file_name, 0, 512 * sizeof(wchar_t)); + memset(temp, 0, sizeof(temp)); if (dev->drv->bus_type == ZIP_BUS_SCSI) - swprintf(file_name, 512, L"scsi_zip_%02i_mode_sense_bin", dev->id); + swprintf(temp, sizeof_w(temp), + L"scsi_zip_%02i_mode_sense_bin", dev->id); else - swprintf(file_name, 512, L"zip_%02i_mode_sense_bin", dev->id); - f = plat_fopen(nvr_path(file_name), L"wb"); - if (f) - fclose(f); + swprintf(temp, sizeof_w(temp), + L"zip_%02i_mode_sense_bin", dev->id); + + fp = plat_fopen(nvr_path(temp), L"wb"); + if (fp != NULL) { + /* Nothing to write, not used by ZIP. */ + + (void)fclose(fp); + } } static int -zip_read_capacity(void *p, uint8_t *cdb, uint8_t *buffer, uint32_t *len) +read_capacity(void *p, uint8_t *cdb, uint8_t *buffer, uint32_t *len) { - zip_t *dev = (zip_t *) p; - int size = 0; + zip_t *dev = (zip_t *)p; + int size; + + size = (dev->drv->is_250) ? dev->drv->medium_size : ZIP_SECTORS; + + /* IMPORTANT: we return is the last LBA block. */ + size--; - if (dev->drv->is_250) - size = dev->drv->medium_size - 1; /* IMPORTANT: What's returned is the last LBA block. */ - else - size = ZIP_SECTORS - 1; /* IMPORTANT: What's returned is the last LBA block. */ memset(buffer, 0, 8); buffer[0] = (size >> 24) & 0xff; buffer[1] = (size >> 16) & 0xff; @@ -778,7 +792,7 @@ zip_read_capacity(void *p, uint8_t *cdb, uint8_t *buffer, uint32_t *len) /*SCSI Mode Sense 6/10*/ static uint8_t -zip_mode_sense_read(zip_t *dev, uint8_t page_control, uint8_t page, uint8_t pos) +mode_sense_read(zip_t *dev, uint8_t page_control, uint8_t page, uint8_t pos) { switch (page_control) { case 0: @@ -786,27 +800,26 @@ zip_mode_sense_read(zip_t *dev, uint8_t page_control, uint8_t page, uint8_t pos) if (dev->drv->is_250 && (page == 5) && (pos == 9) && (dev->drv->medium_size == ZIP_SECTORS)) return 0x60; return dev->ms_pages_saved.pages[page][pos]; - break; + case 1: if (dev->drv->is_250) - return zip_250_mode_sense_pages_changeable.pages[page][pos]; - else - return zip_mode_sense_pages_changeable.pages[page][pos]; - break; + return mode_sense_pages_changeable250.pages[page][pos]; + return mode_sense_pages_changeable.pages[page][pos]; + case 2: if (dev->drv->is_250) { if ((page == 5) && (pos == 9) && (dev->drv->medium_size == ZIP_SECTORS)) return 0x60; if (dev->drv->bus_type == ZIP_BUS_SCSI) - return zip_250_mode_sense_pages_default_scsi.pages[page][pos]; - else - return zip_250_mode_sense_pages_default.pages[page][pos]; - } else { - if (dev->drv->bus_type == ZIP_BUS_SCSI) - return zip_mode_sense_pages_default_scsi.pages[page][pos]; - else - return zip_mode_sense_pages_default.pages[page][pos]; + return mode_sense_pages_default250_scsi.pages[page][pos]; + return mode_sense_pages_default250.pages[page][pos]; } + + if (dev->drv->bus_type == ZIP_BUS_SCSI) + return mode_sense_pages_default_scsi.pages[page][pos]; + return mode_sense_pages_default.pages[page][pos]; + + default: break; } @@ -815,23 +828,17 @@ zip_mode_sense_read(zip_t *dev, uint8_t page_control, uint8_t page, uint8_t pos) static uint32_t -zip_mode_sense(zip_t *dev, uint8_t *buf, uint32_t pos, uint8_t page, uint8_t block_descriptor_len) +mode_sense(zip_t *dev, uint8_t *buf, uint32_t pos, uint8_t page, uint8_t block_descriptor_len) { - uint64_t pf; uint8_t page_control = (page >> 6) & 3; - - if (dev->drv->is_250) - pf = zip_250_mode_sense_page_flags; - else - pf = zip_mode_sense_page_flags; - - int i = 0; - int j = 0; - uint8_t msplen; + uint64_t pf; + int i, j; page &= 0x3f; + pf = (dev->drv->is_250) ? mode_sense_page_flags250 : mode_sense_page_flags; + if (block_descriptor_len) { if (dev->drv->is_250) { buf[pos++] = ((dev->drv->medium_size >> 24) & 0xff); @@ -853,12 +860,12 @@ zip_mode_sense(zip_t *dev, uint8_t *buf, uint32_t pos, uint8_t page, uint8_t blo for (i = 0; i < 0x40; i++) { if ((page == GPMODE_ALL_PAGES) || (page == i)) { if (pf & (1LL << ((uint64_t) page))) { - buf[pos++] = zip_mode_sense_read(dev, page_control, i, 0); - msplen = zip_mode_sense_read(dev, page_control, i, 1); + buf[pos++] = mode_sense_read(dev, page_control, i, 0); + msplen = mode_sense_read(dev, page_control, i, 1); buf[pos++] = msplen; DEBUG("ZIP %i: MODE SENSE: Page [%02X] length %i\n", dev->id, i, msplen); for (j = 0; j < msplen; j++) - buf[pos++] = zip_mode_sense_read(dev, page_control, i, 2 + j); + buf[pos++] = mode_sense_read(dev, page_control, i, 2 + j); } } } @@ -868,13 +875,16 @@ zip_mode_sense(zip_t *dev, uint8_t *buf, uint32_t pos, uint8_t page, uint8_t blo static void -zip_update_request_length(zip_t *dev, int len, int block_len) +update_request_length(zip_t *dev, int len, int block_len) { int bt, min_len = 0; dev->max_transfer_len = dev->request_length; - /* For media access commands, make sure the requested DRQ length matches the block length. */ + /* + * For media access commands, make sure the requested + * DRQ length matches the block length. + */ switch (dev->current_cdb[0]) { case 0x08: case 0x28: @@ -896,15 +906,19 @@ zip_update_request_length(zip_t *dev, int len, int block_len) break; } } + /*FALLTHROUGH*/ + default: dev->packet_len = len; break; } + /* If the DRQ length is odd, and the total remaining length is bigger, make sure it's even. */ if ((dev->max_transfer_len & 1) && (dev->max_transfer_len < len)) dev->max_transfer_len &= 0xfffe; + /* If the DRQ length is smaller or equal in size to the total remaining length, set it to that. */ - if (!dev->max_transfer_len) + if (! dev->max_transfer_len) dev->max_transfer_len = 65534; if ((len <= dev->max_transfer_len) && (len >= min_len)) @@ -917,18 +931,18 @@ zip_update_request_length(zip_t *dev, int len, int block_len) static void -zip_command_bus(zip_t *dev) +command_bus(zip_t *dev) { dev->status = BUSY_STAT; dev->phase = 1; dev->pos = 0; dev->callback = 1LL * ZIP_TIME; - zip_set_callback(dev); + set_callback(dev); } static void -zip_command_common(zip_t *dev) +command_common(zip_t *dev) { double bytes_per_second, period; double dusec; @@ -944,7 +958,7 @@ zip_command_common(zip_t *dev) dev->callback = -1LL; /* Speed depends on SCSI controller */ return; } else { - if (zip_current_mode(dev) == 2) + if (current_mode(dev) == 2) bytes_per_second = 66666666.666666666666666; /* 66 MB/s MDMA-2 speed */ else bytes_per_second = 8333333.333333333333333; /* 8.3 MB/s PIO-2 speed */ @@ -952,51 +966,56 @@ zip_command_common(zip_t *dev) period = 1000000.0 / bytes_per_second; dusec = (double) TIMER_USEC; - dusec = dusec * period * (double) (dev->packet_len); - dev->callback = ((int64_t) dusec); + dusec = dusec * period * ((double)dev->packet_len); + dev->callback = (int64_t)dusec; } - zip_set_callback(dev); + set_callback(dev); } static void -zip_command_complete(zip_t *dev) +command_complete(zip_t *dev) { dev->packet_status = PHASE_COMPLETE; - zip_command_common(dev); + + command_common(dev); } static void -zip_command_read(zip_t *dev) +command_read(zip_t *dev) { dev->packet_status = PHASE_DATA_IN; - zip_command_common(dev); + + command_common(dev); } static void -zip_command_read_dma(zip_t *dev) +command_read_dma(zip_t *dev) { dev->packet_status = PHASE_DATA_IN_DMA; - zip_command_common(dev); + + command_common(dev); } static void -zip_command_write(zip_t *dev) +command_write(zip_t *dev) { dev->packet_status = PHASE_DATA_OUT; - zip_command_common(dev); + + command_common(dev); } static void -zip_command_write_dma(zip_t *dev) +command_write_dma(zip_t *dev) { dev->packet_status = PHASE_DATA_OUT_DMA; - zip_command_common(dev); + + command_common(dev); } @@ -1006,7 +1025,7 @@ zip_command_write_dma(zip_t *dev) alloc_len = Allocated transfer length; direction = Transfer direction (0 = read from host, 1 = write to host). */ static void -zip_data_command_finish(zip_t *dev, int len, int block_len, int alloc_len, int direction) +data_command_finish(zip_t *dev, int len, int block_len, int alloc_len, int direction) { DEBUG("ZIP %i: Finishing command (%02X): %i, %i, %i, %i, %i\n", dev->id, dev->current_cdb[0], len, block_len, alloc_len, direction, dev->request_length); @@ -1015,26 +1034,27 @@ zip_data_command_finish(zip_t *dev, int len, int block_len, int alloc_len, int d if (alloc_len < len) len = alloc_len; } - if ((len == 0) || (zip_current_mode(dev) == 0)) { + + if ((len == 0) || (current_mode(dev) == 0)) { if (dev->drv->bus_type != ZIP_BUS_SCSI) dev->packet_len = 0; - zip_command_complete(dev); + command_complete(dev); } else { - if (zip_current_mode(dev) == 2) { + if (current_mode(dev) == 2) { if (dev->drv->bus_type != ZIP_BUS_SCSI) dev->packet_len = alloc_len; if (direction == 0) - zip_command_read_dma(dev); + command_read_dma(dev); else - zip_command_write_dma(dev); + command_write_dma(dev); } else { - zip_update_request_length(dev, len, block_len); + update_request_length(dev, len, block_len); if (direction == 0) - zip_command_read(dev); + command_read(dev); else - zip_command_write(dev); + command_write(dev); } } @@ -1044,14 +1064,14 @@ zip_data_command_finish(zip_t *dev, int len, int block_len, int alloc_len, int d static void -zip_sense_clear(zip_t *dev, int command) +sense_clear(zip_t *dev, int command) { - zip_sense_key = zip_asc = zip_ascq = 0; + dev->sense[2] = dev->sense[12] = dev->sense[13] = 0; } static void -zip_set_phase(zip_t *dev, uint8_t phase) +set_phase(zip_t *dev, uint8_t phase) { if (dev->drv->bus_type != ZIP_BUS_SCSI) return; @@ -1061,10 +1081,11 @@ zip_set_phase(zip_t *dev, uint8_t phase) static void -zip_cmd_error(zip_t *dev) +cmd_error(zip_t *dev) { - zip_set_phase(dev, SCSI_PHASE_STATUS); - dev->error = ((zip_sense_key & 0xf) << 4) | ABRT_ERR; + set_phase(dev, SCSI_PHASE_STATUS); + + dev->error = ((dev->sense[2] & 0xf) << 4) | ABRT_ERR; if (dev->unit_attention) dev->error |= MCR_ERR; dev->status = READY_STAT | ERR_STAT; @@ -1072,15 +1093,18 @@ zip_cmd_error(zip_t *dev) dev->pos = 0; dev->packet_status = 0x80; dev->callback = 50LL * ZIP_TIME; - zip_set_callback(dev); - DEBUG("ZIP %i: [%02X] ERROR: %02X/%02X/%02X\n", dev->id, dev->current_cdb[0], zip_sense_key, zip_asc, zip_ascq); + + set_callback(dev); + DEBUG("ZIP %i: [%02X] ERROR: %02X/%02X/%02X\n", + dev->id, dev->current_cdb[0], dev->sense[2], dev->sense[12], dev->sense[13]); } static void -zip_unit_attention(zip_t *dev) +unit_attention(zip_t *dev) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); + dev->error = (SENSE_UNIT_ATTENTION << 4) | ABRT_ERR; if (dev->unit_attention) dev->error |= MCR_ERR; @@ -1089,98 +1113,110 @@ zip_unit_attention(zip_t *dev) dev->pos = 0; dev->packet_status = 0x80; dev->callback = 50LL * ZIP_TIME; - zip_set_callback(dev); + + set_callback(dev); DEBUG("ZIP %i: UNIT ATTENTION\n", dev->id); } static void -zip_bus_master_error(zip_t *dev) +bus_master_error(zip_t *dev) { - zip_sense_key = zip_asc = zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = dev->sense[12] = dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_not_ready(zip_t *dev) +not_ready(zip_t *dev) { - zip_sense_key = SENSE_NOT_READY; - zip_asc = ASC_MEDIUM_NOT_PRESENT; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_NOT_READY; + dev->sense[12] = ASC_MEDIUM_NOT_PRESENT; + dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_write_protected(zip_t *dev) +write_protected(zip_t *dev) { - zip_sense_key = SENSE_UNIT_ATTENTION; - zip_asc = ASC_WRITE_PROTECTED; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_UNIT_ATTENTION; + dev->sense[12] = ASC_WRITE_PROTECTED; + dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_invalid_lun(zip_t *dev) +invalid_lun(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_LUN; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_INV_LUN; + dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_illegal_opcode(zip_t *dev) +illegal_opcode(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_ILLEGAL_OPCODE; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_ILLEGAL_OPCODE; + dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_lba_out_of_range(zip_t *dev) +lba_out_of_range(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_LBA_OUT_OF_RANGE; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_LBA_OUT_OF_RANGE; + dev->sense[13] = 0; + + cmd_error(dev); } static void -zip_invalid_field(zip_t *dev) +invalid_field(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_FIELD_IN_CMD_PACKET; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_INV_FIELD_IN_CMD_PACKET; + dev->sense[13] = 0; + + cmd_error(dev); + dev->status = 0x53; } static void -zip_invalid_field_pl(zip_t *dev) +invalid_field_pl(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_FIELD_IN_PARAMETER_LIST; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_INV_FIELD_IN_PARAMETER_LIST; + dev->sense[13] = 0; + + cmd_error(dev); + dev->status = 0x53; } static void -zip_data_phase_error(zip_t *dev) +data_phase_error(zip_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_DATA_PHASE_ERROR; - zip_ascq = 0; - zip_cmd_error(dev); + dev->sense[2] = SENSE_ILLEGAL_REQUEST; + dev->sense[12] = ASC_DATA_PHASE_ERROR; + dev->sense[13] = 0; + + cmd_error(dev); } @@ -1189,8 +1225,8 @@ zip_blocks(zip_t *dev, int32_t *len, int first_batch, int out) { *len = 0; - if (!dev->sector_len) { - zip_command_complete(dev); + if (! dev->sector_len) { + command_complete(dev); return -1; } @@ -1198,7 +1234,7 @@ zip_blocks(zip_t *dev, int32_t *len, int first_batch, int out) if (dev->sector_pos >= dev->drv->medium_size) { DEBUG("ZIP %i: Trying to %s beyond the end of disk\n", dev->id, out ? "write" : "read"); - zip_lba_out_of_range(dev); + lba_out_of_range(dev); return 0; } @@ -1226,46 +1262,38 @@ zip_insert(zip_t *dev) } -/*SCSI Sense Initialization*/ -void -zip_sense_code_ok(zip_t *dev) -{ - zip_sense_key = SENSE_NONE; - zip_asc = 0; - zip_ascq = 0; -} - - static int -zip_pre_execution_check(zip_t *dev, uint8_t *cdb) +pre_execution_check(zip_t *dev, uint8_t *cdb) { int ready = 0; if (dev->drv->bus_type == ZIP_BUS_SCSI) { if ((cdb[0] != GPCMD_REQUEST_SENSE) && (cdb[1] & 0xe0)) { DEBUG("ZIP %i: Attempting to execute a unknown command targeted at SCSI LUN %i\n", dev->id, ((dev->request_length >> 5) & 7)); - zip_invalid_lun(dev); + invalid_lun(dev); return 0; } } - if (!(zip_command_flags[cdb[0]] & IMPLEMENTED)) { + if (! (command_flags[cdb[0]] & IMPLEMENTED)) { DEBUG("ZIP %i: Attempting to execute unknown command %02X over %s\n", dev->id, cdb[0], (dev->drv->bus_type == ZIP_BUS_SCSI) ? "SCSI" : "ATAPI"); - zip_illegal_opcode(dev); + illegal_opcode(dev); return 0; } - if ((dev->drv->bus_type < ZIP_BUS_SCSI) && (zip_command_flags[cdb[0]] & SCSI_ONLY)) { + if ((dev->drv->bus_type < ZIP_BUS_SCSI) && + (command_flags[cdb[0]] & SCSI_ONLY)) { DEBUG("ZIP %i: Attempting to execute SCSI-only command %02X over ATAPI\n", dev->id, cdb[0]); - zip_illegal_opcode(dev); + illegal_opcode(dev); return 0; } - if ((dev->drv->bus_type == ZIP_BUS_SCSI) && (zip_command_flags[cdb[0]] & ATAPI_ONLY)) { + if ((dev->drv->bus_type == ZIP_BUS_SCSI) && + (command_flags[cdb[0]] & ATAPI_ONLY)) { DEBUG("ZIP %i: Attempting to execute ATAPI-only command %02X over SCSI\n", dev->id, cdb[0]); - zip_illegal_opcode(dev); + illegal_opcode(dev); return 0; } @@ -1281,11 +1309,11 @@ zip_pre_execution_check(zip_t *dev, uint8_t *cdb) execution under it, error out and report the condition. */ if (dev->unit_attention == 1) { /* Only increment the unit attention phase if the command can not pass through it. */ - if (!(zip_command_flags[cdb[0]] & ALLOW_UA)) { + if (! (command_flags[cdb[0]] & ALLOW_UA)) { DBGLOG(1, "ZIP %i: Unit attention now 2\n", dev->id); dev->unit_attention = 2; DEBUG("ZIP %i: UNIT ATTENTION: Command %02X not allowed to pass through\n", dev->id, cdb[0]); - zip_unit_attention(dev); + unit_attention(dev); return 0; } } else if (dev->unit_attention == 2) { @@ -1298,12 +1326,12 @@ zip_pre_execution_check(zip_t *dev, uint8_t *cdb) /* Unless the command is REQUEST SENSE, clear the sense. This will *NOT* the UNIT ATTENTION condition if it's set. */ if (cdb[0] != GPCMD_REQUEST_SENSE) - zip_sense_clear(dev, cdb[0]); + sense_clear(dev, cdb[0]); /* Next it's time for NOT READY. */ - if ((zip_command_flags[cdb[0]] & CHECK_READY) && !ready) { + if ((command_flags[cdb[0]] & CHECK_READY) && !ready) { DEBUG("ZIP %i: Not ready (%02X)\n", dev->id, cdb[0]); - zip_not_ready(dev); + not_ready(dev); return 0; } @@ -1332,42 +1360,47 @@ zip_rezero(zip_t *dev) void zip_reset(void *p) { - zip_t *dev = (zip_t *) p; + zip_t *dev = (zip_t *)p; zip_rezero(dev); + dev->status = 0; dev->callback = 0LL; - zip_set_callback(dev); - zip_set_signature(dev); + + set_callback(dev); + + set_signature(dev); + dev->packet_status = 0xff; dev->unit_attention = 0; } static void -zip_request_sense(zip_t *dev, uint8_t *buffer, uint8_t alloc_length, int desc) +request_sense(zip_t *dev, uint8_t *buffer, uint8_t alloc_length, int desc) { /*Will return 18 bytes of 0*/ if (alloc_length != 0) { memset(buffer, 0, alloc_length); - if (!desc) + if (! desc) memcpy(buffer, dev->sense, alloc_length); else { - buffer[1] = zip_sense_key; - buffer[2] = zip_asc; - buffer[3] = zip_ascq; + buffer[1] = dev->sense[2]; + buffer[2] = dev->sense[12]; + buffer[3] = dev->sense[13]; } } buffer[0] = desc ? 0x72 : 0x70; - if (dev->unit_attention && (zip_sense_key == 0)) { + if (dev->unit_attention && (dev->sense[2] == 0)) { buffer[desc ? 1 : 2] = SENSE_UNIT_ATTENTION; buffer[desc ? 2 : 12] = ASC_MEDIUM_MAY_HAVE_CHANGED; buffer[desc ? 3 : 13] = 0; } - DEBUG("ZIP %i: Reporting sense: %02X %02X %02X\n", dev->id, buffer[2], buffer[12], buffer[13]); + DEBUG("ZIP %i: Reporting sense: %02X %02X %02X\n", + dev->id, buffer[2], buffer[12], buffer[13]); if (buffer[desc ? 1 : 2] == SENSE_UNIT_ATTENTION) { /* If the last remaining sense is unit attention, clear @@ -1376,12 +1409,12 @@ zip_request_sense(zip_t *dev, uint8_t *buffer, uint8_t alloc_length, int desc) } /* Clear the sense stuff as per the spec. */ - zip_sense_clear(dev, GPCMD_REQUEST_SENSE); + sense_clear(dev, GPCMD_REQUEST_SENSE); } static void -zip_request_sense_for_scsi(void *p, uint8_t *buffer, uint8_t alloc_length) +request_sense_scsi(void *p, uint8_t *buffer, uint8_t alloc_length) { zip_t *dev = (zip_t *) p; int ready = 0; @@ -1397,35 +1430,37 @@ zip_request_sense_for_scsi(void *p, uint8_t *buffer, uint8_t alloc_length) /* Do *NOT* advance the unit attention phase. */ - zip_request_sense(dev, buffer, alloc_length, 0); + request_sense(dev, buffer, alloc_length, 0); } static void -zip_set_buf_len(zip_t *dev, int32_t *BufLen, int32_t *src_len) +set_buf_len(zip_t *dev, int32_t *BufLen, int32_t *src_len) { - if (dev->drv->bus_type == ZIP_BUS_SCSI) { - if (*BufLen == -1) - *BufLen = *src_len; - else { - *BufLen = MIN(*src_len, *BufLen); - *src_len = *BufLen; - } - DEBUG("ZIP %i: Actual transfer length: %i\n", dev->id, *BufLen); + if (dev->drv->bus_type != ZIP_BUS_SCSI) return; + + if (*BufLen == -1) + *BufLen = *src_len; + else { + *BufLen = MIN(*src_len, *BufLen); + *src_len = *BufLen; } + + DEBUG("ZIP %i: Actual transfer length: %i\n", dev->id, *BufLen); } static void -zip_buf_alloc(zip_t *dev, uint32_t len) +buf_alloc(zip_t *dev, uint32_t len) { DEBUG("ZIP %i: Allocated buffer length: %i\n", dev->id, len); - dev->buffer = (uint8_t *) malloc(len); + + dev->buffer = (uint8_t *)mem_alloc(len); } static void -zip_buf_free(zip_t *dev) +buf_free(zip_t *dev) { if (dev->buffer) { DEBUG("ZIP %i: Freeing buffer...\n", dev->id); @@ -1438,7 +1473,7 @@ zip_buf_free(zip_t *dev) static void zip_command(void *p, uint8_t *cdb) { - zip_t *dev = (zip_t *) p; + zip_t *dev = (zip_t *)p; int pos = 0, block_desc = 0; int ret; int32_t len, max_len; @@ -1464,7 +1499,7 @@ zip_command(void *p, uint8_t *cdb) if (cdb[0] != 0) { DEBUG("ZIP %i: Command 0x%02X, Sense Key %02X, Asc %02X, Ascq %02X, Unit attention: %i\n", - dev->id, cdb[0], zip_sense_key, zip_asc, zip_ascq, dev->unit_attention); + dev->id, cdb[0], dev->sense[2], dev->sense[12], dev->sense[13], dev->unit_attention); DEBUG("ZIP %i: Request length: %04X\n", dev->id, dev->request_length); DEBUG("ZIP %i: CDB: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", dev->id, @@ -1474,41 +1509,43 @@ zip_command(void *p, uint8_t *cdb) dev->sector_len = 0; - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); /* This handles the Not Ready/Unit Attention check if it has to be handled at this point. */ - if (zip_pre_execution_check(dev, cdb) == 0) + if (pre_execution_check(dev, cdb) == 0) return; switch (cdb[0]) { case GPCMD_SEND_DIAGNOSTIC: - if (!(cdb[1] & (1 << 2))) { - zip_invalid_field(dev); + if (! (cdb[1] & (1 << 2))) { + invalid_field(dev); return; } + case GPCMD_SCSI_RESERVE: case GPCMD_SCSI_RELEASE: case GPCMD_TEST_UNIT_READY: - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + set_phase(dev, SCSI_PHASE_STATUS); + command_complete(dev); break; case GPCMD_FORMAT_UNIT: if ((dev->drv->bus_type == ZIP_BUS_SCSI) && dev->drv->read_only) { - zip_write_protected(dev); + write_protected(dev); return; } - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + set_phase(dev, SCSI_PHASE_STATUS); + command_complete(dev); break; case GPCMD_IOMEGA_SENSE: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[4]; - zip_buf_alloc(dev, 256); - zip_set_buf_len(dev, BufLen, &max_len); + buf_alloc(dev, 256); + set_buf_len(dev, BufLen, &max_len); memset(dev->buffer, 0, 256); + if (cdb[2] == 1) { /* This page is related to disk health status - setting this page to 0 makes disk health read as "marginal". */ @@ -1527,58 +1564,59 @@ zip_command(void *p, uint8_t *cdb) for (i = 0x00; i < 0x27; i++) dev->buffer[i + 0x16] = 0x00; } else { - zip_invalid_field(dev); - zip_buf_free(dev); + invalid_field(dev); + buf_free(dev); return; } - zip_data_command_finish(dev, 18, 18, cdb[4], 0); + data_command_finish(dev, 18, 18, cdb[4], 0); break; case GPCMD_REZERO_UNIT: dev->sector_pos = dev->sector_len = 0; zip_seek(dev, 0); - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); break; case GPCMD_REQUEST_SENSE: /* If there's a unit attention condition and there's a buffered not ready, a standalone REQUEST SENSE should forget about the not ready, and report unit attention straight away. */ - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[4]; - if (!max_len) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + if (! max_len) { + set_phase(dev, SCSI_PHASE_STATUS); dev->packet_status = PHASE_COMPLETE; dev->callback = 20LL * ZIP_TIME; - zip_set_callback(dev); + + set_callback(dev); break; } - zip_buf_alloc(dev, 256); - zip_set_buf_len(dev, BufLen, &max_len); + buf_alloc(dev, 256); + set_buf_len(dev, BufLen, &max_len); len = (cdb[1] & 1) ? 8 : 18; - zip_request_sense(dev, dev->buffer, max_len, cdb[1] & 1); - zip_data_command_finish(dev, len, len, cdb[4], 0); + request_sense(dev, dev->buffer, max_len, cdb[1] & 1); + data_command_finish(dev, len, len, cdb[4], 0); break; case GPCMD_MECHANISM_STATUS: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); len = (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; - zip_buf_alloc(dev, 8); + buf_alloc(dev, 8); - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); memset(dev->buffer, 0, 8); dev->buffer[5] = 1; - zip_data_command_finish(dev, 8, 8, len, 0); + data_command_finish(dev, 8, 8, len, 0); break; case GPCMD_READ_6: case GPCMD_READ_10: case GPCMD_READ_12: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); alloc_length = 512; switch(cdb[0]) { @@ -1587,46 +1625,53 @@ zip_command(void *p, uint8_t *cdb) dev->sector_pos = ((((uint32_t) cdb[1]) & 0x1f) << 16) | (((uint32_t) cdb[2]) << 8) | ((uint32_t) cdb[3]); DEBUG("ZIP %i: Length: %i, LBA: %i\n", dev->id, dev->sector_len, dev->sector_pos); break; + case GPCMD_READ_10: dev->sector_len = (cdb[7] << 8) | cdb[8]; dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; DEBUG("ZIP %i: Length: %i, LBA: %i\n", dev->id, dev->sector_len, dev->sector_pos); break; + case GPCMD_READ_12: dev->sector_len = (((uint32_t) cdb[6]) << 24) | (((uint32_t) cdb[7]) << 16) | (((uint32_t) cdb[8]) << 8) | ((uint32_t) cdb[9]); dev->sector_pos = (((uint32_t) cdb[2]) << 24) | (((uint32_t) cdb[3]) << 16) | (((uint32_t) cdb[4]) << 8) | ((uint32_t) cdb[5]); break; } - if (!dev->sector_len) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + if (! dev->sector_len) { + set_phase(dev, SCSI_PHASE_STATUS); DBGLOG(1, "ZIP %i: All done - callback set\n", dev->id); dev->packet_status = PHASE_COMPLETE; dev->callback = 20LL * ZIP_TIME; - zip_set_callback(dev); + + set_callback(dev); break; } + /* + * If we are reading all blocks in one go for DMA, why + * not also for PIO, it should NOT matter anyway, this + * step should be identical and only the way the read + * data is transferred to the host should be different. + */ max_len = dev->sector_len; - dev->requested_blocks = max_len; /* If we're reading all blocks in one go for DMA, why not also for PIO, it should NOT - matter anyway, this step should be identical and only the way the read dat is - transferred to the host should be different. */ + dev->requested_blocks = max_len; dev->packet_len = max_len * alloc_length; - zip_buf_alloc(dev, dev->packet_len); + buf_alloc(dev, dev->packet_len); ret = zip_blocks(dev, &alloc_length, 1, 0); if (ret <= 0) { - zip_buf_free(dev); + buf_free(dev); return; } dev->requested_blocks = max_len; dev->packet_len = alloc_length; - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); - zip_data_command_finish(dev, alloc_length, 512, alloc_length, 0); + data_command_finish(dev, alloc_length, 512, alloc_length, 0); if (dev->packet_status != PHASE_COMPLETE) ui_sb_icon_update(SB_ZIP | dev->id, 1); @@ -1637,21 +1682,22 @@ zip_command(void *p, uint8_t *cdb) case GPCMD_VERIFY_6: case GPCMD_VERIFY_10: case GPCMD_VERIFY_12: - if (!(cdb[1] & 2)) { - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + if (! (cdb[1] & 2)) { + set_phase(dev, SCSI_PHASE_STATUS); + command_complete(dev); break; } + case GPCMD_WRITE_6: case GPCMD_WRITE_10: case GPCMD_WRITE_AND_VERIFY_10: case GPCMD_WRITE_12: case GPCMD_WRITE_AND_VERIFY_12: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + set_phase(dev, SCSI_PHASE_DATA_OUT); alloc_length = 512; if ((dev->drv->bus_type == ZIP_BUS_SCSI) && dev->drv->read_only) { - zip_write_protected(dev); + write_protected(dev); return; } @@ -1661,6 +1707,7 @@ zip_command(void *p, uint8_t *cdb) dev->sector_len = cdb[4]; dev->sector_pos = ((((uint32_t) cdb[1]) & 0x1f) << 16) | (((uint32_t) cdb[2]) << 8) | ((uint32_t) cdb[3]); break; + case GPCMD_VERIFY_10: case GPCMD_WRITE_10: case GPCMD_WRITE_AND_VERIFY_10: @@ -1668,6 +1715,7 @@ zip_command(void *p, uint8_t *cdb) dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; DEBUG("ZIP %i: Length: %i, LBA: %i\n", dev->id, dev->sector_len, dev->sector_pos); break; + case GPCMD_VERIFY_12: case GPCMD_WRITE_12: case GPCMD_WRITE_AND_VERIFY_12: @@ -1679,40 +1727,45 @@ zip_command(void *p, uint8_t *cdb) if (dev->drv->is_250) { if ((dev->sector_pos >= dev->drv->medium_size) || ((dev->sector_pos + dev->sector_len - 1) >= dev->drv->medium_size)) { - zip_lba_out_of_range(dev); + lba_out_of_range(dev); return; } } else { if ((dev->sector_pos >= ZIP_SECTORS) || ((dev->sector_pos + dev->sector_len - 1) >= ZIP_SECTORS)) { - zip_lba_out_of_range(dev); + lba_out_of_range(dev); return; } } - if (!dev->sector_len) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + if (! dev->sector_len) { + set_phase(dev, SCSI_PHASE_STATUS); DBGLOG(1, "ZIP %i: All done - callback set\n", dev->id); dev->packet_status = PHASE_COMPLETE; dev->callback = 20LL * ZIP_TIME; - zip_set_callback(dev); + + set_callback(dev); break; } + /* + * If we are writing all blocks in one go for DMA, why + * not also for PIO, it should NOT matter anyway, this + * step should be identical and only the way the data + * written is transferred to the host should be different. + */ max_len = dev->sector_len; - dev->requested_blocks = max_len; /* If we're writing all blocks in one go for DMA, why not also for PIO, it should NOT - matter anyway, this step should be identical and only the way the read dat is - transferred to the host should be different. */ + dev->requested_blocks = max_len; dev->packet_len = max_len * alloc_length; - zip_buf_alloc(dev, dev->packet_len); + buf_alloc(dev, dev->packet_len); dev->requested_blocks = max_len; dev->packet_len = max_len << 9; - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); - zip_data_command_finish(dev, dev->packet_len, 512, dev->packet_len, 1); + data_command_finish(dev, dev->packet_len, 512, dev->packet_len, 1); if (dev->packet_status != PHASE_COMPLETE) ui_sb_icon_update(SB_ZIP | dev->id, 1); @@ -1721,16 +1774,16 @@ zip_command(void *p, uint8_t *cdb) return; case GPCMD_WRITE_SAME_10: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + set_phase(dev, SCSI_PHASE_DATA_OUT); alloc_length = 512; if ((cdb[1] & 6) == 6) { - zip_invalid_field(dev); + invalid_field(dev); return; } if ((dev->drv->bus_type == ZIP_BUS_SCSI) && dev->drv->read_only) { - zip_write_protected(dev); + write_protected(dev); return; } @@ -1740,40 +1793,45 @@ zip_command(void *p, uint8_t *cdb) if (dev->drv->is_250) { if ((dev->sector_pos >= dev->drv->medium_size) || ((dev->sector_pos + dev->sector_len - 1) >= dev->drv->medium_size)) { - zip_lba_out_of_range(dev); + lba_out_of_range(dev); return; } } else { if ((dev->sector_pos >= ZIP_SECTORS) || ((dev->sector_pos + dev->sector_len - 1) >= ZIP_SECTORS)) { - zip_lba_out_of_range(dev); + lba_out_of_range(dev); return; } } - if (!dev->sector_len) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + if (! dev->sector_len) { + set_phase(dev, SCSI_PHASE_STATUS); DBGLOG(1, "ZIP %i: All done - callback set\n", dev->id); dev->packet_status = PHASE_COMPLETE; dev->callback = 20LL * ZIP_TIME; - zip_set_callback(dev); + + set_callback(dev); break; } + /* + * If we are writing all blocks in one go for DMA, why + * not also for PIO, it should NOT matter anyway, this + * step should be identical and only the way the data + * written is transferred to the host should be different. + */ max_len = dev->sector_len; - dev->requested_blocks = max_len; /* If we're writing all blocks in one go for DMA, why not also for PIO, it should NOT - matter anyway, this step should be identical and only the way the read dat is - transferred to the host should be different. */ + dev->requested_blocks = max_len; dev->packet_len = max_len * alloc_length; - zip_buf_alloc(dev, dev->packet_len); + buf_alloc(dev, dev->packet_len); dev->requested_blocks = max_len; dev->packet_len = alloc_length; - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); - zip_data_command_finish(dev, dev->packet_len, 512, dev->packet_len, 1); + data_command_finish(dev, dev->packet_len, 512, dev->packet_len, 1); if (dev->packet_status != PHASE_COMPLETE) ui_sb_icon_update(SB_ZIP | dev->id, 1); @@ -1783,7 +1841,7 @@ zip_command(void *p, uint8_t *cdb) case GPCMD_MODE_SENSE_6: case GPCMD_MODE_SENSE_10: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); if (dev->drv->bus_type == ZIP_BUS_SCSI) block_desc = ((cdb[1] >> 3) & 1) ? 0 : 1; @@ -1792,15 +1850,15 @@ zip_command(void *p, uint8_t *cdb) if (cdb[0] == GPCMD_MODE_SENSE_6) { len = cdb[4]; - zip_buf_alloc(dev, 256); + buf_alloc(dev, 256); } else { len = (cdb[8] | (cdb[7] << 8)); - zip_buf_alloc(dev, 65536); + buf_alloc(dev, 65536); } - if (!(zip_mode_sense_page_flags & (1LL << (uint64_t) (cdb[2] & 0x3f)))) { - zip_invalid_field(dev); - zip_buf_free(dev); + if (!(mode_sense_page_flags & (1LL << (uint64_t) (cdb[2] & 0x3f)))) { + invalid_field(dev); + buf_free(dev); return; } @@ -1808,14 +1866,14 @@ zip_command(void *p, uint8_t *cdb) alloc_length = len; if (cdb[0] == GPCMD_MODE_SENSE_6) { - len = zip_mode_sense(dev, dev->buffer, 4, cdb[2], block_desc); + len = mode_sense(dev, dev->buffer, 4, cdb[2], block_desc); len = MIN(len, alloc_length); dev->buffer[0] = len - 1; dev->buffer[1] = 0; if (block_desc) dev->buffer[3] = 8; } else { - len = zip_mode_sense(dev, dev->buffer, 8, cdb[2], block_desc); + len = mode_sense(dev, dev->buffer, 8, cdb[2], block_desc); len = MIN(len, alloc_length); dev->buffer[0]=(len - 2) >> 8; dev->buffer[1]=(len - 2) & 255; @@ -1826,35 +1884,35 @@ zip_command(void *p, uint8_t *cdb) } } - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); DEBUG("ZIP %i: Reading mode page: %02X...\n", dev->id, cdb[2]); - zip_data_command_finish(dev, len, len, alloc_length, 0); + data_command_finish(dev, len, len, alloc_length, 0); return; case GPCMD_MODE_SELECT_6: case GPCMD_MODE_SELECT_10: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + set_phase(dev, SCSI_PHASE_DATA_OUT); if (cdb[0] == GPCMD_MODE_SELECT_6) { len = cdb[4]; - zip_buf_alloc(dev, 256); + buf_alloc(dev, 256); } else { len = (cdb[7] << 8) | cdb[8]; - zip_buf_alloc(dev, 65536); + buf_alloc(dev, 65536); } - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); dev->total_length = len; dev->do_page_save = cdb[1] & 1; - zip_data_command_finish(dev, len, len, len, 1); + data_command_finish(dev, len, len, len, 1); return; case GPCMD_START_STOP_UNIT: - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); switch(cdb[4] & 3) { case 0: /* Stop the disc. */ @@ -1870,17 +1928,17 @@ zip_command(void *p, uint8_t *cdb) break; } - zip_command_complete(dev); + command_complete(dev); break; case GPCMD_INQUIRY: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[3]; max_len <<= 8; max_len |= cdb[4]; - zip_buf_alloc(dev, 65536); + buf_alloc(dev, 65536); if (cdb[1] & 1) { preamble_len = 4; @@ -1897,10 +1955,11 @@ zip_command(void *p, uint8_t *cdb) dev->buffer[idx++] = 0x00; dev->buffer[idx++] = 0x83; break; + case 0x83: if (idx + 24 > max_len) { - zip_data_phase_error(dev); - zip_buf_free(dev); + data_phase_error(dev); + buf_free(dev); return; } @@ -1927,10 +1986,11 @@ zip_command(void *p, uint8_t *cdb) ide_padstr8(dev->buffer + idx, 20, "53R141"); /* Product */ idx += 20; break; + default: DEBUG("INQUIRY: Invalid page: %02X\n", cdb[2]); - zip_invalid_field(dev); - zip_buf_free(dev); + invalid_field(dev); + buf_free(dev); return; } } else { @@ -1979,57 +2039,58 @@ atapi_out: len=idx; len = MIN(len, max_len); - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, max_len, 0); + data_command_finish(dev, len, len, max_len, 0); break; case GPCMD_PREVENT_REMOVAL: - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + set_phase(dev, SCSI_PHASE_STATUS); + command_complete(dev); break; case GPCMD_SEEK_6: case GPCMD_SEEK_10: - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); switch(cdb[0]) { case GPCMD_SEEK_6: pos = (cdb[2] << 8) | cdb[3]; break; + case GPCMD_SEEK_10: pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; break; } zip_seek(dev, pos); - zip_command_complete(dev); + command_complete(dev); break; case GPCMD_READ_CDROM_CAPACITY: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + set_phase(dev, SCSI_PHASE_DATA_IN); - zip_buf_alloc(dev, 8); + buf_alloc(dev, 8); - if (zip_read_capacity(dev, dev->current_cdb, dev->buffer, (uint32_t *) &len) == 0) { - zip_buf_free(dev); + if (read_capacity(dev, dev->current_cdb, dev->buffer, (uint32_t *) &len) == 0) { + buf_free(dev); return; } - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, len, 0); + data_command_finish(dev, len, len, len, 0); break; case GPCMD_IOMEGA_EJECT: - zip_set_phase(dev, SCSI_PHASE_STATUS); + set_phase(dev, SCSI_PHASE_STATUS); ui_zip_eject(dev->id); - zip_command_complete(dev); + command_complete(dev); break; case GPCMD_READ_FORMAT_CAPACITIES: len = (cdb[7] << 8) | cdb[8]; - zip_buf_alloc(dev, len); + buf_alloc(dev, len); memset(dev->buffer, 0, len); pos = 0; @@ -2052,10 +2113,10 @@ atapi_out: dev->buffer[pos++] = dev->drv->medium_size & 0xff; dev->buffer[pos++] = 2; /* Current medium capacity */ } else { - dev->buffer[pos++] = (ZIP_250_SECTORS >> 24) & 0xff; - dev->buffer[pos++] = (ZIP_250_SECTORS >> 16) & 0xff; - dev->buffer[pos++] = (ZIP_250_SECTORS >> 8) & 0xff; - dev->buffer[pos++] = ZIP_250_SECTORS & 0xff; + dev->buffer[pos++] = (ZIP_SECTORS_250 >> 24) & 0xff; + dev->buffer[pos++] = (ZIP_SECTORS_250 >> 16) & 0xff; + dev->buffer[pos++] = (ZIP_SECTORS_250 >> 8) & 0xff; + dev->buffer[pos++] = ZIP_SECTORS_250 & 0xff; dev->buffer[pos++] = 3; /* Maximum medium capacity */ } } else { @@ -2085,40 +2146,36 @@ atapi_out: dev->buffer[pos++] = 512 & 0xff; } - zip_set_buf_len(dev, BufLen, &len); + set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, len, 0); + data_command_finish(dev, len, len, len, 0); break; default: - zip_illegal_opcode(dev); + illegal_opcode(dev); break; } - DBGLOG(1, "ZIP %i: Phase: %02X, request length: %i\n", dev->id, dev->phase, dev->request_length); + DBGLOG(1, "ZIP %i: Phase: %02X, request length: %i\n", + dev->id, dev->phase, dev->request_length); if (zip_atapi_phase_to_scsi(dev) == SCSI_PHASE_STATUS) - zip_buf_free(dev); + buf_free(dev); } /* The command second phase function, needed for Mode Select. */ static uint8_t -zip_phase_data_out(zip_t *dev) +phase_data_out(zip_t *dev) { uint16_t block_desc_len; uint16_t pos; - uint8_t error = 0; uint8_t page, page_len; - uint32_t i = 0; - uint8_t hdr_len, val, old_val, ch; - uint32_t last_to_write = 0; uint32_t c, h, s; - int len = 0; switch(dev->current_cdb[0]) { @@ -2126,6 +2183,7 @@ zip_phase_data_out(zip_t *dev) case GPCMD_VERIFY_10: case GPCMD_VERIFY_12: break; + case GPCMD_WRITE_6: case GPCMD_WRITE_10: case GPCMD_WRITE_AND_VERIFY_10: @@ -2134,6 +2192,7 @@ zip_phase_data_out(zip_t *dev) if (dev->requested_blocks > 0) zip_blocks(dev, &len, 1, 1); break; + case GPCMD_WRITE_SAME_10: if (!dev->current_cdb[7] && !dev->current_cdb[8]) { if (dev->drv->is_250) @@ -2167,6 +2226,7 @@ zip_phase_data_out(zip_t *dev) fwrite(dev->buffer, 1, 512, dev->drv->f); } break; + case GPCMD_MODE_SELECT_6: case GPCMD_MODE_SELECT_10: if (dev->current_cdb[0] == GPCMD_MODE_SELECT_10) @@ -2195,11 +2255,11 @@ zip_phase_data_out(zip_t *dev) pos += 2; - if (!(zip_mode_sense_page_flags & (1LL << ((uint64_t) page)))) + if (!(mode_sense_page_flags & (1LL << ((uint64_t) page)))) error |= 1; else { for (i = 0; i < page_len; i++) { - ch = zip_mode_sense_pages_changeable.pages[page][i + 2]; + ch = mode_sense_pages_changeable.pages[page][i + 2]; val = dev->buffer[pos + i]; old_val = dev->ms_pages_saved.pages[page][i + 2]; if (val != old_val) { @@ -2214,18 +2274,18 @@ zip_phase_data_out(zip_t *dev) pos += page_len; if (dev->drv->bus_type == ZIP_BUS_SCSI) - val = zip_mode_sense_pages_default_scsi.pages[page][0] & 0x80; + val = mode_sense_pages_default_scsi.pages[page][0] & 0x80; else - val = zip_mode_sense_pages_default.pages[page][0] & 0x80; + val = mode_sense_pages_default.pages[page][0] & 0x80; if (dev->do_page_save && val) - zip_mode_sense_save(dev); + mode_sense_save(dev); if (pos >= dev->total_length) break; } if (error) { - zip_invalid_field_pl(dev); + invalid_field_pl(dev); return 0; } break; @@ -2237,7 +2297,7 @@ zip_phase_data_out(zip_t *dev) /* This is the general ATAPI PIO request function. */ static void -zip_pio_request(zip_t *dev, uint8_t out) +pio_request(zip_t *dev, uint8_t out) { int ret = 0; @@ -2249,37 +2309,39 @@ zip_pio_request(zip_t *dev, uint8_t out) dev->status = BUSY_STAT; if (dev->pos >= dev->packet_len) { - DEBUG("ZIP %i: %i bytes %s, command done\n", dev->id, dev->pos, out ? "written" : "read"); + DEBUG("ZIP %i: %i bytes %s, command done\n", + dev->id, dev->pos, out ? "written" : "read"); dev->pos = dev->request_pos = 0; if (out) { - ret = zip_phase_data_out(dev); + ret = phase_data_out(dev); /* If ret = 0 (phase 1 error), then we do not do anything else other than free the buffer, as the phase and callback have already been set by the error function. */ if (ret) - zip_command_complete(dev); + command_complete(dev); } else - zip_command_complete(dev); - zip_buf_free(dev); + command_complete(dev); + buf_free(dev); } else { - DEBUG("ZIP %i: %i bytes %s, %i bytes are still left\n", dev->id, dev->pos, - out ? "written" : "read", dev->packet_len - dev->pos); + DEBUG("ZIP %i: %i bytes %s, %i bytes are still left\n", dev->id, + dev->pos, out ? "written" : "read", dev->packet_len - dev->pos); /* If less than (packet length) bytes are remaining, update packet length accordingly. */ if ((dev->packet_len - dev->pos) < (dev->max_transfer_len)) dev->max_transfer_len = dev->packet_len - dev->pos; - DEBUG("ZIP %i: Packet length %i, request length %i\n", dev->id, dev->packet_len, - dev->max_transfer_len); + DEBUG("ZIP %i: Packet length %i, request length %i\n", + dev->id, dev->packet_len, dev->max_transfer_len); dev->packet_status = out ? PHASE_DATA_OUT : PHASE_DATA_IN; dev->status = BUSY_STAT; dev->phase = 1; - zip_callback((void *) dev); + zip_callback(dev); + dev->callback = 0LL; - zip_set_callback(dev); + set_callback(dev); dev->request_pos = 0; } @@ -2287,40 +2349,45 @@ zip_pio_request(zip_t *dev, uint8_t out) static int -zip_read_from_ide_dma(zip_t *dev) +read_from_ide_dma(zip_t *dev) { int ret; - if (!dev) + if (dev == NULL) return 0; if (ide_bus_master_write) { ret = ide_bus_master_write(dev->drv->bus_id.ide_channel >> 1, dev->buffer, dev->packet_len, ide_bus_master_priv[dev->drv->bus_id.ide_channel >> 1]); - if (ret == 2) /* DMA not enabled, wait for it to be enabled. */ + if (ret == 2) /* DMA not enabled, wait for it to be.. */ return 2; - else if (ret == 1) { /* DMA error. */ - zip_bus_master_error(dev); + if (ret == 1) { /* DMA error */ + bus_master_error(dev); return 0; - } else - return 1; - } else - return 0; + } + + return 1; + } + + return 0; } static int -zip_read_from_scsi_dma(scsi_device_t *sd, UNUSED(uint8_t scsi_id)) +read_from_scsi_dma(scsi_device_t *sd, UNUSED(uint8_t scsi_id)) { zip_t *dev = (zip_t *)sd->p; int32_t *BufLen = &sd->buffer_length; - if (!dev) + if (dev == NULL) return 0; - DEBUG("Reading from SCSI DMA: SCSI ID %02X, init length %i\n", scsi_id, *BufLen); + DEBUG("Reading from SCSI DMA: SCSI ID %02X, init length %i\n", + scsi_id, *BufLen); + memcpy(dev->buffer, sd->cmd_buffer, *BufLen); + return 1; } @@ -2334,7 +2401,7 @@ zip_irq_raise(zip_t *dev) static int -zip_read_from_dma(zip_t *dev) +read_from_dma(zip_t *dev) { scsi_device_t *sd = &scsi_devices[dev->drv->bus_id.scsi.id][dev->drv->bus_id.scsi.lun]; #ifdef _LOGGING @@ -2343,9 +2410,9 @@ zip_read_from_dma(zip_t *dev) int ret = 0; if (dev->drv->bus_type == ZIP_BUS_SCSI) - ret = zip_read_from_scsi_dma(sd, dev->drv->bus_id.scsi.id); + ret = read_from_scsi_dma(sd, dev->drv->bus_id.scsi.id); else - ret = zip_read_from_ide_dma(dev); + ret = read_from_ide_dma(dev); if (ret != 1) return ret; @@ -2355,46 +2422,47 @@ zip_read_from_dma(zip_t *dev) else DEBUG("ZIP %i: ATAPI Input data length: %i\n", dev->id, dev->packet_len); - ret = zip_phase_data_out(dev); + ret = phase_data_out(dev); if (ret) return 1; - else - return 0; + + return 0; } static int -zip_write_to_ide_dma(zip_t *dev) +write_to_ide_dma(zip_t *dev) { int ret; - if (!dev) + if (dev == NULL) return 0; if (ide_bus_master_read) { ret = ide_bus_master_read(dev->drv->bus_id.ide_channel >> 1, dev->buffer, dev->packet_len, ide_bus_master_priv[dev->drv->bus_id.ide_channel >> 1]); - if (ret == 2) /* DMA not enabled, wait for it to be enabled. */ + if (ret == 2) /* DMA not enabled, wait for it to be.. */ return 2; - else if (ret == 1) { /* DMA error. */ - zip_bus_master_error(dev); + if (ret == 1) { /* DMA error */ + bus_master_error(dev); return 0; - } else - return 1; - } else - return 0; + } + return 1; + } + + return 0; } static int -zip_write_to_scsi_dma(scsi_device_t *sd, UNUSED(uint8_t scsi_id)) +write_to_scsi_dma(scsi_device_t *sd, UNUSED(uint8_t scsi_id)) { zip_t *dev = (zip_t *)sd->p; int32_t BufLen = sd->buffer_length; - if (!dev) + if (dev == NULL) return 0; DEBUG("Writing to SCSI DMA: SCSI ID %02X, init length %i\n", scsi_id, BufLen); @@ -2407,7 +2475,7 @@ zip_write_to_scsi_dma(scsi_device_t *sd, UNUSED(uint8_t scsi_id)) static int -zip_write_to_dma(zip_t *dev) +write_to_dma(zip_t *dev) { scsi_device_t *sd = &scsi_devices[dev->drv->bus_id.scsi.id][dev->drv->bus_id.scsi.lun]; #ifdef _LOGGING @@ -2417,9 +2485,9 @@ zip_write_to_dma(zip_t *dev) if (dev->drv->bus_type == ZIP_BUS_SCSI) { DEBUG("Write to SCSI DMA: (ID %02X)\n", dev->drv->bus_id.scsi.id); - ret = zip_write_to_scsi_dma(sd, dev->drv->bus_id.scsi.id); + ret = write_to_scsi_dma(sd, dev->drv->bus_id.scsi.id); } else - ret = zip_write_to_ide_dma(dev); + ret = write_to_ide_dma(dev); if (dev->drv->bus_type == ZIP_BUS_SCSI) DEBUG("ZIP %i: SCSI Output data length: %i\n", dev->id, BufLen); @@ -2433,7 +2501,7 @@ zip_write_to_dma(zip_t *dev) static void zip_callback(void *p) { - zip_t *dev = (zip_t *) p; + zip_t *dev = (zip_t *)p; int ret; switch(dev->packet_status) { @@ -2443,12 +2511,14 @@ zip_callback(void *p) dev->phase = 1; dev->status = READY_STAT | DRQ_STAT | (dev->status & ERR_STAT); return; + case PHASE_COMMAND: DEBUG("ZIP %i: PHASE_COMMAND\n", dev->id); dev->status = BUSY_STAT | (dev->status & ERR_STAT); memcpy(dev->atapi_cdb, dev->buffer, 12); zip_command(dev, dev->atapi_cdb); return; + case PHASE_COMPLETE: DEBUG("ZIP %i: PHASE_COMPLETE\n", dev->id); dev->status = READY_STAT; @@ -2457,26 +2527,28 @@ zip_callback(void *p) ui_sb_icon_update(SB_ZIP | dev->id, 0); zip_irq_raise(dev); return; + case PHASE_DATA_OUT: DEBUG("ZIP %i: PHASE_DATA_OUT\n", dev->id); dev->status = READY_STAT | DRQ_STAT | (dev->status & ERR_STAT); dev->phase = 0; zip_irq_raise(dev); return; + case PHASE_DATA_OUT_DMA: DEBUG("ZIP %i: PHASE_DATA_OUT_DMA\n", dev->id); - ret = zip_read_from_dma(dev); + ret = read_from_dma(dev); if ((ret == 1) || (dev->drv->bus_type == ZIP_BUS_SCSI)) { DEBUG("ZIP %i: DMA data out phase done\n"); - zip_buf_free(dev); - zip_command_complete(dev); + buf_free(dev); + command_complete(dev); } else if (ret == 2) { DEBUG("ZIP %i: DMA out not enabled, wait\n"); - zip_command_bus(dev); + command_bus(dev); } else { DEBUG("ZIP %i: DMA data out phase failure\n"); - zip_buf_free(dev); + buf_free(dev); } return; case PHASE_DATA_IN: @@ -2485,22 +2557,24 @@ zip_callback(void *p) dev->phase = 2; zip_irq_raise(dev); return; + case PHASE_DATA_IN_DMA: DEBUG("ZIP %i: PHASE_DATA_IN_DMA\n", dev->id); - ret = zip_write_to_dma(dev); + ret = write_to_dma(dev); if ((ret == 1) || (dev->drv->bus_type == ZIP_BUS_SCSI)) { DEBUG("ZIP %i: DMA data in phase done\n", dev->id); - zip_buf_free(dev); - zip_command_complete(dev); + buf_free(dev); + command_complete(dev); } else if (ret == 2) { DEBUG("ZIP %i: DMA in not enabled, wait\n", dev->id); - zip_command_bus(dev); + command_bus(dev); } else { DEBUG("ZIP %i: DMA data in phase failure\n", dev->id); - zip_buf_free(dev); + buf_free(dev); } return; + case PHASE_ERROR: DEBUG("ZIP %i: PHASE_ERROR\n", dev->id); dev->status = READY_STAT | ERR_STAT; @@ -2514,23 +2588,18 @@ zip_callback(void *p) static uint32_t -zip_packet_read(void *p, int length) +packet_read(void *p, int length) { zip_t *dev = (zip_t *) p; - uint16_t *zipbufferw; uint32_t *zipbufferl; - uint32_t temp = 0; - if (!dev) + if ((dev == NULL) || (dev->buffer == NULL)) return 0; - zipbufferw = (uint16_t *) dev->buffer; - zipbufferl = (uint32_t *) dev->buffer; - - if (!dev->buffer) - return 0; + zipbufferw = (uint16_t *)dev->buffer; + zipbufferl = (uint32_t *)dev->buffer; /* Make sure we return a 0 and don't attempt to read from the buffer if we're transferring bytes beyond it, which can happen when issuing media access commands with an allocated length below minimum request length @@ -2541,16 +2610,19 @@ zip_packet_read(void *p, int length) dev->pos++; dev->request_pos++; break; + case 2: temp = (dev->pos < dev->packet_len) ? zipbufferw[dev->pos >> 1] : 0; dev->pos += 2; dev->request_pos += 2; break; + case 4: temp = (dev->pos < dev->packet_len) ? zipbufferl[dev->pos >> 2] : 0; dev->pos += 4; dev->request_pos += 4; break; + default: return 0; } @@ -2558,52 +2630,55 @@ zip_packet_read(void *p, int length) if (dev->packet_status == PHASE_DATA_IN) { if ((dev->request_pos >= dev->max_transfer_len) || (dev->pos >= dev->packet_len)) { /* Time for a DRQ. */ - zip_pio_request(dev, 0); + pio_request(dev, 0); } return temp; - } else - return 0; + } + + return 0; } static void -zip_packet_write(void *p, uint32_t val, int length) +packet_write(void *p, uint32_t val, int length) { zip_t *dev = (zip_t *) p; - uint16_t *zipbufferw; uint32_t *zipbufferl; - if (!dev) + if (dev == NULL) return; if (dev->packet_status == PHASE_IDLE) { - if (!dev->buffer) - zip_buf_alloc(dev, 12); + if (dev->buffer == NULL) + buf_alloc(dev, 12); } - zipbufferw = (uint16_t *) dev->buffer; - zipbufferl = (uint32_t *) dev->buffer; - - if (!dev->buffer) + if (dev->buffer == NULL) return; + zipbufferw = (uint16_t *)dev->buffer; + zipbufferl = (uint32_t *)dev->buffer; + switch(length) { case 1: dev->buffer[dev->pos] = val & 0xff; dev->pos++; dev->request_pos++; break; + case 2: zipbufferw[dev->pos >> 1] = val & 0xffff; dev->pos += 2; dev->request_pos += 2; break; + case 4: zipbufferl[dev->pos >> 2] = val; dev->pos += 4; dev->request_pos += 4; break; + default: return; } @@ -2611,10 +2686,12 @@ zip_packet_write(void *p, uint32_t val, int length) if (dev->packet_status == PHASE_DATA_OUT) { if ((dev->request_pos >= dev->max_transfer_len) || (dev->pos >= dev->packet_len)) { /* Time for a DRQ. */ - zip_pio_request(dev, 1); + pio_request(dev, 1); } return; - } else if (dev->packet_status == PHASE_IDLE) { + } + + if (dev->packet_status == PHASE_IDLE) { if (dev->pos >= 12) { dev->pos = 0; dev->status = BUSY_STAT; @@ -2623,7 +2700,6 @@ zip_packet_write(void *p, uint32_t val, int length) zip_callback((void *) dev); timer_update_outstanding(); } - return; } } @@ -2659,7 +2735,7 @@ zip_250_identify(ide_t *ide, int ide_has_dma) static int -zip_get_max(int ide_has_dma, int type) +get_max(int ide_has_dma, int type) { int ret = -1; @@ -2686,7 +2762,7 @@ zip_get_max(int ide_has_dma, int type) static int -zip_get_timings(int ide_has_dma, int type) +get_timings(int ide_has_dma, int type) { int ret = 0; @@ -2745,16 +2821,16 @@ zip_init(zip_t *dev) dev->drv->bus_mode |= 1; DEBUG("ZIP %i: Bus type %i, bus mode %i\n", dev->id, dev->drv->bus_type, dev->drv->bus_mode); if (dev->drv->bus_type < ZIP_BUS_SCSI) - zip_set_signature(dev); + set_signature(dev); dev->status = READY_STAT | DSC_STAT; dev->pos = 0; dev->packet_status = 0xff; - zip_sense_key = zip_asc = zip_ascq = dev->unit_attention = 0; + dev->sense[2] = dev->sense[12] = dev->sense[13] = dev->unit_attention = 0; } static void -zip_drive_reset(int c) +drive_reset(int c) { scsi_device_t *sd; zip_t *dev; @@ -2769,35 +2845,40 @@ zip_drive_reset(int c) dev->id = c; dev->drv = &zip_drives[c]; - if (zip_drives[c].bus_type == ZIP_BUS_SCSI) { - /* SCSI ZIP, attach to the SCSI bus. */ - sd = &scsi_devices[zip_drives[c].bus_id.scsi.id][zip_drives[c].bus_id.scsi.lun]; + switch (zip_drives[c].bus_type) { + case ZIP_BUS_SCSI: + sd = &scsi_devices[zip_drives[c].bus_id.scsi.id][zip_drives[c].bus_id.scsi.lun]; - sd->p = dev; - sd->command = zip_command; - sd->callback = zip_callback; - sd->err_stat_to_scsi = zip_err_stat_to_scsi; - sd->request_sense = zip_request_sense_for_scsi; - sd->reset = zip_reset; - sd->read_capacity = zip_read_capacity; - sd->type = SCSI_REMOVABLE_DISK; + sd->p = dev; + sd->command = zip_command; + sd->callback = zip_callback; + sd->err_stat_to_scsi = err_stat_to_scsi; + sd->request_sense = request_sense_scsi; + sd->reset = zip_reset; + sd->read_capacity = read_capacity; + sd->type = SCSI_REMOVABLE_DISK; + + DEBUG("SCSI ZIP drive %i attached to SCSI ID %i\n", + c, dev->drv->bus_id.scsi.id); + break; + + case ZIP_BUS_ATAPI: + id = ide_drives[zip_drives[c].bus_id.ide_channel]; + + /* + * If the IDE channel is initialized, we attach to it, + * otherwise, we do nothing - it's going to be a drive + * that's not attached to anything. + */ + if (id == NULL) break; - DEBUG("SCSI ZIP drive %i attached to SCSI ID %i\n", - c, dev->drv->bus_id.scsi.id); - } else if (zip_drives[c].bus_type == ZIP_BUS_ATAPI) { - /* ATAPI CD-ROM, attach to the IDE bus. */ - id = ide_drives[zip_drives[c].bus_id.ide_channel]; - /* If the IDE channel is initialized, we attach to it, - otherwise, we do nothing - it's going to be a drive - that's not attached to anything. */ - if (id != NULL) { id->p = dev; - id->get_max = zip_get_max; - id->get_timings = zip_get_timings; + id->get_max = get_max; + id->get_timings = get_timings; id->identify = zip_identify; - id->set_signature = zip_set_signature; - id->packet_write = zip_packet_write; - id->packet_read = zip_packet_read; + id->set_signature = set_signature; + id->packet_write = packet_write; + id->packet_read = packet_read; id->stop = NULL; id->packet_callback = zip_callback; id->device_reset = zip_reset; @@ -2807,7 +2888,7 @@ zip_drive_reset(int c) DEBUG("ATAPI ZIP drive %i attached to IDE channel %i\n", c, dev->drv->bus_id.ide_channel); - } + break; } } @@ -2819,28 +2900,29 @@ zip_hard_reset(void) int c; for (c = 0; c < ZIP_NUM; c++) { - if ((zip_drives[c].bus_type == ZIP_BUS_ATAPI) || (zip_drives[c].bus_type == ZIP_BUS_SCSI)) { - DEBUG("ZIP hard_reset drive=%d\n", c); + if ((zip_drives[c].bus_type != ZIP_BUS_ATAPI) && + (zip_drives[c].bus_type == ZIP_BUS_SCSI)) continue; - /* Make sure to ignore any SCSI ZIP drive that has an out of range ID. */ - if ((zip_drives[c].bus_type == ZIP_BUS_SCSI) && (zip_drives[c].bus_id.scsi.id > SCSI_ID_MAX)) - continue; + DEBUG("ZIP hard_reset drive=%d\n", c); - /* Make sure to ignore any ATAPI ZIP drive that has an out of range IDE channel. */ - if ((zip_drives[c].bus_type == ZIP_BUS_ATAPI) && (zip_drives[c].bus_id.ide_channel > 7)) - continue; + /* Ignore any SCSI ZIP drive that has an out of range ID. */ + if ((zip_drives[c].bus_type == ZIP_BUS_SCSI) && + (zip_drives[c].bus_id.scsi.id > SCSI_ID_MAX)) continue; - zip_drive_reset(c); + /* Ignore any ATAPI ZIP drive that has an out of range IDE channel. */ + if ((zip_drives[c].bus_type == ZIP_BUS_ATAPI) && + (zip_drives[c].bus_id.ide_channel > 7)) continue; - dev = (zip_t *)zip_drives[c].priv; + drive_reset(c); - zip_init(dev); + dev = (zip_t *)zip_drives[c].priv; - if (wcslen(dev->drv->image_path)) - zip_load(dev, dev->drv->image_path); + zip_init(dev); - zip_mode_sense_load(dev); - } + if (wcslen(dev->drv->image_path)) + zip_load(dev, dev->drv->image_path); + + mode_sense_load(dev); } } @@ -2871,7 +2953,7 @@ zip_reset_bus(int bus) int i; for (i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && zip_drives[i].priv) + if ((zip_drives[i].bus_type == bus) && zip_drives[i].priv) zip_reset(zip_drives[i].priv); } } @@ -2884,12 +2966,7 @@ zip_string_to_bus(const char *str) if (! strcmp(str, "none")) return(ret); - if (! strcmp(str, "ide") || !strcmp(str, "atapi") -#if 1 - || !strcmp(str, "ide_pio_only") || !strcmp(str, "ide_pio_and_dma") - || !strcmp(str, "atapi_pio_only") || !strcmp(str, "atapi_pio_and_dma") -#endif - ) return(ZIP_BUS_ATAPI); + if (! strcmp(str, "ide") || !strcmp(str, "atapi")) return(ZIP_BUS_ATAPI); if (! strcmp(str, "scsi")) return(ZIP_BUS_SCSI); diff --git a/src/devices/disk/zip.h b/src/devices/disk/zip.h index 46ca243..ec7aef1 100644 --- a/src/devices/disk/zip.h +++ b/src/devices/disk/zip.h @@ -9,7 +9,7 @@ * Implementation of the Iomega ZIP drive with SCSI(-like) * commands, for both ATAPI and SCSI usage. * - * Version: @(#)zip.h 1.0.10 2018/10/25 + * Version: @(#)zip.h 1.0.11 2018/10/26 * * Author: Miran Grca, * @@ -44,7 +44,7 @@ #define ZIP_TIME (5LL * 100LL * (1LL << TIMER_SHIFT)) #define ZIP_SECTORS (96*2048) -#define ZIP_250_SECTORS (489532) +#define ZIP_SECTORS_250 (489532) enum { @@ -117,14 +117,6 @@ typedef struct { extern zip_drive_t zip_drives[ZIP_NUM]; -extern uint8_t atapi_zip_drives[8]; -extern uint8_t scsi_zip_drives[16][8]; - -/*FIXME: These should be removed, it makes the code unclear. --FvK */ -#define zip_sense_error dev->sense[0] -#define zip_sense_key dev->sense[2] -#define zip_asc dev->sense[12] -#define zip_ascq dev->sense[13] #ifdef __cplusplus diff --git a/src/ui/ui_new_image.c b/src/ui/ui_new_image.c index 8aa7738..bf7d0a1 100644 --- a/src/ui/ui_new_image.c +++ b/src/ui/ui_new_image.c @@ -12,7 +12,7 @@ * format handlers, and re-integrated with that code. This is * just the wrong place for it.. * - * Version: @(#)ui_new_image.c 1.0.4 2018/10/05 + * Version: @(#)ui_new_image.c 1.0.5 2018/10/26 * * Authors: Fred N. van Kempen, * Miran Grca, @@ -223,7 +223,7 @@ floppy_create_image(const wchar_t *fn, int8_t ds, int8_t is_fdi) sector_bytes = (128 << dp->sector_len); total_sectors = dp->sides * dp->tracks * dp->sectors; if (total_sectors > ZIP_SECTORS) - total_sectors = ZIP_250_SECTORS; + total_sectors = ZIP_SECTORS_250; total_size = total_sectors * sector_bytes; root_dir_bytes = (dp->root_dir_entries << 5); fat_size = (dp->spfat * sector_bytes); @@ -337,7 +337,7 @@ zip_create_image(const wchar_t *fn, int8_t ds, int8_t is_zdi) sector_bytes = (128 << dp->sector_len); total_sectors = dp->sides * dp->tracks * dp->sectors; if (total_sectors > ZIP_SECTORS) - total_sectors = ZIP_250_SECTORS; + total_sectors = ZIP_SECTORS_250; total_size = total_sectors * sector_bytes; root_dir_bytes = (dp->root_dir_entries << 5); fat_size = (dp->spfat * sector_bytes);