2-Defining an APB Model in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Defining an APB Model in Python\n",
    "\n",
    "In order to Verify our Register File Generator, we'll define an executable APB\n",
    "Model as a Python an object.  We'll use this model to generate the low-level\n",
    "input stimuli for issuing requests over the APBBus.\n",
    "\n",
    "This implementation is based on the [ARM AMBA 3 APB Protocol\n",
    "Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf), Copyright ©\n",
    "2003, 2004. ARM Limited. All rights reserved.  \n",
    "\n",
    "The basic architecture of our APBModel will be a Python object that translates\n",
    "various APB bus requests into low-level input stimuli.  That is, we'd like\n",
    "interface where can tell the model to write some data to a specifc address.\n",
    "The model is responsible for translating that request into a sequence of cycle\n",
    "accurate inputs for the APBBus.  Because this is a two way protocol, we'll also\n",
    "need a mechanism for providing inputs to the APB model that come from the slave\n",
    "(i.e. the `PREADY` line which a slave uses to indicate that a request has been\n",
    "processed).\n",
    "\n",
    "First, we define a helper function that will be used to cache our Python type\n",
    "generators.  This is essential so we can do comparisons of generated types\n",
    "(i.e. check if `type0 == type1`) by doing object equality.  Consider the\n",
    "following Python code for dynamically constructing a class with a parameter `n`\n",
    "that is used to set a class attribute `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_A(n):\n",
    "    class A:\n",
    "        __n = n\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we'd like to compare the equality of two invocations of this class\n",
    "factory function with the same parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_A(3) == make_A(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we'd like the result to be `True`. There's a few ways to handle\n",
    "this issue, but we'll use a cache based pattern to cache objects created\n",
    "by the `make_A` function based on the input parameter.  Python provides\n",
    "a built in library function to do this called `functools.lru_cache`\n",
    "(https://docs.python.org/3/library/functools.html#functools.lru_cache)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def make_A(n):\n",
    "    class A:\n",
    "        __n = n\n",
    "    return A\n",
    "\n",
    "make_A(3) == make_A(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`functools.lru_cache` memoizes calls to the function, but by default it doesn't\n",
    "handle keyword arguments with default values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@lru_cache(maxsize=None)\n",
    "def make_A(n=3):\n",
    "    class A:\n",
    "        __n = n\n",
    "    return A\n",
    "\n",
    "make_A(3) == make_A()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remedy this, we'll augment it with another decorater based on\n",
    "https://stackoverflow.com/questions/36771866/memoization-caching-with-default-optional-arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "from functools import wraps\n",
    "\n",
    "\n",
    "def canonicalize_args(f):\n",
    "    \"\"\"Wrapper for functools.lru_cache() to canonicalize default\n",
    "    and keyword arguments so cache hits are maximized.\"\"\"\n",
    "\n",
    "    @wraps(f)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        sig = inspect.getfullargspec(f.__wrapped__)\n",
    "\n",
    "        # build newargs by filling in defaults, args, kwargs\n",
    "        newargs = [None] * len(sig.args)\n",
    "        if sig.defaults is not None:\n",
    "            newargs[-len(sig.defaults):] = sig.defaults\n",
    "        newargs[:len(args)] = args\n",
    "        for name, value in kwargs.items():\n",
    "            newargs[sig.args.index(name)] = value\n",
    "\n",
    "        return f(*newargs)\n",
    "\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try it out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@canonicalize_args\n",
    "@lru_cache(maxsize=None)\n",
    "def make_A(n=3):\n",
    "    class A:\n",
    "        __n = n\n",
    "    return A\n",
    "\n",
    "make_A(3) == make_A()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this cacheing infrastructure in place, we'll now move on to defining our\n",
    "APB type generators as Python functions that return Python types modeling\n",
    "various components of the APB interface.\n",
    "\n",
    "First we'll define an enumerated type to model our APB commands.  We'll do this\n",
    "using the base types provided by the\n",
    "[hwtypes](https:/leonardt/hwtypes) Python package which provides\n",
    "various convenient algebraic data types (ADTs) including `Enum` and `Product`\n",
    "(we'll use Product next).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hwtypes import Enum, Product\n",
    "\n",
    "class APBCommand(Enum):\n",
    "    READ = 0\n",
    "    WRITE = 1\n",
    "    IDLE = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll define an `APB` type generator by extending Peak's `Product` type.\n",
    "Our complex APB type will be defined in terms of the more basic `Bit` and\n",
    "`BitVector` types from the [hwtypes](https:/leonardt/hwtypes)\n",
    "package.  These types provide a Python executable model for fixed width bit\n",
    "vectors and single bits with various operators defined.\n",
    "\n",
    "Here's an example of using these types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ^ b = Bit(True)\n",
      "~c & d = 1\n"
     ]
    }
   ],
   "source": [
    "from hwtypes import Bit, BitVector\n",
    "\n",
    "a = Bit(0)\n",
    "b = Bit(1)\n",
    "print(f\"a ^ b = {a ^ b}\")\n",
    "\n",
    "\n",
    "c = BitVector[4](0xE)\n",
    "d = BitVector[4](0xF)\n",
    "print(f\"~c & d = {~c & d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our APB type generator will create a `Product` type (similar to a struct in C)\n",
    "with fields corresponding to each port in the APB specification as defined in\n",
    "Table 4-1 (page 4-2) of the [APB\n",
    "Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "@canonicalize_args\n",
    "@lru_cache(maxsize=None)\n",
    "def APB(addr_width, data_width, num_slaves=1):\n",
    "    \"\"\"\n",
    "    Constructs a concrete APB type based on the `addr_width`, `data_width` and\n",
    "    `num_slaves` parameters.  Rather than using the standard subclassing\n",
    "    syntax, we dynamically construct a dictionary containing our field names\n",
    "    and types, then use Python's `type` function to construct our new type\n",
    "    definition.\n",
    "\n",
    "    This allows us to dynamically add more fields based on the number of\n",
    "    slaves.\n",
    "    \"\"\"\n",
    "    strobe_width = math.ceil(data_width / 8)\n",
    "\n",
    "    fields = {\n",
    "        \"PADDR\": BitVector[addr_width],\n",
    "        \"PWRITE\": Bit,\n",
    "    }\n",
    "\n",
    "    # Dynamically add `PSELx` fields based on `num_slaves` parameter\n",
    "    for i in range(num_slaves):\n",
    "        fields[f\"PSEL{i}\"] = Bit\n",
    "\n",
    "    fields.update({\n",
    "        \"PENABLE\": Bit,\n",
    "        \"PWDATA\": BitVector[data_width],\n",
    "        \"PRDATA\": BitVector[data_width],\n",
    "        \"PREADY\": Bit,\n",
    "        \"PSTRB\": BitVector[strobe_width],\n",
    "        \"PPROT\": Bit,\n",
    "        \"SLVERR\": Bit,\n",
    "    })\n",
    "\n",
    "    result = type(\"_APB\", (Product, ), fields)\n",
    "    return result\n",
    "\n",
    "\n",
    "def default_APB_instance(_APB):\n",
    "    \"\"\"\n",
    "    Convenience function to instantiate an _APB object with default values of 0\n",
    "    \"\"\"\n",
    "    fields = {}\n",
    "    for key, value in _APB.field_dict.items():\n",
    "        fields[key] = value(0)\n",
    "    return _APB(**fields)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= Type  ==========\n",
      "{'PADDR': <class 'hwtypes.bit_vector.BitVector[16]'>,\n",
      " 'PENABLE': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'PPROT': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'PRDATA': <class 'hwtypes.bit_vector.BitVector[32]'>,\n",
      " 'PREADY': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'PSEL0': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'PSEL1': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'PSTRB': <class 'hwtypes.bit_vector.BitVector[4]'>,\n",
      " 'PWDATA': <class 'hwtypes.bit_vector.BitVector[32]'>,\n",
      " 'PWRITE': <class 'hwtypes.bit_vector.Bit'>,\n",
      " 'SLVERR': <class 'hwtypes.bit_vector.Bit'>}\n",
      "==========================\n",
      "===== Default Value ======\n",
      "{'PADDR': BitVector[16](0),\n",
      " 'PENABLE': Bit(False),\n",
      " 'PPROT': Bit(False),\n",
      " 'PRDATA': BitVector[32](0),\n",
      " 'PREADY': Bit(False),\n",
      " 'PSEL0': Bit(False),\n",
      " 'PSEL1': Bit(False),\n",
      " 'PSTRB': BitVector[4](0),\n",
      " 'PWDATA': BitVector[32](0),\n",
      " 'PWRITE': Bit(False),\n",
      " 'SLVERR': Bit(False)}\n",
      "==========================\n"
     ]
    }
   ],
   "source": [
    "_APB = APB(16, 32, num_slaves=2)\n",
    "\n",
    "import pprint\n",
    "pp = pprint.PrettyPrinter()\n",
    "# We can use the `field_dict` property to fetch a dictionary mapping fields to\n",
    "# types in our concrete type definition\n",
    "print(\"========= Type  ==========\")\n",
    "pp.pprint(dict(_APB.field_dict))\n",
    "print(\"==========================\")\n",
    "# For an instance of the type, we can use `value_dict` to fetch a dictionary\n",
    "# mapping fields to values\n",
    "print(\"===== Default Value ======\")\n",
    "pp.pprint(dict(default_APB_instance(_APB).value_dict))\n",
    "print(\"==========================\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll define a type generator for an APB Request as a Product type with\n",
    "fields for a command, address, data, and slave id.  This type will be used\n",
    "to initiate a request using the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "@canonicalize_args\n",
    "@lru_cache(maxsize=None)\n",
    "def Request(addr_width, data_width, num_slaves):\n",
    "    class _Request(Product):\n",
    "        command = APBCommand\n",
    "        address = BitVector[addr_width]\n",
    "        data = BitVector[data_width]\n",
    "        slave_id = BitVector[max(math.ceil(math.log2(num_slaves)), 1)]\n",
    "    return _Request"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= Type  ==========\n",
      "{'address': <class 'hwtypes.bit_vector.BitVector[16]'>,\n",
      " 'command': APBCommand,\n",
      " 'data': <class 'hwtypes.bit_vector.BitVector[32]'>,\n",
      " 'slave_id': <class 'hwtypes.bit_vector.BitVector[1]'>}\n",
      "==========================\n",
      "===== Default Value ======\n",
      "{'address': BitVector[16](222),\n",
      " 'command': APBCommand.WRITE,\n",
      " 'data': BitVector[32](48879),\n",
      " 'slave_id': BitVector[1](1)}\n",
      "==========================\n"
     ]
    }
   ],
   "source": [
    "_Request = Request(16, 32, 2)\n",
    "\n",
    "print(\"========= Type  ==========\")\n",
    "pp.pprint(dict(_Request.field_dict))\n",
    "print(\"==========================\")\n",
    "request_val = _Request(APBCommand.WRITE, BitVector[16](0xDE),\n",
    "                       BitVector[32](0xBEEF), BitVector[1](1))\n",
    "print(\"===== Default Value ======\")\n",
    "pp.pprint(dict(request_val.value_dict))\n",
    "print(\"==========================\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll define a similar type to model the IO of our APBBus master which will\n",
    "consist of a request to execute and an APBBus.  We'll use `request` to initiate\n",
    "a request with the model and `apb` to sample the input stimuli.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@canonicalize_args\n",
    "@lru_cache(maxsize=None)\n",
    "def APBBusIO(addr_width, data_width, num_slaves=1):\n",
    "    class IO(Product):\n",
    "        apb = APB(addr_width, data_width, num_slaves)\n",
    "        request = Request(addr_width, data_width, num_slaves)\n",
    "    return IO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= Type  ==========\n",
      "{'apb': _APB, 'request': _Request}\n",
      "==========================\n",
      "===== Default Value ======\n",
      "{'apb': _APB(PADDR=0, PWRITE=Bit(False), PSEL0=Bit(False), PSEL1=Bit(False), PENABLE=Bit(False), PWDATA=0, PRDATA=0, PREADY=Bit(False), PSTRB=0, PPROT=Bit(False), SLVERR=Bit(False)),\n",
      " 'request': _Request(command=APBCommand.WRITE, address=222, data=48879, slave_id=1)}\n",
      "==========================\n"
     ]
    }
   ],
   "source": [
    "_APBBusIO = APBBusIO(16, 32, 2)\n",
    "\n",
    "print(\"========= Type  ==========\")\n",
    "pp.pprint(dict(_APBBusIO.field_dict))\n",
    "print(\"==========================\")\n",
    "print(\"===== Default Value ======\")\n",
    "pp.pprint(dict(_APBBusIO(default_APB_instance(_APB), request_val).value_dict))\n",
    "print(\"==========================\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll define a Python coroutine to model our APBBus with the ability to\n",
    "mock requests from a master.  The behavior of the coroutine will emulate the\n",
    "cycle-accurate behavior of the bus.  Thus, advancing the coroutine once will\n",
    "model advancing one clock cycle in time.  IO with the model will be perfromed\n",
    "by setting the `io` attribute (e.g. perform a read request by setting\n",
    "`io.request` and then advancing the coroutine and sampling the output values of\n",
    "`io.apb`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "@canonicalize_args\n",
    "@lru_cache(maxsize=None)\n",
    "def APBBus(addr_width, data_width, num_slaves=1):\n",
    "    # TODO: Does this need to be a generator?\n",
    "    class APBBus:\n",
    "        \"\"\"\n",
    "        This defines a coroutine that impelements the behavior of an APBBus.  The interface\n",
    "        to the coroutine is via the `__call__` method which accepts an instance\n",
    "        of the `APBBusIO` type.\n",
    "        \"\"\"\n",
    "        def __init__(self):\n",
    "            # Store the type of the interface so users can easily fetch it\n",
    "            self.IO = APBBusIO(addr_width, data_width, num_slaves)\n",
    "\n",
    "            # The main functionality of the coroutine is defined the `_main`\n",
    "            # method.  Because of how Python generators work, to emulate the\n",
    "            # standard behavior of a coroutine, the main function should be\n",
    "            # invoked once to create the generator object, then `next` is\n",
    "            # called to initialize the coroutine\n",
    "            # See http://www.dabeaz.com/coroutines/ for more info on Python\n",
    "            # coroutines\n",
    "            self.main = self._main()\n",
    "            next(self.main)\n",
    "            # TODO: This logic should move to the infrastructure and be\n",
    "            # provided as a simple way to construct a coroutine\n",
    "\n",
    "        def __call__(self, io):\n",
    "            \"\"\"\n",
    "            Calling the object equates to advancing the coroutine once.\n",
    "            IO is performed through the `io` attribute.\n",
    "            \"\"\"\n",
    "            self.io = io\n",
    "            self.main.send(None)\n",
    "\n",
    "        def _main(self):\n",
    "            \"\"\"\n",
    "            This main coroutine implements a state machine with three top-level\n",
    "            states corresponding to: reading, writing, and idleing.\n",
    "            \"\"\"\n",
    "            yield  # Initial state\n",
    "            while True:\n",
    "                if self.io.request.command == APBCommand.READ:\n",
    "                    yield from self.read(self.io.request.address,\n",
    "                                         self.io.request.data)\n",
    "                elif self.io.request.command == APBCommand.WRITE:\n",
    "                    yield from self.write(self.io.request.address,\n",
    "                                          self.io.request.data)\n",
    "                else:\n",
    "                    yield\n",
    "\n",
    "        def set_psel(self, value):\n",
    "            \"\"\"\n",
    "            Helper function that sets the correct PSEL line based on the\n",
    "            `slave_id` of the current request\n",
    "            \"\"\"\n",
    "            setattr(self.io.apb, f\"PSEL{self.io.request.slave_id}\", value)\n",
    "\n",
    "        def write(self, address, data):\n",
    "            \"\"\"\n",
    "            Issue a write as a sequence of output values:\n",
    "                * Set the address and write data lines based on the input\n",
    "                * Set PSEL for the requested slave\n",
    "                * Set PWRITE\n",
    "                * Wait one clock cycle\n",
    "                * Set PENABLE\n",
    "                * Wait one clock cycle\n",
    "                * Wait for PREADY to be high (from the slave)\n",
    "                * Clear PENABLE and PSEL\n",
    "            \"\"\"\n",
    "            self.io.apb.PADDR = address\n",
    "            self.io.apb.PWDATA = data\n",
    "            self.set_psel(Bit(1))\n",
    "            self.io.apb.PWRITE = Bit(1)\n",
    "            yield\n",
    "            self.io.apb.PENABLE = Bit(1)\n",
    "            yield\n",
    "            while not self.io.apb.PREADY:\n",
    "                # TODO: Insert timeout logic\n",
    "                yield\n",
    "            self.io.apb.PENABLE = Bit(0)\n",
    "            self.set_psel(Bit(0))\n",
    "\n",
    "        def read(self, address, data):\n",
    "            \"\"\"\n",
    "            Issue a read as a sequence of output values:\n",
    "                * Set the address line based on the input\n",
    "                * Set PSEL for the requested slave\n",
    "                * Clear PWRITE\n",
    "                * Wait one clock cycle\n",
    "                * Set PENABLE\n",
    "                * Wait one clock cycle\n",
    "                * Wait for PREADY to be high (from the slave)\n",
    "                * Clear PENABLE and PSEL\n",
    "            \"\"\"\n",
    "            self.io.apb.PADDR = address\n",
    "            self.set_psel(Bit(1))\n",
    "            self.io.apb.PWRITE = Bit(0)\n",
    "            yield\n",
    "            self.io.apb.PENABLE = Bit(1)\n",
    "            yield\n",
    "            while not self.io.apb.PREADY:\n",
    "                # TODO: Insert timeout logic\n",
    "                yield\n",
    "            self.io.apb.PENABLE = Bit(0)\n",
    "            self.set_psel(Bit(0))\n",
    "\n",
    "            # TODO: Handle PSLVERR and checking the expected data\n",
    "    return APBBus()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with our APBBus model defined, we should test it to verify that it\n",
    "generates the appropriate input stimuli for various commands.  To do this,\n",
    "we'll use the `waveform` package to generate a visual representation of the\n",
    "cycle level behavior of the model.  Here's an example of using the waveform\n",
    "module with the APB type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from waveform import WaveForm\n",
    "\n",
    "\n",
    "_APB = APB(16, 32)\n",
    "apb_fields = (field for field in _APB.field_dict)\n",
    "\n",
    "waveform = WaveForm(apb_fields, clock_name=\"PCLK\")\n",
    "apb = default_APB_instance(_APB)\n",
    "\n",
    "# Record intial state\n",
    "waveform.step(apb)\n",
    "\n",
    "# Step the clock\n",
    "apb.PCLK = Bit(1)\n",
    "waveform.step(apb)\n",
    "\n",
    "# Set some other fields\n",
    "apb.PWDATA = BitVector[32](0xDEADBEEF)\n",
    "apb.PADDR = BitVector[16](0xFEED)\n",
    "apb.PENABLE = Bit(1)\n",
    "apb.PSEL0 = Bit(1)\n",
    "apb.PWRITE = Bit(1)\n",
    "apb.PCLK = Bit(0)\n",
    "waveform.step(apb)\n",
    "\n",
    "for i in range(2):\n",
    "# Step the clock\n",
    "    apb.PCLK ^= apb.PCLK\n",
    "    waveform.step(apb)\n",
    "\n",
    "apb.PREADY = Bit(1)\n",
    "apb.PENABLE = Bit(0)\n",
    "\n",
    "for i in range(2):\n",
    "    apb.PCLK ^= apb.PCLK\n",
    "    waveform.step(apb)\n",
    "\n",
    "waveform.render_ipynb(\"waveform_example\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will write a test sequence of inputs to the model and record the outputs\n",
    "to verify the behavior for a write with no wait states.  Our expected output\n",
    "waveform should look similar to Figure 2-1 (page 2-2) of the [APB\n",
    "Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addr_width = 16\n",
    "data_width = 32\n",
    "bus = APBBus(addr_width, data_width)\n",
    "addr = 13\n",
    "data = 45\n",
    "request = Request(addr_width, data_width, 1)(\n",
    "    APBCommand.IDLE, BitVector[addr_width](addr),\n",
    "    BitVector[data_width](data), BitVector[1](0))\n",
    "\n",
    "# Specialized instance of APB for addr/data width\n",
    "_APB = APB(addr_width, data_width)\n",
    "\n",
    "io = APBBusIO(addr_width, data_width)(default_APB_instance(_APB), request)\n",
    "\n",
    "apb_fields = (field for field in _APB.field_dict)\n",
    "waveform = WaveForm(apb_fields, clock_name=\"PCLK\")\n",
    "\n",
    "# check idle stae\n",
    "for i in range(1):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "\n",
    "# Send request\n",
    "request.command = APBCommand.WRITE\n",
    "bus(io)\n",
    "assert io.apb.PSEL0 == 1\n",
    "\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "request.command = APBCommand.IDLE\n",
    "\n",
    "# No wait state\n",
    "io.apb.PREADY = Bit(1)\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "assert io.apb.PENABLE == 1\n",
    "assert io.apb.PSEL0 == 1\n",
    "\n",
    "bus(io)\n",
    "# Slave pulls PREADY down at the same time\n",
    "io.apb.PREADY = Bit(0)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "assert io.apb.PENABLE == 0\n",
    "assert io.apb.PSEL0 == 0\n",
    "\n",
    "io.apb.PWDATA = BitVector[data_width](0)\n",
    "\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "waveform.render_ipynb(\"write_no_wait\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next is a test for a write with a wait state which should look like Figure 2-2\n",
    "(pg 2-3) of the [APB\n",
    "Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addr_width = 16\n",
    "data_width = 32\n",
    "bus = APBBus(addr_width, data_width)\n",
    "addr = 13\n",
    "data = 45\n",
    "request = Request(addr_width, data_width, 1)(\n",
    "    APBCommand.IDLE, BitVector[addr_width](addr), BitVector[data_width](data), BitVector[1](0))\n",
    "\n",
    "# Specialized instance of APB for addr/data width\n",
    "_APB = APB(addr_width, data_width)\n",
    "\n",
    "io = APBBusIO(addr_width, data_width)(\n",
    "    default_APB_instance(_APB), request)\n",
    "\n",
    "apb_fields = (field for field in _APB.field_dict)\n",
    "waveform = WaveForm(apb_fields, clock_name=\"PCLK\")\n",
    "\n",
    "# check idle stae\n",
    "for i in range(1):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "\n",
    "# Send request\n",
    "request.command = APBCommand.WRITE\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "assert io.apb.PSEL0 == 1\n",
    "assert io.apb.PWRITE == 1\n",
    "\n",
    "request.command = APBCommand.IDLE\n",
    "\n",
    "# Wait by holding PREADY down\n",
    "io.apb.PREADY = Bit(0)\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "assert io.apb.PENABLE == 1\n",
    "assert io.apb.PSEL0 == 1\n",
    "assert io.apb.PWRITE == 1\n",
    "\n",
    "for i in range(2):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "    assert io.apb.PENABLE == 1\n",
    "    assert io.apb.PSEL0 == 1\n",
    "    assert io.apb.PWRITE == 1\n",
    "\n",
    "bus(io)\n",
    "# PREADY high when done\n",
    "io.apb.PREADY = Bit(1)\n",
    "waveform.step(bus.io.apb)\n",
    "bus(io)\n",
    "io.apb.PREADY = Bit(0)\n",
    "io.apb.PWDATA = BitVector[data_width](0)\n",
    "waveform.step(bus.io.apb)\n",
    "assert io.apb.PENABLE == 0\n",
    "assert io.apb.PSEL0 == 0\n",
    "waveform.render_ipynb(\"write_with_wait\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly we can test a read with no wait which should look like\n",
    "Figure 2-3 (pg 2-4) of the [APB\n",
    "Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addr_width = 16\n",
    "data_width = 32\n",
    "bus = APBBus(addr_width, data_width)\n",
    "addr = 13\n",
    "data = 0\n",
    "request = Request(addr_width, data_width, 1)(\n",
    "    APBCommand.IDLE, BitVector[addr_width](addr), BitVector[data_width](data), BitVector[1](0))\n",
    "\n",
    "# Specialized instance of APB for addr/data width\n",
    "_APB = APB(addr_width, data_width)\n",
    "\n",
    "io = APBBusIO(addr_width, data_width)(default_APB_instance(_APB), request)\n",
    "\n",
    "apb_fields = (field for field in _APB.field_dict)\n",
    "waveform = WaveForm(apb_fields, clock_name=\"PCLK\")\n",
    "\n",
    "# check idle stae\n",
    "for i in range(1):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "\n",
    "# Send request\n",
    "request.command = APBCommand.READ\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "request.command = APBCommand.IDLE\n",
    "\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "assert io.apb.PENABLE == 1\n",
    "\n",
    "# No wait state\n",
    "bus(io)\n",
    "io.apb.PREADY = Bit(1)\n",
    "io.apb.PRDATA = BitVector[data_width](13)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "bus(io)\n",
    "io.apb.PREADY = Bit(0)\n",
    "io.apb.PRDATA = BitVector[data_width](0)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "assert io.apb.PENABLE == 0\n",
    "assert io.apb.PSEL0 == 0\n",
    "waveform.render_ipynb(\"read_no_wait\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And test a read with a wait state which should look like Figure 2-4 (pg 2-5) of\n",
    "the [APB Specification](https://static.docs.arm.com/ihi0024/b/AMBA3apb.pdf).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addr_width = 16\n",
    "data_width = 32\n",
    "bus = APBBus(addr_width, data_width)\n",
    "addr = 13\n",
    "data = 0\n",
    "request = Request(addr_width, data_width, 1)(\n",
    "    APBCommand.IDLE, BitVector[addr_width](addr), BitVector[data_width](data), BitVector[1](0))\n",
    "\n",
    "# Specialized instance of APB for addr/data width\n",
    "_APB = APB(addr_width, data_width)\n",
    "\n",
    "io = APBBusIO(addr_width, data_width)(default_APB_instance(_APB), request)\n",
    "\n",
    "apb_fields = (field for field in _APB.field_dict)\n",
    "waveform = WaveForm(apb_fields, clock_name=\"PCLK\")\n",
    "\n",
    "# check idle stae\n",
    "for i in range(1):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "\n",
    "# Send request\n",
    "request.command = APBCommand.READ\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "request.command = APBCommand.IDLE\n",
    "\n",
    "bus(io)\n",
    "waveform.step(bus.io.apb)\n",
    "assert io.apb.PENABLE == 1\n",
    "\n",
    "for i in range(2):\n",
    "    bus(io)\n",
    "    waveform.step(bus.io.apb)\n",
    "\n",
    "bus(io)\n",
    "io.apb.PREADY = Bit(1)\n",
    "io.apb.PRDATA = BitVector[data_width](13)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "bus(io)\n",
    "io.apb.PREADY = Bit(0)\n",
    "io.apb.PRDATA = BitVector[data_width](0)\n",
    "waveform.step(bus.io.apb)\n",
    "\n",
    "assert io.apb.PENABLE == 0\n",
    "assert io.apb.PSEL0 == 0\n",
    "waveform.render_ipynb(\"write_no_wait\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next notebook, we'll demonstrate how to use this APBModel to verify the\n",
    "register file."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}