Patch #5347 by Rani Hod - Adds FM radio and recording features to the iAudio X5.

Also includes a rewrite of the Coldfire I2C driver to include both read and write.


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10272 a1c6a512-1295-4272-9138-f99709370657

4 files changed, 256 insertions, 135 deletions

diff --git a/firmware/drivers/fmradio_i2c.c b/firmware/drivers/fmradio_i2c.c
index 2475084696..6f87e15b3e 100644
--- a/firmware/drivers/fmradio_i2c.c
+++ b/firmware/drivers/fmradio_i2c.c
@@ -27,6 +27,22 @@
 
 #if (CONFIG_TUNER & TEA5767)
 #if (CONFIG_I2C == I2C_COLDFIRE)
+
+#ifdef IAUDIO_X5
+#include "i2c-coldfire.h"
+
+int fmradio_i2c_write(unsigned char address, const unsigned char* buf,
+                      int count)
+{
+    return i2c_write(I2C_IFACE_0, address, buf, count);
+}
+
+int fmradio_i2c_read(unsigned char address, unsigned char* buf, int count)
+{
+    return i2c_read(I2C_IFACE_0, address, buf, count);
+}
+#else
+
 /* cute little functions, atomic read-modify-write */
 /* SDA is GPIO1,23 */
 
@@ -242,6 +258,7 @@ int fmradio_i2c_read(int address, unsigned char* buf, int count)
     fmradio_i2c_stop();
     return x;
 }
+#endif /* ! IAUDIO_X5 */
 #else
 /* cute little functions, atomic read-modify-write */
 /* SDA is PB4 */
diff --git a/firmware/drivers/i2c-coldfire.c b/firmware/drivers/i2c-coldfire.c
index 47aeba757f..a628ce5f0e 100644
--- a/firmware/drivers/i2c-coldfire.c
+++ b/firmware/drivers/i2c-coldfire.c
@@ -5,6 +5,7 @@
  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
  *                     \/            \/     \/    \/            \/
+ *
  * $Id$
  *
  * Copyright (C) 2005 by Andy Young
@@ -23,17 +24,16 @@
 #include "system.h"
 #include "i2c-coldfire.h"
 
-#define I2C_DEVICE_1    ((volatile unsigned char *)&MADR)
-#define I2C_DEVICE_2    ((volatile unsigned char *)&MADR2)
 
-/* Local functions definitions */
+/* --- Local functions - declarations --- */
+
+static int i2c_start(volatile unsigned char *iface);
+static int i2c_wait_for_slave(volatile unsigned char *iface);
+static int i2c_outb(volatile unsigned char *iface, unsigned char byte);
+inline void i2c_stop(volatile unsigned char *iface);
 
-static int i2c_write_byte(int device, unsigned char data);
-static int i2c_gen_start(int device);
-static void i2c_gen_stop(int device);
-static volatile unsigned char *i2c_get_addr(int device);
 
-/* Public functions */
+/* --- Public functions - implementation --- */
 
 void i2c_init(void)
 {
@@ -55,14 +55,15 @@ void i2c_init(void)
 #endif
     
     /* I2C Clock divisor = 160 => 124.1556 MHz / 2 / 160 = 388.08 kHz */
-    MFDR = 0x0d;
+    MFDR  = 0x0d;
     MFDR2 = 0x0d;
 
 #ifdef IAUDIO_X5
-    MBCR = IEN;  /* Enable interface */
+    MBCR  = IEN;  /* Enable interface */
+    MBCR2 = IEN; 
 #endif
 
-#if (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
+#if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
     /* Audio Codec */
     MBDR = 0;    /* iRiver firmware does this */
     MBCR = IEN;  /* Enable interface */
@@ -72,109 +73,169 @@ void i2c_init(void)
 void i2c_close(void)
 {
     MBCR  = 0;
+    MBCR2 = 0;
 }
 
-/**
- * Writes bytes to the selected device.
+/*
+ * Writes bytes to a I2C device.
  *
- * Use device=1 for bus 1 at 0x40000280
- * Use device=2 for bus 2 at 0x80000440
- * 
- * Returns number of bytes successfully send or -1 if START failed
+ * Returns number of bytes successfully sent or a negative value on error.
  */
-int i2c_write(int device, unsigned char *buf, int count)
+int i2c_write(volatile unsigned char *iface, unsigned char addr, 
+              const unsigned char *buf, int count)
 {
-    int i;
-    int rc;
+    int i, rc;
 
-    rc = i2c_gen_start(device);
+    if ( ! count)
+        return 0;
+   
+    rc = i2c_start(iface);
     if (rc < 0)
+        return rc;
+    
+    rc = i2c_outb(iface, addr & 0xfe);
+    if (rc < 0)
+        return rc;
+    
+    for (i = 0; i < count; i++)
     {
-        logf("i2c: gen_start failed (d=%d)", device);
-        return rc*10 - 1;
-    }
-
-    for (i=0; i<count; i++)
-    {
-        rc = i2c_write_byte(device, buf[i]);
+        rc = i2c_outb(iface, *buf++);
         if (rc < 0)
-        {
-            logf("i2c: write failed at (d=%d,i=%d)", device, i);
-            return rc*10 - 2;
-        }
+            return rc;
     }
-
-    i2c_gen_stop(device);
-
+    i2c_stop(iface);
+    
     return count;
 }
 
-/* Write a byte to the interface, returns 0 on success, -1 otherwise. */
-int i2c_write_byte(int device, unsigned char data)
+/*
+ * Reads bytes from a I2C device.
+ *
+ * Returns number of bytes successfully received or a negative value on error.
+ */
+int i2c_read(volatile unsigned char *iface, unsigned char addr, 
+             unsigned char *buf, int count)
 {
-    volatile unsigned char *regs = i2c_get_addr(device);
+    int i, rc;
 
-    long count = 0;
+    if ( ! count)
+        return 0;
+   
+    rc = i2c_start(iface);
+    if (rc < 0)
+        return rc;
 
-    regs[O_MBDR] = data;                /* Write data byte */   
+    rc = i2c_outb(iface, addr | 1);
+    if (rc < 0)
+        return rc;
+
+    /* Switch to Rx mode */
+    iface[O_MBCR] &= ~MTX;
+    iface[O_MBCR] &= ~TXAK;
+ 
+    /* Dummy read */
+    rc = (int) iface[O_MBDR];
+  
+    for (i = 0; i < count; i++)
+    {
+        rc = i2c_wait_for_slave(iface);
+        if (rc < 0)
+            return rc;
 
-    /* Wait for bus busy */
-    while (!(regs[O_MBSR] & IBB) && count < MAX_LOOP)
-        count++;
+        if (i == count-2)
+            /* Don't ACK the next-to-last byte */
+            iface[O_MBCR] |= TXAK;
+    
+        if (i == count-1)
+            /* Generate STOP before reading last byte */
+            i2c_stop(iface); 
 
-    if (count >= MAX_LOOP)
-        return -1;
+        *buf++ = iface[O_MBDR];
+    }
+    return count;
+}
 
-    count = 0;
+/* --- Local functions - implementation --- */
 
-    /* Wait for interrupt flag */
-    while (!(regs[O_MBSR] & IFF) && count < MAX_LOOP)
-        count++;
+/* Begin I2C session on the given interface.
+ *
+ * Returns 0 on success, negative value on error.
+ */
+int i2c_start(volatile unsigned char *iface)
+{
+    /* Wait for bus to become free */
+    int j = MAX_LOOP;
+    while (--j && (iface[O_MBSR] & IBB))
+        ;
+    if (!j)
+    {
+        logf("i2c: bus is busy (iface=%08x)", iface);
+        return -1;
+    }
+ 
+    /* Generate START and prepare for write */
+    iface[O_MBCR] |= (MSTA | TXAK | MTX);
+  
+    return 0; 
+}
 
-    if (count >= MAX_LOOP)
+/* Wait for slave to act on given I2C interface.
+ *
+ * Returns 0 on success, negative value on error.
+ */
+int i2c_wait_for_slave(volatile unsigned char *iface)
+{
+    int j = MAX_LOOP;
+    while (--j && ! (iface[O_MBSR] & IFF))
+        ;
+    if (!j)
+    {
+        logf("i2c: IFF not set (iface=%08x)", iface);
+        i2c_stop(iface); 
         return -2;
-
-    regs[O_MBSR] &= ~IFF;       /* Clear interrupt flag  */
-
-    if (!(regs[O_MBSR] & ICF))  /* Check that transfer is complete */
-        return -3;
-
-    if (regs[O_MBSR] & RXAK)    /* Check that the byte has been ACKed */
-        return -4;
-
+    }
+  
+    /* Clear interrupt flag */
+    iface[O_MBSR] &= ~IFF;
+    
     return 0;
 }
 
-
-/* Returns 0 on success, -1 on failure */
-int i2c_gen_start(int device)
+/* Write the given byte to the given I2C interface.
+ *
+ * Returns 0 on success, negative value on error.
+ */
+int i2c_outb(volatile unsigned char *iface, unsigned char byte)
 {
-    volatile unsigned char *regs = i2c_get_addr(device);
-    long count = 0;
-
-    /* Wait for bus to become free */
-    while ((regs[O_MBSR] & IBB) && (count < MAX_LOOP))
-        count++;
-
-    if (count >= MAX_LOOP)
-        return -1;
+    int rc;
 
-    regs[O_MBCR] |= MSTA | MTX;         /* Generate START */
+    iface[O_MBDR] = byte;
 
+    rc = i2c_wait_for_slave(iface);
+    if (rc < 0)
+        return rc;
+    
+    /* Check that transfer is complete */
+    if ( !(iface[O_MBSR] & ICF))
+    {
+        logf("i2c: transfer error (iface=%08x)", iface);
+        i2c_stop(iface); 
+        return -3;
+    }
+    
+    /* Check that the byte has been ACKed */
+    if (iface[O_MBSR] & RXAK)
+    {
+        logf("i2c: no ACK (iface=%08x)", iface);
+        i2c_stop(iface); 
+        return -4;
+    }
+    
     return 0;
-}  
-
-void i2c_gen_stop(int device)
-{
-    volatile unsigned char *regs = i2c_get_addr(device);
-    regs[O_MBCR] &= ~MSTA;          /* Clear MSTA to generate STOP */
 }
 
-
-volatile unsigned char *i2c_get_addr(int device)
+/* End I2C session on the given interface. */
+inline void i2c_stop(volatile unsigned char *iface)
 {
-    if (device == 1)
-        return I2C_DEVICE_1;
-
-    return I2C_DEVICE_2;
+    iface[O_MBCR] &= ~MSTA;
 }
diff --git a/firmware/drivers/tlv320.c b/firmware/drivers/tlv320.c
index 8ef32919ce..39cd2a5536 100644
--- a/firmware/drivers/tlv320.c
+++ b/firmware/drivers/tlv320.c
@@ -28,6 +28,7 @@
 #include "string.h"
 #include "file.h"
 #include "buffer.h"
+#include "audio.h"
 
 #include "i2c-coldfire.h"
 #include "tlv320.h"
@@ -46,14 +47,13 @@ unsigned tlv320_regs[0xf];
 
 void tlv320_write_reg(unsigned reg, unsigned value)
 {
-    unsigned char data[3];
+    unsigned char data[2];
 
-    data[0] = TLV320_ADDR;
     /* The register address is the high 7 bits and the data the low 9 bits */
-    data[1] = (reg << 1) | ((value >> 8) & 1);
-    data[2] = value & 0xff; 
+    data[0] = (reg << 1) | ((value >> 8) & 1);
+    data[1] = value & 0xff; 
 
-    if (i2c_write(1, data, 3) != 3)
+    if (i2c_write(I2C_IFACE_0, TLV320_ADDR, data, 2) != 2)
     {
         logf("tlv320 error reg=0x%x", reg);
         return;
@@ -73,15 +73,16 @@ void tlv320_init(void)
 
     /* Initialize all registers */
 
-    tlv320_write_reg(REG_PC, 0x00); /* All ON */
-    tlv320_set_linein_vol(0, 0);
+    tlv320_write_reg(REG_PC, PC_ADC|PC_MIC|PC_LINE);  /* All ON except ADC, MIC and LINE */
+    tlv320_set_recvol(0, 0, AUDIO_GAIN_MIC);
+    tlv320_set_recvol(0, 0, AUDIO_GAIN_LINEIN);
     tlv320_mute(true);
     tlv320_write_reg(REG_AAP, AAP_DAC|AAP_MICM);
     tlv320_write_reg(REG_DAP, 0x00);  /* No deemphasis */
     tlv320_write_reg(REG_DAIF, DAIF_IWL_16|DAIF_FOR_I2S);
     tlv320_set_headphone_vol(0, 0);
     tlv320_write_reg(REG_DIA, DIA_ACT);
-    tlv320_write_reg(REG_SRC, (8 << 2)); /* 44.1kHz */
+    tlv320_write_reg(REG_SRC, (1 << 5)); /* 44.1kHz */
 }
 
 /**
@@ -114,18 +115,30 @@ void tlv320_set_headphone_vol(int vol_l, int vol_r)
 }
 
 /**
- * Sets left and right linein volume  (31(max) to 0(muted))
+ * Set recording volume
+ *
+ * Line in   : 0 .. 31 => Volume -34.5 .. 12 dB
+ * Mic (left): 0 ..  1 => Volume   0   .. 20 dB
+ *
  */
-void tlv320_set_linein_vol(int vol_l, int vol_r)
+void tlv320_set_recvol(int left, int right, int type)
 {
-    unsigned value_l = tlv320_regs[REG_LLIV];
-    unsigned value_r = tlv320_regs[REG_RLIV];
-
-    value_l |= LLIV_LIV(vol_l);
-    value_r |= RLIV_RIV(vol_r);
-
-    tlv320_write_reg(REG_LLIV, value_l);
-    tlv320_write_reg(REG_RLIV, value_r);
+    if (type == AUDIO_GAIN_MIC)
+    {
+        unsigned value_aap = tlv320_regs[REG_AAP];
+        
+        if (left)
+            value_aap |= AAP_MICB;  /* Enable mic boost (20dB) */
+        else
+            value_aap &= ~AAP_MICB;
+
+        tlv320_write_reg(REG_AAP, value_aap);            
+        
+    } else if (type == AUDIO_GAIN_LINEIN)
+    {
+        tlv320_write_reg(REG_LLIV, LLIV_LIV(left));
+        tlv320_write_reg(REG_RLIV, RLIV_RIV(right));    
+    }
 }
 
 /**
@@ -148,10 +161,11 @@ void tlv320_mute(bool mute)
         value_r = RHV_RHV(tlv320.vol_r);
     }
 
-    tlv320_write_reg(REG_LHV, value_r);
+    tlv320_write_reg(REG_LHV, value_l);
     tlv320_write_reg(REG_RHV, value_r);
 }
 
+/* Nice shutdown of TLV320 codec */
 void tlv320_close()
 {
     tlv320_write_reg(REG_PC, 0xFF);  /* All OFF */
@@ -159,35 +173,66 @@ void tlv320_close()
 
 void tlv320_enable_recording(bool source_mic)
 {
-    unsigned value_pc = tlv320_regs[REG_PC];
-    unsigned value_aap = tlv320_regs[REG_AAP];
-
-    /* select source*/
+    unsigned value_daif = tlv320_regs[REG_DAIF];
+    unsigned value_aap, value_pc;
+    
     if (source_mic)
     {
-        value_aap &= ~AAP_INSEL;
-        value_pc |= PC_MIC;
+        /* select mic and enable mic boost (20 dB) */
+        value_aap = AAP_DAC | AAP_INSEL | AAP_MICB;   
+        value_pc = PC_LINE;                 /* power down line-in */
     }
     else
     {
-        value_aap |= AAP_INSEL;
-        value_pc |= PC_LINE;
+        value_aap = AAP_DAC | AAP_MICM;
+        value_pc = PC_MIC;                  /* power down mic */
     }
 
-    /* poweron adc */
-    value_pc |= PC_ADC;
+    tlv320_write_reg(REG_PC, value_pc);
+    sleep(HZ/8);
 
     tlv320_write_reg(REG_AAP, value_aap);
-    tlv320_write_reg(REG_PC, value_pc);
+    sleep(HZ/8);
+    
+    /* Enable MASTER mode (start sending I2S data to the CPU) */
+    value_daif |= DAIF_MS;                   
+    tlv320_write_reg(REG_DAIF, value_daif);
 }
-
+  
 void tlv320_disable_recording()
 {
-    unsigned value = tlv320_regs[REG_PC];
-
-    /* powerdown mic, linein and adc */
-    value &= ~(PC_MIC | PC_LINE | PC_ADC);
+    unsigned value_pc = tlv320_regs[REG_PC];
+    unsigned value_aap = tlv320_regs[REG_AAP];
+    unsigned value_daif = tlv320_regs[REG_DAIF];
+
+    value_daif &= ~DAIF_MS;                /* disable MASTER mode */
+    tlv320_write_reg(REG_DAIF, value_daif);
+    
+    value_aap |= AAP_MICM;                 /* mute mic */
+    tlv320_write_reg(REG_PC, value_aap);
+
+    value_pc |= (PC_MIC|PC_LINE|PC_ADC);   /* power down mic, line-in and adc */
+    tlv320_write_reg(REG_PC, value_pc);    
+    
+    sleep(HZ/8);
+}
 
-    /* powerdown mic, linein and adc */
-    tlv320_write_reg(REG_PC, value);
+void tlv320_set_monitor(bool enable)
+{
+  unsigned value_aap, value_pc;
+  if (enable)
+  {
+    value_aap = AAP_BYPASS | AAP_MICM;
+    value_pc = (PC_MIC|PC_DAC|PC_ADC);   /* power down mic, dac and adc */
+  }
+  else
+  {
+    value_aap = AAP_DAC | AAP_MICM;
+    value_pc = (PC_MIC|PC_LINE|PC_ADC);   /* power down mic, line-in and adc */
+  }
+  tlv320_write_reg(REG_AAP, value_aap);
+  tlv320_write_reg(REG_PC,  value_pc);
+
+  sleep(HZ/8);
 }
+
diff --git a/firmware/drivers/uda1380.c b/firmware/drivers/uda1380.c
index ef19dcf1c5..241a117385 100644
--- a/firmware/drivers/uda1380.c
+++ b/firmware/drivers/uda1380.c
@@ -76,14 +76,13 @@ unsigned short uda1380_defaults[2*NUM_DEFAULT_REGS] =
 /* Returns 0 if register was written or -1 if write failed */
 int uda1380_write_reg(unsigned char reg, unsigned short value)
 {
-    unsigned char data[4];
+    unsigned char data[3];
 
-    data[0] = UDA1380_ADDR;
-    data[1] = reg;
-    data[2] = value >> 8;
-    data[3] = value & 0xff;
+    data[0] = reg;
+    data[1] = value >> 8;
+    data[2] = value & 0xff;
 
-    if (i2c_write(1, data, 4) != 4)
+    if (i2c_write(I2C_IFACE_0, UDA1380_ADDR, data, 3) != 3)
     {
         DEBUGF("uda1380 error reg=0x%x", reg);
         return -1;
@@ -322,21 +321,20 @@ void uda1380_set_recvol(int left, int right, int type)
             {
                 /* for this order we can combine both registers,
                     making the glitch even smaller */
-                unsigned char data[6];
+                unsigned char data[5];
                 unsigned short value_dec;
                 unsigned short value_pga;
                 value_dec = DEC_VOLL(left) | DEC_VOLR(right);
                 value_pga = (uda1380_regs[REG_PGA] & ~PGA_GAIN_MASK)
                                 | PGA_GAINL(left_ag) | PGA_GAINR(right_ag);
 
-                data[0] = UDA1380_ADDR;
-                data[1] = REG_DEC_VOL;
-                data[2] = value_dec >> 8;
-                data[3] = value_dec & 0xff;
-                data[4] = value_pga >> 8;
-                data[5] = value_pga & 0xff;
+                data[0] = REG_DEC_VOL;
+                data[1] = value_dec >> 8;
+                data[2] = value_dec & 0xff;
+                data[3] = value_pga >> 8;
+                data[4] = value_pga & 0xff;
 
-                if (i2c_write(1, data, 6) != 6)
+                if (i2c_write(I2C_IFACE_0, UDA1380_ADDR, data, 5) != 5)
                 {
                     DEBUGF("uda1380 error reg=combi rec gain");
                 }