Changeset 9fe4db3 in mainline for uspace/lib


Ignore:
Timestamp:
2011-12-17T08:38:38Z (14 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
65d7b0a
Parents:
f4d5f90 (diff), 792807f (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 with mainline

Location:
uspace/lib
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/as.c

    rf4d5f90 r9fe4db3  
    117117/** Find mapping to physical address.
    118118 *
    119  * @param address Virtual address in question (virtual).
    120  * @param[out] frame Frame address (physical).
    121  * @return Error code.
    122  * @retval EOK No error, @p frame holds the translation.
    123  * @retval ENOENT Mapping not found.
     119 * @param      virt Virtual address to find mapping for.
     120 * @param[out] phys Physical adress.
     121 *
     122 * @return EOK on no error.
     123 * @retval ENOENT if no mapping was found.
     124 *
    124125 */
    125 int as_get_physical_mapping(const void *address, uintptr_t *frame)
     126int as_get_physical_mapping(const void *virt, uintptr_t *phys)
    126127{
    127         uintptr_t tmp_frame;
    128         uintptr_t virt = (uintptr_t) address;
    129        
    130         int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING,
    131             (sysarg_t) virt, (sysarg_t) &tmp_frame);
    132         if (rc != EOK) {
    133                 return rc;
    134         }
    135        
    136         if (frame != NULL) {
    137                 *frame = tmp_frame;
    138         }
    139        
    140         return EOK;
     128        return (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING, (sysarg_t) virt,
     129            (sysarg_t) phys);
    141130}
    142131
  • uspace/lib/c/generic/ddi.c

    rf4d5f90 r9fe4db3  
    3333 */
    3434
     35#include <assert.h>
     36#include <unistd.h>
     37#include <errno.h>
    3538#include <sys/types.h>
    3639#include <abi/ddi/arg.h>
     
    5760 * Caller of this function must have the CAP_MEM_MANAGER capability.
    5861 *
    59  * @param p  Physical address of the starting frame.
    60  * @param v  Virtual address of the starting page.
     62 * @param phys  Physical address of the starting frame.
     63 * @param virt  Virtual address of the starting page.
    6164 * @param pages Number of pages to map.
    6265 * @param flags Flags for the new address space area.
     
    6972 *
    7073 */
    71 int physmem_map(void *pf, void *vp, size_t pages, unsigned int flags)
     74int physmem_map(void *phys, void *virt, size_t pages, unsigned int flags)
    7275{
    73         return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp,
    74             pages, flags);
     76        return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) phys,
     77            (sysarg_t) virt, pages, flags);
    7578}
    7679
    77 int dmamem_map(dmamem_t *dmamem, size_t pages, unsigned int map_flags,
    78     unsigned int dma_flags)
     80int dmamem_map(void *virt, size_t size, unsigned int map_flags,
     81    unsigned int flags, void **phys)
    7982{
    80         // FIXME TODO
    81         return -1;
     83        return (int) __SYSCALL5(SYS_DMAMEM_MAP, (sysarg_t) virt,
     84            (sysarg_t) size, (sysarg_t) map_flags, (sysarg_t) flags,
     85            (sysarg_t) phys);
    8286}
    8387
    84 int dmamem_unmap(dmamem_t *dmamem)
     88int dmamem_map_anonymous(size_t size, unsigned int map_flags,
     89    unsigned int flags, void **phys, void **virt)
    8590{
    86         // FIXME TODO
    87         return -1;
     91        *virt = as_get_mappable_page(size);
     92        if (*virt == NULL)
     93                return ENOMEM;
     94       
     95        return dmamem_map(*virt, size, map_flags,
     96            flags | DMAMEM_FLAGS_ANONYMOUS, phys);
    8897}
    8998
    90 int dmamem_lock(void *virt, void **phys, size_t pages)
     99int dmamem_unmap(void *virt, size_t size, unsigned int flags)
    91100{
    92         // FIXME TODO
    93         return -1;
     101        return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size,
     102            (sysarg_t) flags);
    94103}
    95104
    96 int dmamem_unlock(void *virt, size_t pages)
     105int dmamem_unmap_anonymous(void *virt)
    97106{
    98         // FIXME TODO
    99         return -1;
     107        return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, 0,
     108            DMAMEM_FLAGS_ANONYMOUS);
    100109}
    101110
  • uspace/lib/c/include/ddi.h

    rf4d5f90 r9fe4db3  
    4040#include <task.h>
    4141
    42 typedef struct {
    43         /** Physical memory */
    44         void *phys;
    45        
    46         /** Virtual memory */
    47         void *virt;
    48        
    49         /** Size in pages */
    50         size_t size;
    51        
    52         /** Mapping flags */
    53         unsigned int flags;
    54 } dmamem_t;
     42extern int device_assign_devno(void);
    5543
    56 extern int device_assign_devno(void);
    5744extern int physmem_map(void *, void *, size_t, unsigned int);
    58 extern int dmamem_map(dmamem_t *, size_t, unsigned int, unsigned int);
    59 extern int dmamem_unmap(dmamem_t *);
    60 extern int dmamem_lock(void *, void **, size_t);
    61 extern int dmamem_unlock(void *, size_t);
     45
     46extern int dmamem_map(void *, size_t, unsigned int, unsigned int, void **);
     47extern int dmamem_map_anonymous(size_t, unsigned int, unsigned int, void **,
     48    void **);
     49extern int dmamem_unmap(void *, size_t, unsigned int);
     50extern int dmamem_unmap_anonymous(void *);
     51
    6252extern int iospace_enable(task_id_t, void *, unsigned long);
    6353extern int pio_enable(void *, size_t, void **);
     54
    6455extern int register_irq(int, int, int, irq_code_t *);
    6556extern int unregister_irq(int, int);
  • uspace/lib/net/generic/packet_client.c

    rf4d5f90 r9fe4db3  
    3939#include <unistd.h>
    4040#include <sys/mman.h>
    41 
    4241#include <packet_client.h>
    4342#include <packet_remote.h>
  • uspace/lib/nic/include/nic.h

    rf4d5f90 r9fe4db3  
    275275
    276276/* Packet DMA lock */
    277 extern void *nic_dma_lock_packet(packet_t *);
    278 extern int nic_dma_unlock_packet(packet_t *);
     277extern int nic_dma_lock_packet(packet_t *, size_t, void **);
     278extern int nic_dma_unlock_packet(packet_t *, size_t);
    279279
    280280#endif // __NIC_H__
  • uspace/lib/nic/src/nic_driver.c

    rf4d5f90 r9fe4db3  
    4646#include <ipc/irc.h>
    4747#include <sysinfo.h>
    48 
     48#include <as.h>
    4949#include <devman.h>
    5050#include <ddf/interrupt.h>
     
    13341334 * @return physical address of packet
    13351335 */
    1336 void *nic_dma_lock_packet(packet_t *packet)
    1337 {
    1338         void *phys_addr;
    1339         int rc = dmamem_lock(packet, &phys_addr, 1);
    1340         if (rc != EOK)
    1341                 return NULL;
    1342        
    1343         return phys_addr;
     1336int nic_dma_lock_packet(packet_t *packet, size_t size, void **phys)
     1337{
     1338        return dmamem_map(packet, SIZE2PAGES(size), 0, 0, phys);
    13441339}
    13451340
     
    13481343 * @param packet
    13491344 */
    1350 int nic_dma_unlock_packet(packet_t *packet)
    1351 {
    1352         return dmamem_unlock(packet, 1);
     1345int nic_dma_unlock_packet(packet_t *packet, size_t size)
     1346{
     1347        return dmamem_unmap(packet, size, 0);
    13531348}
    13541349
  • uspace/lib/nic/src/nic_rx_control.c

    rf4d5f90 r9fe4db3  
    438438                }
    439439        }
     440       
    440441        /* Blocked source addresses */
    441442        if (rxc->block_sources) {
     
    443444                        return false;
    444445        }
     446       
    445447        /* VLAN filtering */
    446448        if (!rxc->vlan_exact && rxc->vlan_mask != NULL) {
Note: See TracChangeset for help on using the changeset viewer.