diff --git a/hw/esp.c b/hw/esp.c
index bcd90fb..13c36f2 100644
--- a/hw/esp.c
+++ b/hw/esp.c
@@ -21,8 +21,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+
 #include "hw.h"
-#include "block.h"
 #include "scsi-disk.h"
 #include "scsi.h"
 
@@ -44,14 +44,13 @@
 #define DPRINTF(fmt, args...)
 #endif
 
-#define ESP_MASK 0x3f
 #define ESP_REGS 16
-#define ESP_SIZE (ESP_REGS * 4)
 #define TI_BUFSZ 32
 
 typedef struct ESPState ESPState;
 
 struct ESPState {
+    uint32_t it_shift;
     qemu_irq irq;
     uint8_t rregs[ESP_REGS];
     uint8_t wregs[ESP_REGS];
@@ -403,7 +402,7 @@
     ESPState *s = opaque;
     uint32_t saddr;
 
-    saddr = (addr & ESP_MASK) >> 2;
+    saddr = (addr >> s->it_shift) & (ESP_REGS - 1);
     DPRINTF("read reg[%d]: 0x%2.2x\n", saddr, s->rregs[saddr]);
     switch (saddr) {
     case ESP_FIFO:
@@ -439,7 +438,7 @@
     ESPState *s = opaque;
     uint32_t saddr;
 
-    saddr = (addr & ESP_MASK) >> 2;
+    saddr = (addr >> s->it_shift) & (ESP_REGS - 1);
     DPRINTF("write reg[%d]: 0x%2.2x -> 0x%2.2x\n", saddr, s->wregs[saddr],
             val);
     switch (saddr) {
@@ -621,7 +620,7 @@
         s->scsi_dev[id] = scsi_disk_init(bd, 0, esp_command_complete, s);
 }
 
-void *esp_init(target_phys_addr_t espaddr,
+void *esp_init(target_phys_addr_t espaddr, int it_shift,
                espdma_memory_read_write dma_memory_read,
                espdma_memory_read_write dma_memory_write,
                void *dma_opaque, qemu_irq irq, qemu_irq *reset)
@@ -634,12 +633,13 @@
         return NULL;
 
     s->irq = irq;
+    s->it_shift = it_shift;
     s->dma_memory_read = dma_memory_read;
     s->dma_memory_write = dma_memory_write;
     s->dma_opaque = dma_opaque;
 
     esp_io_memory = cpu_register_io_memory(0, esp_mem_read, esp_mem_write, s);
-    cpu_register_physical_memory(espaddr, ESP_SIZE, esp_io_memory);
+    cpu_register_physical_memory(espaddr, ESP_REGS << it_shift, esp_io_memory);
 
     esp_reset(s);
 
diff --git a/hw/mips_jazz.c b/hw/mips_jazz.c
index 0fadd91..b377b20 100644
--- a/hw/mips_jazz.c
+++ b/hw/mips_jazz.c
@@ -200,7 +200,7 @@
     /* FIXME: missing NS SONIC DP83932 */
 
     /* SCSI adapter */
-    scsi_hba = esp_init(0x80002000,
+    scsi_hba = esp_init(0x80002000, 0,
                         espdma_memory_read, espdma_memory_write, NULL,
                         rc4030[5], &esp_reset);
     for (n = 0; n < ESP_MAX_DEVS; n++) {
diff --git a/hw/scsi.h b/hw/scsi.h
index a90927f..78ae768 100644
--- a/hw/scsi.h
+++ b/hw/scsi.h
@@ -2,7 +2,7 @@
 #define ESP_MAX_DEVS 7
 typedef void (*espdma_memory_read_write)(void *opaque, uint8_t *buf, int len);
 void esp_scsi_attach(void *opaque, BlockDriverState *bd, int id);
-void *esp_init(target_phys_addr_t espaddr,
+void *esp_init(target_phys_addr_t espaddr, int it_shift,
                espdma_memory_read_write dma_memory_read,
                espdma_memory_read_write dma_memory_write,
                void *dma_opaque, qemu_irq irq, qemu_irq *reset);
diff --git a/hw/sun4m.c b/hw/sun4m.c
index 1d36f61..b983c75 100644
--- a/hw/sun4m.c
+++ b/hw/sun4m.c
@@ -516,7 +516,7 @@
         exit(1);
     }
 
-    main_esp = esp_init(hwdef->esp_base,
+    main_esp = esp_init(hwdef->esp_base, 2,
                         espdma_memory_read, espdma_memory_write,
                         espdma, *espdma_irq, esp_reset);
 
@@ -668,7 +668,7 @@
         exit(1);
     }
 
-    main_esp = esp_init(hwdef->esp_base,
+    main_esp = esp_init(hwdef->esp_base, 2,
                         espdma_memory_read, espdma_memory_write,
                         espdma, *espdma_irq, esp_reset);
 
@@ -1460,7 +1460,7 @@
         exit(1);
     }
 
-    main_esp = esp_init(hwdef->esp_base,
+    main_esp = esp_init(hwdef->esp_base, 2,
                         espdma_memory_read, espdma_memory_write,
                         espdma, *espdma_irq, esp_reset);
 
