Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset d51838f in mainline


Ignore:
Timestamp:
2017-10-14T22:49:18Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
75911d24
Parents:
ce732e74
Message:

Let leaf drivers enable/disable/clear interrupts via hw_res instead of directly using irc.

Location:
uspace
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/audio/hdaudio/hdaudio.c

    rce732e74 rd51838f  
    3636#include <bitops.h>
    3737#include <ddi.h>
     38#include <device/hw_res.h>
    3839#include <device/hw_res_parsed.h>
    39 #include <irc.h>
    4040#include <stdio.h>
    4141#include <errno.h>
     
    257257        ddf_msg(LVL_NOTE, "range0.base=%zu", hdaudio_irq_pio_ranges[0].base);
    258258
    259         rc = irc_enable_interrupt(res.irqs.irqs[0]);
     259        rc = hw_res_enable_interrupt(hda->parent_sess, res.irqs.irqs[0]);
    260260        if (rc != EOK) {
    261261                ddf_msg(LVL_ERROR, "Failed enabling interrupt. (%d)", rc);
  • uspace/drv/block/ahci/ahci.c

    rce732e74 rd51838f  
    3636#include <ddf/interrupt.h>
    3737#include <ddf/log.h>
     38#include <device/hw_res.h>
    3839#include <device/hw_res_parsed.h>
    3940#include <pci_dev_iface.h>
    40 #include <irc.h>
    4141#include <ahci_iface.h>
    4242#include "ahci.h"
     
    11921192        }
    11931193       
    1194         int rc = irc_enable_interrupt(hw_res_parsed.irqs.irqs[0]);
     1194        int rc = hw_res_enable_interrupt(ahci->parent_sess,
     1195            hw_res_parsed.irqs.irqs[0]);
    11951196        if (rc != EOK) {
    11961197                ddf_msg(LVL_ERROR, "Failed enable interupt.");
  • uspace/drv/bus/isa/isa.c

    rce732e74 rd51838f  
    115115}
    116116
    117 static int isa_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
    118 {
    119         isa_fun_t *fun = isa_fun(fnode);
     117static bool isa_fun_owns_interrupt(isa_fun_t *fun, int irq)
     118{
    120119        const hw_resource_list_t *res = &fun->hw_resources;
    121         bool found;
    122120
    123121        /* Check that specified irq really belongs to the function */
    124         found = false;
    125122        for (size_t i = 0; i < res->count; ++i) {
    126123                if (res->resources[i].type == INTERRUPT &&
    127124                    res->resources[i].res.interrupt.irq == irq) {
    128                         found = true;
    129                         break;
    130                 }
    131         }
    132 
    133         if (!found)
     125                        return true;
     126                }
     127        }
     128
     129        return false;
     130}
     131
     132static int isa_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
     133{
     134        isa_fun_t *fun = isa_fun(fnode);
     135
     136        if (!isa_fun_owns_interrupt(fun, irq))
    134137                return EINVAL;
    135138
    136139        return irc_enable_interrupt(irq);
     140}
     141
     142static int isa_fun_disable_interrupt(ddf_fun_t *fnode, int irq)
     143{
     144        isa_fun_t *fun = isa_fun(fnode);
     145
     146        if (!isa_fun_owns_interrupt(fun, irq))
     147                return EINVAL;
     148
     149        return irc_disable_interrupt(irq);
     150}
     151
     152static int isa_fun_clear_interrupt(ddf_fun_t *fnode, int irq)
     153{
     154        isa_fun_t *fun = isa_fun(fnode);
     155
     156        if (!isa_fun_owns_interrupt(fun, irq))
     157                return EINVAL;
     158
     159        return irc_clear_interrupt(irq);
    137160}
    138161
     
    185208        .get_resource_list = isa_fun_get_resources,
    186209        .enable_interrupt = isa_fun_enable_interrupt,
     210        .disable_interrupt = isa_fun_disable_interrupt,
     211        .clear_interrupt = isa_fun_clear_interrupt,
    187212        .dma_channel_setup = isa_fun_setup_dma,
    188213        .dma_channel_remain = isa_fun_remain_dma,
  • uspace/drv/bus/pci/pciintel/pci.c

    rce732e74 rd51838f  
    9999}
    100100
     101static int pciintel_fun_owns_interrupt(pci_fun_t *fun, int irq)
     102{
     103        size_t i;
     104        hw_resource_list_t *res = &fun->hw_resources;
     105       
     106        for (i = 0; i < res->count; i++) {
     107                if (res->resources[i].type == INTERRUPT &&
     108                    res->resources[i].res.interrupt.irq == irq) {
     109                        return true;
     110                }
     111        }
     112       
     113        return false;
     114}
     115
    101116static int pciintel_enable_interrupt(ddf_fun_t *fnode, int irq)
    102117{
    103         pci_fun_t *dev_data = pci_fun(fnode);
    104        
    105         size_t i;
    106         hw_resource_list_t *res = &dev_data->hw_resources;
    107         bool found = false;
    108        
    109         found = false;
    110         for (i = 0; i < res->count; i++) {
    111                 if (res->resources[i].type == INTERRUPT) {
    112                         found = true;
    113                         break;
    114                 }
    115         }
    116        
    117         if (!found)
     118        pci_fun_t *fun = pci_fun(fnode);
     119       
     120        if (!pciintel_fun_owns_interrupt(fun, irq))
    118121                return EINVAL;
    119        
     122
    120123        return irc_enable_interrupt(irq);
     124}
     125
     126static int pciintel_disable_interrupt(ddf_fun_t *fnode, int irq)
     127{
     128        pci_fun_t *fun = pci_fun(fnode);
     129       
     130        if (!pciintel_fun_owns_interrupt(fun, irq))
     131                return EINVAL;
     132
     133        return irc_disable_interrupt(irq);
     134}
     135
     136static int pciintel_clear_interrupt(ddf_fun_t *fnode, int irq)
     137{
     138        pci_fun_t *fun = pci_fun(fnode);
     139       
     140        if (!pciintel_fun_owns_interrupt(fun, irq))
     141                return EINVAL;
     142
     143        return irc_clear_interrupt(irq);
    121144}
    122145
     
    188211        .get_resource_list = &pciintel_get_resources,
    189212        .enable_interrupt = &pciintel_enable_interrupt,
     213        .disable_interrupt = &pciintel_disable_interrupt,
     214        .clear_interrupt = &pciintel_clear_interrupt,
    190215};
    191216
  • uspace/drv/char/ns8250/ns8250.c

    rce732e74 rd51838f  
    5555#include <ops/char_dev.h>
    5656
    57 #include <irc.h>
    5857#include <device/hw_res.h>
    5958#include <ipc/serial_ctl.h>
     
    154153        /** DDF function node */
    155154        ddf_fun_t *fun;
     155        /** Parent session */
     156        async_sess_t *parent_sess;
    156157        /** I/O registers **/
    157158        ns8250_regs_t *regs;
     
    382383static int ns8250_dev_initialize(ns8250_t *ns)
    383384{
    384         async_sess_t *parent_sess;
    385385        int ret = EOK;
    386386       
     
    390390        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    391391       
    392         /* Connect to the parent's driver. */
    393         parent_sess = ddf_dev_parent_sess_get(ns->dev);
    394         if (parent_sess == NULL) {
    395                 ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
    396                     "device %s.", ddf_dev_get_name(ns->dev));
    397                 ret = ENOENT;
    398                 goto failed;
    399         }
    400        
    401392        /* Get hw resources. */
    402         ret = hw_res_get_resource_list(parent_sess, &hw_resources);
     393        ret = hw_res_get_resource_list(ns->parent_sess, &hw_resources);
    403394        if (ret != EOK) {
    404395                ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
     
    487478{
    488479        /* Enable interrupt using IRC service. */
    489         int rc = irc_enable_interrupt(ns->irq);
     480        int rc = hw_res_enable_interrupt(ns->parent_sess, ns->irq);
    490481        if (rc != EOK)
    491482                return EIO;
     
    780771       
    781772        ns8250_read_from_device(ns);
    782         irc_clear_interrupt(ns->irq);
     773        hw_res_clear_interrupt(ns->parent_sess, ns->irq);
    783774}
    784775
     
    829820        fibril_condvar_initialize(&ns->input_buffer_available);
    830821        ns->dev = dev;
     822       
     823        ns->parent_sess = ddf_dev_parent_sess_get(ns->dev);
     824        if (ns->parent_sess == NULL) {
     825                ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
     826                    "device %s.", ddf_dev_get_name(ns->dev));
     827                rc = EIO;
     828                goto fail;
     829        }
    831830       
    832831        rc = ns8250_dev_initialize(ns);
  • uspace/drv/char/pl050/pl050.c

    rce732e74 rd51838f  
    3838#include <ddf/interrupt.h>
    3939#include <ddf/log.h>
     40#include <device/hw_res.h>
    4041#include <device/hw_res_parsed.h>
    4142#include <io/chardev_srv.h>
    42 #include <irc.h>
    4343
    4444#include "pl050_hw.h"
     
    221221        }
    222222
    223         rc = irc_enable_interrupt(res.irqs.irqs[0]);
     223        rc = hw_res_enable_interrupt(pl050->parent_sess, res.irqs.irqs[0]);
    224224        if (rc != EOK) {
    225225                ddf_msg(LVL_ERROR, "Failed enabling interrupt. (%d)", rc);
  • uspace/drv/nic/e1k/e1k.c

    rce732e74 rd51838f  
    4040#include <thread.h>
    4141#include <byteorder.h>
    42 #include <irc.h>
    4342#include <as.h>
    4443#include <ddi.h>
    4544#include <ddf/log.h>
    4645#include <ddf/interrupt.h>
     46#include <device/hw_res.h>
    4747#include <device/hw_res_parsed.h>
    4848#include <pci_dev_iface.h>
     
    116116/** E1000 device data */
    117117typedef struct {
     118        /** DDF device */
     119        ddf_dev_t *dev;
     120        /** Parent session */
     121        async_sess_t *parent_sess;
    118122        /** Device configuration */
    119123        e1000_info_t info;
     
    17571761        e1000_enable_interrupts(e1000);
    17581762       
    1759         int rc = irc_enable_interrupt(e1000->irq);
     1763        int rc = hw_res_enable_interrupt(e1000->parent_sess, e1000->irq);
    17601764        if (rc != EOK) {
    17611765                e1000_disable_interrupts(e1000);
     
    18021806        e1000_disable_rx(e1000);
    18031807       
    1804         irc_disable_interrupt(e1000->irq);
     1808        hw_res_disable_interrupt(e1000->parent_sess, e1000->irq);
    18051809        e1000_disable_interrupts(e1000);
    18061810       
     
    18841888       
    18851889        memset(e1000, 0, sizeof(e1000_t));
     1890        e1000->dev = dev;
    18861891       
    18871892        nic_set_specific(nic, e1000);
     
    19982003                ddf_msg(LVL_ERROR, "Unable to allocate device softstate");
    19992004                return ENOMEM;
     2005        }
     2006       
     2007        e1000->parent_sess = ddf_dev_parent_sess_get(dev);
     2008        if (e1000->parent_sess == NULL) {
     2009                ddf_msg(LVL_ERROR, "Failed connecting parent device.");
     2010                return EIO;
    20002011        }
    20012012       
     
    21192130{
    21202131        ddf_fun_t *fun;
    2121         assert(dev);
    21222132       
    21232133        /* Initialize device structure for E1000 */
  • uspace/drv/nic/ne2k/dp8390.h

    rce732e74 rd51838f  
    5050#define __NET_NETIF_DP8390_H__
    5151
     52#include <async.h>
     53#include <ddf/driver.h>
    5254#include <fibril_synch.h>
    5355#include <nic.h>
     
    223225
    224226typedef struct {
     227        /** DDF device */
     228        ddf_dev_t *dev;
     229        /** Parent session */
     230        async_sess_t *parent_sess;
    225231        /* Device configuration */
    226232        void *base_port; /**< Port assigned from ISA configuration **/
  • uspace/drv/nic/ne2k/ne2k.c

    rce732e74 rd51838f  
    4040#include <stdio.h>
    4141#include <errno.h>
    42 #include <irc.h>
     42#include <device/hw_res.h>
    4343#include <stdlib.h>
    4444#include <str_error.h>
     
    256256                        return rc;
    257257
    258                 rc = irc_enable_interrupt(ne2k->irq);
     258                rc = hw_res_enable_interrupt(ne2k->parent_sess, ne2k->irq);
    259259                if (rc != EOK) {
    260260                        ne2k_down(ne2k);
     
    269269        ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
    270270
    271         (void) irc_disable_interrupt(ne2k->irq);
     271        (void) hw_res_disable_interrupt(ne2k->parent_sess, ne2k->irq);
    272272        ne2k->receive_configuration = RCR_AB | RCR_AM;
    273273        ne2k_down(ne2k);
     
    384384        }
    385385       
     386        ne2k->dev = dev;
     387        ne2k->parent_sess = ddf_dev_parent_sess_get(dev);
     388        if (ne2k->parent_sess == NULL) {
     389                ne2k_dev_cleanup(dev);
     390                return ENOMEM;
     391        }
     392       
    386393        int rc = ne2k_dev_init(nic_data);
    387394        if (rc != EOK) {
  • uspace/drv/nic/rtl8139/driver.c

    rce732e74 rd51838f  
    3636#include <ddf/log.h>
    3737#include <ddf/interrupt.h>
     38#include <device/hw_res.h>
    3839#include <io/log.h>
    3940#include <nic.h>
    4041#include <pci_dev_iface.h>
    41 #include <irc.h>
    4242#include <stdio.h>
    4343#include <str.h>
     
    920920        rtl8139_hw_int_set(rtl8139);
    921921
    922         int rc = irc_enable_interrupt(rtl8139->irq);
     922        int rc = hw_res_enable_interrupt(rtl8139->parent_sess, rtl8139->irq);
    923923        if (rc != EOK) {
    924924                rtl8139_on_stopped(nic_data);
     
    976976                return NULL;
    977977
    978         rtl8139_t *rtl8139 = malloc(sizeof(rtl8139_t));
     978        rtl8139_t *rtl8139 = calloc(1, sizeof(rtl8139_t));
    979979        if (!rtl8139) {
    980980                nic_unbind_and_destroy(dev);
     
    982982        }
    983983
    984         memset(rtl8139, 0, sizeof(rtl8139_t));
     984        rtl8139->dev = dev;
    985985
    986986        rtl8139->nic_data = nic_data;
     
    11661166
    11671167        ddf_msg(LVL_DEBUG, "rtl8139: dev_data created");
     1168        rtl8139->parent_sess = ddf_dev_parent_sess_get(dev);
     1169        if (rtl8139->parent_sess == NULL) {
     1170                ddf_msg(LVL_ERROR, "Error connecting parent device.");
     1171                return EIO;
     1172        }
    11681173
    11691174        /* Obtain and fill hardware resources info and connect to parent */
     
    12581263        ddf_fun_t *fun;
    12591264
    1260         assert(dev);
    12611265        ddf_msg(LVL_NOTE, "RTL8139_dev_add %s (handle = %zu)",
    12621266            ddf_dev_get_name(dev), ddf_dev_get_handle(dev));
  • uspace/drv/nic/rtl8139/driver.h

    rce732e74 rd51838f  
    8787/** RTL8139 device data */
    8888typedef struct rtl8139_data {
     89        /** DDF device */
     90        ddf_dev_t *dev;
     91        /** Parent session */
     92        async_sess_t *parent_sess;
    8993        /** I/O address of the device */
    9094        void *io_addr;
  • uspace/drv/nic/rtl8169/driver.c

    rce732e74 rd51838f  
    3131#include <align.h>
    3232#include <byteorder.h>
    33 #include <irc.h>
    3433#include <libarch/barrier.h>
    3534
     
    3837#include <ddf/log.h>
    3938#include <ddf/interrupt.h>
     39#include <device/hw_res.h>
     40#include <device/hw_res_parsed.h>
    4041#include <io/log.h>
    4142#include <nic.h>
    4243#include <pci_dev_iface.h>
    4344
    44 #include <ipc/irc.h>
    4545#include <sysinfo.h>
    4646#include <ipc/ns.h>
     
    396396        rtl8169_t *rtl8169 = nic_get_specific(nic_data);
    397397
     398        rtl8169->dev = dev;
     399        rtl8169->parent_sess = ddf_dev_parent_sess_get(dev);
     400        if (rtl8169->parent_sess == NULL)
     401                return EIO;
     402
    398403        /* Get PCI VID & PID */
    399         rc = pci_config_space_read_16(ddf_dev_parent_sess_get(dev),
    400             PCI_VENDOR_ID, &rtl8169->pci_vid);
     404        rc = pci_config_space_read_16(rtl8169->parent_sess, PCI_VENDOR_ID,
     405            &rtl8169->pci_vid);
    401406        if (rc != EOK)
    402407                return rc;
    403408
    404         rc = pci_config_space_read_16(ddf_dev_parent_sess_get(dev),
    405             PCI_DEVICE_ID, &rtl8169->pci_pid);
     409        rc = pci_config_space_read_16(rtl8169->parent_sess, PCI_DEVICE_ID,
     410            &rtl8169->pci_pid);
    406411        if (rc != EOK)
    407412                return rc;
     
    745750
    746751        pio_write_16(rtl8169->regs + IMR, 0xffff);
    747         irc_enable_interrupt(rtl8169->irq);
     752        /* XXX Check return value */
     753        hw_res_enable_interrupt(rtl8169->parent_sess, rtl8169->irq);
    748754
    749755        return EOK;
  • uspace/drv/nic/rtl8169/driver.h

    rce732e74 rd51838f  
    4949/** RTL8139 device data */
    5050typedef struct rtl8169_data {
     51        /** DDF device */
     52        ddf_dev_t *dev;
     53        /** Parent session */
     54        async_sess_t *parent_sess;
    5155        /** I/O address of the device */
    5256        void *regs_phys;
  • uspace/drv/platform/icp/icp.c

    rce732e74 rd51838f  
    3939#include <stdio.h>
    4040#include <errno.h>
     41#include <irc.h>
    4142#include <stdbool.h>
    4243#include <stdlib.h>
     
    142143}
    143144
    144 static int icp_enable_interrupt(ddf_fun_t *fun, int irq)
    145 {
    146         /* TODO */
     145static bool icp_fun_owns_interrupt(icp_fun_t *fun, int irq)
     146{
     147        const hw_resource_list_t *res = &fun->hw_resources;
     148
     149        /* Check that specified irq really belongs to the function */
     150        for (size_t i = 0; i < res->count; ++i) {
     151                if (res->resources[i].type == INTERRUPT &&
     152                    res->resources[i].res.interrupt.irq == irq) {
     153                        return true;
     154                }
     155        }
     156
    147157        return false;
     158}
     159
     160static int icp_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
     161{
     162        icp_fun_t *fun = icp_fun(fnode);
     163
     164        if (!icp_fun_owns_interrupt(fun, irq))
     165                return EINVAL;
     166
     167        return irc_enable_interrupt(irq);
    148168}
    149169
     
    155175static hw_res_ops_t icp_hw_res_ops = {
    156176        .get_resource_list = &icp_get_resources,
    157         .enable_interrupt = &icp_enable_interrupt,
     177        .enable_interrupt = &icp_fun_enable_interrupt,
    158178};
    159179
  • uspace/lib/c/generic/device/hw_res.c

    rce732e74 rd51838f  
    8686}
    8787
     88int hw_res_disable_interrupt(async_sess_t *sess, int irq)
     89{
     90        async_exch_t *exch = async_exchange_begin(sess);
     91       
     92        int rc = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     93            HW_RES_DISABLE_INTERRUPT, irq);
     94        async_exchange_end(exch);
     95       
     96        return rc;
     97}
     98
     99int hw_res_clear_interrupt(async_sess_t *sess, int irq)
     100{
     101        async_exch_t *exch = async_exchange_begin(sess);
     102       
     103        int rc = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     104            HW_RES_CLEAR_INTERRUPT, irq);
     105        async_exchange_end(exch);
     106       
     107        return rc;
     108}
     109
    88110/** Setup DMA channel to specified place and mode.
    89111 *
  • uspace/lib/c/include/device/hw_res.h

    rce732e74 rd51838f  
    5252        HW_RES_GET_RESOURCE_LIST = 0,
    5353        HW_RES_ENABLE_INTERRUPT,
     54        HW_RES_DISABLE_INTERRUPT,
     55        HW_RES_CLEAR_INTERRUPT,
    5456        HW_RES_DMA_CHANNEL_SETUP,
    5557        HW_RES_DMA_CHANNEL_REMAIN,
     
    116118extern int hw_res_get_resource_list(async_sess_t *, hw_resource_list_t *);
    117119extern int hw_res_enable_interrupt(async_sess_t *, int);
     120extern int hw_res_disable_interrupt(async_sess_t *, int);
     121extern int hw_res_clear_interrupt(async_sess_t *, int);
    118122
    119123extern int hw_res_dma_channel_setup(async_sess_t *, unsigned int, uint32_t,
  • uspace/lib/drv/generic/remote_hw_res.c

    rce732e74 rd51838f  
    4545static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
    4646    ipc_call_t *);
     47static void remote_hw_res_disable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
     48    ipc_call_t *);
     49static void remote_hw_res_clear_interrupt(ddf_fun_t *, void *, ipc_callid_t,
     50    ipc_call_t *);
    4751static void remote_hw_res_dma_channel_setup(ddf_fun_t *, void *, ipc_callid_t,
    4852    ipc_call_t *);
     
    5357        [HW_RES_GET_RESOURCE_LIST] = &remote_hw_res_get_resource_list,
    5458        [HW_RES_ENABLE_INTERRUPT] = &remote_hw_res_enable_interrupt,
     59        [HW_RES_DISABLE_INTERRUPT] = &remote_hw_res_disable_interrupt,
     60        [HW_RES_CLEAR_INTERRUPT] = &remote_hw_res_clear_interrupt,
    5561        [HW_RES_DMA_CHANNEL_SETUP] = &remote_hw_res_dma_channel_setup,
    5662        [HW_RES_DMA_CHANNEL_REMAIN] = &remote_hw_res_dma_channel_remain,
     
    6874       
    6975        if (hw_res_ops->enable_interrupt == NULL) {
     76                async_answer_0(callid, ENOTSUP);
     77                return;
     78        }
     79       
     80        const int irq = DEV_IPC_GET_ARG1(*call);
     81        const int ret = hw_res_ops->enable_interrupt(fun, irq);
     82        async_answer_0(callid, ret);
     83}
     84
     85static void remote_hw_res_disable_interrupt(ddf_fun_t *fun, void *ops,
     86    ipc_callid_t callid, ipc_call_t *call)
     87{
     88        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
     89       
     90        if (hw_res_ops->disable_interrupt == NULL) {
     91                async_answer_0(callid, ENOTSUP);
     92                return;
     93        }
     94       
     95        const int irq = DEV_IPC_GET_ARG1(*call);
     96        const int ret = hw_res_ops->disable_interrupt(fun, irq);
     97        async_answer_0(callid, ret);
     98}
     99
     100static void remote_hw_res_clear_interrupt(ddf_fun_t *fun, void *ops,
     101    ipc_callid_t callid, ipc_call_t *call)
     102{
     103        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
     104       
     105        if (hw_res_ops->clear_interrupt == NULL) {
    70106                async_answer_0(callid, ENOTSUP);
    71107                return;
  • uspace/lib/drv/include/ops/hw_res.h

    rce732e74 rd51838f  
    4545        hw_resource_list_t *(*get_resource_list)(ddf_fun_t *);
    4646        int (*enable_interrupt)(ddf_fun_t *, int);
     47        int (*disable_interrupt)(ddf_fun_t *, int);
     48        int (*clear_interrupt)(ddf_fun_t *, int);
    4749        int (*dma_channel_setup)(ddf_fun_t *, unsigned, uint32_t, uint32_t, uint8_t);
    4850        int (*dma_channel_remain)(ddf_fun_t *, unsigned, size_t *);
Note: See TracChangeset for help on using the changeset viewer.