void vibtonz_pwm(int nForce)
{
	static int prev_duty=0;
	t_vib_desc *vib_iter =&vib_desc;
	int pwm_period=0, pwm_duty = 0;

	printk("%s : %d \n", __func__, nForce);
	if( vib_iter->initialized == 0) return;

	pwm_period = vib_iter->pwm_period;
	pwm_duty = pwm_period/2 + ((pwm_period/2 - 2) *nForce) /127;

	if(pwm_duty > vib_iter->pwm_duty)
	{
		pwm_duty = vib_iter->pwm_duty;
	}
	else if(pwm_period - pwm_duty > vib_iter->pwm_duty)
	{
		pwm_duty = pwm_period - vib_iter->pwm_duty;
	}
	
	pwm_set_period_ns(vib_iter->pwm,vib_iter->pwm_period); 	
	pwm_set_polarity(vib_iter->pwm, vib_iter->pwm_polarity);
	pwm_set_duty_ns(vib_iter->pwm, pwm_duty); 
}
static PyObject *py_set_polarity(PyObject *self, PyObject *args, PyObject *kwargs){
    char key[8];
    char *channel;
    int polarity = 0;
    static char *kwlist[] = {"channel", "polarity", NULL};

    if(!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i", kwlist, &channel, &polarity))
        return NULL;

    if (polarity != 0 && polarity != 1)
    {
        PyErr_SetString(PyExc_ValueError, "polarity must be either 0 or 1");
        return NULL;
    } 

    if (!get_pwm_key(channel, key)) {
        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
        return NULL;    
    }

    if (pwm_set_polarity(key, polarity) == -1) {
        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
        return NULL;
    }

    Py_RETURN_NONE;

}
示例#3
0
static int __devinit pwm_ir_tx_probe(struct pwm_ir_dev *dev)
{
    struct pwm_ir_data *data = dev->pdev->dev.platform_data;
    int rc = 0;

    if (data->reg_id) {
        dev->reg = regulator_get(&dev->pdev->dev, data->reg_id);
        if (IS_ERR(dev->reg)) {
            dev_err(&dev->pdev->dev,
                    "failed to regulator_get(%s)\n",
                    data->reg_id);
            return PTR_ERR(dev->reg);
        }
    }

    dev->pwm = pwm_request(data->pwm_id, PWM_IR_NAME);
    if (IS_ERR(dev->pwm)) {
        dev_err(&dev->pdev->dev,
                "failed to pwm_request(%d)\n",
                data->pwm_id);
        rc = PTR_ERR(dev->pwm);
        goto err_regulator_put;
    }

    if (data->low_active) {
#if 0 /* need the latest kernel */
        rc = pwm_set_polarity(dev->pwm, PWM_POLARITY_INVERSED);
#else
        rc = -ENOSYS;
#endif
        if (rc != 0) {
            dev_err(&dev->pdev->dev, "failed to change polarity\n");
            goto err_pwm_free;
        }
    }

    rc = pwm_ir_tx_config(dev, 38000, 50);
    if (rc != 0) {
        dev_err(&dev->pdev->dev, "failed to change carrier and duty\n");
        goto err_pwm_free;
    }

    dev->rdev->tx_ir           = pwm_ir_tx_transmit;
    dev->rdev->s_tx_carrier    = pwm_ir_tx_carrier;
    dev->rdev->s_tx_duty_cycle = pwm_ir_tx_duty_cycle;

    return rc;

err_pwm_free:
    pwm_free(dev->pwm);
err_regulator_put:
    if (dev->reg)
        regulator_put(dev->reg);
    return rc;
}
示例#4
0
void servo_init()
{
    int i;
    for(i=0;i<sizeof(servo_pin)/sizeof(servo_pin[0]);i++)
    {
        pwm_stop(servo_pin[i][0], servo_pin[i][1]);
        pwm_set_period(servo_pin[i][0], servo_pin[i][1], SERVO_STD_PERIOD);
        pwm_set_polarity(servo_pin[i][0], servo_pin[i][1], 1);
        pwm_set_duty_cycle(servo_pin[i][0], servo_pin[i][1], SERVO_ANGLE_TO_DUTY(0));  /* keep in the middle */
    }
    start_servo();
}
示例#5
0
int OSAL_Pwm_Set_Polarity(__hdle p_handler, int polarity)
{
	int ret = 0;
	struct pwm_device *pwm_dev;

	pwm_dev = (struct pwm_device *)p_handler;
	if(NULL == pwm_dev || IS_ERR(pwm_dev)) {
		__wrn("OSAL_Pwm_Set_Polarity, handle is NULL!\n");
		ret = -1;
	} else {
		ret = pwm_set_polarity(pwm_dev, polarity);
		__inf("OSAL_Pwm_Set_Polarity pwm %d, active %s\n", pwm_dev->pwm, (polarity==0)? "high":"low");
	}

	return ret;
}
示例#6
0
static ssize_t pwm_polarity_store(struct device *dev,
                                  struct device_attribute *attr,
                                  const char *buf, size_t len)
{
    unsigned long polarity;
    struct pwm_device *p = dev_get_drvdata(dev);
    int ret;

    if (!kstrtoul(buf, 10, &polarity)) {
        ret = pwm_set_polarity(p, polarity);

        if (ret < 0)
            return ret;
    }

    return len;
}
示例#7
0
static ssize_t pwm_test_store_polarity(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int rc;
	struct pwm_test *pwm_test = dev_get_drvdata(dev);

	rc = kstrtoul(buf, 0, &pwm_test->polarity_s);
	if (rc)
		return rc;

	rc = pwm_set_polarity(pwm_test->pwm, pwm_test->polarity_s);
	if (rc) {
		pr_err("operation failed %d\n", rc);
		return rc;
	}

	pwm_test->polarity = pwm_test->polarity_s;
	return count;
}
static ssize_t pwm_test_store_polarity(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int rc;
	struct pwm_test *pwm_test = dev_get_drvdata(dev);
	int val;
	enum pwm_polarity polarity;

	rc = kstrtoint(buf, 0, &val);
	if (rc)
		return rc;

	/* only zero and one allowed */
	if (val != 0 && val != 1)
		return -EINVAL;

	polarity = val ? PWM_POLARITY_INVERSED : PWM_POLARITY_NORMAL;

	/* same? don't do anything */
	if (polarity == pwm_test->polarity)
		return count;

	/* polarity can only change when we stop the pwm */
	if (pwm_test->run)
		pwm_disable(pwm_test->pwm);

	rc = pwm_set_polarity(pwm_test->pwm, polarity);
	if (rc) {
		dev_err(dev, "pwm_set_polarity failed\n");
		if (pwm_test->run)
			pwm_enable(pwm_test->pwm);
		return rc;
	}

	if (pwm_test->run)
		pwm_enable(pwm_test->pwm);

	pwm_test->polarity = polarity;

	return count;
}
示例#9
0
static int pwm_backlight_probe(struct platform_device *pdev)
{
	struct backlight_properties props;
	struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
	struct backlight_device *bl;
	struct pwm_bl_data *pb;
	int ret;

	if (!data) {
		dev_err(&pdev->dev, "failed to find platform data\n");
		return -EINVAL;
	}

	if (data->init) {
		ret = data->init(&pdev->dev);
		if (ret < 0)
			return ret;
	}

	pb = kzalloc(sizeof(*pb), GFP_KERNEL);
	if (!pb) {
		dev_err(&pdev->dev, "no memory for state\n");
		ret = -ENOMEM;
		goto err_alloc;
	}

	pb->period = data->pwm_period_ns;
	pb->notify = data->notify;
	pb->check_fb = data->check_fb;
	pb->lth_brightness = data->lth_brightness *
		(data->pwm_period_ns / data->max_brightness);
	pb->dev = &pdev->dev;

	pb->pwm = pwm_request(data->pwm_name, "backlight");
	if (IS_ERR(pb->pwm)) {
		dev_err(&pdev->dev, "unable to request PWM for backlight\n");
		ret = PTR_ERR(pb->pwm);
		goto err_pwm;
	} else
		dev_dbg(&pdev->dev, "got pwm for backlight\n");

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = data->max_brightness;
	bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
				       &pwm_backlight_ops, &props);
	if (IS_ERR(bl)) {
		dev_err(&pdev->dev, "failed to register backlight\n");
		ret = PTR_ERR(bl);
		goto err_bl;
	}

	bl->props.brightness = data->dft_brightness;
	pwm_set_polarity(pb->pwm, data->polarity);
	backlight_update_status(bl);

	platform_set_drvdata(pdev, bl);
	return 0;

err_bl:
	pwm_release(pb->pwm);
err_pwm:
	kfree(pb);
err_alloc:
	if (data->exit)
		data->exit(&pdev->dev);
	return ret;
}
示例#10
0
int pwm_start(const char *key, float duty, float freq, int polarity)
{
    char fragment[18];
    char pwm_test_fragment[20];
    char pwm_test_path[45];
    char period_path[50];
    char duty_path[50];
    char polarity_path[55];
    int period_fd, duty_fd, polarity_fd;
    struct pwm_exp *new_pwm, *pwm;

    if(!BBB_G(pwm_initialized)) {
        initialize_pwm();
    }

    snprintf(fragment, sizeof(fragment), "bone_pwm_%s", key);
    

    if (!load_device_tree(fragment)) {
        //error enabling pin for pwm
        return -1;
    }

    //creates the fragment in order to build the pwm_test_filename, such as "pwm_test_P9_13"
    snprintf(pwm_test_fragment, sizeof(pwm_test_fragment), "pwm_test_%s", key);

    //finds and builds the pwm_test_path, as it can be variable...
    build_path(BBB_G(ocp_dir), pwm_test_fragment, pwm_test_path, sizeof(pwm_test_path));

    //create the path for the period and duty
    snprintf(period_path, sizeof(period_path), "%s/period", pwm_test_path);
    snprintf(duty_path, sizeof(duty_path), "%s/duty", pwm_test_path);
    snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_test_path);

    //add period and duty fd to pwm list    
    if ((period_fd = open(period_path, O_RDWR)) < 0)
        return -1;


    if ((duty_fd = open(duty_path, O_RDWR)) < 0) {
        //error, close already opened period_fd.
        close(period_fd);
        return -1;
    }

    if ((polarity_fd = open(polarity_path, O_RDWR)) < 0) {
        //error, close already opened period_fd and duty_fd.
        close(period_fd);
        close(duty_fd);
        return -1;
    }    

    // add to list
    new_pwm = malloc(sizeof(struct pwm_exp));
    if (new_pwm == 0) {
        return -1; // out of memory
    }

    strncpy(new_pwm->key, key, KEYLEN);  /* can leave string unterminated */
    new_pwm->key[KEYLEN] = '\0'; /* terminate string */
    new_pwm->period_fd = period_fd;
    new_pwm->duty_fd = duty_fd;
    new_pwm->polarity_fd = polarity_fd;
    new_pwm->next = NULL;

    if (exported_pwms == NULL)
    {
        // create new list
        exported_pwms = new_pwm;
    } else {
        // add to end of existing list
        pwm = exported_pwms;
        while (pwm->next != NULL)
            pwm = pwm->next;
        pwm->next = new_pwm;
    }

    pwm_set_frequency(key, freq);
    pwm_set_polarity(key, polarity);
    pwm_set_duty_cycle(key, duty);

    return 1;
}
static int ss_brcm_haptic_probe(struct platform_device *pdev)
{
	struct platform_isa1000_vibrator_data *pdata = pdev->dev.platform_data;
	t_vib_desc *vib_iter;
	int ret=0;

	printk("ss_brcm_haptic_probe \n"); 

	/* vib_iter=kzalloc(sizeof(t_vib_desc), GFP_KERNEL);
	   if(vib_iter == NULL)
	   {
	   pr_err("%s : memory allocation failure \n", __func__);
	   return -ENOMEM;
	   } */
	vib_iter=&vib_desc;

	vib_iter->vib_vcc = (const char *)pdata->regulator_id;
	printk(KERN_INFO "%s: Vibrator vcc=%s \n", __func__, vib_iter->vib_vcc);

	//vib_iter->vib_regulator=regulator_get(NULL, VIB_VCC);
	vib_iter->vib_regulator=regulator_get(NULL, vib_iter->vib_vcc);
	if(IS_ERR(vib_iter->vib_regulator))
	{
		printk(KERN_INFO "%s: failed to get regulator \n", __func__);
		return -ENODEV;
	}

	regulator_enable(vib_iter->vib_regulator);

	vib_iter->gpio_en = pdata->gpio_en;
	vib_iter->pwm = pwm_request(pdata->pwm_name, "vibrator");
	if (IS_ERR(vib_iter->pwm)) 
	{
		pr_err("[VIB] Failed to request pwm.\n");
		 return -EFAULT;
	}
	vib_iter->pwm_duty = pdata->pwm_duty;
	vib_iter->pwm_period = pdata->pwm_period_ns;
	vib_iter->pwm_polarity = pdata->polarity;

	pwm_set_polarity(vib_iter->pwm , vib_iter->pwm_polarity); 

	vib_iter->timed_dev.name="vibrator";
	vib_iter->timed_dev.enable=vibrator_enable_set_timeout;
	vib_iter->timed_dev.get_time=vibrator_get_remaining_time;

	ret = timed_output_dev_register(&vib_iter->timed_dev);
	if(ret < 0)
	{
		printk(KERN_ERR "Vibrator: timed_output dev registration failure\n");
		timed_output_dev_unregister(&vib_iter->timed_dev);
	}

	init_timer(&vib_iter->vib_timer);
	vib_iter->vib_timer.function = on_vibrate_timer_expired;
	vib_iter->vib_timer.data = (unsigned long)vib_iter;

	platform_set_drvdata(pdev, vib_iter);

	INIT_WORK(&vib_iter->off_work, vibrator_off_work_func);
	
	vib_iter->initialized = 1;
	printk("%s : ss vibrator probe\n", __func__);
	return 0;

}
void Pwm::set_polarity(Polarity polarity)
{
    (CheckError)pwm_set_polarity(key_.c_str(), (int)polarity);
}
示例#13
0
文件: pwm.c 项目: wda2945/Fido
int pwm_start(const char *pinName, int exportNumber, char *pwmDir, float duty, float freq, int polarity, PwmChannel_t *pwm)
{
    char pwm_control_path[PATHLEN];


    char pwm_path[PATHLEN];				//pwm channel control folder
    char export[2];
    int fd;

    strncpy(pwm->key, pinName, KEYLEN);

    if (set_pinmux(pinName, "pwm") < 0)
    {
    	return -1;
    }
    //export pwm channel
    if ((fd = open("/sys/class/pwm/export", O_WRONLY)) < 0)
    {
    	LogError("pwm open(/sys/class/pwm/export) fail (%s)\n", strerror(errno));
        return -1;
    }
    snprintf(export, 2, "%i", exportNumber);
    write(fd,export,1);
    close(fd);

    snprintf(pwm_path, sizeof(pwm_path), "/sys/class/pwm/%s", pwmDir);

    //create the path for period control
    snprintf(pwm_control_path, sizeof(pwm_control_path), "%s/period_ns", pwm_path);
    if ((pwm->period_fd = open(pwm_control_path, O_WRONLY)) < 0)
    {
    	LogError("pwm open(%s) fail (%s)\n", pwm_control_path, strerror(errno));
        return -1;
    }

    snprintf(pwm_control_path, sizeof(pwm_control_path), "%s/duty_ns", pwm_path);
    if ((pwm->duty_fd = open(pwm_control_path, O_WRONLY)) < 0) {
        //error, close already opened period_fd.
    	LogError("pwm open(%s) fail (%s)\n", pwm_control_path, strerror(errno));
        close(pwm->period_fd);
        return -1;
    }

    snprintf(pwm_control_path, sizeof(pwm_control_path), "%s/polarity", pwm_path);
    if ((pwm->polarity_fd = open(pwm_control_path, O_WRONLY)) < 0) {
    	LogError("pwm open(%s) fail (%s)\n", pwm_control_path, strerror(errno));
        //error, close already opened period_fd and duty_fd.
        close(pwm->period_fd);
        close(pwm->duty_fd);
        return -1;
    }    

    snprintf(pwm_control_path, sizeof(pwm_control_path), "%s/run", pwm_path);
    if ((pwm->run_fd = open(pwm_control_path, O_WRONLY)) < 0) {
    	LogError("pwm open(%s) fail (%s)\n", pwm_control_path, strerror(errno));
        //error, close already opened period_fd and duty_fd.
    	close(pwm->polarity_fd);
        close(pwm->period_fd);
        close(pwm->duty_fd);
        return -1;
    }

    pwm_set_frequency(pwm, freq);
    pwm_set_polarity(pwm, polarity);
    pwm_set_duty_cycle(pwm, duty);
    pwm_set_run(pwm, 1);

    return 0;
}
static int pwm_backlight_probe(struct platform_device *pdev)
{
	struct backlight_properties props;
	struct platform_pwm_backlight_data *data = NULL;
	struct backlight_device *bl;
	struct pwm_bl_data *pb;
	const char *pwm_request_label = NULL;
	int ret;
	int bl_delay_on = 0;
	printk("[BACKLIGHT] %s : %d\n", __func__, __LINE__);
	if (pdev->dev.platform_data)
		data = pdev->dev.platform_data;

	else if (pdev->dev.of_node) {
		u32 val;
		data = kzalloc(sizeof(struct platform_pwm_backlight_data),
				GFP_KERNEL);
		if (!data)
			return -ENOMEM;

		if (of_property_read_u32(pdev->dev.of_node, "pwm-id", &val)) {
			ret = -EINVAL;
			goto err_read;
		}
		data->pwm_id = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"max-brightness", &val)) {
			ret = -EINVAL;
			goto err_read;
		}
		data->max_brightness = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"dft-brightness", &val)) {
			ret = -EINVAL;
			goto err_read;
		}
		data->dft_brightness = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"polarity", &val)) {
			ret = -EINVAL;
			goto err_read;
		}
		data->polarity = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"pwm-period-ns", &val)) {
			ret = -EINVAL;
			goto err_read;
		}
		data->pwm_period_ns = val;

		if (of_property_read_string(pdev->dev.of_node,
			"pwm-request-label", &pwm_request_label)) {
			ret = -EINVAL;
			goto err_read;
		}

		if (of_property_read_u32(pdev->dev.of_node,
				"bl-on-delay", &val)) {
			bl_delay_on = 0;
		} else
			bl_delay_on = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"pwm_pin_name", &val)) {
			pwm_pin = -1;
		} else
			pwm_pin = val;

		if (of_property_read_u32(pdev->dev.of_node,
				"pwm_pin_reboot_func", &val)) {
			pwm_pin_reboot_func = -1;
		} else
			pwm_pin_reboot_func = val;

		pdev->dev.platform_data = data;

	}
	if (!data) {
		dev_err(&pdev->dev, "failed to find platform data\n");
		return -EINVAL;
	}

	if (data->init) {
		ret = data->init(&pdev->dev);
		if (ret < 0)
			return ret;
	}

	pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL);
	if (!pb) {
		dev_err(&pdev->dev, "no memory for state\n");
		ret = -ENOMEM;
		goto err_alloc;
	}

	pb->period = data->pwm_period_ns;

	pb->notify = data->notify;
	pb->notify_after = data->notify_after;
	pb->check_fb = data->check_fb;
	pb->lth_brightness = data->lth_brightness *
		(data->pwm_period_ns / data->max_brightness);
	pb->dev = &pdev->dev;
	if (pdev->dev.of_node)
		pb->pwm = pwm_request(data->pwm_id, pwm_request_label);
	else
		pb->pwm = pwm_request(data->pwm_id, "backlight");

	if (IS_ERR(pb->pwm)) {
		dev_err(&pdev->dev, "unable to request PWM for backlight\n");
		ret = PTR_ERR(pb->pwm);
		goto err_alloc;
	} else
		dev_dbg(&pdev->dev, "got pwm for backlight\n");

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = data->max_brightness;
	//bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
	//			       &pwm_backlight_ops, &props);

	bl = backlight_device_register("panel", &pdev->dev, pb,
				       &pwm_backlight_ops, &props);

	if (IS_ERR(bl)) {
		dev_err(&pdev->dev, "failed to register backlight\n");
		ret = PTR_ERR(bl);
		goto err_bl;
	}

	bl->props.brightness = data->dft_brightness;
	pwm_set_polarity(pb->pwm, data->polarity);

	pr_info("pwm_backlight_probe bl-delay-on %d\r\n", bl_delay_on);
	pr_info("pwm_backlight_probe pwm_pin  %d\r\n", pwm_pin);
	pr_info("pwm_backlight_probe pwm_pin_reboot_func %d\r\n", pwm_pin_reboot_func);

	if (bl_delay_on == 0)
		backlight_update_status(bl);
	else {
		INIT_DELAYED_WORK(&(pb->bl_delay_on_work), bl_delay_on_func);
		schedule_delayed_work(&(pb->bl_delay_on_work),
			msecs_to_jiffies(bl_delay_on));
	}

	platform_set_drvdata(pdev, bl);
#ifdef CONFIG_BACKLIGHT_USE_EARLYSUSPEND
	pb->bd_early_suspend.suspend = backlight_driver_early_suspend;
	pb->bd_early_suspend.resume = backlight_driver_late_resume;
	pb->bd_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
	register_early_suspend(&pb->bd_early_suspend);
#endif

	printk("[BACKLIGHT] %s : %d\n", __func__, __LINE__);
	return 0;

err_bl:
	pwm_free(pb->pwm);
err_alloc:
	if (data->exit)
		data->exit(&pdev->dev);
err_read:
	if (pdev->dev.of_node)
		kfree(data);
	return ret;
}