Changeset 3a0a4d8 in mainline for uspace/drv

Timestamp:

2013-09-12T07:54:05Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export

Children:

95027b5

Parents:

47f5a77 (diff), 64f3d3b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge mainline changes

Location:

uspace/drv

Files:

• audio/sb16/Makefile (added)
• audio/sb16/ddf_log.h (added)
• audio/sb16/dsp.c (added)
• audio/sb16/dsp.h (added)
• audio/sb16/dsp_commands.h (added)
• audio/sb16/main.c (added)
• audio/sb16/mixer.c (added)
• audio/sb16/mixer.h (added)
• audio/sb16/mixer_iface.c (added)
• audio/sb16/pcm_iface.c (added)
• audio/sb16/registers.h (added)
• audio/sb16/sb16.c (added)
• audio/sb16/sb16.h (added)
• audio/sb16/sb16.ma (added)
• block/ahci/ahci.c (modified) (18 diffs)
• bus/isa/i8237.c (modified) (9 diffs)
• bus/isa/i8237.h (modified) (1 diff)
• bus/isa/isa.c (modified) (29 diffs)
• bus/pci/pciintel/pci.c (modified) (13 diffs)
• bus/pci/pciintel/pci.h (modified) (3 diffs)
• bus/usb/uhci/utils/malloc32.h (modified) (2 diffs)
• bus/usb/usbmid/explore.c (modified) (2 diffs)
• bus/usb/usbmid/usbmid.c (modified) (1 diff)
• bus/usb/vhc/transfer.c (modified) (1 diff)
• fb/amdm37x_dispc/amdm37x_dispc.c (modified) (1 diff)
• fb/kfb/port.c (modified) (1 diff)
• infrastructure/root/root.c (modified) (1 diff)
• infrastructure/rootamdm37x/rootamdm37x.c (modified) (5 diffs)
• infrastructure/rootamdm37x/uhh.h (modified) (1 diff)
• infrastructure/rootmalta/Makefile (added)
• infrastructure/rootmalta/rootmalta.c (added)
• infrastructure/rootmalta/rootmalta.ma (added)
• infrastructure/rootpc/rootpc.c (modified) (6 diffs)
• nic/e1k/e1k.c (modified) (15 diffs)
• nic/rtl8139/driver.c (modified) (2 diffs)
• nic/rtl8139/driver.h (modified) (2 diffs)

uspace/drv/block/ahci/ahci.c

@@ -119 +119 @@
 static int ahci_identify_device(sata_dev_t *);
 static int ahci_set_highest_ultra_dma_mode(sata_dev_t *);
-static int ahci_rb_fpdma(sata_dev_t *, void *, uint64_t);
-static int ahci_wb_fpdma(sata_dev_t *, void *, uint64_t);
+static int ahci_rb_fpdma(sata_dev_t *, uintptr_t, uint64_t);
+static int ahci_wb_fpdma(sata_dev_t *, uintptr_t, uint64_t);
 
 static void ahci_sata_devices_create(ahci_dev_t *, ddf_dev_t *);
@@ -233 +233 @@
         sata_dev_t *sata = fun_sata_dev(fun);
         
-        void *phys;
+        uintptr_t phys;
         void *ibuf;
-        int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
-            0, &phys, (void **) &ibuf);
+        int rc = dmamem_map_anonymous(sata->block_size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &ibuf);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Cannot allocate read buffer.");
@@ -276 +276 @@
         sata_dev_t *sata = fun_sata_dev(fun);
         
-        void *phys;
+        uintptr_t phys;
         void *ibuf;
-        int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
-            0, &phys, (void **) &ibuf);
+        int rc = dmamem_map_anonymous(sata->block_size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &ibuf);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Cannot allocate write buffer.");
@@ -336 +336 @@
  *
  */
-static void ahci_identify_device_cmd(sata_dev_t *sata, void *phys)
+static void ahci_identify_device_cmd(sata_dev_t *sata, uintptr_t phys)
 {
         volatile sata_std_command_frame_t *cmd =
@@ -381 +381 @@
  *
  */
-static void ahci_identify_packet_device_cmd(sata_dev_t *sata, void *phys)
+static void ahci_identify_packet_device_cmd(sata_dev_t *sata, uintptr_t phys)
 {
         volatile sata_std_command_frame_t *cmd =
@@ -435 +435 @@
         }
         
-        void *phys;
+        uintptr_t phys;
         sata_identify_data_t *idata;
         int rc = dmamem_map_anonymous(SATA_IDENTIFY_DEVICE_BUFFER_LENGTH,
-            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
+            (void **) &idata);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Cannot allocate buffer to identify device.");
@@ -561 +562 @@
  *
  */
-static void ahci_set_mode_cmd(sata_dev_t *sata, void* phys, uint8_t mode)
+static void ahci_set_mode_cmd(sata_dev_t *sata, uintptr_t phys, uint8_t mode)
 {
         volatile sata_std_command_frame_t *cmd =
@@ -567 +568 @@
         
         cmd->fis_type = SATA_CMD_FIS_TYPE;
-        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR; 
+        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
         cmd->command = 0xef;
         cmd->features = 0x03;
@@ -628 +629 @@
         }
         
-        void *phys;
+        uintptr_t phys;
         sata_identify_data_t *idata;
         int rc = dmamem_map_anonymous(SATA_SET_FEATURE_BUFFER_LENGTH,
-            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
+            (void **) &idata);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Cannot allocate buffer for device set mode.");
@@ -677 +679 @@
  *
  */
-static void ahci_rb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
+static void ahci_rb_fpdma_cmd(sata_dev_t *sata, uintptr_t phys,
+    uint64_t blocknum)
 {
         volatile sata_ncq_command_frame_t *cmd =
@@ -734 +737 @@
  *
  */
-static int ahci_rb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
+static int ahci_rb_fpdma(sata_dev_t *sata, uintptr_t phys, uint64_t blocknum)
 {
         if (sata->is_invalid_device) {
@@ -763 +766 @@
  *
  */
-static void ahci_wb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
+static void ahci_wb_fpdma_cmd(sata_dev_t *sata, uintptr_t phys,
+    uint64_t blocknum)
 {
         volatile sata_ncq_command_frame_t *cmd =
@@ -821 +825 @@
  *
  */
-static int ahci_wb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
+static int ahci_wb_fpdma(sata_dev_t *sata, uintptr_t phys, uint64_t blocknum)
 {
         if (sata->is_invalid_device) {
@@ -933 +937 @@
 {
         size_t size = 4096;
-        void *phys = NULL;
+        uintptr_t phys = 0;
         void *virt_fb = NULL;
         void *virt_cmd = NULL;
@@ -949 +953 @@
         
         /* Allocate and init retfis structure. */
-        int rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
-            &phys, &virt_fb);
+        int rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_fb);
         if (rc != EOK)
                 goto error_retfis;
@@ -959 +963 @@
         
         /* Allocate and init command header structure. */
-        rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
-            &phys, &virt_cmd);
+        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_cmd);
         if (rc != EOK)
                 goto error_cmd;
@@ -970 +974 @@
         
         /* Allocate and init command table structure. */
-        rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
-            &phys, &virt_table);
+        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_table);
         if (rc != EOK)
                 goto error_table;
@@ -1153 +1157 @@
         ahci->memregs = NULL;
         
-        physmem_map((void *) (size_t) (hw_res_parsed.mem_ranges.ranges[0].address),
+        physmem_map((uintptr_t) (hw_res_parsed.mem_ranges.ranges[0].address),
             AHCI_MEMREGS_PAGES_COUNT, AS_AREA_READ | AS_AREA_WRITE,
             (void **) &ahci->memregs);

uspace/drv/bus/isa/i8237.c

@@ -38 +38 @@
 #include <stdbool.h>
 #include <errno.h>
+#include <ddi.h>
+#include <ddf/log.h>
 #include <fibril_synch.h>
 #include <ddi.h>
@@ -198 +200 @@
         .channels = {
                 /* The first chip 8-bit */
-                {
-                        (uint8_t *) 0x00,
-                        (uint8_t *) 0x01,
-                        (uint8_t *) 0x87,
-                        (uint8_t *) 0x0a,
-                        (uint8_t *) 0x0b,
-                        (uint8_t *) 0x0c,
-                },
-                {
-                        (uint8_t *) 0x02,
-                        (uint8_t *) 0x03,
-                        (uint8_t *) 0x83,
-                        (uint8_t *) 0x0a,
-                        (uint8_t *) 0x0b,
-                        (uint8_t *) 0x0c,
-                },
-                {
-                        (uint8_t *) 0x04,
-                        (uint8_t *) 0x05,
-                        (uint8_t *) 0x81,
-                        (uint8_t *) 0x0a,
-                        (uint8_t *) 0x0b,
-                        (uint8_t *) 0x0c,
-                },
-                {
-                        (uint8_t *) 0x06,
-                        (uint8_t *) 0x07,
-                        (uint8_t *) 0x82,
-                        (uint8_t *) 0x0a,
-                        (uint8_t *) 0x0b,
-                        (uint8_t *) 0x0c,
+                { /* Channel 0 - Unusable*/
+                        .offset_reg_address = (uint8_t *) 0x00,
+                        .size_reg_address = (uint8_t *) 0x01,
+                        .page_reg_address = (uint8_t *) 0x87,
+                        .single_mask_address = (uint8_t *) 0x0a,
+                        .mode_address = (uint8_t *) 0x0b,
+                        .flip_flop_address = (uint8_t *) 0x0c,
+                },
+                { /* Channel 1 */
+                        .offset_reg_address = (uint8_t *) 0x02,
+                        .size_reg_address = (uint8_t *) 0x03,
+                        .page_reg_address = (uint8_t *) 0x83,
+                        .single_mask_address = (uint8_t *) 0x0a,
+                        .mode_address = (uint8_t *) 0x0b,
+                        .flip_flop_address = (uint8_t *) 0x0c,
+                },
+                { /* Channel 2 */
+                        .offset_reg_address = (uint8_t *) 0x04,
+                        .size_reg_address = (uint8_t *) 0x05,
+                        .page_reg_address = (uint8_t *) 0x81,
+                        .single_mask_address = (uint8_t *) 0x0a,
+                        .mode_address = (uint8_t *) 0x0b,
+                        .flip_flop_address = (uint8_t *) 0x0c,
+                },
+                { /* Channel 3 */
+                        .offset_reg_address = (uint8_t *) 0x06,
+                        .size_reg_address = (uint8_t *) 0x07,
+                        .page_reg_address = (uint8_t *) 0x82,
+                        .single_mask_address = (uint8_t *) 0x0a,
+                        .mode_address = (uint8_t *) 0x0b,
+                        .flip_flop_address = (uint8_t *) 0x0c,
                 },
                 
                 /* The second chip 16-bit */
-                {
-                        (uint8_t *) 0xc0,
-                        (uint8_t *) 0xc2,
-                        (uint8_t *) 0x8f,
-                        (uint8_t *) 0xd4,
-                        (uint8_t *) 0xd6,
-                        (uint8_t *) 0xd8,
-                },
-                {
-                        (uint8_t *) 0xc4,
-                        (uint8_t *) 0xc6,
-                        (uint8_t *) 0x8b,
-                        (uint8_t *) 0xd4,
-                        (uint8_t *) 0xd6,
-                        (uint8_t *) 0xd8,
-                },
-                {
-                        (uint8_t *) 0xc8,
-                        (uint8_t *) 0xca,
-                        (uint8_t *) 0x89,
-                        (uint8_t *) 0xd4,
-                        (uint8_t *) 0xd6,
-                        (uint8_t *) 0xd8,
-                },
-                {
-                        (uint8_t *) 0xcc,
-                        (uint8_t *) 0xce,
-                        (uint8_t *) 0x8a,
-                        (uint8_t *) 0xd4,
-                        (uint8_t *) 0xd6,
-                        (uint8_t *) 0xd8,
+                { /* Channel 4 - Unusable */
+                        .offset_reg_address = (uint8_t *) 0xc0,
+                        .size_reg_address = (uint8_t *) 0xc2,
+                        .page_reg_address = (uint8_t *) 0x8f,
+                        .single_mask_address = (uint8_t *) 0xd4,
+                        .mode_address = (uint8_t *) 0xd6,
+                        .flip_flop_address = (uint8_t *) 0xd8,
+                },
+                { /* Channel 5 */
+                        .offset_reg_address = (uint8_t *) 0xc4,
+                        .size_reg_address = (uint8_t *) 0xc6,
+                        .page_reg_address = (uint8_t *) 0x8b,
+                        .single_mask_address = (uint8_t *) 0xd4,
+                        .mode_address = (uint8_t *) 0xd6,
+                        .flip_flop_address = (uint8_t *) 0xd8,
+                },
+                { /* Channel 6 */
+                        .offset_reg_address = (uint8_t *) 0xc8,
+                        .size_reg_address = (uint8_t *) 0xca,
+                        .page_reg_address = (uint8_t *) 0x89,
+                        .single_mask_address = (uint8_t *) 0xd4,
+                        .mode_address = (uint8_t *) 0xd6,
+                        .flip_flop_address = (uint8_t *) 0xd8,
+                },
+                { /* Channel 7 */
+                        .offset_reg_address = (uint8_t *) 0xcc,
+                        .size_reg_address = (uint8_t *) 0xce,
+                        .page_reg_address = (uint8_t *) 0x8a,
+                        .single_mask_address = (uint8_t *) 0xd4,
+                        .mode_address = (uint8_t *) 0xd6,
+                        .flip_flop_address = (uint8_t *) 0xd8,
                 },
         },
@@ -272 +274 @@
 };
 
-/* Initialize I/O access to DMA controller I/O ports.
+/** Initialize I/O access to DMA controller I/O ports.
  *
  * @param controller DMA Controller structure to initialize.
@@ -304 +306 @@
         
         return EOK;
+}
+
+/** Helper function. Channels 4,5,6, and 7 are 8 bit DMA.
+ * @pram channel DMA channel.
+ * @reutrn True, if channel is 4,5,6, or 7, false otherwise.
+ */
+static inline bool is_dma16(unsigned channel)
+{
+        return (channel >= 4) && (channel < 8);
+}
+
+/** Helper function. Channels 0,1,2, and 3 are 8 bit DMA.
+ * @pram channel DMA channel.
+ * @reutrn True, if channel is 0,1,2, or 3, false otherwise.
+ */
+static inline bool is_dma8(unsigned channel)
+{
+        return (channel < 4);
 }
 
@@ -320 +340 @@
  *
  * @return Error code.
- *
- */
-int dma_setup_channel(unsigned int channel, uint32_t pa, uint16_t size,
+ */
+int dma_channel_setup(unsigned int channel, uint32_t pa, uint32_t size,
     uint8_t mode)
 {
+        if (!is_dma8(channel) && !is_dma16(channel))
+                return ENOENT;
+
         if ((channel == 0) || (channel == 4))
                 return ENOTSUP;
-        
-        if (channel > 7)
-                return ENOENT;
         
         /* DMA is limited to 24bit addresses. */
@@ -336 +355 @@
         
         /* 8 bit channels use only 4 bits from the page register. */
-        if ((channel > 0) && (channel < 4) && (pa >= (1 << 20)))
+        if (is_dma8(channel) && (pa >= (1 << 20)))
+                return EINVAL;
+
+        /* Buffers cannot cross 64K page boundaries */
+        if ((pa & 0xffff0000) != ((pa + size - 1) & 0xffff0000))
                 return EINVAL;
         
@@ -352 +375 @@
         ddf_msg(LVL_DEBUG, "Unspoiled address %#" PRIx32 " (size %" PRIu16 ")",
             pa, size);
-        if (channel > 4) {
+        if (is_dma16(channel)) {
                 /* Size must be aligned to 16 bits */
                 if ((size & 1) != 0) {
@@ -358 +381 @@
                         return EINVAL;
                 }
-                
+                /* Size is in 2byte words */
                 size >>= 1;
-                
                 /* Address is fun: lower 16 bits need to be shifted by 1 */
                 pa = ((pa & 0xffff) >> 1) | (pa & 0xff0000);
@@ -426 +448 @@
 }
 
+/** Query remaining buffer size.
+ *
+ * @param channel DMA Channel 1, 2, 3 for 8 bit transfers,
+ *                    5, 6, 7 for 16 bit.
+ * @param size    Place to store number of bytes pending in the assigned buffer.
+ *
+ * @return Error code.
+ */
+int dma_channel_remain(unsigned channel, size_t *size)
+{
+        assert(size);
+        if (!is_dma8(channel) && !is_dma16(channel))
+                return ENOENT;
+        
+        if ((channel == 0) || (channel == 4))
+                return ENOTSUP;
+        
+        fibril_mutex_lock(&guard);
+        if (!controller_8237.initialized) {
+                fibril_mutex_unlock(&guard);
+                return EIO;
+        }
+
+        const dma_channel_t dma_channel = controller_8237.channels[channel];
+        /* Get size - reset flip-flop */
+        pio_write_8(dma_channel.flip_flop_address, 0);
+        
+        /* Low byte */
+        const uint8_t value_low = pio_read_8(dma_channel.size_reg_address);
+        ddf_msg(LVL_DEBUG2, "Read size low byte: %p:%x.",
+            dma_channel.size_reg_address, value_low);
+        
+        /* High byte */
+        const uint8_t value_high = pio_read_8(dma_channel.size_reg_address);
+        ddf_msg(LVL_DEBUG2, "Read size high byte: %p:%x.",
+            dma_channel.size_reg_address, value_high);
+        fibril_mutex_unlock(&guard);
+
+        uint16_t remain = (value_high << 8 | value_low) ;
+        /* 16 bit DMA size is in words,
+         * the upper bits are bogus for 16bit transfers so we need to get
+         * rid of them. Using limited type works well.*/
+        if (is_dma16(channel))
+                remain <<= 1;
+        *size =  is_dma16(channel) ? remain + 2: remain + 1;
+        return EOK;
+}
 /**
  * @}

uspace/drv/bus/isa/i8237.h

@@ -38 +38 @@
 #define DRV_BUS_ISA_I8237_H
 
-extern int dma_setup_channel(unsigned int, uint32_t, uint16_t, uint8_t);
+extern int dma_channel_setup(unsigned, uint32_t, uint32_t, uint8_t);
+extern int dma_channel_remain(unsigned, size_t *);
 
 #endif

uspace/drv/bus/isa/isa.c

@@ -67 +67 @@
 
 #include <device/hw_res.h>
+#include <device/pio_window.h>
 
 #include "i8237.h"
@@ -79 +80 @@
         ddf_dev_t *dev;
         ddf_fun_t *fctl;
+        pio_window_t pio_win;
         list_t functions;
 } isa_bus_t;
@@ -85 +87 @@
         fibril_mutex_t mutex;
         ddf_fun_t *fnode;
+        hw_resource_t resources[ISA_MAX_HW_RES];
         hw_resource_list_t hw_resources;
         link_t bus_link;
@@ -103 +106 @@
 static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
 {
-        isa_fun_t *fun = isa_fun(fnode);
-        assert(fun != NULL);
-
-        return &fun->hw_resources;
-}
-
-static bool isa_enable_fun_interrupt(ddf_fun_t *fnode)
+        isa_fun_t *isa = isa_fun(fnode);
+        assert(isa);
+
+        return &isa->hw_resources;
+}
+
+static bool isa_fun_enable_interrupt(ddf_fun_t *fnode)
 {
         /* This is an old ugly way, copied from pci driver */
         assert(fnode);
-        isa_fun_t *fun = isa_fun(fnode);
+        isa_fun_t *isa = isa_fun(fnode);
+        assert(isa);
 
         sysarg_t apic;
@@ -129 +133 @@
                 return false;
 
-        const hw_resource_list_t *res = &fun->hw_resources;
+        const hw_resource_list_t *res = &isa->hw_resources;
         assert(res);
         for (size_t i = 0; i < res->count; ++i) {
@@ -151 +155 @@
 }
 
-static int isa_dma_channel_fun_setup(ddf_fun_t *fnode,
-    unsigned int channel, uint32_t pa, uint16_t size, uint8_t mode)
+static int isa_fun_setup_dma(ddf_fun_t *fnode,
+    unsigned int channel, uint32_t pa, uint32_t size, uint8_t mode)
 {
         assert(fnode);
-        isa_fun_t *fun = isa_fun(fnode);
-        const hw_resource_list_t *res = &fun->hw_resources;
+        isa_fun_t *isa = isa_fun(fnode);
+        assert(isa);
+        const hw_resource_list_t *res = &isa->hw_resources;
         assert(res);
-        
-        const unsigned int ch = channel;
+
         for (size_t i = 0; i < res->count; ++i) {
+                /* Check for assigned channel */
                 if (((res->resources[i].type == DMA_CHANNEL_16) &&
-                    (res->resources[i].res.dma_channel.dma16 == ch)) ||
+                    (res->resources[i].res.dma_channel.dma16 == channel)) ||
                     ((res->resources[i].type == DMA_CHANNEL_8) &&
-                    (res->resources[i].res.dma_channel.dma8 == ch))) {
-                        return dma_setup_channel(channel, pa, size, mode);
-                }
-        }
-        
+                    (res->resources[i].res.dma_channel.dma8 == channel))) {
+                        return dma_channel_setup(channel, pa, size, mode);
+                }
+        }
+
+        return EINVAL;
+}
+
+static int isa_fun_remain_dma(ddf_fun_t *fnode,
+    unsigned channel, size_t *size)
+{
+        assert(size);
+        assert(fnode);
+        isa_fun_t *isa = isa_fun(fnode);
+        assert(isa);
+        const hw_resource_list_t *res = &isa->hw_resources;
+        assert(res);
+
+        for (size_t i = 0; i < res->count; ++i) {
+                /* Check for assigned channel */
+                if (((res->resources[i].type == DMA_CHANNEL_16) &&
+                    (res->resources[i].res.dma_channel.dma16 == channel)) ||
+                    ((res->resources[i].type == DMA_CHANNEL_8) &&
+                    (res->resources[i].res.dma_channel.dma8 == channel))) {
+                        return dma_channel_remain(channel, size);
+                }
+        }
+
         return EINVAL;
 }
@@ -174 +202 @@
 static hw_res_ops_t isa_fun_hw_res_ops = {
         .get_resource_list = isa_get_fun_resources,
-        .enable_interrupt = isa_enable_fun_interrupt,
-        .dma_channel_setup = isa_dma_channel_fun_setup,
+        .enable_interrupt = isa_fun_enable_interrupt,
+        .dma_channel_setup = isa_fun_setup_dma,
+        .dma_channel_remain = isa_fun_remain_dma,
 };
 
-static ddf_dev_ops_t isa_fun_ops;
+static ddf_dev_ops_t isa_fun_ops= {
+        .interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops,
+};
 
 static int isa_dev_add(ddf_dev_t *dev);
@@ -212 +243 @@
 
         fibril_mutex_initialize(&fun->mutex);
+        fun->hw_resources.resources = fun->resources;
+
         fun->fnode = fnode;
         return fun;
@@ -270 +303 @@
 {
         char *line = str;
+        *next = NULL;
 
         if (str == NULL) {
-                *next = NULL;
                 return NULL;
         }
@@ -282 +315 @@
         if (*str != '\0') {
                 *next = str + 1;
-        } else {
-                *next = NULL;
         }
 
@@ -310 +341 @@
         /* Get the name part of the rest of the line. */
         strtok(line, ":");
-
-        /* Allocate output buffer. */
-        size_t size = str_size(line) + 1;
-        char *name = malloc(size);
-
-        if (name != NULL) {
-                /* Copy the result to the output buffer. */
-                str_cpy(name, size, line);
-        }
-
-        return name;
-}
-
-static inline char *skip_spaces(char *line)
+        return line;
+}
+
+static inline const char *skip_spaces(const char *line)
 {
         /* Skip leading spaces. */
@@ -332 +353 @@
 }
 
-static void isa_fun_set_irq(isa_fun_t *fun, int irq)
+static void isa_fun_add_irq(isa_fun_t *fun, int irq)
 {
         size_t count = fun->hw_resources.count;
@@ -348 +369 @@
 }
 
-static void isa_fun_set_dma(isa_fun_t *fun, int dma)
+static void isa_fun_add_dma(isa_fun_t *fun, int dma)
 {
         size_t count = fun->hw_resources.count;
@@ -381 +402 @@
 }
 
-static void isa_fun_set_io_range(isa_fun_t *fun, size_t addr, size_t len)
+static void isa_fun_add_io_range(isa_fun_t *fun, size_t addr, size_t len)
 {
         size_t count = fun->hw_resources.count;
         hw_resource_t *resources = fun->hw_resources.resources;
+
+        isa_bus_t *isa = isa_bus(ddf_fun_get_dev(fun->fnode));
 
         if (count < ISA_MAX_HW_RES) {
                 resources[count].type = IO_RANGE;
                 resources[count].res.io_range.address = addr;
+                resources[count].res.io_range.address += isa->pio_win.io.base;
                 resources[count].res.io_range.size = len;
                 resources[count].res.io_range.endianness = LITTLE_ENDIAN;
@@ -400 +424 @@
 }
 
-static void fun_parse_irq(isa_fun_t *fun, char *val)
+static void fun_parse_irq(isa_fun_t *fun, const char *val)
 {
         int irq = 0;
@@ -409 +433 @@
 
         if (val != end)
-                isa_fun_set_irq(fun, irq);
-}
-
-static void fun_parse_dma(isa_fun_t *fun, char *val)
-{
-        unsigned int dma = 0;
+                isa_fun_add_irq(fun, irq);
+}
+
+static void fun_parse_dma(isa_fun_t *fun, const char *val)
+{
         char *end = NULL;
         
         val = skip_spaces(val);
-        dma = (unsigned int) strtol(val, &end, 10);
+        const int dma = strtol(val, &end, 10);
         
         if (val != end)
-                isa_fun_set_dma(fun, dma);
-}
-
-static void fun_parse_io_range(isa_fun_t *fun, char *val)
+                isa_fun_add_dma(fun, dma);
+}
+
+static void fun_parse_io_range(isa_fun_t *fun, const char *val)
 {
         size_t addr, len;
@@ -441 +464 @@
                 return;
 
-        isa_fun_set_io_range(fun, addr, len);
-}
-
-static void get_match_id(char **id, char *val)
-{
-        char *end = val;
+        isa_fun_add_io_range(fun, addr, len);
+}
+
+static void get_match_id(char **id, const char *val)
+{
+        const char *end = val;
 
         while (!isspace(*end))
@@ -456 +479 @@
 }
 
-static void fun_parse_match_id(isa_fun_t *fun, char *val)
+static void fun_parse_match_id(isa_fun_t *fun, const char *val)
 {
         char *id = NULL;
-        int score = 0;
         char *end = NULL;
-        int rc;
 
         val = skip_spaces(val);
 
-        score = (int)strtol(val, &end, 10);
+        int score = (int)strtol(val, &end, 10);
         if (val == end) {
                 ddf_msg(LVL_ERROR, "Cannot read match score for function "
@@ -483 +504 @@
             "function %s", id, score, ddf_fun_get_name(fun->fnode));
 
-        rc = ddf_fun_add_match_id(fun->fnode, id, score);
+        int rc = ddf_fun_add_match_id(fun->fnode, id, score);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
@@ -492 +513 @@
 }
 
-static bool prop_parse(isa_fun_t *fun, char *line, const char *prop,
-    void (*read_fn)(isa_fun_t *, char *))
+static bool prop_parse(isa_fun_t *fun, const char *line, const char *prop,
+    void (*read_fn)(isa_fun_t *, const char *))
 {
         size_t proplen = str_size(prop);
@@ -508 +529 @@
 }
 
-static void fun_prop_parse(isa_fun_t *fun, char *line)
+static void fun_prop_parse(isa_fun_t *fun, const char *line)
 {
         /* Skip leading spaces. */
@@ -523 +544 @@
 }
 
-static void fun_hw_res_alloc(isa_fun_t *fun)
-{
-        fun->hw_resources.resources =
-            (hw_resource_t *) malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
-}
-
-static void fun_hw_res_free(isa_fun_t *fun)
-{
-        free(fun->hw_resources.resources);
-        fun->hw_resources.resources = NULL;
-}
-
 static char *isa_fun_read_info(char *fun_conf, isa_bus_t *isa)
 {
         char *line;
-        char *fun_name = NULL;
 
         /* Skip empty lines. */
-        while (true) {
+        do {
                 line = str_get_line(fun_conf, &fun_conf);
 
@@ -549 +557 @@
                 }
 
-                if (!line_empty(line))
-                        break;
-        }
+        } while (line_empty(line));
 
         /* Get device name. */
-        fun_name = get_device_name(line);
+        const char *fun_name = get_device_name(line);
         if (fun_name == NULL)
                 return NULL;
 
         isa_fun_t *fun = isa_fun_create(isa, fun_name);
-        free(fun_name);
         if (fun == NULL) {
                 return NULL;
         }
-
-        /* Allocate buffer for the list of hardware resources of the device. */
-        fun_hw_res_alloc(fun);
 
         /* Get properties of the device (match ids, irq and io range). */
@@ -596 +598 @@
 }
 
-static void fun_conf_parse(char *conf, isa_bus_t *isa)
-{
+static void isa_functions_add(isa_bus_t *isa)
+{
+        char *conf = fun_conf_read(CHILD_FUN_CONF_PATH);
         while (conf != NULL && *conf != '\0') {
                 conf = isa_fun_read_info(conf, isa);
         }
-}
-
-static void isa_functions_add(isa_bus_t *isa)
-{
-        char *fun_conf;
-
-        fun_conf = fun_conf_read(CHILD_FUN_CONF_PATH);
-        if (fun_conf != NULL) {
-                fun_conf_parse(fun_conf, isa);
-                free(fun_conf);
-        }
+        free(conf);
 }
 
 static int isa_dev_add(ddf_dev_t *dev)
 {
-        isa_bus_t *isa;
+        async_sess_t *sess;
+        int rc;
 
         ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
             (int) ddf_dev_get_handle(dev));
 
-        isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
+        isa_bus_t *isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
         if (isa == NULL)
                 return ENOMEM;
@@ -628 +622 @@
         isa->dev = dev;
         list_initialize(&isa->functions);
+
+        sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+        if (sess == NULL) {
+                ddf_msg(LVL_ERROR, "isa_dev_add failed to connect to the "
+                    "parent driver.");
+                return ENOENT;
+        }
+
+        rc = pio_window_get(sess, &isa->pio_win);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "isa_dev_add failed to get PIO window "
+                    "for the device.");
+                return rc;
+        }       
 
         /* Make the bus device more visible. Does not do anything. */
@@ -658 +666 @@
 {
         isa_bus_t *isa = isa_bus(dev);
-        int rc;
 
         fibril_mutex_lock(&isa->mutex);
@@ -666 +673 @@
                     isa_fun_t, bus_link);
 
-                rc = ddf_fun_offline(fun->fnode);
+                int rc = ddf_fun_offline(fun->fnode);
                 if (rc != EOK) {
                         fibril_mutex_unlock(&isa->mutex);
@@ -682 +689 @@
                 list_remove(&fun->bus_link);
 
-                fun_hw_res_free(fun);
                 ddf_fun_destroy(fun->fnode);
         }
@@ -709 +715 @@
 }
 
-
-static void isa_init()
-{
+int main(int argc, char *argv[])
+{
+        printf(NAME ": HelenOS ISA bus driver\n");
         ddf_log_init(NAME);
-        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
-}
-
-int main(int argc, char *argv[])
-{
-        printf(NAME ": HelenOS ISA bus driver\n");
-        isa_init();
         return ddf_driver_main(&isa_driver);
 }

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

@@ -57 +57 @@
 #include <ops/hw_res.h>
 #include <device/hw_res.h>
+#include <ops/pio_window.h>
+#include <device/pio_window.h>
 #include <ddi.h>
 #include <pci_dev_iface.h>
@@ -141 +143 @@
 }
 
+static pio_window_t *pciintel_get_pio_window(ddf_fun_t *fnode)
+{
+        pci_fun_t *fun = pci_fun(fnode);
+        
+        if (fun == NULL)
+                return NULL;
+        return &fun->pio_window;
+}
+
+
 static int pci_config_space_write_32(ddf_fun_t *fun, uint32_t address,
     uint32_t data)
@@ -198 +210 @@
         .get_resource_list = &pciintel_get_resources,
         .enable_interrupt = &pciintel_enable_interrupt,
+};
+
+static pio_window_ops_t pciintel_pio_window_ops = {
+        .get_pio_window = &pciintel_get_pio_window
 };
 
@@ -211 +227 @@
 static ddf_dev_ops_t pci_fun_ops = {
         .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
+        .interfaces[PIO_WINDOW_DEV_IFACE] = &pciintel_pio_window_ops,
         .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
 };
@@ -233 +250 @@
 static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
 {
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         pci_bus_t *bus = pci_bus_from_fun(fun);
+        uint32_t val;
         
         fibril_mutex_lock(&bus->conf_mutex);
-        
-        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
-        void *addr = bus->conf_data_port + (reg & 3);
-        
+
         pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
-        
+
+        /*
+         * Always read full 32-bits from the PCI conf_data_port register and
+         * get the desired portion of it afterwards. Some architectures do not
+         * support shorter PIO reads offset from this register.
+         */
+        val = uint32_t_le2host(pio_read_32(bus->conf_data_port));
+
         switch (len) {
         case 1:
-                /* No endianness change for 1 byte */
-                buf[0] = pio_read_8(addr);
+                *buf = (uint8_t) (val >> ((reg & 3) * 8));
                 break;
         case 2:
-                ((uint16_t *) buf)[0] = uint16_t_le2host(pio_read_16(addr));
+                *((uint16_t *) buf) = (uint16_t) (val >> ((reg & 3)) * 8);
                 break;
         case 4:
-                ((uint32_t *) buf)[0] = uint32_t_le2host(pio_read_32(addr));
+                *((uint32_t *) buf) = (uint32_t) val;
                 break;
         }
@@ -260 +282 @@
 static void pci_conf_write(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
 {
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         pci_bus_t *bus = pci_bus_from_fun(fun);
+        uint32_t val;
         
         fibril_mutex_lock(&bus->conf_mutex);
-        
-        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
-        void *addr = bus->conf_data_port + (reg & 3);
-        
-        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
+
+        /*
+         * Prepare to write full 32-bits to the PCI conf_data_port register.
+         * Some architectures do not support shorter PIO writes offset from this
+         * register.
+         */
+
+        if (len < 4) {
+                /*
+                 * We have fewer than full 32-bits, so we need to read the
+                 * missing bits first.
+                 */
+                pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
+                val = uint32_t_le2host(pio_read_32(bus->conf_data_port));
+        }
         
         switch (len) {
         case 1:
-                /* No endianness change for 1 byte */
-                pio_write_8(addr, buf[0]);
+                val &= ~(0xffU << ((reg & 3) * 8));
+                val |= *buf << ((reg & 3) * 8);
                 break;
         case 2:
-                pio_write_16(addr, host2uint16_t_le(((uint16_t *) buf)[0]));
+                val &= ~(0xffffU << ((reg & 3) * 8));
+                val |= *((uint16_t *) buf) << ((reg & 3) * 8);
                 break;
         case 4:
-                pio_write_32(addr, host2uint32_t_le(((uint32_t *) buf)[0]));
+                val = *((uint32_t *) buf);
                 break;
         }
+
+        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
+        pio_write_32(bus->conf_data_port, host2uint32_t_le(val));
         
         fibril_mutex_unlock(&bus->conf_mutex);
@@ -433 +471 @@
 {
         /* Value of the BAR */
-        uint32_t val, mask;
+        uint32_t val;
+        uint32_t bar;
+        uint32_t mask;
+
         /* IO space address */
         bool io;
@@ -471 +512 @@
         /* Get the address mask. */
         pci_conf_write_32(fun, addr, 0xffffffff);
-        mask &= pci_conf_read_32(fun, addr);
-        
+        bar = pci_conf_read_32(fun, addr);
+
+        /*
+         * Unimplemented BARs read back as all 0's.
+         */
+        if (!bar)
+                return addr + (addrw64 ? 8 : 4);
+
+        mask &= bar;    
+
         /* Restore the original value. */
         pci_conf_write_32(fun, addr, val);
@@ -520 +569 @@
 {
         uint8_t irq = pci_conf_read_8(fun, PCI_BRIDGE_INT_LINE);
-        if (irq != 0xff)
+        uint8_t pin = pci_conf_read_8(fun, PCI_BRIDGE_INT_PIN);
+
+        if (pin != 0 && irq != 0xff)
                 pci_add_interrupt(fun, irq);
 }
@@ -583 +634 @@
                         pci_read_bars(fun);
                         pci_read_interrupt(fun);
+
+                        /* Propagate the PIO window to the function. */
+                        fun->pio_window = bus->pio_win;
                         
                         ddf_fun_set_ops(fun->fnode, &pci_fun_ops);
@@ -613 +667 @@
 static int pci_dev_add(ddf_dev_t *dnode)
 {
+        hw_resource_list_t hw_resources;
         pci_bus_t *bus = NULL;
         ddf_fun_t *ctl = NULL;
@@ -638 +693 @@
                 goto fail;
         }
-        
-        hw_resource_list_t hw_resources;
+
+        rc = pio_window_get(sess, &bus->pio_win);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "pci_dev_add failed to get PIO window "
+                    "for the device.");
+                goto fail;
+        }
         
         rc = hw_res_get_resource_list(sess, &hw_resources);
@@ -729 +789 @@
 {
         ddf_log_init(NAME);
-        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
-        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
 }
 

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

@@ -40 +40 @@
 #include "pci_regs.h"
 
-#define PCI_MAX_HW_RES 8
+#define PCI_MAX_HW_RES 10 
 
 typedef struct pciintel_bus {
@@ -49 +49 @@
         void *conf_data_port;
         void *conf_addr_port;
+        pio_window_t pio_win;
         fibril_mutex_t conf_mutex;
 } pci_bus_t;
@@ -68 +69 @@
         hw_resource_list_t hw_resources;
         hw_resource_t resources[PCI_MAX_HW_RES];
+        pio_window_t pio_window;
 } pci_fun_t;
 

uspace/drv/bus/usb/uhci/utils/malloc32.h

@@ -92 +92 @@
  */
 static inline void free32(void *addr)
-        { free(addr); }
+{
+        free(addr);
+}
 
 /** Create 4KB page mapping
@@ -98 +100 @@
  * @return Address of the mapped page, NULL on failure.
  */
-static inline void * get_page(void)
+static inline void *get_page(void)
 {
-        void *address, *phys;
+        uintptr_t phys;
+        void *address;
+        
         const int ret = dmamem_map_anonymous(UHCI_REQUIRED_PAGE_SIZE,
-            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &address);
-        return ret == EOK ? address : NULL;
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
+            &address);
+        
+        return ((ret == EOK) ? address : NULL);
 }
 

uspace/drv/bus/usb/usbmid/explore.c

@@ -56 +56 @@
 static bool interface_in_list(const list_t *list, int interface_no)
 {
-        list_foreach(*list, l) {
-                usbmid_interface_t *iface = usbmid_interface_from_link(l);
+        list_foreach(*list, link, usbmid_interface_t, iface) {
                 if (iface->interface_no == interface_no) {
                         return true;
@@ -190 +189 @@
 
         /* Start child function for every interface. */
-        list_foreach(usb_mid->interface_list, link) {
-                usbmid_interface_t *iface = usbmid_interface_from_link(link);
-
+        list_foreach(usb_mid->interface_list, link, usbmid_interface_t, iface) {
                 usb_log_info("Creating child for interface %d (%s).\n",
                     iface->interface_no,

uspace/drv/bus/usb/usbmid/usbmid.c

@@ -135 +135 @@
         }
 
-        list_foreach(match_ids.ids, link) {
-                match_id_t *match_id = list_get_instance(link, match_id_t, link);
+        list_foreach(match_ids.ids, link, match_id_t, match_id) {
                 rc = ddf_fun_add_match_id(child, match_id->id, match_id->score);
                 if (rc != EOK) {

uspace/drv/bus/usb/vhc/transfer.c

@@ -92 +92 @@
 
         bool target_found = false;
-        list_foreach(vhc->devices, pos) {
-                vhc_virtdev_t *dev = list_get_instance(pos, vhc_virtdev_t, link);
+        list_foreach(vhc->devices, link, vhc_virtdev_t, dev) {
                 fibril_mutex_lock(&dev->guard);
                 if (dev->address == transfer->address) {

uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.c

@@ -273 +273 @@
         ddf_log_note("Setting mode: %ux%ux%u\n", x, y, bpp*8);
         const size_t size = ALIGN_UP(x * y * bpp, PAGE_SIZE);
-        void *buffer, *pa;
-        int ret = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE,
-            0, &pa, &buffer);
+        uintptr_t pa;
+        void *buffer;
+        int ret = dmamem_map_anonymous(size, DMAMEM_4GiB,
+            AS_AREA_READ | AS_AREA_WRITE, 0, &pa, &buffer);
         if (ret != EOK) {
                 ddf_log_error("Failed to get new FB\n");
                 return ret;
         }
+        
         amdm37x_dispc_setup_fb(dispc->regs, x, y, bpp *8, (uint32_t)pa);
         dispc->active_fb.idx = mode.index;

uspace/drv/fb/kfb/port.c

@@ -333 +333 @@
         
         kfb.size = scanline * height;
-        rc = physmem_map((void *) paddr + offset,
+        rc = physmem_map(paddr + offset,
             ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH,
             AS_AREA_READ | AS_AREA_WRITE, (void *) &kfb.addr);

uspace/drv/infrastructure/root/root.c

@@ -208 +208 @@
         /*
          * Register virtual devices root.
-         * We ignore error occurrence because virtual devices shall not be
+         * We warn on error occurrence because virtual devices shall not be
          * vital for the system.
          */
-        (void) add_virtual_root_fun(dev);
+        int res = add_virtual_root_fun(dev);
+        if (res != EOK)
+                ddf_msg(LVL_WARN, "Failed to add virtual child.");
 
         /* Register root device's children. */
-        int res = add_platform_fun(dev);
+        res = add_platform_fun(dev);
         if (EOK != res)
                 ddf_msg(LVL_ERROR, "Failed adding child device for platform.");

uspace/drv/infrastructure/rootamdm37x/rootamdm37x.c

@@ -48 +48 @@
 
 typedef struct {
+        const char *name;
+        match_id_t match_id;
         hw_resource_list_t hw_resources;
 } rootamdm37x_fun_t;
 
-/* See amdm37x TRM page. 3316 for these values */
-#define OHCI_BASE_ADDRESS  0x48064400
-#define OHCI_SIZE  1024
-#define EHCI_BASE_ADDRESS  0x48064800
-#define EHCI_SIZE  1024
+/* See amdm37x TRM page 3316 for these values */
+#define OHCI_BASE_ADDRESS   0x48064400
+#define OHCI_SIZE   1024
+#define EHCI_BASE_ADDRESS   0x48064800
+#define EHCI_SIZE   1024
+
+/* See amdm37x TRM page 1813 for these values */
+#define DSS_BASE_ADDRESS   0x48050000
+#define DSS_SIZE   512
+#define DISPC_BASE_ADDRESS   0x48050400
+#define DISPC_SIZE   1024
+#define VIDEO_ENC_BASE_ADDRESS   0x48050C00
+#define VIDEO_ENC_SIZE   256
+
 
 static hw_resource_t ohci_res[] = {
@@ -88 +99 @@
 };
 
-static const rootamdm37x_fun_t ohci = {
-        .hw_resources = {
-            .resources = ohci_res,
-            .count = sizeof(ohci_res)/sizeof(ohci_res[0]),
-        }
-};
-
-static const rootamdm37x_fun_t ehci = {
-        .hw_resources = {
-            .resources = ehci_res,
-            .count = sizeof(ehci_res) / sizeof(ehci_res[0]),
-        }
-};
+static hw_resource_t disp_res[] = {
+        {
+                .type = MEM_RANGE,
+                .res.io_range = {
+                        .address = DSS_BASE_ADDRESS,
+                        .size = DSS_SIZE,
+                        .endianness = LITTLE_ENDIAN
+                },
+        },
+        {
+                .type = MEM_RANGE,
+                .res.io_range = {
+                        .address = DISPC_BASE_ADDRESS,
+                        .size = DISPC_SIZE,
+                        .endianness = LITTLE_ENDIAN
+                },
+        },
+        {
+                .type = MEM_RANGE,
+                .res.io_range = {
+                        .address = VIDEO_ENC_BASE_ADDRESS,
+                        .size = VIDEO_ENC_SIZE,
+                        .endianness = LITTLE_ENDIAN
+                },
+        },
+        {
+                .type = INTERRUPT,
+                .res.interrupt = { .irq = 25 },
+        },
+};
+
+static const rootamdm37x_fun_t amdm37x_funcs[] = {
+{
+        .name = "ohci",
+        .match_id = { .id = "usb/host=ohci", .score = 90 },
+        .hw_resources = { .resources = ohci_res, .count = ARRAY_SIZE(ohci_res) }
+},
+{
+        .name = "ehci",
+        .match_id = { .id = "usb/host=ehci", .score = 90 },
+        .hw_resources = { .resources = ehci_res, .count = ARRAY_SIZE(ehci_res) }
+},
+{
+        .name = "fb",
+        .match_id = { .id = "amdm37x&dispc", .score = 90 },
+        .hw_resources = { .resources = disp_res, .count = ARRAY_SIZE(disp_res) }
+},
+};
+
 
 static hw_resource_list_t *rootamdm37x_get_resources(ddf_fun_t *fnode);
@@ -114 +161 @@
 };
 
-static int rootamdm37x_add_fun(ddf_dev_t *dev, const char *name,
-    const char *str_match_id, const rootamdm37x_fun_t *fun)
-{
-        ddf_msg(LVL_DEBUG, "Adding new function '%s'.", name);
-        
+static int rootamdm37x_add_fun(ddf_dev_t *dev, const rootamdm37x_fun_t *fun)
+{
+        assert(dev);
+        assert(fun);
+
+        ddf_msg(LVL_DEBUG, "Adding new function '%s'.", fun->name);
+
         /* Create new device function. */
-        ddf_fun_t *fnode = ddf_fun_create(dev, fun_inner, name);
+        ddf_fun_t *fnode = ddf_fun_create(dev, fun_inner, fun->name);
         if (fnode == NULL)
                 return ENOMEM;
         
         /* Add match id */
-        int ret = ddf_fun_add_match_id(fnode, str_match_id, 100);
+        int ret = ddf_fun_add_match_id(fnode,
+            fun->match_id.id, fun->match_id.score);
         if (ret != EOK) {
                 ddf_fun_destroy(fnode);
@@ -146 +196 @@
         ret = ddf_fun_bind(fnode);
         if (ret != EOK) {
-                ddf_msg(LVL_ERROR, "Failed binding function %s.", name);
+                ddf_msg(LVL_ERROR, "Failed binding function %s.", fun->name);
                 ddf_fun_destroy(fnode);
                 return ret;
@@ -189 +239 @@
 
         /* Register functions */
-        if (rootamdm37x_add_fun(dev, "ohci", "usb/host=ohci", &ohci) != EOK)
-                ddf_msg(LVL_ERROR, "Failed to add OHCI function for "
-                    "BeagleBoard-xM platform.");
-        if (rootamdm37x_add_fun(dev, "ehci", "usb/host=ehci", &ehci) != EOK)
-                ddf_msg(LVL_ERROR, "Failed to add EHCI function for "
-                    "BeagleBoard-xM platform.");
-        if (rootamdm37x_add_fun(dev, "dispc", "amdm37x&dispc", &ehci) != EOK)
-                ddf_msg(LVL_ERROR, "Failed to add dispc function for "
-                    "BeagleBoard-xM platform.");
-
+        for (unsigned i = 0; i < ARRAY_SIZE(amdm37x_funcs); ++i) {
+                if (rootamdm37x_add_fun(dev, &amdm37x_funcs[i]) != EOK)
+                        ddf_msg(LVL_ERROR, "Failed to add %s function for "
+                            "BeagleBoard-xM platform.", amdm37x_funcs[i].name);
+        }
         return EOK;
 }

uspace/drv/infrastructure/rootamdm37x/uhh.h

@@ -85 +85 @@
 #define UHH_DEBUG_CSR_EHCI_SIMULATION_MODE_FLAG  (1 << 6)
 #define UHH_DEBUG_CSR_OHCI_CNTSEL_FLAG  (1 << 7)
-#define UHH_DEBUG_CSR_OHCI_GLOBAL_sUSPEND_FLAG  (1 << 16)
+#define UHH_DEBUG_CSR_OHCI_GLOBAL_SUSPEND_FLAG  (1 << 16)
 #define UHH_DEBUG_CSR_OHCI_CCS1_FLAG  (1 << 17)
 #define UHH_DEBUG_CSR_OHCI_CCS2_FLAG  (1 << 18)

uspace/drv/infrastructure/rootpc/rootpc.c

@@ -51 +51 @@
 #include <ops/hw_res.h>
 #include <device/hw_res.h>
+#include <ops/pio_window.h>
+#include <device/pio_window.h>
 
 #define NAME "rootpc"
@@ -56 +58 @@
 typedef struct rootpc_fun {
         hw_resource_list_t hw_resources;
+        pio_window_t pio_window;
 } rootpc_fun_t;
 
@@ -93 +96 @@
 static rootpc_fun_t pci_data = {
         .hw_resources = {
-                sizeof(pci_conf_regs)/sizeof(pci_conf_regs[0]),
+                sizeof(pci_conf_regs) / sizeof(pci_conf_regs[0]),
                 pci_conf_regs
+        },
+        .pio_window = {
+                .mem = {
+                        .base = UINT32_C(0),
+                        .size = UINT32_C(0xffffffff) /* practical maximum */
+                },
+                .io = {
+                        .base = UINT32_C(0),
+                        .size = UINT32_C(0x10000)
+                }
         }
 };
@@ -117 +130 @@
         
         return false;
+}
+
+static pio_window_t *rootpc_get_pio_window(ddf_fun_t *fnode)
+{
+        rootpc_fun_t *fun = rootpc_fun(fnode);
+        
+        assert(fun != NULL);
+        return &fun->pio_window;
 }
 
@@ -122 +143 @@
         .get_resource_list = &rootpc_get_resources,
         .enable_interrupt = &rootpc_enable_interrupt,
+};
+
+static pio_window_ops_t fun_pio_window_ops = {
+        .get_pio_window = &rootpc_get_pio_window
 };
 
@@ -197 +222 @@
         ddf_log_init(NAME);
         rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops;
+        rootpc_fun_ops.interfaces[PIO_WINDOW_DEV_IFACE] = &fun_pio_window_ops;
 }
 

uspace/drv/nic/e1k/e1k.c

@@ -129 +129 @@
         
         /** Physical tx ring address */
-        void *tx_ring_phys;
+        uintptr_t tx_ring_phys;
         /** Virtual tx ring address */
         void *tx_ring_virt;
         
         /** Ring of TX frames, physical address */
-        void **tx_frame_phys;
+        uintptr_t *tx_frame_phys;
         /** Ring of TX frames, virtual address */
         void **tx_frame_virt;
         
         /** Physical rx ring address */
-        void *rx_ring_phys;
+        uintptr_t rx_ring_phys;
         /** Virtual rx ring address */
         void *rx_ring_virt;
         
         /** Ring of RX frames, physical address */
-        void **rx_frame_phys;
+        uintptr_t *rx_frame_phys;
         /** Ring of RX frames, virtual address */
         void **rx_frame_virt;
@@ -1377 +1377 @@
         int rc = dmamem_map_anonymous(
             E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
-            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
-            &e1000->rx_ring_virt);
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
+            &e1000->rx_ring_phys, &e1000->rx_ring_virt);
         if (rc != EOK)
                 return rc;
@@ -1387 +1387 @@
             (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
         
-        e1000->rx_frame_phys =
-            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
+        e1000->rx_frame_phys = (uintptr_t *)
+            calloc(E1000_RX_FRAME_COUNT, sizeof(uintptr_t));
         e1000->rx_frame_virt =
             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
-        if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
+        if ((e1000->rx_frame_phys == NULL) || (e1000->rx_frame_virt == NULL)) {
                 rc = ENOMEM;
                 goto error;
@@ -1397 +1397 @@
         
         size_t i;
+        uintptr_t frame_phys;
         void *frame_virt;
-        void *frame_phys;
         
         for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
-                rc = dmamem_map_anonymous(
-                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
-                    0, &frame_phys, &frame_virt);
+                rc = dmamem_map_anonymous(E1000_MAX_SEND_FRAME_SIZE,
+                    DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
+                    &frame_phys, &frame_virt);
                 if (rc != EOK)
                         goto error;
                 
+                e1000->rx_frame_phys[i] = frame_phys;
                 e1000->rx_frame_virt[i] = frame_virt;
-                e1000->rx_frame_phys[i] = frame_phys;
         }
         
@@ -1424 +1424 @@
                 if (e1000->rx_frame_virt[i] != NULL) {
                         dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
+                        e1000->rx_frame_phys[i] = 0;
                         e1000->rx_frame_virt[i] = NULL;
-                        e1000->rx_frame_phys[i] = NULL;
                 }
         }
@@ -1436 +1436 @@
         if (e1000->rx_frame_virt != NULL) {
                 free(e1000->rx_frame_virt);
-                e1000->rx_frame_phys = NULL;
+                e1000->rx_frame_virt = NULL;
         }
         
@@ -1454 +1454 @@
         for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
                 dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
+                e1000->rx_frame_phys[offset] = 0;
                 e1000->rx_frame_virt[offset] = NULL;
-                e1000->rx_frame_phys[offset] = NULL;
         }
         
         free(e1000->rx_frame_virt);
-        free(e1000->rx_frame_phys);
+        
+        e1000->rx_frame_phys = NULL;
         e1000->rx_frame_virt = NULL;
-        e1000->rx_frame_phys = NULL;
+        
         dmamem_unmap_anonymous(e1000->rx_ring_virt);
 }
@@ -1569 +1570 @@
         fibril_mutex_lock(&e1000->tx_lock);
         
-        e1000->tx_ring_phys = NULL;
+        e1000->tx_ring_phys = 0;
         e1000->tx_ring_virt = NULL;
+        
         e1000->tx_frame_phys = NULL;
         e1000->tx_frame_virt = NULL;
@@ -1576 +1578 @@
         int rc = dmamem_map_anonymous(
             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
-            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
-            &e1000->tx_ring_virt);
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
+            &e1000->tx_ring_phys, &e1000->tx_ring_virt);
         if (rc != EOK)
                 goto error;
@@ -1584 +1586 @@
             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
         
-        e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
-        e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
-
-        if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
+        e1000->tx_frame_phys = (uintptr_t *)
+            calloc(E1000_TX_FRAME_COUNT, sizeof(uintptr_t));
+        e1000->tx_frame_virt =
+            calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
+
+        if ((e1000->tx_frame_phys == NULL) || (e1000->tx_frame_virt == NULL)) {
                 rc = ENOMEM;
                 goto error;
@@ -1593 +1597 @@
         
         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
-                rc = dmamem_map_anonymous(
-                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
+                rc = dmamem_map_anonymous(E1000_MAX_SEND_FRAME_SIZE,
+                    DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE,
                     0, &e1000->tx_frame_phys[i], &e1000->tx_frame_virt[i]);
                 if (rc != EOK)
@@ -1616 +1620 @@
         }
         
-        if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
+        if ((e1000->tx_frame_phys != NULL) && (e1000->tx_frame_virt != NULL)) {
                 for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
                         if (e1000->tx_frame_virt[i] != NULL) {
                                 dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
+                                e1000->tx_frame_phys[i] = 0;
                                 e1000->tx_frame_virt[i] = NULL;
-                                e1000->tx_frame_phys[i] = NULL;
                         }
                 }
@@ -1633 +1637 @@
         if (e1000->tx_frame_virt != NULL) {
                 free(e1000->tx_frame_virt);
-                e1000->tx_frame_phys = NULL;
+                e1000->tx_frame_virt = NULL;
         }
         
@@ -1650 +1654 @@
         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
                 dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
+                e1000->tx_frame_phys[i] = 0;
                 e1000->tx_frame_virt[i] = NULL;
-                e1000->tx_frame_phys[i] = NULL;
         }
         
@@ -1661 +1665 @@
         if (e1000->tx_frame_virt != NULL) {
                 free(e1000->tx_frame_virt);
-                e1000->tx_frame_phys = NULL;
+                e1000->tx_frame_virt = NULL;
         }
         

uspace/drv/nic/rtl8139/driver.c

@@ -1144 +1144 @@
         ddf_msg(LVL_DEBUG, "Creating buffers");
 
-        rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, AS_AREA_WRITE, 0,
-            &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
+        rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, DMAMEM_4GiB,
+            AS_AREA_WRITE, 0, &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Can not allocate transmitter buffers.");
@@ -1164 +1164 @@
             RxBUF_TOT_LENGTH);
 
-        rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, AS_AREA_READ, 0,
-            &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
+        rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, DMAMEM_4GiB,
+            AS_AREA_READ, 0, &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Can not allocate receive buffer.");

uspace/drv/nic/rtl8139/driver.h

@@ -100 +100 @@
          *  Each buffer takes 2kB
          */
-        void *tx_buff_phys;
+        uintptr_t tx_buff_phys;
         void *tx_buff_virt;
 
@@ -117 +117 @@
 
         /** Buffer for receiving frames */
-        void *rx_buff_phys;
+        uintptr_t rx_buff_phys;
         void *rx_buff_virt;