mpm_transport: Update to adapt to new changes in dspmem driver

Then updated dspmem driver now removes dev-tree entries and adds sysfs
entries.
Currently using the sysfs entries to find index.

Signed-off-by: Sam Nelson <sam.nelson@ti.com>

1 files changed, 152 insertions, 82 deletions

diff --git a/src/transport/sharedmem/mpm_transport_sharedmem.c b/src/transport/sharedmem/mpm_transport_sharedmem.c
index 63d5fb8..a76a200 100755
--- a/src/transport/sharedmem/mpm_transport_sharedmem.c
+++ b/src/transport/sharedmem/mpm_transport_sharedmem.c
@@ -44,7 +44,11 @@
 #include "uio_module_drv.h"
 
 #define MAX_DEVICE_NAME_LEN 32
-#define MAX_FILE_NAME_LENGTH    128
+#define MAX_FILE_NAME_LENGTH 256
+#define MAX_PARAM_VAL_LENGTH 32
+#define HEXA_DECIMAL_BASE 16
+
+#define SYSFS_ENTRY_PREFIX /sys/class/misc
 
 static int
 mpm_transport_get_mem_details (mpm_transport_cfg_t *sp,
@@ -78,17 +82,41 @@ mpm_transport_get_mem_details (mpm_transport_cfg_t *sp,
                 laddr, size, sp->name);
         return -1;
 }
+
+/* Function finds the mapping index based on the starting address */
+static int mpm_transport_find_map_index(mpm_transport_sharedmem_t *td, int fd_index, uint64_t global_start_addr) {
+
+        int k;
+
+        for (k = 0; k < td->fd_mem_block.num_mem_blocks[fd_index]; k++) {
+                if(((uint32_t)global_start_addr >=  td->fd_mem_block.mem_block[fd_index][k].base) &&
+                        ((uint32_t)global_start_addr <  (td->fd_mem_block.mem_block[fd_index][k].base
+                        + td->fd_mem_block.mem_block[fd_index][k].length))) {
+#ifdef DEBUG
+                        mpm_printf(1, "DEBUG: Success map_index %d, global_start_addr 0x%x: fd_index %d\n",
+                                k, (uint32_t)global_start_addr, fd_index);
+#endif
+                        return k;
+                }
+        }
+        return -1;
+
+}
+
 int mpm_transport_sharedmem_open(mpm_transport_cfg_t *sp, mpm_transport_open_t *ocfg)
 {
         int i, j, k;
         mpm_transport_sharedmem_t *td;
         int fd;
         char filename[MAX_FILE_NAME_LENGTH];
+        char hexstring[MAX_PARAM_VAL_LENGTH];
         off_t  fileSize;
         struct stat statbuf;
         char   *scratch;
         char   *devname;
         int fd_index;
+        int map_index;
+        int ret;
 
         td = calloc(1, sizeof(mpm_transport_sharedmem_t));
         if (!td) {
@@ -98,30 +126,22 @@ int mpm_transport_sharedmem_open(mpm_transport_cfg_t *sp, mpm_transport_open_t *
         td->fd_mem_block.num_fds = 0;
         for (i = 0; i < sp->num_mmap; i++) {
                 /* check if fd for same device name is already opened */
-                for (j = 0; j < i; j++) {
+                for (j = 0; j < td->fd_mem_block.num_fds; j++) {
 #ifdef DEBUG
-                        mpm_printf(1, "DEBUG: string compare %s : %s\n",
-                                sp->mmap[i].devicename, sp->mmap[j].devicename);
+                        mpm_printf(1, "DEBUG: string compare i:%d, j:%d, %s : %s\n",
+                                i, j, sp->mmap[i].devicename, sp->mmap[j].devicename);
 #endif
                         if (!strncmp(sp->mmap[i].devicename, sp->mmap[j].devicename, MAX_DEVICE_NAME_LEN)) {
                                 td->fd_index[i] = td->fd_index[j];
                                 fd_index = td->fd_index[i];
-                                for (k = 0; k < td->fd_mem_block.num_mem_blocks[fd_index]; k++) {
-                                        if((sp->mmap[i].global_addr >=  td->fd_mem_block.mem_block[fd_index][k].base) &&
-                                                (sp->mmap[i].global_addr <  td->fd_mem_block.mem_block[fd_index][k].base
-                                                 + td->fd_mem_block.mem_block[fd_index][k].length)) {
-                                                td->map_index[i] = k;
-#ifdef DEBUG
-                                                mpm_printf(1, "DEBUG: Success mmap entry %d: fd_index %d, map_index %d\n",
-                                                        i, fd_index, k);
-#endif
-                                                break;
-                                        }
-                                }
-                                if(k >= td->fd_mem_block.num_mem_blocks[fd_index]) {
-                                        mpm_printf(1, "Could not find map index for address %x\n",
-                                                sp->mmap[i].global_addr);
+                                map_index = mpm_transport_find_map_index(td, fd_index, sp->mmap[i].global_addr);
+                                if ( map_index < 0 ) {
+                                        mpm_printf(1, "Could not find map index for address %llx error map_index %d\n",
+                                                sp->mmap[i].global_addr, map_index);
+                                        return MPM_TRANSPORT_SHM_OPEN_ERR_MAP_INDEX;
+
                                 }
+                                td->map_index[i] = map_index;
                                 break;
                         }
                 }
@@ -137,76 +157,126 @@ int mpm_transport_sharedmem_open(mpm_transport_cfg_t *sp, mpm_transport_open_t *
                 }
                 td->fd_index[i] = td->fd_mem_block.num_fds;
                 devname = strrchr(sp->mmap[i].devicename, '/')+1;
-                /* Check device tree and record the index of the mmap */
-                snprintf(filename, MAX_FILE_NAME_LENGTH, "/proc/device-tree/soc/%s/reg", devname);
-                if ((fd = open (filename, O_RDONLY)) == -1)
-                {
-                        mpm_printf(1, "Failed to open \"%s\" err=%s\n",
-                                filename, strerror(errno));
-                        return MPM_TRANSPORT_SHM_OPEN_ERR_MEM_FILE_OPEN;
-                }
-                if (fstat (fd, &statbuf) == -1)
-                {
-                        mpm_printf (1, "Failed to find size of %s (%s)\n",
-                                filename, strerror(errno));
-                        return MPM_TRANSPORT_SHM_OPEN_ERR_FIND_FILE_SIZE;
-                }
-                fileSize = statbuf.st_size;
-                td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]  = fileSize / sizeof(mem_block_t);
-                scratch = malloc (sizeof(mem_block_t) * td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]);
-                if (!td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]  || ! scratch)
-                {
-                        mpm_printf (1, "Failed to malloc size blocks for %d\n", td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]);
-                        return MPM_TRANSPORT_SHM_OPEN_ERR_MALLOC;
-                }
-                if ( read (fd, scratch, fileSize) != fileSize)
-                {
-                        mpm_printf (1, "Failed to read %d bytes from %s\n",
-                                                 (int)fileSize, filename);
-                        return MPM_TRANSPORT_SHM_OPEN_ERR_READ;
-                }
-                close (fd);
-                if ( td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds] > MPM_MAX_MEM_ENTRIES) {
-                        mpm_printf (1, "Number of blocks %d exceeds max %d\n",
-                                td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds], MPM_MAX_MEM_ENTRIES );
-                        return MPM_TRANSPORT_SHM_OPEN_ERR_BLOCKS_EXCEED_MAX;                    
-                }
-                for (k = 0; k < td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]; k++)
-                {
-                         /* Swizzle from big endian in proc */
-                         td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base =
-                                 (scratch[k*8 + 0] << 24) |
-                                 (scratch[k*8 + 1] << 16) |
-                                 (scratch[k*8 + 2] <<  8) |
-                                 (scratch[k*8 + 3]      );
-                         td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length =
-                                 (scratch[k*8 + 4] << 24) |
-                                 (scratch[k*8 + 5] << 16) |
-                                 (scratch[k*8 + 6] <<  8) |
-                                 (scratch[k*8 + 7]      );
+
+                k = 0;
+                /* Check first if there are sysfs entries for the memory */
+                snprintf(filename, MAX_FILE_NAME_LENGTH,
+                        "SYSFS_ENTRY_PREFIX""/%s/memory%d/addr", devname, k);
+
+                if ((fd = open (filename, O_RDONLY)) != -1) {
+
+                        /* Found sysfs entry : Read memory information */
+                        do {
+                                ret = read(fd, hexstring, MAX_PARAM_VAL_LENGTH);
+                                if ( ret <= 0 ) {
+                                        mpm_printf (1, "Failed to read %d bytes from %s: ret %d\n",
+                                                (int) MAX_PARAM_VAL_LENGTH, filename, ret);
+                                        return MPM_TRANSPORT_SHM_OPEN_ERR_READ;
+                                }
+                                close(fd);
+                                /* And populate mem_block base information */
+                                td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base
+                                        = (uint32_t)strtoul(hexstring, NULL, HEXA_DECIMAL_BASE);
 #ifdef DEBUG
-                        mpm_printf(1, " DEBUG: Index %d: Base %x, length %x\n", k, td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base,
-                                td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length);
+                                mpm_printf(1, "Recording addr 0x%x\n",
+                                        td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base);
 #endif
-                }
-                for (k = 0; k < td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]; k++)
-                {
-                        if((sp->mmap[i].global_addr >=  td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base) && 
-                                (sp->mmap[i].global_addr <  td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base 
-                                + td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length)) {
-                                td->map_index[i] = k;
-                                mpm_printf(1, "Success mmap entry %d: fd_index %d, map_index %d\n",
-                                        i,td->fd_mem_block.num_fds, k);
-                                break;
+                                snprintf(filename, MAX_FILE_NAME_LENGTH,
+                                        "SYSFS_ENTRY_PREFIX""/%s/memory%d/size",
+                                        devname, k);
+                                fd = open(filename, O_RDONLY);
+                                if ( fd == -1 ) {
+                                        mpm_printf(1, "Failed to open \"%s\" err=%s\n",
+                                                filename, strerror(errno));
+                                        return MPM_TRANSPORT_SHM_OPEN_ERR_MEM_FILE_OPEN;
+                                }
+
+                                ret = read(fd, hexstring, MAX_PARAM_VAL_LENGTH);
+                                if ( ret <= 0 ) {
+                                        mpm_printf (1, "Failed to read %d bytes from %s: ret %d\n",
+                                                (int) MAX_PARAM_VAL_LENGTH, filename, ret);
+                                        return MPM_TRANSPORT_SHM_OPEN_ERR_READ;
+                                }
+                                close(fd);
+                                td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length
+                                        = (uint32_t)strtoul(hexstring, NULL, HEXA_DECIMAL_BASE);
+#ifdef DEBUG
+                                mpm_printf(1, "Recording length 0x%x\n",
+                                        td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length);
+#endif
+                                k++;
+                                snprintf(filename, MAX_FILE_NAME_LENGTH,
+                                        "SYSFS_ENTRY_PREFIX""/%s/memory%d/addr",
+                                        devname, k);
+                        } while ((fd = open(filename, O_RDONLY)) != -1 );
+                } else {
+                        /* Check device tree and record the index of the mmap */
+                        snprintf(filename, MAX_FILE_NAME_LENGTH, "/proc/device-tree/soc/%s/reg", devname);
+
+                        if ((fd = open(filename, O_RDONLY)) == -1)
+                        {
+                                mpm_printf(1, "Failed to open \"%s\" err=%s\n",
+                                        filename, strerror(errno));
+                                return MPM_TRANSPORT_SHM_OPEN_ERR_MEM_FILE_OPEN;
+                        }
+                        if (fstat (fd, &statbuf) == -1)
+                        {
+                                mpm_printf (1, "Failed to find size of %s (%s)\n",
+                                        filename, strerror(errno));
+                                return MPM_TRANSPORT_SHM_OPEN_ERR_FIND_FILE_SIZE;
+                        }
+                        fileSize = statbuf.st_size;
+                        td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]  = fileSize / sizeof(mem_block_t);
+                        scratch = malloc (sizeof(mem_block_t) * td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]);
+                        if (!td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]  || !scratch)
+                        {
+                                mpm_printf (1, "Failed to malloc size blocks for %d\n",
+                                        td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]);
+                                return MPM_TRANSPORT_SHM_OPEN_ERR_MALLOC;
+                        }
+                        if ( read (fd, scratch, fileSize) != fileSize)
+                        {
+                                mpm_printf (1, "Failed to read %d bytes from %s\n",
+                                                         (int)fileSize, filename);
+                                return MPM_TRANSPORT_SHM_OPEN_ERR_READ;
                         }
+                        close (fd);
+                        if ( td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds] > MPM_MAX_MEM_ENTRIES) {
+                                mpm_printf (1, "Number of blocks %d exceeds max %d\n",
+                                        td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds], MPM_MAX_MEM_ENTRIES );
+                                return MPM_TRANSPORT_SHM_OPEN_ERR_BLOCKS_EXCEED_MAX;
+                        }
+                        for (k = 0; k < td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]; k++)
+                        {
+                                 /* Swizzle from big endian in proc */
+                                 td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base =
+                                         (scratch[k*8 + 0] << 24) |
+                                         (scratch[k*8 + 1] << 16) |
+                                         (scratch[k*8 + 2] <<  8) |
+                                         (scratch[k*8 + 3]      );
+                                 td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length =
+                                         (scratch[k*8 + 4] << 24) |
+                                         (scratch[k*8 + 5] << 16) |
+                                         (scratch[k*8 + 6] <<  8) |
+                                         (scratch[k*8 + 7]      );
+#ifdef DEBUG
+                                mpm_printf(1, " DEBUG: Index %d: Base %x, length %x\n", k,
+                                        td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].base,
+                                        td->fd_mem_block.mem_block[td->fd_mem_block.num_fds][k].length);
+#endif
+                        }
+                        free (scratch);
                 }
-                if(k >= td->fd_mem_block.num_mem_blocks[td->fd_mem_block.num_fds]) {
-                        mpm_printf(1, "Could not find map index for address %x\n",
+                /* Now find the matching map section */
+                map_index = mpm_transport_find_map_index(td, td->fd_mem_block.num_fds,
                                 sp->mmap[i].global_addr);
+                if ( map_index < 0 ) {
+                        mpm_printf(1, "Could not find map index for address 0x%llx error: map_index %d\n",
+                                sp->mmap[i].global_addr, map_index);
                         return MPM_TRANSPORT_SHM_OPEN_ERR_MAP_INDEX;
                 }
-                
-                free (scratch);
+                td->map_index[i] = map_index;
+
                 td->fd_mem_block.num_fds++;
                 if ( td->fd_mem_block.num_fds >= MPM_MAX_NUM_FDS ) {
                         mpm_printf (1, "Number of fds %d exceeds max fds %d\n",