[Armadeus-commitlog] armadeus branch, master, updated. release-3.2-240-g927b7a7
Brought to you by:
sszy
Menu
▾
▴
[Armadeus-commitlog] armadeus branch, master, updated. release-3.2-240-g927b7a7
|
From: Julien B a. A. <ar...@us...> - 2010-03-16 21:49:22
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "armadeus".
The branch, master has been updated
via 927b7a7bb2772e43c3c6d50d769ed9e8e09e3424 (commit)
via 578d824b8987307b5f4518381f9771cb87953fee (commit)
from 3548856d4e58383048ab017dbd71079720e3867f (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 927b7a7bb2772e43c3c6d50d769ed9e8e09e3424
Author: Julien Boibessot <jul...@ar...>
Date: Tue Mar 16 22:47:39 2010 +0100
Indentation
commit 578d824b8987307b5f4518381f9771cb87953fee
Author: Julien Boibessot <jul...@ar...>
Date: Tue Mar 16 10:15:55 2010 +0100
[LINUX] Add 24MHz external clock support to TSC210x
-----------------------------------------------------------------------
Summary of changes:
.../2.6.29/073-armadeus-tsc2102.patch | 16 +-
target/linux/modules/pwm/pwm.c | 335 ++++++++++----------
2 files changed, 183 insertions(+), 168 deletions(-)
diff --git a/buildroot/target/device/armadeus/linux/kernel-patches/2.6.29/073-armadeus-tsc2102.patch b/buildroot/target/device/armadeus/linux/kernel-patches/2.6.29/073-armadeus-tsc2102.patch
index d6d83b7..b70bfa7 100644
--- a/buildroot/target/device/armadeus/linux/kernel-patches/2.6.29/073-armadeus-tsc2102.patch
+++ b/buildroot/target/device/armadeus/linux/kernel-patches/2.6.29/073-armadeus-tsc2102.patch
@@ -4,7 +4,7 @@ DON'T EDIT IT OR YOUR MODIFICATIONS WILL BE LOST
Index: linux-2.6.29.6/include/linux/spi/tsc2102.h
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.29.6/include/linux/spi/tsc2102.h 2010-01-19 10:25:41.000000000 +0100
++++ linux-2.6.29.6/include/linux/spi/tsc2102.h 2010-02-24 15:11:28.000000000 +0100
@@ -0,0 +1,302 @@
+/*
+ * include/linux/spi/tsc2102.h
@@ -311,8 +311,8 @@ Index: linux-2.6.29.6/include/linux/spi/tsc2102.h
Index: linux-2.6.29.6/drivers/spi/tsc2102.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.29.6/drivers/spi/tsc2102.c 2010-01-19 11:19:57.000000000 +0100
-@@ -0,0 +1,1188 @@
++++ linux-2.6.29.6/drivers/spi/tsc2102.c 2010-03-15 12:06:23.000000000 +0100
+@@ -0,0 +1,1198 @@
+/*
+ * drivers/spi/tsc2102.c
+ *
@@ -884,6 +884,11 @@ Index: linux-2.6.29.6/drivers/spi/tsc2102.c
+ pll->pll2 = (PLL2_D_VAL(6448));
+ break;
+
++ case 24000000:
++ pll->pll1 = (PLL1_PLLEN | PLL1_Q_VAL(0) | PLL1_P_VAL(2) | PLL1_J_VAL(7));
++ pll->pll2 = (PLL2_D_VAL(5264));
++ break;
++
+ default:
+ pll->pll1 = 0x811c;
+ pll->pll2 = (PLL2_D_VAL(5462));
@@ -903,6 +908,11 @@ Index: linux-2.6.29.6/drivers/spi/tsc2102.c
+ pll->pll2 = (PLL2_D_VAL(1440));
+ break;
+
++ case 24000000:
++ pll->pll1 = (PLL1_PLLEN | PLL1_Q_VAL(0) | PLL1_P_VAL(2) | PLL1_J_VAL(8));
++ pll->pll2 = (PLL2_D_VAL(1920));
++ break;
++
+ default:
+ pll->pll1 = 0x8120;
+ pll->pll2 = (PLL2_D_VAL(1920));
diff --git a/target/linux/modules/pwm/pwm.c b/target/linux/modules/pwm/pwm.c
index 9de2847..2fca2ad 100644
--- a/target/linux/modules/pwm/pwm.c
+++ b/target/linux/modules/pwm/pwm.c
@@ -46,13 +46,12 @@
#include <linux/wait.h>
#include <linux/pm.h>
#include <linux/clk.h>
-/* For /sys */
#include <linux/sysdev.h>
/* For struct class */
#include <linux/device.h>
-/* For circular buffer */
#include <linux/circ_buf.h>
#include <linux/platform_device.h>
+
#include "pwm.h"
#ifdef CONFIG_ARCH_MX2
@@ -62,57 +61,57 @@
#define PWMSAMPLE (0x0c)
#define PWMPERIOD (0x10)
#define PWMCOUNTER (0x14)
-#define PWM_EN (1<<0)
-#define PWM_IRQEN (1<<0)
-#define PWM_SWR (1<<3)
-#define PWM_CLKSRC_MASK (3<<16)
-#define PWM_CLKSRC_IPG (2<<16)
-#define PWM_CLKSRC_32K (3<<16)
-#define PWM_REPEAT_MASK (3<<1)
-#define PWM_HCTR (1<<20)
-#define PWM_BCTR (1<<21)
-#define PWM_FWM_3 (2<<26)
-#define PWM_FIFOAV (7<<0)
-#define PWM_FIFO_EMPTY (1<<3)
-#define PWM_FWM (3<<26)
-#define PWM_REPEAT(x) (((x) & 0x03) << 1)
-#define PWM_CLKSEL_MASK (0)
+#define PWM_EN (1<<0)
+#define PWM_IRQEN (1<<0)
+#define PWM_SWR (1<<3)
+#define PWM_CLKSRC_MASK (3<<16)
+#define PWM_CLKSRC_IPG (2<<16)
+#define PWM_CLKSRC_32K (3<<16)
+#define PWM_REPEAT_MASK (3<<1)
+#define PWM_HCTR (1<<20)
+#define PWM_BCTR (1<<21)
+#define PWM_FWM_3 (2<<26)
+#define PWM_FIFOAV (7<<0)
+#define PWM_FIFO_EMPTY (1<<3)
+#define PWM_FWM (3<<26)
+#define PWM_REPEAT(x) (((x) & 0x03) << 1)
+#define PWM_CLKSEL_MASK (0)
#define PWM_PRESCALER_MASK 0x0000FFF0
#define PWM_PRESCALER(x) (((x-1) & 0xFFF) << 4)
#define PWM_PERIOD(x) ((x) & 0xFFFF)
-#define PWM_SAMPLE(x) ((x) & 0xFFFF)
-#define PWM_INT MXC_INT_PWM
-#define PWM_MAX_DEV 1
+#define PWM_SAMPLE(x) ((x) & 0xFFFF)
+#define PWM_INT MXC_INT_PWM
+#define PWM_MAX_DEV 1
-#define PWM_MIN_FREQUENCY 1 // Hz
-#define PWM_MAX_FREQUENCY 1000000 /* Hz */
+#define PWM_MIN_FREQUENCY 1 /* Hz */
+#define PWM_MAX_FREQUENCY 1000000 /* Hz */
#else
-#define PWMCTRL (0x00)
-#define PWMSTATUS (0x00)
-#define PWMIRQ (0x00)
-#define PWMSAMPLE (0x04)
-#define PWMPERIOD (0x08)
-#define PWMCOUNTER (0x0C)
-#define PWM_EN (1<<4)
-#define PWM_IRQEN PWMC_IRQEN
-#define PWM_SWR PWMC_SWR
-#define PWM_CLKSRC_MASK (1<<15)
-#define PWM_CLKSRC_IPG (0<<15)
-#define PWM_CLKSRC_32K (1<<15)
-#define PWM_FWM_3 (2<<26)
-#define PWM_FWM (3<<26)
-#define PWM_HCTR PWMC_HCTR
-#define PWM_BCTR PWMC_BCTR
-#define PWM_FIFOAV PWMC_FIFOAV
-#define PWM_REPEAT_MASK 0x0000000C
-#define PWM_CLKSEL_MASK 0x00000003
-#define PWM_REPEAT(x) PWMC_REPEAT(x)
+#define PWMCTRL (0x00)
+#define PWMSTATUS (0x00)
+#define PWMIRQ (0x00)
+#define PWMSAMPLE (0x04)
+#define PWMPERIOD (0x08)
+#define PWMCOUNTER (0x0C)
+#define PWM_EN (1<<4)
+#define PWM_IRQEN PWMC_IRQEN
+#define PWM_SWR PWMC_SWR
+#define PWM_CLKSRC_MASK (1<<15)
+#define PWM_CLKSRC_IPG (0<<15)
+#define PWM_CLKSRC_32K (1<<15)
+#define PWM_FWM_3 (2<<26)
+#define PWM_FWM (3<<26)
+#define PWM_HCTR PWMC_HCTR
+#define PWM_BCTR PWMC_BCTR
+#define PWM_FIFOAV PWMC_FIFOAV
+#define PWM_REPEAT_MASK 0x0000000C
+#define PWM_CLKSEL_MASK 0x00000003
+#define PWM_REPEAT(x) PWMC_REPEAT(x)
#define PWM_PRESCALER_MASK 0x00007F00
#define PWM_PRESCALER(x) PWMC_PRESCALER(x)
-#define PWM_PERIOD(x) PWMP_PERIOD(x)
-#define PWM_SAMPLE(x) PWMS_SAMPLE(x)
-#define PWM_MAX_DEV 1
+#define PWM_PERIOD(x) PWMP_PERIOD(x)
+#define PWM_SAMPLE(x) PWMS_SAMPLE(x)
+#define PWM_MAX_DEV 1
#define PWM_MIN_FREQUENCY 2 /* Hz */
#define PWM_MAX_FREQUENCY 1000000 /* Hz */
@@ -187,27 +186,29 @@ static struct class pwm_class; /* forward declaration only */
* Circular buffer handling four sound playing
***************************************************************/
-static inline u8 get_byte_from_circbuf( struct sound_circ_buf* abuffer )
+static inline u8 get_byte_from_circbuf(struct sound_circ_buf* abuffer)
{
- u8 b = abuffer->buf[ abuffer->read ];
+ u8 b = abuffer->buf[abuffer->read];
abuffer->read = (abuffer->read + 1) & (abuffer->size - 1);
+
return b;
}
-static inline u16 get_word_from_circbuf( struct sound_circ_buf* abuffer )
+static inline u16 get_word_from_circbuf(struct sound_circ_buf* abuffer)
{
u16 w = *((u16*)(&(abuffer->buf[ abuffer->read ])));
abuffer->read = (abuffer->read + 2) & (abuffer->size - 1);
+
return w;
}
-static inline void put_byte_to_circbuf( struct sound_circ_buf* abuffer, unsigned char abyte )
+static inline void put_byte_to_circbuf(struct sound_circ_buf* abuffer, unsigned char abyte)
{
- abuffer->buf[ abuffer->write ] = abyte;
+ abuffer->buf[abuffer->write] = abyte;
abuffer->write = (abuffer->write + 1) & (abuffer->size - 1);
}
-static inline void increase_circbuf( struct sound_circ_buf* abuffer, int count )
+static inline void increase_circbuf(struct sound_circ_buf* abuffer, int count)
{
abuffer->write = (abuffer->write + count) & (abuffer->size - 1);
pr_debug("Added %d bytes to buffer, now write is in pos %d\n", count, abuffer->write);
@@ -215,7 +216,7 @@ static inline void increase_circbuf( struct sound_circ_buf* abuffer, int count )
static int get_current_pwm_clk_rate(struct pwm_device *pwm)
{
- if( (readl(pwm->membase + PWMCTRL) & PWM_CLKSRC_MASK) == PWM_CLKSRC_32K)
+ if ((readl(pwm->membase + PWMCTRL) & PWM_CLKSRC_MASK) == PWM_CLKSRC_32K)
return 32768;
#ifdef CONFIG_ARCH_MX2
return clk_get_rate(pwm->clk);
@@ -240,21 +241,20 @@ static long get_pwm_max_freq(struct pwm_device *pwm)
static void compute_pwm_params(u32 req_freq, struct pwm_device *pwm)
{
u32 input_freq, divider;
+
input_freq = get_current_pwm_clk_rate(pwm);
// printk("input freq, %x %x\n", input_freq, req_freq);
divider = ((input_freq*10)/req_freq+5)/10;
- if( divider/65536 ){
+ if (divider/65536) {
pwm->entry.prescaler = divider/65536 +1;
pwm->entry.period = input_freq/(pwm->entry.prescaler*req_freq)-2;
- }
- else{
+ } else {
pwm->entry.period = divider-2;
pwm->entry.prescaler = 1;
}
}
-
/****************************************************************
*
***************************************************************/
@@ -271,15 +271,15 @@ static void write_bits(u32 bit, u32 mask, unsigned long reg)
static void setup_pwm_params(struct pwm_device *pwm)
{
- write_bits( PWM_CLKSRC_IPG, PWM_CLKSRC_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_CLKSRC_IPG, PWM_CLKSRC_MASK, pwm->membase + PWMCTRL);
/* Setup prescaler */
pr_debug("Updating PWM registers\n");
- write_bits( PWM_PRESCALER(pwm->entry.prescaler),
- PWM_PRESCALER_MASK, pwm->membase + PWMCTRL ); /*| PWMC_REPEAT(3)*/;
+ write_bits(PWM_PRESCALER(pwm->entry.prescaler),
+ PWM_PRESCALER_MASK, pwm->membase + PWMCTRL); /*| PWMC_REPEAT(3)*/;
/* Setup period */
- writel(PWM_PERIOD(pwm->entry.period) , pwm->membase + PWMPERIOD );
+ writel(PWM_PERIOD(pwm->entry.period), pwm->membase + PWMPERIOD);
/* Setup duty cycle */
- writel(PWM_SAMPLE( (u32) ((pwm->entry.period * pwm->duty) / 1000) ),
+ writel(PWM_SAMPLE((u32)((pwm->entry.period * pwm->duty) / 1000)),
pwm->membase + PWMSAMPLE);
}
@@ -292,11 +292,11 @@ static void setup_pwm_unit(struct pwm_device *pwm)
{
if (pwm->active) {
/* Activate PWM */
- write_bits( PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
setup_pwm_params(pwm);
} else {
/* De-activate */
- write_bits( ~PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(~PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
}
}
@@ -306,7 +306,7 @@ static int create_timer(pwm_timer_t *timer)
init_timer(timer->timer_blk_ptr);
timer->timer_blk_ptr->function = timer->timer_func;
- return(0);
+ return 0;
}
static int start_timer(pwm_timer_t *timer)
@@ -316,7 +316,7 @@ static int start_timer(pwm_timer_t *timer)
add_timer((struct timer_list *)timer->timer_blk_ptr);
- return(0);
+ return 0;
}
static int stop_timer(pwm_timer_t *timer)
@@ -324,16 +324,16 @@ static int stop_timer(pwm_timer_t *timer)
timer->stop_flag = 1;
del_timer_sync((struct timer_list *)timer->timer_blk_ptr);
- return(0);
+ return 0;
}
static void stop_pwm(struct pwm_device *pwm)
{
- write_bits( ~PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ );
- write_bits( ~PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(~PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ);
+ write_bits(~PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
pwm->sampleValue = 0;
- if(pwm->mode == PWM_TONE_MODE)
+ if (pwm->mode == PWM_TONE_MODE)
stop_timer(&pwm->timer);
/* Can release file now */
@@ -347,7 +347,7 @@ static void pwmIntFunc( unsigned long unused)
{
// u32 period;
- PK("<1>pwm sam int\n");
+ PK("<1>pwm sam int\n");
// if (gWriteCnt > 0)
// {
@@ -374,11 +374,11 @@ static void pwmIntFunc( unsigned long unused)
static int init_pwm(struct pwm_device *pwm)
{
/* Software reset */
- write_bits( PWM_SWR, PWM_SWR, pwm->membase + PWMCTRL );
+ write_bits(PWM_SWR, PWM_SWR, pwm->membase + PWMCTRL);
udelay(10);
/* Activate & de-activate PWM (seems to be necessary after a reset) */
- write_bits( PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
- write_bits( ~PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
+ write_bits(~PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
return 1;
}
@@ -393,15 +393,16 @@ int pwm_release(struct inode * inode, struct file * filp)
interruptible_sleep_on(&pwm->exit_wait);
if (pwm->mode == PWM_PLAY_MODE) {
/* disable IRQ */
- write_bits( ~PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ);
+ write_bits(~PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ);
}
- write_bits( ~PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(~PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
- if( pwm->circ_buf.buf ) {
- kfree( pwm->circ_buf.buf );
+ if (pwm->circ_buf.buf) {
+ kfree(pwm->circ_buf.buf);
pwm->circ_buf.buf = 0;
}
printk(DRIVER_NAME " released, 4 bytes FIFO usage: %d\n", pwm->nbbytes);
+
return 0;
}
@@ -416,6 +417,7 @@ int pwm_open(struct inode * inode, struct file * filp)
init_pwm(pwm);
pr_debug(DRIVER_NAME " opened \n");
+
return 0;
}
@@ -467,36 +469,36 @@ int pwm_ioctl(struct inode * inode, struct file *filp, unsigned int cmd, unsigne
{
/*int clock = get_current_pwm_clk_rate(pwm);*/
/* Disable PWM */
- write_bits( ~PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(~PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
/* if(!( (clock >= 16000000) && (clock<17000000))){
printk("audio playback works only with a 16MHz input clock %d!\n",
get_current_pwm_clk_rate(pwm));
break;
}*/
- write_bits( PWM_CLKSRC_IPG, PWM_CLKSRC_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_CLKSRC_IPG, PWM_CLKSRC_MASK, pwm->membase + PWMCTRL);
#ifdef CONFIG_ARCH_MX2
- write_bits( PWM_PRESCALER(2),PWM_PRESCALER_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_PRESCALER(2), PWM_PRESCALER_MASK, pwm->membase + PWMCTRL);
#else
- write_bits( PWM_PRESCALER(1),PWM_PRESCALER_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_PRESCALER(1), PWM_PRESCALER_MASK, pwm->membase + PWMCTRL);
#endif
- switch(arg)
- {
+ switch (arg) {
case PWM_SAMPLING_32KHZ:
/* REPEAT = 0 => divide by 1 */
- write_bits( 0, PWM_REPEAT_MASK, pwm->membase + PWMCTRL );
+ write_bits(0, PWM_REPEAT_MASK, pwm->membase + PWMCTRL);
str = "32Khz";
break;
+
case PWM_SAMPLING_16KHZ:
/* REPEAT = 01 => divide by 2 */
- write_bits( PWM_REPEAT(1), PWM_REPEAT_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_REPEAT(1), PWM_REPEAT_MASK, pwm->membase + PWMCTRL);
str = "16Khz";
break;
case PWM_SAMPLING_8KHZ:
default:
/* REPEAT = 10 => divide by 4*/
- write_bits( PWM_REPEAT(2), PWM_REPEAT_MASK, pwm->membase + PWMCTRL );
+ write_bits(PWM_REPEAT(2), PWM_REPEAT_MASK, pwm->membase + PWMCTRL);
str = "8Khz";
break;
}
@@ -525,8 +527,7 @@ int pwm_ioctl(struct inode * inode, struct file *filp, unsigned int cmd, unsigne
break;
case PWM_IOC_SPERIOD:
- if (pwm->mode == PWM_TONE_MODE)
- {
+ if (pwm->mode == PWM_TONE_MODE) {
PK("<1>PWM period = %d\n",(int)arg);
pwm->timer.period = arg/12;
}
@@ -537,22 +538,22 @@ int pwm_ioctl(struct inode * inode, struct file *filp, unsigned int cmd, unsigne
break;
case PWM_IOC_SWAPDATA:
- if (arg&PWM_SWAP_HCTRL) { /* Halfword FIFO data swapping */
- write_bits( PWM_REPEAT(1), PWM_REPEAT_MASK, pwm->membase + PWMCTRL );
- write_bits( PWM_HCTR, PWM_HCTR, pwm->membase + PWMCTRL );
+ if (arg & PWM_SWAP_HCTRL) { /* Halfword FIFO data swapping */
+ write_bits(PWM_REPEAT(1), PWM_REPEAT_MASK, pwm->membase + PWMCTRL);
+ write_bits(PWM_HCTR, PWM_HCTR, pwm->membase + PWMCTRL);
} else {
- write_bits( ~PWM_HCTR, PWM_HCTR, pwm->membase + PWMCTRL );
+ write_bits(~PWM_HCTR, PWM_HCTR, pwm->membase + PWMCTRL);
}
if (arg & PWM_SWAP_BCTRL) { /* Byte FIFO data swapping */
- write_bits( PWM_BCTR, PWM_BCTR, pwm->membase + PWMCTRL );
+ write_bits(PWM_BCTR, PWM_BCTR, pwm->membase + PWMCTRL);
} else {
- write_bits( ~PWM_BCTR, PWM_BCTR, pwm->membase + PWMCTRL );
+ write_bits(~PWM_BCTR, PWM_BCTR, pwm->membase + PWMCTRL);
}
break;
default:
- printk( DRIVER_NAME ": unkown IOCTL\n");
+ printk(DRIVER_NAME ": unkown IOCTL\n");
break;
}
@@ -581,13 +582,13 @@ static ssize_t pwm_write( struct file *filp, const char *buf, size_t count, loff
struct pwm_device *pwm = dev_table[iminor(filp->f_dentry->d_inode)];
struct sound_circ_buf *circ = &pwm->circ_buf;
- pr_debug( "pwm_write ----\n" );
+ pr_debug("pwm_write ----\n");
if (count > MAX_SOUND_BUFFER_SIZE)
count = MAX_SOUND_BUFFER_SIZE;
/* First time, allocate the double buffer */
if (!circ->buf) {
- circ->buf = kmalloc( MAX_SOUND_BUFFER_SIZE*2, GFP_KERNEL );
+ circ->buf = kmalloc(MAX_SOUND_BUFFER_SIZE*2, GFP_KERNEL);
if (!circ->buf) {
goto out;
} else {
@@ -604,17 +605,18 @@ static ssize_t pwm_write( struct file *filp, const char *buf, size_t count, loff
pr_debug("Remaining space to end: %d, must write: %d \n", remaining_space, count);
if (remaining_space >= count) {
// Get data from UserSpace
- if( copy_from_user( circ->buf + circ->write , buf, count ) ) {
- ret = -EFAULT; goto out;
+ if (copy_from_user(circ->buf + circ->write, buf, count)) {
+ ret = -EFAULT;
+ goto out;
}
- increase_circbuf( &pwm->circ_buf, count );
+ increase_circbuf(&pwm->circ_buf, count);
/* if not enough space, then */
} else {
/* Do it in 2 times */
if (copy_from_user(circ->buf + circ->write, buf, remaining_space)) {
ret = -EFAULT; goto out;
}
- increase_circbuf( &pwm->circ_buf, remaining_space );
+ increase_circbuf(&pwm->circ_buf, remaining_space);
if (copy_from_user(circ->buf + circ->write, buf, count - remaining_space)) {
ret = -EFAULT; goto out;
}
@@ -623,19 +625,19 @@ static ssize_t pwm_write( struct file *filp, const char *buf, size_t count, loff
if (pwm->mode == PWM_PLAY_MODE) {
/* Enable IRQ */
- write_bits( PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ);
+ write_bits(PWM_IRQEN, PWM_IRQEN, pwm->membase + PWMIRQ);
} else {
- writel(pwm->sampleValue, pwm->membase + PWMSAMPLE);
+ writel(pwm->sampleValue, pwm->membase + PWMSAMPLE);
/* set prescaler to the max */
- write_bits(PWM_PRESCALER(0xffff) , PWM_PRESCALER_MASK, pwm->membase + PWMCTRL);
+ write_bits(PWM_PRESCALER(0xffff), PWM_PRESCALER_MASK, pwm->membase + PWMCTRL);
/*writeBufPtr16 = (u16*)gpWriteBuf;
gWriteCnt /= 2; //input size is 8bit size, need /2 to get 16bit size
StartTimer( &timer );*/
}
- writel(0x00000000, pwm->membase + PWMSAMPLE);
- write_bits( PWM_FWM_3 , PWM_FWM, pwm->membase + PWMCTRL );
+ writel(0x00000000, pwm->membase + PWMSAMPLE);
+ write_bits(PWM_FWM_3, PWM_FWM, pwm->membase + PWMCTRL);
/* Enable PWM */
- write_bits( PWM_EN, PWM_EN, pwm->membase + PWMCTRL );
+ write_bits(PWM_EN, PWM_EN, pwm->membase + PWMCTRL);
/* Calculate how much space is left in buffer */
remaining_space = CIRC_SPACE(circ->write, circ->read, circ->size);
@@ -646,7 +648,7 @@ static ssize_t pwm_write( struct file *filp, const char *buf, size_t count, loff
}
out:
- pr_debug( "out pwm_write PWMC = 0x%8x ----\n", readl(pwm->membase + PWMCTRL ));
+ pr_debug("out pwm_write PWMC = 0x%8x ----\n", readl(pwm->membase + PWMCTRL));
return count;
}
@@ -672,7 +674,7 @@ static ssize_t pwm_show_duty(struct device *dev, struct device_attribute *attr,
ssize_t ret_size = 0;
struct pwm_device *pwm = to_pwm_device(dev);
- ret_size=sprintf(buf,"%u",pwm->duty);
+ ret_size=sprintf(buf, "%u", pwm->duty);
return ret_size;
}
@@ -699,7 +701,7 @@ static ssize_t pwm_store_duty(struct device *dev, struct device_attribute *attr,
if ((value < 1) || (value > 999))
return -EIO;
- pwm->duty=(unsigned)value;
+ pwm->duty = (unsigned)value;
setup_pwm_unit(pwm);
return size;
@@ -715,7 +717,7 @@ static ssize_t pwm_show_period(struct device *dev, struct device_attribute *attr
ssize_t ret_size = 0;
struct pwm_device *pwm = to_pwm_device(dev);
- ret_size=sprintf(buf,"%d",pwm->entry.period);
+ ret_size = sprintf(buf, "%d", pwm->entry.period);
return ret_size;
}
@@ -734,12 +736,13 @@ static ssize_t pwm_store_period(struct device *dev, struct device_attribute *att
long value/*,i*/;
struct pwm_device *pwm = to_pwm_device(dev);
- value = simple_strtol(buf, NULL, 10); // in us
+ value = simple_strtol(buf, NULL, 10); /* in us */
if ((value < (1000000/get_pwm_max_freq(pwm))) || (value > (1000000/get_pwm_min_freq(pwm))))
return -EIO;
compute_pwm_params(1000000/value, pwm);
setup_pwm_unit(pwm);
+
return size;
}
@@ -754,9 +757,9 @@ static ssize_t pwm_show_frequency(struct device *dev, struct device_attribute *a
struct pwm_device *pwm = to_pwm_device(dev);
if (pwm->entry.period)
- ret_size = sprintf(buf,"%d", (u32) 1000000/(pwm->entry.period));
+ ret_size = sprintf(buf, "%d", (u32) 1000000/(pwm->entry.period));
else
- ret_size = sprintf(buf,"0");
+ ret_size = sprintf(buf, "0");
return ret_size;
}
@@ -779,13 +782,13 @@ static ssize_t pwm_store_frequency(struct device *dev, struct device_attribute *
struct pwm_device *pwm = to_pwm_device(dev);
value = simple_strtol(buf, NULL, 10);
- if( (value < get_pwm_min_freq(pwm)) || (value > get_pwm_max_freq(pwm)) )
+ if ((value < get_pwm_min_freq(pwm)) || (value > get_pwm_max_freq(pwm)))
return -EIO;
compute_pwm_params(value, pwm);
setup_pwm_unit(pwm);
- return( size );
+ return size;
}
/**
@@ -798,7 +801,7 @@ static ssize_t pwm_show_state(struct device *dev, struct device_attribute *attr,
ssize_t ret_size = 0;
struct pwm_device *pwm = to_pwm_device(dev);
- ret_size=sprintf(buf,"%d",pwm->active);
+ ret_size = sprintf(buf, "%d", pwm->active);
return ret_size;
}
@@ -818,9 +821,9 @@ static ssize_t pwm_store_state(struct device *dev, struct device_attribute *attr
value = simple_strtol(buf, NULL, 10);
if (value != 0)
- pwm->active=1;
+ pwm->active = 1;
else
- pwm->active=0;
+ pwm->active = 0;
setup_pwm_unit(pwm);
@@ -868,23 +871,23 @@ static irqreturn_t pwm_interrupt(int irq, void *dev_id)
#else
status = readl(pwm->membase + PWMSTATUS);
#endif
- remaining = CIRC_CNT( pwm->circ_buf.write, pwm->circ_buf.read, pwm->circ_buf.size );
- if( remaining <= 1024 && remaining > 1021 ) { // TODO make it better (I think a test each consumed sample is the only accurate solution
- // Can accept new data now
- wake_up_interruptible( &pwm->write_wait );
+ remaining = CIRC_CNT(pwm->circ_buf.write, pwm->circ_buf.read, pwm->circ_buf.size);
+ if (remaining <= 1024 && remaining > 1021) { /* TODO make it better (I think a test each consumed sample is the only accurate solution */
+ /* Can accept new data now */
+ wake_up_interruptible(&pwm->write_wait);
}
/* End of sound buffer */
- if( remaining < 3 ) {
- if(pwm->dataLen == PWM_DATA_8BIT) {
- while( remaining ) {
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ if (remaining < 3) {
+ if (pwm->dataLen == PWM_DATA_8BIT) {
+ while (remaining) {
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
/*PK("<1>(%d) pwm_int: PWMS = 0x%8x\n", gWriteCnt, PWMS);*/
remaining--;
}
} else { /* PWM_DATA_16BIT) */
- while( remaining ) {
- writel( (u32)(get_word_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ while (remaining) {
+ writel((u32)(get_word_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
//PK("<1>(%d) pwm_int: PWMS = 0x%8x\n", gWriteCnt, PWMS);
remaining--;
}
@@ -895,31 +898,31 @@ static irqreturn_t pwm_interrupt(int irq, void *dev_id)
/* Put sound samples in FIFO */
if (pwm->dataLen == PWM_DATA_8BIT) {
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
#ifdef CONFIG_ARCH_MX2
if ((readl(pwm->membase + PWMSTATUS) & PWM_FIFOAV) == 3) { /* TODO: verify if needed */
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
}
#else
if ((readl(pwm->membase + PWMSTATUS) & PWM_FIFOAV) > 0) { /* TODO: verify if needed */
- writel( (u32)(get_byte_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_byte_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
}
#endif
} else { /* PWM_DATA_16BIT) */
// TODO: put good value in PWMC_BCTR to auto swap bytes if needed (do it at write or ioctl)
- writel( (u32)(get_word_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
- writel( (u32)(get_word_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
- writel( (u32)(get_word_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_word_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_word_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_word_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
if ((readl(pwm->membase + PWMSTATUS) & PWM_FIFOAV) > 0) { /* TODO: verify if needed */
- writel( (u32)(get_word_from_circbuf( &pwm->circ_buf )), pwm->membase + PWMSAMPLE);
+ writel((u32)(get_word_from_circbuf(&pwm->circ_buf)), pwm->membase + PWMSAMPLE);
pwm->nbbytes++;
}
}
end:
- return(IRQ_HANDLED);
+ return IRQ_HANDLED;
}
/**
@@ -933,12 +936,12 @@ static int imx_pwm_drv_probe(struct platform_device *pdev)
struct pwm_device *pwm;
struct imx_pwm_platform_data *pdata = pdev->dev.platform_data;
- printk(KERN_INFO " Initializing PWM#%u...",pdev->id);
+ printk(KERN_INFO "Initializing PWM%u...", pdev->id);
- if( pdev->id >= PWM_MAX_DEV )
+ if (pdev->id >= PWM_MAX_DEV)
printk(DRIVER_NAME " failed. Unknown PWM%u device. Remember that this device only supports %d PWM\n", pdev->id, PWM_MAX_DEV);
- if ( dev_table[pdev->id] != NULL ) {
+ if (dev_table[pdev->id] != NULL) {
printk(KERN_ERR ": already used\n");
return -ENODEV;
}
@@ -955,9 +958,9 @@ static int imx_pwm_drv_probe(struct platform_device *pdev)
pwm->class_dev.class = &pwm_class;
pwm->class_dev.parent = &pdev->dev;
snprintf(pwm->class_dev.bus_id, BUS_ID_SIZE, "pwm%i", pdev->id);
- pwm->active=0;
- pwm->duty=500; /* = 50.O% */
- pdev->dev.driver_data=pwm;
+ pwm->active = 0;
+ pwm->duty = 500; /* = 50.O% */
+ pdev->dev.driver_data = pwm;
dev_table[pdev->id] = pwm;
pwm->irq = platform_get_irq(pdev, 0);
@@ -967,13 +970,13 @@ static int imx_pwm_drv_probe(struct platform_device *pdev)
goto error_malloc;
}
- if (unlikely(!(res = platform_get_resource(pdev, IORESOURCE_MEM, 0)))){
+ if (unlikely(!(res = platform_get_resource(pdev, IORESOURCE_MEM, 0)))) {
printk(KERN_ERR "Unable to get mem ressource\n");
err = -ENOENT;
goto error_malloc;
}
- if (unlikely(!request_mem_region( res->start, res->end - res->start + 1, DRIVER_NAME ))) {
+ if (unlikely(!request_mem_region(res->start, res->end - res->start + 1, DRIVER_NAME))) {
printk(KERN_ERR "Region busy\n");
err = -EBUSY;
goto error_malloc;
@@ -990,7 +993,7 @@ static int imx_pwm_drv_probe(struct platform_device *pdev)
/* Dynamic Major allocation */
if (gMajor == 0) {
gMajor = err;
- printk("PWM major number = %d\n",gMajor);
+ printk("PWM major number = %d\n", gMajor);
}
err = request_irq(pwm->irq, pwm_interrupt, IRQF_DISABLED, DRIVER_NAME, pwm);
@@ -1033,13 +1036,13 @@ static int imx_pwm_drv_probe(struct platform_device *pdev)
init_pwm(pwm);
printk("i.MX PWM driver v" DRIVER_VERSION "\n");
- return(0);
+ return 0;
error_file:
printk(KERN_ERR "%s: class /sys file creation failed\n", DRIVER_NAME);
unregister_sys_file(pwm);
error_register:
- device_unregister( &pwm->class_dev );
+ device_unregister(&pwm->class_dev);
error_irq:
free_irq(pwm->irq, pwm);
error_chrdev:
@@ -1051,13 +1054,13 @@ error_malloc:
return err;
}
-static inline void unregister_sys_file( struct pwm_device *pwm )
+static inline void unregister_sys_file(struct pwm_device *pwm)
{
/* Unregister /sys attributes */
- device_remove_file( &pwm->class_dev, &dev_attr_active );
- device_remove_file( &pwm->class_dev, &dev_attr_period );
- device_remove_file( &pwm->class_dev, &dev_attr_frequency );
- device_remove_file( &pwm->class_dev, &dev_attr_duty );
+ device_remove_file(&pwm->class_dev, &dev_attr_active);
+ device_remove_file(&pwm->class_dev, &dev_attr_period);
+ device_remove_file(&pwm->class_dev, &dev_attr_frequency);
+ device_remove_file(&pwm->class_dev, &dev_attr_duty);
}
/**
@@ -1071,15 +1074,16 @@ static int imx_pwm_drv_remove (struct platform_device *pdev)
struct imx_pwm_platform_data *pdata = pdev->dev.platform_data;
unregister_sys_file(pwm);
- device_unregister( &pwm->class_dev );
+ device_unregister(&pwm->class_dev);
free_irq(pwm->irq, pwm);
unregister_chrdev(gMajor, DRIVER_NAME);
- res = platform_get_resource( pdev, IORESOURCE_MEM, 0 );
- release_mem_region( res->start, res->end - res->start + 1 );
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ release_mem_region(res->start, res->end - res->start + 1);
kfree(pwm);
dev_table[pdev->id] = NULL;
- if( pdata->exit() )
+ if (pdata->exit())
pdata->exit();
+
return 0;
}
@@ -1096,7 +1100,7 @@ static int imx_pwm_drv_suspend (struct platform_device *pdev, pm_message_t state
clk_disable(pwm->clk);
dev_dbg(&pdev->dev, "suspended\n");
- if( pdata->exit() )
+ if (pdata->exit())
pdata->exit();
return 0;
@@ -1108,13 +1112,14 @@ static int imx_pwm_drv_suspend (struct platform_device *pdev, pm_message_t state
*/
static int imx_pwm_drv_resume (struct platform_device *pdev)
{
- struct pwm_device *pwm=(struct pwm_device*)pdev->dev.driver_data;
+ struct pwm_device *pwm = (struct pwm_device*)pdev->dev.driver_data;
struct imx_pwm_platform_data *pdata = pdev->dev.platform_data;
clk_enable(pwm->clk);
dev_dbg(&pdev->dev, "resumed\n");
- if( pdata->init() )
+ if (pdata->init())
pdata->init();
+
return 0;
}
#else
@@ -1162,8 +1167,6 @@ static int __init imx_pwm_init(void)
{
int ret;
- printk(KERN_INFO "Initializing PWM class.\n");
-
if (unlikely((ret = class_register(&pwm_class)))) {
printk(KERN_ERR "%s: couldn't register class, exiting\n", DRIVER_NAME);
return ret;
@@ -1192,11 +1195,12 @@ out_sysdev_class:
static void __exit imx_pwm_exit(void)
{
int i;
+
platform_driver_unregister(&imx_pwm_driver);
sysdev_unregister(&pwm_sys_device);
sysdev_class_unregister(&pwm_sysclass);
class_unregister(&pwm_class);
- for(i=0; i<PWM_MAX_DEV; i++)
+ for (i=0; i<PWM_MAX_DEV; i++)
dev_table[i] = NULL;
printk(DRIVER_NAME " successfully unloaded\n");
}
@@ -1206,3 +1210,4 @@ module_exit(imx_pwm_exit);
MODULE_AUTHOR("Julien Boibessot & Sebastien Royen, inspired by a lot of other PWM drivers");
MODULE_DESCRIPTION("i.MX PWM driver");
MODULE_LICENSE("GPL");
+
hooks/post-receive
--
armadeus
|
