build/patch/kernel/sun7i-default/0015-rewrite-function-bestprescale.patch

From 2920d2cfb3fed734404e4ace8d43c95846c06e77 Mon Sep 17 00:00:00 2001
From: Damien Pageot <damien.pageot78@gmail.com>
Date: Thu, 31 Mar 2016 16:38:56 +0200
Subject: [PATCH 15/19] rewrite function bestprescale

recode best prescale function and add non prescale
---
 drivers/misc/pwm-sunxi.c | 1564 +++++++++++++++++++++++-----------------------
 1 file changed, 791 insertions(+), 773 deletions(-)

diff --git a/drivers/misc/pwm-sunxi.c b/drivers/misc/pwm-sunxi.c
index 310798e..6f1e498 100644
--- a/drivers/misc/pwm-sunxi.c
+++ b/drivers/misc/pwm-sunxi.c
@@ -1,10 +1,10 @@
-/* pwm-sunxi.c 
- * 
- * pwm module for sun4i (and others) like cubieboard and pcduino 
- * 
- * (C) Copyright 2013 
- * David H. Wilkins  <dwil...@conecuh.com> 
- * 
+/* pwm-sunxi.c
+ *
+ * pwm module for sun4i (and others) like cubieboard and pcduino
+ *
+ * (C) Copyright 2013
+ * David H. Wilkins  <dwil...@conecuh.com>
+ *
  * CHANGELOG:
  * 10.08.2013 - Stefan Voit <stefan.voit@voit-consulting.com>
  * - Added script.bin support for [pwm0_para] and [pwm1_para]: pwm_used, pwm_period, pwm_duty_percent
@@ -16,130 +16,130 @@
  * - Implement duty_percent=0 to set pwm line to 0 - right now it goes to 100%
  * - Change the script_bin settings loader for pwm_period to allow text based values (100ms, 10hz,...)
  * - Merge h & c file
- * - 
+ * -
  *
- * This program is free software; you can redistribute it and/or 
- * modify it under the terms of the GNU General Public License as 
- * published by the Free Software Foundation; either version 2 of 
- * the License, or (at your option) any later version. 
- * 
- * This program is distributed in the hope that it will be useful, 
- * but WITHOUT ANY WARRANTY; without even the implied warranty of 
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the 
- * GNU General Public License for more details. 
- * 
- * You should have received a copy of the GNU General Public License 
- * along with this program; if not, write to the Free Software 
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
- * MA 02111-1307 USA 
- */ 
- 
-#include <linux/kobject.h> 
-#include <linux/slab.h> 
-#include <linux/device.h> 
-#include <linux/sysfs.h> 
-#include <linux/module.h> 
-#include <linux/kernel.h> 
-#include <linux/platform_device.h> 
-#include <linux/err.h> 
-#include <asm/io.h> 
-#include <asm/delay.h> 
-#include <mach/platform.h> 
-#include <linux/pwm.h> 
-#include <linux/ctype.h> 
-#include <linux/limits.h> 
-#include <linux/pwm.h> 
-#include <linux/kdev_t.h> 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/kobject.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/sysfs.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <asm/io.h>
+#include <asm/delay.h>
+#include <mach/platform.h>
+#include <linux/pwm.h>
+#include <linux/ctype.h>
+#include <linux/limits.h>
+#include <linux/pwm.h>
+#include <linux/kdev_t.h>
 #include <plat/system.h>
 #include <plat/sys_config.h>
 
-#include "pwm-sunxi.h" 
-/* 
- * Forward Declarations 
- */ 
+#include "pwm-sunxi.h"
+/*
+ * Forward Declarations
+ */
 
 
 #define SUNXI_PWM_DEBUG
 
 //comment to get debug messages
 #undef SUNXI_PWM_DEBUG
- 
-void release_pwm_sunxi(struct kobject *kobj); 
-void pwm_setup_available_channels(void ); 
-ssize_t pwm_set_mode(unsigned int enable, struct sun4i_pwm_available_channel *chan); 
-enum sun4i_pwm_prescale  pwm_get_best_prescale(unsigned long long period); 
-unsigned int get_entire_cycles(struct sun4i_pwm_available_channel *chan); 
-unsigned int get_active_cycles(struct sun4i_pwm_available_channel *chan); 
-unsigned long convert_string_to_microseconds(const char *buf); 
-int pwm_set_period_and_duty(struct sun4i_pwm_available_channel *chan); 
-void fixup_duty(struct sun4i_pwm_available_channel *chan); 
- 
- 
-static DEFINE_MUTEX(sysfs_lock); 
-static struct class pwm_class; 
- 
-void *PWM_CTRL_REG_BASE = NULL; 
- 
- 
-static struct class_attribute pwm_class_attrs[] = { 
-	__ATTR_NULL 
-}; 
- 
- 
-static struct class pwm_class = { 
-	.name =         "pwm-sunxi", 
-	.owner =        THIS_MODULE, 
-	.class_attrs =  pwm_class_attrs, 
-}; 
- 
- 
-/* 
- * sysfs store / show functions 
- */ 
- 
-static ssize_t pwm_polarity_show(struct device *dev, struct device_attribute *attr, char *buf); 
-static ssize_t pwm_period_show(struct device *dev, struct device_attribute *attr, char *buf); 
-static ssize_t pwm_duty_show(struct device *dev, struct device_attribute *attr, char *buf); 
-static ssize_t pwm_run_show(struct device *dev,struct device_attribute *attr, char *buf); 
-static ssize_t pwm_duty_percent_show(struct device *dev,struct device_attribute *attr, char *buf); 
-static ssize_t pwm_pulse_show(struct device *dev,struct device_attribute *attr, char *buf); 
-static ssize_t pwm_pin_show(struct device *dev,struct device_attribute *attr, char *buf); 
- 
-static ssize_t pwm_polarity_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
-static ssize_t pwm_period_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
-static ssize_t pwm_duty_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
-static ssize_t pwm_run_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
-static ssize_t pwm_duty_percent_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
-static ssize_t pwm_pulse_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size); 
- 
-static DEVICE_ATTR(polarity, 0644,pwm_polarity_show, pwm_polarity_store); 
-static DEVICE_ATTR(period, 0644, pwm_period_show, pwm_period_store); 
-static DEVICE_ATTR(duty, 0644,pwm_duty_show, pwm_duty_store); 
-static DEVICE_ATTR(run, 0644, pwm_run_show, pwm_run_store); 
-static DEVICE_ATTR(duty_percent, 0644, pwm_duty_percent_show, pwm_duty_percent_store); 
-static DEVICE_ATTR(pulse, 0644, pwm_pulse_show, pwm_pulse_store); 
-static DEVICE_ATTR(pin, 0644, pwm_pin_show, NULL); 
- 
-static const struct attribute *pwm_attrs[] = { 
-	&dev_attr_polarity.attr, 
-	&dev_attr_period.attr, 
-	&dev_attr_duty.attr, 
-	&dev_attr_run.attr, 
-	&dev_attr_duty_percent.attr, 
-	&dev_attr_pulse.attr, 
-	&dev_attr_pin.attr, 
-	NULL, 
-}; 
- 
-static const struct attribute_group pwm_attr_group = { 
-	.attrs = (struct attribute **) pwm_attrs 
-}; 
- 
-struct device *pwm0; 
-struct device *pwm1; 
- 
- 
-static struct sun4i_pwm_available_channel pwm_available_chan[SUN4I_MAX_HARDWARE_PWM_CHANNELS]; 
+
+void release_pwm_sunxi(struct kobject *kobj);
+void pwm_setup_available_channels(void );
+ssize_t pwm_set_mode(unsigned int enable, struct sun4i_pwm_available_channel *chan);
+enum sun4i_pwm_prescale  pwm_get_best_prescale(unsigned long long period);
+unsigned int get_entire_cycles(struct sun4i_pwm_available_channel *chan);
+unsigned int get_active_cycles(struct sun4i_pwm_available_channel *chan);
+unsigned long convert_string_to_microseconds(const char *buf);
+int pwm_set_period_and_duty(struct sun4i_pwm_available_channel *chan);
+void fixup_duty(struct sun4i_pwm_available_channel *chan);
+
+
+static DEFINE_MUTEX(sysfs_lock);
+static struct class pwm_class;
+
+void *PWM_CTRL_REG_BASE = NULL;
+
+
+static struct class_attribute pwm_class_attrs[] = {
+	__ATTR_NULL
+};
+
+
+static struct class pwm_class = {
+	.name =         "pwm-sunxi",
+	.owner =        THIS_MODULE,
+	.class_attrs =  pwm_class_attrs,
+};
+
+
+/*
+ * sysfs store / show functions
+ */
+
+static ssize_t pwm_polarity_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t pwm_period_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t pwm_duty_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t pwm_run_show(struct device *dev,struct device_attribute *attr, char *buf);
+static ssize_t pwm_duty_percent_show(struct device *dev,struct device_attribute *attr, char *buf);
+static ssize_t pwm_pulse_show(struct device *dev,struct device_attribute *attr, char *buf);
+static ssize_t pwm_pin_show(struct device *dev,struct device_attribute *attr, char *buf);
+
+static ssize_t pwm_polarity_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+static ssize_t pwm_period_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+static ssize_t pwm_duty_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+static ssize_t pwm_run_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+static ssize_t pwm_duty_percent_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+static ssize_t pwm_pulse_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size);
+
+static DEVICE_ATTR(polarity, 0644,pwm_polarity_show, pwm_polarity_store);
+static DEVICE_ATTR(period, 0644, pwm_period_show, pwm_period_store);
+static DEVICE_ATTR(duty, 0644,pwm_duty_show, pwm_duty_store);
+static DEVICE_ATTR(run, 0644, pwm_run_show, pwm_run_store);
+static DEVICE_ATTR(duty_percent, 0644, pwm_duty_percent_show, pwm_duty_percent_store);
+static DEVICE_ATTR(pulse, 0644, pwm_pulse_show, pwm_pulse_store);
+static DEVICE_ATTR(pin, 0644, pwm_pin_show, NULL);
+
+static const struct attribute *pwm_attrs[] = {
+	&dev_attr_polarity.attr,
+	&dev_attr_period.attr,
+	&dev_attr_duty.attr,
+	&dev_attr_run.attr,
+	&dev_attr_duty_percent.attr,
+	&dev_attr_pulse.attr,
+	&dev_attr_pin.attr,
+	NULL,
+};
+
+static const struct attribute_group pwm_attr_group = {
+	.attrs = (struct attribute **) pwm_attrs
+};
+
+struct device *pwm0;
+struct device *pwm1;
+
+
+static struct sun4i_pwm_available_channel pwm_available_chan[SUN4I_MAX_HARDWARE_PWM_CHANNELS];
 static int sunxi_pwm_class_registered = 0;
 
 static void __init sunxi_pwm_register_class(void)
@@ -154,18 +154,18 @@ static void __init sunxi_pwm_register_class(void)
 	sunxi_pwm_class_registered = 1;
 }
 
-static int __init sunxi_pwm_init(void) 
-{ 
+static int __init sunxi_pwm_init(void)
+{
 	int init_enable, init_duty_percent, init_period;
 	struct sun4i_pwm_available_channel *chan;
 	int err = 0;
 
-	pwm_setup_available_channels(); 
+	pwm_setup_available_channels();
 
 	//PWM 0
 	//printk("pwm-sunxi: configuring pwm0...\n");
 	chan = &pwm_available_chan[0];
- 	
+
 	init_enable=0;
 	init_period=0;
 	init_duty_percent=100;
@@ -193,13 +193,13 @@ static int __init sunxi_pwm_init(void)
 		}
 
 		chan->duty_percent=init_duty_percent;
-		chan->period = init_period; 
-		chan->prescale = pwm_get_best_prescale(init_period); 
-		fixup_duty(chan); 
+		chan->period = init_period;
+		chan->prescale = pwm_get_best_prescale(init_period);
+		fixup_duty(chan);
 #ifdef SUNXI_PWM_DEBUG
 		printk("pwm-sunxi: pwm0 set initial values\n");
 #endif
-		pwm_set_mode(init_enable,chan); 
+		pwm_set_mode(init_enable,chan);
 		printk("pwm-sunxi: pwm0 configured - period: %ld, duty_percent: %d, duty: %ld\n",
 			chan->period, chan->duty_percent, chan->duty);
 	}
@@ -210,7 +210,7 @@ static int __init sunxi_pwm_init(void)
 	//PWM 1
 	//printk("pwm-sunxi: configuring pwm1...\n");
 	chan = &pwm_available_chan[1];
- 	
+
 	init_enable=0;
 	init_period=0;
 	init_duty_percent=100;
@@ -238,23 +238,23 @@ static int __init sunxi_pwm_init(void)
 		}
 
 		chan->duty_percent=init_duty_percent;
-		chan->period = init_period; 
-		chan->prescale = pwm_get_best_prescale(init_period); 
-		fixup_duty(chan); 
+		chan->period = init_period;
+		chan->prescale = pwm_get_best_prescale(init_period);
+		fixup_duty(chan);
 #ifdef SUNXI_PWM_DEBUG
 		printk("pwm-sunxi: pwm0 set initial values\n");
 #endif
-		pwm_set_mode(init_enable,chan); 
+		pwm_set_mode(init_enable,chan);
 		printk("pwm-sunxi: pwm1 configured - period: %ld, duty_percent: %d, duty: %ld\n",
 			chan->period, chan->duty_percent, chan->duty);
 	}
 	return 0;
-} 
+}
 
-void sunxi_pwm_exit(void) 
-{ 
-	void *timer_base = ioremap(SW_PA_TIMERC_IO_BASE, 0x400); 
-	void *PWM_CTRL_REG_BASE = timer_base + 0x200; 
+void sunxi_pwm_exit(void)
+{
+	void *timer_base = ioremap(SW_PA_TIMERC_IO_BASE, 0x400);
+	void *PWM_CTRL_REG_BASE = timer_base + 0x200;
 
 	if (pwm0) {
 		device_destroy(&pwm_class, pwm0->devt);
@@ -268,647 +268,665 @@ void sunxi_pwm_exit(void)
 	}
 
 	if (sunxi_pwm_class_registered) {
-		writel(0, PWM_CTRL_REG_BASE + 0); 
+		writel(0, PWM_CTRL_REG_BASE + 0);
 		class_unregister(&pwm_class);
 	}
 }
 
-/* 
- * Functions to display the pwm variables currently set 
- */ 
- 
-static ssize_t pwm_polarity_show(struct device *dev, struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	switch (chan->channel) { 
-	case 0: 
-		status = scnprintf(buf,PAGE_SIZE,"%d",chan->ctrl_current.s.ch0_act_state); 
-		break; 
-	case 1: 
-		status = scnprintf(buf,PAGE_SIZE,"%d",chan->ctrl_current.s.ch1_act_state); 
-		break; 
-	default: 
-		status = -EINVAL; 
-		break; 
-	} 
-	return status; 
-} 
-static ssize_t pwm_period_show(struct device *dev, struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	status = sprintf(buf,"%lu",chan->period); 
-	return status; 
-} 
-static ssize_t pwm_duty_show(struct device *dev, struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	status = sprintf(buf,"%lu",chan->duty); 
-	return status; 
-} 
-static ssize_t pwm_run_show(struct device *dev,struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	switch (chan->channel) { 
-	case 0: 
-		status = sprintf(buf,"%d",chan->ctrl_current.s.ch0_en); 
-		break; 
-	case 1: 
-		status = sprintf(buf,"%d",chan->ctrl_current.s.ch1_en); 
-		break; 
-	default: 
-		status = -EINVAL; 
-		break; 
-	} 
- 
-	return status; 
-} 
-static ssize_t pwm_duty_percent_show(struct device *dev,struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	return sprintf(buf,"%u",chan->duty_percent); 
-} 
-static ssize_t pwm_pulse_show(struct device *dev,struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	switch (chan->channel) { 
-	case 0: 
-		status = sprintf(buf,"%d",chan->ctrl_current.s.ch0_pulse_start); 
-		break; 
-	case 1: 
-		status = sprintf(buf,"%d",chan->ctrl_current.s.ch1_pulse_start); 
-		break; 
-	default: 
-		status = -EINVAL; 
-		break; 
-	} 
-	return status; 
-} 
- 
-static ssize_t pwm_pin_show(struct device *dev,struct device_attribute *attr, char *buf) { 
-	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status; 
-	status = sprintf(buf,"%s",chan->pin_name); 
- 
-	return status; 
-} 
- 
-/* 
- * Functions to store values for pwm 
- */ 
- 
-static ssize_t pwm_polarity_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status = -EINVAL; 
-	int act_state = 0; 
- 
-	sscanf(buf,"%d",&act_state); 
-	if(act_state < 2) { 
-		switch (chan->channel) { 
-		case 0: 
-			chan->ctrl_current.s.ch0_act_state = act_state; 
-			break; 
-		case 1: 
-			chan->ctrl_current.s.ch1_act_state = act_state; 
-			break; 
-		default: 
-			status = -EINVAL; 
-			break; 
-		} 
-		status = size; 
-	} 
-	return status; 
-} 
-static ssize_t pwm_period_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	unsigned long long period = 0; 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
- 
-	period = convert_string_to_microseconds(buf); 
-	if(!period || period > ULONG_MAX) { 
-		size = -EINVAL; 
-	} else { 
-		if(period <= chan->duty) { 
-			chan->duty = period; 
-		} 
-		chan->period = period; 
-		chan->prescale = pwm_get_best_prescale(period); 
-		fixup_duty(chan); 
-		if(chan->duty) { 
-			pwm_set_mode(NO_ENABLE_CHANGE,chan); 
-		} 
-	} 
-	return size; 
-} 
-static ssize_t pwm_duty_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	unsigned long long duty = 0; 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
- 
-	/* sscanf(buf,"%Lu",&duty); */ /* L means long long pointer */ 
-	duty = convert_string_to_microseconds(buf); 
-	duty = duty > ULONG_MAX ? ULONG_MAX : duty; 
-	duty = duty > chan->period ? chan->period : duty; 
-	chan->duty_percent = -1; /* disable duty_percent if duty is set by hand */ 
-	chan->duty = duty; 
-	pwm_set_mode(NO_ENABLE_CHANGE,chan); 
-	return size; 
-} 
- 
-struct time_suffix suffixes[] = { 
-	[0] = { .suffix = "hz",  .multiplier =	  1, .freq = true  }, /* f = 1/T */ 
-	[1] = { .suffix = "khz", .multiplier =       1000, .freq = true  }, 
-	[2] = { .suffix = "mhz", .multiplier =    1000000, .freq = true  }, 
-	[3] = { .suffix = "ghz", .multiplier = 1000000000, .freq = true  }, 
-	[4] = { .suffix = "ms",  .multiplier =       1000, .freq = false }, /* T = 1/f */ 
-	[5] = { .suffix = "us",  .multiplier =	  1, .freq = false }, 
-	[6] = { .suffix = "ns",  .multiplier =	  1, .freq = false }, 
-	[7] = { .suffix = NULL,  .multiplier =	  0, .freq = false }, 
-}; 
- 
- 
-unsigned long convert_string_to_microseconds(const char *buf) { 
-	unsigned char ch = 0; 
-	char numbers[10]; 
-	char letters[4]; 
-	const char *bufptr = buf; 
-	int i = 0; 
-	unsigned long microseconds = 0; 
-	unsigned long numeric_part = 0; 
-	int found_suffix = -1; 
-	int numbers_index = 0, letters_index = 0; 
-	while(bufptr && *bufptr && (ch = *bufptr)  && isdigit(ch) && numbers_index < (sizeof(numbers)-1)) { 
-		numbers[numbers_index++] = *bufptr++; 
-	} 
-	numbers[numbers_index] = 0; 
-	while(bufptr && *bufptr && (ch = *bufptr)  && strchr("usmhznhzkg",tolower(ch)) && letters_index < (sizeof(letters)-1)) { 
-		letters[letters_index++] = tolower(*bufptr); 
-		bufptr++; 
-	} 
-	letters[letters_index] = 0; 
-	sscanf(numbers,"%lu",&numeric_part); 
-	while(suffixes[i].suffix) { 
-		if(!strcmp(suffixes[i].suffix,letters)) { 
-			found_suffix = i; 
-			break; 
-		} 
-		i++; 
-	} 
-	if(found_suffix > -1) { 
-		if(suffixes[found_suffix].freq) { 
-			microseconds = 1000000 / (numeric_part * suffixes[found_suffix].multiplier); 
-		} else { 
-			microseconds = suffixes[found_suffix].multiplier * numeric_part; 
-		} 
-	} 
-	return microseconds; 
-} 
- 
- 
- 
- 
-static const unsigned int prescale_divisor[13] = {120, 
-						  180, 
-						  240, 
-						  360, 
-						  480, 
-						  480, /* Invalid Option */ 
-						  480, /* Invalid Option */ 
-						  480, /* Invalid Option */ 
-						  12000, 
-						  24000, 
-						  36000, 
-						  48000, 
-						  72000}; 
- 
-/* 
- * Find the best prescale value for the period 
- * We want to get the highest period cycle count possible, so we look 
- * make a run through the prescale values looking for numbers over 
- * min_optimal_period_cycles.  If none are found then root though again 
- * taking anything that works 
- */ 
-enum sun4i_pwm_prescale  pwm_get_best_prescale(unsigned long long period_in) { 
-	int i; 
-	unsigned long period = period_in; 
-	const unsigned long min_optimal_period_cycles = MAX_CYCLES / 2; 
-	const unsigned long min_period_cycles = 0x02; 
-	enum sun4i_pwm_prescale best_prescale = 0; 
- 
-	best_prescale = -1; 
-	for(i = 0 ; i < 13 ; i++) { 
-		unsigned long int check_value = (prescale_divisor[i] /24); 
-		if(check_value < 1 || check_value > period) { 
-			break; 
-		} 
-		if(((period / check_value) >= min_optimal_period_cycles) && 
-			((period / check_value) <= MAX_CYCLES)) { 
-			best_prescale = i; 
-			break; 
-		} 
-	} 
- 
-	if(best_prescale > 13) { 
-		for(i = 0 ; i < 13 ; i++) { 
-			unsigned long int check_value = (prescale_divisor[i] /24); 
-			if(check_value < 1 || check_value > period) { 
-				break; 
-			} 
-			if(((period / check_value) >= min_period_cycles) && 
-				((period / check_value) <= MAX_CYCLES)) { 
-				best_prescale = i; 
-				break; 
-			} 
-		} 
-	} 
-	if(best_prescale > 13) { 
-		best_prescale = PRESCALE_DIV480;  /* Something that's not zero - use invalid prescale value */ 
-	} 
- 
-	return best_prescale; 
-} 
- 
-/* 
- * return the number of cycles for the channel period computed from the microseconds 
- * for the period.  Allwinner docs call this "entire" cycles 
- */ 
-unsigned int get_entire_cycles(struct sun4i_pwm_available_channel *chan) { 
-	unsigned int entire_cycles = 0x01; 
-	if ((2 * prescale_divisor[chan->prescale] * MAX_CYCLES) > 0) { 
-		entire_cycles = chan->period / (prescale_divisor[chan->prescale] /24); 
-	} 
-	if(entire_cycles == 0) {entire_cycles = MAX_CYCLES;} 
-	if(entire_cycles > MAX_CYCLES) {entire_cycles = MAX_CYCLES;} 
+/*
+ * Functions to display the pwm variables currently set
+ */
+
+static ssize_t pwm_polarity_show(struct device *dev, struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	switch (chan->channel) {
+	case 0:
+		status = scnprintf(buf,PAGE_SIZE,"%d",chan->ctrl_current.s.ch0_act_state);
+		break;
+	case 1:
+		status = scnprintf(buf,PAGE_SIZE,"%d",chan->ctrl_current.s.ch1_act_state);
+		break;
+	default:
+		status = -EINVAL;
+		break;
+	}
+	return status;
+}
+static ssize_t pwm_period_show(struct device *dev, struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	status = sprintf(buf,"%lu",chan->period);
+	return status;
+}
+static ssize_t pwm_duty_show(struct device *dev, struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	status = sprintf(buf,"%lu",chan->duty);
+	return status;
+}
+static ssize_t pwm_run_show(struct device *dev,struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	switch (chan->channel) {
+	case 0:
+		status = sprintf(buf,"%d",chan->ctrl_current.s.ch0_en);
+		break;
+	case 1:
+		status = sprintf(buf,"%d",chan->ctrl_current.s.ch1_en);
+		break;
+	default:
+		status = -EINVAL;
+		break;
+	}
+
+	return status;
+}
+static ssize_t pwm_duty_percent_show(struct device *dev,struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	return sprintf(buf,"%u",chan->duty_percent);
+}
+static ssize_t pwm_pulse_show(struct device *dev,struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	switch (chan->channel) {
+	case 0:
+		status = sprintf(buf,"%d",chan->ctrl_current.s.ch0_pulse_start);
+		break;
+	case 1:
+		status = sprintf(buf,"%d",chan->ctrl_current.s.ch1_pulse_start);
+		break;
+	default:
+		status = -EINVAL;
+		break;
+	}
+	return status;
+}
+
+static ssize_t pwm_pin_show(struct device *dev,struct device_attribute *attr, char *buf) {
+	const struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status;
+	status = sprintf(buf,"%s",chan->pin_name);
+
+	return status;
+}
+
+/*
+ * Functions to store values for pwm
+ */
+
+static ssize_t pwm_polarity_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status = -EINVAL;
+	int act_state = 0;
+
+	sscanf(buf,"%d",&act_state);
+	if(act_state < 2) {
+		switch (chan->channel) {
+		case 0:
+			chan->ctrl_current.s.ch0_act_state = act_state;
+			break;
+		case 1:
+			chan->ctrl_current.s.ch1_act_state = act_state;
+			break;
+		default:
+			status = -EINVAL;
+			break;
+		}
+		status = size;
+	}
+	return status;
+}
+static ssize_t pwm_period_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	unsigned long long period = 0;
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+
+	period = convert_string_to_microseconds(buf);
+	if(!period || period > ULONG_MAX) {
+		size = -EINVAL;
+	} else {
+		if(period <= chan->duty) {
+			chan->duty = period;
+		}
+		chan->period = period;
+		chan->prescale = pwm_get_best_prescale(period);
+		fixup_duty(chan);
+		if(chan->duty) {
+			pwm_set_mode(NO_ENABLE_CHANGE,chan);
+		}
+	}
+	return size;
+}
+static ssize_t pwm_duty_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	unsigned long long duty = 0;
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+
+	/* sscanf(buf,"%Lu",&duty); */ /* L means long long pointer */
+	duty = convert_string_to_microseconds(buf);
+	duty = duty > ULONG_MAX ? ULONG_MAX : duty;
+	duty = duty > chan->period ? chan->period : duty;
+	chan->duty_percent = -1; /* disable duty_percent if duty is set by hand */
+	chan->duty = duty;
+	pwm_set_mode(NO_ENABLE_CHANGE,chan);
+	return size;
+}
+
+struct time_suffix suffixes[] = {
+	[0] = { .suffix = "hz",  .multiplier =	  1, .freq = true  }, /* f = 1/T */
+	[1] = { .suffix = "khz", .multiplier =       1000, .freq = true  },
+	[2] = { .suffix = "mhz", .multiplier =    1000000, .freq = true  },
+	[3] = { .suffix = "ghz", .multiplier = 1000000000, .freq = true  },
+	[4] = { .suffix = "ms",  .multiplier =       1000, .freq = false }, /* T = 1/f */
+	[5] = { .suffix = "us",  .multiplier =	  1, .freq = false },
+	[6] = { .suffix = "ns",  .multiplier =	  1, .freq = false },
+	[7] = { .suffix = NULL,  .multiplier =	  0, .freq = false },
+};
+
+
+unsigned long convert_string_to_microseconds(const char *buf) {
+	unsigned char ch = 0;
+	char numbers[10];
+	char letters[4];
+	const char *bufptr = buf;
+	int i = 0;
+	unsigned long microseconds = 0;
+	unsigned long numeric_part = 0;
+	int found_suffix = -1;
+	int numbers_index = 0, letters_index = 0;
+	while(bufptr && *bufptr && (ch = *bufptr)  && isdigit(ch) && numbers_index < (sizeof(numbers)-1)) {
+		numbers[numbers_index++] = *bufptr++;
+	}
+	numbers[numbers_index] = 0;
+	while(bufptr && *bufptr && (ch = *bufptr)  && strchr("usmhznhzkg",tolower(ch)) && letters_index < (sizeof(letters)-1)) {
+		letters[letters_index++] = tolower(*bufptr);
+		bufptr++;
+	}
+	letters[letters_index] = 0;
+	sscanf(numbers,"%lu",&numeric_part);
+	while(suffixes[i].suffix) {
+		if(!strcmp(suffixes[i].suffix,letters)) {
+			found_suffix = i;
+			break;
+		}
+		i++;
+	}
+	if(found_suffix > -1) {
+		if(suffixes[found_suffix].freq) {
+			microseconds = 1000000 / (numeric_part * suffixes[found_suffix].multiplier);
+		} else {
+			microseconds = suffixes[found_suffix].multiplier * numeric_part;
+		}
+	}
+	return microseconds;
+}
+
+
+
+
+static const unsigned int prescale_divisor[13] = {120,
+						  180,
+						  240,
+						  360,
+						  480,
+						  480, /* Invalid Option */
+						  480, /* Invalid Option */
+						  480, /* Invalid Option */
+						  12000,
+						  24000,
+						  36000,
+						  48000,
+						  72000};
+
+/*
+ * Find the best prescale value for the period
+ * We want to get the highest period cycle count possible, so we look
+ * make a run through the prescale values looking for numbers over
+ * min_optimal_period_cycles.  If none are found then root though again
+ * taking anything that works
+ */
+enum sun4i_pwm_prescale  pwm_get_best_prescale(unsigned long long period_in_us) {
+	int i;
+	unsigned long period_ticks_ns = 42; /* non exact value this introduce 0.8% per clock of error */
+	unsigned long period_ns = period_in_us *1000;
+	enum sun4i_pwm_prescale best_prescale = PRESCALE_DIV1;
+/* with this code the lowest prescaler is always selected */
+    if (period_in_us!= 0){
+
+        if (period_ns < MAX_CYCLES * period_ticks_ns) /* ~2.7ms */
+            goto finded;
+
+        if (period_ns < MAX_CYCLES * 120 * period_ticks_ns){ /*~327ms~*/
+            best_prescale = PRESCALE_DIV120;
+            goto finded;
+        }
+        if (period_ns < MAX_CYCLES * 180 * period_ticks_ns){ /*~491ms~*/
+            best_prescale = PRESCALE_DIV180;
+            goto finded;
+        }
+        if (period_ns < MAX_CYCLES * 240 * period_ticks_ns){ /*~655ms~*/
+            best_prescale = PRESCALE_DIV240;
+            goto finded;
+        }
+        if (period_ns < MAX_CYCLES * 360 * period_ticks_ns){ /*~983ms~*/
+            best_prescale = PRESCALE_DIV360;
+            goto finded;
+        }
+        if (period_ns < MAX_CYCLES * 480 * period_ticks_ns){ /*~1310ms~*/
+            best_prescale = PRESCALE_DIV480;
+            goto finded;
+        }
+        if (period_in_us < MAX_CYCLES * 12 * period_ticks_ns){ /*~32767.5ms~*/
+            best_prescale = PRESCALE_DIV12k;
+            goto finded;
+        }
+
+        if (period_in_us < MAX_CYCLES * 24 * period_ticks_ns){ /*~65535ms*/
+            best_prescale = PRESCALE_DIV24k;
+            goto finded;
+        }
+        if (period_in_us < MAX_CYCLES * 36 * period_ticks_ns){ /*~98302ms~*/
+            best_prescale = PRESCALE_DIV36k;
+            goto finded;
+        }
+        if (period_in_us < MAX_CYCLES * 48 * period_ticks_ns){ /*~130070ms~*/
+            best_prescale = PRESCALE_DIV48k;
+            goto finded;
+        }
+        if (period_in_us < MAX_CYCLES * 72 * period_ticks_ns){  /*max absolute error ~~1.5ms */
+            best_prescale = PRESCALE_DIV72k;
+        }
+    }
+    else
+        best_prescale = PRESCALE_DIV480; /*default value when non found or input is 0*/
+ finded:
+	return best_prescale;
+}
+
+/*
+ * return the number of cycles for the channel period computed from the microseconds
+ * for the period.  Allwinner docs call this "entire" cycles
+ */
+unsigned int get_entire_cycles(struct sun4i_pwm_available_channel *chan) {
+	unsigned int entire_cycles = 0x01;
+	if ((2 * prescale_divisor[chan->prescale] * MAX_CYCLES) > 0) {
+		entire_cycles = chan->period / (prescale_divisor[chan->prescale] /24);
+	}
+	if(entire_cycles == 0) {entire_cycles = MAX_CYCLES;}
+	if(entire_cycles > MAX_CYCLES) {entire_cycles = MAX_CYCLES;}
 #ifdef SUNXI_PWM_DEBUG
-	printk("Best prescale was %d, entire cycles was %u\n",chan->prescale, entire_cycles); 
+	printk("Best prescale was %d, entire cycles was %u\n",chan->prescale, entire_cycles);
 #endif
- 
-	return entire_cycles; 
-} 
- 
-/* 
- * return the number of cycles for the channel duty computed from the microseconds 
- * for the duty.  Allwinner docs call this "active" cycles 
- */ 
-unsigned int get_active_cycles(struct sun4i_pwm_available_channel *chan) { 
-	unsigned int active_cycles = 0x01; 
-	unsigned int entire_cycles = get_entire_cycles(chan); 
-	if(chan->duty < 0 && chan->period) { 
-       		active_cycles = entire_cycles-1; 
-	} else if ((2 * prescale_divisor[chan->prescale] * MAX_CYCLES) > 0) { 
-		active_cycles = chan->duty / (prescale_divisor[chan->prescale] /24); 
-	} 
-/*	if(active_cycles == 0) {active_cycles = 0x0ff;} */ 
+
+	return entire_cycles;
+}
+
+/*
+ * return the number of cycles for the channel duty computed from the microseconds
+ * for the duty.  Allwinner docs call this "active" cycles
+ */
+unsigned int get_active_cycles(struct sun4i_pwm_available_channel *chan) {
+	unsigned int active_cycles = 0x01;
+	unsigned int entire_cycles = get_entire_cycles(chan);
+	if(chan->duty < 0 && chan->period) {
+       		active_cycles = entire_cycles-1;
+	} else if ((2 * prescale_divisor[chan->prescale] * MAX_CYCLES) > 0) {
+		active_cycles = chan->duty / (prescale_divisor[chan->prescale] /24);
+	}
+/*	if(active_cycles == 0) {active_cycles = 0x0ff;} */
 #ifdef SUNXI_PWM_DEBUG
-	printk("Best prescale was %d, active cycles was %u (before entire check)\n",chan->prescale, active_cycles); 
+	printk("Best prescale was %d, active cycles was %u (before entire check)\n",chan->prescale, active_cycles);
 #endif
-	if(active_cycles > MAX_CYCLES) {active_cycles = entire_cycles-1;} 
+	if(active_cycles > MAX_CYCLES) {active_cycles = entire_cycles-1;}
 #ifdef SUNXI_PWM_DEBUG
-	printk("Best prescale was %d, active cycles was %u (after  entire check)\n",chan->prescale, active_cycles); 
+	printk("Best prescale was %d, active cycles was %u (after  entire check)\n",chan->prescale, active_cycles);
 #endif
-	return active_cycles; 
-} 
- 
-/* 
- * When the duty is set, compute the number of microseconds 
- * based on the period. 
- */ 
- 
-void fixup_duty(struct sun4i_pwm_available_channel *chan) { 
-	if(chan->duty_percent >= 0) { 
-		chan->duty = chan->period * chan->duty_percent / 100; 
-	} 
-} 
- 
-/* 
- * Stores the run (enable) bit. 
- */ 
- 
-static ssize_t pwm_run_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status = -EINVAL; 
-	int enable = 0; 
- 
-	sscanf(buf,"%d",&enable); 
-	if(enable < 2) { 
-		status = pwm_set_mode(enable, chan); 
-	} 
-	return size; 
-} 
- 
-static ssize_t pwm_duty_percent_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	unsigned int duty_percent = 0; 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
- 
-	sscanf(buf,"%u",&duty_percent); 
-	if(duty_percent > 100) { 
-		size = -EINVAL; 
-	} else { 
-		chan->duty_percent = duty_percent; 
-		if(chan->period) { 
-			fixup_duty(chan); 
-			pwm_set_mode(NO_ENABLE_CHANGE,chan); 
-		} 
-	} 
- 
-	return size; 
-} 
-static ssize_t pwm_pulse_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) { 
-	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev); 
-	ssize_t status = -EINVAL; 
-	int pulse = 0; 
-	sscanf(buf,"%d",&pulse); 
-	if(pulse < 2) { 
-		switch (chan->channel) { 
-		case 0: 
-			chan->ctrl_current.s.ch0_pulse_start = pulse; 
-			break; 
-		case 1: 
-			chan->ctrl_current.s.ch1_pulse_start = pulse; 
-			break; 
-		default: 
-			status = -EINVAL; 
-			break; 
-		} 
-		status = size; 
-	} 
-	return status; 
-} 
- 
-int pwm_set_period_and_duty(struct sun4i_pwm_available_channel *chan) { 
-	int return_val = -EINVAL; 
-	unsigned int entire_cycles = get_entire_cycles(chan); 
-	unsigned int active_cycles = get_active_cycles(chan); 
-	chan->period_reg.initializer = 0; 
-	if(entire_cycles >= active_cycles && active_cycles) { 
-		chan->period_reg.s.pwm_entire_cycles = entire_cycles; 
-		chan->period_reg.s.pwm_active_cycles = active_cycles; 
-	} else { 
-		chan->period_reg.s.pwm_entire_cycles = MAX_CYCLES; 
-		chan->period_reg.s.pwm_active_cycles = MAX_CYCLES; 
-	} 
-	writel(chan->period_reg.initializer, chan->period_reg_addr); 
-	return return_val; 
-} 
- 
- 
-ssize_t pwm_set_mode(unsigned int enable, struct sun4i_pwm_available_channel *chan) { 
-	ssize_t status = 0; 
-	if(enable == NO_ENABLE_CHANGE) { 
-		switch (chan->channel) { 
-		case 0: 
-			enable = chan->ctrl_current.s.ch0_en; 
-			break; 
-		case 1: 
-			enable = chan->ctrl_current.s.ch1_en; 
-			break; 
-		default: 
-			status = -EINVAL; 
-			break; 
-		} 
-	} 
-	chan->ctrl_current.initializer = readl(chan->ctrl_addr); 
-	if(enable == 1) { 
-		switch (chan->channel) { 
-		case 0: 
-			chan->ctrl_current.s.ch0_prescaler = 0; 
-			chan->ctrl_current.s.ch0_act_state = 0; 
-			chan->ctrl_current.s.ch0_mode = 0; 
-			chan->ctrl_current.s.ch0_pulse_start = 0; 
-			chan->ctrl_current.s.ch0_en = 0; 
-			chan->ctrl_current.s.ch0_clk_gating = 0; 
-			break; 
-		case 1: 
-			chan->ctrl_current.s.ch1_prescaler = 0; 
-			chan->ctrl_current.s.ch1_act_state = 0; 
-			chan->ctrl_current.s.ch1_mode = 0; 
-			chan->ctrl_current.s.ch1_pulse_start = 0; 
-			chan->ctrl_current.s.ch1_en = 1; 
-			chan->ctrl_current.s.ch1_clk_gating = 0; 
-			break; 
-		default: 
-			status = -EINVAL; 
-			break; 
-		} 
-		if(status) { 
-			return status; 
-		} 
-		//writel(chan->ctrl_current.initializer,chan->ctrl_addr); 
-		chan->pin_current.initializer = readl(chan->pin_addr); 
-		if(chan->pin_mask.s0.pin0_select) { 
-			chan->pin_current.s0.pin0_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin1_select) { 
-			chan->pin_current.s0.pin1_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin2_select) { 
-			chan->pin_current.s0.pin2_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin3_select) { 
-			chan->pin_current.s0.pin3_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin4_select) { 
-			chan->pin_current.s0.pin4_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin5_select) { 
-			chan->pin_current.s0.pin5_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin6_select) { 
-			chan->pin_current.s0.pin6_select = SELECT_PWM; 
-		} 
-		if(chan->pin_mask.s0.pin7_select) { 
-			chan->pin_current.s0.pin7_select = SELECT_PWM; 
-		} 
-		if(chan->channel == 0) { 
-			chan->ctrl_current.s.ch0_prescaler = chan->prescale; 
-		} else { 
-			chan->ctrl_current.s.ch1_prescaler = chan->prescale; 
-		} 
-		pwm_set_period_and_duty(chan); 
- 
-		writel(chan->pin_current.initializer,chan->pin_addr); 
-		//writel(chan->ctrl_current.initializer,chan->ctrl_addr); 
-		switch (chan->channel) { 
-		case 0: 
-			chan->ctrl_current.s.ch0_en = 1; 
-			chan->ctrl_current.s.ch0_clk_gating = 1; 
-			break; 
-		case 1: 
-			chan->ctrl_current.s.ch1_en = 1; 
-			chan->ctrl_current.s.ch1_clk_gating = 1; 
-			break; 
-		} 
-		writel(chan->ctrl_current.initializer,chan->ctrl_addr); 
- 
-	} else if (enable == 0) { 
-		switch (chan->channel) { 
-		case 0: 
-			chan->ctrl_current.s.ch0_clk_gating = 0; 
-			chan->ctrl_current.s.ch0_en = enable; 
-			break; 
-		case 1: 
-			chan->ctrl_current.s.ch1_clk_gating = 0; 
-			chan->ctrl_current.s.ch1_en = enable; 
-			break; 
-		default: 
-			status = -EINVAL; 
-			break; 
-		} 
-		if(!status) { 
-			chan->pin_current.initializer &= ~chan->pin_mask.initializer; 
-			chan->pin_current.initializer |= readl(chan->pin_addr) & chan->pin_mask.initializer; 
-			writel(chan->pin_current.initializer,chan->pin_addr); 
-			writel(chan->ctrl_current.initializer,chan->ctrl_addr); 
-		} 
-	} 
-	return status; 
-} 
- 
- 
- 
-void pwm_setup_available_channels( void ) { 
-	void * timer_base = ioremap(SW_PA_TIMERC_IO_BASE, 0x400);  /* 0x01c20c00 */ 
-	void * PWM_CTRL_REG_BASE = timer_base + 0x200;	     /* 0x01c20e00 */ 
-	void * portc_io_base = ioremap(SW_PA_PORTC_IO_BASE,0x400); /* 0x01c20800 */ 
-	void * PB_CFG0_REG = (portc_io_base + 0x24);	       /* 0x01C20824 */ 
-	void * PI_CFG0_REG = (portc_io_base + 0x120);	      /* 0x01c20920 */ 
- 
-	/*void * PB_PULL0_REG = (portc_io_base + 0x040);*/	     /* 0x01c20840 */ 
-	/*void * PI_PULL0_REG = (portc_io_base + 0x13c);*/	     /* 0x01c2091c */ 
-	/*void * PH_CFG0_REG = (portc_io_base + 0xfc);*/	       /* 0x01c208fc */ 
-	/*void * PH_CFG1_REG = (portc_io_base + 0x100);*/	      /* 0x01c20900 */ 
-	/*void * PH_PULL0_REG = (portc_io_base + 0x118);*/	     /* 0x01c20918 */ 
- 
-	pwm_available_chan[0].use_count = 0; 
-	pwm_available_chan[0].ctrl_addr = PWM_CTRL_REG_BASE; 
-	pwm_available_chan[0].pin_addr = PB_CFG0_REG; 
-	pwm_available_chan[0].period_reg_addr = pwm_available_chan[0].ctrl_addr + 0x04; 
-	pwm_available_chan[0].channel = 0; 
-	pwm_available_chan[0].ctrl_backup.initializer = readl(pwm_available_chan[0].ctrl_addr); 
-	pwm_available_chan[0].ctrl_mask.initializer = 0; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_prescaler = 0x0f; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_en = 0x01; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_act_state = 0x01; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_clk_gating = 0x00; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_mode = 0x01; 
-	pwm_available_chan[0].ctrl_mask.s.ch0_pulse_start = 0x01; 
-	pwm_available_chan[0].ctrl_current.initializer = 0; 
-	pwm_available_chan[0].pin_backup.initializer = readl(pwm_available_chan[0].pin_addr); 
-/*	pwm_available_chan[0].pin_mask.initializer = 0xffffffff; */ 
-	pwm_available_chan[0].pin_mask.s0.pin2_select = 0x07; 
-	pwm_available_chan[0].pin_current.s0.pin2_select = 0x02; 
- 
-	pwm_available_chan[0].pin_name = "PB2"; 
-	pwm_available_chan[0].period = 10000; 
-	pwm_available_chan[0].duty_percent = 100; 
-	*(unsigned int *)&pwm_available_chan[0].period_reg = 0; 
-	pwm_available_chan[0].prescale = 0; 
- 
- 
-	pwm_available_chan[1].use_count = 0; 
-	pwm_available_chan[1].ctrl_addr = PWM_CTRL_REG_BASE; 
-	pwm_available_chan[1].pin_addr = PI_CFG0_REG; 
-	pwm_available_chan[1].period_reg_addr = pwm_available_chan[1].ctrl_addr + 0x08; 
-	pwm_available_chan[1].channel = 1; 
-	pwm_available_chan[1].ctrl_backup.initializer = readl(pwm_available_chan[1].ctrl_addr); 
-	pwm_available_chan[1].ctrl_mask.initializer = 0; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_prescaler = 0x0f; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_en = 0x01; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_act_state = 0x01; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_clk_gating = 0x00; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_mode = 0x01; 
-	pwm_available_chan[1].ctrl_mask.s.ch1_pulse_start = 0x01; 
-	pwm_available_chan[1].ctrl_current.initializer = 0; 
-	pwm_available_chan[1].pin_backup.initializer = readl(pwm_available_chan[1].pin_addr); 
-	pwm_available_chan[1].pin_mask.initializer = 0; 
-	pwm_available_chan[1].pin_mask.s0.pin3_select = 0x07; 
-	pwm_available_chan[1].pin_current.s0.pin3_select = 0x02; 
-	pwm_available_chan[1].pin_name = "PI3"; 
-	pwm_available_chan[1].period = 10000; 
-	pwm_available_chan[1].duty_percent = 50; 
-	*(unsigned int *)&pwm_available_chan[1].period_reg = 0; 
-	pwm_available_chan[1].prescale = 0; 
- 
- 
-} 
- 
-struct pwm_device { 
-	struct sun4i_pwm_available_channel *chan; 
-}; 
- 
-struct pwm_device pwm_devices[2] = { 
-	[0] = {.chan = &pwm_available_chan[0]}, 
-	[1] = {.chan = &pwm_available_chan[1]} 
-}; 
- 
-struct pwm_device *pwm_request(int pwm_id, const char *label) 
-{ 
-	struct pwm_device *pwm; 
-	int found = 0; 
- 
-	if(pwm_id < 2 && pwm_id >= 0) { 
-		pwm = &pwm_devices[pwm_id]; 
-		found = 1; 
-	} 
-	if (found) { 
-		if (pwm->chan->use_count == 0) { 
-			pwm->chan->use_count++; 
-			pwm->chan->name = label; 
-		} else 
-			pwm = ERR_PTR(-EBUSY); 
-	} else 
-		pwm = ERR_PTR(-ENOENT); 
- 
-	return pwm; 
-} 
-EXPORT_SYMBOL(pwm_request); 
- 
- 
-int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) 
-{ 
-	if (pwm == NULL || period_ns == 0 || duty_ns > period_ns) 
-		return -EINVAL; 
- 
-	pwm->chan->period = period_ns / 1000; 
-	pwm->chan->prescale = pwm_get_best_prescale(pwm->chan->period); 
-	pwm->chan->duty = duty_ns / 1000; 
-	fixup_duty(pwm->chan); 
-	pwm_set_mode(NO_ENABLE_CHANGE,pwm->chan); 
-	return 0; 
-} 
-EXPORT_SYMBOL(pwm_config); 
- 
- 
-int pwm_enable(struct pwm_device *pwm) 
-{ 
-	if (pwm == NULL) { 
-		return -EINVAL; 
-	} 
-	pwm_set_mode(PWM_CTRL_ENABLE,pwm->chan); 
-	return 0; 
-} 
-EXPORT_SYMBOL(pwm_enable); 
- 
-void pwm_disable(struct pwm_device *pwm) 
-{ 
-	if (pwm == NULL) { 
-		return; 
-	} 
-	pwm_set_mode(PWM_CTRL_DISABLE,pwm->chan); 
-} 
-EXPORT_SYMBOL(pwm_disable); 
- 
-void pwm_free(struct pwm_device *pwm) 
-{ 
-	if (pwm->chan->use_count) { 
-		pwm->chan->use_count--; 
-	} else 
-		pr_warning("PWM device already freed\n"); 
-} 
-EXPORT_SYMBOL(pwm_free); 
- 
- 
-module_init(sunxi_pwm_init); 
-module_exit(sunxi_pwm_exit); 
- 
- 
- 
- 
-MODULE_LICENSE("GPL"); 
-MODULE_AUTHOR("David H. Wilkins <dwil...@conecuh.com>"); 
+	return active_cycles;
+}
+
+/*
+ * When the duty is set, compute the number of microseconds
+ * based on the period.
+ */
+
+void fixup_duty(struct sun4i_pwm_available_channel *chan) {
+	if(chan->duty_percent >= 0) {
+		chan->duty = chan->period * chan->duty_percent / 100;
+	}
+}
+
+/*
+ * Stores the run (enable) bit.
+ */
+
+static ssize_t pwm_run_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status = -EINVAL;
+	int enable = 0;
+
+	sscanf(buf,"%d",&enable);
+	if(enable < 2) {
+		status = pwm_set_mode(enable, chan);
+	}
+	return size;
+}
+
+static ssize_t pwm_duty_percent_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	unsigned int duty_percent = 0;
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+
+	sscanf(buf,"%u",&duty_percent);
+	if(duty_percent > 100) {
+		size = -EINVAL;
+	} else {
+		chan->duty_percent = duty_percent;
+		if(chan->period) {
+			fixup_duty(chan);
+			pwm_set_mode(NO_ENABLE_CHANGE,chan);
+		}
+	}
+
+	return size;
+}
+static ssize_t pwm_pulse_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t size) {
+	struct sun4i_pwm_available_channel *chan = dev_get_drvdata(dev);
+	ssize_t status = -EINVAL;
+	int pulse = 0;
+	sscanf(buf,"%d",&pulse);
+	if(pulse < 2) {
+		switch (chan->channel) {
+		case 0:
+			chan->ctrl_current.s.ch0_pulse_start = pulse;
+			break;
+		case 1:
+			chan->ctrl_current.s.ch1_pulse_start = pulse;
+			break;
+		default:
+			status = -EINVAL;
+			break;
+		}
+		status = size;
+	}
+	return status;
+}
+
+int pwm_set_period_and_duty(struct sun4i_pwm_available_channel *chan) {
+	int return_val = -EINVAL;
+	unsigned int entire_cycles = get_entire_cycles(chan);
+	unsigned int active_cycles = get_active_cycles(chan);
+	chan->period_reg.initializer = 0;
+	if(entire_cycles >= active_cycles && active_cycles) {
+		chan->period_reg.s.pwm_entire_cycles = entire_cycles;
+		chan->period_reg.s.pwm_active_cycles = active_cycles;
+	} else {
+		chan->period_reg.s.pwm_entire_cycles = MAX_CYCLES;
+		chan->period_reg.s.pwm_active_cycles = MAX_CYCLES;
+	}
+	writel(chan->period_reg.initializer, chan->period_reg_addr);
+	return return_val;
+}
+
+
+ssize_t pwm_set_mode(unsigned int enable, struct sun4i_pwm_available_channel *chan) {
+	ssize_t status = 0;
+	if(enable == NO_ENABLE_CHANGE) {
+		switch (chan->channel) {
+		case 0:
+			enable = chan->ctrl_current.s.ch0_en;
+			break;
+		case 1:
+			enable = chan->ctrl_current.s.ch1_en;
+			break;
+		default:
+			status = -EINVAL;
+			break;
+		}
+	}
+	chan->ctrl_current.initializer = readl(chan->ctrl_addr);
+	if(enable == 1) {
+		switch (chan->channel) {
+		case 0:
+			chan->ctrl_current.s.ch0_prescaler = 0;
+			chan->ctrl_current.s.ch0_act_state = 0;
+			chan->ctrl_current.s.ch0_mode = 0;
+			chan->ctrl_current.s.ch0_pulse_start = 0;
+			chan->ctrl_current.s.ch0_en = 0;
+			chan->ctrl_current.s.ch0_clk_gating = 0;
+			break;
+		case 1:
+			chan->ctrl_current.s.ch1_prescaler = 0;
+			chan->ctrl_current.s.ch1_act_state = 0;
+			chan->ctrl_current.s.ch1_mode = 0;
+			chan->ctrl_current.s.ch1_pulse_start = 0;
+			chan->ctrl_current.s.ch1_en = 1;
+			chan->ctrl_current.s.ch1_clk_gating = 0;
+			break;
+		default:
+			status = -EINVAL;
+			break;
+		}
+		if(status) {
+			return status;
+		}
+		//writel(chan->ctrl_current.initializer,chan->ctrl_addr);
+		chan->pin_current.initializer = readl(chan->pin_addr);
+		if(chan->pin_mask.s0.pin0_select) {
+			chan->pin_current.s0.pin0_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin1_select) {
+			chan->pin_current.s0.pin1_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin2_select) {
+			chan->pin_current.s0.pin2_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin3_select) {
+			chan->pin_current.s0.pin3_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin4_select) {
+			chan->pin_current.s0.pin4_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin5_select) {
+			chan->pin_current.s0.pin5_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin6_select) {
+			chan->pin_current.s0.pin6_select = SELECT_PWM;
+		}
+		if(chan->pin_mask.s0.pin7_select) {
+			chan->pin_current.s0.pin7_select = SELECT_PWM;
+		}
+		if(chan->channel == 0) {
+			chan->ctrl_current.s.ch0_prescaler = chan->prescale;
+		} else {
+			chan->ctrl_current.s.ch1_prescaler = chan->prescale;
+		}
+		pwm_set_period_and_duty(chan);
+
+		writel(chan->pin_current.initializer,chan->pin_addr);
+		//writel(chan->ctrl_current.initializer,chan->ctrl_addr);
+		switch (chan->channel) {
+		case 0:
+			chan->ctrl_current.s.ch0_en = 1;
+			chan->ctrl_current.s.ch0_clk_gating = 1;
+			break;
+		case 1:
+			chan->ctrl_current.s.ch1_en = 1;
+			chan->ctrl_current.s.ch1_clk_gating = 1;
+			break;
+		}
+		writel(chan->ctrl_current.initializer,chan->ctrl_addr);
+
+	} else if (enable == 0) {
+		switch (chan->channel) {
+		case 0:
+			chan->ctrl_current.s.ch0_clk_gating = 0;
+			chan->ctrl_current.s.ch0_en = enable;
+			break;
+		case 1:
+			chan->ctrl_current.s.ch1_clk_gating = 0;
+			chan->ctrl_current.s.ch1_en = enable;
+			break;
+		default:
+			status = -EINVAL;
+			break;
+		}
+		if(!status) {
+			chan->pin_current.initializer &= ~chan->pin_mask.initializer;
+			chan->pin_current.initializer |= readl(chan->pin_addr) & chan->pin_mask.initializer;
+			writel(chan->pin_current.initializer,chan->pin_addr);
+			writel(chan->ctrl_current.initializer,chan->ctrl_addr);
+		}
+	}
+	return status;
+}
+
+
+
+void pwm_setup_available_channels( void ) {
+	void * timer_base = ioremap(SW_PA_TIMERC_IO_BASE, 0x400);  /* 0x01c20c00 */
+	void * PWM_CTRL_REG_BASE = timer_base + 0x200;	     /* 0x01c20e00 */
+	void * portc_io_base = ioremap(SW_PA_PORTC_IO_BASE,0x400); /* 0x01c20800 */
+	void * PB_CFG0_REG = (portc_io_base + 0x24);	       /* 0x01C20824 */
+	void * PI_CFG0_REG = (portc_io_base + 0x120);	      /* 0x01c20920 */
+
+	/*void * PB_PULL0_REG = (portc_io_base + 0x040);*/	     /* 0x01c20840 */
+	/*void * PI_PULL0_REG = (portc_io_base + 0x13c);*/	     /* 0x01c2091c */
+	/*void * PH_CFG0_REG = (portc_io_base + 0xfc);*/	       /* 0x01c208fc */
+	/*void * PH_CFG1_REG = (portc_io_base + 0x100);*/	      /* 0x01c20900 */
+	/*void * PH_PULL0_REG = (portc_io_base + 0x118);*/	     /* 0x01c20918 */
+
+	pwm_available_chan[0].use_count = 0;
+	pwm_available_chan[0].ctrl_addr = PWM_CTRL_REG_BASE;
+	pwm_available_chan[0].pin_addr = PB_CFG0_REG;
+	pwm_available_chan[0].period_reg_addr = pwm_available_chan[0].ctrl_addr + 0x04;
+	pwm_available_chan[0].channel = 0;
+	pwm_available_chan[0].ctrl_backup.initializer = readl(pwm_available_chan[0].ctrl_addr);
+	pwm_available_chan[0].ctrl_mask.initializer = 0;
+	pwm_available_chan[0].ctrl_mask.s.ch0_prescaler = 0x0f;
+	pwm_available_chan[0].ctrl_mask.s.ch0_en = 0x01;
+	pwm_available_chan[0].ctrl_mask.s.ch0_act_state = 0x01;
+	pwm_available_chan[0].ctrl_mask.s.ch0_clk_gating = 0x00;
+	pwm_available_chan[0].ctrl_mask.s.ch0_mode = 0x01;
+	pwm_available_chan[0].ctrl_mask.s.ch0_pulse_start = 0x01;
+	pwm_available_chan[0].ctrl_current.initializer = 0;
+	pwm_available_chan[0].pin_backup.initializer = readl(pwm_available_chan[0].pin_addr);
+/*	pwm_available_chan[0].pin_mask.initializer = 0xffffffff; */
+	pwm_available_chan[0].pin_mask.s0.pin2_select = 0x07;
+	pwm_available_chan[0].pin_current.s0.pin2_select = 0x02;
+
+	pwm_available_chan[0].pin_name = "PB2";
+	pwm_available_chan[0].period = 10000;
+	pwm_available_chan[0].duty_percent = 100;
+	*(unsigned int *)&pwm_available_chan[0].period_reg = 0;
+	pwm_available_chan[0].prescale = 0;
+
+
+	pwm_available_chan[1].use_count = 0;
+	pwm_available_chan[1].ctrl_addr = PWM_CTRL_REG_BASE;
+	pwm_available_chan[1].pin_addr = PI_CFG0_REG;
+	pwm_available_chan[1].period_reg_addr = pwm_available_chan[1].ctrl_addr + 0x08;
+	pwm_available_chan[1].channel = 1;
+	pwm_available_chan[1].ctrl_backup.initializer = readl(pwm_available_chan[1].ctrl_addr);
+	pwm_available_chan[1].ctrl_mask.initializer = 0;
+	pwm_available_chan[1].ctrl_mask.s.ch1_prescaler = 0x0f;
+	pwm_available_chan[1].ctrl_mask.s.ch1_en = 0x01;
+	pwm_available_chan[1].ctrl_mask.s.ch1_act_state = 0x01;
+	pwm_available_chan[1].ctrl_mask.s.ch1_clk_gating = 0x00;
+	pwm_available_chan[1].ctrl_mask.s.ch1_mode = 0x01;
+	pwm_available_chan[1].ctrl_mask.s.ch1_pulse_start = 0x01;
+	pwm_available_chan[1].ctrl_current.initializer = 0;
+	pwm_available_chan[1].pin_backup.initializer = readl(pwm_available_chan[1].pin_addr);
+	pwm_available_chan[1].pin_mask.initializer = 0;
+	pwm_available_chan[1].pin_mask.s0.pin3_select = 0x07;
+	pwm_available_chan[1].pin_current.s0.pin3_select = 0x02;
+	pwm_available_chan[1].pin_name = "PI3";
+	pwm_available_chan[1].period = 10000;
+	pwm_available_chan[1].duty_percent = 50;
+	*(unsigned int *)&pwm_available_chan[1].period_reg = 0;
+	pwm_available_chan[1].prescale = 0;
+
+
+}
+
+struct pwm_device {
+	struct sun4i_pwm_available_channel *chan;
+};
+
+struct pwm_device pwm_devices[2] = {
+	[0] = {.chan = &pwm_available_chan[0]},
+	[1] = {.chan = &pwm_available_chan[1]}
+};
+
+struct pwm_device *pwm_request(int pwm_id, const char *label)
+{
+	struct pwm_device *pwm;
+	int found = 0;
+
+	if(pwm_id < 2 && pwm_id >= 0) {
+		pwm = &pwm_devices[pwm_id];
+		found = 1;
+	}
+	if (found) {
+		if (pwm->chan->use_count == 0) {
+			pwm->chan->use_count++;
+			pwm->chan->name = label;
+		} else
+			pwm = ERR_PTR(-EBUSY);
+	} else
+		pwm = ERR_PTR(-ENOENT);
+
+	return pwm;
+}
+EXPORT_SYMBOL(pwm_request);
+
+
+int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
+{
+	if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
+		return -EINVAL;
+
+	pwm->chan->period = period_ns / 1000;
+	pwm->chan->prescale = pwm_get_best_prescale(pwm->chan->period);
+	pwm->chan->duty = duty_ns / 1000;
+	fixup_duty(pwm->chan);
+	pwm_set_mode(NO_ENABLE_CHANGE,pwm->chan);
+	return 0;
+}
+EXPORT_SYMBOL(pwm_config);
+
+
+int pwm_enable(struct pwm_device *pwm)
+{
+	if (pwm == NULL) {
+		return -EINVAL;
+	}
+	pwm_set_mode(PWM_CTRL_ENABLE,pwm->chan);
+	return 0;
+}
+EXPORT_SYMBOL(pwm_enable);
+
+void pwm_disable(struct pwm_device *pwm)
+{
+	if (pwm == NULL) {
+		return;
+	}
+	pwm_set_mode(PWM_CTRL_DISABLE,pwm->chan);
+}
+EXPORT_SYMBOL(pwm_disable);
+
+void pwm_free(struct pwm_device *pwm)
+{
+	if (pwm->chan->use_count) {
+		pwm->chan->use_count--;
+	} else
+		pr_warning("PWM device already freed\n");
+}
+EXPORT_SYMBOL(pwm_free);
+
+
+module_init(sunxi_pwm_init);
+module_exit(sunxi_pwm_exit);
+
+
+
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("David H. Wilkins <dwil...@conecuh.com>");
-- 
1.9.1