mirror of
https://github.com/ivanizag/izapple2.git
synced 2025-03-17 04:29:19 +00:00
Separation of the Smartport card and the Smartport hard disk
This commit is contained in:
Ivan Izaguirre
parent
d631ee7973
commit
5d857dda4b
2
.gitignore
vendored
2
.gitignore
vendored
@ -4,6 +4,8 @@ a2sdl.exe
|
||||
frontend/a2sdl/a2sdl
|
||||
frontend/a2sdl/*.woz
|
||||
frontend/a2sdl/*.dsk
|
||||
frontend/a2sdl/*.po
|
||||
frontend/a2sdl/*.2mg
|
||||
frontend/a2fyne/a2fyne
|
||||
frontend/headless/headless
|
||||
frontend/*/snapshot.gif
|
||||
|
||||
@ -139,14 +139,12 @@ func (a *Apple2) AddDisk2Sequencer(slot int, diskImage, diskBImage string, track
|
||||
|
||||
// AddSmartPortDisk adds a smart port card and image
|
||||
func (a *Apple2) AddSmartPortDisk(slot int, hdImage string, trace bool) error {
|
||||
c := NewCardHardDisk()
|
||||
c := NewCardSmartport()
|
||||
c.trace = trace
|
||||
err := c.LoadImage(hdImage)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
a.insertCard(c, slot)
|
||||
return nil
|
||||
|
||||
err := c.LoadImage(hdImage)
|
||||
return err
|
||||
}
|
||||
|
||||
// AddVidHD adds a card with the signature of VidHD
|
||||
|
||||
@ -3,12 +3,10 @@ package izapple2
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"github.com/ivanizag/izapple2/storage"
|
||||
)
|
||||
|
||||
/*
|
||||
To implement a hard drive we just have to support boot from #PR7 and the PRODOS expextations.
|
||||
To implement a hard drive we just have to support boot from #PR7 and the PRODOS expectations.
|
||||
|
||||
See:
|
||||
Beneath Prodos, section 6-6, 7-13 and 5-8. (http://www.apple-iigs.info/doc/fichiers/beneathprodos.pdf)
|
||||
@ -19,188 +17,115 @@ See:
|
||||
|
||||
*/
|
||||
|
||||
// CardHardDisk represents a SmartPort card
|
||||
type CardHardDisk struct {
|
||||
// CardSmartport represents a SmartPort card
|
||||
type CardSmartport struct {
|
||||
cardBase
|
||||
hardDiskDevice smartPortDevice
|
||||
hardDiskBlocks uint32
|
||||
|
||||
filename string
|
||||
trace bool
|
||||
|
||||
disk *storage.BlockDisk
|
||||
mliParams uint16
|
||||
trace bool
|
||||
}
|
||||
|
||||
// NewCardHardDisk creates a new SmartPort card
|
||||
func NewCardHardDisk() *CardHardDisk {
|
||||
var c CardHardDisk
|
||||
// NewCardSmartport creates a new SmartPort card
|
||||
func NewCardSmartport() *CardSmartport {
|
||||
var c CardSmartport
|
||||
c.name = "Smartport Card"
|
||||
return &c
|
||||
}
|
||||
|
||||
// GetInfo returns smartport info
|
||||
func (c *CardHardDisk) GetInfo() map[string]string {
|
||||
func (c *CardSmartport) GetInfo() map[string]string {
|
||||
info := make(map[string]string)
|
||||
info["filename"] = c.filename
|
||||
info["trace"] = strconv.FormatBool(c.trace)
|
||||
return info
|
||||
}
|
||||
|
||||
// LoadImage loads a disk image
|
||||
func (c *CardHardDisk) LoadImage(filename string) error {
|
||||
hd, err := storage.OpenBlockDisk(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
func (c *CardSmartport) LoadImage(filename string) error {
|
||||
device, err := NewSmartPortHardDisk(c, filename)
|
||||
if err == nil {
|
||||
device.trace = c.trace
|
||||
c.hardDiskDevice = device
|
||||
c.hardDiskBlocks = device.disk.GetSizeInBlocks() // Needed for the PRODOS status
|
||||
}
|
||||
c.disk = hd
|
||||
c.filename = filename
|
||||
return nil
|
||||
return err
|
||||
}
|
||||
|
||||
const (
|
||||
proDosDeviceCommandStatus = 0
|
||||
proDosDeviceCommandRead = 1
|
||||
proDosDeviceCommandWrite = 2
|
||||
proDosDeviceCommandFormat = 3
|
||||
)
|
||||
|
||||
const (
|
||||
proDosDeviceNoError = uint8(0)
|
||||
proDosDeviceErrorIO = uint8(0x27)
|
||||
proDosDeviceErrorNoDevice = uint8(0x28)
|
||||
proDosDeviceErrorWriteProtected = uint8(0x2b)
|
||||
)
|
||||
|
||||
func (c *CardHardDisk) assign(a *Apple2, slot int) {
|
||||
func (c *CardSmartport) assign(a *Apple2, slot int) {
|
||||
c.loadRom(buildHardDiskRom(slot))
|
||||
|
||||
c.addCardSoftSwitchR(0, func() uint8 {
|
||||
// Prodos entry point
|
||||
command := a.mmu.Peek(0x42)
|
||||
unit := a.mmu.Peek(0x43)
|
||||
address := uint16(a.mmu.Peek(0x44)) + uint16(a.mmu.Peek(0x45))<<8
|
||||
block := uint16(a.mmu.Peek(0x46)) + uint16(a.mmu.Peek(0x47))<<8
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Prodos command %v on slot %v, unit $%x, block %v to $%x.\n", command, slot, unit, block, address)
|
||||
}
|
||||
unit := a.mmu.Peek(0x43) & 0x0f
|
||||
|
||||
switch command {
|
||||
case proDosDeviceCommandStatus:
|
||||
return c.status(unit, address)
|
||||
case proDosDeviceCommandRead:
|
||||
return c.readBlock(block, address)
|
||||
case proDosDeviceCommandWrite:
|
||||
return c.writeBlock(block, address)
|
||||
default:
|
||||
// Prodos device command not supported
|
||||
return proDosDeviceErrorIO
|
||||
// Generate Smarport compatible params
|
||||
var params []uint8
|
||||
if command == proDosDeviceCommandStatus {
|
||||
params = []uint8{
|
||||
5, unit,
|
||||
a.mmu.Peek(0x44), a.mmu.Peek(0x45), // data address
|
||||
0,
|
||||
}
|
||||
} else {
|
||||
params = []uint8{
|
||||
7, unit,
|
||||
a.mmu.Peek(0x44), a.mmu.Peek(0x45), // data address
|
||||
a.mmu.Peek(0x46), a.mmu.Peek(0x47), 0, // block number
|
||||
}
|
||||
}
|
||||
}, "HDCOMMAND")
|
||||
result := c.hardDiskDevice.exec(command, params)
|
||||
if c.trace {
|
||||
fmt.Printf("[CardSmartport] PRODOS command $%x on slot %v, unit $%x, result $%02x.\n", command, slot, unit, result)
|
||||
}
|
||||
return result
|
||||
}, "SMARTPORTPRODOSCOMMAND")
|
||||
|
||||
c.addCardSoftSwitchR(1, func() uint8 {
|
||||
// Blocks available, low byte
|
||||
return uint8(c.disk.GetSizeInBlocks())
|
||||
return uint8(c.hardDiskBlocks)
|
||||
}, "HDBLOCKSLO")
|
||||
c.addCardSoftSwitchR(2, func() uint8 {
|
||||
// Blocks available, high byte
|
||||
return uint8(c.disk.GetSizeInBlocks() >> 8)
|
||||
return uint8(c.hardDiskBlocks)
|
||||
}, "HDBLOCKHI")
|
||||
|
||||
c.addCardSoftSwitchR(3, func() uint8 {
|
||||
// Smart port entry point
|
||||
command := c.a.mmu.Peek(c.mliParams + 1)
|
||||
paramsAddress := uint16(c.a.mmu.Peek(c.mliParams+2)) + uint16(c.a.mmu.Peek(c.mliParams+3))<<8
|
||||
unit := a.mmu.Peek(paramsAddress + 1)
|
||||
address := uint16(a.mmu.Peek(paramsAddress+2)) + uint16(a.mmu.Peek(paramsAddress+3))<<8
|
||||
block := uint16(a.mmu.Peek(paramsAddress+4)) + uint16(a.mmu.Peek(paramsAddress+5))<<8
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Smart port command %v on slot %v, unit $%x, block %v to $%x.\n", command, slot, unit, block, address)
|
||||
}
|
||||
|
||||
switch command {
|
||||
case proDosDeviceCommandStatus:
|
||||
return c.status(unit, address)
|
||||
case proDosDeviceCommandRead:
|
||||
return c.readBlock(block, address)
|
||||
case proDosDeviceCommandWrite:
|
||||
return c.writeBlock(block, address)
|
||||
default:
|
||||
// Smartport device command not supported
|
||||
return proDosDeviceErrorIO
|
||||
paramsSize := int(a.mmu.Peek(paramsAddress + 0))
|
||||
params := make([]uint8, paramsSize)
|
||||
for i := 0; i < paramsSize; i++ {
|
||||
params[i] = a.mmu.Peek(paramsAddress + uint16(i))
|
||||
}
|
||||
}, "HDSMARTPORT")
|
||||
unit := params[1]
|
||||
|
||||
result := c.hardDiskDevice.exec(command, params)
|
||||
if c.trace {
|
||||
fmt.Printf("[CardSmartport] Smart port command $%x on slot %v, unit $%x, result $%02x.\n", command, slot, unit, result)
|
||||
}
|
||||
return result
|
||||
}, "SMARTPORTEXEC")
|
||||
|
||||
c.addCardSoftSwitchW(4, func(value uint8) {
|
||||
c.mliParams = (c.mliParams & 0xff00) + uint16(value)
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Smart port LO: 0x%x.\n", c.mliParams)
|
||||
fmt.Printf("[CardSmartport] Smart port LO: 0x%x.\n", c.mliParams)
|
||||
}
|
||||
}, "HDSMARTPORTLO")
|
||||
c.addCardSoftSwitchW(5, func(value uint8) {
|
||||
c.mliParams = (c.mliParams & 0x00ff) + (uint16(value) << 8)
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Smart port HI: 0x%x.\n", c.mliParams)
|
||||
fmt.Printf("[CardSmartport] Smart port HI: 0x%x.\n", c.mliParams)
|
||||
}
|
||||
}, "HDSMARTPORTHI")
|
||||
|
||||
c.cardBase.assign(a, slot)
|
||||
}
|
||||
|
||||
func (c *CardHardDisk) readBlock(block uint16, dest uint16) uint8 {
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Read block %v into $%x.\n", block, dest)
|
||||
}
|
||||
|
||||
data, err := c.disk.Read(uint32(block))
|
||||
if err != nil {
|
||||
return proDosDeviceErrorIO
|
||||
}
|
||||
// Byte by byte transfer to memory using the full Poke code path
|
||||
for i := uint16(0); i < uint16(len(data)); i++ {
|
||||
c.a.mmu.Poke(dest+i, data[i])
|
||||
}
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
|
||||
func (c *CardHardDisk) writeBlock(block uint16, source uint16) uint8 {
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Write block %v from $%x.\n", block, source)
|
||||
}
|
||||
|
||||
if c.disk.IsReadOnly() {
|
||||
return proDosDeviceErrorWriteProtected
|
||||
}
|
||||
|
||||
// Byte by byte transfer from memory using the full Peek code path
|
||||
buf := make([]uint8, storage.ProDosBlockSize)
|
||||
for i := uint16(0); i < uint16(len(buf)); i++ {
|
||||
buf[i] = c.a.mmu.Peek(source + i)
|
||||
}
|
||||
|
||||
err := c.disk.Write(uint32(block), buf)
|
||||
if err != nil {
|
||||
return proDosDeviceErrorIO
|
||||
}
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
|
||||
func (c *CardHardDisk) status(unit uint8, dest uint16) uint8 {
|
||||
if c.trace {
|
||||
fmt.Printf("[CardHardDisk] Status for %v into $%x.\n", unit, dest)
|
||||
}
|
||||
|
||||
// See http://www.1000bit.it/support/manuali/apple/technotes/smpt/tn.smpt.2.html
|
||||
c.a.mmu.Poke(dest+0, 0x02) // One device
|
||||
c.a.mmu.Poke(dest+1, 0xff) // No interrupt
|
||||
c.a.mmu.Poke(dest+2, 0x00)
|
||||
c.a.mmu.Poke(dest+3, 0x00) // Unknown manufacturer
|
||||
c.a.mmu.Poke(dest+4, 0x01)
|
||||
c.a.mmu.Poke(dest+5, 0x00) // Version 1.0 final
|
||||
c.a.mmu.Poke(dest+6, 0x00)
|
||||
c.a.mmu.Poke(dest+7, 0x00) // Reserved
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
|
||||
func buildHardDiskRom(slot int) []uint8 {
|
||||
data := make([]uint8, 256)
|
||||
ssBase := 0x80 + uint8(slot<<4)
|
||||
46
smartPortDevice.go
Normal file
46
smartPortDevice.go
Normal file
@ -0,0 +1,46 @@
|
||||
package izapple2
|
||||
|
||||
/*
|
||||
A smartport device
|
||||
*/
|
||||
|
||||
type smartPortDevice interface {
|
||||
exec(command uint8, params []uint8) uint8
|
||||
}
|
||||
|
||||
const (
|
||||
proDosDeviceCommandStatus = 0
|
||||
proDosDeviceCommandRead = 1
|
||||
proDosDeviceCommandWrite = 2
|
||||
proDosDeviceCommandFormat = 3
|
||||
)
|
||||
|
||||
const (
|
||||
proDosDeviceNoError = uint8(0)
|
||||
proDosDeviceErrorIO = uint8(0x27)
|
||||
proDosDeviceErrorNoDevice = uint8(0x28)
|
||||
proDosDeviceErrorWriteProtected = uint8(0x2b)
|
||||
)
|
||||
|
||||
/*
|
||||
func smartPortParam8(params []uint8, offset uint8) uint8 {
|
||||
if int(offset) >= len(params) {
|
||||
return 0
|
||||
}
|
||||
return params[offset]
|
||||
}
|
||||
*/
|
||||
|
||||
func smartPortParam16(params []uint8, offset uint8) uint16 {
|
||||
if int(offset+1) >= len(params) {
|
||||
return 0
|
||||
}
|
||||
return uint16(params[offset]) + uint16(params[offset+1])<<8
|
||||
}
|
||||
|
||||
func smartPortParam24(params []uint8, offset uint8) uint32 {
|
||||
if int(offset+2) >= len(params) {
|
||||
return 0
|
||||
}
|
||||
return uint32(params[offset]) + uint32(params[offset+1])<<8 + uint32(params[offset+2])<<16
|
||||
}
|
||||
127
smartPortHardDisk.go
Normal file
127
smartPortHardDisk.go
Normal file
@ -0,0 +1,127 @@
|
||||
package izapple2
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/ivanizag/izapple2/storage"
|
||||
)
|
||||
|
||||
/*
|
||||
To implement a smartport hard drive we have to support the smartport commands.
|
||||
|
||||
See:
|
||||
Beneath Prodos, section 6-6, 7-13 and 5-8. (http://www.apple-iigs.info/doc/fichiers/beneathprodos.pdf)
|
||||
Apple IIc Technical Reference, 2nd Edition. Chapter 8. https://ia800207.us.archive.org/19/items/AppleIIcTechnicalReference2ndEd/Apple%20IIc%20Technical%20Reference%202nd%20ed.pdf
|
||||
|
||||
*/
|
||||
|
||||
// SmartPortHardDisk represents a SmartPort card
|
||||
type SmartPortHardDisk struct {
|
||||
host *CardSmartport // For DMA
|
||||
filename string
|
||||
trace bool
|
||||
disk *storage.BlockDisk
|
||||
}
|
||||
|
||||
// NewSmartPortHardDisk creates a new hard disk with the smartport interface
|
||||
func NewSmartPortHardDisk(host *CardSmartport, filename string) (*SmartPortHardDisk, error) {
|
||||
var d SmartPortHardDisk
|
||||
d.host = host
|
||||
d.filename = filename
|
||||
|
||||
hd, err := storage.OpenBlockDisk(filename)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
d.disk = hd
|
||||
|
||||
return &d, nil
|
||||
}
|
||||
|
||||
func (d *SmartPortHardDisk) exec(command uint8, params []uint8) uint8 {
|
||||
var result uint8
|
||||
|
||||
switch command {
|
||||
case proDosDeviceCommandStatus:
|
||||
address := smartPortParam16(params, 2)
|
||||
result = d.status(address)
|
||||
|
||||
case proDosDeviceCommandRead:
|
||||
address := smartPortParam16(params, 2)
|
||||
block := smartPortParam24(params, 4)
|
||||
result = d.readBlock(block, address)
|
||||
|
||||
case proDosDeviceCommandWrite:
|
||||
address := smartPortParam16(params, 2)
|
||||
block := smartPortParam24(params, 4)
|
||||
result = d.writeBlock(block, address)
|
||||
|
||||
default:
|
||||
// Prodos device command not supported
|
||||
result = proDosDeviceErrorIO
|
||||
}
|
||||
|
||||
if d.trace {
|
||||
fmt.Printf("[SmartPortHardDisk] Command $%x, return $%02x \n", command, result)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
func (d *SmartPortHardDisk) readBlock(block uint32, dest uint16) uint8 {
|
||||
if d.trace {
|
||||
fmt.Printf("[SmartPortHardDisk] Read block %v into $%x.\n", block, dest)
|
||||
}
|
||||
|
||||
data, err := d.disk.Read(block)
|
||||
if err != nil {
|
||||
return proDosDeviceErrorIO
|
||||
}
|
||||
// Byte by byte transfer to memory using the full Poke code path
|
||||
for i := uint16(0); i < uint16(len(data)); i++ {
|
||||
d.host.a.mmu.Poke(dest+i, data[i])
|
||||
}
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
|
||||
func (d *SmartPortHardDisk) writeBlock(block uint32, source uint16) uint8 {
|
||||
if d.trace {
|
||||
fmt.Printf("[SmartPortHardDisk] Write block %v from $%x.\n", block, source)
|
||||
}
|
||||
|
||||
if d.disk.IsReadOnly() {
|
||||
return proDosDeviceErrorWriteProtected
|
||||
}
|
||||
|
||||
// Byte by byte transfer from memory using the full Peek code path
|
||||
buf := make([]uint8, storage.ProDosBlockSize)
|
||||
for i := uint16(0); i < uint16(len(buf)); i++ {
|
||||
buf[i] = d.host.a.mmu.Peek(source + i)
|
||||
}
|
||||
|
||||
err := d.disk.Write(block, buf)
|
||||
if err != nil {
|
||||
return proDosDeviceErrorIO
|
||||
}
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
|
||||
func (d *SmartPortHardDisk) status(dest uint16) uint8 {
|
||||
if d.trace {
|
||||
fmt.Printf("[SmartPortHardDisk] Status into $%x.\n", dest)
|
||||
}
|
||||
|
||||
// See http://www.1000bit.it/support/manuali/apple/technotes/smpt/tn.smpt.2.html
|
||||
d.host.a.mmu.Poke(dest+0, 0x02) // One device
|
||||
d.host.a.mmu.Poke(dest+1, 0xff) // No interrupt
|
||||
d.host.a.mmu.Poke(dest+2, 0x00)
|
||||
d.host.a.mmu.Poke(dest+3, 0x00) // Unknown manufacturer
|
||||
d.host.a.mmu.Poke(dest+4, 0x01)
|
||||
d.host.a.mmu.Poke(dest+5, 0x00) // Version 1.0 final
|
||||
d.host.a.mmu.Poke(dest+6, 0x00)
|
||||
d.host.a.mmu.Poke(dest+7, 0x00) // Reserved
|
||||
|
||||
return proDosDeviceNoError
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user