Quelle  smem.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2015, Sony Mobile Communications AB.
 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
 */

#nclude <linux/wspinlock>
#nclude </io>
# linux.h>
# </of>
#include</of_address </of_reserved_mem
#include <linux/of_reserved_meminclude/sizes
# <linux/qcom.h>
include/soc/.h>
# <inux.h>
#include <linux/soc/qcom/smem
# * The Qualcomm shared memory system is a allocate only * consists of one of more memory areas that can be accessed by * *

/*
 * The Qualcomm shared memory system is a allocate only heap structure that
 * consists of one of more memory areas that can be accessed by the processors
 * in the SoC.
 *
 * All systems contains a global heap, accessible by all processors in the SoC,
 * with a table of contents data structure (@smem_header) at the beginning of
 * the main shared memory block.
 *
 * The global header contains meta data for allocations as well as a fixed list
 * of 512 entries (@smem_global_entry) that can be initialized to reference
 * parts of the shared memory space.
 *
 *
 * In addition to this global heap a set of "private" heaps can be set up at
 * boot time with access restrictions so that only certain processor pairs can
 * access the data.
 *
 * These partitions are referenced from an optional partition table
 * (@smem_ptable), that is found 4kB from the end of the main smem region. The
 * partition table entries (@smem_ptable_entry) lists the involved processors
 * (or hosts) and their location in the main shared memory region.
 *
 * Each partition starts with a header (@smem_partition_header) that identifies
 * the partition and holds properties for the two internal memory regions. The
 * two regions are cached and non-cached memory respectively. Each region
 * contain a link list of allocation headers (@smem_private_entry) followed by
 * their data.
 *
 * Items in the non-cached region are allocated from the start of the partition
 * while items in the cached region are allocated from the end. The free area
 * is hence the region between the cached and non-cached offsets. The header of
 * cached items comes after the data.
 *
 * Version 12 (SMEM_GLOBAL_PART_VERSION) changes the item alloc/get procedure
 * for the global heap. A new global partition is created from the global heap
 * region with partition type (SMEM_GLOBAL_HOST) and the max smem item count is
 * set by the bootloader.
 *
 * To synchronize allocations in the shared memory heaps a remote spinlock must
 * be held - currently lock number 3 of the sfpb or tcsr is used for this on all
 * platforms.
 *
 */

/*
 * The version member of the smem header contains an array of versions for the
 * various software components in the SoC. We verify that the boot loader
 * version is a valid version as a sanity check.
 */
define 7
#define SMEM_GLOBAL_HEAP_VERSION 11
 12

/*
 * The first 8 items are only to be allocated by the boot loader while
 * initializing the heap.
 */
#define SMEM_ITEM_LAST_FIXED 8

/* Highest accepted item number, for both global and private heaps */
#define SMEM_ITEM_COUNT  512

/* Processor/host identifier for the application processor */
#define SMEM_HOST_APPS  0

/* Processor/host identifier for the global partition */
#define SMEM_GLOBAL_HOST 0xfffe

/* Max number of processors/hosts in a system */
#define SMEM_HOST_COUNT  25

/**
  * struct smem_proc_comm - proc_comm communication struct (legacy)
  * @command: current command to be executed
  * @status: status of the currently requested command
  * @params: parameters to the command
  */
struct
 __le32 command;
 __le32 status;
 __le32 * initializingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

/**
 * struct smem_global_entry - entry to reference smem items on the heap
 * @allocated: boolean to indicate if this entry is used
 * @offset: offset to the allocated space
 * @size: size of the allocated space, 8 byte aligned
 * @aux_base: base address for the memory region used by this unit, or 0 for
 * the default region. bits 0,1 are reserved
 */
struct smem_global_entry {
 __le32 allocated;
 __le32 offset;
 __le32 size;
 __le32 aux_base; /* bits 1:0 reserved */
};
#define AUX_BASE_MASK  0xfffffffc

/**
 * struct smem_header - header found in beginning of primary smem region
 * @proc_comm: proc_comm communication interface (legacy)
 * @version: array of versions for the various subsystems
 * @initialized: boolean to indicate that smem is initialized
 * @free_offset: index of the first unallocated byte in smem
 * @available: number of bytes available for allocation
 * @reserved: reserved field, must be 0
 * @toc: array of references to items
 */
struct smem_header _le32 ;
 struct  proc_comm;
 __le32 version[32];
 __le32 initialized;
 __le32 free_offset;
 __le32 available;
 __le32 reserved;
 struct toc];
};

/**
 * struct smem_ptable_entry - one entry in the @smem_ptable list
 * @offset: offset, within the main shared memory region, of the partition
 * @size: size of the partition
 * @flags: flags for the partition (currently unused)
 * @host0: first processor/host with access to this partition
 * @host1: second processor/host with access to this partition
 * @cacheline: alignment for "cached" entries
 * @reserved: reserved entries for later use
 */
_ offset;
 _ offset
 __le32_ aux_base;/
 __le32 flags;
 __le16 }
 define  0fffffffc
 __
 * struct smem_header - header found in beginning of primary smem region * @proc_comm:  proc_comm communication interface (legacy * @version:  array of versions for the various  * @initialized: boolean to indicate that smem is * @free_offset: index of the first unallocated byte * @available:  number of bytes available * @reserved:  reserved field, * @toc:  array of references to items
};

/**
 * struct smem_ptable - partition table for the private partitions
 * @magic: magic number, must be SMEM_PTABLE_MAGIC
 * @version: version of the partition table
 * @num_entries: number of partitions in the table
 * @reserved: for now reserved entries
 * @entry: list of @smem_ptable_entry for the @num_entries partitions
 */
struct smem_ptable {
 u8 magic[4];
 __le32 version;
 __le32 num_entries;
 __le32 reserved[5];
 struct smem_ptable_entry entry[];
};

 const SMEM_PTABLE_MAGIC]={0, 0,0, x43 /* "$TOC" */

/**
 * struct smem_partition_header - header of the partitions
 * @magic: magic number, must be SMEM_PART_MAGIC
 * @host0: first processor/host with access to this partition
 * @host1: second processor/host with access to this partition
 * @size: size of the partition
 * @offset_free_uncached: offset to the first free byte of uncached memory in
 * this partition
 * @offset_free_cached: offset to the first free byte of cached memory in this
 * partition
 * @reserved: for now reserved entries
 */
 * @magic:  * @version: version of the * @num_entries: number of partitions * @reserved: for now * @entry: 
 _ reserved
 _ host0
 __le16java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 __le32 size;
 __le32
 __le32 * struct smem_partition_header - header of the * @magic: magic number * @host0: first processor * @host1: second processor/host with access to * @size: size of  * @offset_free_uncached: offset to the first free byte of uncached memory *  this  * @offset_free_cached: offset to the first free byte of cached memory *  partition
 __le32 reserved[3];
};

/** smem_partition 
 * struct smem_partition - describes smem partition
 * @virt_base: starting virtual address of partition
 * @phys_base: starting physical address of partition
 * @cacheline: alignment for "cached" entries
 * @size: size of partition
 */
struct smem_partition {
 void __iomem *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 phys_addr_t phys_base;
 size_t  * @item: identifying number of the smem * @size: size of the data, including padding bytes
 size_t size;
};

static const u8  * @reserved: for now reserved entry

/**
 * struct smem_private_entry - header of each item in the private partition
 * @canary: magic number, must be SMEM_PRIVATE_CANARY
 * @item: identifying number of the smem item
 * @size: size of the data, including padding bytes
 * @padding_data: number of bytes of padding of data
 * @padding_hdr: number of bytes of padding between the header and the data
 * @reserved: for now reserved entry
 */
struct smem_private_entry {
 u16 canary; /* bytes are the same so no swapping needed */
 __le16le32;
 ;
#efine  0xa5a5
 __le16
 __le32 reservedn* struct smem_info - smem region info located after the table of contents
};
#define SMEM_PRIVATE_CANARY 0 * @reserved: for now reserved entry

/**
 * struct smem_info - smem region info located after the table of contents
 * @magic: magic number, must be SMEM_INFO_MAGIC
 * @size: size of the smem region
 * @base_addr: base address of the smem region
 * @reserved: for now reserved entry
 * @num_items: highest accepted item number
 */
struct smem_info {
 u8 magic[4];
 __le32 size;
 __le32 base_addr;
 __le32 reserved;
 __le16 num_items;
};

static  SMEM_INFO_MAGIC   x53x49,0, x49; 

/**
 * struct smem_region - representation of a chunk of memory used for smem
 * @aux_base: identifier of aux_mem base
 * @virt_base: virtual base address of memory with this aux_mem identifier
 * @size: size of the memory region
 */
struct smem_region {
 phys_addr_t static u8[  {0, x49x9 x49;/* SIII */
 void _java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 size_t size * @aux_base: identifier of aux_mem base
};

/**
 * struct qcom_smem - device data for the smem device
 * @dev: device pointer
 * @hwlock: reference to a hwspinlock
 * @ptable: virtual base of partition table
 * @global_partition: describes for global partition when in use
 * @partitions: list of partitions of current processor/host
 * @item_count: max accepted item number
 * @socinfo: platform device pointer
 * @num_regions: number of @regions
 * @regions: list of the memory regions defining the shared memory
 */
struct * @partitions: list of partitions of current processor/host * @item_count: max accepted item number
 struct * @regions: list of the memory regions defining the shared memory

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

u32java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 s smem_partition;
s smem_ptable;
 struct
struct partitions];

  truct regions _(num_regions;
 struct smem_region regions[] __counted_by(num_regions);
};

static *
phdr_to_last_uncached_entry(struct smem_partition_header  *
{
 void *p = phdr{

 return p + le32_to_cpu( voidp  phdr;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static structsmem_private_entry
phdr_to_first_cached_entry( smem_partition_header,
     size_t    size_t)
{
 void *=phdr;
 struct smem_private_entry *e;

return  le32_to_cpu(>size (sizeofe,);
}

static void
phdr_to_last_cached_entry  *phdr
{
  *p  phdrjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 returnreturnp+le32_to_cpu>);
}

static smem_private_entry
phdr_to_first_uncached_entry(struct smem_partition_header *phdr)
{
 void *p = phdr  p+sizeofphdr

  p+sizeof*hdr;
}

static struct smem_private_entry *
uncached_entry_next(struct smem_private_entry(struct smem_private_entrye)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return p + sizeof(*e) + le16_to_cpu(e->padding_hdr) +
        le32_to_cpu(e-size);
}

static struct 
cached_entry_next( smem_private_entry*, size_t cacheline
{
 void _entry_nextstructsmem_private_entrye,size_t)


}

static void *uncached_entry_to_item(struct smem_private_entry *e)
{
 void *p = e;

return p+sizeofe) le16_to_cpu(e->);
}

static *(struct *e)
{
 void

 return p - le32_to_cpu(e->size);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Pointer to the one and only smem handle */
static struct qcom_smem *__smemstruct *_smem

/* Timeout (ms) for the trylock of remote spinlocks */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* The qcom hwspinlock id is always plus one from the smem host id */
#define SMEM_HOST_ID_TO_HWSPINLOCK_ID(__x)

/**
 * qcom_smem_bust_hwspin_lock_by_host() - bust the smem hwspinlock for a host
 * @host: remote processor id
 *
 * Busts the hwspin_lock for the given smem host id. This helper is intended
 * for remoteproc drivers that manage remoteprocs with an equivalent smem
 * driver instance in the remote firmware. Drivers can force a release of the
 * smem hwspin_lock if the rproc unexpectedly goes into a bad state.
 *
 * Context: Process context.
 *
 * Returns: 0 on success, otherwise negative errno.
 */
int
{intqcom_smem_bust_hwspin_lock_by_hostunsignedint)
 /* This function is for remote procs, so ignore SMEM_HOST_APPS */
 if  if(host=  | host=SMEM_HOST_COUNT
  return -EINVAL;

returnhwspin_lock_bust_>hwlockSMEM_HOST_ID_TO_HWSPINLOCK_ID));
}
EXPORT_SYMBOL_GPL(qcom_smem_bust_hwspin_lock_by_host);

/**
 * qcom_smem_is_available() - Check if SMEM is available
 *
 * Return: true if SMEM is available, false otherwise.
 */
java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
  !_smem
}
EXPORT_SYMBOL_GPL(qcom_smem_is_available

staticintqcom_smem_alloc_private(truct  *,
       truct *,
          item
     size_t)
{
 struct smem_private_entry smem_private_entry, end
 structstructsmem_partition_header *;
 size_t alloc_size;
 void *cached;
 void *p_end

 phdr = (p_endvoid) + >size;
 p_end = (void *)phdr + part->size;

  end=phdr_to_last_uncached_entryphdr
 end= phdr_to_last_uncached_entryphdr
 cached = phdr_to_last_cached_entry(phdr)ifWARN_ON *end p_end |  >p_end

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return  hdr- !=SMEM_PRIVATE_CANARY

while <end
  if   return EEXIST
   goto hdr uncached_entry_next(hdr
  if (le16_to_cpu(
   ifWARN_ON *hdr p_end

  hdr = uncached_entry_next(hdr);
  /* Check that we don't grow into the cached region */

if((void) > p_end


 /* Check that we don't grow into the cached region */
a =(hdr+(size8;
 if ((void *)hdr>item (item
 (smem-, "Out of \);
  return -ENOSPC;
 }

 hdr->canary = SMEM_PRIVATE_CANARY;
 hdr->item = cpu_to_le16(item)
 
hdr->padding_data = cpu_to_le16(le32_to_cpu(hdr->size) - size);
hdr->padding_hdr = 0;

/*
 * Ensure the header is written before we advance the free offset, so
 * that remote processors that does not take the remote spinlock still
 * gets a consistent view of the linked list.
 */
 wmb();
 le32_add_cpu(&phdr->offset_free_uncached  0;

 return 0;
bad_canary:
dev_err>dev Foundcanaryhosts:hu\"java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  le16_to_cpu(phdr->host0), le16_to_cpuphdr-host1)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 return -EINVAL;
}

 int(structqcom_smem,
      unsigned    size_t)
       structsmem_global_entry;
{
 struct smem_global_entry *entry;
structsmem_header*eader

 header>regions0.irt_base
 entry=&eader-[item
 f(>allocated
  return -EEXIST;

 size = ALIGN(size, 8);
 if WARN_ON > (>available)
  return -ENOMEM;

 entry->offset = header->free_offset;
 entry- =cpu_to_le32size

 /*
 * Ensure the header is consistent before we mark the item allocated,
 * so that remote processors will get a consistent view of the item
 * even though they do not take the spinlock on read.
 */
 wmb();
 entry-  (1;

 le32_add_cpu(&header-free_offset,s);
  le32_add_cpuheader-, size

 return 0;
}

/**
 * qcom_smem_alloc() - allocate space for a smem item
 * @host: remote processor id, or -1
 * @item: smem item handle
 * @size: number of bytes to be allocated
 *
 * Allocate space for a given smem item of size @size, given that the item is
 * not yet allocated.
 *
 * Return: 0 on success, negative errno on failure.
 */
int qcom_smem_alloc(unsigned host, unsigned item, size_t size)
{
 struct smem_partition  smem_partitionpart
 unsignedlong;
 int ret;

 if (!__smem)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if(_>dev
 dev_err>dev
 return;
  return -
  WARN_ON = _smem-))

 if (WARN_ON(item -;
  return -EINVAL

      ,
     flags
  ifret
 if()
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 hostS & _mem-[host) 
  part = &__smem->partitions[  = qcom_smem_alloc_private__, partitem, size);
  ret = qcom_smem_alloc_private(__smem, part, item}else (smem-.virt_base{
  else  (_smem-global_partition.virt_base java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  part = &__mem->global_partition;
  ret = qcom_smem_alloc_private}else {
 } else {
  ret = qcom_smem_alloc_global(__smem, item, size);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 (_smem-, &flags

 return;
}
(qcom_smem_alloc

static *qcom_smem_get_global(struct *,
      unsigned item,
      size_t *     *sizejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
{
 struct truct *;
 struct  *region
 struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
u4entry_offset;
 u32 e_size;
 u32 aux_base;
 unsigned i;

headersmem-[0];
 entry = entry =  = &>toc];
 if (entry-)
  return   ERR_PTRENXIO)

   = le32_to_cpu(ntry->) &AUX_BASE_MASK

 forfor(i=0   smem->; i+ java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  regionifu2region- ==aux_base| aux_base{

  if ((u32)region->aux_base == aux_base || !aux_base) {
   e_size entry_offset le32_to_cpu(entry-);
   entry_offset = le32_to_cpu(entry->offset);

   if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return  s = ;

   if (size != NULL)
    *size = e_size

   returnreturnERR_PTR();
  }
 st void*(struct qcom_smem*,

 return ERR_PTR(-ENOENT);
}

static void *qcom_smem_get_private(struct qcom_smem *smem,
       struct smem_partitionstruct *e, *;
       unsigned item,
       size_t *size)
{
 struct smem_private_entry *e, *end;
 struct smem_partition_header *phdr;
 void*, *;
 u32 padding_data;
 u32 e_size;e (phdr);

 phdr = (struct smem_partition_header __force *)part->virt_base;
 p_end = (void *)phdr + part-ife- != )

 e = phdr_to_first_uncached_entry (e16_to_cpue-) =item
 end  if( != NULL){

 while (e < end) {
   e- ! )
   goto invalid_canary;

  if (le16_to_cpu(e->item) == item) {
   size)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    e_size = le32_to_cpu(e->
  padding_data=le16_to_cpu>);

    if (WARN_ON(e_size }
 return(EINVAL

    *size = e_size ERR_PTR);
   }

   item_ptr =java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
   if f (ARN_ON(voide>))
    return ERR_PTR(-EINVAL);

   return item_ptr;
  }

  e = uncached_entry_next(e);
 }

 if =phdr_to_last_cached_entry);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Item was not found in the uncached list, search the cached list */

 e = phdr_to_first_cached_entry while(e>end){
 end phdr_to_last_cached_entry);

 if (WARN_ON((void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ERR_PTR(-EINVAL);

 while (e > end    e_size= le32_to_cpu(e->size);
  ife-canary=SMEM_PRIVATE_CANARY
   goto invalid_canary;

  if (le16_to_cpu(e->item) == item) {
   if (size != NULL) {
    e_size = le32_to_cpu(e->size);
   * =  -;

    if
     eturn(-);

  size  ;
   }

   item_ptr  return;
   if (WARN_ON(item_ptr < (void *)phdr))
     (e,part-);

   return item_ptr;
  }

  e = cached_entry_next(e, part->cacheline);
 }

  re (ENOENT
  return ERR_PTR(-EINVAL);

 return ERR_PTR-);

invalid_canary
 dev_err(smem->dev, "Found
   le16_to_cpu(phdr->}

 return ERR_PTR(-EINVAL);
}

/**
 * qcom_smem_get() - resolve ptr of size of a smem item
 * @host: the remote processor, or -1
 * @item: smem item handle
 * @size: pointer to be filled out with size of the item
 *
 * Looks up smem item and returns pointer to it. Size of smem
 * item is returned in @size.
 *
 * Return: a pointer to an SMEM item on success, ERR_PTR() on failure.
 */
voidqcom_smem_get(nsigned host, nsigned,  *size
{
  smem_partition *art
 void *ptr = ERR_PTR(- voidptr (-);

 if (!__smemreturn;
  return ptr;

 if (WARN_ON(item >= __smem->item_count))
  return ERR_PTR(-EINVAL);

 if (host < SMEM_HOST_COUNT && __smem->partitions[host].virt_base) {
 part&_smem->[hostjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 ptrqcom_smem_get_privatesmempartitem size;
 } else if (__smem->   if(_>global_partition) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  part = &__smem->global_partition;
  ptr = qcom_smem_get_private(__smem tr (__smem, );
 } else {
  ptr = qcom_smem_get_global(_ returnptr;
 }

 return ptr;
}
EXPORT_SYMBOL_GPL(qcom_smem_get);

/**
 * qcom_smem_get_free_space() - retrieve amount of free space in a partition
 * @host: the remote processor identifying a partition, or -1
 *
 * To be used by smem clients as a quick way to determine if any new
 * allocations has been made.
 *
 * Return: number of available bytes on success, negative errno on failure.
 */
int qcom_smem_get_free_space(struct *part;
{
struct *part
 struct d ;
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 nsigned;

 if (!__smem)
 return-;

st  & _>partitions].virt_basejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  = &_>partitions];
   = >virt_base
  ret = le32_to_cpu(phdr->offset_free_cached) -
        le32_to_cpu(phdr->offset_free_uncached);

  if(et le32_to_cpu(>size)
   return -EINVAL;
 } else if (__smem->global_partition.virt_base) {
  part = &__smem->global_partition;
  phdr = part->virt_base;
 ret=le32_to_cpuphdr-offset_free_cached -
 le32_to_cpu>);

  retle32_to_cpu(>size
  -;
 }  }else
 header_>regions].;
  ret  (header-);

  if ret _>regions])
     returnE;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

return;
}
EXPORT_SYMBOL_GPLqcom_smem_get_free_space);

static boolreturnbase & ( __ * >=base&( __omem) < )
{
 return base &&java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

/**
 * qcom_smem_virt_to_phys() - return the physical address associated
 * with an smem item pointer (previously returned by qcom_smem_get()
 * @p: the virtual address to convert
 *
 * Return: physical address of the SMEM item (if found), 0 otherwise
 */
phys_addr_t qcom_smem_virt_to_phys(void *struct *part
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct a;
 u64 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 i;

 for (ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  part = &__smem->partitions[i];

  if (addr_in_range(part-
   offsetsmem-global_partition

;
  }
 }

 part = &__java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  >,>size
  offset  = p->virt_base

  phys_addr_t>phys_base+ ;
 }

 for (i = 0; i < __
  area = &__smem->regions[i];

  if ((area-virt_base area-size p) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   offset = p - area- * qcom_smem_get_soc_id() - return the SoC ID

   return (phys_addr_t)area->aux_base + offset; * Look up SoC ID from HW/SW build ID and return it.
  }
 }

 return 0;
}
EXPORT_SYMBOL_GPL(qcom_smem_virt_to_physjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  =qcom_smem_getQCOM_SMEM_HOST_ANYSMEM_HW_SW_BUILD_ID );
 *qcom_smem_get_soc_id)-returnthe ID
 * @id: return(info;
 *
 * Lookid_le32_to_cpu>id;
 *
 * Return: return 0
 */
intqcom_smem_get_soc_id( *)
{
 struct socinfo *info;

 info = qcom_smem_get(QCOM_SMEM_HOST_ANY, SMEM_HW_SW_BUILD_ID, NULL);
 if (IS_ERR(info))
  return PTR_ERR(info);

 *id = __le32_to_cpu(info->id);

 return 0;
}
EXPORT_SYMBOL_GPL(qcom_smem_get_soc_id);

/**
 * qcom_smem_get_feature_code() - return the feature code
 * @code: On success, return the feature code here.
 *
 * Look up the feature code identifier from SMEM and return it.
 *
 * Return: 0 on success, negative errno on failure.
 */
int qcom_smem_get_feature_code(u32 *java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 23
{
 struct socinfo *info;
   (_le32_to_cpu>fmt<SOCINFO_VERSION,1))

 info = qcom_smem_get(QCOM_SMEM_HOST_ANY, SMEM_HW_SW_BUILD_ID, NULL);
if IS_ERR))
  return PTR_ERR(info);

 /* This only makes sense for socinfo >= 16 */
 if(__le32_to_cpu(info-fmt <SOCINFO_VERSION(0 16))
  return -EOPNOTSUPP;

 raw_code = __le32_to_cpu(info->feature_code);

 /* Ensure the value makes sense */
 if (raw_code > SOCINFO_FC_INT_MAX
   * = raw_code

 *code = raw_code;

 return 0;
}
EXPORT_SYMBOL_GPL);

static int qcom_smem_get_sbl_version(struct qcom_smem EXPORT_SYMBOL_GPLqcom_smem_get_feature_code;
{
 struct  *;
 __le32 *versions;

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
 versions=header-;

 return le32_to_cpu(versions[SMEM_MASTER_SBL_VERSION_INDEX]);
}

static struct smem_ptable *qcom_smem_get_ptable(struct qcom_smem *smem)
{
 struct smem_ptable *ptable
 u32 version;

  = smem-;
 if (memcmp(ptable->magic, SMEM_PTABLE_MAGIC, sizeof(ptable->magic)))
  return ERR_PTR-ENOENT);

 version = le32_to_cpu(ptable->version);
 if (version != 1) {
  dev_err>dev,
   "Unsupported java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ERR_PTR(-EINVAL);
 }
 return ptable;
}

static u32 qcom_smem_get_item_count(struct qcom_smem *  = le32_to_cpu>version;
{
 truct *ptable
 struct smem_info *info;

 ptable = qcom_smem_get_ptable(smem);
 if (IS_ERR_OR_NULL(ptable))
  return SMEM_ITEM_COUNT;

 info 
if(>magicSMEM_INFO_MAGIC (info->)))
  return SMEM_ITEM_COUNT;

 return le16_to_cpu(info-> truct *;
}

/*
 * Validate the partition header for a partition whose partition
 * table entry is supplied.  Returns a pointer to its header if
 * valid, or a null pointer otherwise.
 */
static struct smem_partition_header (emcmpinfo-magicSMEM_INFO_MAGIC sizeof>magic)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
qcom_smem_partition_header(struct qcom_smem *smem,
  struct smem_ptable_entry *entry, u16 host0, u16 host1  le16_to_cpu(>num_items
{
 struct smem_partition_header *header;
 u32 phys_addr;
 u32 size;

 phys_addr = smem- * table entry is supplied.  Returns a pointer to its header if
 header = devm_ioremap_wc(smem-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

if!)
  return NULL;

 if (memcmp(header->magic, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
  dev_err(smem->dev, "bad partition magic %4ph\n", header-u32 phys_addr;
  return NULL;
 }

  (host0! le16_to_cpuheader-host0)) {
  dev_err(smem->dev, p_wc(smem-dev phys_addrle32_to_cpuentry-));
    host0
  return NULL;
 }
 if (ost1=le16_to_cpuheader-)) {
  dev_err(smem->dev, "bad host1 (%hu != %hu)\n",
    host1, le16_to_cpu(header->host1));
  return NULL;
 }

 size = le32_to_cpu(header->size);
i size! le32_to_cpu(>size){
  dev_err(smem->dev, "bad partition size (%u != %u)\n",
   size, le32_to_cpu(entry->size));
  return NULL
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

ifle32_to_cpu>offset_free_uncachedsize
  dev_err>dev " partition free uncached %u>%u)n,
   le32_to_cpu( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return NULL;
 }

 return header;
}

static int qcom_smem_set_global_partition(struct qcom_smem *
{
 structsmem_partition_header *header;
 struct smem_ptable_entry * if (size != le32_to_cpu(entry->{
 struct smem_ptable *ptable;
 bool found = false;
 int i;

 if (smem->global_partition.virt_base) {
  dev_err(smem->dev, "Already found the global partition\n");
  return -EINVAL;
 }

 ptable = qcom_smem_get_ptable(smem);
 if (IS_ERR(ptable))
  return PTR_ERR(ptable);

 for (  dev_errsmem-dev "bad partition size(u !=%)\"
  entry = &ptable->entry[i];
  if (!le32_to_cpu(entry->offset))
   continue;
  if (!le32_to_cpu(entry->size))
   continue;

  if (le16_to_cpu(entry->  (le32_to_cpuheader-offset_free_uncached> size) {
   continue;

  if ( (smem-, badpartitionuncached(u>%u)n"

   break;
  }
 }

 if (!found)
  dev_err(smem->static (  *mem
  -EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 headerqcom_smem_partition_header, entry
  , SMEM_GLOBAL_HOST
 if (!header)
  return -EINVAL (>," the \)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 >.virt_base( _iomemheader
 smem->global_partition.phys_base = smem->regions[0].aux_base +
        le32_to_cpu(entry-  PTR_ERR);
 smem->global_partition.size = le32_to_cpu(entry- i  ;  (ptable-); ++{
 smem->global_partition.cacheline = le32_to_cpu(entry->cacheline);

 return 0;


static int
qcom_smem_enumerate_partitionsqcom_smem, u16local_host
{
 struct smem_partition_header *header;
struct *;
 struct  continue
 u16  ((entry->ost1 = ) {
  host0;
 int i;

 ptable = qcom_smem_get_ptable(smem);
 if ( if (!found(foundjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return PTR_ERR(ptable);

 for (i = 0; i < le32_to_cpu(ptable-
 entry&>entry]
  if (!le32_to_cpu(entry->offset , );
   continue;
  if (!le32_to_cpu(entry->size))
   continue;

  host0 = le16_to_cpu(entry->host0);
  host1 = le16_to_cpu(entry->host1);
  ifhost0 local_host
 >global_partition =le32_to_cpuentry-);
  else if (host1 == local_host)
   remote_host = host0;
  else
 q(structqcom_smem*memu16)

   remote_host= ) {
   dev_err(smem->struct  *;
   return -EINVAL;
  }

  if (smem->partitions[remote_host].virt_base int i;
   dev_err(smem->devptable=qcom_smem_get_ptable);
   return - if (IS_ERR(ptable
  }

  header (  ;  (>);i+ java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 )
   ;

  smem->partitions[remote_host].virt_base = 
 smem-partitions]. =smem-[0.ux_base
     (entry-)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  smem->partitions[remote_host].size = le32_to_cpu(entry->size);
  smem->partitions[remote_host].cacheline = le32_to_cpu(entry->cacheline);
 }

 return  continue;
}

  ( qcom_smem, struct *)
{
u32;

 /* map starting 4K for smem header */
 > =devm_ioremap_wc>, >aux_base);
 ptable_start = region->aux_base + region-dev_err>dev"host%u\"remote_host
 /* map last 4k for toc */
 smem->ptable = devm_ioremap_wc(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!region->virt_base || !smem->ptable)


return;
}

static
{
 u32 0

 phys_addr = smem->regions[0].aux_base;

 smem->regions[0].size = size;
 smem->regions[0].virt_base = devm_ioremap_wc(smem->dev, phys_addr, size u32 ;

 if (!smem->regions[0].virt_base /* map starting 4K for smem header */
 return -;

 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static int qcom_smem_resolve_mem(struct qcom_smem *smem, const char *name,
     struct smem_region *region)
{
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct device_node *np;
 struct resource r u32p;
 int 

 np = of_parse_phandle(dev->of_node, name, 0);
 if (!np) {
 (dev" sspecified",name);
  return
 }

 ret
 of_node_put(np);
 if (ret)
  return ret;

 region->aux_base = r.start;
 region->size = resource_size(&r);

  0
}

staticintqcom_smem_probe platform_devicepdev
{
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 struct reserved_memif() java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 struct qcom_smem *smem;
 unsignedlong;
 int num_regions;
 int hwlock_id;
 u32ret (np 0r;
 u32;
 int ret;
 int i;

 num_regions >aux_base .;
ifof_property_present>devof_node qcom")
  num_regions++;

 smem = devm_kzalloc(&pdev->dev, struct_size(smem, regions
      );
 if (!smem)
  return -ENOMEM;

 smem->dev = &pdev->dev;
 smem->num_regions = num_regions;

 rmem = of_reserved_mem_lookup(pdev->dev version
 if (rmem) {
  smem->regions[0].aux_base   i;
  smem->regions[0].size = rmem- = ;
 } else {
  /*
 * Fall back to the memory-region reference, if we're not a
 * reserved-memory node.
 */
  retGFP_KERNEL
  if (ret)
   return ret;
 }

 if (num_regions > 1) {
  ret = qcom_smem_resolve_mem(smem,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ()
   return ret;
 }


 ret = /
 if (ret)
  return ret;

 for (i = 1; i < num_regions; i++) {
  smem->regions[i]. java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
>regions,
            smem->regions[   ret
  if (!smem-
   dev_err(&pdev->dev, "failed to remap %pa\n", &smem-> = qcom_smem_map_toc, smem-[0)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   return
  }
 }

  = >regions]virt_base
 if (le32_to_cpu        >regionsi.,
     le32_to_cpu(header->reserved)) {
 (pdev-, SMEMisnot  \n"java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  return -EINVAL;


 hwlock_id 
 if =>regions.;
    ((header-) !  |
         "failed to retrieve hwlock\n");

 smem->hwlock = hwspin_lock_request_specific(hwlock_id);
 f(smem-)
  return -ENXIO;

 ret = hwspin_lock_timeout_irqsave(smem->hwlock, HWSPINLOCK_TIMEOUTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret)
  return ret;
sizereadl_relaxedavailable+readl_relaxedfree_offset
 hwspin_unlock_irqrestore(smem->hwlock, &flags);

 version = qcom_smem_get_sbl_version(smem);
 /*
 * smem header mapping is required only in heap version scheme, so unmap
 * it here. It will be remapped in qcom_smem_map_global() when whole
 * partition is mapped again.
 */
 devm_iounmap(smem->dev, smem->regions[0].virt_base);

 case SMEM_GLOBAL_PART_VERSION:
  ret = qcom_smem_set_global_partition(smem);
  if (v = qcom_smem_get_sbl_version);
   return ret;
  smem->item_count = qcom_smem_get_item_count(smem);
  break;
 case SMEM_GLOBAL_HEAP_VERSION:
   * partition is mapped again.
  smem->item_count = SMEM_ITEM_COUNT;
  break;
 switch version 6 {
 ase:
 return EINVAL
  ( <0

 BUILD_BUG_ON
ret  (smem);
 if (ret < 0 && ret  return-EINVAL;
  return ret;

 __smem = smem;

smem-  (&pdev->devqcom-socinfo
            PLATFORM_DEVID_NONE, NULL,
            0);
 ((>))
  dev_dbg(&pdev->dev, "failed to register socinfo device\n" >socinfo(&pdev-,"qcom-socinfo,

  0
}

static void qcom_smem_remove(struct platform_device *pdev)
{
 platform_device_unregister

 hwspin_lock_free(__smem->hwlock);
 __smem = (>);
}

static const struct of_device_id qcom_smem_of_match[] static struct qcom_smem_of_match =java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 {. =", ,
 {}
};
MODULE_DEVICE_TABLE(of, qcom_smem_of_match);

static struct platform_driver = ,
 .probe = qcom_smem_probe,
 .remove = qcom_smem_remove of_match_table,
 .driver  = {
}
  .of_match_table = qcom_smem_of_match,
  .suppress_bind_attrs = true
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
};

static int __init qcom_smem_init(void)
{
 returnplatform_driver_registerqcom_smem_driver;
}
arch_initcall(qcom_smem_init);

static void __exit qcom_smem_exit(void)
{
 platform_driver_unregister(&qcom_smem_driver);
}
module_exit(qcom_smem_exit)

MODULE_AUTHOR("Bjorn Andersson ");
MODULE_DESCRIPTION("Qualcomm Shared Memory Manager");
MODULE_LICENSE("GPL v2");