コード例 #1
0
ファイル: mq_initialize.c プロジェクト: FreddieChopin/NuttX
void mq_desblockalloc(void)
{
  FAR struct mq_des_block_s *mqdesblock;

  /* Allocate a block of message descriptors */

  mqdesblock = (FAR struct mq_des_block_s *)kmm_malloc(sizeof(struct mq_des_block_s));
  if (mqdesblock)
    {
      int i;

      /* Add the block to the list of allocated blocks (in case
       * we ever need to reclaim the memory.
       */

      sq_addlast((FAR sq_entry_t*)&mqdesblock->queue, &g_desalloc);

      /* Then add each message queue descriptor to the free list */

      for (i = 0; i < NUM_MSG_DESCRIPTORS; i++)
        {
          sq_addlast((FAR sq_entry_t*)&mqdesblock->mqdes[i], &g_desfree);
        }
    }
}
コード例 #2
0
ファイル: kxtj9.c プロジェクト: jksim/nuttx
int kxtj9_driver_init(){
    int ret = 0;

    if (g_data != NULL)
        goto init_done;
    g_data = kmm_malloc(sizeof(struct kxtj9_data));
    memset(g_data, 0, sizeof(struct kxtj9_data));

    g_data->i2c = up_i2cinitialize(CONFIG_SENSOR_KXTJ9_I2C_BUS);
    if (!g_data->i2c) {
        dbg("failed to init i2c\n");
        ret = -ENODEV;
        goto init_done;
    }

    ret = I2C_SETADDRESS(g_data->i2c, KXTJ9_I2C_ADDR, 7);
    if (ret) {
        dbg("failed to set i2c address\n");
        goto init_done;
    }

    I2C_SETFREQUENCY(g_data->i2c, CONFIG_SENSOR_KXTJ9_I2C_BUS_SPEED);

init_done:
    return ret;
}
コード例 #3
0
ファイル: pipe_common.c プロジェクト: a1ien/nuttx
FAR struct pipe_dev_s *pipecommon_allocdev(size_t bufsize)
{
  FAR struct pipe_dev_s *dev;

  DEBUGASSERT(bufsize <= CONFIG_DEV_PIPE_MAXSIZE);

  /* Allocate a private structure to manage the pipe */

  dev = (FAR struct pipe_dev_s *)kmm_malloc(sizeof(struct pipe_dev_s));
  if (dev)
    {
      /* Initialize the private structure */

      memset(dev, 0, sizeof(struct pipe_dev_s));
      sem_init(&dev->d_bfsem, 0, 1);
      sem_init(&dev->d_rdsem, 0, 0);
      sem_init(&dev->d_wrsem, 0, 0);

     /* The read/write wait semaphores are used for signaling and, hence,
      * should not have priority inheritance enabled.
      */

     sem_setprotocol(&dev->d_rdsem, SEM_PRIO_NONE);
     sem_setprotocol(&dev->d_wrsem, SEM_PRIO_NONE);

      dev->d_bufsize = bufsize;
    }

  return dev;
}
コード例 #4
0
static int proc_dup(FAR const struct file *oldp, FAR struct file *newp)
{
  FAR struct proc_file_s *oldfile;
  FAR struct proc_file_s *newfile;

  fvdbg("Dup %p->%p\n", oldp, newp);

  /* Recover our private data from the old struct file instance */

  oldfile = (FAR struct proc_file_s *)oldp->f_priv;
  DEBUGASSERT(oldfile);

  /* Allocate a new container to hold the task and node selection */

  newfile = (FAR struct proc_file_s *)kmm_malloc(sizeof(struct proc_file_s));
  if (!newfile)
    {
      fdbg("ERROR: Failed to allocate file container\n");
      return -ENOMEM;
    }

  /* The copy the file information from the old container to the new */

  memcpy(newfile, oldfile, sizeof(struct proc_file_s));

  /* Save the new container in the new file structure */

  newp->f_priv = (FAR void *)newfile;
  return OK;
}
コード例 #5
0
ファイル: lm75.c プロジェクト: FreddieChopin/NuttX
int lm75_register(FAR const char *devpath, FAR struct i2c_dev_s *i2c, uint8_t addr)
{
  FAR struct lm75_dev_s *priv;
  int ret;

  /* Initialize the LM-75 device structure */

  priv = (FAR struct lm75_dev_s *)kmm_malloc(sizeof(struct lm75_dev_s));
  if (!priv)
    {
      lm75dbg("Failed to allocate instance\n");
      return -ENOMEM;
    }

  priv->i2c        = i2c;
  priv->addr       = addr;
  priv->fahrenheit = false;

  /* Register the character driver */

  ret = register_driver(devpath, &g_lm75fops, 0666, priv);
  if (ret < 0)
    {
      lm75dbg("Failed to register driver: %d\n", ret);
      kmm_free(priv);
    }

  return ret;
}
コード例 #6
0
ファイル: mb7040.c プロジェクト: justdoitding/Nuttx_PSoC4
int mb7040_register(FAR const char *devpath, FAR struct i2c_dev_s *i2c,
                    uint8_t addr)
{
  FAR struct mb7040_dev_s *priv;
  int ret;

  /* Sanity check */

  DEBUGASSERT(i2c != NULL);

  /* Initialize the device's structure */

  priv = (FAR struct mb7040_dev_s *)kmm_malloc(sizeof(*priv));
  if (priv == NULL)
    {
      sndbg("Failed to allocate instance\n");
      return -ENOMEM;
    }

  priv->i2c  = i2c;
  priv->addr = addr;

  /* Register the character driver */

  ret = register_driver(devpath, &g_fops, 0666, priv);
  if (ret < 0)
    {
      sndbg("Failed to register driver: %d\n", ret);
      kmm_free(priv);
    }

  return ret;
}
コード例 #7
0
ファイル: fs_procfsuptime.c プロジェクト: dagar/NuttX
static int uptime_dup(FAR const struct file *oldp, FAR struct file *newp)
{
  FAR struct uptime_file_s *oldattr;
  FAR struct uptime_file_s *newattr;

  finfo("Dup %p->%p\n", oldp, newp);

  /* Recover our private data from the old struct file instance */

  oldattr = (FAR struct uptime_file_s *)oldp->f_priv;
  DEBUGASSERT(oldattr);

  /* Allocate a new container to hold the task and attribute selection */

  newattr = (FAR struct uptime_file_s *)kmm_malloc(sizeof(struct uptime_file_s));
  if (!newattr)
    {
      ferr("ERROR: Failed to allocate file attributes\n");
      return -ENOMEM;
    }

  /* The copy the file attributes from the old attributes to the new */

  memcpy(newattr, oldattr, sizeof(struct uptime_file_s));

  /* Save the new attributes in the new file structure */

  newp->f_priv = (FAR void *)newattr;
  return OK;
}
コード例 #8
0
ファイル: mq_initialize.c プロジェクト: FreddieChopin/NuttX
static struct mqueue_msg_s *
mq_msgblockalloc(FAR sq_queue_t *queue, uint16_t nmsgs,
                 uint8_t alloc_type)
{
  struct mqueue_msg_s *mqmsgblock;

  /* The g_msgfree must be loaded at initialization time to hold the
   * configured number of messages.
   */

  mqmsgblock = (FAR struct mqueue_msg_s*)
    kmm_malloc(sizeof(struct mqueue_msg_s) * nmsgs);

  if (mqmsgblock)
    {
      struct mqueue_msg_s *mqmsg = mqmsgblock;
      int      i;

      for (i = 0; i < nmsgs; i++)
        {
          mqmsg->type = alloc_type;
          sq_addlast((FAR sq_entry_t*)mqmsg++, queue);
        }
    }

  return mqmsgblock;
}
コード例 #9
0
ファイル: max6675.c プロジェクト: dagar/NuttX
int max6675_register(FAR const char *devpath, FAR struct spi_dev_s *spi)
{
  FAR struct max6675_dev_s *priv;
  int ret;

  /* Sanity check */

  DEBUGASSERT(spi != NULL);

  /* Initialize the MAX6675 device structure */

  priv = (FAR struct max6675_dev_s *)kmm_malloc(sizeof(struct max6675_dev_s));
  if (priv == NULL)
    {
      snerr("ERROR: Failed to allocate instance\n");
      return -ENOMEM;
    }

  priv->spi        = spi;
  priv->temp       = 0;

  /* Register the character driver */

  ret = register_driver(devpath, &g_max6675fops, 0666, priv);
  if (ret < 0)
    {
      snerr("ERROR: Failed to register driver: %d\n", ret);
      kmm_free(priv);
    }

  return ret;
}
コード例 #10
0
ファイル: group_malloc.c プロジェクト: a1ien/nuttx
FAR void *group_malloc(FAR struct task_group_s *group, size_t nbytes)
{
  /* A NULL group pointer means the current group */

  if (!group)
    {
      FAR struct tcb_s *tcb = this_task();
      DEBUGASSERT(tcb && tcb->group);
      group = tcb->group;
    }

  /* Check the group type */

  if ((group->tg_flags & GROUP_FLAG_PRIVILEGED) != 0)
    {
      /* It is a privileged group... use the kernel mode memory allocator */

      return kmm_malloc(nbytes);
    }
  else
    {
      /* This is an unprivileged group... use the user mode memory
       * allocator.
       */

      return kumm_malloc(nbytes);
    }
}
コード例 #11
0
static int dm320_allocvideomemory(void)
{
#ifndef CONFIG_DM320_VID0_DISABLE
#ifndef CONFIG_DM320_DISABLE_PINGPONG
  g_vid0base   = (FAR void *)kmm_malloc(2 * DM320_VID0_FBLEN);
  g_vid0ppbase = (FAR char *)g_vid0base + DM320_VID0_FBLEN;
#else
  g_vid0base   = (FAR void *)kmm_malloc(DM320_VID0_FBLEN);
#endif
  if (!g_vid0base)
    {
      goto errout;
    }
#endif

#ifndef CONFIG_DM320_VID1_DISABLE
  g_vid1base = (FAR void *)kmm_malloc(DM320_VID1_FBLEN);
  if (!g_vid1base)
    {
      goto errout;
    }
#endif

#ifndef CONFIG_DM320_OSD0_DISABLE
  g_osd0base = (FAR void *)kmm_malloc(DM320_OSD0_FBLEN);
  if (!g_osd0base)
    {
      goto errout;
    }
#endif

#ifndef CONFIG_DM320_OSD1_DISABLE
  g_osd1base = (FAR void *)kmm_malloc(DM320_OSD1_FBLEN);
  if (!g_osd1base)
    {
      goto errout;
    }
#endif

  return OK;

errout:
  dm320_freevideomemory();
  return -ENOMEM;
}
コード例 #12
0
int group_initialize(FAR struct task_tcb_s *tcb)
{
  FAR struct task_group_s *group;
#if defined(HAVE_GROUP_MEMBERS) || defined(CONFIG_ARCH_ADDRENV)
  irqstate_t flags;
#endif

  DEBUGASSERT(tcb && tcb->cmn.group);
  group = tcb->cmn.group;

#ifdef HAVE_GROUP_MEMBERS
  /* Allocate space to hold GROUP_INITIAL_MEMBERS members of the group */

  group->tg_members = (FAR pid_t *)kmm_malloc(GROUP_INITIAL_MEMBERS*sizeof(pid_t));
  if (!group->tg_members)
    {
      kmm_free(group);
      return -ENOMEM;
    }

  /* Assign the PID of this new task as a member of the group. */

  group->tg_members[0] = tcb->cmn.pid;

  /* Initialize the non-zero elements of group structure and assign it to
   * the tcb.
   */

  group->tg_mxmembers  = GROUP_INITIAL_MEMBERS; /* Number of members in allocation */

#endif

#if defined(HAVE_GROUP_MEMBERS) || defined(CONFIG_ARCH_ADDRENV)
  /* Add the initialized entry to the list of groups */

  flags = irqsave();
  group->flink = g_grouphead;
  g_grouphead = group;
  irqrestore(flags);

#endif

  /* Save the ID of the main task within the group of threads.  This needed
   * for things like SIGCHILD.  It ID is also saved in the TCB of the main
   * task but is also retained in the group which may persist after the main
   * task has exited.
   */

#if !defined(CONFIG_DISABLE_PTHREAD) && defined(CONFIG_SCHED_HAVE_PARENT)
  group->tg_task = tcb->cmn.pid;
#endif

  /* Mark that there is one member in the group, the main task */

  group->tg_nmembers = 1;
  return OK;
}
コード例 #13
0
static inline FAR struct usbhost_state_s *usbhost_allocclass(void)
{
  FAR struct usbhost_state_s *priv;

  DEBUGASSERT(!up_interrupt_context());
  priv = (FAR struct usbhost_state_s *)kmm_malloc(sizeof(struct usbhost_state_s));
  uvdbg("Allocated: %p\n", priv);
  return priv;
}
コード例 #14
0
ファイル: sig_dispatch.c プロジェクト: acassis/ros2_nuttx
static FAR sigpendq_t *sig_allocatependingsignal(void)
{
  FAR sigpendq_t *sigpend;
  irqstate_t      flags;

  /* Check if we were called from an interrupt handler. */

  if (up_interrupt_context())
    {
      /* Try to get the pending signal structure from the free list */

      sigpend = (FAR sigpendq_t *)sq_remfirst(&g_sigpendingsignal);
      if (!sigpend)
        {
          /* If no pending signal structure is available in the free list,
           * then try the special list of structures reserved for
           * interrupt handlers
           */

          sigpend = (FAR sigpendq_t *)sq_remfirst(&g_sigpendingirqsignal);
        }
    }

  /* If we were not called from an interrupt handler, then we are
   * free to allocate pending action structures if necessary.
   */

  else
    {
      /* Try to get the pending signal structure from the free list */

      flags = enter_critical_section();
      sigpend = (FAR sigpendq_t *)sq_remfirst(&g_sigpendingsignal);
      leave_critical_section(flags);

      /* Check if we got one. */

      if (!sigpend)
        {
          /* No... Allocate the pending signal */

          if (!sigpend)
            {
              sigpend = (FAR sigpendq_t *)kmm_malloc((sizeof (sigpendq_t)));
            }

          /* Check if we got an allocated message */

          if (sigpend)
            {
              sigpend->type = SIG_ALLOC_DYN;
            }
        }
    }

  return sigpend;
}
コード例 #15
0
ファイル: mq_sndinternal.c プロジェクト: a1ien/nuttx
FAR struct mqueue_msg_s *mq_msgalloc(void)
{
  FAR struct mqueue_msg_s *mqmsg;
  irqstate_t flags;

  /* If we were called from an interrupt handler, then try to get the message
   * from generally available list of messages. If this fails, then try the
   * list of messages reserved for interrupt handlers
   */

  if (up_interrupt_context())
    {
      /* Try the general free list */

      mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfree);
      if (mqmsg == NULL)
        {
          /* Try the free list reserved for interrupt handlers */

          mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfreeirq);
        }
    }

  /* We were not called from an interrupt handler. */

  else
    {
      /* Try to get the message from the generally available free list.
       * Disable interrupts -- we might be called from an interrupt handler.
       */

      flags = enter_critical_section();
      mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfree);
      leave_critical_section(flags);

      /* If we cannot a message from the free list, then we will have to
       * allocate one.
       */

      if (mqmsg == NULL)
        {
          mqmsg = (FAR struct mqueue_msg_s *)
            kmm_malloc((sizeof (struct mqueue_msg_s)));

          /* Check if we allocated the message */

          if (mqmsg != NULL)
            {
              /* Yes... remember that this message was dynamically allocated */

              mqmsg->type = MQ_ALLOC_DYN;
            }
        }
    }

  return mqmsg;
}
コード例 #16
0
FAR sigq_t *sig_allocatependingsigaction(void)
{
  FAR sigq_t    *sigq;
  irqstate_t saved_state;

  /* Check if we were called from an interrupt handler. */

  if (up_interrupt_context())
    {
      /* Try to get the pending signal action structure from the free list */

      sigq = (FAR sigq_t *)sq_remfirst(&g_sigpendingaction);

      /* If so, then try the special list of structures reserved for
       * interrupt handlers
       */

      if (!sigq)
        {
          sigq = (FAR sigq_t *)sq_remfirst(&g_sigpendingirqaction);
        }
    }

  /* If we were not called from an interrupt handler, then we are
   * free to allocate pending signal action structures if necessary. */

  else
    {
      /* Try to get the pending signal action structure from the free list */

      saved_state = irqsave();
      sigq = (FAR sigq_t *)sq_remfirst(&g_sigpendingaction);
      irqrestore(saved_state);

      /* Check if we got one. */

      if (!sigq)
        {
          /* No...Try the resource pool */

          if (!sigq)
            {
              sigq = (FAR sigq_t *)kmm_malloc((sizeof (sigq_t)));
            }

          /* Check if we got an allocated message */

          if (sigq)
            {
              sigq->type = SIG_ALLOC_DYN;
            }
        }
    }

  return sigq;
}
コード例 #17
0
ファイル: mtd_config.c プロジェクト: FreddieChopin/NuttX
static int mtdconfig_getconfig(FAR struct mtdconfig_struct_s *dev,
              FAR struct config_data_s *pdata)
{
  int    ret = -ENOSYS;
  off_t  offset, bytes_to_read;
  struct mtdconfig_header_s hdr;

  /* Allocate a temp block buffer */

  dev->buffer = (FAR uint8_t *)kmm_malloc(dev->blocksize);
  if (dev->buffer == NULL)
    {
      return -ENOMEM;
    }

  /* Get the offset of the first entry.  This will also check
   * the format signature bytes.
   */

  offset = mtdconfig_findfirstentry(dev, &hdr);
  offset = mtdconfig_findentry(dev, offset, pdata, &hdr);

  /* Test if the header was found. */

  if (offset > 0 && (pdata->id == hdr.id && pdata->instance == hdr.instance))
    {
      /* Entry found.  Read the data */

      bytes_to_read = hdr.len;
      if (bytes_to_read > pdata->len)
        {
          bytes_to_read = pdata->len;
        }

      /* Perform the read */

      ret = mtdconfig_readbytes(dev, offset + sizeof(hdr), pdata->configdata,
                                bytes_to_read);
      if (ret != OK)
        {
          /* Error reading the data */

          ret = -EIO;
          goto errout;
        }

      ret = OK;
    }

errout:
  /* Free the buffer */

  kmm_free(dev->buffer);
  return ret;
}
コード例 #18
0
ファイル: apb-es1.c プロジェクト: KimMui/GDMAC
int usbdev_apbinitialize(struct apbridge_usb_driver *driver)
{
    struct apbridge_alloc_s *alloc;
    struct apbridge_dev_s *priv;
    struct apbridge_driver_s *drvr;
    int ret;

    /* Allocate the structures needed */

    alloc = (struct apbridge_alloc_s *)
        kmm_malloc(sizeof(struct apbridge_alloc_s));
    if (!alloc) {
        usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCDEVSTRUCT), 0);
        return -ENOMEM;
    }

    /* Convenience pointers into the allocated blob */

    priv = &alloc->dev;
    drvr = &alloc->drvr;

    /* Initialize the USB driver structure */

    memset(priv, 0, sizeof(struct apbridge_dev_s));
    priv->driver = driver;

    /* Initialize the USB class driver structure */

    drvr->drvr.speed = USB_SPEED_HIGH;
    drvr->drvr.ops = &g_driverops;
    drvr->dev = priv;

    /* Register the USB serial class driver */

    ret = usbdev_register(&drvr->drvr);
    if (ret) {
        usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_DEVREGISTER),
                 (uint16_t) - ret);
        goto errout_with_alloc;
    }
    ret = priv->driver->init(priv);
    if (ret)
        goto errout_with_init;

    /* Register the single port supported by this implementation */
    return OK;

 errout_with_init:
    usbdev_unregister(&drvr->drvr);
 errout_with_alloc:
    kmm_free(alloc);
    return ret;
}
コード例 #19
0
ファイル: fs_foreachinode.c プロジェクト: KimMui/i2sTest
int foreach_inode(foreach_inode_t handler, FAR void *arg)
{
#ifdef ENUM_INODE_ALLOC
  FAR struct inode_path_s *info;
  int ret;

  /* Allocate the mountpoint info structure */

  info = (FAR struct inode_path_s *)kmm_malloc(sizeof(struct inode_path_s));
  if (!info)
    {
      return -ENOMEM;
    }

  /* Initialize the info structure */

  info->handler = handler;
  info->arg     = arg;
  info->path[0] = '\0';

  /* Start the recursion at the root inode */

  inode_semtake();
  ret = foreach_inodelevel(root_inode, info);
  inode_semgive();

  /* Free the info structure and return the result */

  kmm_free(info);
  return ret;

#else
  struct inode_path_s info;
  int ret;

  /* Initialize the info structure */

  info.handler = handler;
  info.arg     = arg;
  info.path[0] = '\0';

  /* Start the recursion at the root inode */

  inode_semtake();
  ret = foreach_inodelevel(root_inode, &info);
  inode_semgive();

  return ret;

#endif
}
コード例 #20
0
FAR struct mqueue_msg_s *mq_msgalloc(void)
{
  FAR struct mqueue_msg_s *mqmsg;
  irqstate_t saved_state;

  /* If we were called from an interrupt handler, then try to get the message
   * from generally available list of messages. If this fails, then try the
   * list of messages reserved for interrupt handlers
   */

  if (up_interrupt_context())
    {
      /* Try the general free list */

      mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfree);
      if (!mqmsg)
        {
          /* Try the free list reserved for interrupt handlers */

          mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfreeirq);
        }
    }

  /* We were not called from an interrupt handler. */

  else
    {
      /* Try to get the message from the generally available free list.
       * Disable interrupts -- we might be called from an interrupt handler.
       */

      saved_state = irqsave();
      mqmsg = (FAR struct mqueue_msg_s *)sq_remfirst(&g_msgfree);
      irqrestore(saved_state);

      /* If we cannot a message from the free list, then we will have to allocate one. */

      if (!mqmsg)
        {
          mqmsg = (FAR struct mqueue_msg_s *)kmm_malloc((sizeof (struct mqueue_msg_s)));

          /* Check if we got an allocated message */

          ASSERT(mqmsg);
          mqmsg->type = MQ_ALLOC_DYN;
        }
    }

  return mqmsg;
}
コード例 #21
0
ファイル: ramdisk.c プロジェクト: FreddieChopin/NuttX
int romdisk_register(int minor, uint8_t *buffer, uint32_t nsectors,
                     uint16_t sectsize)
#endif
{
  struct rd_struct_s *dev;
  char devname[16];
  int ret = -ENOMEM;

  fvdbg("buffer: %p nsectors: %d sectsize: %d\n", buffer, nsectors, sectsize);

  /* Sanity check */

#ifdef CONFIG_DEBUG
  if (minor < 0 || minor > 255 || !buffer || !nsectors || !sectsize)
    {
      return -EINVAL;
    }
#endif

  /* Allocate a ramdisk device structure */

  dev = (struct rd_struct_s *)kmm_malloc(sizeof(struct rd_struct_s));
  if (dev)
    {
      /* Initialize the ramdisk device structure */

      dev->rd_nsectors     = nsectors;     /* Number of sectors on device */
      dev->rd_sectsize     = sectsize;     /* The size of one sector */
#ifdef CONFIG_FS_WRITABLE
      dev->rd_writeenabled = writeenabled; /* true: can write to ram disk */
#endif
      dev->rd_buffer       = buffer;       /* RAM disk backup memory */

      /* Create a ramdisk device name */

      snprintf(devname, 16, "/dev/ram%d", minor);

      /* Inode private data is a reference to the ramdisk device structure */

      ret = register_blockdriver(devname, &g_bops, 0, dev);
      if (ret < 0)
        {
          fdbg("register_blockdriver failed: %d\n", -ret);
          kmm_free(dev);
        }
    }

  return ret;
}
コード例 #22
0
ファイル: timer_create.c プロジェクト: bherrera/NuttX
static struct posix_timer_s *timer_allocate(void)
{
  FAR struct posix_timer_s *ret;
  irqstate_t flags;
  uint8_t pt_flags;

  /* Try to get a preallocated timer from the free list */

#if CONFIG_PREALLOC_TIMERS > 0
  flags = irqsave();
  ret   = (FAR struct posix_timer_s *)sq_remfirst((FAR sq_queue_t *)&g_freetimers);
  irqrestore(flags);

  /* Did we get one? */

  if (ret)
    {
      pt_flags = PT_FLAGS_PREALLOCATED;
    }
  else
#endif
    {
      /* Allocate a new timer from the heap */

      ret      = (FAR struct posix_timer_s *)kmm_malloc(sizeof(struct posix_timer_s));
      pt_flags = 0;
    }

  /* If we have a timer, then put it into the allocated timer list */

  if (ret)
    {
      /* Initialize the timer structure */

      memset(ret, 0, sizeof(struct posix_timer_s));
      ret->pt_flags = pt_flags;

      /* And add it to the end of the list of allocated timers */

      flags = irqsave();
      sq_addlast((FAR sq_entry_t *)ret, (FAR sq_queue_t *)&g_alloctimers);
      irqrestore(flags);
    }

  return ret;
}
コード例 #23
0
ファイル: mod_sections.c プロジェクト: a1ien/nuttx
int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo)
{
  size_t shdrsize;
  int ret;

  DEBUGASSERT(loadinfo->shdr == NULL);

  /* Verify that there are sections */

  if (loadinfo->ehdr.e_shnum < 1)
    {
      serr("ERROR: No sections(?)\n");
      return -EINVAL;
    }

  /* Get the total size of the section header table */

  shdrsize = (size_t)loadinfo->ehdr.e_shentsize * (size_t)loadinfo->ehdr.e_shnum;
  if (loadinfo->ehdr.e_shoff + shdrsize > loadinfo->filelen)
    {
      serr("ERROR: Insufficent space in file for section header table\n");
      return -ESPIPE;
    }

  /* Allocate memory to hold a working copy of the sector header table */

  loadinfo->shdr = (FAR FAR Elf32_Shdr *)kmm_malloc(shdrsize);
  if (!loadinfo->shdr)
    {
      serr("ERROR: Failed to allocate the section header table. Size: %ld\n",
           (long)shdrsize);
      return -ENOMEM;
    }

  /* Read the section header table into memory */

  ret = mod_read(loadinfo, (FAR uint8_t *)loadinfo->shdr, shdrsize,
                    loadinfo->ehdr.e_shoff);
  if (ret < 0)
    {
      serr("ERROR: Failed to read section header table: %d\n", ret);
    }

  return ret;
}
コード例 #24
0
ファイル: pipe_common.c プロジェクト: nodesign/nuttx-kernel
FAR struct pipe_dev_s *pipecommon_allocdev(void)
{
 struct pipe_dev_s *dev;

  /* Allocate a private structure to manage the pipe */

  dev = (struct pipe_dev_s *)kmm_malloc(sizeof(struct pipe_dev_s));
  if (dev)
    {
      /* Initialize the private structure */

      memset(dev, 0, sizeof(struct pipe_dev_s));
      sem_init(&dev->d_bfsem, 0, 1);
      sem_init(&dev->d_rdsem, 0, 0);
      sem_init(&dev->d_wrsem, 0, 0);
    }

  return dev;
}
コード例 #25
0
int usbmsc_archinitialize(void)
{
  uint8_t *pbuffer;
  int ret;

  pbuffer = (uint8_t *)kmm_malloc(BUFFER_SIZE);
  if (!pbuffer)
    {
      lowsyslog(LOG_ERR, "ERROR: Failed to allocate ramdisk of size %d\n",
                BUFFER_SIZE);
      return -ENOMEM;
    }

  /* Register a RAMDISK device to manage this RAM image */

  ret = ramdisk_register(CONFIG_SYSTEM_USBMSC_DEVMINOR1,
                         pbuffer,
                         USBMSC_NSECTORS,
                         USBMSC_SECTORSIZE,
                         RDFLAG_WRENABLED | RDFLAG_FUNLINK);
  if (ret < 0)
    {
      syslog(LOG_ERR,
             "ERROR: create_ramdisk: Failed to register ramdisk at %s: %d\n",
             g_source, -ret);
      kmm_free(pbuffer);
      return ret;
    }

  /* Create a FAT filesystem on the ramdisk */

  ret = mkfatfs(g_source, &g_fmt);
  if (ret < 0)
    {
      syslog(LOG_ERR,
             "ERROR: create_ramdisk: Failed to create FAT filesystem on ramdisk at %s\n",
             g_source);
      /* kmm_free(pbuffer); -- RAM disk is registered */
      return ret;
    }

  return 0;
}
コード例 #26
0
int elf_allocbuffer(FAR struct elf_loadinfo_s *loadinfo)
{
  /* Has a buffer been allocated> */

  if (!loadinfo->iobuffer)
    {
      /* No.. allocate one now */

      loadinfo->iobuffer = (FAR uint8_t *)kmm_malloc(CONFIG_ELF_BUFFERSIZE);
      if (!loadinfo->iobuffer)
        {
          bdbg("Failed to allocate an I/O buffer\n");
          return -ENOMEM;
        }

      loadinfo->buflen = CONFIG_ELF_BUFFERSIZE;
    }

  return OK;
}
コード例 #27
0
ファイル: mtd_config.c プロジェクト: FreddieChopin/NuttX
int mtdconfig_register(FAR struct mtd_dev_s *mtd)
{
  int ret = OK;
  struct mtdconfig_struct_s *dev;
  struct mtd_geometry_s geo;      /* Device geometry */

  dev = (struct mtdconfig_struct_s *)kmm_malloc(sizeof(struct mtdconfig_struct_s));
  if (dev)
    {
      /* Initialize the mtdconfig device structure */

      dev->mtd = mtd;
      sem_init(&dev->exclsem, 0, 1);

      /* Get the device geometry. (casting to uintptr_t first eliminates
       * complaints on some architectures where the sizeof long is different
       * from the size of a pointer).
       */

      ret = MTD_IOCTL(mtd, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&geo));
      if (ret < 0)
        {
          fdbg("MTD ioctl(MTDIOC_GEOMETRY) failed: %d\n", ret);
          kmm_free(dev);
          goto errout;
        }

      dev->blocksize = geo.blocksize;
      dev->neraseblocks = geo.neraseblocks;
      dev->erasesize = geo.erasesize;
      dev->nblocks = geo.neraseblocks * geo.erasesize / geo.blocksize;

      (void)register_driver("/dev/config", &mtdconfig_fops, 0666, dev);
    }

errout:
  return ret;
}
コード例 #28
0
ファイル: lm75.c プロジェクト: justdoitding/Nuttx_PSoC4
int lm75_register(FAR const char *devpath, FAR struct i2c_dev_s *i2c, uint8_t addr)
{
  FAR struct lm75_dev_s *priv;
  int ret;

  /* Sanity check */

  DEBUGASSERT(i2c != NULL);
  DEBUGASSERT(addr == CONFIG_LM75_ADDR0 || addr == CONFIG_LM75_ADDR1 ||
              addr == CONFIG_LM75_ADDR2 || addr == CONFIG_LM75_ADDR3 ||
              addr == CONFIG_LM75_ADDR4 || addr == CONFIG_LM75_ADDR5 ||
              addr == CONFIG_LM75_ADDR6 || addr == CONFIG_LM75_ADDR7);

  /* Initialize the LM-75 device structure */

  priv = (FAR struct lm75_dev_s *)kmm_malloc(sizeof(struct lm75_dev_s));
  if (priv == NULL)
    {
      sndbg("Failed to allocate instance\n");
      return -ENOMEM;
    }

  priv->i2c        = i2c;
  priv->addr       = addr;
  priv->fahrenheit = false;

  /* Register the character driver */

  ret = register_driver(devpath, &g_lm75fops, 0666, priv);
  if (ret < 0)
    {
      sndbg("Failed to register driver: %d\n", ret);
      kmm_free(priv);
    }

  return ret;
}
コード例 #29
0
ファイル: nuttx.c プロジェクト: acassis/ros2_nuttx
int up_create_stack(struct tcb_s *tcb, size_t stack_size, uint8_t ttype)
{
    uint32_t *stack_alloc_ptr;
    int ret = ERROR;
    size_t *adj_stack_ptr;

    /* Move up to next even word boundary if necessary */

    size_t adj_stack_size = (stack_size + 3) & ~3;
    size_t adj_stack_words = adj_stack_size >> 2;

    /* Allocate the memory for the stack */

#if defined(CONFIG_BUILD_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
    /* Use the kernel allocator if this is a kernel thread */

    if (ttype == TCB_FLAG_TTYPE_KERNEL) {
        stack_alloc_ptr = (uint32_t *)kmm_malloc(stack_size);
    } else
#endif
    {
        stack_alloc_ptr = (uint32_t*)kumm_malloc(adj_stack_size);
    }
    if (stack_alloc_ptr) {
        /* This is the address of the last word in the allocation */

        adj_stack_ptr = &stack_alloc_ptr[adj_stack_words - 1];

        /* Save the values in the TCB */

        tcb->adj_stack_size  = adj_stack_size;
        tcb->stack_alloc_ptr = stack_alloc_ptr;
        tcb->adj_stack_ptr   = (void *)((unsigned int)adj_stack_ptr & ~7);
        ret = OK;
    }
    return ret;
}
コード例 #30
0
ファイル: pca9635pw.c プロジェクト: justdoitding/Nuttx_PSoC4
int pca9635pw_register(FAR const char *devpath, FAR struct i2c_dev_s *i2c,
                       uint8_t const pca9635pw_i2c_addr)
{
  /* Sanity check */

  DEBUGASSERT(i2c != NULL);

  /* Initialize the PCA9635PW device structure */

  FAR struct pca9635pw_dev_s *priv =
    (FAR struct pca9635pw_dev_s *)kmm_malloc(sizeof(struct pca9635pw_dev_s));

  if (priv == NULL)
    {
      dbg("Failed to allocate instance of pca9635pw_dev_s\n");
      return -ENOMEM;
    }

  priv->i2c = i2c;
  priv->i2c_addr = pca9635pw_i2c_addr;

  /* Register the character driver */

  int const ret = register_driver(devpath, &g_pca9635pw_fileops, 666, priv);
  if (ret != OK)
    {
      dbg("Failed to register driver: %d\n", ret);
      kmm_free(priv);
      return ret;
    }

  /* setup i2c frequency */

  I2C_SETFREQUENCY(priv->i2c, I2C_BUS_FREQ_HZ);

  return OK;
}