Changeset 3a0a4d8 in mainline for uspace/drv/bus

Timestamp:

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

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, 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/bus

Files:

• isa/i8237.c (modified) (9 diffs)
• isa/i8237.h (modified) (1 diff)
• isa/isa.c (modified) (29 diffs)
• pci/pciintel/pci.c (modified) (13 diffs)
• pci/pciintel/pci.h (modified) (3 diffs)
• usb/uhci/utils/malloc32.h (modified) (2 diffs)
• usb/usbmid/explore.c (modified) (2 diffs)
• usb/usbmid/usbmid.c (modified) (1 diff)
• usb/vhc/transfer.c (modified) (1 diff)

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) {