static int dvfs_open(FAR struct file *filep, FAR const char *relpath, int oflags, mode_t mode) { FAR struct dvfs_file_s *priv; finfo("Open '%s'\n", relpath); /* "dvfs" is the only acceptable value for the relpath */ if (strcmp(relpath, "dvfs") != 0) { ferr("ERROR: relpath is '%s'\n", relpath); return -ENOENT; } /* Allocate a container to hold the task and attribute selection */ priv = (FAR struct dvfs_file_s *)kmm_zalloc(sizeof(struct dvfs_file_s)); if (!priv) { ferr("ERROR: Failed to allocate file attributes\n"); return -ENOMEM; } /* Save the index as the open-specific state in filep->f_priv */ filep->f_priv = (FAR void *)priv; return OK; }
int sig_notification(pid_t pid, FAR struct sigevent *event) { FAR struct sig_notify_s *notify; DEBUGASSERT(event != NULL && event->sigev_notify_function != NULL); int ret; /* Allocate a structure to hold the notification information */ notify = kmm_zalloc(sizeof(struct sig_notify_s)); if (notify == NULL) { return -ENOMEM; } /* Initialize the notification information */ #ifdef CONFIG_CAN_PASS_STRUCTS notify->nt_value = event->sigev_value; #else notify->nt_value.sival_ptr = event->sigev_value.sival_ptr; #endif notify->nt_func = event->sigev_notify_function; /* Then queue the work */ ret = work_queue(NTWORK, ¬ify->nt_work, sig_ntworker, notify, 0); if (ret < 0) { kmm_free(notify); } return ret; }
static int skel_opendir(FAR const char *relpath, FAR struct fs_dirent_s *dir) { FAR struct skel_level1_s *level1; fvdbg("relpath: \"%s\"\n", relpath ? relpath : "NULL"); DEBUGASSERT(relpath && dir && !dir->u.procfs); /* The path refers to the 1st level sbdirectory. Allocate the level1 * dirent structure. */ level1 = (FAR struct skel_level1_s *) kmm_zalloc(sizeof(struct skel_level1_s)); if (!level1) { fdbg("ERROR: Failed to allocate the level1 directory structure\n"); return -ENOMEM; } /* TODO: Initialze context specific data */ /* Initialze base structure components */ level1->base.level = 1; level1->base.nentries = 0; level1->base.index = 0; dir->u.procfs = (FAR void *) level1; return OK; }
static int djoy_open(FAR struct file *filep) { FAR struct inode *inode; FAR struct djoy_upperhalf_s *priv; FAR const struct djoy_lowerhalf_s *lower; FAR struct djoy_open_s *opriv; #ifndef CONFIG_DISABLE_POLL djoy_buttonset_t supported; #endif int ret; DEBUGASSERT(filep && filep->f_inode); inode = filep->f_inode; DEBUGASSERT(inode->i_private); priv = (FAR struct djoy_upperhalf_s *)inode->i_private; /* Get exclusive access to the driver structure */ ret = djoy_takesem(&priv->du_exclsem); if (ret < 0) { ierr("ERROR: djoy_takesem failed: %d\n", ret); return ret; } /* Allocate a new open structure */ opriv = (FAR struct djoy_open_s *)kmm_zalloc(sizeof(struct djoy_open_s)); if (!opriv) { ierr("ERROR: Failled to allocate open structure\n"); ret = -ENOMEM; goto errout_with_sem; } /* Initialize the open structure */ #ifndef CONFIG_DISABLE_POLL lower = priv->du_lower; DEBUGASSERT(lower && lower->dl_supported); supported = lower->dl_supported(lower); opriv->do_pollevents.dp_press = supported; opriv->do_pollevents.dp_release = supported; #endif /* Attach the open structure to the device */ opriv->do_flink = priv->du_open; priv->du_open = opriv; /* Attach the open structure to the file structure */ filep->f_priv = (FAR void *)opriv; ret = OK; errout_with_sem: djoy_givesem(&priv->du_exclsem); return ret; }
int ramlog_register(FAR const char *devpath, FAR char *buffer, size_t buflen) { FAR struct ramlog_dev_s *priv; int ret = -ENOMEM; /* Sanity checking */ DEBUGASSERT(devpath && buffer && buflen > 1); /* Allocate a RAM logging device structure */ priv = (struct ramlog_dev_s *)kmm_zalloc(sizeof(struct ramlog_dev_s)); if (priv) { /* Initialize the non-zero values in the RAM logging device structure */ sem_init(&priv->rl_exclsem, 0, 1); #ifndef CONFIG_RAMLOG_NONBLOCKING sem_init(&priv->rl_waitsem, 0, 0); #endif priv->rl_bufsize = buflen; priv->rl_buffer = buffer; /* Register the character driver */ ret = register_driver(devpath, &g_ramlogfops, 0666, priv); if (ret < 0) { kmm_free(priv); } } return ret; }
int svc_send_event(enum svc_event event, void *parameter0, void *parameter1, void *parameter2) { llvdbg("event: %s (%d), %p %p %p\n", svc_event_to_string(event), event, parameter0, parameter1, parameter2); struct svc_work *svc_work = (struct svc_work *)kmm_zalloc(sizeof(*svc_work)); if (!svc_work) { lldbg("ERROR: failed to alloc work: errno=%d\n", get_errno()); return -1; } svc_work->svc = &g_svc; svc_work->event = event; svc_work->parameter0 = parameter0; svc_work->parameter1 = parameter1; svc_work->parameter2 = parameter2; int ret = work_queue(HPWORK, &svc_work->work, svc_work_callback, svc_work, 0 /* delay */); if (ret) { lldbg("ERROR: failed to queue work: errno=%d\n", get_errno()); return ret; } return ret; }
static int ccm_dup(FAR const struct file *oldp, FAR struct file *newp) { FAR struct ccm_file_s *oldpriv; FAR struct ccm_file_s *newpriv; fvdbg("Dup %p->%p\n", oldp, newp); /* Recover our private data from the old struct file instance */ oldpriv = (FAR struct ccm_file_s *)oldp->f_priv; DEBUGASSERT(oldpriv); /* Allocate a new container to hold the task and attribute selection */ newpriv = (FAR struct ccm_file_s *)kmm_zalloc(sizeof(struct ccm_file_s)); if (!newpriv) { fdbg("ERROR: Failed to allocate file attributes\n"); return -ENOMEM; } /* The copy the file attributes from the old attributes to the new */ memcpy(newpriv, oldpriv, sizeof(struct ccm_file_s)); /* Save the new attributes in the new file structure */ newp->f_priv = (FAR void *)newpriv; return OK; }
int pwm_register(FAR const char *path, FAR struct pwm_lowerhalf_s *dev) { FAR struct pwm_upperhalf_s *upper; /* Allocate the upper-half data structure */ upper = (FAR struct pwm_upperhalf_s *)kmm_zalloc(sizeof(struct pwm_upperhalf_s)); if (!upper) { pwmdbg("Allocation failed\n"); return -ENOMEM; } /* Initialize the PWM device structure (it was already zeroed by kmm_zalloc()) */ sem_init(&upper->exclsem, 0, 1); #ifdef CONFIG_PWM_PULSECOUNT sem_init(&upper->waitsem, 0, 0); #endif upper->dev = dev; /* Register the PWM device */ pwmvdbg("Registering %s\n", path); return register_driver(path, &g_pwmops, 0666, upper); }
int pwm_register(FAR const char *path, FAR struct pwm_lowerhalf_s *dev) { FAR struct pwm_upperhalf_s *upper; /* Allocate the upper-half data structure */ upper = (FAR struct pwm_upperhalf_s *)kmm_zalloc(sizeof(struct pwm_upperhalf_s)); if (!upper) { pwmerr("Allocation failed\n"); return -ENOMEM; } /* Initialize the PWM device structure (it was already zeroed by kmm_zalloc()) */ sem_init(&upper->exclsem, 0, 1); #ifdef CONFIG_PWM_PULSECOUNT sem_init(&upper->waitsem, 0, 0); /* The wait semaphore is used for signaling and, hence, should not have priority * inheritance enabled. */ sem_setprotocol(&upper->waitsem, SEM_PRIO_NONE); #endif upper->dev = dev; /* Register the PWM device */ pwminfo("Registering %s\n", path); return register_driver(path, &g_pwmops, 0666, upper); }
static int skel_open(FAR struct file *filep, FAR const char *relpath, int oflags, mode_t mode) { FAR struct skel_file_s *priv; fvdbg("Open '%s'\n", relpath); /* PROCFS is read-only. Any attempt to open with any kind of write * access is not permitted. * * REVISIT: Write-able proc files could be quite useful. */ if (((oflags & O_WRONLY) != 0 || (oflags & O_RDONLY) == 0) && (skel_procfsoperations.write == NULL)) { fdbg("ERROR: Only O_RDONLY supported\n"); return -EACCES; } /* Allocate a container to hold the task and attribute selection */ priv = (FAR struct skel_file_s *)kmm_zalloc(sizeof(struct skel_file_s)); if (!priv) { fdbg("ERROR: Failed to allocate file attributes\n"); return -ENOMEM; } /* TODO: Initialize the context specific data here */ /* Save the index as the open-specific state in filep->f_priv */ filep->f_priv = (FAR void *)priv; return OK; }
static int mtd_open(FAR struct file *filep, FAR const char *relpath, int oflags, mode_t mode) { FAR struct mtd_file_s *attr; fvdbg("Open '%s'\n", relpath); /* PROCFS is read-only. Any attempt to open with any kind of write * access is not permitted. * * REVISIT: Write-able proc files could be quite useful. */ if ((oflags & O_WRONLY) != 0 || (oflags & O_RDONLY) == 0) { fdbg("ERROR: Only O_RDONLY supported\n"); return -EACCES; } /* Allocate a context structure */ attr = (FAR struct mtd_file_s *)kmm_zalloc(sizeof(struct mtd_file_s)); if (!attr) { fdbg("ERROR: Failed to allocate file attributes\n"); return -ENOMEM; } attr->pnextmtd = g_pfirstmtd; /* Save the context as the open-specific state in filep->f_priv */ filep->f_priv = (FAR void *)attr; return OK; }
FAR struct local_conn_s *local_alloc(void) { FAR struct local_conn_s *conn = (FAR struct local_conn_s *)kmm_zalloc(sizeof(struct local_conn_s)); if (conn) { /* Initialize non-zero elements the new connection structure */ conn->lc_infd = -1; conn->lc_outfd = -1; #ifdef CONFIG_NET_LOCAL_STREAM /* This semaphore is used for signaling and, hence, should not have * priority inheritance enabled. */ sem_init(&conn->lc_waitsem, 0, 0); sem_setprotocol(&conn->lc_waitsem, SEM_PRIO_NONE); #ifdef HAVE_LOCAL_POLL memset(conn->lc_accept_fds, 0, sizeof(conn->lc_accept_fds)); #endif #endif } return conn; }
FAR struct battery_charger_dev_s *bq2425x_initialize(FAR struct i2c_dev_s *i2c, uint8_t addr, uint32_t frequency) { FAR struct bq2425x_dev_s *priv; int ret; /* Initialize the BQ2425x device structure */ priv = (FAR struct bq2425x_dev_s *)kmm_zalloc(sizeof(struct bq2425x_dev_s)); if (priv) { /* Initialize the BQ2425x device structure */ sem_init(&priv->batsem, 0, 1); priv->ops = &g_bq2425xops; priv->i2c = i2c; priv->addr = addr; priv->frequency = frequency; /* Set the I2C frequency (ignoring the returned, actual frequency) */ (void)I2C_SETFREQUENCY(i2c, priv->frequency); /* Reset the BQ2425x */ ret = bq2425x_reset(priv); if (ret < 0) { batdbg("Failed to reset the BQ2425x: %d\n", ret); kmm_free(priv); return NULL; } /* Disable watchdog otherwise BQ2425x returns to StandAlone mode */ ret = bq2425x_watchdog(priv, false); if (ret < 0) { batdbg("Failed to disable BQ2425x watchdog: %d\n", ret); kmm_free(priv); return NULL; } /* Define that our power supply can offer 2000mA to the charger */ ret = bq2425x_powersupply(priv, 2000); if (ret < 0) { batdbg("Failed to set BQ2425x power supply current: %d\n", ret); kmm_free(priv); return NULL; } } return (FAR struct battery_charger_dev_s *)priv; }
FAR void *watchdog_register(FAR const char *path, FAR struct watchdog_lowerhalf_s *lower) { FAR struct watchdog_upperhalf_s *upper; int ret; DEBUGASSERT(path && lower); wdvdbg("Entry: path=%s\n", path); /* Allocate the upper-half data structure */ upper = (FAR struct watchdog_upperhalf_s *) kmm_zalloc(sizeof(struct watchdog_upperhalf_s)); if (!upper) { wddbg("Upper half allocation failed\n"); goto errout; } /* Initialize the watchdog timer device structure (it was already zeroed * by kmm_zalloc()). */ sem_init(&upper->exclsem, 0, 1); upper->lower = lower; /* Copy the registration path */ upper->path = strdup(path); if (!upper->path) { wddbg("Path allocation failed\n"); goto errout_with_upper; } /* Register the watchdog timer device */ ret = register_driver(path, &g_wdogops, 0666, upper); if (ret < 0) { wddbg("register_driver failed: %d\n", ret); goto errout_with_path; } return (FAR void *)upper; errout_with_path: kmm_free(upper->path); errout_with_upper: sem_destroy(&upper->exclsem); kmm_free(upper); errout: return NULL; }
static inline FAR struct gran_s * gran_common_initialize(FAR void *heapstart, size_t heapsize, uint8_t log2gran, uint8_t log2align) { FAR struct gran_s *priv; uintptr_t heapend; uintptr_t alignedstart; unsigned int mask; unsigned int alignedsize; unsigned int ngranules; /* Check parameters if debug is on. Note the size of a granule is * limited to 2**31 bytes and that the size of the granule must be greater * than or equal to the alignment size. */ DEBUGASSERT(heapstart && heapsize > 0 && log2gran > 0 && log2gran < 32 && log2gran >= log2align); /* Get the aligned start of the heap */ mask = (1 << log2align) - 1; alignedstart = ((uintptr_t)heapstart + mask) & ~mask; /* Determine the number of granules */ mask = (1 << log2gran) - 1; heapend = (uintptr_t)heapstart + heapsize; alignedsize = (heapend - alignedstart) & ~mask; ngranules = alignedsize >> log2gran; /* Allocate the information structure with a granule table of the * correct size. */ priv = (FAR struct gran_s *)kmm_zalloc(SIZEOF_GRAN_S(ngranules)); if (priv) { /* Initialize non-zero elements of the granules heap info structure */ priv->log2gran = log2gran; priv->ngranules = ngranules; priv->heapstart = alignedstart; /* Initialize mutual exclusion support */ #ifndef CONFIG_GRAN_INTR sem_init(&priv->exclsem, 0, 1); #endif } return priv; }
int mod_load(FAR struct mod_loadinfo_s *loadinfo) { int ret; svdbg("loadinfo: %p\n", loadinfo); DEBUGASSERT(loadinfo && loadinfo->filfd >= 0); /* Load section headers into memory */ ret = mod_loadshdrs(loadinfo); if (ret < 0) { sdbg("ERROR: mod_loadshdrs failed: %d\n", ret); goto errout_with_buffers; } /* Determine total size to allocate */ mod_elfsize(loadinfo); /* Allocate (and zero) memory for the ELF file. */ /* Allocate memory to hold the ELF image */ loadinfo->textalloc = (uintptr_t)kmm_zalloc(loadinfo->textsize + loadinfo->datasize); if (!loadinfo->textalloc) { sdbg("ERROR: Failed to allocate memory for the module\n"); ret = -ENOMEM; goto errout_with_buffers; } loadinfo->datastart = loadinfo->textalloc + loadinfo->textsize; /* Load ELF section data into memory */ ret = mod_loadfile(loadinfo); if (ret < 0) { sdbg("ERROR: mod_loadfile failed: %d\n", ret); goto errout_with_buffers; } return OK; /* Error exits */ errout_with_buffers: mod_unload(loadinfo); return ret; }
int romdisk_register(int minor, FAR const uint8_t *buffer, uint32_t nsectors, uint16_t sectsize) #endif { struct rd_struct_s *dev; char devname[16]; int ret = -ENOMEM; finfo("buffer: %p nsectors: %d sectsize: %d\n", buffer, nsectors, sectsize); /* Sanity check */ #ifdef CONFIG_DEBUG_FEATURES if (minor < 0 || minor > 255 || !buffer || !nsectors || !sectsize) { return -EINVAL; } #endif /* Allocate a ramdisk device structure */ dev = (struct rd_struct_s *)kmm_zalloc(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 */ dev->rd_buffer = buffer; /* RAM disk backup memory */ #ifdef CONFIG_FS_WRITABLE dev->rd_flags = rdflags & RDFLAG_USER; #endif /* 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) { ferr("register_blockdriver failed: %d\n", -ret); kmm_free(dev); } } return ret; }
int btn_register(FAR const char *devname, FAR const struct btn_lowerhalf_s *lower) { FAR struct btn_upperhalf_s *priv; int ret; DEBUGASSERT(devname && lower); /* Allocate a new button driver instance */ priv = (FAR struct btn_upperhalf_s *) kmm_zalloc(sizeof(struct btn_upperhalf_s)); if (!priv) { ierr("ERROR: Failed to allocate device structure\n"); return -ENOMEM; } /* Make sure that all button interrupts are disabled */ DEBUGASSERT(lower->bl_enable); lower->bl_enable(lower, 0, 0, NULL, NULL); /* Initialize the new button driver instance */ priv->bu_lower = lower; nxsem_init(&priv->bu_exclsem, 0, 1); DEBUGASSERT(lower->bl_buttons); priv->bu_sample = lower->bl_buttons(lower); /* And register the button driver */ ret = register_driver(devname, &btn_fops, 0666, priv); if (ret < 0) { ierr("ERROR: register_driver failed: %d\n", ret); goto errout_with_priv; } return OK; errout_with_priv: nxsem_destroy(&priv->bu_exclsem); kmm_free(priv); return ret; }
DMA_HANDLE lc823450_dmachannel(int ch) { struct lc823450_dmach_s *dmach = NULL; /* Get exclusive access to the GPDMA state structure */ dmach = (struct lc823450_dmach_s *) kmm_zalloc(sizeof(struct lc823450_dmach_s)); if (dmach) { dmach->chn = ch; } return (DMA_HANDLE)dmach; }
static int zc_open(FAR struct file *filep) { FAR struct inode *inode; FAR struct zc_upperhalf_s *priv; FAR const struct zc_lowerhalf_s *lower; FAR struct zc_open_s *opriv; int ret; DEBUGASSERT(filep && filep->f_inode); inode = filep->f_inode; DEBUGASSERT(inode->i_private); priv = (FAR struct zc_upperhalf_s *)inode->i_private; /* Get exclusive access to the driver structure */ ret = sem_wait(&priv->exclsem); if (ret < 0) { snvdbg("ERROR: sem_wait failed: %d\n", ret); return ret; } /* Allocate a new open structure */ opriv = (FAR struct zc_open_s *)kmm_zalloc(sizeof(struct zc_open_s)); if (!opriv) { snvdbg("ERROR: Failled to allocate open structure\n"); ret = -ENOMEM; goto errout_with_sem; } /* Attach the open structure to the device */ opriv->do_flink = priv->zu_open; priv->zu_open = opriv; /* Attach the open structure to the file structure */ filep->f_priv = (FAR void *)opriv; ret = OK; errout_with_sem: sem_post(&priv->exclsem); return ret; }
int gpio_lower_half(FAR struct ioexpander_dev_s *ioe, unsigned int pin, enum gpio_pintype_e pintype, int minor) { FAR struct gplh_dev_s *priv; FAR struct gpio_dev_s *gpio; int ret; DEBUGASSERT(ioe != NULL && pin < CONFIG_IOEXPANDER_NPINS && (unsigned int)pintype < GPIO_NPINTYPES); #ifndef CONFIG_IOEXPANDER_INT_ENABLE /* If there is no I/O expander interrupt support, then we cannot handle * interrupting pin types. */ DEBUGASSERT(pintype != GPIO_INTERRUPT_PIN); #endif /* Allocate an new instance of the GPIO lower half driver */ priv = (FAR struct gplh_dev_s *)kmm_zalloc(sizeof(struct gplh_dev_s)); if (priv == NULL) { gpioerr("ERROR: Failed to allocate driver state\n"); return -ENOMEM; } /* Initialize the non-zero elements of the newly allocated instance */ priv->pin = (uint8_t)pin; priv->ioe = ioe; gpio = &priv->gpio; gpio->gp_pintype = (uint8_t)pintype; gpio->gp_ops = &g_gplh_ops; /* Register the GPIO driver */ ret = gpio_pin_register(gpio, minor); if (ret < 0) { gpioerr("ERROR: gpio_pin_register() failed: %d\n", ret); kmm_free(priv); } return ret; }
int djoy_register(FAR const char *devname, FAR const struct djoy_lowerhalf_s *lower) { FAR struct djoy_upperhalf_s *priv; int ret; DEBUGASSERT(devname && lower); /* Allocate a new djoystick driver instance */ priv = (FAR struct djoy_upperhalf_s *) kmm_zalloc(sizeof(struct djoy_upperhalf_s)); if (!priv) { ierr("ERROR: Failed to allocate device structure\n"); return -ENOMEM; } /* Make sure that all djoystick interrupts are disabled */ DEBUGASSERT(lower->dl_enable); lower->dl_enable(lower, 0, 0, NULL, NULL); /* Initialize the new djoystick driver instance */ priv->du_lower = lower; sem_init(&priv->du_exclsem, 0, 1); DEBUGASSERT(lower->dl_sample); priv->du_sample = lower->dl_sample(lower); /* And register the djoystick driver */ ret = register_driver(devname, &djoy_fops, 0666, priv); if (ret < 0) { ierr("ERROR: register_driver failed: %d\n", ret); sem_destroy(&priv->du_exclsem); kmm_free(priv); } return ret; }
int i2c_register(FAR struct i2c_master_s *i2c, int bus) { FAR struct i2c_driver_s *priv; char devname[DEVNAME_FMTLEN]; int ret; /* Sanity check */ DEBUGASSERT(i2c != NULL && (unsigned)bus < 1000); /* Allocate a I2C character device structure */ priv = (FAR struct i2c_driver_s *)kmm_zalloc(sizeof(struct i2c_driver_s)); if (priv) { /* Initialize the I2C character device structure */ priv->i2c = i2c; #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS sem_init(&priv->exclsem, 0, 1); #endif /* Create the character device name */ snprintf(devname, DEVNAME_FMTLEN, DEVNAME_FMT, bus); ret = register_driver(devname, &i2cdrvr_fops, 0666, priv); if (ret < 0) { /* Free the device structure if we failed to create the character * device. */ kmm_free(priv); } /* Return the result of the registration */ return OK; } return -ENOMEM; }
int rtc_initialize(int minor, FAR struct rtc_lowerhalf_s *lower) { FAR struct rtc_upperhalf_s *upper; char devpath[16]; int ret; DEBUGASSERT(lower && lower->ops && minor >= 0 && minor < 1000); /* Allocate an upper half container structure */ upper = (FAR struct rtc_upperhalf_s *)kmm_zalloc( sizeof(struct rtc_upperhalf_s)); if (!upper) { return -ENOMEM; } /* Initialize the upper half container */ upper->lower = lower; /* Contain lower half driver */ #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS upper->crefs = 0; /* No open references */ upper->unlinked = false; /* Driver is not unlinked */ #endif /* * Create the driver name. There is space for the a minor number * up to 6 characters */ snprintf(devpath, 16, "/dev/rtc%d", minor); /* And, finally, register the new RTC driver */ ret = register_driver(devpath, &rtc_fops, 0666, upper); if (ret < 0) { kmm_free(upper); return ret; } return OK; }
FAR void* ubxmdm_register(FAR const char *path, FAR struct ubxmdm_lower *lower) { FAR struct ubxmdm_upper *upper; int ret; DEBUGASSERT(path && lower); upper = (FAR struct ubxmdm_upper*) kmm_zalloc(sizeof(struct ubxmdm_upper)); if (!upper) { m_err("ERROR: Upper half allocation failed\n"); goto errout; } upper->lower = lower; upper->path = strdup(path); if (!upper->path) { m_err("ERROR: Path allocation failed\n"); goto errout_with_upper; } ret = register_driver(path, &ubxmdm_fops, 0666, upper); if (ret < 0) { m_err("ERROR: register_driver failed: %d\n", ret); goto errout_with_path; } return (FAR void*) upper; errout_with_path: kmm_free(upper->path); errout_with_upper: kmm_free(upper); errout: return NULL; }
static int ccm_open(FAR struct file *filep, FAR const char *relpath, int oflags, mode_t mode) { FAR struct ccm_file_s *priv; fvdbg("Open '%s'\n", relpath); /* PROCFS is read-only. Any attempt to open with any kind of write * access is not permitted. * * REVISIT: Write-able proc files could be quite useful. */ if ((oflags & O_WRONLY) != 0 || (oflags & O_RDONLY) == 0) { fdbg("ERROR: Only O_RDONLY supported\n"); return -EACCES; } /* "cpuload" is the only acceptable value for the relpath */ if (strcmp(relpath, "ccm") != 0) { fdbg("ERROR: relpath is '%s'\n", relpath); return -ENOENT; } /* Allocate a container to hold the task and attribute selection */ priv = (FAR struct ccm_file_s *)kmm_zalloc(sizeof(struct ccm_file_s)); if (!priv) { fdbg("ERROR: Failed to allocate file attributes\n"); return -ENOMEM; } /* Save the index as the open-specific state in filep->f_priv */ filep->f_priv = (FAR void *)priv; return OK; }
int i2schar_register(FAR struct i2s_dev_s *i2s, int minor) { FAR struct i2schar_dev_s *priv; char devname[DEVNAME_FMTLEN]; int ret; /* Sanity check */ DEBUGASSERT(i2s != NULL && (unsigned)minor < 1000); /* Allocate a I2S character device structure */ priv = (FAR struct i2schar_dev_s *)kmm_zalloc(sizeof(struct i2schar_dev_s)); if (priv) { /* Initialize the I2S character device structure */ priv->i2s = i2s; sem_init(&priv->exclsem, 0, 1); /* Create the character device name */ snprintf(devname, DEVNAME_FMTLEN, DEVNAME_FMT, minor); ret = register_driver(devname, &i2schar_fops, 0666, priv); if (ret < 0) { /* Free the device structure if we failed to create the character * device. */ kmm_free(priv); } /* Return the result of the registration */ return OK; } return -ENOMEM; }
struct scsc_mx *scsc_mx_create(struct scsc_mif_abs *mif) { struct scsc_mx *mx; mx = kmm_zalloc(sizeof(*mx)); if (!mx) { return NULL; } mx->mif_abs = mif; mifintrbit_init(&mx->intr, mif); mifmboxman_init(&mx->mbox); panicmon_init(&mx->panicmon, mx); suspendmon_init(&mx->suspendmon, mx); mxman_init(&mx->mxman, mx); srvman_init(&mx->srvman, mx); SLSI_INFO_NODEV("Hurray Maxwell is here with %p\n", mx); return mx; }
int zc_register(FAR const char *devname, FAR struct zc_lowerhalf_s *lower) { FAR struct zc_upperhalf_s *priv; int ret; DEBUGASSERT(devname && lower); /* Allocate a new zero cross driver instance */ priv = (FAR struct zc_upperhalf_s *) kmm_zalloc(sizeof(struct zc_upperhalf_s)); if (!priv) { snvdbg("ERROR: Failed to allocate device structure\n"); return -ENOMEM; } /* Make sure that zero cross interrupt is disabled */ DEBUGASSERT(lower->zc_enable); lower->zc_enable(lower, NULL, NULL); /* Initialize the new zero cross driver instance */ priv->lower = lower; sem_init(&priv->exclsem, 0, 1); /* And register the zero cross driver */ ret = register_driver(devname, &g_zcops, 0666, priv); if (ret < 0) { snvdbg("ERROR: register_driver failed: %d\n", ret); sem_destroy(&priv->exclsem); kmm_free(priv); } return ret; }
int qe_register(FAR const char *devpath, FAR struct qe_lowerhalf_s *lower) { FAR struct qe_upperhalf_s *upper; /* Allocate the upper-half data structure */ upper = (FAR struct qe_upperhalf_s *)kmm_zalloc(sizeof(struct qe_upperhalf_s)); if (!upper) { snerr("ERROR: Allocation failed\n"); return -ENOMEM; } /* Initialize the PWM device structure (it was already zeroed by kmm_zalloc()) */ sem_init(&upper->exclsem, 0, 1); upper->lower = lower; /* Register the PWM device */ sninfo("Registering %s\n", devpath); return register_driver(devpath, &g_qeops, 0666, upper); }