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

Changeset 8442d10 in mainline


Ignore:
Timestamp:
2013-09-09T21:48:12Z (8 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
c67dbd6
Parents:
2e2c18a1
Message:

improve the API of physmem_map(), dmamem_map() and dmamem_map_anonymous()
the "constraint" argument of dmamem_map_anonymous() should be used to specify bits disallowed in the physical frame address

Location:
uspace
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/klog/klog.c

    r2e2c18a1 r8442d10  
    206206        klog_length = size / sizeof(wchar_t);
    207207       
    208         rc = physmem_map((void *) faddr, pages,
    209             AS_AREA_READ | AS_AREA_CACHEABLE, (void *) &klog);
     208        rc = physmem_map(faddr, pages, AS_AREA_READ | AS_AREA_CACHEABLE,
     209            (void *) &klog);
    210210        if (rc != EOK) {
    211211                fprintf(stderr, "%s: Unable to map klog\n", NAME);
  • uspace/drv/audio/sb16/dsp.c

    r2e2c18a1 r8442d10  
    173173{
    174174        assert(dsp);
    175         if (size > MAX_BUFFER_SIZE || size == 0 || (size % 2) == 1)
     175       
     176        if ((size > MAX_BUFFER_SIZE) || (size == 0) || ((size % 2) == 1))
    176177                size = MAX_BUFFER_SIZE;
    177         void *buffer = NULL, *pa = NULL;
    178         int ret = dmamem_map_anonymous(size, AS_AREA_WRITE | AS_AREA_READ,
    179             0, &pa, &buffer);
     178       
     179        uintptr_t pa = 0;
     180        void *buffer = NULL;
     181       
     182        int ret = dmamem_map_anonymous(size, DMAMEM_16MiB,
     183            AS_AREA_WRITE | AS_AREA_READ, 0, &pa, &buffer);
    180184        if (ret != EOK) {
    181185                ddf_log_error("Failed to allocate DMA buffer.");
    182186                return ENOMEM;
    183187        }
    184 
    185         ddf_log_verbose("Setup dma buffer at %p(%p) %zu.", buffer, pa, size);
    186         assert((uintptr_t)pa < (1 << 25));
    187 
     188       
     189        ddf_log_verbose("Setup DMA buffer at %p (%zu) %zu.", buffer, pa, size);
     190        assert(pa < (1 << 24));
     191       
    188192        /* Setup 16 bit channel */
    189         ret = setup_dma(dsp, (uintptr_t)pa, size);
     193        ret = setup_dma(dsp, pa, size);
    190194        if (ret == EOK) {
    191195                dsp->buffer.data = buffer;
     
    196200                dmamem_unmap_anonymous(buffer);
    197201        }
     202       
    198203        return ret;
    199204}
  • uspace/drv/block/ahci/ahci.c

    r2e2c18a1 r8442d10  
    119119static int ahci_identify_device(sata_dev_t *);
    120120static int ahci_set_highest_ultra_dma_mode(sata_dev_t *);
    121 static int ahci_rb_fpdma(sata_dev_t *, void *, uint64_t);
    122 static int ahci_wb_fpdma(sata_dev_t *, void *, uint64_t);
     121static int ahci_rb_fpdma(sata_dev_t *, uintptr_t, uint64_t);
     122static int ahci_wb_fpdma(sata_dev_t *, uintptr_t, uint64_t);
    123123
    124124static void ahci_sata_devices_create(ahci_dev_t *, ddf_dev_t *);
     
    233233        sata_dev_t *sata = fun_sata_dev(fun);
    234234       
    235         void *phys;
     235        uintptr_t phys;
    236236        void *ibuf;
    237         int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
    238             0, &phys, (void **) &ibuf);
     237        int rc = dmamem_map_anonymous(sata->block_size, DMAMEM_4GiB,
     238            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &ibuf);
    239239        if (rc != EOK) {
    240240                ddf_msg(LVL_ERROR, "Cannot allocate read buffer.");
     
    276276        sata_dev_t *sata = fun_sata_dev(fun);
    277277       
    278         void *phys;
     278        uintptr_t phys;
    279279        void *ibuf;
    280         int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
    281             0, &phys, (void **) &ibuf);
     280        int rc = dmamem_map_anonymous(sata->block_size, DMAMEM_4GiB,
     281            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &ibuf);
    282282        if (rc != EOK) {
    283283                ddf_msg(LVL_ERROR, "Cannot allocate write buffer.");
     
    336336 *
    337337 */
    338 static void ahci_identify_device_cmd(sata_dev_t *sata, void *phys)
     338static void ahci_identify_device_cmd(sata_dev_t *sata, uintptr_t phys)
    339339{
    340340        volatile sata_std_command_frame_t *cmd =
     
    381381 *
    382382 */
    383 static void ahci_identify_packet_device_cmd(sata_dev_t *sata, void *phys)
     383static void ahci_identify_packet_device_cmd(sata_dev_t *sata, uintptr_t phys)
    384384{
    385385        volatile sata_std_command_frame_t *cmd =
     
    435435        }
    436436       
    437         void *phys;
     437        uintptr_t phys;
    438438        sata_identify_data_t *idata;
    439439        int rc = dmamem_map_anonymous(SATA_IDENTIFY_DEVICE_BUFFER_LENGTH,
    440             AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
     440            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
     441            (void **) &idata);
    441442        if (rc != EOK) {
    442443                ddf_msg(LVL_ERROR, "Cannot allocate buffer to identify device.");
     
    561562 *
    562563 */
    563 static void ahci_set_mode_cmd(sata_dev_t *sata, void* phys, uint8_t mode)
     564static void ahci_set_mode_cmd(sata_dev_t *sata, uintptr_t phys, uint8_t mode)
    564565{
    565566        volatile sata_std_command_frame_t *cmd =
     
    567568       
    568569        cmd->fis_type = SATA_CMD_FIS_TYPE;
    569         cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR; 
     570        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    570571        cmd->command = 0xef;
    571572        cmd->features = 0x03;
     
    628629        }
    629630       
    630         void *phys;
     631        uintptr_t phys;
    631632        sata_identify_data_t *idata;
    632633        int rc = dmamem_map_anonymous(SATA_SET_FEATURE_BUFFER_LENGTH,
    633             AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
     634            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
     635            (void **) &idata);
    634636        if (rc != EOK) {
    635637                ddf_msg(LVL_ERROR, "Cannot allocate buffer for device set mode.");
     
    677679 *
    678680 */
    679 static void ahci_rb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
     681static void ahci_rb_fpdma_cmd(sata_dev_t *sata, uintptr_t phys,
     682    uint64_t blocknum)
    680683{
    681684        volatile sata_ncq_command_frame_t *cmd =
     
    734737 *
    735738 */
    736 static int ahci_rb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
     739static int ahci_rb_fpdma(sata_dev_t *sata, uintptr_t phys, uint64_t blocknum)
    737740{
    738741        if (sata->is_invalid_device) {
     
    763766 *
    764767 */
    765 static void ahci_wb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
     768static void ahci_wb_fpdma_cmd(sata_dev_t *sata, uintptr_t phys,
     769    uint64_t blocknum)
    766770{
    767771        volatile sata_ncq_command_frame_t *cmd =
     
    821825 *
    822826 */
    823 static int ahci_wb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
     827static int ahci_wb_fpdma(sata_dev_t *sata, uintptr_t phys, uint64_t blocknum)
    824828{
    825829        if (sata->is_invalid_device) {
     
    933937{
    934938        size_t size = 4096;
    935         void *phys = NULL;
     939        uintptr_t phys = 0;
    936940        void *virt_fb = NULL;
    937941        void *virt_cmd = NULL;
     
    949953       
    950954        /* Allocate and init retfis structure. */
    951         int rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
    952             &phys, &virt_fb);
     955        int rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
     956            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_fb);
    953957        if (rc != EOK)
    954958                goto error_retfis;
     
    959963       
    960964        /* Allocate and init command header structure. */
    961         rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
    962             &phys, &virt_cmd);
     965        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
     966            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_cmd);
    963967        if (rc != EOK)
    964968                goto error_cmd;
     
    970974       
    971975        /* Allocate and init command table structure. */
    972         rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
    973             &phys, &virt_table);
     976        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
     977            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &virt_table);
    974978        if (rc != EOK)
    975979                goto error_table;
     
    11531157        ahci->memregs = NULL;
    11541158       
    1155         physmem_map((void *) (size_t) (hw_res_parsed.mem_ranges.ranges[0].address),
     1159        physmem_map((uintptr_t) (hw_res_parsed.mem_ranges.ranges[0].address),
    11561160            AHCI_MEMREGS_PAGES_COUNT, AS_AREA_READ | AS_AREA_WRITE,
    11571161            (void **) &ahci->memregs);
  • uspace/drv/bus/usb/uhci/utils/malloc32.h

    r2e2c18a1 r8442d10  
    100100static inline void * get_page(void)
    101101{
    102         void *address, *phys;
     102        uintptr_t phys;
     103        void *address;
     104       
    103105        const int ret = dmamem_map_anonymous(UHCI_REQUIRED_PAGE_SIZE,
    104             AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &address);
     106            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
     107            &address);
    105108        return ret == EOK ? address : NULL;
    106109}
  • uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.c

    r2e2c18a1 r8442d10  
    273273        ddf_log_note("Setting mode: %ux%ux%u\n", x, y, bpp*8);
    274274        const size_t size = ALIGN_UP(x * y * bpp, PAGE_SIZE);
    275         void *buffer, *pa;
    276         int ret = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE,
    277             0, &pa, &buffer);
     275        uintptr_t pa;
     276        void *buffer;
     277        int ret = dmamem_map_anonymous(size, DMAMEM_4GiB,
     278            AS_AREA_READ | AS_AREA_WRITE, 0, &pa, &buffer);
    278279        if (ret != EOK) {
    279280                ddf_log_error("Failed to get new FB\n");
  • uspace/drv/fb/kfb/port.c

    r2e2c18a1 r8442d10  
    333333       
    334334        kfb.size = scanline * height;
    335         rc = physmem_map((void *) paddr + offset,
     335        rc = physmem_map(paddr + offset,
    336336            ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH,
    337337            AS_AREA_READ | AS_AREA_WRITE, (void *) &kfb.addr);
  • uspace/drv/nic/e1k/e1k.c

    r2e2c18a1 r8442d10  
    129129       
    130130        /** Physical tx ring address */
    131         void *tx_ring_phys;
     131        uintptr_t tx_ring_phys;
    132132        /** Virtual tx ring address */
    133133        void *tx_ring_virt;
    134134       
    135135        /** Ring of TX frames, physical address */
    136         void **tx_frame_phys;
     136        uintptr_t *tx_frame_phys;
    137137        /** Ring of TX frames, virtual address */
    138138        void **tx_frame_virt;
    139139       
    140140        /** Physical rx ring address */
    141         void *rx_ring_phys;
     141        uintptr_t rx_ring_phys;
    142142        /** Virtual rx ring address */
    143143        void *rx_ring_virt;
    144144       
    145145        /** Ring of RX frames, physical address */
    146         void **rx_frame_phys;
     146        uintptr_t *rx_frame_phys;
    147147        /** Ring of RX frames, virtual address */
    148148        void **rx_frame_virt;
     
    13771377        int rc = dmamem_map_anonymous(
    13781378            E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
    1379             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    1380             &e1000->rx_ring_virt);
     1379            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
     1380            &e1000->rx_ring_phys, &e1000->rx_ring_virt);
    13811381        if (rc != EOK)
    13821382                return rc;
     
    13871387            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    13881388       
    1389         e1000->rx_frame_phys =
    1390             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
     1389        e1000->rx_frame_phys = (uintptr_t *)
     1390            calloc(E1000_RX_FRAME_COUNT, sizeof(uintptr_t));
    13911391        e1000->rx_frame_virt =
    13921392            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
    1393         if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
     1393        if ((e1000->rx_frame_phys == NULL) || (e1000->rx_frame_virt == NULL)) {
    13941394                rc = ENOMEM;
    13951395                goto error;
     
    13971397       
    13981398        size_t i;
     1399        uintptr_t frame_phys;
    13991400        void *frame_virt;
    1400         void *frame_phys;
    14011401       
    14021402        for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    1403                 rc = dmamem_map_anonymous(
    1404                     E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    1405                     0, &frame_phys, &frame_virt);
     1403                rc = dmamem_map_anonymous(E1000_MAX_SEND_FRAME_SIZE,
     1404                    DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
     1405                    &frame_phys, &frame_virt);
    14061406                if (rc != EOK)
    14071407                        goto error;
    14081408               
     1409                e1000->rx_frame_phys[i] = frame_phys;
    14091410                e1000->rx_frame_virt[i] = frame_virt;
    1410                 e1000->rx_frame_phys[i] = frame_phys;
    14111411        }
    14121412       
     
    14241424                if (e1000->rx_frame_virt[i] != NULL) {
    14251425                        dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
     1426                        e1000->rx_frame_phys[i] = 0;
    14261427                        e1000->rx_frame_virt[i] = NULL;
    1427                         e1000->rx_frame_phys[i] = NULL;
    14281428                }
    14291429        }
     
    14361436        if (e1000->rx_frame_virt != NULL) {
    14371437                free(e1000->rx_frame_virt);
    1438                 e1000->rx_frame_phys = NULL;
     1438                e1000->rx_frame_virt = NULL;
    14391439        }
    14401440       
     
    14541454        for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
    14551455                dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
     1456                e1000->rx_frame_phys[offset] = 0;
    14561457                e1000->rx_frame_virt[offset] = NULL;
    1457                 e1000->rx_frame_phys[offset] = NULL;
    14581458        }
    14591459       
    14601460        free(e1000->rx_frame_virt);
    1461         free(e1000->rx_frame_phys);
     1461       
     1462        e1000->rx_frame_phys = NULL;
    14621463        e1000->rx_frame_virt = NULL;
    1463         e1000->rx_frame_phys = NULL;
     1464       
    14641465        dmamem_unmap_anonymous(e1000->rx_ring_virt);
    14651466}
     
    15691570        fibril_mutex_lock(&e1000->tx_lock);
    15701571       
    1571         e1000->tx_ring_phys = NULL;
     1572        e1000->tx_ring_phys = 0;
    15721573        e1000->tx_ring_virt = NULL;
     1574       
    15731575        e1000->tx_frame_phys = NULL;
    15741576        e1000->tx_frame_virt = NULL;
     
    15761578        int rc = dmamem_map_anonymous(
    15771579            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
    1578             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    1579             &e1000->tx_ring_virt);
     1580            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
     1581            &e1000->tx_ring_phys, &e1000->tx_ring_virt);
    15801582        if (rc != EOK)
    15811583                goto error;
     
    15841586            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
    15851587       
    1586         e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
    1587         e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
    1588 
    1589         if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
     1588        e1000->tx_frame_phys = (uintptr_t *)
     1589            calloc(E1000_TX_FRAME_COUNT, sizeof(uintptr_t));
     1590        e1000->tx_frame_virt =
     1591            calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
     1592
     1593        if ((e1000->tx_frame_phys == NULL) || (e1000->tx_frame_virt == NULL)) {
    15901594                rc = ENOMEM;
    15911595                goto error;
     
    15931597       
    15941598        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    1595                 rc = dmamem_map_anonymous(
    1596                     E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
     1599                rc = dmamem_map_anonymous(E1000_MAX_SEND_FRAME_SIZE,
     1600                    DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE,
    15971601                    0, &e1000->tx_frame_phys[i], &e1000->tx_frame_virt[i]);
    15981602                if (rc != EOK)
     
    16161620        }
    16171621       
    1618         if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
     1622        if ((e1000->tx_frame_phys != NULL) && (e1000->tx_frame_virt != NULL)) {
    16191623                for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    16201624                        if (e1000->tx_frame_virt[i] != NULL) {
    16211625                                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
     1626                                e1000->tx_frame_phys[i] = 0;
    16221627                                e1000->tx_frame_virt[i] = NULL;
    1623                                 e1000->tx_frame_phys[i] = NULL;
    16241628                        }
    16251629                }
     
    16331637        if (e1000->tx_frame_virt != NULL) {
    16341638                free(e1000->tx_frame_virt);
    1635                 e1000->tx_frame_phys = NULL;
     1639                e1000->tx_frame_virt = NULL;
    16361640        }
    16371641       
     
    16501654        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    16511655                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
     1656                e1000->tx_frame_phys[i] = 0;
    16521657                e1000->tx_frame_virt[i] = NULL;
    1653                 e1000->tx_frame_phys[i] = NULL;
    16541658        }
    16551659       
     
    16611665        if (e1000->tx_frame_virt != NULL) {
    16621666                free(e1000->tx_frame_virt);
    1663                 e1000->tx_frame_phys = NULL;
     1667                e1000->tx_frame_virt = NULL;
    16641668        }
    16651669       
  • uspace/drv/nic/rtl8139/driver.c

    r2e2c18a1 r8442d10  
    11441144        ddf_msg(LVL_DEBUG, "Creating buffers");
    11451145
    1146         rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, AS_AREA_WRITE, 0,
    1147             &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
     1146        rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, DMAMEM_4GiB,
     1147            AS_AREA_WRITE, 0, &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
    11481148        if (rc != EOK) {
    11491149                ddf_msg(LVL_ERROR, "Can not allocate transmitter buffers.");
     
    11641164            RxBUF_TOT_LENGTH);
    11651165
    1166         rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, AS_AREA_READ, 0,
    1167             &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
     1166        rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, DMAMEM_4GiB,
     1167            AS_AREA_READ, 0, &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
    11681168        if (rc != EOK) {
    11691169                ddf_msg(LVL_ERROR, "Can not allocate receive buffer.");
  • uspace/drv/nic/rtl8139/driver.h

    r2e2c18a1 r8442d10  
    100100         *  Each buffer takes 2kB
    101101         */
    102         void *tx_buff_phys;
     102        uintptr_t tx_buff_phys;
    103103        void *tx_buff_virt;
    104104
     
    117117
    118118        /** Buffer for receiving frames */
    119         void *rx_buff_phys;
     119        uintptr_t rx_buff_phys;
    120120        void *rx_buff_virt;
    121121
  • uspace/lib/c/generic/ddi.c

    r2e2c18a1 r8442d10  
    7676 *
    7777 */
    78 int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
     78int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
    7979{
    8080        return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
     
    8383
    8484int dmamem_map(void *virt, size_t size, unsigned int map_flags,
    85     unsigned int flags, void **phys)
     85    unsigned int flags, uintptr_t *phys)
    8686{
    8787        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
     
    9090}
    9191
    92 int dmamem_map_anonymous(size_t size, unsigned int map_flags,
    93     unsigned int flags, void **phys, void **virt)
    94 {
     92int dmamem_map_anonymous(size_t size, uintptr_t constraint,
     93    unsigned int map_flags, unsigned int flags, uintptr_t *phys, void **virt)
     94{
     95        *phys = constraint;
     96       
    9597        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
    9698            (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
     
    158160        if (!virt)
    159161                return EINVAL;
    160 
    161         void *phys_frame =
    162             (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
    163         size_t offset = pio_addr - phys_frame;
     162       
     163        uintptr_t phys_frame =
     164            ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
     165        size_t offset = (uintptr_t) pio_addr - phys_frame;
    164166        size_t pages = SIZE2PAGES(offset + size);
    165167       
  • uspace/lib/c/generic/time.c

    r2e2c18a1 r8442d10  
    556556               
    557557                void *addr;
    558                 rc = physmem_map((void *) faddr, 1,
    559                     AS_AREA_READ | AS_AREA_CACHEABLE, &addr);
     558                rc = physmem_map(faddr, 1, AS_AREA_READ | AS_AREA_CACHEABLE,
     559                    &addr);
    560560                if (rc != EOK) {
    561561                        as_area_destroy(addr);
  • uspace/lib/c/include/ddi.h

    r2e2c18a1 r8442d10  
    4242#include <task.h>
    4343
     44#define DMAMEM_16MiB  ((uintptr_t) UINT64_C(0xffffffffff000000))
     45#define DMAMEM_4GiB   ((uintptr_t) UINT64_C(0xffffffff00000000))
     46
    4447extern int device_assign_devno(void);
    4548
    46 extern int physmem_map(void *, size_t, unsigned int, void **);
     49extern int physmem_map(uintptr_t, size_t, unsigned int, void **);
    4750
    48 extern int dmamem_map(void *, size_t, unsigned int, unsigned int, void **);
    49 extern int dmamem_map_anonymous(size_t, unsigned int, unsigned int, void **,
    50     void **);
     51extern int dmamem_map(void *, size_t, unsigned int, unsigned int, uintptr_t *);
     52extern int dmamem_map_anonymous(size_t, uintptr_t, unsigned int, unsigned int,
     53    uintptr_t *, void **);
    5154extern int dmamem_unmap(void *, size_t);
    5255extern int dmamem_unmap_anonymous(void *);
  • uspace/srv/bd/rd/rd.c

    r2e2c18a1 r8442d10  
    165165            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
    166166       
    167         ret = physmem_map((void *) addr_phys,
     167        ret = physmem_map(addr_phys,
    168168            ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags, &rd_addr);
    169169        if (ret != EOK) {
  • uspace/srv/hid/input/port/niagara.c

    r2e2c18a1 r8442d10  
    9797                return -1;
    9898       
    99         int rc = physmem_map((void *) paddr, 1,
    100             AS_AREA_READ | AS_AREA_WRITE, (void *) &input_buffer);
     99        int rc = physmem_map(paddr, 1, AS_AREA_READ | AS_AREA_WRITE,
     100            (void *) &input_buffer);
    101101        if (rc != 0) {
    102102                printf("Niagara: uspace driver couldn't map physical memory: %d\n",
  • uspace/srv/hid/output/port/ega.c

    r2e2c18a1 r8442d10  
    216216        ega.size = (ega.cols * ega.rows) << 1;
    217217       
    218         rc = physmem_map((void *) paddr,
     218        rc = physmem_map(paddr,
    219219            ALIGN_UP(ega.size, PAGE_SIZE) >> PAGE_WIDTH,
    220220            AS_AREA_READ | AS_AREA_WRITE, (void *) &ega.addr);
  • uspace/srv/hid/output/port/kchar.c

    r2e2c18a1 r8442d10  
    8484                return rc;
    8585       
    86         rc = physmem_map((void *) paddr,
     86        rc = physmem_map(paddr,
    8787            ALIGN_UP(1, PAGE_SIZE) >> PAGE_WIDTH,
    8888            AS_AREA_READ | AS_AREA_WRITE, (void *) &kchar.addr);
  • uspace/srv/hid/output/port/niagara.c

    r2e2c18a1 r8442d10  
    104104                return rc;
    105105       
    106         rc = physmem_map((void *) paddr, 1,
    107             AS_AREA_READ | AS_AREA_WRITE, (void *) &niagara.fifo);
     106        rc = physmem_map(paddr, 1, AS_AREA_READ | AS_AREA_WRITE,
     107            (void *) &niagara.fifo);
    108108        if (rc != EOK)
    109109                return rc;
  • uspace/srv/hw/irc/obio/obio.c

    r2e2c18a1 r8442d10  
    6969#define INO_MASK        0x1f
    7070
    71 static void *base_phys;
     71static uintptr_t base_phys;
    7272static volatile uint64_t *base_virt;
    7373
     
    123123        }
    124124       
    125         base_phys = (void *) paddr;
     125        base_phys = (uintptr_t) paddr;
    126126       
    127127        int flags = AS_AREA_READ | AS_AREA_WRITE;
     
    135135        }
    136136       
    137         printf("%s: OBIO registers with base at %p\n", NAME, base_phys);
     137        printf("%s: OBIO registers with base at %zu\n", NAME, base_phys);
    138138       
    139139        async_set_client_connection(obio_connection);
Note: See TracChangeset for help on using the changeset viewer.