mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
10 KiB
297 lines
10 KiB
VME Device Drivers |
|
================== |
|
|
|
Driver registration |
|
------------------- |
|
|
|
As with other subsystems within the Linux kernel, VME device drivers register |
|
with the VME subsystem, typically called from the devices init routine. This is |
|
achieved via a call to :c:func:`vme_register_driver`. |
|
|
|
A pointer to a structure of type :c:type:`struct vme_driver <vme_driver>` must |
|
be provided to the registration function. Along with the maximum number of |
|
devices your driver is able to support. |
|
|
|
At the minimum, the '.name', '.match' and '.probe' elements of |
|
:c:type:`struct vme_driver <vme_driver>` should be correctly set. The '.name' |
|
element is a pointer to a string holding the device driver's name. |
|
|
|
The '.match' function allows control over which VME devices should be registered |
|
with the driver. The match function should return 1 if a device should be |
|
probed and 0 otherwise. This example match function (from vme_user.c) limits |
|
the number of devices probed to one: |
|
|
|
.. code-block:: c |
|
|
|
#define USER_BUS_MAX 1 |
|
... |
|
static int vme_user_match(struct vme_dev *vdev) |
|
{ |
|
if (vdev->id.num >= USER_BUS_MAX) |
|
return 0; |
|
return 1; |
|
} |
|
|
|
The '.probe' element should contain a pointer to the probe routine. The |
|
probe routine is passed a :c:type:`struct vme_dev <vme_dev>` pointer as an |
|
argument. |
|
|
|
Here, the 'num' field refers to the sequential device ID for this specific |
|
driver. The bridge number (or bus number) can be accessed using |
|
dev->bridge->num. |
|
|
|
A function is also provided to unregister the driver from the VME core called |
|
:c:func:`vme_unregister_driver` and should usually be called from the device |
|
driver's exit routine. |
|
|
|
|
|
Resource management |
|
------------------- |
|
|
|
Once a driver has registered with the VME core the provided match routine will |
|
be called the number of times specified during the registration. If a match |
|
succeeds, a non-zero value should be returned. A zero return value indicates |
|
failure. For all successful matches, the probe routine of the corresponding |
|
driver is called. The probe routine is passed a pointer to the devices |
|
device structure. This pointer should be saved, it will be required for |
|
requesting VME resources. |
|
|
|
The driver can request ownership of one or more master windows |
|
(:c:func:`vme_master_request`), slave windows (:c:func:`vme_slave_request`) |
|
and/or dma channels (:c:func:`vme_dma_request`). Rather than allowing the device |
|
driver to request a specific window or DMA channel (which may be used by a |
|
different driver) the API allows a resource to be assigned based on the required |
|
attributes of the driver in question. For slave windows these attributes are |
|
split into the VME address spaces that need to be accessed in 'aspace' and VME |
|
bus cycle types required in 'cycle'. Master windows add a further set of |
|
attributes in 'width' specifying the required data transfer widths. These |
|
attributes are defined as bitmasks and as such any combination of the |
|
attributes can be requested for a single window, the core will assign a window |
|
that meets the requirements, returning a pointer of type vme_resource that |
|
should be used to identify the allocated resource when it is used. For DMA |
|
controllers, the request function requires the potential direction of any |
|
transfers to be provided in the route attributes. This is typically VME-to-MEM |
|
and/or MEM-to-VME, though some hardware can support VME-to-VME and MEM-to-MEM |
|
transfers as well as test pattern generation. If an unallocated window fitting |
|
the requirements can not be found a NULL pointer will be returned. |
|
|
|
Functions are also provided to free window allocations once they are no longer |
|
required. These functions (:c:func:`vme_master_free`, :c:func:`vme_slave_free` |
|
and :c:func:`vme_dma_free`) should be passed the pointer to the resource |
|
provided during resource allocation. |
|
|
|
|
|
Master windows |
|
-------------- |
|
|
|
Master windows provide access from the local processor[s] out onto the VME bus. |
|
The number of windows available and the available access modes is dependent on |
|
the underlying chipset. A window must be configured before it can be used. |
|
|
|
|
|
Master window configuration |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
Once a master window has been assigned :c:func:`vme_master_set` can be used to |
|
configure it and :c:func:`vme_master_get` to retrieve the current settings. The |
|
address spaces, transfer widths and cycle types are the same as described |
|
under resource management, however some of the options are mutually exclusive. |
|
For example, only one address space may be specified. |
|
|
|
|
|
Master window access |
|
~~~~~~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_master_read` can be used to read from and |
|
:c:func:`vme_master_write` used to write to configured master windows. |
|
|
|
In addition to simple reads and writes, :c:func:`vme_master_rmw` is provided to |
|
do a read-modify-write transaction. Parts of a VME window can also be mapped |
|
into user space memory using :c:func:`vme_master_mmap`. |
|
|
|
|
|
Slave windows |
|
------------- |
|
|
|
Slave windows provide devices on the VME bus access into mapped portions of the |
|
local memory. The number of windows available and the access modes that can be |
|
used is dependent on the underlying chipset. A window must be configured before |
|
it can be used. |
|
|
|
|
|
Slave window configuration |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
Once a slave window has been assigned :c:func:`vme_slave_set` can be used to |
|
configure it and :c:func:`vme_slave_get` to retrieve the current settings. |
|
|
|
The address spaces, transfer widths and cycle types are the same as described |
|
under resource management, however some of the options are mutually exclusive. |
|
For example, only one address space may be specified. |
|
|
|
|
|
Slave window buffer allocation |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
Functions are provided to allow the user to allocate |
|
(:c:func:`vme_alloc_consistent`) and free (:c:func:`vme_free_consistent`) |
|
contiguous buffers which will be accessible by the VME bridge. These functions |
|
do not have to be used, other methods can be used to allocate a buffer, though |
|
care must be taken to ensure that they are contiguous and accessible by the VME |
|
bridge. |
|
|
|
|
|
Slave window access |
|
~~~~~~~~~~~~~~~~~~~ |
|
|
|
Slave windows map local memory onto the VME bus, the standard methods for |
|
accessing memory should be used. |
|
|
|
|
|
DMA channels |
|
------------ |
|
|
|
The VME DMA transfer provides the ability to run link-list DMA transfers. The |
|
API introduces the concept of DMA lists. Each DMA list is a link-list which can |
|
be passed to a DMA controller. Multiple lists can be created, extended, |
|
executed, reused and destroyed. |
|
|
|
|
|
List Management |
|
~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_new_dma_list` is provided to create and |
|
:c:func:`vme_dma_list_free` to destroy DMA lists. Execution of a list will not |
|
automatically destroy the list, thus enabling a list to be reused for repetitive |
|
tasks. |
|
|
|
|
|
List Population |
|
~~~~~~~~~~~~~~~ |
|
|
|
An item can be added to a list using :c:func:`vme_dma_list_add` (the source and |
|
destination attributes need to be created before calling this function, this is |
|
covered under "Transfer Attributes"). |
|
|
|
.. note:: |
|
|
|
The detailed attributes of the transfers source and destination |
|
are not checked until an entry is added to a DMA list, the request |
|
for a DMA channel purely checks the directions in which the |
|
controller is expected to transfer data. As a result it is |
|
possible for this call to return an error, for example if the |
|
source or destination is in an unsupported VME address space. |
|
|
|
Transfer Attributes |
|
~~~~~~~~~~~~~~~~~~~ |
|
|
|
The attributes for the source and destination are handled separately from adding |
|
an item to a list. This is due to the diverse attributes required for each type |
|
of source and destination. There are functions to create attributes for PCI, VME |
|
and pattern sources and destinations (where appropriate): |
|
|
|
- PCI source or destination: :c:func:`vme_dma_pci_attribute` |
|
- VME source or destination: :c:func:`vme_dma_vme_attribute` |
|
- Pattern source: :c:func:`vme_dma_pattern_attribute` |
|
|
|
The function :c:func:`vme_dma_free_attribute` should be used to free an |
|
attribute. |
|
|
|
|
|
List Execution |
|
~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_dma_list_exec` queues a list for execution and will |
|
return once the list has been executed. |
|
|
|
|
|
Interrupts |
|
---------- |
|
|
|
The VME API provides functions to attach and detach callbacks to specific VME |
|
level and status ID combinations and for the generation of VME interrupts with |
|
specific VME level and status IDs. |
|
|
|
|
|
Attaching Interrupt Handlers |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_irq_request` can be used to attach and |
|
:c:func:`vme_irq_free` to free a specific VME level and status ID combination. |
|
Any given combination can only be assigned a single callback function. A void |
|
pointer parameter is provided, the value of which is passed to the callback |
|
function, the use of this pointer is user undefined. The callback parameters are |
|
as follows. Care must be taken in writing a callback function, callback |
|
functions run in interrupt context: |
|
|
|
.. code-block:: c |
|
|
|
void callback(int level, int statid, void *priv); |
|
|
|
|
|
Interrupt Generation |
|
~~~~~~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_irq_generate` can be used to generate a VME interrupt |
|
at a given VME level and VME status ID. |
|
|
|
|
|
Location monitors |
|
----------------- |
|
|
|
The VME API provides the following functionality to configure the location |
|
monitor. |
|
|
|
|
|
Location Monitor Management |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_lm_request` is provided to request the use of a block |
|
of location monitors and :c:func:`vme_lm_free` to free them after they are no |
|
longer required. Each block may provide a number of location monitors, |
|
monitoring adjacent locations. The function :c:func:`vme_lm_count` can be used |
|
to determine how many locations are provided. |
|
|
|
|
|
Location Monitor Configuration |
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
|
|
Once a bank of location monitors has been allocated, the function |
|
:c:func:`vme_lm_set` is provided to configure the location and mode of the |
|
location monitor. The function :c:func:`vme_lm_get` can be used to retrieve |
|
existing settings. |
|
|
|
|
|
Location Monitor Use |
|
~~~~~~~~~~~~~~~~~~~~ |
|
|
|
The function :c:func:`vme_lm_attach` enables a callback to be attached and |
|
:c:func:`vme_lm_detach` allows on to be detached from each location monitor |
|
location. Each location monitor can monitor a number of adjacent locations. The |
|
callback function is declared as follows. |
|
|
|
.. code-block:: c |
|
|
|
void callback(void *data); |
|
|
|
|
|
Slot Detection |
|
-------------- |
|
|
|
The function :c:func:`vme_slot_num` returns the slot ID of the provided bridge. |
|
|
|
|
|
Bus Detection |
|
------------- |
|
|
|
The function :c:func:`vme_bus_num` returns the bus ID of the provided bridge. |
|
|
|
|
|
VME API |
|
------- |
|
|
|
.. kernel-doc:: include/linux/vme.h |
|
:internal: |
|
|
|
.. kernel-doc:: drivers/vme/vme.c |
|
:export:
|
|
|