Changes in / [ddd0499d:695b6ff] in mainline


Ignore:
Location:
uspace
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/audio/sb16/main.c

    rddd0499d r695b6ff  
    4949
    5050static int sb_add_device(ddf_dev_t *device);
    51 static int sb_get_res(ddf_dev_t *device, addr_range_t **pp_sb_regs,
    52     addr_range_t **pp_mpu_regs, int *irq, int *dma8, int *dma16);
     51static int sb_get_res(ddf_dev_t *device, uintptr_t *sb_regs,
     52    size_t *sb_regs_size, uintptr_t *mpu_regs, size_t *mpu_regs_size,
     53    int *irq, int *dma8, int *dma16);
    5354static int sb_enable_interrupts(ddf_dev_t *device);
    5455
    … …  
    102103        }
    103104
    104         addr_range_t sb_regs;
    105         addr_range_t *p_sb_regs = &sb_regs;
    106         addr_range_t mpu_regs;
    107         addr_range_t *p_mpu_regs = &mpu_regs;
     105        uintptr_t sb_regs = 0, mpu_regs = 0;
     106        size_t sb_regs_size = 0, mpu_regs_size = 0;
    108107        int irq = 0, dma8 = 0, dma16 = 0;
    109108
    110         rc = sb_get_res(device, &p_sb_regs, &p_mpu_regs, &irq, &dma8, &dma16);
     109        rc = sb_get_res(device, &sb_regs, &sb_regs_size, &mpu_regs,
     110            &mpu_regs_size, &irq, &dma8, &dma16);
    111111        if (rc != EOK) {
    112112                ddf_log_error("Failed to get resources: %s.", str_error(rc));
    … …  
    114114        }
    115115
    116         sb16_irq_code(p_sb_regs, dma8, dma16, irq_cmds, irq_ranges);
     116        sb16_irq_code((void*)sb_regs, dma8, dma16, irq_cmds, irq_ranges);
    117117
    118118        irq_code_t irq_code = {
    … …  
    139139        }
    140140
    141         rc = sb16_init_sb16(soft_state, p_sb_regs, device, dma8, dma16);
     141        rc = sb16_init_sb16(soft_state, (void*)sb_regs, sb_regs_size, device,
     142            dma8, dma16);
    142143        if (rc != EOK) {
    143144                ddf_log_error("Failed to init sb16 driver: %s.",
    … …  
    146147        }
    147148
    148         rc = sb16_init_mpu(soft_state, p_mpu_regs);
     149        rc = sb16_init_mpu(soft_state, (void*)mpu_regs, mpu_regs_size);
    149150        if (rc == EOK) {
    150151                ddf_fun_t *mpu_fun =
    … …  
    172173}
    173174
    174 static int sb_get_res(ddf_dev_t *device, addr_range_t **pp_sb_regs,
    175     addr_range_t **pp_mpu_regs, int *irq, int *dma8, int *dma16)
     175static int sb_get_res(ddf_dev_t *device, uintptr_t *sb_regs,
     176    size_t *sb_regs_size, uintptr_t *mpu_regs, size_t *mpu_regs_size,
     177    int *irq, int *dma8, int *dma16)
    176178{
    177179        assert(device);
    … …  
    223225        }
    224226
     227
    225228        if (hw_res.io_ranges.count == 1) {
    226                 if (pp_sb_regs && *pp_sb_regs)
    227                         **pp_sb_regs = hw_res.io_ranges.ranges[0];
    228                 if (pp_mpu_regs)
    229                         *pp_mpu_regs = NULL;
     229                if (sb_regs)
     230                        *sb_regs = hw_res.io_ranges.ranges[0].address;
     231                if (sb_regs_size)
     232                        *sb_regs_size = hw_res.io_ranges.ranges[0].size;
    230233        } else {
    231234                const int sb =
    232235                    (hw_res.io_ranges.ranges[0].size >= sizeof(sb16_regs_t))
    233                         ? 0 : 1;
     236                        ? 1 : 0;
    234237                const int mpu = 1 - sb;
    235                 if (pp_sb_regs && *pp_sb_regs)
    236                         **pp_sb_regs = hw_res.io_ranges.ranges[sb];
    237                 if (pp_mpu_regs && *pp_mpu_regs)
    238                         **pp_mpu_regs = hw_res.io_ranges.ranges[mpu];
     238                if (sb_regs)
     239                        *sb_regs = hw_res.io_ranges.ranges[sb].address;
     240                if (sb_regs_size)
     241                        *sb_regs_size = hw_res.io_ranges.ranges[sb].size;
     242                if (mpu_regs)
     243                        *sb_regs = hw_res.io_ranges.ranges[mpu].address;
     244                if (mpu_regs_size)
     245                        *sb_regs_size = hw_res.io_ranges.ranges[mpu].size;
    239246        }
    240247
    … …  
    254261        return enabled ? EOK : EIO;
    255262}
    256 
    257263/**
    258264 * @}

  • uspace/drv/audio/sb16/sb16.c

    rddd0499d r695b6ff  
    7777}
    7878
    79 void sb16_irq_code(addr_range_t *regs, int dma8, int dma16, irq_cmd_t cmds[],
    80     irq_pio_range_t ranges[])
     79void sb16_irq_code(void *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[])
    8180{
    8281        assert(regs);
    8382        assert(dma8 > 0 && dma8 < 4);
    84 
    85         sb16_regs_t *registers = RNGABSPTR(*regs);
     83        sb16_regs_t *registers = regs;
    8684        memcpy(cmds, irq_cmds, sizeof(irq_cmds));
    87         cmds[0].addr = (void *) &registers->dsp_read_status;
    88         ranges[0].base = (uintptr_t) registers;
     85        cmds[0].addr = (void*)&registers->dsp_read_status;
     86        ranges[0].base = (uintptr_t)registers;
    8987        ranges[0].size = sizeof(*registers);
    9088        if (dma16 > 4 && dma16 < 8) {
    9189                /* Valid dma16 */
    92                 cmds[1].addr = (void *) &registers->dma16_ack;
     90                cmds[1].addr = (void*)&registers->dma16_ack;
    9391        } else {
    9492                cmds[1].cmd = CMD_ACCEPT;
    … …  
    9694}
    9795
    98 int sb16_init_sb16(sb16_t *sb, addr_range_t *regs, ddf_dev_t *dev, int dma8,
    99     int dma16)
     96int sb16_init_sb16(sb16_t *sb, void *regs, size_t size,
     97    ddf_dev_t *dev, int dma8, int dma16)
    10098{
    10199        assert(sb);
    102 
    103100        /* Setup registers */
    104         int ret = pio_enable_range(regs, (void **) &sb->regs);
     101        int ret = pio_enable(regs, size, (void**)&sb->regs);
    105102        if (ret != EOK)
    106103                return ret;
    107         ddf_log_note("PIO registers at %p accessible.", sb->regs);
     104        ddf_log_debug("PIO registers at %p accessible.", sb->regs);
    108105
    109106        /* Initialize DSP */
    … …  
    190187}
    191188
    192 int sb16_init_mpu(sb16_t *sb, addr_range_t *regs)
     189int sb16_init_mpu(sb16_t *sb, void *regs, size_t size)
    193190{
    194191        sb->mpu_regs = NULL;

  • uspace/drv/audio/sb16/sb16.h

    rddd0499d r695b6ff  
    3838#include <ddf/driver.h>
    3939#include <ddi.h>
    40 #include <device/hw_res_parsed.h>
    4140
    4241#include "dsp.h"
    … …  
    5251
    5352size_t sb16_irq_code_size(void);
    54 void sb16_irq_code(addr_range_t *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[]);
    55 int sb16_init_sb16(sb16_t *sb, addr_range_t *regs, ddf_dev_t *dev, int dma8, int dma16);
    56 int sb16_init_mpu(sb16_t *sb, addr_range_t *regs);
     53void sb16_irq_code(void *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[]);
     54int sb16_init_sb16(sb16_t *sb, void *regs, size_t size,
     55    ddf_dev_t *dev, int dma8, int dma16);
     56int sb16_init_mpu(sb16_t *sb, void *regs, size_t size);
    5757void sb16_interrupt(sb16_t *sb);
    5858

  • uspace/drv/block/ahci/ahci.c

    rddd0499d r695b6ff  
    11571157        ahci->memregs = NULL;
    11581158       
    1159         physmem_map(RNGABS(hw_res_parsed.mem_ranges.ranges[0]),
     1159        physmem_map((uintptr_t) (hw_res_parsed.mem_ranges.ranges[0].address),
    11601160            AHCI_MEMREGS_PAGES_COUNT, AS_AREA_READ | AS_AREA_WRITE,
    11611161            (void **) &ahci->memregs);
    … …  
    11641164       
    11651165        /* Register interrupt handler */
    1166         ahci_ranges[0].base = RNGABS(hw_res_parsed.mem_ranges.ranges[0]);
     1166        ahci_ranges[0].base = (size_t) hw_res_parsed.mem_ranges.ranges[0].address;
    11671167        ahci_ranges[0].size = sizeof(ahci_memregs_t);
    11681168       
    … …  
    11711171               
    11721172                ahci_cmds[base].addr =
    1173                     ((uint32_t *) RNGABSPTR(hw_res_parsed.mem_ranges.ranges[0])) +
     1173                    ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) +
    11741174                    AHCI_PORTS_REGISTERS_OFFSET + port * AHCI_PORT_REGISTERS_SIZE +
    11751175                    AHCI_PORT_IS_REGISTER_OFFSET;
    … …  
    11771177               
    11781178                ahci_cmds[base + 3].addr =
    1179                     ((uint32_t *) RNGABSPTR(hw_res_parsed.mem_ranges.ranges[0])) +
     1179                    ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) +
    11801180                    AHCI_GHC_IS_REGISTER_OFFSET;
    11811181                ahci_cmds[base + 4].addr = ahci_cmds[base + 3].addr;

  • uspace/drv/block/ata_bd/main.c

    rddd0499d r695b6ff  
    8484        }
    8585
    86         addr_range_t *cmd_rng = &hw_res.io_ranges.ranges[0];
    87         addr_range_t *ctl_rng = &hw_res.io_ranges.ranges[1];
    88         ata_res->cmd = RNGABS(*cmd_rng);
    89         ata_res->ctl = RNGABS(*ctl_rng);
    90 
    91         if (RNGSZ(*ctl_rng) < sizeof(ata_ctl_t)) {
     86        ata_res->cmd = hw_res.io_ranges.ranges[0].address;
     87        ata_res->ctl = hw_res.io_ranges.ranges[1].address;
     88
     89        if (hw_res.io_ranges.ranges[0].size < sizeof(ata_ctl_t)) {
    9290                rc = EINVAL;
    9391                goto error;
    9492        }
    9593
    96         if (RNGSZ(*cmd_rng) < sizeof(ata_cmd_t)) {
     94        if (hw_res.io_ranges.ranges[1].size < sizeof(ata_cmd_t)) {
    9795                rc = EINVAL;
    9896                goto error;

  • uspace/drv/bus/isa/isa.c

    rddd0499d r695b6ff  
    6565#include <ddf/log.h>
    6666#include <ops/hw_res.h>
    67 #include <ops/pio_window.h>
    6867
    6968#include <device/hw_res.h>
    … …  
    105104}
    106105
    107 static hw_resource_list_t *isa_fun_get_resources(ddf_fun_t *fnode)
    108 {
    109         isa_fun_t *fun = isa_fun(fnode);
    110         assert(fun);
    111 
    112         return &fun->hw_resources;
     106static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
     107{
     108        isa_fun_t *isa = isa_fun(fnode);
     109        assert(isa);
     110
     111        return &isa->hw_resources;
    113112}
    114113
    … …  
    117116        /* This is an old ugly way, copied from pci driver */
    118117        assert(fnode);
    119         isa_fun_t *fun = isa_fun(fnode);
    120         assert(fun);
     118        isa_fun_t *isa = isa_fun(fnode);
     119        assert(isa);
    121120
    122121        sysarg_t apic;
    … …  
    134133                return false;
    135134
    136         const hw_resource_list_t *res = &fun->hw_resources;
     135        const hw_resource_list_t *res = &isa->hw_resources;
    137136        assert(res);
    138137        for (size_t i = 0; i < res->count; ++i) {
    … …  
    160159{
    161160        assert(fnode);
    162         isa_fun_t *fun = isa_fun(fnode);
    163         assert(fun);
    164         const hw_resource_list_t *res = &fun->hw_resources;
     161        isa_fun_t *isa = isa_fun(fnode);
     162        assert(isa);
     163        const hw_resource_list_t *res = &isa->hw_resources;
    165164        assert(res);
    166165
    … …  
    183182        assert(size);
    184183        assert(fnode);
    185         isa_fun_t *fun = isa_fun(fnode);
    186         assert(fun);
    187         const hw_resource_list_t *res = &fun->hw_resources;
     184        isa_fun_t *isa = isa_fun(fnode);
     185        assert(isa);
     186        const hw_resource_list_t *res = &isa->hw_resources;
    188187        assert(res);
    189188
    … …  
    202201
    203202static hw_res_ops_t isa_fun_hw_res_ops = {
    204         .get_resource_list = isa_fun_get_resources,
     203        .get_resource_list = isa_get_fun_resources,
    205204        .enable_interrupt = isa_fun_enable_interrupt,
    206205        .dma_channel_setup = isa_fun_setup_dma,
    … …  
    208207};
    209208
    210 static pio_window_t *isa_fun_get_pio_window(ddf_fun_t *fnode)
    211 {
    212         ddf_dev_t *dev = ddf_fun_get_dev(fnode);
    213         isa_bus_t *isa = isa_bus(dev);
    214         assert(isa);
    215 
    216         return &isa->pio_win;
    217 }
    218 
    219 static pio_window_ops_t isa_fun_pio_window_ops = {
    220         .get_pio_window = isa_fun_get_pio_window
    221 };
    222 
    223209static ddf_dev_ops_t isa_fun_ops= {
    224210        .interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops,
    225         .interfaces[PIO_WINDOW_DEV_IFACE] = &isa_fun_pio_window_ops,
    226211};
    227212
    … …  
    429414                resources[count].res.io_range.address += isa->pio_win.io.base;
    430415                resources[count].res.io_range.size = len;
    431                 resources[count].res.io_range.relative = false;
    432416                resources[count].res.io_range.endianness = LITTLE_ENDIAN;
    433417

  • uspace/drv/bus/pci/pciintel/pci.c

    rddd0499d r695b6ff  
    256256        fibril_mutex_lock(&bus->conf_mutex);
    257257
    258         pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
     258        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
    259259
    260260        /*
    … …  
    263263         * support shorter PIO reads offset from this register.
    264264         */
    265         val = uint32_t_le2host(pio_read_32(bus->conf_data_reg));
     265        val = uint32_t_le2host(pio_read_32(bus->conf_data_port));
    266266
    267267        switch (len) {
    … …  
    299299                 * missing bits first.
    300300                 */
    301                 pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
    302                 val = uint32_t_le2host(pio_read_32(bus->conf_data_reg));
     301                pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
     302                val = uint32_t_le2host(pio_read_32(bus->conf_data_port));
    303303        }
    304304       
    … …  
    317317        }
    318318
    319         pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
    320         pio_write_32(bus->conf_data_reg, host2uint32_t_le(val));
     319        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
     320        pio_write_32(bus->conf_data_port, host2uint32_t_le(val));
    321321       
    322322        fibril_mutex_unlock(&bus->conf_mutex);
    … …  
    449449                hw_resources[count].res.io_range.address = range_addr;
    450450                hw_resources[count].res.io_range.size = range_size;
    451                 hw_resources[count].res.io_range.relative = true;
    452451                hw_resources[count].res.io_range.endianness = LITTLE_ENDIAN;
    453452        } else {
    … …  
    455454                hw_resources[count].res.mem_range.address = range_addr;
    456455                hw_resources[count].res.mem_range.size = range_size;
    457                 hw_resources[count].res.mem_range.relative = false;
    458456                hw_resources[count].res.mem_range.endianness = LITTLE_ENDIAN;
    459457        }
    … …  
    724722            hw_resources.resources[1].res.io_range.address);
    725723       
    726         if (pio_enable_resource(&bus->pio_win, &hw_resources.resources[0],
    727             (void **) &bus->conf_addr_reg)) {
     724        bus->conf_io_addr =
     725            (uint32_t) hw_resources.resources[0].res.io_range.address;
     726        bus->conf_io_data =
     727            (uint32_t) hw_resources.resources[1].res.io_range.address;
     728       
     729        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 4,
     730            &bus->conf_addr_port)) {
    728731                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    729732                rc = EADDRNOTAVAIL;
    730733                goto fail;
    731734        }
    732         if (pio_enable_resource(&bus->pio_win, &hw_resources.resources[1],
    733             (void **) &bus->conf_data_reg)) {
     735        if (pio_enable((void *)(uintptr_t)bus->conf_io_data, 4,
     736            &bus->conf_data_port)) {
    734737                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    735738                rc = EADDRNOTAVAIL;

  • uspace/drv/bus/pci/pciintel/pci.h

    rddd0499d r695b6ff  
    4545        /** DDF device node */
    4646        ddf_dev_t *dnode;
    47         ioport32_t *conf_addr_reg;
    48         ioport32_t *conf_data_reg;
     47        uint32_t conf_io_addr;
     48        uint32_t conf_io_data;
     49        void *conf_data_port;
     50        void *conf_addr_port;
    4951        pio_window_t pio_win;
    5052        fibril_mutex_t conf_mutex;

  • uspace/drv/bus/usb/ehci/main.c

    rddd0499d r695b6ff  
    7777        assert(device);
    7878
    79         addr_range_t reg_range;
     79        uintptr_t reg_base = 0;
     80        size_t reg_size = 0;
    8081        int irq = 0;
    8182
    82         int rc = get_my_registers(device, &reg_range, &irq);
     83        int rc = get_my_registers(device, &reg_base, &reg_size, &irq);
    8384        if (rc != EOK) {
    8485                usb_log_error("Failed to get memory addresses for %" PRIun
    … …  
    8788        }
    8889
    89         usb_log_info("Memory mapped regs at %p (size %zu), IRQ %d.\n",
    90             RNGABSPTR(reg_range), RNGSZ(reg_range), irq);
     90        usb_log_info("Memory mapped regs at 0x%" PRIxn " (size %zu), IRQ %d.\n",
     91            reg_base, reg_size, irq);
    9192
    92         rc = disable_legacy(device, &reg_range);
     93        rc = disable_legacy(device, reg_base, reg_size);
    9394        if (rc != EOK) {
    9495                usb_log_error("Failed to disable legacy USB: %s.\n",

  • uspace/drv/bus/usb/ehci/res.c

    rddd0499d r695b6ff  
    7171 *
    7272 * @param[in] dev Device asking for the addresses.
    73  * @param[out] mem_regs_p Pointer to the register range.
     73 * @param[out] mem_reg_address Base address of the memory range.
     74 * @param[out] mem_reg_size Size of the memory range.
    7475 * @param[out] irq_no IRQ assigned to the device.
    7576 * @return Error code.
    7677 */
    7778int get_my_registers(ddf_dev_t *dev,
    78     addr_range_t *mem_regs_p, int *irq_no)
     79    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
    7980{
    8081        assert(dev);
    … …  
    9899        }
    99100
    100         if (mem_regs_p)
    101                 *mem_regs_p = hw_res.mem_ranges.ranges[0];
     101        if (mem_reg_address)
     102                *mem_reg_address = hw_res.mem_ranges.ranges[0].address;
     103        if (mem_reg_size)
     104                *mem_reg_size = hw_res.mem_ranges.ranges[0].size;
    102105        if (irq_no)
    103106                *irq_no = hw_res.irqs.irqs[0];
    … …  
    264267}
    265268
    266 int disable_legacy(ddf_dev_t *device, addr_range_t *reg_range)
     269int disable_legacy(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size)
    267270{
    268271        assert(device);
    … …  
    271274        /* Map EHCI registers */
    272275        void *regs = NULL;
    273         int rc = pio_enable_range(reg_range, &regs);
     276        int rc = pio_enable((void*)reg_base, reg_size, &regs);
    274277        if (rc != EOK) {
    275278                usb_log_error("Failed to map registers %p: %s.\n",
    276                     RNGABSPTR(*reg_range), str_error(rc));
     279                    (void *) reg_base, str_error(rc));
    277280                return rc;
    278281        }

  • uspace/drv/bus/usb/ehci/res.h

    rddd0499d r695b6ff  
    3737
    3838#include <ddf/driver.h>
    39 #include <device/hw_res_parsed.h>
    4039
    41 int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
     40int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    4241int enable_interrupts(ddf_dev_t *);
    43 int disable_legacy(ddf_dev_t *, addr_range_t *);
     42int disable_legacy(ddf_dev_t *, uintptr_t, size_t);
    4443
    4544#endif

  • uspace/drv/bus/usb/ohci/hc.c

    rddd0499d r695b6ff  
    106106 * @param[out] cmds Commands buffer.
    107107 * @param[in] cmds_size Size of the commands buffer (bytes).
    108  * @param[in] regs Device's register range.
     108 * @param[in] regs Physical address of device's registers.
     109 * @param[in] reg_size Size of the register area (bytes).
    109110 *
    110111 * @return Error code.
    … …  
    112113int
    113114hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
    114     size_t cmds_size, addr_range_t *regs)
     115    size_t cmds_size, uintptr_t regs, size_t reg_size)
    115116{
    116117        if ((ranges_size < sizeof(ohci_pio_ranges)) ||
    117118            (cmds_size < sizeof(ohci_irq_commands)) ||
    118             (RNGSZ(*regs) < sizeof(ohci_regs_t)))
     119            (reg_size < sizeof(ohci_regs_t)))
    119120                return EOVERFLOW;
    120121
    121122        memcpy(ranges, ohci_pio_ranges, sizeof(ohci_pio_ranges));
    122         ranges[0].base = RNGABS(*regs);
     123        ranges[0].base = regs;
    123124
    124125        memcpy(cmds, ohci_irq_commands, sizeof(ohci_irq_commands));
    125         ohci_regs_t *registers = (ohci_regs_t *) RNGABSPTR(*regs);
     126        ohci_regs_t *registers = (ohci_regs_t *) regs;
    126127        cmds[0].addr = (void *) &registers->interrupt_status;
    127128        cmds[3].addr = (void *) &registers->interrupt_status;
    … …  
    134135 *
    135136 * @param[in] device Host controller DDF device
    136  * @param[in] regs Register range
     137 * @param[in] reg_base Register range base
     138 * @param[in] reg_size Register range size
    137139 * @param[in] irq Interrupt number
    138140 * @paran[in] handler Interrupt handler
    … …  
    140142 * @return EOK on success or negative error code
    141143 */
    142 int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
    143     interrupt_handler_t handler)
     144int hc_register_irq_handler(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size,
     145    int irq, interrupt_handler_t handler)
    144146{
    145147        int rc;
    … …  
    156158
    157159        rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
    158             sizeof(irq_cmds), regs);
     160            sizeof(irq_cmds), reg_base, reg_size);
    159161        if (rc != EOK) {
    160162                usb_log_error("Failed to generate IRQ code: %s.\n",
    … …  
    257259 *
    258260 * @param[in] instance Memory place for the structure.
    259  * @param[in] regs Device's I/O registers range.
     261 * @param[in] regs Address of the memory mapped I/O registers.
     262 * @param[in] reg_size Size of the memory mapped area.
    260263 * @param[in] interrupts True if w interrupts should be used
    261264 * @return Error code
    262265 */
    263 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
    264 {
    265         assert(instance);
    266 
    267         int rc = pio_enable_range(regs, (void **) &instance->registers);
     266int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
     267{
     268        assert(instance);
     269
     270        int rc =
     271            pio_enable((void*)regs, reg_size, (void**)&instance->registers);
    268272        if (rc != EOK) {
    269273                usb_log_error("Failed to gain access to device registers: %s.\n",

  • uspace/drv/bus/usb/ohci/hc.h

    rddd0499d r695b6ff  
    7575} hc_t;
    7676
    77 int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t,
    78     addr_range_t *);
    79 int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
    80     interrupt_handler_t);
     77int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t, uintptr_t,
     78    size_t);
     79int hc_register_irq_handler(ddf_dev_t *, uintptr_t, size_t, int, interrupt_handler_t);
    8180int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    82 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts);
     81int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
    8382
    8483/** Safely dispose host controller internal structures

  • uspace/drv/bus/usb/ohci/ohci.c

    rddd0499d r695b6ff  
    177177        ddf_fun_set_ops(instance->rh_fun, &rh_ops);
    178178
    179         addr_range_t regs;
     179        uintptr_t reg_base = 0;
     180        size_t reg_size = 0;
    180181        int irq = 0;
    181182
    182         rc = get_my_registers(device, &regs, &irq);
     183        rc = get_my_registers(device, &reg_base, &reg_size, &irq);
    183184        if (rc != EOK) {
    184185                usb_log_error("Failed to get register memory addresses "
    … …  
    189190
    190191        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
    191             RNGABSPTR(regs), RNGSZ(regs), irq);
    192 
    193         rc = hc_register_irq_handler(device, &regs, irq, irq_handler);
     192            (void *) reg_base, reg_size, irq);
     193
     194        rc = hc_register_irq_handler(device, reg_base, reg_size, irq, irq_handler);
    194195        if (rc != EOK) {
    195196                usb_log_error("Failed to register interrupt handler: %s.\n",
    … …  
    214215        }
    215216
    216         rc = hc_init(&instance->hc, &regs, interrupts);
     217        rc = hc_init(&instance->hc, reg_base, reg_size, interrupts);
    217218        if (rc != EOK) {
    218219                usb_log_error("Failed to init ohci_hcd: %s.\n", str_error(rc));

  • uspace/drv/bus/usb/ohci/res.c

    rddd0499d r695b6ff  
    4848 *
    4949 * @param[in] dev Device asking for the addresses.
    50  * @param[out] p_regs Pointer to register range.
     50 * @param[out] mem_reg_address Base address of the memory range.
     51 * @param[out] mem_reg_size Size of the memory range.
    5152 * @param[out] irq_no IRQ assigned to the device.
    5253 * @return Error code.
    5354 */
    54 int get_my_registers(ddf_dev_t *dev, addr_range_t *p_regs, int *irq_no)
     55int get_my_registers(ddf_dev_t *dev,
     56    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
    5557{
    5658        assert(dev);
    … …  
    6466        hw_res_list_parsed_t hw_res;
    6567        hw_res_list_parsed_init(&hw_res);
    66         const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
     68        const int ret =  hw_res_get_list_parsed(parent_sess, &hw_res, 0);
    6769        async_hangup(parent_sess);
    6870        if (ret != EOK) {
    … …  
    7678        }
    7779
    78         if (p_regs)
    79                 *p_regs = hw_res.mem_ranges.ranges[0];
     80        if (mem_reg_address)
     81                *mem_reg_address = hw_res.mem_ranges.ranges[0].address;
     82        if (mem_reg_size)
     83                *mem_reg_size = hw_res.mem_ranges.ranges[0].size;
    8084        if (irq_no)
    8185                *irq_no = hw_res.irqs.irqs[0];

  • uspace/drv/bus/usb/ohci/res.h

    rddd0499d r695b6ff  
    3636
    3737#include <ddf/driver.h>
    38 #include <device/hw_res_parsed.h>
    3938
    40 int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
     39int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    4140int enable_interrupts(ddf_dev_t *);
    4241

  • uspace/drv/bus/usb/uhci/hc.c

    rddd0499d r695b6ff  
    105105 * @param[out] cmds Commands buffer.
    106106 * @param[in] cmds_size Size of the commands buffer (bytes).
    107  * @param[in] regs Device's register range.
     107 * @param[in] regs Physical address of device's registers.
     108 * @param[in] reg_size Size of the register area (bytes).
    108109 *
    109110 * @return Error code.
    … …  
    111112int
    112113hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
    113     size_t cmds_size, addr_range_t *regs)
     114    size_t cmds_size, uintptr_t regs, size_t reg_size)
    114115{
    115116        if ((ranges_size < sizeof(uhci_irq_pio_ranges)) ||
    116117            (cmds_size < sizeof(uhci_irq_commands)) ||
    117             (RNGSZ(*regs) < sizeof(uhci_regs_t)))
     118            (reg_size < sizeof(uhci_regs_t)))
    118119                return EOVERFLOW;
    119120
    120121        memcpy(ranges, uhci_irq_pio_ranges, sizeof(uhci_irq_pio_ranges));
    121         ranges[0].base = RNGABS(*regs);
     122        ranges[0].base = regs;
    122123
    123124        memcpy(cmds, uhci_irq_commands, sizeof(uhci_irq_commands));
    124         uhci_regs_t *registers = (uhci_regs_t *) RNGABSPTR(*regs);
     125        uhci_regs_t *registers = (uhci_regs_t *) regs;
    125126        cmds[0].addr = &registers->usbsts;
    126127        cmds[3].addr = &registers->usbsts;
    … …  
    132133 *
    133134 * @param[in] device Host controller DDF device
    134  * @param[in] regs Register range
     135 * @param[in] reg_base Register range base
     136 * @param[in] reg_size Register range size
    135137 * @param[in] irq Interrupt number
    136138 * @paran[in] handler Interrupt handler
    … …  
    138140 * @return EOK on success or negative error code
    139141 */
    140 int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
    141     interrupt_handler_t handler)
     142int hc_register_irq_handler(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size,
     143    int irq, interrupt_handler_t handler)
    142144{
    143145        int rc;
    … …  
    145147        irq_cmd_t irq_cmds[hc_irq_cmd_count];
    146148        rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
    147             sizeof(irq_cmds), regs);
     149            sizeof(irq_cmds), reg_base, reg_size);
    148150        if (rc != EOK) {
    149151                usb_log_error("Failed to generate IRQ commands: %s.\n",
    … …  
    230232 *
    231233 * @param[in] instance Memory place to initialize.
    232  * @param[in] regs Range of device's I/O control registers.
     234 * @param[in] regs Address of I/O control registers.
     235 * @param[in] reg_size Size of I/O control registers.
    233236 * @param[in] interrupts True if hw interrupts should be used.
    234237 * @return Error code.
    … …  
    238241 * interrupt fibrils.
    239242 */
    240 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
    241 {
    242         assert(regs->size >= sizeof(uhci_regs_t));
     243int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interrupts)
     244{
     245        assert(reg_size >= sizeof(uhci_regs_t));
    243246        int rc;
    244247
    … …  
    248251        /* allow access to hc control registers */
    249252        uhci_regs_t *io;
    250         rc = pio_enable_range(regs, (void **) &io);
     253        rc = pio_enable(regs, reg_size, (void **)&io);
    251254        if (rc != EOK) {
    252255                usb_log_error("Failed to gain access to registers at %p: %s.\n",
    … …  
    257260        instance->registers = io;
    258261        usb_log_debug(
    259             "Device registers at %p (%zuB) accessible.\n", io, regs->size);
     262            "Device registers at %p (%zuB) accessible.\n", io, reg_size);
    260263
    261264        rc = hc_init_mem_structures(instance);

  • uspace/drv/bus/usb/uhci/hc.h

    rddd0499d r695b6ff  
    3737
    3838#include <ddf/interrupt.h>
    39 #include <device/hw_res_parsed.h>
    4039#include <fibril.h>
    4140#include <usb/host/hcd.h>
    … …  
    121120} hc_t;
    122121
    123 int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
    124     interrupt_handler_t);
    125 int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t,
    126     addr_range_t *);
     122int hc_register_irq_handler(ddf_dev_t *, uintptr_t, size_t, int, interrupt_handler_t);
     123int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t, uintptr_t,
     124    size_t);
    127125void hc_interrupt(hc_t *instance, uint16_t status);
    128 int hc_init(hc_t *instance, addr_range_t *regs, bool interupts);
     126int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interupts);
    129127
    130128/** Safely dispose host controller internal structures
    … …  
    134132static inline void hc_fini(hc_t *instance) {} /* TODO: implement*/
    135133#endif
    136 
    137134/**
    138135 * @}

  • uspace/drv/bus/usb/uhci/res.c

    rddd0499d r695b6ff  
    4646 *
    4747 * @param[in] dev Device asking for the addresses.
    48  * @param[out] io_regs_p Pointer to register I/O range.
     48 * @param[out] io_reg_address Base address of the I/O range.
     49 * @param[out] io_reg_size Size of the I/O range.
    4950 * @param[out] irq_no IRQ assigned to the device.
    5051 * @return Error code.
    5152 */
    52 int get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs_p, int *irq_no)
     53int get_my_registers(ddf_dev_t *dev,
     54    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
    5355{
    5456        assert(dev);
    … …  
    7476        }
    7577
    76         if (io_regs_p)
    77                 *io_regs_p = hw_res.io_ranges.ranges[0];
     78        if (io_reg_address)
     79                *io_reg_address = hw_res.io_ranges.ranges[0].address;
     80        if (io_reg_size)
     81                *io_reg_size = hw_res.io_ranges.ranges[0].size;
    7882        if (irq_no)
    7983                *irq_no = hw_res.irqs.irqs[0];

  • uspace/drv/bus/usb/uhci/res.h

    rddd0499d r695b6ff  
    3737
    3838#include <ddf/driver.h>
    39 #include <device/hw_res_parsed.h>
    4039
    41 int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
     40int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    4241int enable_interrupts(ddf_dev_t *);
    4342int disable_legacy(ddf_dev_t *);

  • uspace/drv/bus/usb/uhci/uhci.c

    rddd0499d r695b6ff  
    184184        ddf_fun_data_implant(instance->rh_fun, &instance->rh);
    185185
    186         addr_range_t regs;
     186        uintptr_t reg_base = 0;
     187        size_t reg_size = 0;
    187188        int irq = 0;
    188189
    189         rc = get_my_registers(device, &regs, &irq);
     190        rc = get_my_registers(device, &reg_base, &reg_size, &irq);
    190191        if (rc != EOK) {
    191192                usb_log_error("Failed to get I/O addresses for %" PRIun ": %s.\n",
    … …  
    193194                goto error;
    194195        }
    195         usb_log_debug("I/O regs at %p (size %zu), IRQ %d.\n",
    196             RNGABSPTR(regs), RNGSZ(regs), irq);
     196        usb_log_debug("I/O regs at 0x%p (size %zu), IRQ %d.\n",
     197            (void *) reg_base, reg_size, irq);
    197198
    198199        rc = disable_legacy(device);
    … …  
    203204        }
    204205
    205         rc = hc_register_irq_handler(device, &regs, irq, irq_handler);
     206        rc = hc_register_irq_handler(device, reg_base, reg_size, irq, irq_handler);
    206207        if (rc != EOK) {
    207208                usb_log_error("Failed to register interrupt handler: %s.\n",
    … …  
    222223        }
    223224
    224         rc = hc_init(&instance->hc, &regs, interrupts);
     225        rc = hc_init(&instance->hc, (void*)reg_base, reg_size, interrupts);
    225226        if (rc != EOK) {
    226227                usb_log_error("Failed to init uhci_hcd: %s.\n", str_error(rc));

  • uspace/drv/bus/usb/uhcirh/main.c

    rddd0499d r695b6ff  
    4848#define NAME "uhcirh"
    4949
    50 static int hc_get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs);
     50static int hc_get_my_registers(ddf_dev_t *dev,
     51    uintptr_t *io_reg_address, size_t *io_reg_size);
    5152
    5253static int uhci_rh_dev_add(ddf_dev_t *device);
    … …  
    8990            ddf_dev_get_handle(device));
    9091
    91         addr_range_t regs;
     92        uintptr_t io_regs = 0;
     93        size_t io_size = 0;
    9294        uhci_root_hub_t *rh = NULL;
    9395        int rc;
    9496
    95         rc = hc_get_my_registers(device, &regs);
     97        rc = hc_get_my_registers(device, &io_regs, &io_size);
    9698        if (rc != EOK) {
    9799                usb_log_error( "Failed to get registers from HC: %s.\n",
    … …  
    101103
    102104        usb_log_debug("I/O regs at %p (size %zuB).\n",
    103             RNGABSPTR(regs), RNGSZ(regs));
     105            (void *) io_regs, io_size);
    104106
    105107        rh = ddf_dev_data_alloc(device, sizeof(uhci_root_hub_t));
    … …  
    109111        }
    110112
    111         rc = uhci_root_hub_init(rh, &regs, device);
     113        rc = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
    112114        if (rc != EOK) {
    113115                usb_log_error("Failed(%d) to initialize rh driver instance: "
    … …  
    125127 *
    126128 * @param[in] dev Device asking for the addresses.
    127  * @param[out] io_regs_p Pointer to the device's register range.
     129 * @param[out] io_reg_address Base address of the memory range.
     130 * @param[out] io_reg_size Size of the memory range.
    128131 * @return Error code.
    129132 */
    130 int hc_get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs_p)
     133int hc_get_my_registers(
     134    ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
    131135{
    132136        async_sess_t *parent_sess =
    … …  
    149153        }
    150154
    151         if (io_regs_p != NULL)
    152                 *io_regs_p = hw_res.io_ranges.ranges[0];
     155        if (io_reg_address != NULL)
     156                *io_reg_address = hw_res.io_ranges.ranges[0].address;
     157
     158        if (io_reg_size != NULL)
     159                *io_reg_size = hw_res.io_ranges.ranges[0].size;
    153160
    154161        hw_res_list_parsed_clean(&hw_res);

  • uspace/drv/bus/usb/uhcirh/root_hub.c

    rddd0499d r695b6ff  
    3636#include <ddi.h>
    3737#include <usb/debug.h>
    38 #include <device/hw_res_parsed.h>
    3938
    4039#include "root_hub.h"
    … …  
    4342 *
    4443 * @param[in] instance Driver memory structure to use.
    45  * @param[in] io_regs Range of I/O registers.
     44 * @param[in] addr Address of I/O registers.
     45 * @param[in] size Size of available I/O space.
    4646 * @param[in] rh Pointer to DDF instance of the root hub driver.
    4747 * @return Error code.
    4848 */
    49 int uhci_root_hub_init(uhci_root_hub_t *instance, addr_range_t *io_regs,
    50     ddf_dev_t *rh)
     49int uhci_root_hub_init(
     50  uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh)
    5151{
    52         port_status_t *regs;
    53 
    5452        assert(instance);
    5553        assert(rh);
    5654
    5755        /* Allow access to root hub port registers */
    58         assert(sizeof(*regs) * UHCI_ROOT_HUB_PORT_COUNT <= io_regs->size);
    59 
    60         int ret = pio_enable_range(io_regs, (void **) &regs);
     56        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT <= size);
     57        port_status_t *regs;
     58        int ret = pio_enable(addr, size, (void**)&regs);
    6159        if (ret < 0) {
    6260                usb_log_error(
    6361                    "Failed(%d) to gain access to port registers at %p: %s.\n",
    64                     ret, RNGABSPTR(*io_regs), str_error(ret));
     62                    ret, regs, str_error(ret));
    6563                return ret;
    6664        }

  • uspace/drv/bus/usb/uhcirh/root_hub.h

    rddd0499d r695b6ff  
    3636
    3737#include <ddf/driver.h>
    38 #include <device/hw_res_parsed.h>
    3938
    4039#include "port.h"
    … …  
    4948} uhci_root_hub_t;
    5049
    51 int uhci_root_hub_init(uhci_root_hub_t *instance, addr_range_t *regs,
    52     ddf_dev_t *rh);
     50int uhci_root_hub_init(
     51    uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh);
    5352
    5453void uhci_root_hub_fini(uhci_root_hub_t *instance);

  • uspace/drv/char/i8042/i8042.c

    rddd0499d r695b6ff  
    145145 *
    146146 * @param dev       Driver structure to initialize.
    147  * @param regs      I/O range  of registers.
     147 * @param regs      I/O address of registers.
     148 * @param reg_size  size of the reserved I/O address space.
    148149 * @param irq_kbd   IRQ for primary port.
    149150 * @param irq_mouse IRQ for aux port.
    … …  
    153154 *
    154155 */
    155 int i8042_init(i8042_t *dev, addr_range_t *regs, int irq_kbd,
     156int i8042_init(i8042_t *dev, void *regs, size_t reg_size, int irq_kbd,
    156157    int irq_mouse, ddf_dev_t *ddf_dev)
    157158{
    … …  
    161162        const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
    162163        irq_cmd_t cmds[cmd_count];
    163         i8042_regs_t *ar;
    164164
    165165        int rc;
    … …  
    170170        dev->aux_fun = NULL;
    171171       
    172         if (regs->size < sizeof(i8042_regs_t)) {
     172        if (reg_size < sizeof(i8042_regs_t)) {
    173173                rc = EINVAL;
    174174                goto error;
    175175        }
    176176       
    177         if (pio_enable_range(regs, (void **) &dev->regs) != 0) {
     177        if (pio_enable(regs, sizeof(i8042_regs_t), (void **) &dev->regs) != 0) {
    178178                rc = EIO;
    179179                goto error;
    … …  
    234234
    235235        memcpy(ranges, i8042_ranges, sizeof(i8042_ranges));
    236         ranges[0].base = RNGABS(*regs);
    237 
    238 
    239         ar = RNGABSPTR(*regs);
     236        ranges[0].base = (uintptr_t) regs;
     237
    240238        memcpy(cmds, i8042_cmds, sizeof(i8042_cmds));
    241         cmds[0].addr = (void *) &ar->status;
    242         cmds[3].addr = (void *) &ar->data;
     239        cmds[0].addr = (void *) &(((i8042_regs_t *) regs)->status);
     240        cmds[3].addr = (void *) &(((i8042_regs_t *) regs)->data);
    243241
    244242        irq_code_t irq_code = {

  • uspace/drv/char/i8042/i8042.h

    rddd0499d r695b6ff  
    6868} i8042_t;
    6969
    70 int i8042_init(i8042_t *, addr_range_t *, int, int, ddf_dev_t *);
     70int i8042_init(i8042_t *, void *, size_t, int, int, ddf_dev_t *);
    7171
    7272#endif

  • uspace/drv/char/i8042/main.c

    rddd0499d r695b6ff  
    4949 *
    5050 * @param[in]  dev            Device asking for the addresses.
    51  * @param[out] p_io_reg       Pointer to register range.
     51 * @param[out] io_reg_address Base address of the memory range.
     52 * @param[out] io_reg_size    Size of the memory range.
    5253 * @param[out] kbd_irq        Primary port IRQ.
    5354 * @param[out] mouse_irq      Auxiliary port IRQ.
    … …  
    5657 *
    5758 */
    58 static int get_my_registers(ddf_dev_t *dev, addr_range_t *p_io_reg,
    59     int *kbd_irq, int *mouse_irq)
     59static int get_my_registers(ddf_dev_t *dev, uintptr_t *io_reg_address,
     60    size_t *io_reg_size, int *kbd_irq, int *mouse_irq)
    6061{
    6162        assert(dev);
    … …  
    7879        }
    7980       
    80         if (p_io_reg)
    81                 *p_io_reg = hw_resources.io_ranges.ranges[0];
     81        if (io_reg_address)
     82                *io_reg_address = hw_resources.io_ranges.ranges[0].address;
     83       
     84        if (io_reg_size)
     85                *io_reg_size = hw_resources.io_ranges.ranges[0].size;
    8286       
    8387        if (kbd_irq)
    … …  
    100104static int i8042_dev_add(ddf_dev_t *device)
    101105{
    102         addr_range_t io_regs;
     106        uintptr_t io_regs = 0;
     107        size_t io_size = 0;
    103108        int kbd = 0;
    104109        int mouse = 0;
    … …  
    108113                return EINVAL;
    109114       
    110         rc = get_my_registers(device, &io_regs, &kbd, &mouse);
     115        rc = get_my_registers(device, &io_regs, &io_size, &kbd, &mouse);
    111116        if (rc != EOK) {
    112117                ddf_msg(LVL_ERROR, "Failed to get registers: %s.",
    … …  
    115120        }
    116121       
    117         ddf_msg(LVL_DEBUG,
    118             "I/O regs at %p (size %zuB), IRQ kbd %d, IRQ mouse %d.",
    119             RNGABSPTR(io_regs), RNGSZ(io_regs), kbd, mouse);
     122        ddf_msg(LVL_DEBUG, "I/O regs at %p (size %zuB), IRQ kbd %d, IRQ mouse %d.",
     123            (void *) io_regs, io_size, kbd, mouse);
    120124       
    121125        i8042_t *i8042 = ddf_dev_data_alloc(device, sizeof(i8042_t));
    … …  
    125129        }
    126130       
    127         rc = i8042_init(i8042, &io_regs, kbd, mouse, device);
     131        rc = i8042_init(i8042, (void *) io_regs, io_size, kbd, mouse, device);
    128132        if (rc != EOK) {
    129133                ddf_msg(LVL_ERROR, "Failed to initialize i8042 driver: %s.",

  • uspace/drv/infrastructure/rootmac/rootmac.c

    rddd0499d r695b6ff  
    5454                        .address = 0xfec00000,
    5555                        .size = 4,
    56                         .relative = false,
    5756                        .endianness = LITTLE_ENDIAN
    5857                }
    … …  
    6362                        .address = 0xfee00000,
    6463                        .size = 4,
    65                         .relative = false,
    6664                        .endianness = LITTLE_ENDIAN
    6765                }

  • uspace/drv/infrastructure/rootmalta/rootmalta.c

    rddd0499d r695b6ff  
    9999                        .address = GT_BASE + GT_PCI_CONFADDR,
    100100                        .size = 4,
    101                         .relative = false,
    102101                        .endianness = LITTLE_ENDIAN
    103102                }
    … …  
    108107                        .address = GT_BASE + GT_PCI_CONFDATA,
    109108                        .size = 4,
    110                         .relative = false,
    111109                        .endianness = LITTLE_ENDIAN
    112110                }

  • uspace/drv/infrastructure/rootpc/rootpc.c

    rddd0499d r695b6ff  
    8181                        .address = 0xCF8,
    8282                        .size = 4,
    83                         .relative = false,
    8483                        .endianness = LITTLE_ENDIAN
    8584                }
    … …  
    9089                        .address = 0xCFC,
    9190                        .size = 4,
    92                         .relative = false,
    9391                        .endianness = LITTLE_ENDIAN
    9492                }

  • uspace/drv/nic/e1k/e1k.c

    rddd0499d r695b6ff  
    19411941        e1000->irq = hw_resources->irqs.irqs[0];
    19421942        e1000->reg_base_phys =
    1943             MEMADDR_TO_PTR(RNGABS(hw_resources->mem_ranges.ranges[0]));
     1943            MEMADDR_TO_PTR(hw_resources->mem_ranges.ranges[0].address);
    19441944       
    19451945        return EOK;

  • uspace/drv/nic/ne2k/ne2k.c

    rddd0499d r695b6ff  
    211211        ne2k->irq = hw_res_parsed.irqs.irqs[0];
    212212       
    213         addr_range_t regs = hw_res_parsed.io_ranges.ranges[0];
    214         ne2k->base_port = RNGABSPTR(regs);
     213        ne2k->base_port = (void *) (uintptr_t)
     214            hw_res_parsed.io_ranges.ranges[0].address;
    215215       
    216216        hw_res_list_parsed_clean(&hw_res_parsed);
    217217       
    218         /* Enable programmed I/O */
    219         if (pio_enable_range(&regs, &ne2k->port) != EOK)
     218        /* Enable port I/O */
     219        if (pio_enable(ne2k->base_port, NE2K_IO_SIZE, &ne2k->port) != EOK)
    220220                return EADDRNOTAVAIL;
     221       
    221222       
    222223        ne2k->data_port = ne2k->port + NE2K_DATA;

  • uspace/drv/nic/rtl8139/driver.c

    rddd0499d r695b6ff  
    10871087        ddf_msg(LVL_DEBUG, "%s device: irq 0x%x assigned", ddf_dev_get_name(dev), rtl8139->irq);
    10881088
    1089         rtl8139->io_addr = IOADDR_TO_PTR(RNGABS(hw_resources->io_ranges.ranges[0]));
     1089        rtl8139->io_addr = IOADDR_TO_PTR(hw_resources->io_ranges.ranges[0].address);
    10901090        if (hw_resources->io_ranges.ranges[0].size < RTL8139_IO_SIZE) {
    10911091                ddf_msg(LVL_ERROR, "i/o range assigned to the device "

  • uspace/lib/c/generic/ddi.c

    rddd0499d r695b6ff  
    4242#include <ddi.h>
    4343#include <libarch/ddi.h>
    44 #include <device/hw_res.h>
    45 #include <device/hw_res_parsed.h>
    46 #include <device/pio_window.h>
    4744#include <libc.h>
    4845#include <task.h>
    … …  
    137134       
    138135        return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
    139 }
    140 
    141 /** Enable PIO for specified address range.
    142  *
    143  * @param range I/O range to be enable.
    144  * @param virt  Virtual address for application's PIO operations.
    145  */
    146 int pio_enable_range(addr_range_t *range, void **virt)
    147 {
    148         return pio_enable(RNGABSPTR(*range), RNGSZ(*range), virt);
    149 }
    150 
    151 /** Enable PIO for specified HW resource wrt. to the PIO window.
    152  *
    153  * @param win      PIO window. May be NULL if the resources are known to be
    154  *                 absolute.
    155  * @param res      Resources specifying the I/O range wrt. to the PIO window.
    156  * @param virt     Virtual address for application's PIO operations.
    157  *
    158  * @return EOK on success.
    159  * @return Negative error code on failure.
    160  *
    161  */
    162 int pio_enable_resource(pio_window_t *win, hw_resource_t *res, void **virt)
    163 {
    164         uintptr_t addr;
    165         size_t size;
    166 
    167         switch (res->type) {
    168         case IO_RANGE:
    169                 addr = res->res.io_range.address;
    170                 if (res->res.io_range.relative) {
    171                         if (!win)
    172                                 return EINVAL;
    173                         addr += win->io.base;
    174                 }
    175                 size = res->res.io_range.size;
    176                 break;
    177         case MEM_RANGE:
    178                 addr = res->res.mem_range.address;
    179                 if (res->res.mem_range.relative) {
    180                         if (!win)
    181                                 return EINVAL;
    182                         addr += win->mem.base;
    183                 }
    184                 size = res->res.mem_range.size;
    185                 break;
    186         default:
    187                 return EINVAL;
    188         }
    189 
    190         return pio_enable((void *) addr, size, virt);   
    191136}
    192137

  • uspace/lib/c/generic/device/hw_res_parsed.c

    rddd0499d r695b6ff  
    8080}
    8181
    82 static uint64_t absolutize(uint64_t addr, bool relative, uint64_t base)
    83 {
    84         if (!relative)
    85                 return addr;
    86         else
    87                 return addr + base;
    88 }
    89 
    90 static uint64_t relativize(uint64_t addr, bool relative, uint64_t base)
    91 {
    92         if (relative)
    93                 return addr;
    94         else
    95                 return addr - base;
    96 }
    97 
    9882static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    99     const pio_window_t *win, const hw_resource_t *res, int flags)
    100 {
    101         endianness_t endianness;
    102         uint64_t absolute;
    103         uint64_t relative;
    104         size_t size;
    105 
     83    const hw_resource_t *res, int flags)
     84{
    10685        assert(res && (res->type == IO_RANGE));
    10786       
    108         absolute = absolutize(res->res.io_range.address,
    109             res->res.io_range.relative, win->io.base);
    110         relative = relativize(res->res.io_range.address,
    111             res->res.io_range.relative, win->io.base);
    112         size = res->res.io_range.size;
    113         endianness = res->res.io_range.endianness;
     87        uint64_t address = res->res.io_range.address;
     88        endianness_t endianness = res->res.io_range.endianness;
     89        size_t size = res->res.io_range.size;
    11490       
    11591        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    12197        if (!keep_duplicit) {
    12298                for (size_t i = 0; i < count; i++) {
    123                         uint64_t s_address;
    124                         size_t s_size;
    125 
    126                         s_address = RNGABS(out->io_ranges.ranges[i]);
    127                         s_size = RNGSZ(out->io_ranges.ranges[i]);
     99                        uint64_t s_address = out->io_ranges.ranges[i].address;
     100                        size_t s_size = out->io_ranges.ranges[i].size;
    128101                       
    129                         if ((absolute == s_address) && (size == s_size))
    130                                 return;
    131                 }
    132         }
    133        
    134         RNGABS(out->io_ranges.ranges[count]) = absolute;
    135         RNGREL(out->io_ranges.ranges[count]) = relative;
    136         RNGSZ(out->io_ranges.ranges[count]) = size;
     102                        if ((address == s_address) && (size == s_size))
     103                                return;
     104                }
     105        }
     106       
     107        out->io_ranges.ranges[count].address = address;
    137108        out->io_ranges.ranges[count].endianness = endianness;
     109        out->io_ranges.ranges[count].size = size;
    138110        out->io_ranges.count++;
    139111}
    140112
    141113static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    142     const pio_window_t *win, const hw_resource_t *res, int flags)
    143 {
    144         endianness_t endianness;
    145         uint64_t absolute;
    146         uint64_t relative;
    147         size_t size;
    148        
     114    const hw_resource_t *res, int flags)
     115{
    149116        assert(res && (res->type == MEM_RANGE));
    150117       
    151         absolute = absolutize(res->res.mem_range.address,
    152             res->res.mem_range.relative, win->mem.base);
    153         relative = relativize(res->res.mem_range.address,
    154             res->res.mem_range.relative, win->mem.base);
    155         size = res->res.mem_range.size;
    156         endianness = res->res.mem_range.endianness;
     118        uint64_t address = res->res.mem_range.address;
     119        endianness_t endianness = res->res.mem_range.endianness;
     120        size_t size = res->res.mem_range.size;
    157121       
    158122        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    164128        if (!keep_duplicit) {
    165129                for (size_t i = 0; i < count; ++i) {
    166                         uint64_t s_address;
    167                         size_t s_size;
    168 
    169                         s_address = RNGABS(out->mem_ranges.ranges[i]);;
    170                         s_size = RNGSZ(out->mem_ranges.ranges[i]);
     130                        uint64_t s_address = out->mem_ranges.ranges[i].address;
     131                        size_t s_size = out->mem_ranges.ranges[i].size;
    171132                       
    172                         if ((absolute == s_address) && (size == s_size))
    173                                 return;
    174                 }
    175         }
    176        
    177         RNGABS(out->mem_ranges.ranges[count]) = absolute;
    178         RNGREL(out->mem_ranges.ranges[count]) = relative;
    179         RNGSZ(out->mem_ranges.ranges[count]) = size;
     133                        if ((address == s_address) && (size == s_size))
     134                                return;
     135                }
     136        }
     137       
     138        out->mem_ranges.ranges[count].address = address;
    180139        out->mem_ranges.ranges[count].endianness = endianness;
     140        out->mem_ranges.ranges[count].size = size;
    181141        out->mem_ranges.count++;
    182142}
    … …  
    184144/** Parse list of hardware resources
    185145 *
    186  * @param      win          PIO window.
    187  * @param      res          Original structure resource.
    188  * @param[out] out          Output parsed resources.
    189  * @param      flags        Flags of the parsing:
    190  *                          HW_RES_KEEP_ZERO_AREA for keeping zero-size areas,
    191  *                          HW_RES_KEEP_DUPLICITIES to keep duplicit areas.
     146 * @param      hw_resources Original structure resource
     147 * @param[out] out          Output parsed resources
     148 * @param      flags        Flags of the parsing.
     149 *                          HW_RES_KEEP_ZERO_AREA for keeping
     150 *                          zero-size areas, HW_RES_KEEP_DUPLICITIES
     151 *                          for keep duplicit areas
    192152 *
    193153 * @return EOK if succeed, error code otherwise.
    194154 *
    195155 */
    196 int hw_res_list_parse(const pio_window_t *win,
    197     const hw_resource_list_t *res, hw_res_list_parsed_t *out, int flags)
    198 {
    199         if (!res || !out)
     156int hw_res_list_parse(const hw_resource_list_t *hw_resources,
     157    hw_res_list_parsed_t *out, int flags)
     158{
     159        if ((!hw_resources) || (!out))
    200160                return EINVAL;
    201161       
    202         size_t res_count = res->count;
     162        size_t res_count = hw_resources->count;
    203163        hw_res_list_parsed_clean(out);
    204164       
    … …  
    214174       
    215175        for (size_t i = 0; i < res_count; ++i) {
    216                 const hw_resource_t *resource = &res->resources[i];
     176                const hw_resource_t *resource = &(hw_resources->resources[i]);
    217177               
    218178                switch (resource->type) {
    … …  
    221181                        break;
    222182                case IO_RANGE:
    223                         hw_res_parse_add_io_range(out, win, resource, flags);
     183                        hw_res_parse_add_io_range(out, resource, flags);
    224184                        break;
    225185                case MEM_RANGE:
    226                         hw_res_parse_add_mem_range(out, win, resource, flags);
     186                        hw_res_parse_add_mem_range(out, resource, flags);
    227187                        break;
    228188                case DMA_CHANNEL_8:
    … …  
    256216    hw_res_list_parsed_t *hw_res_parsed, int flags)
    257217{
    258         pio_window_t pio_window;
    259         int rc;
    260 
    261218        if (!hw_res_parsed)
    262219                return EBADMEM;
    … …  
    265222        hw_res_list_parsed_clean(hw_res_parsed);
    266223        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    267 
    268         rc = pio_window_get(sess, &pio_window);
    269         if (rc != EOK)
    270                 return rc;
    271        
    272         rc = hw_res_get_resource_list(sess, &hw_resources);
     224       
     225        int rc = hw_res_get_resource_list(sess, &hw_resources);
    273226        if (rc != EOK)
    274227                return rc;
    275 
    276         rc = hw_res_list_parse(&pio_window, &hw_resources, hw_res_parsed,
    277             flags);
     228       
     229        rc = hw_res_list_parse(&hw_resources, hw_res_parsed, flags);
    278230        hw_res_clean_resource_list(&hw_resources);
    279231       

  • uspace/lib/c/include/ddi.h

    rddd0499d r695b6ff  
    4040#include <sys/time.h>
    4141#include <abi/ddi/irq.h>
    42 #include <device/hw_res.h>
    43 #include <device/hw_res_parsed.h>
    44 #include <device/pio_window.h>
    4542#include <task.h>
    4643
    … …  
    5855extern int dmamem_unmap_anonymous(void *);
    5956
    60 extern int pio_enable_range(addr_range_t *, void **);
    61 extern int pio_enable_resource(pio_window_t *, hw_resource_t *, void **);
    6257extern int pio_enable(void *, size_t, void **);
    6358

  • uspace/lib/c/include/device/hw_res.h

    rddd0499d r695b6ff  
    7676                struct {
    7777                        uint64_t address;
     78                        endianness_t endianness;
    7879                        size_t size;
    79                         bool relative;
    80                         endianness_t endianness;
    8180                } mem_range;
    8281               
    8382                struct {
    8483                        uint64_t address;
     84                        endianness_t endianness;
    8585                        size_t size;
    86                         bool relative;
    87                         endianness_t endianness;
    8886                } io_range;
    8987               

  • uspace/lib/c/include/device/hw_res_parsed.h

    rddd0499d r695b6ff  
    3737
    3838#include <device/hw_res.h>
    39 #include <device/pio_window.h>
    4039#include <str.h>
    4140
    … …  
    4645#define HW_RES_KEEP_DUPLICIT   0x2
    4746
    48 
    49 #define RNGABS(rng)     (rng).address.absolute
    50 #define RNGREL(rng)     (rng).address.relative
    51 #define RNGSZ(rng)      (rng).size
    52 
    53 #define RNGABSPTR(rng)  ((void *) ((uintptr_t) RNGABS((rng))))
    54 
    55 typedef struct address64 {
    56         /** Aboslute address. */
    57         uint64_t absolute;
    58         /** PIO window base relative address. */
    59         uint64_t relative;
    60 } address64_t;
    61 
    6247/** Address range structure */
    6348typedef struct addr_range {
    6449        /** Start address */
    65         address64_t address;
     50        uint64_t address;
     51       
     52        /** Endianness */
     53        endianness_t endianness;
    6654       
    6755        /** Area size */
    6856        size_t size;
    69 
    70         /** Endianness */
    71         endianness_t endianness;
    7257} addr_range_t;
    7358
    … …  
    154139}
    155140
    156 extern int hw_res_list_parse(const pio_window_t *, const hw_resource_list_t *,
     141extern int hw_res_list_parse(const hw_resource_list_t *,
    157142    hw_res_list_parsed_t *, int);
    158143extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
Note: See TracChangeset for help on using the changeset viewer.