omap24xx_i2c: Set/get bus num and speed
authorPaul Kocialkowski <contact@paulk.fr>
Mon, 1 Sep 2014 20:59:42 +0000 (22:59 +0200)
committerPaul Kocialkowski <contact@paulk.fr>
Mon, 1 Sep 2014 21:01:26 +0000 (23:01 +0200)
Signed-off-by: Paul Kocialkowski <contact@paulk.fr>
drivers/omap24xx_i2c.c
include/asm/arch-omap3/i2c.h
include/i2c.h

index 1198fa2..8f238bf 100644 (file)
 #include <asm/arch/i2c.h>
 #include <asm/io.h>
 
-#define inb(a) __raw_readb(a)
-#define outb(a,v) __raw_writeb(a,v)
-#define inw(a) __raw_readw(a)
-#define outw(a,v) __raw_writew(a,v)
-
 static void wait_for_bb (void);
 static u16 wait_for_pin (void);
 static void flush_fifo(void);
 
+u32 i2c_base = I2C_DEFAULT_BASE;
+unsigned int i2c_speed = CFG_I2C_SPEED;
+
+u8 i2c_readb (u32 reg)
+{
+       return __raw_readb(i2c_base + reg);
+}
+
+u16 i2c_readw (u32 reg)
+{
+       return __raw_readw(i2c_base + reg);
+}
+
+u32 i2c_readl (u32 reg)
+{
+       return __raw_readl(i2c_base + reg);
+}
+
+void i2c_writeb (u8 value, u32 reg)
+{
+       __raw_writeb(value, i2c_base + reg);
+}
+
+void i2c_writew (u16 value, u32 reg)
+{
+       __raw_writew (value, i2c_base + reg);
+}
+
+void i2c_writel (u32 value, u32 reg)
+{
+       __raw_writel (value, i2c_base + reg);
+}
+
 void i2c_init (int speed, int slaveadd)
 {
        u16 scl;
 
-       outw(0x2, I2C_SYSC); /* for ES2 after soft reset */
+       i2c_writew(0x2, I2C_SYSC); /* for ES2 after soft reset */
        udelay(1000);
-       outw(0x0, I2C_SYSC); /* will probably self clear but */
+       i2c_writew(0x0, I2C_SYSC); /* will probably self clear but */
 
-       if (inw (I2C_CON) & I2C_CON_EN) {
-               outw (0, I2C_CON);
+       if (i2c_readw (I2C_CON) & I2C_CON_EN) {
+               i2c_writew (0, I2C_CON);
                udelay (50000);
        }
 
        /* 12Mhz I2C module clock */
-       outw (0, I2C_PSC);
+       i2c_writew (0, I2C_PSC);
        speed = speed/1000;                 /* 100 or 400 */
        scl = ((12000/(speed*2)) - 7);
-       outw (scl, I2C_SCLL);
+       i2c_writew (scl, I2C_SCLL);
        scl = ((12000/(speed*2)) - 5);
-       outw (scl, I2C_SCLH);
+       i2c_writew (scl, I2C_SCLH);
        /* own address */
-       outw (slaveadd, I2C_OA);
-       outw (I2C_CON_EN, I2C_CON);
+       i2c_writew (slaveadd, I2C_OA);
+       i2c_writew (I2C_CON_EN, I2C_CON);
 
        /* have to enable intrrupts or OMAP i2c module doesn't work */
-       outw (I2C_IE_XRDY_IE | I2C_IE_RRDY_IE | I2C_IE_ARDY_IE |
+       i2c_writew (I2C_IE_XRDY_IE | I2C_IE_RRDY_IE | I2C_IE_ARDY_IE |
              I2C_IE_NACK_IE | I2C_IE_AL_IE, I2C_IE);
        udelay (1000);
        flush_fifo();
-       outw (0xFFFF, I2C_STAT);
-       outw (0, I2C_CNT);
+       i2c_writew (0xFFFF, I2C_STAT);
+       i2c_writew (0, I2C_CNT);
 }
 
 static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
@@ -78,19 +106,18 @@ static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
        wait_for_bb ();
 
        /* one byte only */
-       outw (1, I2C_CNT);
+       i2c_writew (1, I2C_CNT);
        /* set slave address */
-       outw (devaddr, I2C_SA);
+       i2c_writew (devaddr, I2C_SA);
        /* no stop bit needed here */
-       outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX, I2C_CON);
+       i2c_writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX, I2C_CON);
 
        status = wait_for_pin ();
 
        if (status & I2C_STAT_XRDY) {
-               /* Important: have to use byte access */
-               *(volatile u8 *) (I2C_DATA) = regoffset;
+               i2c_writeb (regoffset, I2C_DATA);
                udelay (20000);
-               if (inw (I2C_STAT) & I2C_STAT_NACK) {
+               if (i2c_readw (I2C_STAT) & I2C_STAT_NACK) {
                        i2c_error = 1;
                }
        } else {
@@ -99,28 +126,28 @@ static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
 
        if (!i2c_error) {
                /* free bus, otherwise we can't use a combined transction */
-               outw (0, I2C_CON);
-               while (inw (I2C_STAT) || (inw (I2C_CON) & I2C_CON_MST)) {
+               i2c_writew (0, I2C_CON);
+               while (i2c_readw (I2C_STAT) || (i2c_readw (I2C_CON) & I2C_CON_MST)) {
                        udelay (10000);
                        /* Have to clear pending interrupt to clear I2C_STAT */
-                       outw (0xFFFF, I2C_STAT);
+                       i2c_writew (0xFFFF, I2C_STAT);
                }
 
                wait_for_bb ();
                /* set slave address */
-               outw (devaddr, I2C_SA);
+               i2c_writew (devaddr, I2C_SA);
                /* read one byte from slave */
-               outw (1, I2C_CNT);
+               i2c_writew (1, I2C_CNT);
                /* need stop bit here */
-               outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP,
+               i2c_writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP,
                      I2C_CON);
 
                status = wait_for_pin ();
                if (status & I2C_STAT_RRDY) {
 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
-                        *value = inb(I2C_DATA);
+                        *value = i2c_readb(I2C_DATA);
 #else
-                        *value = inw(I2C_DATA);
+                        *value = i2c_readw(I2C_DATA);
 #endif
                        udelay (20000);
                } else {
@@ -128,17 +155,17 @@ static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
                }
 
                if (!i2c_error) {
-                       outw (I2C_CON_EN, I2C_CON);
-                       while (inw (I2C_STAT)
-                              || (inw (I2C_CON) & I2C_CON_MST)) {
+                       i2c_writew (I2C_CON_EN, I2C_CON);
+                       while (i2c_readw (I2C_STAT)
+                              || (i2c_readw (I2C_CON) & I2C_CON_MST)) {
                                udelay (10000);
-                               outw (0xFFFF, I2C_STAT);
+                               i2c_writew (0xFFFF, I2C_STAT);
                        }
                }
        }
        flush_fifo();
-       outw (0xFFFF, I2C_STAT);
-       outw (0, I2C_CNT);
+       i2c_writew (0xFFFF, I2C_STAT);
+       i2c_writew (0, I2C_CNT);
        return i2c_error;
 }
 
@@ -151,11 +178,11 @@ static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value)
        wait_for_bb ();
 
        /* two bytes */
-       outw (2, I2C_CNT);
+       i2c_writew (2, I2C_CNT);
        /* set slave address */
-       outw (devaddr, I2C_SA);
+       i2c_writew (devaddr, I2C_SA);
        /* stop bit needed here */
-       outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX |
+       i2c_writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX |
              I2C_CON_STP, I2C_CON);
 
        /* wait until state change */
@@ -164,24 +191,24 @@ static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value)
        if (status & I2C_STAT_XRDY) {
 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
                 /* send out 1 byte */
-                outb(regoffset, I2C_DATA);
-                outw(I2C_STAT_XRDY, I2C_STAT);
+                i2c_writeb(regoffset, I2C_DATA);
+                i2c_writew(I2C_STAT_XRDY, I2C_STAT);
                 status = wait_for_pin();
                 if ((status & I2C_STAT_XRDY)) {
                         /* send out next 1 byte */
-                        outb(value, I2C_DATA);
-                        outw(I2C_STAT_XRDY, I2C_STAT);
+                        i2c_writeb(value, I2C_DATA);
+                        i2c_writew(I2C_STAT_XRDY, I2C_STAT);
                 } else {
                         i2c_error = 1;
                 }
 #else
                 /* send out two bytes */
-                outw ((value << 8) + regoffset, I2C_DATA);
+                i2c_writew ((value << 8) + regoffset, I2C_DATA);
 #endif
 
                /* must have enough delay to allow BB bit to go low */
                udelay (50000);
-               if (inw (I2C_STAT) & I2C_STAT_NACK) {
+               if (i2c_readw (I2C_STAT) & I2C_STAT_NACK) {
                        i2c_error = 1;
                }
        } else {
@@ -191,18 +218,18 @@ static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value)
        if (!i2c_error) {
                int eout = 200;
 
-               outw (I2C_CON_EN, I2C_CON);
-               while ((stat = inw (I2C_STAT)) || (inw (I2C_CON) & I2C_CON_MST)) {
+               i2c_writew (I2C_CON_EN, I2C_CON);
+               while ((stat = i2c_readw (I2C_STAT)) || (i2c_readw (I2C_CON) & I2C_CON_MST)) {
                        udelay (1000);
                        /* have to read to clear intrrupt */
-                       outw (0xFFFF, I2C_STAT);
+                       i2c_writew (0xFFFF, I2C_STAT);
                        if(--eout == 0) /* better leave with error than hang */
                                break;
                }
        }
        flush_fifo();
-       outw (0xFFFF, I2C_STAT);
-       outw (0, I2C_CNT);
+       i2c_writew (0xFFFF, I2C_STAT);
+       i2c_writew (0, I2C_CNT);
        return i2c_error;
 }
 
@@ -213,14 +240,14 @@ static void flush_fifo(void)
         * you get a bus error
         */
        while(1){
-               stat = inw(I2C_STAT);
+               stat = i2c_readw(I2C_STAT);
                if(stat == I2C_STAT_RRDY){
 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
-                        inb(I2C_DATA);
+                        i2c_readb(I2C_DATA);
 #else
-                        inw(I2C_DATA);
+                        i2c_readw(I2C_DATA);
 #endif
-                       outw(I2C_STAT_RRDY,I2C_STAT);
+                       i2c_writew(I2C_STAT_RRDY,I2C_STAT);
                        udelay(1000);
                }else
                        break;
@@ -231,7 +258,7 @@ int i2c_probe (uchar chip)
 {
        int res = 1; /* default = fail */
 
-       if (chip == inw (I2C_OA)) {
+       if (chip == i2c_readw (I2C_OA)) {
                return res;
        }
 
@@ -239,27 +266,27 @@ int i2c_probe (uchar chip)
        wait_for_bb ();
 
        /* try to read one byte */
-       outw (1, I2C_CNT);
+       i2c_writew (1, I2C_CNT);
        /* set slave address */
-       outw (chip, I2C_SA);
+       i2c_writew (chip, I2C_SA);
        /* stop bit needed here */
-       outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, I2C_CON);
+       i2c_writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, I2C_CON);
        /* enough delay for the NACK bit set */
        udelay (50000);
 
-       if (!(inw (I2C_STAT) & I2C_STAT_NACK)) {
+       if (!(i2c_readw (I2C_STAT) & I2C_STAT_NACK)) {
                res = 0;      /* success case */
                flush_fifo();
-               outw(0xFFFF, I2C_STAT);
+               i2c_writew(0xFFFF, I2C_STAT);
        } else {
-               outw(0xFFFF, I2C_STAT);  /* failue, clear sources*/
-               outw (inw (I2C_CON) | I2C_CON_STP, I2C_CON); /* finish up xfer */
+               i2c_writew(0xFFFF, I2C_STAT);    /* failue, clear sources*/
+               i2c_writew (i2c_readw (I2C_CON) | I2C_CON_STP, I2C_CON); /* finish up xfer */
                udelay(20000);
                wait_for_bb ();
        }
        flush_fifo();
-       outw (0, I2C_CNT); /* don't allow any more data in...we don't want it.*/
-       outw(0xFFFF, I2C_STAT);
+       i2c_writew (0, I2C_CNT); /* don't allow any more data in...we don't want it.*/
+       i2c_writew(0xFFFF, I2C_STAT);
        return res;
 }
 
@@ -318,17 +345,17 @@ static void wait_for_bb (void)
        int timeout = 10;
        u16 stat;
 
-       outw(0xFFFF, I2C_STAT);  /* clear current interruts...*/
-       while ((stat = inw (I2C_STAT) & I2C_STAT_BB) && timeout--) {
-               outw (stat, I2C_STAT);
+       i2c_writew(0xFFFF, I2C_STAT);    /* clear current interruts...*/
+       while ((stat = i2c_readw (I2C_STAT) & I2C_STAT_BB) && timeout--) {
+               i2c_writew (stat, I2C_STAT);
                udelay (50000);
        }
 
        if (timeout <= 0) {
                printf ("timed out in wait_for_bb: I2C_STAT=%x\n",
-                       inw (I2C_STAT));
+                       i2c_readw (I2C_STAT));
        }
-       outw(0xFFFF, I2C_STAT);  /* clear delayed stuff*/
+       i2c_writew(0xFFFF, I2C_STAT);    /* clear delayed stuff*/
 }
 
 static u16 wait_for_pin (void)
@@ -338,7 +365,7 @@ static u16 wait_for_pin (void)
 
        do {
                udelay (1000);
-               status = inw (I2C_STAT);
+               status = i2c_readw (I2C_STAT);
        } while (  !(status &
                   (I2C_STAT_ROVR | I2C_STAT_XUDF | I2C_STAT_XRDY |
                    I2C_STAT_RRDY | I2C_STAT_ARDY | I2C_STAT_NACK |
@@ -346,10 +373,57 @@ static u16 wait_for_pin (void)
 
        if (timeout <= 0) {
                printf ("timed out in wait_for_pin: I2C_STAT=%x\n",
-                       inw (I2C_STAT));
-                       outw(0xFFFF, I2C_STAT);
+                       i2c_readw (I2C_STAT));
+                       i2c_writew(0xFFFF, I2C_STAT);
 }
        return status;
 }
 
+int i2c_set_bus_num(unsigned int bus)
+{
+       switch (bus) {
+               case 0:
+                       i2c_base = I2C_BASE1;
+                       break;
+               case 1:
+                       i2c_base = I2C_BASE2;
+                       break;
+               case 2:
+                       i2c_base = I2C_BASE3;
+                       break;
+       }
+
+       i2c_init (i2c_speed, CFG_I2C_SLAVE);
+
+       return 0;
+}
+
+unsigned int i2c_get_bus_num(void)
+{
+       switch (i2c_base) {
+               case I2C_BASE1:
+                       return 0;
+               case I2C_BASE2:
+                       return 1;
+               case I2C_BASE3:
+                       return 2;
+               default:
+                       return 0;
+       }
+}
+
+int i2c_set_bus_speed(unsigned int speed)
+{
+       i2c_speed = speed;
+
+       i2c_init (i2c_speed, CFG_I2C_SLAVE);
+
+       return 0;
+}
+
+unsigned int i2c_get_bus_speed(void)
+{
+       return i2c_speed;
+}
+
 #endif /* CONFIG_DRIVER_OMAP24XX_I2C */
index 28ae5ca..4303d49 100644 (file)
 
 #define I2C_DEFAULT_BASE I2C_BASE1
 
-#define I2C_REV                 (I2C_DEFAULT_BASE + 0x00)
-#define I2C_IE                  (I2C_DEFAULT_BASE + 0x04)
-#define I2C_STAT                (I2C_DEFAULT_BASE + 0x08)
-#define I2C_IV                  (I2C_DEFAULT_BASE + 0x0c)
-#define I2C_BUF                 (I2C_DEFAULT_BASE + 0x14)
-#define I2C_CNT                 (I2C_DEFAULT_BASE + 0x18)
-#define I2C_DATA                (I2C_DEFAULT_BASE + 0x1c)
-#define I2C_SYSC                (I2C_DEFAULT_BASE + 0x20)
-#define I2C_CON                 (I2C_DEFAULT_BASE + 0x24)
-#define I2C_OA                  (I2C_DEFAULT_BASE + 0x28)
-#define I2C_SA                  (I2C_DEFAULT_BASE + 0x2c)
-#define I2C_PSC                 (I2C_DEFAULT_BASE + 0x30)
-#define I2C_SCLL                (I2C_DEFAULT_BASE + 0x34)
-#define I2C_SCLH                (I2C_DEFAULT_BASE + 0x38)
-#define I2C_SYSTEST             (I2C_DEFAULT_BASE + 0x3c)
+#define I2C_REV                 (0x00)
+#define I2C_IE                  (0x04)
+#define I2C_STAT                (0x08)
+#define I2C_IV                  (0x0c)
+#define I2C_BUF                 (0x14)
+#define I2C_CNT                 (0x18)
+#define I2C_DATA                (0x1c)
+#define I2C_SYSC                (0x20)
+#define I2C_CON                 (0x24)
+#define I2C_OA                  (0x28)
+#define I2C_SA                  (0x2c)
+#define I2C_PSC                 (0x30)
+#define I2C_SCLL                (0x34)
+#define I2C_SCLH                (0x38)
+#define I2C_SYSTEST             (0x3c)
 
 /* I2C masks */
 
index 8e53773..7e2036d 100644 (file)
@@ -87,7 +87,7 @@ unsigned int i2c_get_bus_num(void);
  *     Returns: 0 on success, not 0 on failure
  *
  */
-int i2c_set_bus_speed(unsigned int);
+int i2c_set_bus_speed(unsigned int speed);
 
 /*
  * i2c_get_bus_speed: