Home | History | Annotate | Download | only in libgralloc
      1 /*
      2  * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
      3 
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *   * Redistributions of source code must retain the above copyright
      8  *     notice, this list of conditions and the following disclaimer.
      9  *   * Redistributions in binary form must reproduce the above
     10  *     copyright notice, this list of conditions and the following
     11  *     disclaimer in the documentation and/or other materials provided
     12  *     with the distribution.
     13  *   * Neither the name of The Linux Foundation nor the names of its
     14  *     contributors may be used to endorse or promote products derived
     15  *     from this software without specific prior written permission.
     16  *
     17  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     24  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     26  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28  */
     29 
     30 #define DEBUG 0
     31 #include <linux/ioctl.h>
     32 #include <sys/mman.h>
     33 #include <stdlib.h>
     34 #include <fcntl.h>
     35 #include <cutils/log.h>
     36 #include <errno.h>
     37 #include "gralloc_priv.h"
     38 #include "ionalloc.h"
     39 
     40 using gralloc::IonAlloc;
     41 
     42 #define ION_DEVICE "/dev/ion"
     43 
     44 int IonAlloc::open_device()
     45 {
     46     if(mIonFd == FD_INIT)
     47         mIonFd = open(ION_DEVICE, O_RDONLY);
     48 
     49     if(mIonFd < 0 ) {
     50         ALOGE("%s: Failed to open ion device - %s",
     51               __FUNCTION__, strerror(errno));
     52         mIonFd = FD_INIT;
     53         return -errno;
     54     }
     55     return 0;
     56 }
     57 
     58 void IonAlloc::close_device()
     59 {
     60     if(mIonFd >= 0)
     61         close(mIonFd);
     62     mIonFd = FD_INIT;
     63 }
     64 
     65 int IonAlloc::alloc_buffer(alloc_data& data)
     66 {
     67     Locker::Autolock _l(mLock);
     68     int err = 0;
     69     struct ion_handle_data handle_data;
     70     struct ion_fd_data fd_data;
     71     struct ion_allocation_data ionAllocData;
     72     void *base = 0;
     73 
     74     ionAllocData.len = data.size;
     75     ionAllocData.align = data.align;
     76     ionAllocData.heap_mask = data.flags & ~ION_SECURE;
     77     ionAllocData.flags = data.uncached ? 0 : ION_FLAG_CACHED;
     78     // ToDo: replace usage of alloc data structure with
     79     //  ionallocdata structure.
     80     if (data.flags & ION_SECURE)
     81         ionAllocData.flags |= ION_SECURE;
     82 
     83     err = open_device();
     84     if (err)
     85         return err;
     86     if(ioctl(mIonFd, ION_IOC_ALLOC, &ionAllocData)) {
     87         err = -errno;
     88         ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
     89         return err;
     90     }
     91 
     92     fd_data.handle = ionAllocData.handle;
     93     handle_data.handle = ionAllocData.handle;
     94     if(ioctl(mIonFd, ION_IOC_MAP, &fd_data)) {
     95         err = -errno;
     96         ALOGE("%s: ION_IOC_MAP failed with error - %s",
     97               __FUNCTION__, strerror(errno));
     98         ioctl(mIonFd, ION_IOC_FREE, &handle_data);
     99         return err;
    100     }
    101 
    102     if(!(data.flags & ION_SECURE)) {
    103         base = mmap(0, ionAllocData.len, PROT_READ|PROT_WRITE,
    104                     MAP_SHARED, fd_data.fd, 0);
    105         if(base == MAP_FAILED) {
    106             err = -errno;
    107             ALOGE("%s: Failed to map the allocated memory: %s",
    108                   __FUNCTION__, strerror(errno));
    109             ioctl(mIonFd, ION_IOC_FREE, &handle_data);
    110             return err;
    111         }
    112         memset(base, 0, ionAllocData.len);
    113         // Clean cache after memset
    114         clean_buffer(base, data.size, data.offset, fd_data.fd,
    115                      CACHE_CLEAN_AND_INVALIDATE);
    116     }
    117 
    118     data.base = base;
    119     data.fd = fd_data.fd;
    120     ioctl(mIonFd, ION_IOC_FREE, &handle_data);
    121     ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%d fd:%d",
    122           data.base, ionAllocData.len, data.fd);
    123     return 0;
    124 }
    125 
    126 
    127 int IonAlloc::free_buffer(void* base, size_t size, int offset, int fd)
    128 {
    129     Locker::Autolock _l(mLock);
    130     ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%d fd:%d",
    131           base, size, fd);
    132     int err = 0;
    133     err = open_device();
    134     if (err)
    135         return err;
    136 
    137     if(base)
    138         err = unmap_buffer(base, size, offset);
    139     close(fd);
    140     return err;
    141 }
    142 
    143 int IonAlloc::map_buffer(void **pBase, size_t size, int offset, int fd)
    144 {
    145     int err = 0;
    146     void *base = 0;
    147     // It is a (quirky) requirement of ION to have opened the
    148     // ion fd in the process that is doing the mapping
    149     err = open_device();
    150     if (err)
    151         return err;
    152 
    153     base = mmap(0, size, PROT_READ| PROT_WRITE,
    154                 MAP_SHARED, fd, 0);
    155     *pBase = base;
    156     if(base == MAP_FAILED) {
    157         err = -errno;
    158         ALOGE("ion: Failed to map memory in the client: %s",
    159               strerror(errno));
    160     } else {
    161         ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%d offset:%d fd:%d",
    162               base, size, offset, fd);
    163     }
    164     return err;
    165 }
    166 
    167 int IonAlloc::unmap_buffer(void *base, size_t size, int offset)
    168 {
    169     ALOGD_IF(DEBUG, "ion: Unmapping buffer  base:%p size:%d", base, size);
    170     int err = 0;
    171     if(munmap(base, size)) {
    172         err = -errno;
    173         ALOGE("ion: Failed to unmap memory at %p : %s",
    174               base, strerror(errno));
    175     }
    176     return err;
    177 
    178 }
    179 int IonAlloc::clean_buffer(void *base, size_t size, int offset, int fd, int op)
    180 {
    181     struct ion_flush_data flush_data;
    182     struct ion_fd_data fd_data;
    183     struct ion_handle_data handle_data;
    184     struct ion_handle* handle;
    185     int err = 0;
    186 
    187     err = open_device();
    188     if (err)
    189         return err;
    190 
    191     fd_data.fd = fd;
    192     if (ioctl(mIonFd, ION_IOC_IMPORT, &fd_data)) {
    193         err = -errno;
    194         ALOGE("%s: ION_IOC_IMPORT failed with error - %s",
    195               __FUNCTION__, strerror(errno));
    196         return err;
    197     }
    198 
    199     handle_data.handle = fd_data.handle;
    200     flush_data.handle  = fd_data.handle;
    201     flush_data.vaddr   = base;
    202     flush_data.offset  = offset;
    203     flush_data.length  = size;
    204 
    205     struct ion_custom_data d;
    206     switch(op) {
    207     case CACHE_CLEAN:
    208         d.cmd = ION_IOC_CLEAN_CACHES;
    209         break;
    210     case CACHE_INVALIDATE:
    211             d.cmd = ION_IOC_INV_CACHES;
    212         break;
    213     case CACHE_CLEAN_AND_INVALIDATE:
    214     default:
    215         d.cmd = ION_IOC_CLEAN_INV_CACHES;
    216     }
    217 
    218     d.arg = (unsigned long int)&flush_data;
    219 
    220     if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
    221         err = -errno;
    222         ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
    223 
    224               __FUNCTION__, strerror(errno));
    225         ioctl(mIonFd, ION_IOC_FREE, &handle_data);
    226         return err;
    227     }
    228     ioctl(mIonFd, ION_IOC_FREE, &handle_data);
    229     return 0;
    230 }
    231 
    232