Merge pull request #575 from toyowata/master

0xc0170 · 0xc0170 · commit 53e1cdc34d88 · 2014-10-17T14:45:44.000+02:00
HAL : LPC824 - Fix SPI1 SWM table
diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC82X/spi_api.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC82X/spi_api.c
@@ -24,22 +24,22 @@
 
 static const SWM_Map SWM_SPI_SSEL[] = {
     {4, 16},
-    {5, 16},
+    {6, 8},
 };
 
 static const SWM_Map SWM_SPI_SCLK[] = {
     {3, 24},
-    {4, 24},
+    {5, 16},
 };
 
 static const SWM_Map SWM_SPI_MOSI[] = {
     {4, 0},
-    {5, 0},
+    {5, 24},
 };
 
 static const SWM_Map SWM_SPI_MISO[] = {
     {4, 8},
-    {5, 16},
+    {6, 0},
 };
 
 // bit flags for used SPIs
@@ -55,8 +55,8 @@ static int get_available_spi(void)
     return -1;
 }
 
-static inline int ssp_disable(spi_t *obj);
-static inline int ssp_enable(spi_t *obj);
+static inline void spi_disable(spi_t *obj);
+static inline void spi_enable(spi_t *obj);
 
 void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
 {
@@ -104,7 +104,7 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
     LPC_SYSCON->PRESETCTRL    |=  (1 << obj->spi_n);
 
     // set default format and frequency
-    if (ssel == NC) {
+    if (ssel == (PinName)NC) {
         spi_format(obj, 8, 0, 0);  // 8 bits, mode 0, master
     } else {
         spi_format(obj, 8, 0, 1);  // 8 bits, mode 0, slave
@@ -113,7 +113,7 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
     obj->spi->DLY = 2;             // 2 SPI clock times pre-delay
 
     // enable the ssp channel
-    ssp_enable(obj);
+    spi_enable(obj);
 }
 
 void spi_free(spi_t *obj)
@@ -123,92 +123,87 @@ void spi_free(spi_t *obj)
 void spi_format(spi_t *obj, int bits, int mode, int slave)
 {
     MBED_ASSERT(((bits >= 1) && (bits <= 16)) && ((mode >= 0) && (mode <= 3)));
-    ssp_disable(obj);
+    spi_disable(obj);
 
     obj->spi->CFG &= ~((0x3 << 4) | (1 << 2));
     obj->spi->CFG |=  ((mode & 0x3) << 4) | ((slave ? 0 : 1) << 2);
 
-    obj->spi->TXDATCTL &= ~( 0xF << 24);
-    obj->spi->TXDATCTL |=  (((bits & 0xF) - 1) << 24);
+    obj->spi->TXCTL &= ~( 0xF << 24);
+    obj->spi->TXCTL |=  ((bits - 1) << 24);
 
-    ssp_enable(obj);
+    spi_enable(obj);
 }
 
 void spi_frequency(spi_t *obj, int hz)
 {
-    ssp_disable(obj);
+    spi_disable(obj);
 
     // rise DIV value if it cannot be divided
     obj->spi->DIV = (SystemCoreClock + (hz - 1))/hz - 1;
 
-    ssp_enable(obj);
+    spi_enable(obj);
 }
 
-static inline int ssp_disable(spi_t *obj)
+static inline void spi_disable(spi_t *obj)
 {
-    return obj->spi->CFG &= ~(1 << 0);
+    obj->spi->CFG &= ~(1 << 0);
 }
 
-static inline int ssp_enable(spi_t *obj)
+static inline void spi_enable(spi_t *obj)
 {
-    return obj->spi->CFG |= (1 << 0);
+    obj->spi->CFG |= (1 << 0);
 }
 
-static inline int ssp_readable(spi_t *obj)
+static inline int spi_readable(spi_t *obj)
 {
     return obj->spi->STAT & (1 << 0);
 }
 
-static inline int ssp_writeable(spi_t *obj)
+static inline int spi_writeable(spi_t *obj)
 {
     return obj->spi->STAT & (1 << 1);
 }
 
-static inline void ssp_write(spi_t *obj, int value)
+static inline void spi_write(spi_t *obj, int value)
 {
-    while (!ssp_writeable(obj));
+    while (!spi_writeable(obj));
     // end of transfer
-    obj->spi->TXDATCTL |= (1 << 20);
-    obj->spi->TXDAT = value;
+    obj->spi->TXCTL |= (1 << 20);
+    obj->spi->TXDAT = (value & 0xffff);
 }
 
-static inline int ssp_read(spi_t *obj)
+static inline int spi_read(spi_t *obj)
 {
-    while (!ssp_readable(obj));
-    return obj->spi->RXDAT;
+    while (!spi_readable(obj));
+    return (obj->spi->RXDAT & 0xFFFF);
 }
 
-static inline int ssp_busy(spi_t *obj)
+int spi_master_write(spi_t *obj, int value)
 {
-    // checking RXOV(Receiver Overrun interrupt flag)
-    return obj->spi->STAT & (1 << 2);
+    spi_write(obj, value);
+    return spi_read(obj);
 }
 
-int spi_master_write(spi_t *obj, int value)
+static inline int spi_busy(spi_t *obj)
 {
-    ssp_write(obj, value);
-    return ssp_read(obj);
+    // checking RXOV(Receiver Overrun interrupt flag)
+    return obj->spi->STAT & (1 << 2);
 }
 
 int spi_slave_receive(spi_t *obj)
 {
-    return (ssp_readable(obj) && !ssp_busy(obj)) ? (1) : (0);
+    return (spi_readable(obj) && !spi_busy(obj)) ? (1) : (0);
 }
 
 int spi_slave_read(spi_t *obj)
 {
-    return obj->spi->RXDAT;
+    return (obj->spi->RXDAT & 0xFFFF);
 }
 
 void spi_slave_write(spi_t *obj, int value)
 {
-    while (ssp_writeable(obj) == 0);
+    while (spi_writeable(obj) == 0);
     obj->spi->TXDAT = value;
 }
 
-int spi_busy(spi_t *obj)
-{
-    return ssp_busy(obj);
-}
-
 #endif
diff --git a/libraries/tests/mbed/i2c_eeprom/main.cpp b/libraries/tests/mbed/i2c_eeprom/main.cpp
@@ -49,7 +49,8 @@ I2C i2c(P0_23, P0_22);
       defined(TARGET_NUCLEO_F401RE) || \
       defined(TARGET_NUCLEO_F411RE) || \
       defined(TARGET_NUCLEO_L053R8) || \
-      defined(TARGET_NUCLEO_L152RE)
+      defined(TARGET_NUCLEO_L152RE) || \
+      defined(TARGET_FF_ARDUINO)
 I2C i2c(I2C_SDA, I2C_SCL);
 
 #elif defined(TARGET_LPC11U68)
diff --git a/libraries/tests/mbed/i2c_master/main.cpp b/libraries/tests/mbed/i2c_master/main.cpp
@@ -8,6 +8,8 @@
 I2C i2c(PTE0, PTE1);
 #elif defined(TARGET_nRF51822)
 I2C i2c(p22,p20);
+#elif defined(TARGET_FF_ARDUINO)
+I2C i2c(I2C_SDA, I2C_SCL);
 #else
 I2C i2c(p28, p27);
 #endif
diff --git a/libraries/tests/mbed/pwm_led/pwm.cpp b/libraries/tests/mbed/pwm_led/pwm.cpp
@@ -16,7 +16,8 @@
       defined(TARGET_NUCLEO_L152RE)
 #define TEST_LED D3
 
-#elif defined (TARGET_K22F)
+#elif defined (TARGET_K22F) || \
+      defined (TARGET_LPC824)
 #define TEST_LED LED_GREEN
 
 #else
diff --git a/libraries/tests/mbed/spi_master/main.cpp b/libraries/tests/mbed/spi_master/main.cpp
@@ -10,6 +10,9 @@ DigitalOut cs(PTB1);
 #elif defined(TARGET_KL46Z)
 SPI spi(PTD2, PTD3, PTD1);   // mosi, miso, sclk
 DigitalOut cs(PTA13);
+#elif defined(TARGET_FF_ARDUINO)
+SPI spi(D11, D12, D13);   // mosi, miso, sclk
+DigitalOut cs(D10);
 #else
 SPI spi(p5, p6, p7); // mosi, miso, sclk
 DigitalOut cs(p8);
diff --git a/libraries/tests/mbed/spi_slave/main.cpp b/libraries/tests/mbed/spi_slave/main.cpp
@@ -6,6 +6,8 @@ SPISlave device(PTD2, PTD3, PTD1, PTD0);    // mosi, miso, sclk, ssel
 SPISlave device(p12, p13, p15, p14);  // mosi, miso, sclk, ssel
 #elif defined(TARGET_LPC812)
 SPISlave device(P0_14, P0_15, P0_12, P0_13);    // mosi, miso, sclk, ssel
+#elif defined(TARGET_FF_ARDUINO)
+SPISlave device(D11, D12, D13, D10);       // mosi, miso, sclk, ssel
 #else
 SPISlave device(p5, p6, p7, p8);            // mosi, miso, sclk, ssel
 #endif

Original file line number	Diff line number	Diff line change
`@@ -24,22 +24,22 @@`
`24`	`24`
`25`	`25`	`static const SWM_Map SWM_SPI_SSEL[] = {`
`26`	`26`	`{4, 16},`
`27`		`- {5, 16},`
	`27`	`+ {6, 8},`
`28`	`28`	`};`
`29`	`29`
`30`	`30`	`static const SWM_Map SWM_SPI_SCLK[] = {`
`31`	`31`	`{3, 24},`
`32`		`- {4, 24},`
	`32`	`+ {5, 16},`
`33`	`33`	`};`
`34`	`34`
`35`	`35`	`static const SWM_Map SWM_SPI_MOSI[] = {`
`36`	`36`	`{4, 0},`
`37`		`- {5, 0},`
	`37`	`+ {5, 24},`
`38`	`38`	`};`
`39`	`39`
`40`	`40`	`static const SWM_Map SWM_SPI_MISO[] = {`
`41`	`41`	`{4, 8},`
`42`		`- {5, 16},`
	`42`	`+ {6, 0},`
`43`	`43`	`};`
`44`	`44`
`45`	`45`	`// bit flags for used SPIs`
`@@ -55,8 +55,8 @@ static int get_available_spi(void)`
`55`	`55`	`return -1;`
`56`	`56`	`}`
`57`	`57`
`58`		`-static inline int ssp_disable(spi_t *obj);`
`59`		`-static inline int ssp_enable(spi_t *obj);`
	`58`	`+static inline void spi_disable(spi_t *obj);`
	`59`	`+static inline void spi_enable(spi_t *obj);`
`60`	`60`
`61`	`61`	`void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)`
`62`	`62`	`{`
`@@ -104,7 +104,7 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel`
`104`	`104`	`LPC_SYSCON->PRESETCTRL \|= (1 << obj->spi_n);`
`105`	`105`
`106`	`106`	`// set default format and frequency`
`107`		`- if (ssel == NC) {`
	`107`	`+ if (ssel == (PinName)NC) {`
`108`	`108`	`spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master`
`109`	`109`	`} else {`
`110`	`110`	`spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave`
`@@ -113,7 +113,7 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel`
`113`	`113`	`obj->spi->DLY = 2; // 2 SPI clock times pre-delay`
`114`	`114`
`115`	`115`	`// enable the ssp channel`
`116`		`- ssp_enable(obj);`
	`116`	`+ spi_enable(obj);`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`void spi_free(spi_t *obj)`
`@@ -123,92 +123,87 @@ void spi_free(spi_t *obj)`
`123`	`123`	`void spi_format(spi_t *obj, int bits, int mode, int slave)`
`124`	`124`	`{`
`125`	`125`	`MBED_ASSERT(((bits >= 1) && (bits <= 16)) && ((mode >= 0) && (mode <= 3)));`
`126`		`- ssp_disable(obj);`
	`126`	`+ spi_disable(obj);`
`127`	`127`
`128`	`128`	`obj->spi->CFG &= ~((0x3 << 4) \| (1 << 2));`
`129`	`129`	`obj->spi->CFG \|= ((mode & 0x3) << 4) \| ((slave ? 0 : 1) << 2);`
`130`	`130`
`131`		`- obj->spi->TXDATCTL &= ~( 0xF << 24);`
`132`		`- obj->spi->TXDATCTL \|= (((bits & 0xF) - 1) << 24);`
	`131`	`+ obj->spi->TXCTL &= ~( 0xF << 24);`
	`132`	`+ obj->spi->TXCTL \|= ((bits - 1) << 24);`
`133`	`133`
`134`		`- ssp_enable(obj);`
	`134`	`+ spi_enable(obj);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`void spi_frequency(spi_t *obj, int hz)`
`138`	`138`	`{`
`139`		`- ssp_disable(obj);`
	`139`	`+ spi_disable(obj);`
`140`	`140`
`141`	`141`	`// rise DIV value if it cannot be divided`
`142`	`142`	`obj->spi->DIV = (SystemCoreClock + (hz - 1))/hz - 1;`
`143`	`143`
`144`		`- ssp_enable(obj);`
	`144`	`+ spi_enable(obj);`
`145`	`145`	`}`
`146`	`146`
`147`		`-static inline int ssp_disable(spi_t *obj)`
	`147`	`+static inline void spi_disable(spi_t *obj)`
`148`	`148`	`{`
`149`		`- return obj->spi->CFG &= ~(1 << 0);`
	`149`	`+ obj->spi->CFG &= ~(1 << 0);`
`150`	`150`	`}`
`151`	`151`
`152`		`-static inline int ssp_enable(spi_t *obj)`
	`152`	`+static inline void spi_enable(spi_t *obj)`
`153`	`153`	`{`
`154`		`- return obj->spi->CFG \|= (1 << 0);`
	`154`	`+ obj->spi->CFG \|= (1 << 0);`
`155`	`155`	`}`
`156`	`156`
`157`		`-static inline int ssp_readable(spi_t *obj)`
	`157`	`+static inline int spi_readable(spi_t *obj)`
`158`	`158`	`{`
`159`	`159`	`return obj->spi->STAT & (1 << 0);`
`160`	`160`	`}`
`161`	`161`
`162`		`-static inline int ssp_writeable(spi_t *obj)`
	`162`	`+static inline int spi_writeable(spi_t *obj)`
`163`	`163`	`{`
`164`	`164`	`return obj->spi->STAT & (1 << 1);`
`165`	`165`	`}`
`166`	`166`
`167`		`-static inline void ssp_write(spi_t *obj, int value)`
	`167`	`+static inline void spi_write(spi_t *obj, int value)`
`168`	`168`	`{`
`169`		`- while (!ssp_writeable(obj));`
	`169`	`+ while (!spi_writeable(obj));`
`170`	`170`	`// end of transfer`
`171`		`- obj->spi->TXDATCTL \|= (1 << 20);`
`172`		`- obj->spi->TXDAT = value;`
	`171`	`+ obj->spi->TXCTL \|= (1 << 20);`
	`172`	`+ obj->spi->TXDAT = (value & 0xffff);`
`173`	`173`	`}`
`174`	`174`
`175`		`-static inline int ssp_read(spi_t *obj)`
	`175`	`+static inline int spi_read(spi_t *obj)`
`176`	`176`	`{`
`177`		`- while (!ssp_readable(obj));`
`178`		`- return obj->spi->RXDAT;`
	`177`	`+ while (!spi_readable(obj));`
	`178`	`+ return (obj->spi->RXDAT & 0xFFFF);`
`179`	`179`	`}`
`180`	`180`
`181`		`-static inline int ssp_busy(spi_t *obj)`
	`181`	`+int spi_master_write(spi_t *obj, int value)`
`182`	`182`	`{`
`183`		`- // checking RXOV(Receiver Overrun interrupt flag)`
`184`		`- return obj->spi->STAT & (1 << 2);`
	`183`	`+ spi_write(obj, value);`
	`184`	`+ return spi_read(obj);`
`185`	`185`	`}`
`186`	`186`
`187`		`-int spi_master_write(spi_t *obj, int value)`
	`187`	`+static inline int spi_busy(spi_t *obj)`
`188`	`188`	`{`
`189`		`- ssp_write(obj, value);`
`190`		`- return ssp_read(obj);`
	`189`	`+ // checking RXOV(Receiver Overrun interrupt flag)`
	`190`	`+ return obj->spi->STAT & (1 << 2);`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`int spi_slave_receive(spi_t *obj)`
`194`	`194`	`{`
`195`		`- return (ssp_readable(obj) && !ssp_busy(obj)) ? (1) : (0);`
	`195`	`+ return (spi_readable(obj) && !spi_busy(obj)) ? (1) : (0);`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`int spi_slave_read(spi_t *obj)`
`199`	`199`	`{`
`200`		`- return obj->spi->RXDAT;`
	`200`	`+ return (obj->spi->RXDAT & 0xFFFF);`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`void spi_slave_write(spi_t *obj, int value)`
`204`	`204`	`{`
`205`		`- while (ssp_writeable(obj) == 0);`
	`205`	`+ while (spi_writeable(obj) == 0);`
`206`	`206`	`obj->spi->TXDAT = value;`
`207`	`207`	`}`
`208`	`208`
`209`		`-int spi_busy(spi_t *obj)`
`210`		`-{`
`211`		`- return ssp_busy(obj);`
`212`		`-}`
`213`		`-`
`214`	`209`	`#endif`