i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed all warnings.

Browse Source 
Renamed DPRINT() to the more common (in our codebase) TRACE().
print_sr0() is only compiled in and called if DEBUG is defined.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@6324 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2004-01-26 10:28:16 +00:00
parent fb86eb2c00
commit 6b6b3d294b
3 changed files with 234 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/drivers/arch/x86/floppy/floppy.c
+74 -44
View File
@@ -98,16 +98,20 @@ typedef struct floppy_cookie {
} floppy_cookie; } floppy_cookie;
void motor_off_daemon(void *t, int tim); static int motor_off_daemon(void *t, int tim);
status_t init_hardware(void)
status_t
init_hardware(void)
{ {
DPRINT("init_hardware()\n"); TRACE("init_hardware()\n");
/* assume there is always one */ /* assume there is always one */
return B_OK; return B_OK;
} }
status_t init_driver(void)
status_t
init_driver(void)
{ {
status_t err; status_t err;
unsigned int i, j; unsigned int i, j;
@@ -115,7 +119,7 @@ status_t init_driver(void)
uint64 cmcookie = 0; uint64 cmcookie = 0;
struct device_info info; struct device_info info;
DPRINT("init_driver()\n"); TRACE("init_driver()\n");
if ((err = get_module(B_ISA_MODULE_NAME, (module_info **)&isa)) < B_OK) { if ((err = get_module(B_ISA_MODULE_NAME, (module_info **)&isa)) < B_OK) {
dprintf(FLO "no isa module!\n"); dprintf(FLO "no isa module!\n");
return err; return err;
@@ -183,7 +187,8 @@ status_t init_driver(void)
dprintf(FLO "controller doesn't have any io ??\n"); dprintf(FLO "controller doesn't have any io ??\n");
goto config_error; goto config_error;
} }
dprintf(FLO "controller at 0x%04lx, irq %ld, dma %ld\n", master->iobase, master->irq, master->dma); dprintf(FLO "controller at 0x%04lx, irq %ld, dma %ld\n",
master->iobase, master->irq, master->dma);
//master->dma = -1; // XXX: DEBUG: disable DMA //master->dma = -1; // XXX: DEBUG: disable DMA
/* allocate resources */ /* allocate resources */
master->completion = create_sem(0, "floppy interrupt"); master->completion = create_sem(0, "floppy interrupt");
@@ -194,7 +199,9 @@ status_t init_driver(void)
// goto config_error; // goto config_error;
/* 20K should hold a full cylinder XXX: B_LOMEM for DMA ! */ /* 20K should hold a full cylinder XXX: B_LOMEM for DMA ! */
master->buffer_area = create_area("floppy cylinder buffer", &(master->buffer), B_ANY_KERNEL_ADDRESS, CYL_BUFFER_SIZE, B_FULL_LOCK, B_READ_AREA|B_WRITE_AREA); master->buffer_area = create_area("floppy cylinder buffer", (void **)&master->buffer,
B_ANY_KERNEL_ADDRESS, CYL_BUFFER_SIZE,
B_FULL_LOCK, B_READ_AREA|B_WRITE_AREA);
if (master->buffer_area < B_OK) if (master->buffer_area < B_OK)
goto config_error2; goto config_error2;
master->slock = 0; master->slock = 0;
@@ -204,7 +211,7 @@ status_t init_driver(void)
flops = count_floppies(master); /* actually a bitmap */ flops = count_floppies(master); /* actually a bitmap */
flops = MAX(flops, 1); /* XXX: assume at least one */ flops = MAX(flops, 1); /* XXX: assume at least one */
DPRINT("drives found: 0x%01x\n", flops); TRACE("drives found: 0x%01x\n", flops);
for (i = 0; current < MAX_FLOPPIES && i < 4; i++) { for (i = 0; current < MAX_FLOPPIES && i < 4; i++) {
if ((flops & (1 << i)) == 0) if ((flops & (1 << i)) == 0)
continue; continue;
@@ -249,12 +256,12 @@ config_ok:
if (floppies[i].iobase) { if (floppies[i].iobase) {
#ifdef FIRST_ONE_NO_NUMBER #ifdef FIRST_ONE_NO_NUMBER
if (!i) if (!i)
sprintf(floppy_dev_name[i], OLD_DEV_FORMAT, i); strcpy(floppy_dev_name[i], OLD_DEV_FORMAT);
else else
#endif #endif
sprintf(floppy_dev_name[i], DEV_FORMAT, i); sprintf(floppy_dev_name[i], DEV_FORMAT, i);
dev_names[j++] = floppy_dev_name[i]; dev_names[j++] = floppy_dev_name[i];
DPRINT("names[%d] = %s\n", j-1, dev_names[j-1]); TRACE("names[%d] = %s\n", j-1, dev_names[j-1]);
} else } else
strcpy(floppy_dev_name[i], ""); strcpy(floppy_dev_name[i], "");
} }
@@ -271,16 +278,18 @@ config_ok:
return B_OK; return B_OK;
} }
void uninit_driver(void)
void
uninit_driver(void)
{ {
int i; int i;
DPRINT("uninit_driver()\n"); TRACE("uninit_driver()\n");
unregister_kernel_daemon(motor_off_daemon, floppies); unregister_kernel_daemon(motor_off_daemon, floppies);
for (i = 0; i < MAX_FLOPPIES; i++) { for (i = 0; i < MAX_FLOPPIES; i++) {
if (floppies[i].iobase) if (floppies[i].iobase)
turn_off_motor(&floppies[i]); turn_off_motor(&floppies[i]);
} }
DPRINT("dealocating...\n"); TRACE("deallocating...\n");
for (i = 0; i < MAX_FLOPPIES; i++) { for (i = 0; i < MAX_FLOPPIES; i++) {
if (floppies[i].iobase) { if (floppies[i].iobase) {
if (floppies[i].master == &(floppies[i])) { if (floppies[i].master == &(floppies[i])) {
@@ -291,29 +300,35 @@ void uninit_driver(void)
} }
} }
} }
DPRINT("uninit done\n"); TRACE("uninit done\n");
put_module(B_CONFIG_MANAGER_FOR_DRIVER_MODULE_NAME); put_module(B_CONFIG_MANAGER_FOR_DRIVER_MODULE_NAME);
put_module(B_ISA_MODULE_NAME); put_module(B_ISA_MODULE_NAME);
} }
const char **publish_devices(void)
const char **
publish_devices(void)
{ {
if (dev_names[0] == NULL) if (dev_names[0] == NULL)
return NULL; return NULL;
return dev_names; return dev_names;
} }
device_hooks *find_device(const char *name)
device_hooks *
find_device(const char *name)
{ {
(void)name; (void)name;
return &floppy_hooks; return &floppy_hooks;
} }
status_t flo_open(const char *name, uint32 flags, floppy_cookie **cookie)
static status_t
flo_open(const char *name, uint32 flags, floppy_cookie **cookie)
{ {
int i; int i;
status_t err; status_t err;
DPRINT("open(%s)\n", name); TRACE("open(%s)\n", name);
if (flags & O_NONBLOCK) if (flags & O_NONBLOCK)
return EINVAL; return EINVAL;
for (i = 0; i < MAX_FLOPPIES; i++) { for (i = 0; i < MAX_FLOPPIES; i++) {
@@ -332,32 +347,39 @@ status_t flo_open(const char *name, uint32 flags, floppy_cookie **cookie)
return B_OK; return B_OK;
} }
status_t flo_close(floppy_cookie *cookie)
static status_t
flo_close(floppy_cookie *cookie)
{ {
DPRINT("close()\n"); TRACE("close()\n");
cookie->flp = NULL; cookie->flp = NULL;
return B_OK; return B_OK;
} }
status_t flo_free(floppy_cookie *cookie)
static status_t
flo_free(floppy_cookie *cookie)
{ {
DPRINT("free()\n"); TRACE("free()\n");
free(cookie); free(cookie);
return B_OK; return B_OK;
} }
status_t flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *numbytes)
static status_t
flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *numbytes)
{ {
status_t err; status_t err;
size_t len = *numbytes; size_t len = *numbytes;
size_t bytes_read = 0; size_t bytes_read = 0;
int sectsize = SECTOR_SIZE; int sectsize = SECTOR_SIZE;
int cylsize = TRACK_SIZE; /* hmm, badly named, it's actually track_size (a cylinder has 2 tracks, one per head) */ int cylsize = TRACK_SIZE; /* hmm, badly named, it's actually track_size (a cylinder has 2 tracks, one per head) */
device_geometry *geom = NULL; const device_geometry *geom = NULL;
ssize_t disk_size = 0; ssize_t disk_size = 0;
if (cookie->flp->geometry) if (cookie->flp->geometry)
geom = &(cookie->flp->geometry->g); geom = &cookie->flp->geometry->g;
if (geom) { if (geom) {
sectsize = geom->bytes_per_sector; sectsize = geom->bytes_per_sector;
cylsize = sectsize * geom->sectors_per_track/* * geom->head_count*/; cylsize = sectsize * geom->sectors_per_track/* * geom->head_count*/;
@@ -383,11 +405,11 @@ status_t flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *num
} }
// handle partial first block // handle partial first block
if((position % SECTOR_SIZE) != 0) { if ((position % SECTOR_SIZE) != 0) {
size_t toread; size_t toread;
DPRINT("read: begin %Ld, %ld\n", position, bytes_read); TRACE("read: begin %Ld, %ld\n", position, bytes_read);
err = read_sectors(cookie->flp, position / sectsize, 1); err = read_sectors(cookie->flp, position / sectsize, 1);
DPRINT("PIO READ got %d sect\n", err); TRACE("PIO READ got %d sect\n", err);
if (err <= 0) { if (err <= 0) {
*numbytes = 0; *numbytes = 0;
return err; return err;
@@ -400,12 +422,12 @@ status_t flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *num
position += toread; position += toread;
} }
// read the middle blocks // read the middle blocks
while(len >= sectsize) { while (len >= sectsize) {
DPRINT("read: middle %Ld, %ld, %ld\n", position, bytes_read, len); TRACE("read: middle %Ld, %ld, %ld\n", position, bytes_read, len);
// try to read as many sectors as we can // try to read as many sectors as we can
err = read_sectors(cookie->flp, position / sectsize, len / sectsize); err = read_sectors(cookie->flp, position / sectsize, len / sectsize);
DPRINT("PIO READ got %d sect\n", err); TRACE("PIO READ got %d sect\n", err);
if (err <= 0) { if (err <= 0) {
*numbytes = 0; *numbytes = 0;
return err; return err;
@@ -416,11 +438,11 @@ status_t flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *num
position += err * sectsize; position += err * sectsize;
} }
// handle partial last block // handle partial last block
if(len > 0 && (len % sectsize) != 0) { if (len > 0 && (len % sectsize) != 0) {
DPRINT("read: end %Ld, %ld %ld\n", position, bytes_read, len); TRACE("read: end %Ld, %ld %ld\n", position, bytes_read, len);
err = read_sectors(cookie->flp, position / sectsize, 1); err = read_sectors(cookie->flp, position / sectsize, 1);
DPRINT("PIO READ got %d sect\n", err); TRACE("PIO READ got %d sect\n", err);
if (err <= 0) { if (err <= 0) {
*numbytes = 0; *numbytes = 0;
return err; return err;
@@ -434,20 +456,24 @@ status_t flo_read(floppy_cookie *cookie, off_t position, void *data, size_t *num
return B_OK; return B_OK;
} }
status_t flo_write(floppy_cookie *cookie, off_t position, const void *data, size_t *numbytes)
static status_t
flo_write(floppy_cookie *cookie, off_t position, const void *data, size_t *numbytes)
{ {
*numbytes = 0; *numbytes = 0;
return B_ERROR; return B_ERROR;
} }
status_t flo_control(floppy_cookie *cookie, uint32 op, void *data, size_t len)
static status_t
flo_control(floppy_cookie *cookie, uint32 op, void *data, size_t len)
{ {
device_geometry *geom; device_geometry *geom;
status_t err; status_t err;
floppy_t *flp = cookie->flp; floppy_t *flp = cookie->flp;
switch (op) { switch (op) {
case B_GET_ICON: case B_GET_ICON:
DPRINT("control(B_GET_ICON, %d)\n", ((device_icon *)data)->icon_size); TRACE("control(B_GET_ICON, %d)\n", ((device_icon *)data)->icon_size);
if (((device_icon *)data)->icon_size == 16) { /* mini icon */ if (((device_icon *)data)->icon_size == 16) { /* mini icon */
memcpy(((device_icon *)data)->icon_data, floppy_mini_icon, (16*16)); memcpy(((device_icon *)data)->icon_data, floppy_mini_icon, (16*16));
return B_OK; return B_OK;
@@ -458,11 +484,11 @@ status_t flo_control(floppy_cookie *cookie, uint32 op, void *data, size_t len)
} }
return EINVAL; return EINVAL;
case B_GET_BIOS_DRIVE_ID: case B_GET_BIOS_DRIVE_ID:
DPRINT("control(B_GET_BIOS_DRIVE_ID)\n"); TRACE("control(B_GET_BIOS_DRIVE_ID)\n");
*(uint8 *)data = 0; *(uint8 *)data = 0;
return B_OK; return B_OK;
case B_GET_DEVICE_SIZE: case B_GET_DEVICE_SIZE:
DPRINT("control(B_GET_DEVICE_SIZE)\n"); TRACE("control(B_GET_DEVICE_SIZE)\n");
err = query_media(cookie->flp, true); err = query_media(cookie->flp, true);
*(size_t *)data = (flp->bgeom.bytes_per_sector) *(size_t *)data = (flp->bgeom.bytes_per_sector)
* (flp->bgeom.sectors_per_track) * (flp->bgeom.sectors_per_track)
@@ -471,7 +497,7 @@ status_t flo_control(floppy_cookie *cookie, uint32 op, void *data, size_t len)
return B_OK; return B_OK;
case B_GET_GEOMETRY: case B_GET_GEOMETRY:
case B_GET_BIOS_GEOMETRY: case B_GET_BIOS_GEOMETRY:
DPRINT("control(B_GET_(BIOS)_GEOMETRY)\n"); TRACE("control(B_GET_(BIOS)_GEOMETRY)\n");
err = query_media(cookie->flp, false); err = query_media(cookie->flp, false);
geom = (device_geometry *)data; geom = (device_geometry *)data;
geom->bytes_per_sector = flp->bgeom.bytes_per_sector; geom->bytes_per_sector = flp->bgeom.bytes_per_sector;
@@ -484,21 +510,23 @@ status_t flo_control(floppy_cookie *cookie, uint32 op, void *data, size_t len)
geom->write_once = false; geom->write_once = false;
return B_OK; return B_OK;
case B_GET_MEDIA_STATUS: case B_GET_MEDIA_STATUS:
DPRINT("control(B_GET_MEDIA_STATUS)\n"); TRACE("control(B_GET_MEDIA_STATUS)\n");
err = query_media(cookie->flp, false); err = query_media(cookie->flp, false);
*(status_t *)data = err; *(status_t *)data = err;
return B_OK; return B_OK;
} }
DPRINT("control(%ld)\n", op); TRACE("control(%ld)\n", op);
return EINVAL; return EINVAL;
} }
void motor_off_daemon(void *t, int tim)
static int
motor_off_daemon(void *t, int tim)
{ {
int i; int i;
for (i = 0; i < MAX_FLOPPIES; i++) { for (i = 0; i < MAX_FLOPPIES; i++) {
if (floppies[i].iobase && !floppies[i].pending_cmd && floppies[i].motor_timeout > 0) { if (floppies[i].iobase && !floppies[i].pending_cmd && floppies[i].motor_timeout > 0) {
DPRINT("floppies[%d].motor_timeout = %ld\n", i, floppies[i].motor_timeout); TRACE("floppies[%d].motor_timeout = %ld\n", i, floppies[i].motor_timeout);
if (atomic_add(&floppies[i].motor_timeout, -500000) <= 500000) { if (atomic_add(&floppies[i].motor_timeout, -500000) <= 500000) {
dprintf("turning off motor for drive %d\n", floppies[i].drive_num); dprintf("turning off motor for drive %d\n", floppies[i].drive_num);
turn_off_motor(&floppies[i]); turn_off_motor(&floppies[i]);
@@ -506,8 +534,10 @@ void motor_off_daemon(void *t, int tim)
} }
} }
} }
return 0;
} }
device_hooks floppy_hooks = { device_hooks floppy_hooks = {
(device_open_hook)flo_open, (device_open_hook)flo_open,
(device_close_hook)flo_close, (device_close_hook)flo_close,
src/add-ons/kernel/drivers/arch/x86/floppy/floppy.h
+4 -4
View File
@@ -13,10 +13,10 @@
#include "lock.h" #include "lock.h"
#define FLO "floppy: " #define FLO "floppy: "
#if DEBUG > 0 #if defined(DEBUG) && DEBUG > 0
#define DPRINT(x...) dprintf(FLO x) # define TRACE(x...) dprintf(FLO x)
#else #else
#define DPRINT(x...) # define TRACE(x...)
#endif #endif
#define MOTOR_TIMEOUT 5000000 // 5 seconds #define MOTOR_TIMEOUT 5000000 // 5 seconds
@@ -212,4 +212,4 @@ extern status_t query_media(floppy_t *flp, bool forceupdate);
extern ssize_t read_sectors(floppy_t *flp, int lba, int num_sectors); extern ssize_t read_sectors(floppy_t *flp, int lba, int num_sectors);
#endif #endif /* _FLOPPY_H */
src/add-ons/kernel/drivers/arch/x86/floppy/floppy_ctrl.c
+140 -89
View File
@@ -8,11 +8,20 @@
#include <Drivers.h> #include <Drivers.h>
#include "floppy.h" #include "floppy.h"
/* VERY verbose... */ /* VERY verbose... */
//#define DEBUG_LOWLEVEL //#define DEBUG_LOWLEVEL
// debug #if defined(DEBUG) && DEBUG > 0
void PRINT_SR0(uint8 sr0) # define PRINT_SR0(x) print_sr0(x)
#else
# define PRINT_SR0(x) ;
#endif
#if defined(DEBUG) && DEBUG > 0
static void
print_sr0(uint8 sr0)
{ {
const char *result = "ok"; const char *result = "ok";
switch (sr0 & FDC_SR0_IC) { switch (sr0 & FDC_SR0_IC) {
@@ -27,13 +36,16 @@ void PRINT_SR0(uint8 sr0)
break; break;
} }
DPRINT("sr0: ds %d, hs %d, ec %d, se %d, %s\n", (sr0 & FDC_SR0_DS), !!(sr0 & FDC_SR0_HS), !!(sr0 & FDC_SR0_EC), !!(sr0 & FDC_SR0_SE), result); TRACE("sr0: ds %d, hs %d, ec %d, se %d, %s\n", (sr0 & FDC_SR0_DS), !!(sr0 & FDC_SR0_HS), !!(sr0 & FDC_SR0_EC), !!(sr0 & FDC_SR0_SE), result);
} }
#endif
void write_reg(floppy_t *flp, floppy_reg_selector selector, uint8 data)
void
write_reg(floppy_t *flp, floppy_reg_selector selector, uint8 data)
{ {
#ifdef DEBUG_LOWLEVEL #ifdef DEBUG_LOWLEVEL
DPRINT("write to 0x%lx, data 0x%x\n", flp->iobase + selector, data); TRACE("write to 0x%lx, data 0x%x\n", flp->iobase + selector, data);
#endif #endif
flp->isa->write_io_8(flp->iobase + selector, data); flp->isa->write_io_8(flp->iobase + selector, data);
} }
@@ -43,17 +55,19 @@ uint8 read_reg(floppy_t *flp, floppy_reg_selector selector)
uint8 data; uint8 data;
data = flp->isa->read_io_8(flp->iobase + selector); data = flp->isa->read_io_8(flp->iobase + selector);
#ifdef DEBUG_LOWLEVEL #ifdef DEBUG_LOWLEVEL
DPRINT("read from 0x%lx = 0x%x\n", flp->iobase + selector, data); TRACE("read from 0x%lx = 0x%x\n", flp->iobase + selector, data);
#endif #endif
return data; return data;
} }
void reset_controller(floppy_t *master)
void
reset_controller(floppy_t *master)
{ {
uint8 command[4]; /* for SPECIFY & CONFIGURE */ uint8 command[4]; /* for SPECIFY & CONFIGURE */
uint8 result[1]; /* for SPECIFY */ uint8 result[1]; /* for SPECIFY */
DPRINT("reset_controller()\n"); TRACE("reset_controller()\n");
LOCK(master->ben); LOCK(master->ben);
//master->pending_cmd = CMD_RESET; //master->pending_cmd = CMD_RESET;
@@ -84,8 +98,10 @@ void reset_controller(floppy_t *master)
UNLOCK(master->ben); UNLOCK(master->ben);
} }
/* returns a bitmap of the present drives */ /* returns a bitmap of the present drives */
int count_floppies(floppy_t *master) int
count_floppies(floppy_t *master)
{ {
int i, err; int i, err;
int flops = 0; int flops = 0;
@@ -100,13 +116,13 @@ int count_floppies(floppy_t *master)
for (i = 0; i < MAX_DRIVES_PER_CTRL; i++) { for (i = 0; i < MAX_DRIVES_PER_CTRL; i++) {
master->drive_num = i; /* fake */ master->drive_num = i; /* fake */
DPRINT("DETECTING DRIVE %d...\n", i); TRACE("DETECTING DRIVE %d...\n", i);
turn_on_motor(master); turn_on_motor(master);
drive_select(master); drive_select(master);
err = recalibrate_drive(master); err = recalibrate_drive(master);
if (err == 0) if (err == 0)
flops |= 1 << i; flops |= 1 << i;
DPRINT("DRIVE %d %s\n", i, err?"NOT here":"is here"); TRACE("DRIVE %d %s\n", i, err?"NOT here":"is here");
drive_deselect(master); drive_deselect(master);
//snooze(50000); //snooze(50000);
//turn_off_motor(master); //turn_off_motor(master);
@@ -118,12 +134,14 @@ int count_floppies(floppy_t *master)
return flops; return flops;
} }
/* selects the drive until deselect(), takes the benaphore */ /* selects the drive until deselect(), takes the benaphore */
void drive_select(floppy_t *flp) void
drive_select(floppy_t *flp)
{ {
cpu_status st; cpu_status st;
uint8 reg; uint8 reg;
DPRINT("drive_select(%d)\n", flp->drive_num); TRACE("drive_select(%d)\n", flp->drive_num);
LOCK(flp->master->ben); LOCK(flp->master->ben);
/* must be atomic to not change motor states! */ /* must be atomic to not change motor states! */
@@ -147,19 +165,23 @@ void drive_select(floppy_t *flp)
flp->master->current = flp->drive_num; flp->master->current = flp->drive_num;
} }
void drive_deselect(floppy_t *flp)
void
drive_deselect(floppy_t *flp)
{ {
UNLOCK(flp->master->ben); UNLOCK(flp->master->ben);
DPRINT("drive_deselect(%d)\n", flp->drive_num); TRACE("drive_deselect(%d)\n", flp->drive_num);
} }
void turn_on_motor(floppy_t *flp)
void
turn_on_motor(floppy_t *flp)
{ {
cpu_status st; cpu_status st;
uint8 reg; uint8 reg;
bool do_snooze = false; bool do_snooze = false;
DPRINT("turn_on_motor(%d)\n", flp->drive_num); TRACE("turn_on_motor(%d)\n", flp->drive_num);
flp->motor_timeout = MOTOR_TIMEOUT; flp->motor_timeout = MOTOR_TIMEOUT;
/* must be atomic to not deselect a drive! */ /* must be atomic to not deselect a drive! */
@@ -181,10 +203,12 @@ void turn_on_motor(floppy_t *flp)
snooze(MOTOR_SPINUP_DELAY); snooze(MOTOR_SPINUP_DELAY);
} }
void turn_off_motor(floppy_t *flp)
void
turn_off_motor(floppy_t *flp)
{ {
cpu_status st; cpu_status st;
DPRINT("turn_off_motor(%d)\n", flp->drive_num); TRACE("turn_off_motor(%d)\n", flp->drive_num);
/* must be atomic to not deselect a drive! */ /* must be atomic to not deselect a drive! */
st = disable_interrupts(); st = disable_interrupts();
@@ -199,12 +223,16 @@ void turn_off_motor(floppy_t *flp)
restore_interrupts(st); restore_interrupts(st);
} }
void wait_for_rqm(floppy_t *flp)
void
wait_for_rqm(floppy_t *flp)
{ {
while((read_reg(flp, MAIN_STATUS) & 0x80) == 0); while ((read_reg(flp, MAIN_STATUS) & 0x80) == 0);
} }
int send_command(floppy_t *flp, const uint8 *data, int len)
int
send_command(floppy_t *flp, const uint8 *data, int len)
{ {
int i, status; int i, status;
@@ -227,20 +255,22 @@ int send_command(floppy_t *flp, const uint8 *data, int len)
write_reg(flp, DATA, data[i]); write_reg(flp, DATA, data[i]);
} }
#ifdef DEBUG_LOWLEVEL #ifdef DEBUG_LOWLEVEL
DPRINT("sent %d B\n", i); TRACE("sent %d B\n", i);
#endif #endif
return i; return i;
} }
int wait_result(floppy_t *flp) {
int
wait_result(floppy_t *flp) {
status_t err; status_t err;
{ int32 c; get_sem_count(flp->completion, &c); DPRINT("SEM< %ld\n", c); } { int32 c; get_sem_count(flp->completion, &c); TRACE("SEM< %ld\n", c); }
if ((err = acquire_sem_etc(flp->completion, 1, B_TIMEOUT, FLOPPY_CMD_TIMEOUT)) < B_OK) { if ((err = acquire_sem_etc(flp->completion, 1, B_TIMEOUT, FLOPPY_CMD_TIMEOUT)) < B_OK) {
if (err == B_TIMED_OUT) { if (err == B_TIMED_OUT) {
cpu_status st; cpu_status st;
DPRINT("timed out! faking intr !!\n"); TRACE("timed out! faking intr !!\n");
st = disable_interrupts(); st = disable_interrupts();
flo_intr(flp); flo_intr(flp);
restore_interrupts(st); restore_interrupts(st);
@@ -248,11 +278,13 @@ int wait_result(floppy_t *flp) {
} }
return -1; return -1;
} }
{ int32 c; get_sem_count(flp->completion, &c); DPRINT("SEM> %ld\n", c); } { int32 c; get_sem_count(flp->completion, &c); TRACE("SEM> %ld\n", c); }
return 0; return 0;
} }
int read_result(floppy_t *flp, uint8 *data, int len)
int
read_result(floppy_t *flp, uint8 *data, int len)
{ {
int i, status; int i, status;
@@ -266,47 +298,52 @@ int read_result(floppy_t *flp, uint8 *data, int len)
} }
//flp->master->need_reset = 1; //flp->master->need_reset = 1;
#ifdef DEBUG_LOWLEVEL #ifdef DEBUG_LOWLEVEL
DPRINT("read %d B\n", i); TRACE("read %d B\n", i);
#endif #endif
return i; return i;
} }
int wait_til_ready(floppy_t *flp)
int
wait_til_ready(floppy_t *flp)
{ {
int i, status; int i, status;
for (i = 0; i < 1000; i++) for (i = 0; i < 1000; i++)
if ((status = read_reg(flp, MAIN_STATUS)) & 0x80) if ((status = read_reg(flp, MAIN_STATUS)) & 0x80)
return status; return status;
DPRINT("timeout waiting for %d !\n", flp->drive_num); TRACE("timeout waiting for %d !\n", flp->drive_num);
return -1; return -1;
} }
int has_drive_changed(floppy_t *flp) #if 0
static int
has_drive_changed(floppy_t *flp)
{ {
return !!(read_reg(flp, DIGITAL_IN) & 0x80); return !!(read_reg(flp, DIGITAL_IN) & 0x80);
} }
#endif
status_t query_media(floppy_t *flp, bool forceupdate) status_t
query_media(floppy_t *flp, bool forceupdate)
{ {
status_t err = B_OK; status_t err = B_OK;
uint8 command[4]; uint8 command[4];
uint8 result[7]; uint8 result[7];
const floppy_geometry *geom = NULL; const floppy_geometry *geom = NULL;
TRACE("query_media(%d, %s)\n", flp->drive_num, forceupdate?"true":"false");
DPRINT("query_media(%d, %s)\n", flp->drive_num, forceupdate?"true":"false");
turn_on_motor(flp); turn_on_motor(flp);
drive_select(flp); drive_select(flp);
if (read_reg(flp, DIGITAL_IN) & 0x80) {/* media changed */ if (read_reg(flp, DIGITAL_IN) & 0x80) {/* media changed */
flp->status = FLOP_MEDIA_CHANGED; flp->status = FLOP_MEDIA_CHANGED;
DPRINT("media changed\n"); TRACE("media changed\n");
} }
if (err || (flp->status < FLOP_MEDIA_UNREADABLE) || forceupdate) { if (err || (flp->status < FLOP_MEDIA_UNREADABLE) || forceupdate) {
geom = supported_geometries; geom = supported_geometries;
DPRINT("querying format [err %08lx, st %d, fu %s]\n", err, flp->status, forceupdate?"t":"f"); TRACE("querying format [err %08lx, st %d, fu %s]\n", err, flp->status, forceupdate?"t":"f");
/* zero the current geometry */ /* zero the current geometry */
flp->geometry = 0; flp->geometry = 0;
@@ -322,11 +359,11 @@ status_t query_media(floppy_t *flp, bool forceupdate)
send_command(flp, command, 2); send_command(flp, command, 2);
read_result(flp, result, 1); read_result(flp, result, 1);
DPRINT("sense_drive(%d): wp %d, trk0 %d, hd %d, drivesel %d\n", flp->drive_num, !!(result[0]&0x40), !!(result[0]&0x10), !!(result[0]&0x04), (result[0]&0x03)); TRACE("sense_drive(%d): wp %d, trk0 %d, hd %d, drivesel %d\n", flp->drive_num, !!(result[0]&0x40), !!(result[0]&0x10), !!(result[0]&0x04), (result[0]&0x03));
flp->bgeom.read_only = !!(result[0]&0x40); flp->bgeom.read_only = !!(result[0]&0x40);
for (; geom->numsectors; geom++) { for (; geom->numsectors; geom++) {
DPRINT("trying geometry %s\n", geom->name); TRACE("trying geometry %s\n", geom->name);
/* apply geometry parameters */ /* apply geometry parameters */
if (flp->master->data_rate != geom->data_rate) { if (flp->master->data_rate != geom->data_rate) {
@@ -339,7 +376,7 @@ status_t query_media(floppy_t *flp, bool forceupdate)
command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0 command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0
command[2] = 0x00; // track 0 command[2] = 0x00; // track 0
DPRINT("SEEK at track 0 head 0\n"); TRACE("SEEK at track 0 head 0\n");
send_command(flp, command, 3); send_command(flp, command, 3);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
continue; continue;
@@ -352,23 +389,23 @@ status_t query_media(floppy_t *flp, bool forceupdate)
//read_result(flp, result, 2); // read the result //read_result(flp, result, 2); // read the result
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("track is %d\n", flp->result[1]); TRACE("track is %d\n", flp->result[1]);
if (flp->result[0] & FDC_SR0_IC) if (flp->result[0] & FDC_SR0_IC)
continue; continue;
command[0] = 0x0a | ((geom->flags&FL_MFM)?0x40:0); // read track id command[0] = 0x0a | ((geom->flags&FL_MFM)?0x40:0); // read track id
command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0 command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0
DPRINT("READ_TRACK_ID\n"); TRACE("READ_TRACK_ID\n");
send_command(flp, command, 2); send_command(flp, command, 2);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
continue; continue;
//read_result(flp, result, 7); //read_result(flp, result, 7);
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("sr1: %02x\n", flp->result[1]); TRACE("sr1: %02x\n", flp->result[1]);
DPRINT("sr2: %02x\n", flp->result[2]); TRACE("sr2: %02x\n", flp->result[2]);
DPRINT("read id: track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]); TRACE("read id: track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]);
if (flp->result[0] & FDC_SR0_IC) if (flp->result[0] & FDC_SR0_IC)
continue; continue;
@@ -377,7 +414,7 @@ status_t query_media(floppy_t *flp, bool forceupdate)
command[1] = (flp->drive_num & 0x03) | 0x04; // drive | head 1 command[1] = (flp->drive_num & 0x03) | 0x04; // drive | head 1
command[2] = 0x02; // track 2 command[2] = 0x02; // track 2
DPRINT("SEEK at track 2 head 1\n"); TRACE("SEEK at track 2 head 1\n");
send_command(flp, command, 3); send_command(flp, command, 3);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
continue; continue;
@@ -387,14 +424,14 @@ status_t query_media(floppy_t *flp, bool forceupdate)
//read_result(flp, result, 2); // read the result //read_result(flp, result, 2); // read the result
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("track is %d\n", flp->result[1]); TRACE("track is %d\n", flp->result[1]);
if (flp->result[0] & FDC_SR0_IC) if (flp->result[0] & FDC_SR0_IC)
continue; continue;
command[0] = 0x0a | ((geom->flags&FL_MFM)?0x40:0); // read track id command[0] = 0x0a | ((geom->flags&FL_MFM)?0x40:0); // read track id
command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0 command[1] = (flp->drive_num & 0x03) | 0x00; // drive | head 0
DPRINT("READ_TRACK_ID\n"); TRACE("READ_TRACK_ID\n");
send_command(flp, command, 2); send_command(flp, command, 2);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
continue; continue;
@@ -403,9 +440,9 @@ status_t query_media(floppy_t *flp, bool forceupdate)
//read_result(flp, result, 7); //read_result(flp, result, 7);
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("sr1: %02x\n", flp->result[1]); TRACE("sr1: %02x\n", flp->result[1]);
DPRINT("sr2: %02x\n", flp->result[2]); TRACE("sr2: %02x\n", flp->result[2]);
DPRINT("read id: track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]); TRACE("read id: track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]);
if (flp->result[0] & FDC_SR0_IC) if (flp->result[0] & FDC_SR0_IC)
continue; continue;
@@ -446,17 +483,18 @@ status_t query_media(floppy_t *flp, bool forceupdate)
return err; return err;
} }
int recalibrate_drive(floppy_t *flp)
int
recalibrate_drive(floppy_t *flp)
{ {
int retry; int retry;
DPRINT("recalibrate_drive(%d)\n", flp->drive_num); TRACE("recalibrate_drive(%d)\n", flp->drive_num);
turn_on_motor(flp); turn_on_motor(flp);
for(retry = 0; retry < 1; retry++) { for(retry = 0; retry < 1; retry++) {
uint8 command[2] = { 7, 0 }; // recalibrate command uint8 command[2] = { 7, 0 }; // recalibrate command
uint8 result[2];
command[1] = flp->drive_num & 0x03; command[1] = flp->drive_num & 0x03;
// send the recalibrate command // send the recalibrate command
@@ -471,10 +509,10 @@ int recalibrate_drive(floppy_t *flp)
// read the result // read the result
//read_result(flp, result, sizeof(result)); //read_result(flp, result, sizeof(result));
if (flp->result[0] & 0xd0) { if (flp->result[0] & 0xd0) {
DPRINT("recalibration failed\n"); TRACE("recalibration failed\n");
return 2; return 2;
} if (flp->result[1] != 0) { } if (flp->result[1] != 0) {
DPRINT("drive is at cylinder %d, didn't make it to 0\n", result[1]); TRACE("drive is at cylinder %d, didn't make it to 0\n", result[1]);
if (retry > 3) if (retry > 3)
return 1; return 1;
} else { } else {
@@ -483,11 +521,13 @@ int recalibrate_drive(floppy_t *flp)
} }
} }
DPRINT("recalibration done\n"); TRACE("recalibration done\n");
return 0; return 0;
} }
int32 flo_intr(void *arg)
int32
flo_intr(void *arg)
{ {
int i; int i;
int len; int len;
@@ -505,7 +545,7 @@ int32 flo_intr(void *arg)
uint8 msr; uint8 msr;
int got = 0; int got = 0;
msr = read_reg(flp, MAIN_STATUS); msr = read_reg(flp, MAIN_STATUS);
//DPRINT("got irq for %d! MSR=%02x\n", flp->drive_num, msr); //TRACE("got irq for %d! MSR=%02x\n", flp->drive_num, msr);
if ((((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_READD) || if ((((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_READD) ||
((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_READTRK)) && ((msr & 0x60) == 0x60)) { ((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_READTRK)) && ((msr & 0x60) == 0x60)) {
/* non DMA xfer(data) & need read */ /* non DMA xfer(data) & need read */
@@ -515,7 +555,7 @@ int32 flo_intr(void *arg)
len = read_result(flp, flp->result, 2); len = read_result(flp, flp->result, 2);
PRINT_SR0(flp->result[0]);*/ PRINT_SR0(flp->result[0]);*/
//DPRINT("READi\n"); //TRACE("READi\n");
// while ((msr & 0x60) == 0x60 /*&& (got < 256)*/) { // while ((msr & 0x60) == 0x60 /*&& (got < 256)*/) {
while ((msr & 0xF0) == 0xF0 && (master->buffer_index < CYL_BUFFER_SIZE)) { while ((msr & 0xF0) == 0xF0 && (master->buffer_index < CYL_BUFFER_SIZE)) {
master->buffer[master->buffer_index++] = read_reg(flp, DATA); master->buffer[master->buffer_index++] = read_reg(flp, DATA);
@@ -524,16 +564,16 @@ int32 flo_intr(void *arg)
got++; got++;
// spin(10); // spin(10);
/* if (got < 30) /* if (got < 30)
DPRINT("%02x", msr); TRACE("%02x", msr);
else else
spin(15);*/ spin(15);*/
// if (got > 255) // if (got > 255)
// break; // break;
} }
// DPRINT("intr: READ %d\n", got); // TRACE("intr: READ %d\n", got);
} else if (((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_WRITED) && ((msr & 0x60) == 0x20)) { } else if (((flp->pending_cmd & CMD_SWITCH_MASK) == CMD_WRITED) && ((msr & 0x60) == 0x20)) {
/* non DMA xfer(data) & need write */ /* non DMA xfer(data) & need write */
DPRINT("WRITEi\n"); TRACE("WRITEi\n");
} else { } else {
len = 8; len = 8;
@@ -542,11 +582,11 @@ int32 flo_intr(void *arg)
// else // else
// len = 0; // len = 0;
if (len < 0) { if (len < 0) {
DPRINT("buggy interrupt from %d !\n", flp->drive_num); TRACE("buggy interrupt from %d !\n", flp->drive_num);
} else if (len < 1) { /* must pool the interrupt reason */ } else if (len < 1) { /* must pool the interrupt reason */
uint8 command[1] = { CMD_SENSEI }; uint8 command[1] = { CMD_SENSEI };
for (i = 0; i < 4; i++) { /* might have to issue 4 SENSEI */ for (i = 0; i < 4; i++) { /* might have to issue 4 SENSEI */
DPRINT("intr: %dth SENSEI\n", i+1); TRACE("intr: %dth SENSEI\n", i+1);
if (send_command(flp, command, 1) < 1) if (send_command(flp, command, 1) < 1)
break; break;
len = read_result(flp, flp->result, 2); len = read_result(flp, flp->result, 2);
@@ -558,7 +598,7 @@ int32 flo_intr(void *arg)
break; break;
} }
} else } else
DPRINT("RES(%d) %02x %02x %02x %02x\n", len, flp->result[0], flp->result[1], flp->result[2], flp->result[3]); TRACE("RES(%d) %02x %02x %02x %02x\n", len, flp->result[0], flp->result[1], flp->result[2], flp->result[3]);
/* only do that for !READ && !WRITE */ /* only do that for !READ && !WRITE */
flp->pending_cmd = 0; flp->pending_cmd = 0;
release_sem_etc(flp->completion, 1, B_DO_NOT_RESCHEDULE); release_sem_etc(flp->completion, 1, B_DO_NOT_RESCHEDULE);
@@ -569,12 +609,13 @@ int32 flo_intr(void *arg)
release_spinlock(&master->slock); release_spinlock(&master->slock);
if (err == B_UNHANDLED_INTERRUPT) if (err == B_UNHANDLED_INTERRUPT)
DPRINT("unhandled irq!\n"); TRACE("unhandled irq!\n");
return err; return err;
} }
void floppy_dump_reg(floppy_t *flp) { void
floppy_dump_reg(floppy_t *flp) {
uint8 command[1] = { 0x0e }; // dumpreg command uint8 command[1] = { 0x0e }; // dumpreg command
//uint8 result[10]; //uint8 result[10];
uint8 *result = flp->result; uint8 *result = flp->result;
@@ -595,7 +636,9 @@ void floppy_dump_reg(floppy_t *flp) {
(result[8] & 0x20) >> 5, (result[8] & 0x10) >> 4, result[8] & 0x0f, result[9]); (result[8] & 0x20) >> 5, (result[8] & 0x10) >> 4, result[8] & 0x0f, result[9]);
} }
static void fill_command_from_lba(floppy_t *flp, floppy_command *cmd, int lba)
static void
fill_command_from_lba(floppy_t *flp, floppy_command *cmd, int lba)
{ {
cmd->cylinder = lba / (flp->bgeom.sectors_per_track * flp->bgeom.head_count); cmd->cylinder = lba / (flp->bgeom.sectors_per_track * flp->bgeom.head_count);
cmd->head = (lba / flp->bgeom.sectors_per_track) % flp->bgeom.head_count; cmd->head = (lba / flp->bgeom.sectors_per_track) % flp->bgeom.head_count;
@@ -603,13 +646,17 @@ static void fill_command_from_lba(floppy_t *flp, floppy_command *cmd, int lba)
cmd->drive = (flp->drive_num & 0x3) | (cmd->head << 2) | 0x80; /* Implied Seek */ cmd->drive = (flp->drive_num & 0x3) | (cmd->head << 2) | 0x80; /* Implied Seek */
} }
/* does NOT check for valid track number */ /* does NOT check for valid track number */
ssize_t pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors) ssize_t
pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors)
{ {
ssize_t transfered = 0; ssize_t transfered = 0;
floppy_command cmd; floppy_command cmd;
#if 0
uint8 cmd2[8]; uint8 cmd2[8];
uint8 result[4]; uint8 result[4];
#endif
//floppy_result res; //floppy_result res;
if (flp->status < FLOP_MEDIA_FORMAT_FOUND) if (flp->status < FLOP_MEDIA_FORMAT_FOUND)
@@ -638,9 +685,8 @@ ssize_t pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors)
//num_sectors = 1; //num_sectors = 1;
#if 0 #if 0
/* first issue sense interrupt, to find the current track */ /* first issue sense interrupt, to find the current track */
DPRINT("track check: SENSEI\n"); TRACE("track check: SENSEI\n");
cmd2[0] = CMD_SENSEI; cmd2[0] = CMD_SENSEI;
send_command(flp, cmd2, 1); send_command(flp, cmd2, 1);
read_result(flp, result, 2); read_result(flp, result, 2);
@@ -652,7 +698,7 @@ ssize_t pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors)
cmd2[1] = (flp->drive_num & 0x3) | (cmd.head << 2); cmd2[1] = (flp->drive_num & 0x3) | (cmd.head << 2);
cmd2[2] = cmd.cylinder; // track 0 cmd2[2] = cmd.cylinder; // track 0
DPRINT("SEEK at track %d head %d\n", cmd.cylinder, cmd.head); TRACE("SEEK at track %d head %d\n", cmd.cylinder, cmd.head);
send_command(flp, cmd2, 3); send_command(flp, cmd2, 3);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
return ENXIO; return ENXIO;
@@ -666,15 +712,14 @@ ssize_t pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors)
send_command(flp, (uint8 *)&cmd, sizeof(cmd)); send_command(flp, (uint8 *)&cmd, sizeof(cmd));
if (wait_result(flp) < 0) { if (wait_result(flp) < 0) {
drive_deselect(flp); drive_deselect(flp);
return ENXIO; return ENXIO;
} }
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("sr1: %02x\n", flp->result[1]); TRACE("sr1: %02x\n", flp->result[1]);
DPRINT("sr2: %02x\n", flp->result[2]); TRACE("sr2: %02x\n", flp->result[2]);
DPRINT("@ track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]); TRACE("@ track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]);
switch (flp->result[0] & FDC_SR0_IC) { switch (flp->result[0] & FDC_SR0_IC) {
case 0x80: case 0x80:
transfered = EINVAL; transfered = EINVAL;
@@ -700,18 +745,24 @@ ssize_t pio_read_sectors(floppy_t *flp, /*void *buf,*/ int lba, int num_sectors)
return num_sectors;//transfered; return num_sectors;//transfered;
} }
ssize_t pio_write_sectors(floppy_t *flp, /*const void *buf,*/ int lba, int num_sectors)
ssize_t
pio_write_sectors(floppy_t *flp, /*const void *buf,*/ int lba, int num_sectors)
{ {
return -1; return -1;
} }
/* does NOT check for valid track number */ /* does NOT check for valid track number */
ssize_t pio_read_track(floppy_t *flp, /*void *buf,*/ int lba) ssize_t
pio_read_track(floppy_t *flp, /*void *buf,*/ int lba)
{ {
ssize_t transfered = 0; ssize_t transfered = 0;
floppy_command cmd; floppy_command cmd;
#if 0
uint8 cmd2[8]; uint8 cmd2[8];
uint8 result[4]; uint8 result[4];
#endif
int tries = 0; int tries = 0;
if (flp->status < FLOP_MEDIA_FORMAT_FOUND) if (flp->status < FLOP_MEDIA_FORMAT_FOUND)
@@ -738,9 +789,8 @@ retry_track:
dprintf(FLO "pio_read_track(%d, %d={%d,%d,%d}) try %d\n", flp->drive_num, lba, cmd.cylinder, cmd.head, cmd.sector, tries); dprintf(FLO "pio_read_track(%d, %d={%d,%d,%d}) try %d\n", flp->drive_num, lba, cmd.cylinder, cmd.head, cmd.sector, tries);
#if 0 #if 0
/* first issue sense interrupt, to find the current track */ /* first issue sense interrupt, to find the current track */
DPRINT("track check: SENSEI\n"); TRACE("track check: SENSEI\n");
cmd2[0] = CMD_SENSEI; cmd2[0] = CMD_SENSEI;
send_command(flp, cmd2, 1); send_command(flp, cmd2, 1);
read_result(flp, result, 2); read_result(flp, result, 2);
@@ -752,12 +802,11 @@ retry_track:
cmd2[1] = (flp->drive_num & 0x3) | (cmd.head << 2); cmd2[1] = (flp->drive_num & 0x3) | (cmd.head << 2);
cmd2[2] = cmd.cylinder; // track 0 cmd2[2] = cmd.cylinder; // track 0
DPRINT("SEEK at track %d head %d\n", cmd.cylinder, cmd.head); TRACE("SEEK at track %d head %d\n", cmd.cylinder, cmd.head);
send_command(flp, cmd2, 3); send_command(flp, cmd2, 3);
if (wait_result(flp) < 0) if (wait_result(flp) < 0)
return ENXIO; return ENXIO;
} }
#endif #endif
flp->master->avail = 0; flp->master->avail = 0;
@@ -765,21 +814,22 @@ retry_track:
send_command(flp, (uint8 *)&cmd, sizeof(cmd)); send_command(flp, (uint8 *)&cmd, sizeof(cmd));
if (wait_result(flp) < 0) { if (wait_result(flp) < 0) {
drive_deselect(flp); drive_deselect(flp);
return ENXIO; return ENXIO;
} }
PRINT_SR0(flp->result[0]); PRINT_SR0(flp->result[0]);
DPRINT("sr1: %02x\n", flp->result[1]); TRACE("sr1: %02x\n", flp->result[1]);
DPRINT("sr2: %02x\n", flp->result[2]); TRACE("sr2: %02x\n", flp->result[2]);
DPRINT("@ track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]); TRACE("@ track %d, head %d, sec %d, bps %d\n", flp->result[3], flp->result[4], flp->result[5], flp->result[6]);
switch (flp->result[0] & FDC_SR0_IC) { switch (flp->result[0] & FDC_SR0_IC) {
case 0x80: case 0x80:
transfered = EINVAL; transfered = EINVAL;
break; break;
case 0x40: case 0x40:
dprintf(FLO "sr1: %02x\n", flp->result[1]); TRACE(FLO "sr1: %02x\n", flp->result[1]);
if (flp->result[1] != 0x80) {/* End Of Track is not really an error, actually it means it worked :) */ if (flp->result[1] != 0x80) {/* End Of Track is not really an error, actually it means it worked :) */
if (/*(flp->result[1] == 0x10) && */tries < 3) { /* overrun */ if (/*(flp->result[1] == 0x10) && */tries < 3) { /* overrun */
tries++; tries++;
@@ -807,7 +857,8 @@ retry_track:
} }
ssize_t read_sectors(floppy_t *flp, int lba, int num_sectors) ssize_t
read_sectors(floppy_t *flp, int lba, int num_sectors)
{ {
ssize_t transfered = 0; ssize_t transfered = 0;
//return pio_read_sectors(flp, lba, num_sectors); //return pio_read_sectors(flp, lba, num_sectors);