C++ (Cpp) param_set_uint Examples

Example #1

File: configuration.c Project: 791254467/u8500_kernel

static int param_set_osttrace_nb(const char *val, const struct kernel_param *kp)
{
	t_ee_state *state;
	int coreId, rv;
	u32 oldSize;

	for (coreId = FIRST_MPC_ID; coreId <= LAST_MPC_ID; coreId++) {
		state = cm_EEM_getExecutiveEngine(coreId);
		if (&(state->traceBufferSize) == kp->arg)
			break;
	}

	oldSize = state->traceBufferSize;
	rv = param_set_uint(val, kp);
	if (rv)
		return rv;

	if (CM_ENGINE_resizeTraceBuffer(coreId, oldSize) == CM_OK) {
		pr_info("[CM]: OST Trace buffer resizing done successfully "
			"for %s DSP\n", osalEnv.mpc[COREIDX(coreId)].name);
		return 0;
	} else {
		return -EINVAL;
	}
}

Example #2

File: tegra_camera.c Project: Austs5/enrc2b-kernel-BLADE

static int camera_boost_set(const char *arg, const struct kernel_param *kp)
{
	int ret = param_set_uint(arg, kp);
	if (ret)
		return ret;
		
    pr_info("camera_boost=%d\n", camera_boost);
	return 0;
}

Example #3

File: epoll_device.c Project: bmschwa/openonload

/*************************************************************
 * EPOLL2-specific code
 *************************************************************/
static int set_max_stacks(const char *val, struct kernel_param *kp)
{
  int rc = param_set_uint(val, kp);
  if( rc != 0 )
    return rc;

  /* do not accept 0 value: use default instead */
  if( epoll_max_stacks == 0 )
    epoll_max_stacks = CI_CFG_EPOLL_MAX_STACKS;

  return 0;
}

Example #4

File: rockchip_pm.c Project: ibazzi/rk3288-kernel

static int set_policy(const char *val, const struct kernel_param *kp)
{
	int ret;

	ret = param_set_uint(val, kp);
	if (ret < 0)
		return ret;

	rockchip_pm_set_policy(policy);
	policy = rockchip_pm_get_policy();

	return 0;
}

Example #5

File: speedfax.c Project: romanbb/android_kernel_lge_d851

static int
set_debug(const char *val, struct kernel_param *kp)
{
	int ret;
	struct sfax_hw *card;

	ret = param_set_uint(val, kp);
	if (!ret) {
		read_lock(&card_lock);
		list_for_each_entry(card, &Cards, list)
			_set_debug(card);
		read_unlock(&card_lock);
	}
	return ret;
}

Example #6

File: main.c Project: AshishNamdev/linux

static int mtu_max_set(const char *val, const struct kernel_param *kp)
{
	int ret;

	/* sets mtu_max directly. no need to restore it in case of
	 * illegal value since we assume this will fail insmod
	 */
	ret = param_set_uint(val, kp);
	if (ret)
		return ret;

	if (mtu_max < 68 || mtu_max > WIL_MAX_ETH_MTU)
		ret = -EINVAL;

	return ret;
}

Example #7

File: cpuidle.c Project: aironite/halaszk-UNIVERSAL5420

static int set_enable_mask(const char *val, const struct kernel_param *kp)
{
	int rv = param_set_uint(val, kp);
	unsigned long flags;

	if (rv)
		return rv;

	spin_lock_irqsave(&enable_mask_lock, flags);

	if (!(enable_mask & ENABLE_C2)) {
		unsigned int cpuid = smp_processor_id();
		int i;
		for_each_online_cpu(i) {
			if (i == cpuid)
				continue;
			arm_send_ping_ipi(i);
		}
	}

Example #8

File: cpuidle-exynos5433.c Project: Hani-K/H-Vitamin2_trelte

static int set_enable_mask(const char *val, const struct kernel_param *kp)
{
	int rv = param_set_uint(val, kp);
	unsigned long flags;

	pr_info("%s: val=%s, enable_maks=%d\n", __func__, val, enable_mask);

	if (rv)
		return rv;

	spin_lock_irqsave(&enable_mask_lock, flags);

	if (!(enable_mask & ENABLE_C2)) {
		unsigned int cpuid = smp_processor_id();
		int i;
		for_each_online_cpu(i) {
			if (i == cpuid)
				continue;
			arch_send_wakeup_ipi_mask(cpumask_of(i));
		}
	}

Example #9

File: cpuidle-exynos64.c Project: HRTKernel/Hybridmax_Kernel_S6

static int set_enable_mask(const char *val, const struct kernel_param *kp)
{
	int rv = param_set_uint(val, kp);
	unsigned long flags;

	pr_info("%s: enable_mask=0x%x\n", __func__, enable_mask);

	if (rv)
		return rv;

	spin_lock_irqsave(&enable_mask_lock, flags);

	if (!(enable_mask & ENABLE_C2)) {
		unsigned int cpuid = smp_processor_id();
		int i;
		for_each_online_cpu(i) {
			if (i == cpuid)
				continue;
			smp_send_reschedule(i);
		}
	}

Example #10

File: ddr-health.c Project: AudioGod/Gods_kernel_yu_msm8916

static int ddr_health_set(const char *val, struct kernel_param *kp)
{
	int	 ret;
	void	 *virt;
	uint64_t old_addr = 0;
	uint32_t old_size = 0;

	mutex_lock(&lock);
	ret = param_set_uint(val, kp);
	if (ret) {
		pr_err("ddr-health: error setting value %d\n", ret);
		mutex_unlock(&lock);
		return ret;
	}

	if (rpm_kvp.data) {
		ddr_health = (struct ddr_health *)rpm_kvp.data;
		old_addr = ddr_health->addr;
		old_size = ddr_health->size;
	}

	rpm_kvp.key = RPM_MISC_REQ_DDR_HEALTH;

	if (mem_size) {
		virt = kzalloc(mem_size, GFP_KERNEL);
		if (!virt) {
			pr_err("ddr-health: failed to alloc mem request %x\n",
			       mem_size);
			mutex_unlock(&lock);
			return -ENOMEM;
		}

		ddr_health->addr = (uint64_t)virt_to_phys(virt);
		ddr_health->size = mem_size;

		rpm_kvp.length = sizeof(struct ddr_health);
		rpm_kvp.data = (void *)ddr_health;

		ret = msm_rpm_send_message(MSM_RPM_CTX_ACTIVE_SET,
					   RPM_MISC_REQ_TYPE, 0, &rpm_kvp, 1);
		if (ret) {
			pr_err("ddr-health: send buf to RPM failed %d, %x\n",
			       ret, mem_size);
			kfree(virt);
			goto err;
		}
	} else {
		ddr_health->addr = 0;
		ddr_health->size = 0;

		rpm_kvp.length = sizeof(struct ddr_health);
		rpm_kvp.data = (void *)ddr_health;

		ret = msm_rpm_send_message(MSM_RPM_CTX_ACTIVE_SET,
					   RPM_MISC_REQ_TYPE, 0, &rpm_kvp, 1);
		if (ret) {
			pr_err("ddr-health: send nobuf to RPM failed %d, %x\n",
			       ret, mem_size);
			goto err;
		}
	}

	if (old_addr)
		kfree(phys_to_virt((phys_addr_t)old_addr));

	mutex_unlock(&lock);
	return 0;
err:
	ddr_health->addr = old_addr;
	ddr_health->size = old_size;
	mutex_unlock(&lock);
	return ret;
}