$OpenBSD: patch-iodev_floppy_cc,v 1.2 2001/02/12 18:41:06 todd Exp $
--- iodev/floppy.cc.orig	Sat Mar 25 21:28:49 2000
+++ iodev/floppy.cc	Mon Feb 12 12:41:58 2001
@@ -95,21 +95,26 @@ bx_floppy_ctrl_c::init(bx_devices_c *d, 
   switch (bx_options.floppya.type) {
     case BX_FLOPPY_NONE:
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0x0f) | 0x00;
+      bio->printf("[FDD] fda: none\n");
       break;
     case BX_FLOPPY_1_2:
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0x0f) | 0x20;
+      bio->printf("[FDD] fda: 1.2mb\n");
       break;
     case BX_FLOPPY_720K:
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0x0f) | 0x30;
+      bio->printf("[FDD] fda: 720k\n");
       break;
     case BX_FLOPPY_1_44:
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0x0f) | 0x40;
+      bio->printf("[FDD] fda: 1.44mb\n");
       break;
     case BX_FLOPPY_2_88:
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0x0f) | 0x50;
+      bio->printf("[FDD] fda: 2.88mb\n");
       break;
     default:
-      bx_panic("floppy: unknown floppya type\n");
+      bio->panic("[FDD] unknown floppya type\n");
     }
 
   if (bx_options.floppya.type != BX_FLOPPY_NONE) {
@@ -150,7 +155,7 @@ bx_floppy_ctrl_c::init(bx_devices_c *d, 
       cmos->s.reg[0x10] = (cmos->s.reg[0x10] & 0xf0) | 0x05;
       break;
     default:
-      bx_panic("floppy: unknown floppyb type\n");
+      bio->panic("[FDD] unknown floppyb type\n");
     }
 
   if (bx_options.floppyb.type != BX_FLOPPY_NONE) {
@@ -176,9 +181,9 @@ bx_floppy_ctrl_c::init(bx_devices_c *d, 
   BX_FD_THIS s.floppy_timer_index =
     bx_pc_system.register_timer( this, timer_handler,
       bx_options.floppy_command_delay, 0,0);
-
-  bx_printf("bx_options.floppy_command_delay = %u\n",
-    (unsigned) bx_options.floppy_command_delay);
+  if(bio->getdbg().floppy)
+	bio->printf("[FDD] delay = %u\n",
+		(unsigned) bx_options.floppy_command_delay);
 }
 
 
@@ -251,16 +256,16 @@ bx_floppy_ctrl_c::read(Bit32u address, u
   Bit8u status, value;
 
   if (io_len > 1)
-    bx_panic("floppy: io read from address %08x, len=%u\n",
+    bio->panic("[FDD] io read from address %08x, len=%u\n",
              (unsigned) address, (unsigned) io_len);
 
 // ???
 //if (bx_cpu.cs.selector.value != 0xf000) {
-//  bx_printf("BIOS: floppy: read access to port %04x\n", (unsigned) address);
+//  bio->printf("[BIOS] floppy: read access to port %04x\n", (unsigned) address);
 //  }
 
-  if (bx_dbg.floppy)
-    bx_printf("floppy: read access to port %04x\n", (unsigned) address);
+  if (bio->getdbg().floppy)
+    bio->printf("[FDD] read access to port %04x\n", (unsigned) address);
 
   switch (address) {
 #if BX_DMA_FLOPPY_IO
@@ -276,7 +281,7 @@ bx_floppy_ctrl_c::read(Bit32u address, u
 
     case 0x3F5: /* diskette controller data */
       if (BX_FD_THIS s.result_size == 0) {
-        bx_panic("floppy: diskette controller:port3f5: no results to read\n");
+        bio->panic("[FDD] diskette controller:port3f5: no results to read\n");
         }
 
       value = BX_FD_THIS s.result[BX_FD_THIS s.result_index++];
@@ -308,7 +313,7 @@ bx_floppy_ctrl_c::read(Bit32u address, u
     }
 
 #if BX_DMA_FLOPPY_IO
-  bx_panic("floppy: io_read: bailing\n");
+  bio->panic("[FDD] io_read: bailing\n");
   return(0);
 #endif  // #if BX_DMA_FLOPPY_IO
 }
@@ -339,17 +344,17 @@ bx_floppy_ctrl_c::write(Bit32u address, 
   Bit8u motor_on_drive0, motor_on_drive1;
 
   if (io_len > 1)
-    bx_panic("floppy: io write to address %08x, len=%u\n",
+    bio->panic("[FDD] io write to address %08x, len=%u\n",
              (unsigned) address, (unsigned) io_len);
 
 // ???
 //if (bx_cpu.cs.selector.value != 0xf000) {
-//  bx_printf("BIOS: floppy: write access to port %04x, value=%02x\n",
+//  bio->printf("[BIOS] floppy: write access to port %04x, value=%02x\n",
 //      (unsigned) address, (unsigned) value);
 //  }
 
-  if (bx_dbg.floppy)
-    bx_printf("floppy: write access to port %04x, value=%02x\n",
+  if (bio->getdbg().floppy)
+    bio->printf("[FDD] write access to port %04x, value=%02x\n",
       (unsigned) address, (unsigned) value);
 
   switch (address) {
@@ -358,8 +363,8 @@ bx_floppy_ctrl_c::write(Bit32u address, 
       motor_on_drive1 = value & 0x20;
       motor_on_drive0 = value & 0x10;
       dma_and_interrupt_enable = value & 0x08;
-      if (!dma_and_interrupt_enable)
-        bx_printf("floppy: DMA and interrupt capabilities disabled\n");
+      if (!dma_and_interrupt_enable && bio->getdbg().floppy)
+        bio->printf("[FDD] DMA and interrupt capabilities disabled\n");
       normal_operation = value & 0x04;
       drive_select = value & 0x03;
 
@@ -385,33 +390,36 @@ bx_floppy_ctrl_c::write(Bit32u address, 
         bx_pc_system.activate_timer( BX_FD_THIS s.floppy_timer_index,
              bx_options.floppy_command_delay, 0 );
         }
-      if (bx_dbg.floppy) {
-        bx_printf("floppy: io_write: digital output register\n");
-        bx_printf("  motor on, drive1 = %d\n", motor_on_drive1 > 0);
-        bx_printf("  motor on, drive0 = %d\n", motor_on_drive0 > 0);
-        bx_printf("  dma_and_interrupt_enable=%02x\n",
+      if (bio->getdbg().floppy) {
+        bio->printf("[FDD] io_write: digital output register\n");
+        bio->printf("[FDD]   motor on, drive1 = %d\n", motor_on_drive1 > 0);
+        bio->printf("[FDD]   motor on, drive0 = %d\n", motor_on_drive0 > 0);
+        bio->printf("[FDD]   dma_and_interrupt_enable=%02x\n",
           (unsigned) dma_and_interrupt_enable);
-        bx_printf("  normal_operation=%02x\n",
+        bio->printf("[FDD]   normal_operation=%02x\n",
           (unsigned) normal_operation);
-        bx_printf("  drive_select=%02x\n",
+        bio->printf("[FDD]   drive_select=%02x\n",
           (unsigned) drive_select);
         }
-      if (drive_select>1) {
-        bx_panic("floppy: io_write: drive_select>1\n");
+      if (drive_select>1 && bio->getdbg().floppy) {
+        bio->printf("[FDD] io_write: drive_select>1\n");
         }
       break;
 
     case 0x3f4: /* diskette controller data rate select register */
-      bx_panic("floppy: io_write: data rate select register\n");
+      bio->printf("[FDD] io_write: data rate select register (unhandled)\n");
       break;
 
     case 0x3F5: /* diskette controller data */
-      if (bx_dbg.floppy)
-        bx_printf("floppy: command = %02x\n", (unsigned) value);
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] command = %02x\n", (unsigned) value);
       if (BX_FD_THIS s.command_complete) {
-        if (BX_FD_THIS s.pending_command!=0)
-          bx_panic("floppy: io: 3f5: receiving new comm, old one (%02x) pending\n",
-            (unsigned) BX_FD_THIS s.pending_command);
+        if (BX_FD_THIS s.pending_command!=0) {
+		if(bio->getdbg().floppy)
+          		bio->printf("[FDD] io: 3f5: receiving new comm, old one (%02x) pending\n",
+            			(unsigned) BX_FD_THIS s.pending_command);
+		break;
+	}
         BX_FD_THIS s.command[0] = value;
         BX_FD_THIS s.command_complete = 0;
         BX_FD_THIS s.command_index = 1;
@@ -464,8 +472,9 @@ bx_floppy_ctrl_c::write(Bit32u address, 
             break;
 
           default:
-            bx_panic("floppy: io write:3f5: unsupported case 0x%02x\n",
-              (unsigned) value);
+		if(bio->getdbg().floppy)
+			bio->printf("[FDD] io write:3f5: unsupported case 0x%02x\n",
+				(unsigned) value);
             break;
           }
         }
@@ -479,36 +488,36 @@ bx_floppy_ctrl_c::write(Bit32u address, 
           BX_FD_THIS s.command_complete = 1;
           }
         }
-      if (bx_dbg.floppy)
-        bx_printf("floppy: io_write: diskette controller data\n");
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] io_write: diskette controller data\n");
       return;
       break;
 #endif  // #if BX_DMA_FLOPPY_IO
 
     case 0x3F6: /* diskette controller (reserved) */
-      if (bx_dbg.floppy)
-        bx_printf("floppy: io_write: reserved register unsupported\n");
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] io_write: reserved register unsupported\n");
       // this address shared with the hard drive controller
       BX_FD_THIS devices->hard_drive->write_handler(BX_FD_THIS devices->hard_drive, address, value, io_len);
       break;
 
 #if BX_DMA_FLOPPY_IO
     case 0x3F7: /* diskette controller configuration control register */
-      if (bx_dbg.floppy)
-        bx_printf("floppy: io_write: config control register\n");
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] io_write: config control register\n");
       BX_FD_THIS s.data_rate = value & 0x03;
-      if (bx_dbg.floppy)
+      if (bio->getdbg().floppy)
         switch (BX_FD_THIS s.data_rate) {
-          case 0: bx_printf("  500 Kbps\n"); break;
-          case 1: bx_printf("  300 Kbps\n"); break;
-          case 2: bx_printf("  250 Kbps\n"); break;
-          case 3: bx_printf("  1 Mbps\n"); break;
+          case 0: bio->printf("[FDD]   500 Kbps\n"); break;
+          case 1: bio->printf("[FDD]   300 Kbps\n"); break;
+          case 2: bio->printf("[FDD]   250 Kbps\n"); break;
+          case 3: bio->printf("[FDD]   1 Mbps\n"); break;
           }
       return;
       break;
 
    default:
-      bx_panic("floppy: io_write: unknown port %04h\n", (unsigned) address);
+      bio->panic("[FDD] io_write: unknown port %04h\n", (unsigned) address);
       break;
 #endif  // #if BX_DMA_FLOPPY_IO
     }
@@ -520,7 +529,7 @@ bx_floppy_ctrl_c::write(Bit32u address, 
 bx_floppy_ctrl_c::floppy_command(void)
 {
 #if BX_PROVIDE_CPU_MEMORY==0
-  bx_panic("floppy_command(): uses DMA: not supported for"
+  bio->panic("floppy_command(): uses DMA: not supported for"
            " external environment\n");
 #else
   unsigned i;
@@ -533,11 +542,11 @@ bx_floppy_ctrl_c::floppy_command(void)
   Bit32u logical_sector;
 
 
-  if (bx_dbg.floppy) {
-    bx_printf("FLOPPY COMMAND: ");
+  if (bio->getdbg().floppy) {
+    bio->printf("[FDD] FLOPPY COMMAND: ");
     for (i=0; i<BX_FD_THIS s.command_size; i++)
-      bx_printf("[%02x] ", (unsigned) BX_FD_THIS s.command[i]);
-    bx_printf("\n");
+      bio->printf("[%02x] ", (unsigned) BX_FD_THIS s.command[i]);
+    bio->printf("\n");
     }
 
 #if 0
@@ -547,7 +556,7 @@ bx_floppy_ctrl_c::floppy_command(void)
 
   switch (BX_FD_THIS s.command[0]) {
     case 0x03: // specify
-//bx_printf("floppy_command specify\n");
+//bio->printf("[FDD] floppy_command specify\n");
       // execution: specified parameters are loaded
       // result: no result bytes, no interrupt
       step_rate_time = BX_FD_THIS s.command[1] >> 4;
@@ -566,20 +575,20 @@ bx_floppy_ctrl_c::floppy_command(void)
       break;
 
     case 0x07: // recalibrate
-//bx_printf("floppy_command recalibrate\n");
+//bio->printf("[FDD] floppy_command recalibrate\n");
       drive = (BX_FD_THIS s.command[1] & 0x03);
       BX_FD_THIS s.DOR &= 0xfc;
       BX_FD_THIS s.DOR |= drive;
-      if (bx_dbg.floppy)
-        bx_printf("floppy_command(): recalibrate drive %u\n",
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] floppy_command(): recalibrate drive %u\n",
           (unsigned) drive);
       if (drive > 1)
-        bx_panic("floppy_command(): drive > 1\n");
+        bio->panic("[FDD] floppy_command(): drive > 1\n");
       //motor_on = BX_FD_THIS s.DOR & 0xf0;
       motor_on = ( (BX_FD_THIS s.DOR>>(drive+4))
                      & 0x01 );
       if (motor_on == 0) {
-        bx_printf("floppy_command(): recal drive with motor off\n");
+        bio->printf("[FDD] floppy_command(): recal drive with motor off\n");
         }
       if (drive==0)
         BX_FD_THIS s.DOR |= 0x10; // turn on MOTA
@@ -600,7 +609,7 @@ bx_floppy_ctrl_c::floppy_command(void)
       break;
 
     case 0x08: /* sense interrupt status */
-//bx_printf("floppy_command sense interrupt status\n");
+//bio->printf("[FDD] floppy_command sense interrupt status\n");
       /* execution:
        *   get status
        * result:
@@ -617,13 +626,13 @@ bx_floppy_ctrl_c::floppy_command(void)
 
       /* read ready */
       BX_FD_THIS s.main_status_reg = FD_MS_MRQ | FD_MS_DIO | FD_MS_BUSY;
-      if (bx_dbg.floppy)
-        bx_printf("sense interrupt status\n");
+      if (bio->getdbg().floppy)
+        bio->printf("[FDD] sense interrupt status\n");
       return;
       break;
 
     case 0x0f: /* seek */
-//bx_printf("floppy_command seek\n");
+//bio->printf("[FDD] floppy_command seek\n");
       /* command:
        *   byte0 = 0F
        *   byte1 = drive & head select
@@ -640,7 +649,7 @@ bx_floppy_ctrl_c::floppy_command(void)
       BX_FD_THIS s.head[drive] = (BX_FD_THIS s.command[1] >> 2) & 0x01;
       BX_FD_THIS s.cylinder[drive] = BX_FD_THIS s.command[2];
       if (drive > 1)
-        bx_panic("floppy_command(): seek: drive>1\n");
+        bio->panic("[FDD] floppy_command(): seek: drive>1\n");
       /* ??? should also check cylinder validity */
       bx_pc_system.activate_timer( BX_FD_THIS s.floppy_timer_index,
         bx_options.floppy_command_delay, 0 );
@@ -651,7 +660,7 @@ bx_floppy_ctrl_c::floppy_command(void)
       break;
 
     case 0x13: // Configure
-      bx_printf("floppy io: configure (mode=%02xh, pretrack=%02xh)\n",
+      bio->printf("[FDD] floppy io: configure (mode=%02xh, pretrack=%02xh)\n",
 (unsigned)(BX_FD_THIS s.command[2]), (unsigned)(BX_FD_THIS s.command[3]));
       BX_FD_THIS s.result_size = 0;
       BX_FD_THIS s.result_index = 0;
@@ -661,16 +670,16 @@ bx_floppy_ctrl_c::floppy_command(void)
       break;
 
     case 0x4a: // read ID
-//bx_printf("floppy_command read ID\n"); // ???
+//bio->printf("[FDD] floppy_command read ID\n"); // ???
       drive = BX_FD_THIS s.command[1] & 0x03;
       BX_FD_THIS s.DOR &= 0xfc;
       BX_FD_THIS s.DOR |= drive;
 
       motor_on = (BX_FD_THIS s.DOR>>(drive+4)) & 0x01;
       if (motor_on == 0)
-        bx_panic("floppy_command(): 4a: motor not on\n");
+        bio->panic("[FDD] floppy_command(): 4a: motor not on\n");
       if (drive > 1)
-        bx_panic("floppy io: 4a: bad drive #\n");
+        bio->panic("[FDD] floppy io: 4a: bad drive #\n");
       BX_FD_THIS s.result_size = 7;
       BX_FD_THIS s.result_index = 0;
       BX_FD_THIS s.result[0] = 0; /* ??? */
@@ -690,42 +699,42 @@ bx_floppy_ctrl_c::floppy_command(void)
 
 
     case 0xe6: // read normal data
-//bx_printf("floppy_command read normal data\n");
+//bio->printf("[FDD] floppy_command read normal data\n");
     case 0xc5: // write normal data
-//bx_printf("floppy_command write normal data\n");
+//bio->printf("[FDD] floppy_command write normal data\n");
       if ( (BX_FD_THIS s.DOR & 0x08) == 0 )
-        bx_panic("floppy: read/write command with DMA and int disabled\n");
+        bio->panic("[FDD] read/write command with DMA and int disabled\n");
       drive = BX_FD_THIS s.command[1] & 0x03;
       BX_FD_THIS s.DOR &= 0xfc;
       BX_FD_THIS s.DOR |= drive;
 
       motor_on = (BX_FD_THIS s.DOR>>(drive+4)) & 0x01;
       if (motor_on == 0)
-        bx_panic("floppy_command(): read/write: motor not on\n");
+        bio->panic("[FDD] floppy_command(): read/write: motor not on\n");
       head = BX_FD_THIS s.command[3] & 0x01;
       cylinder = BX_FD_THIS s.command[2]; /* 0..79 depending */
       sector = BX_FD_THIS s.command[4];   /* 1..36 depending */
       eot = BX_FD_THIS s.command[6];      /* 1..36 depending */
       sector_size = BX_FD_THIS s.command[5];
       data_length = BX_FD_THIS s.command[8];
-      if (bx_dbg.floppy) {
-        bx_printf("\n\nread/write normal data\n");
-        bx_printf("BEFORE\n");
-        bx_printf("  drive    = %u\n", (unsigned) drive);
-        bx_printf("  head     = %u\n", (unsigned) head);
-        bx_printf("  cylinder = %u\n", (unsigned) cylinder);
-        bx_printf("  sector   = %u\n", (unsigned) sector);
-        bx_printf("  eot      = %u\n", (unsigned) eot);
+      if (bio->getdbg().floppy) {
+        bio->printf("\n\nread/write normal data\n");
+        bio->printf("[FDD] BEFORE\n");
+        bio->printf("[FDD]   drive    = %u\n", (unsigned) drive);
+        bio->printf("[FDD]   head     = %u\n", (unsigned) head);
+        bio->printf("[FDD]   cylinder = %u\n", (unsigned) cylinder);
+        bio->printf("[FDD]   sector   = %u\n", (unsigned) sector);
+        bio->printf("[FDD]   eot      = %u\n", (unsigned) eot);
         }
       if (drive > 1)
-        bx_panic("floppy io: bad drive #\n");
+        bio->panic("floppy io: bad drive #\n");
       if (head > 1)
-        bx_panic("floppy io: bad head #\n");
+        bio->panic("floppy io: bad head #\n");
 
       if ( BX_FD_THIS s.media_present[drive] == 0 ) {
         // media not in drive, return error
 
-        bx_printf("floppy_command: attempt to read/write sector %u,"
+        bio->printf("[FDD] floppy_command: attempt to read/write sector %u,"
                      " sectors/track=%u\n", (unsigned) sector,
                      (unsigned) BX_FD_THIS s.media[drive].sectors_per_track);
         BX_FD_THIS s.result_size = 7;
@@ -745,23 +754,23 @@ bx_floppy_ctrl_c::floppy_command(void)
         }
 
       if (sector_size != 0x02) { // 512 bytes
-        bx_panic("floppy: sector_size not 512\n");
+        bio->panic("[FDD] sector_size not 512\n");
         }
       if ( cylinder >= BX_FD_THIS s.media[drive].tracks ) {
-        bx_printf("\nfloppy io: normal read/write: params out of range\n");
-        bx_printf("*** sector # %02xh\n", (unsigned) sector);
-        bx_printf("*** cylinder #%02xh\n", (unsigned) cylinder);
-        bx_printf("*** eot #%02xh\n", (unsigned) eot);
-        bx_printf("*** head #%02xh\n", (unsigned) head);
-        bx_panic("bailing\n");
+        bio->printf("[FDD] floppy io: normal read/write: params out of range\n");
+        bio->printf("[FDD] *** sector # %02xh\n", (unsigned) sector);
+        bio->printf("[FDD] *** cylinder #%02xh\n", (unsigned) cylinder);
+        bio->printf("[FDD] *** eot #%02xh\n", (unsigned) eot);
+        bio->printf("[FDD] *** head #%02xh\n", (unsigned) head);
+        bio->panic("bailing\n");
         return;
         }
 
       if (sector > BX_FD_THIS s.media[drive].sectors_per_track) {
         // requested sector > last sector on track
-        bx_printf("floppy_command: attempt to read/write sector %u,"
-                     " sectors/track=%u\n", (unsigned) sector,
-                     (unsigned) BX_FD_THIS s.media[drive].sectors_per_track);
+        // bio->printf("[FDD] floppy_command: attempt to read/write sector %u,"
+                     // " sectors/track=%u\n", (unsigned) sector,
+                     // (unsigned) BX_FD_THIS s.media[drive].sectors_per_track);
         // set controller to where drive would have left off
         // after it discovered the sector was past EOT
         BX_FD_THIS s.cylinder[drive] = cylinder;
@@ -792,18 +801,18 @@ bx_floppy_ctrl_c::floppy_command(void)
 
 #if 0
       if (eot != BX_FD_THIS s.media[drive].sectors_per_track)
-        bx_printf("floppy io: bad eot #%02xh\n", (unsigned) eot);
+        bio->printf("[FDD] floppy io: bad eot #%02xh\n", (unsigned) eot);
 #endif
 
-      if (cylinder != BX_FD_THIS s.cylinder[drive])
-        bx_printf("floppy io: cylinder request != current cylinder\n");
+      if (cylinder != BX_FD_THIS s.cylinder[drive] && bio->getdbg().floppy)
+        bio->printf("[FDD] floppy io: cylinder request != current cylinder\n");
 
       logical_sector = (cylinder * 2 * BX_FD_THIS s.media[drive].sectors_per_track) +
                        (head * BX_FD_THIS s.media[drive].sectors_per_track) +
                        (sector - 1);
 
       if (logical_sector >= BX_FD_THIS s.media[drive].sectors) {
-        bx_panic("floppy io: logical sector out of bounds\n");
+        bio->panic("[FDD] floppy io: logical sector out of bounds\n");
         }
 
       BX_FD_THIS s.cylinder[drive] = cylinder;
@@ -833,15 +842,15 @@ bx_floppy_ctrl_c::floppy_command(void)
         return;
         }
       else
-        bx_panic("floppy_command(): unknown read/write command\n");
+        bio->panic("[FDD] floppy_command(): unknown read/write command\n");
 
       return;
       break;
 
     default:
-      bx_panic("floppy_command(): unknown function\n");
+      bio->panic("[FDD] floppy_command(): unknown function\n");
     }
-  bx_panic("\nfloppy_command()\n");
+  bio->panic("\nfloppy_command()\n");
 #endif
 }
 
@@ -852,13 +861,13 @@ bx_floppy_ctrl_c::floppy_xfer(Bit8u driv
   int ret;
 
   if (drive > 1)
-    bx_panic("floppy_xfer: drive > 1\n");
+    bio->panic("floppy_xfer: drive > 1\n");
 
-  if (bx_dbg.floppy) {
-    bx_printf("drive=%u\n", (unsigned) drive);
-    bx_printf("offset=%u\n", (unsigned) offset);
-    bx_printf("bytes=%u\n", (unsigned) bytes);
-    bx_printf("direction=%s\n", (direction==FROM_FLOPPY)? "from" : "to");
+  if (bio->getdbg().floppy) {
+    bio->printf("[FDD] drive=%u\n", (unsigned) drive);
+    bio->printf("[FDD] offset=%u\n", (unsigned) offset);
+    bio->printf("[FDD] bytes=%u\n", (unsigned) bytes);
+    bio->printf("[FDD] direction=%s\n", (direction==FROM_FLOPPY)? "from" : "to");
     }
 
 #ifdef macintosh
@@ -867,7 +876,7 @@ bx_floppy_ctrl_c::floppy_xfer(Bit8u driv
     {
     ret = lseek(BX_FD_THIS s.media[drive].fd, offset, SEEK_SET);
     if (ret < 0) {
-      bx_panic("could not perform lseek() on floppy image file\n");
+      bio->panic("could not perform lseek() on floppy image file\n");
       }
     }
 
@@ -881,12 +890,12 @@ bx_floppy_ctrl_c::floppy_xfer(Bit8u driv
     if (ret < int(bytes)) {
       /* ??? */
       if (ret > 0) {
-        bx_printf("floppy: partial read() on floppy image returns %u/%u\n",
+        bio->printf("[FDD] partial read() on floppy image returns %u/%u\n",
           (unsigned) ret, (unsigned) bytes);
         memset(buffer + ret, 0, bytes - ret);
         }
       else {
-        bx_printf("floppy: read() on floppy image returns 0\n");
+        bio->printf("[FDD] read() on floppy image returns 0\n");
         memset(buffer, 0, bytes);
         }
       }
@@ -900,7 +909,7 @@ bx_floppy_ctrl_c::floppy_xfer(Bit8u driv
 #endif
       ret = ::write(BX_FD_THIS s.media[drive].fd, (bx_ptr_t) buffer, bytes);
     if (ret < int(bytes)) {
-      bx_panic("could not perform write() on floppy image file\n");
+      bio->panic("could not perform write() on floppy image file\n");
       }
     }
 }
@@ -911,7 +920,7 @@ bx_floppy_ctrl_c::floppy_xfer(Bit8u driv
 bx_floppy_ctrl_c::timer_handler(void *this_ptr)
 {
 #if defined(SIMX86)
-  printf("Floppy timer\n");
+  printf("[FDD] Floppy timer\n");
 #endif
 
   bx_floppy_ctrl_c *class_ptr = (bx_floppy_ctrl_c *) this_ptr;
@@ -957,7 +966,7 @@ bx_floppy_ctrl_c::timer()
       break;
 
     default:
-      bx_panic("floppy:timer(): unknown case %02x\n",
+      bio->panic("[FDD]timer(): unknown case %02x\n",
         (unsigned) BX_FD_THIS s.pending_command);
     }
   return;
@@ -998,13 +1007,13 @@ bx_floppy_ctrl_c::dma_write(Bit8u *data_
       BX_FD_THIS s.result[5] = BX_FD_THIS s.sector[drive];
       BX_FD_THIS s.result[6] = 2;
 
-      if (bx_dbg.floppy) {
-        bx_printf("<<READ DONE>>\n");
-        bx_printf("AFTER\n");
-        bx_printf("  drive    = %u\n", (unsigned) drive);
-        bx_printf("  head     = %u\n", (unsigned) BX_FD_THIS s.head[drive]);
-        bx_printf("  cylinder = %u\n", (unsigned) BX_FD_THIS s.cylinder[drive]);
-        bx_printf("  sector   = %u\n", (unsigned) BX_FD_THIS s.sector[drive]);
+      if (bio->getdbg().floppy) {
+        bio->printf("[FDD] <<READ DONE>>\n");
+        bio->printf("[FDD] AFTER\n");
+        bio->printf("[FDD]   drive    = %u\n", (unsigned) drive);
+        bio->printf("[FDD]   head     = %u\n", (unsigned) BX_FD_THIS s.head[drive]);
+        bio->printf("[FDD]   cylinder = %u\n", (unsigned) BX_FD_THIS s.cylinder[drive]);
+        bio->printf("[FDD]   sector   = %u\n", (unsigned) BX_FD_THIS s.sector[drive]);
         }
 
       BX_FD_THIS devices->pic->trigger_irq(6);
@@ -1056,13 +1065,13 @@ bx_floppy_ctrl_c::dma_read(Bit8u *data_b
       BX_FD_THIS s.result[4] = BX_FD_THIS s.head[drive];
       BX_FD_THIS s.result[5] = BX_FD_THIS s.sector[drive];
       BX_FD_THIS s.result[6] = 2;
-      if (bx_dbg.floppy) {
-        bx_printf("<<WRITE DONE>>\n");
-        bx_printf("AFTER\n");
-        bx_printf("  drive    = %u\n", (unsigned) drive);
-        bx_printf("  head     = %u\n", (unsigned) BX_FD_THIS s.head[drive]);
-        bx_printf("  cylinder = %u\n", (unsigned) BX_FD_THIS s.cylinder[drive]);
-        bx_printf("  sector   = %u\n", (unsigned) BX_FD_THIS s.sector[drive]);
+      if (bio->getdbg().floppy) {
+        bio->printf("[FDD] <<WRITE DONE>>\n");
+        bio->printf("[FDD] AFTER\n");
+        bio->printf("[FDD]   drive    = %u\n", (unsigned) drive);
+        bio->printf("[FDD]   head     = %u\n", (unsigned) BX_FD_THIS s.head[drive]);
+        bio->printf("[FDD]   cylinder = %u\n", (unsigned) BX_FD_THIS s.cylinder[drive]);
+        bio->printf("[FDD]   sector   = %u\n", (unsigned) BX_FD_THIS s.sector[drive]);
         }
 
       BX_FD_THIS devices->pic->trigger_irq(6);
@@ -1095,7 +1104,7 @@ bx_floppy_ctrl_c::increment_sector(void)
         // Set to 1 past last possible cylinder value.
         // I notice if I set it to tracks-1, prama linux won't boot.
         BX_FD_THIS s.cylinder[drive] = BX_FD_THIS s.media[drive].tracks;
-        bx_printf("increment_sector: clamping cylinder to max\n");
+        bio->printf("[FDD] increment_sector: clamping cylinder to max\n");
         }
       }
     }
@@ -1184,8 +1193,8 @@ bx_floppy_ctrl_c::evaluate_media(unsigne
 #endif
     ret = fstat(media->fd, &stat_buf);
   if (ret) {
-    perror("fstat'ing floppy 0 drive image file");
-    bx_panic("fstat() returns error!\n");
+    perror("[FDD] fstat'ing floppy 0 drive image file");
+    bio->panic("floppy fstat() returns error!\n");
     return(0);
     }
 
@@ -1222,9 +1231,7 @@ bx_floppy_ctrl_c::evaluate_media(unsigne
           media->heads             = 2;
 	  }
         else {
-          fprintf(stderr, "# floppy: evaluate_media: file '%s' of unknown size %lu\n",
-            path, (unsigned long) stat_buf.st_size);
-          bx_printf("floppy: evaluate_media: file '%s' of unknown size %lu\n",
+          bio->printf("[FDD] evaluate_media: file '%s' of unknown size %lu\n",
             path, (unsigned long) stat_buf.st_size);
           return(0);
           }
@@ -1236,7 +1243,7 @@ bx_floppy_ctrl_c::evaluate_media(unsigne
         media->heads             = 2;
         break;
       default:
-        bx_panic("floppy: evaluate_media: unknown media type\n");
+        bio->panic("[FDD] evaluate_media: unknown media type\n");
       }
     media->sectors = media->heads * media->tracks * media->sectors_per_track;
     return(1); // success
@@ -1277,15 +1284,15 @@ bx_floppy_ctrl_c::evaluate_media(unsigne
         media->heads             = 2;
         break;
       default:
-        bx_panic("floppy: evaluate_media: unknown media type\n");
+        bio->printf("[FDD] evaluate_media: unknown media type\n");
+	return 0;
       }
     media->sectors = media->heads * media->tracks * media->sectors_per_track;
     return(1); // success
     }
   else {
     // unknown file type
-    fprintf(stderr, "# floppy: unknown mode type\n");
-    bx_printf("floppy: unknown mode type\n");
+    bio->printf("[FDD] unknown mode type\n");
     return(0);
     }
 }
