Changeset ddd0499d in mainline for uspace/drv/audio/sb16


Ignore:
Timestamp:
2013-09-12T22:05:13Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4285851b
Parents:
695b6ff (diff), 7de1988c (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:

Support for PIO window-relative and absolute HW resource ranges.

The goal of this merge is to allow bus drivers to pass resources with IO
and memory ranges to the child drivers either in the PIO window-relative
form or system bus absolute form. Using the PIO window and the
relative/absolute attribute of a range, each driver can now reconstruct
both forms. Helper functions are provided to automate these
transformations as much as possible.

Changes in this merge in a greater detail:

  • Support for PIO_WINDOW_DEV_IFACE in isa so that it can provide the PIO window to its children.
  • Add 'relative' member to both hw_resource_t.res.mem_range and hw_resource_t.res.io_range so that the drivers can actually tell whether a range is absolute (eg. it was absolutized by its parent).
  • Add pio_enable_resource() to allow drivers to enable PIO without the need to actually care about what kind of range the resource contains. This is used by pci now.
  • Automate things even more for drivers that use hw_res_get_list_parsed(). The parsed HW resources compute both forms (relative/absolute) and offer it to the driver which is using them. Such a driver then uses whatever form is more fit for it and its purposes.
  • Drivers using the parsed resources can use pio_enable_range() to enable PIO and RNGABS*()/RNGREL()/RNGSZ courtesy macros for easier access to the actual range address/size are provided.
  • Device drivers affected by these API changes were converted.
  • uhcirh now requires uhci to provide PIO_WINDOW_DEV_IFACE; however, the uhcirh driver is removed in the feature USB branch so there was no point in implementing this feature and UHCI USB is thus temporarily broken.
Location:
uspace/drv/audio/sb16
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r695b6ff rddd0499d  
    4949
    5050static int sb_add_device(ddf_dev_t *device);
    51 static 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);
     51static 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);
    5453static int sb_enable_interrupts(ddf_dev_t *device);
    5554
    … …  
    103102        }
    104103
    105         uintptr_t sb_regs = 0, mpu_regs = 0;
    106         size_t sb_regs_size = 0, mpu_regs_size = 0;
     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;
    107108        int irq = 0, dma8 = 0, dma16 = 0;
    108109
    109         rc = sb_get_res(device, &sb_regs, &sb_regs_size, &mpu_regs,
    110             &mpu_regs_size, &irq, &dma8, &dma16);
     110        rc = sb_get_res(device, &p_sb_regs, &p_mpu_regs, &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((void*)sb_regs, dma8, dma16, irq_cmds, irq_ranges);
     116        sb16_irq_code(p_sb_regs, dma8, dma16, irq_cmds, irq_ranges);
    117117
    118118        irq_code_t irq_code = {
    … …  
    139139        }
    140140
    141         rc = sb16_init_sb16(soft_state, (void*)sb_regs, sb_regs_size, device,
    142             dma8, dma16);
     141        rc = sb16_init_sb16(soft_state, p_sb_regs, device, dma8, dma16);
    143142        if (rc != EOK) {
    144143                ddf_log_error("Failed to init sb16 driver: %s.",
    … …  
    147146        }
    148147
    149         rc = sb16_init_mpu(soft_state, (void*)mpu_regs, mpu_regs_size);
     148        rc = sb16_init_mpu(soft_state, p_mpu_regs);
    150149        if (rc == EOK) {
    151150                ddf_fun_t *mpu_fun =
    … …  
    173172}
    174173
    175 static 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)
     174static 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)
    178176{
    179177        assert(device);
    … …  
    225223        }
    226224
    227 
    228225        if (hw_res.io_ranges.count == 1) {
    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;
     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;
    233230        } else {
    234231                const int sb =
    235232                    (hw_res.io_ranges.ranges[0].size >= sizeof(sb16_regs_t))
    236                         ? 1 : 0;
     233                        ? 0 : 1;
    237234                const int mpu = 1 - sb;
    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;
     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];
    246239        }
    247240
    … …  
    261254        return enabled ? EOK : EIO;
    262255}
     256
    263257/**
    264258 * @}

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

    r695b6ff rddd0499d  
    7777}
    7878
    79 void sb16_irq_code(void *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[])
     79void sb16_irq_code(addr_range_t *regs, int dma8, int dma16, irq_cmd_t cmds[],
     80    irq_pio_range_t ranges[])
    8081{
    8182        assert(regs);
    8283        assert(dma8 > 0 && dma8 < 4);
    83         sb16_regs_t *registers = regs;
     84
     85        sb16_regs_t *registers = RNGABSPTR(*regs);
    8486        memcpy(cmds, irq_cmds, sizeof(irq_cmds));
    85         cmds[0].addr = (void*)&registers->dsp_read_status;
    86         ranges[0].base = (uintptr_t)registers;
     87        cmds[0].addr = (void *) &registers->dsp_read_status;
     88        ranges[0].base = (uintptr_t) registers;
    8789        ranges[0].size = sizeof(*registers);
    8890        if (dma16 > 4 && dma16 < 8) {
    8991                /* Valid dma16 */
    90                 cmds[1].addr = (void*)&registers->dma16_ack;
     92                cmds[1].addr = (void *) &registers->dma16_ack;
    9193        } else {
    9294                cmds[1].cmd = CMD_ACCEPT;
    … …  
    9496}
    9597
    96 int sb16_init_sb16(sb16_t *sb, void *regs, size_t size,
    97     ddf_dev_t *dev, int dma8, int dma16)
     98int sb16_init_sb16(sb16_t *sb, addr_range_t *regs, ddf_dev_t *dev, int dma8,
     99    int dma16)
    98100{
    99101        assert(sb);
     102
    100103        /* Setup registers */
    101         int ret = pio_enable(regs, size, (void**)&sb->regs);
     104        int ret = pio_enable_range(regs, (void **) &sb->regs);
    102105        if (ret != EOK)
    103106                return ret;
    104         ddf_log_debug("PIO registers at %p accessible.", sb->regs);
     107        ddf_log_note("PIO registers at %p accessible.", sb->regs);
    105108
    106109        /* Initialize DSP */
    … …  
    187190}
    188191
    189 int sb16_init_mpu(sb16_t *sb, void *regs, size_t size)
     192int sb16_init_mpu(sb16_t *sb, addr_range_t *regs)
    190193{
    191194        sb->mpu_regs = NULL;

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

    r695b6ff rddd0499d  
    3838#include <ddf/driver.h>
    3939#include <ddi.h>
     40#include <device/hw_res_parsed.h>
    4041
    4142#include "dsp.h"
    … …  
    5152
    5253size_t sb16_irq_code_size(void);
    53 void sb16_irq_code(void *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[]);
    54 int sb16_init_sb16(sb16_t *sb, void *regs, size_t size,
    55     ddf_dev_t *dev, int dma8, int dma16);
    56 int sb16_init_mpu(sb16_t *sb, void *regs, size_t size);
     54void sb16_irq_code(addr_range_t *regs, int dma8, int dma16, irq_cmd_t cmds[], irq_pio_range_t ranges[]);
     55int sb16_init_sb16(sb16_t *sb, addr_range_t *regs, ddf_dev_t *dev, int dma8, int dma16);
     56int sb16_init_mpu(sb16_t *sb, addr_range_t *regs);
    5757void sb16_interrupt(sb16_t *sb);
    5858
Note: See TracChangeset for help on using the changeset viewer.