not quite I think. It is more like
+// Hardware, implementing interface with UUID 0xABCD
+
def A_shutdown(cookie, data):
...
def A_do_more_stuff(cookie, data):
...
- def B_do_stuff(cookie, data):
- ...
+ interfaceA = {
+ "shutdown": A_shutdown,
+ "init": A_init,
+ "ctl0": A_do_stuff,
+ "ctl1": A_do_more_stuff
+ }
+// hardware implementing interface with UUID = 0x1234
+
+ def B_do_things(cookie, data):
+ ...
def B_shutdown(cookie, data)
...
- interfaceA = {
- shutdown: A_shutdown,
- init: A_init,
- ctl0: A_do_stuff,
- ctl1: A_do_more_stuff
- }
-
interfaceB = {
- shutdown: B_shutdown,
- init: B_init,
- ctl0: B_do_stuff
+ "shutdown": B_shutdown,
+ "ctl0": B_do_things
}
+
+// The CPU being wired to the devices
+
cpu_interfaces = {
0xABCD: interfaceA,
0x1234: interfaceB
}
+// The functionality that the CPU must implement to use the extension interface
+
cpu_open_handles = {}
__handleId = 0
def new_unused_handle_id()
- __handle = __handle + 1
- return __handle
+ __handleId = __handleId + 1
+ return __handleId
def ext_open(uuid, data):
interface = cpu_interface[uuid]
if interface == NIL:
- raise Exception("Unrecognised interface")
+ raise Exception("No such interface")
handleId = new_unused_handle_id()
- cpu_open_handles[handleId] = (interface, CurrentVirtualMemoryAddressSpace).
- cookie = A_init(data)
+ cpu_open_handles[handleId] = (interface, CurrentVirtualMemoryAddressSpace)
+
+ cookie = A_init(data) # Here device takes over
return (handle_id, cookie)
assert(interface != NIL)
shutdown = interface["shutdown"]
if shutdown != NIL:
- err = interface.shutdown(cookie, data)
+
+ err = interface.shutdown(cookie, data) # Here device takes over
+
if err != 0:
return err
cpu_open_handles[handleId] = NIL
(handleId, cookie) = handle
intf_VMA = cpu_open_handles[handleId]
if intf_VMA == NIL:
- raise Exception("unknown interface")
+ raise Exception("No such interface")
(interface, VMA) = intf_VMA
if VMA != CurrentVirtualMemoryAddressSpace:
- raise Exception("unknown interface") #Disclosing that the interface exists in different address is security hole
+ raise Exception("No such interface") #Disclosing that the interface exists in different address is security hole
assert(interface != NIL)
ctl0 = interface["ctl0"]
if ctl0 == NIL:
- raise Exception("Invalid Instruction")
+ raise Exception("No such Instruction")
- return ctl0(cookie, data)
+ return ctl0(cookie, data) # Here device takes over
- The other ext_ctl's are similar.
+The other ext_ctl's are similar.
==End RB==
cannot take a back seat. If it does, clear historical precedent shows
100% what the outcome will be (1).
* Making the mvendorid and marchid CSRs WARL solves the problem in a
- minimal to zero-disruptive fashion.
+ minimal to zero-disruptive backwards-compatible fashion that provides
+ indefinite transparent *forwards*-compatibility.
* The retro-fitting cost onto existing implementations (even though the
specification has not been finalised) is zero to negligeable
(only changes to words in the specification required at this time:
* Compliance Testing is straightforward and allows vendors to seek and
obtain *multiple* Compliance Certificates with past, present and future
variants of the RISC-V Standard (in the exact same processor,
- simultaneously), in order to support legacy customers and provide
- same customers with a way to avoid "impossible-to-make" decisions that
- throw out ultra-expensive multi-decade proprietary legacy software at
- the same as the (legacy) hardware.
+ simultaneously), in order to support end-customer legacy scenarios and
+ provide the same with a way to avoid "impossible-to-make" decisions that
+ throw out ultra-costly multi-decade-investment in proprietary legacy
+ software at the same as the (legacy) hardware.
-------