HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r61:efd3992e476b

Fixed some issues on SCARD driver!

jeandet -

r61:efd3992e476b dev_alexis

parent child

Context file:

r61:efd3992e476b

Collapse all files

bsp/src/OPLAYER/bsp.c +16 -16

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  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 3 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
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_fsmc.h>
             #include <i2c.h>
             #include <core.h>
             #include <terminal.h>
             #include <sdcard-spi.h>
             #include <sdcard.h>
             #include <mbr.h>
             #include <VS10XX.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             LCD_IF_t lcdIF0={
                 .init = &bsp_FSMC_init,
                 .writereg = &bsp_lcd0_write_reg,
                 .readreg = &bsp_lcd0_read_reg,
                 .writeGRAM = &bsp_lcd0_writeGRAM,
                 .readGRAM = &bsp_lcd0_readGRAM
             };
             LCD_t lcd0={
                 .interface = &lcdIF0,
                 .init = &ili9328init,
                 .paint = &ili9328paint,
                 .paintText = &ili9328paintText,
                 .paintFilRect = &ili9328paintFilRect,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             terminal_t terminal0;
             volatile int8_t* lcd0_CMD=(volatile int8_t*)  0x60000000;
             volatile int8_t* lcd0_DATA=(volatile int8_t*)(0x61FFFFF0);
             float VREF0 =(float)3.3;
             volatile vs10XXDev audioCodec0;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<__MAX_OPENED_FILES__;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 bsp_spi_init();
                 bsp_SD_init();
                 bsp_Audio_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t GPIO_Out_init_List[]={LED1,LED2,LCD_RESET,LCD_BACKL,VS1053xCS,VS1053xDCS,VS1053xRESET,SDCARD2CS};
                 for(int i=0;i<8;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_Out_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpiooutdir | gpiopushpulltype;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpio_t GPIO_In_init_List[]={VS1053DREQ,SDCARD2CD};
                 for(int i=0;i<2;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_In_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpioindir;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpioclr(VS1053xRESET);
                 gpioset(VS1053xCS);
                 gpioset(VS1053xDCS);
                 gpioset(SDCARD2CS);
                 gpioclr(LCD_RESET);
                 gpioclr(LCD_BACKL);
             }
             void bsp_uart_init()
             {
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10
             A20   PE4  = RS      FSMC_NE1 PD7 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t LCD_DBxList[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10\
                                       ,PD4,PD5,PD7,PE4};
                 for(int i=0;i<12;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM4 configuration */
                 //p.FSMC_AddressSetupTime = 5;
                 //p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressSetupTime = 3;
                 p.FSMC_AddressHoldTime = 3;
                 //p.FSMC_DataSetupTime = 9;
                 //ili9328 -> data setup time > 10ns
                 p.FSMC_DataSetupTime = 1;
                 if(getCpuFreq()>100*1000*1000)
                     p.FSMC_DataSetupTime = 2;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 //ili9328 -> data hold time > 15ns
                 if(getCpuFreq()>66*1000*1000)
                     p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
                 gpioset(LCD_RESET);
                 gpioclr(LCD_RESET);
                 delay_100us(500);
                 gpioset(LCD_RESET);
                 delay_100us(500);
                 lcd0.init(&lcd0);
                 gpioset(LCD_BACKL);
                 return 1;
             }
             void bsp_spi_init()
             {
-                gpio_t VSSPI_DBxList[]={VS1053SCK,VS1053MOSI,VS1053MISO};
+            //    gpio_t VSSPI_DBxList[]={VS1053SCK,VS1053MOSI,VS1053MISO};
-                for(int i=0;i<3;i++)
+            //    for(int i=0;i<3;i++)
+            //    {
-                    gpio_t SPI_DBx = gpioopen(VSSPI_DBxList[i]);
+            //        gpio_t SPI_DBx = gpioopen(VSSPI_DBxList[i]);
-                    SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
+            //        SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
-                    gpiosetconfig(&SPI_DBx);
+            //        gpiosetconfig(&SPI_DBx);
-                    GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI1);
+            //        GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI1);
+            //    }
-                spiopenandconfig(VS1053SPI,spi8bits|spimaster|spimsbfirst,2*1000*1000,VS1053MOSI,VS1053MISO,VS1053SCK,-1);
+            //    spiopenandconfig(VS1053SPI,spi8bits|spimaster|spimsbfirst,2*1000*1000,VS1053MOSI,VS1053MISO,VS1053SCK,-1);
                 gpio_t SDSPI_DBxList[]={SDCARD2SCK,SDCARD2MOSI,SDCARD2MISO};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t SPI_DBx = gpioopen(SDSPI_DBxList[i]);
                     SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SPI_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI3);
                 }
                 spiopenandconfig(SDCARD2SPI,spi8bits|spimaster|spimsbfirst,400*1000,SDCARD2MOSI,SDCARD2MISO,SDCARD2SCK,-1);
             }
             void bsp_iic_init()
             {
                 // i2copenandconfig(i2c2,0,10000,PF0,PF1);
             }
             void bsp_Audio_init()
             {
                 vs10XXopen(&audioCodec0,VS1053SPI,vs1052setXCS,vs1052setRST,vs1052setXDCS,vs10XXDREQ);
             }
             void bsp_SD_init()
             {
-                sdcardDev sdcard2;
+            //    sdcardDev sdcard2;
-                blkdevice sdcard2blkdev;
+            //    blkdevice sdcard2blkdev;
-                dikpartition sdcard2Part1;
+            //    dikpartition sdcard2Part1;
-                sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);
+            //    sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);
-                sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);
+            //    sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);
-                sdcard2blkdev.initialize(&sdcard2blkdev);
+            //    sdcard2blkdev.initialize(&sdcard2blkdev);
-                mbropen(&sdcard2blkdev,&sdcard2Part1,1);
+            //    mbropen(&sdcard2blkdev,&sdcard2Part1,1);
             }
             void vs1052setXCS(char val)
             {
                 gpiosetval(VS1053xCS,(int)val);
             }
             void vs1052setXDCS(char val)
             {
                 gpiosetval(VS1053xDCS,(int)val);
             }
             void vs1052setRST(char val)
             {
                 if(val)
                     gpioset(VS1053xRESET);
                 else
                     gpioclr(VS1053xRESET);
             }
             int vs10XXDREQ()
             {
                 return gpiogetval(VS1053DREQ);
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return gpiogetval(SDCARD2CD);
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
                 if(YESNO)
                     gpioclr(SDCARD2CS);
                 else
                     gpioset(SDCARD2CS);
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[3];
                 *lcd0_DATA=pt8[2];
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[1];
                 *lcd0_DATA=pt8[0];
             #endif
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
                 uint32_t DATA=0;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[3]=*lcd0_DATA;
                 pt8[2]=*lcd0_DATA;
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[1]=*lcd0_DATA;
                 pt8[0]=*lcd0_DATA;
             #endif
                 return DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #endif
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
                 pt8[0] = *lcd0_DATA;
                 pt8[0] = *lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     pt8[(2*i) +1]=*lcd0_DATA;
                     pt8[2*i]=*lcd0_DATA;
                 }
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)buffer;
                 pt8[0] = *lcd0_DATA;
                 pt8[0] = *lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     pt8[(2*i) +1]=*lcd0_DATA;
                     pt8[2*i]=*lcd0_DATA;
                 }
             #endif
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

examples/SOLAR_PSU_HELLO/main.c +54 0

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <core.h>
             #include <VS10XX.h>
             #include <bsp.h>
+            #include <spi.h>
+            #include <sdcard.h>
+            #include <sdcard-spi.h>
+            #include <fat32.h>
+            #include <ucdirent.h>
+            #include <string.h>
             extern streamdevice* __opnfiles__[];
             void randBoxesDemo()
             {
                 int16_t x,y,w,h,t,r;
                 x=rand()%240;
                 y=rand()%320;
                 w=rand()%(240-x);
                 if(x>y)
                     r=(rand()%(y))%(320-y);
                 else
                     r=(rand()%(x))%(240-x);
                 h=rand()%(320-y);
                 t=rand()%(10);
                 ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
                 //ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
                 //delay_100us(10);
                 //for(volatile int i=0;i<(1024*2);i++);
             }
             int main()
             {
+                while(!bspsdcardpresent());
+                delay_100us(5000);
+                printf("About to initialize SDCARD");
+                sdcardDev sdcard2;
+                blkdevice sdcard2blkdev;
+                dikpartition sdcard2Part1;
+                FAT32fs partoche;
+                sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);
+                sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);
+                sdcard2blkdev.initialize(&sdcard2blkdev);
+                mbropen(&sdcard2blkdev,&sdcard2Part1,1);
+                if(FATnoErr==fat32open(&partoche,&sdcard2Part1))
+                {
+                    printf("FAT32 partition opened\n");
+                    char test[]="                                              \n";
+                    ucdirent root,folder;
+                    fat32mkdirent(&partoche,&root);
+                    fat32getrootfirstent(&root);
+                    fat32getVolName(&partoche,test);
+                    printf("Vol Name=%s\n",test);
+                    fat32getdirentname(&root,test);
+                    printf("%s\n",test);
+                    while (DIRENT_EndOfDir!=fat32nextdirent(&root))
+                    {
+                        if(test[0]=='m')
+                        {
+                            printf("enter music folder\n");
+                            fat32enterdirent(&root,&folder);
+                            while (DIRENT_EndOfDir!=fat32nextdirent(&folder))
+                            {
+                                printf("%s\n",test);
+                            }
+                        }
+                        fat32getdirentname(&root,test);
+                        printf("%s\n",test);
+                    }
+                    if(test[0]=='m')
+                    {
+                        printf("enter music folder\n");
+                        fat32enterdirent(&root,&folder);
+                        while (DIRENT_EndOfDir!=fat32nextdirent(&folder))
+                        {
+                            printf("%s\n",test);
+                        }
+                    }
+                }
                 while(1)
                 {
                     //        printf("Audio Codec reg0=0x%x\n",vs10XXcmdread(&audioCodec0,0));
                     // printf("hello ");
                     // bsp_lcd0_write_reg(1,0x1234);
                     // delay_100us(10000);
                     //             randBoxesDemo();
                     gpioset(LED1);
                     delay_100us(10000);
                     gpioclr(LED1);
                     delay_100us(10000);
                 }
                 printf("hello world\n\r");
                 return 0;
             }

lib/src/common/FILE_SYSTEM/MBR/mbr.c +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  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 3 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
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include "mbr.h"
             #include <stdio.h>
             int mbropen(blkdevice* phy,dikpartition* part,char partNum)
             {
             	printf("enter MBR open function\n");
             	char mbr[512];
             	if((part==0) || (phy ==0) || (partNum>4) || (partNum==0)  ) return MBRBabArg;
             	part->phy = phy;
             	if(phy->read(phy,mbr,0,1)!=RES_OK)
             	{
             		printf("can't read MBR!\n");
+                    printf("%x %x %x %x %x %x %x %x\n",mbr[0],mbr[1],mbr[2],mbr[3],mbr[4],mbr[5],mbr[6],mbr[7]);
             		return MBRReadErr;
             	}
             	if(((mbr[510]) == (char)0x55) && ((mbr[511]) == (char)0xAA))
             	{
             		part->TypeCode = mbr[(512-82+TypeCodeoffset)+partNum*16];
             		part->LBABegin = (unsigned int)mbr[(512-82+LBABeginoffset)+partNum*16] + ((unsigned int)mbr[(512-82+LBABeginoffset+1)+partNum*16]<<8)+ ((unsigned int)mbr[(512-82+LBABeginoffset+2)+partNum*16]<<16)+ ((unsigned int)mbr[(512-82+LBABeginoffset+3)+partNum*16]<<24);
             		part->NumOfSec = (unsigned int)mbr[(512-82+NumOfSecoffset)+partNum*16] + ((unsigned int)mbr[(512-82+NumOfSecoffset+1)+partNum*16]<<8)+ ((unsigned int)mbr[(512-82+NumOfSecoffset+2)+partNum*16]<<16)+ ((unsigned int)mbr[(512-82+NumOfSecoffset+3)+partNum*16]<<24);
             		printf("MBR Ok\n");
             		return MBRnoErr;
             	}
             	printf("Bad MBR MBR[510]=0x%.2X MBR[511]=0x%.2X!\n",0xff&mbr[510],0xff&mbr[511]);
             	return MBRBadMbr;
             }

lib/src/common/FILE_SYSTEM/SDCARD/sdcard.c +17 -8

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  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 3 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
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include <sdcard.h>
             #include <sdcard-spi.h>
             #include <stdio.h>
             #include <core.h>
             int sdcardselect (blkdeviceptr _this);
             void sdcarddeselect (blkdeviceptr _this);
             int sdcardwait_ready (sdcardDev* sdcard);
             int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token);
             int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,uint32_t btr);
             char sdcardsend_cmd (blkdeviceptr _this,char cmd,uint32_t arg);
             DSTATUS sdcarddisk_status (blkdeviceptr _this);
             DSTATUS sdcarddisk_initialize (blkdeviceptr _this);
             DRESULT sdcarddisk_read (blkdeviceptr _this,char *buff,uint32_t sector,char count);
             DRESULT sdcarddisk_write (blkdeviceptr _this,const char *buff,uint32_t sector,char count);
             DRESULT sdcarddisk_ioctl (blkdeviceptr _this,char ctrl,void *buff);
             static volatile
             unsigned int Timer1, Timer2;	/* 1kHz decrement timer stopped at zero (disk_timerproc()) */
             void sdcarddeselect (blkdeviceptr _this)
             {
             	char d;
             	_this->select(0);
             	((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);	/* Dummy clock (force DO hi-z for multiple slave SPI) */
             }
             int sdcardselect (blkdeviceptr _this)	/* 1:OK, 0:Timeout */
             {
             	char d;
             	_this->select(1);
             	((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);	/* Dummy clock (force DO enabled) */
             	if (sdcardwait_ready(((sdcardDev*)_this->phy))) return 1;	/* OK */
             	_this->select(0);
             	return 0;	/* Timeout */
             }
             int sdcardwait_ready (sdcardDev* sdcard)	/* 1:OK, 0:Timeout */
             {
                 char d=0;
             	unsigned int tmr;
             	volatile unsigned int i=0;
-                for (tmr = 1000; tmr>0; tmr--) {	/* Wait for ready in timeout of 500ms */
+                for (tmr = 500; tmr>0; tmr--) {	/* Wait for ready in timeout of 500ms */
             		sdcard->rcvr_mmc(sdcard->phy,&d, 1);
             		if (d == 0xFF) break;
                     delay_100us(10);
             	}
                 return tmr != 0;
             }
             int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,uint32_t btr)
             {
             	char d[2];
             	unsigned int tmr;
             	volatile unsigned int i=0;
-            	for (tmr = 50000; tmr; tmr--) {	/* Wait for data packet in timeout of 100ms */
+                for (tmr = 100; tmr; tmr--) {	/* Wait for data packet in timeout of 100ms */
             		sdcard->rcvr_mmc(sdcard->phy,d, 1);
             		if (d[0] != 0xFF) break;
-            		for(i=0;i<64;i++);
+                    delay_100us(10);
             	}
             	if (d[0] != 0xFE) return 0;		/* If not valid data token, return with error */
             	sdcard->rcvr_mmc(sdcard->phy,buff, btr);			/* Receive the data block into buffer */
             	sdcard->rcvr_mmc(sdcard->phy,d, 2);					/* Discard CRC */
             	return 1;						/* Return with success */
             }
             int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token)
             {
             	char d[2];
             	if (!sdcardwait_ready(sdcard)) return 0;
             	d[0] = token;
             	sdcard->xmit_mmc(sdcard->phy,d, 1);				/* Xmit a token */
             	if (token != 0xFD) {		/* Is it data token? */
             		sdcard->xmit_mmc(sdcard->phy,buff, 512);	/* Xmit the 512 byte data block to MMC */
             		sdcard->rcvr_mmc(sdcard->phy,d, 2);			/* Xmit dummy CRC (0xFF,0xFF) */
             		sdcard->rcvr_mmc(sdcard->phy,d, 1);			/* Receive data response */
             		if ((d[0] & 0x1F) != 0x05)	/* If not accepted, return with error */
             			return 0;
             	}
             	return 1;
             }
             char sdcardsend_cmd (blkdeviceptr _this,char cmd,uint32_t arg)
             {
             	char n, d, buf[6];
             	if (cmd & 0x80) {	/* ACMD<n> is the command sequense of CMD55-CMD<n> */
             		cmd &= 0x7F;
             		n = sdcardsend_cmd(_this,CMD55, 0);
             		if (n > 1) return n;
             	}
             	/* Select the card and wait for ready */
             	sdcarddeselect(_this);
                 if (!sdcardselect(_this)) {printf("Can't select SDCARD\n");return 0xFF;}
             	/* Send a command packet */
             	buf[0] = 0x40 | cmd;			/* Start + Command index */
             	buf[1] = (char)(arg >> 24);		/* Argument[31..24] */
             	buf[2] = (char)(arg >> 16);		/* Argument[23..16] */
             	buf[3] = (char)(arg >> 8);		/* Argument[15..8] */
             	buf[4] = (char)arg;				/* Argument[7..0] */
             	n = 0x01;						/* Dummy CRC + Stop */
             	if (cmd == CMD0) n = 0x95;		/* (valid CRC for CMD0(0)) */
             	if (cmd == CMD8) n = 0x87;		/* (valid CRC for CMD8(0x1AA)) */
             	if (cmd == CMD55) n = 0x63;
             	buf[5] = n;
             	((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,buf, 6);
             	/* Receive command response */
-            	if (cmd == CMD12) {((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);}	/* Skip a stuff byte when stop reading */
+                if (cmd == CMD12)
-            	n = 10;								/* Wait for a valid response in timeout of 10 attempts */
+                    ((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);
+                }	/* Skip a stuff byte when stop reading */
+                n = 100;								/* Wait for a valid response in timeout of 100 attempts */
             	do
             	{
             		((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);
+                    delay_100us(10);
             		//libucprintf("resp=%d\n\r",d);
+            	}while ((d & 0x80) && --n);
-            	while ((d & 0x80) && --n);
             	return d;			/* Return with the response value */
             }
             DSTATUS sdcarddisk_status (blkdeviceptr _this)
             {
             	DSTATUS s = ((sdcardDev*)_this->phy)->Stat;
             	char ocr[4];
             	if ((_this==0) || !_this->detect()) {
             		s = STA_NODISK | STA_NOINIT;
             	} else {
             		s &= ~STA_NODISK;
             		if (_this->writeprotected())						/* Check card write protection */
             			s |= STA_PROTECT;
             		else
             			s &= ~STA_PROTECT;
             		if (!(s & STA_NOINIT)) {
             			if (sdcardsend_cmd(_this,CMD58, 0))	/* Check if the card is kept initialized */
             				s |= STA_NOINIT;
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             			_this->select(0);
             		}
             	}
             	((sdcardDev*)_this->phy)->Stat = s;
             	return s;
             }
             DSTATUS sdcarddisk_initialize (blkdeviceptr _this)
             {
                 char cmd, ty, ocr[4],ocr2[4];
                 int n;
                 const char dummy=0xff;
                 uint32_t speed = 1000000;
             	((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,350000);
             	if (_this==0) return STA_NOINIT;			/* Supports only drive 0 */
                 /* Is card existing in the soket? */
                 if (((sdcardDev*)_this->phy)->Stat & STA_NODISK)
                 {
                     printf("No SDCARD\n");
                     return ((sdcardDev*)_this->phy)->Stat;
                 }
                 printf("SDCARD Detected\n");
             	for (n = 10; n; n--) ((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);	/* Send 80 dummy clocks */
             	ty = 0;
             	if (sdcardsend_cmd(_this,CMD0, 0) == 1) {			/* Put the card SPI/Idle state */
                     printf("SDCARD in Idle mode\n");
             		Timer1 = 1000;						/* Initialization timeout = 1 sec */
             		if (sdcardsend_cmd(_this,CMD8, 0x1AA) == 1) {	/* SDv2? */
+                        printf("SDCARD V2\n");
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             			//for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);	/* Get 32 bit return value of R7 resp */
             			if (ocr[2] == 0x01 && ocr[3] == 0xAA) {				/* Is the card supports vcc of 2.7-3.6V? */
+                            printf("The card supports vcc of 2.7-3.6V\n");
             				while (Timer1 && sdcardsend_cmd(_this,ACMD41, 1UL << 30)) ;	/* Wait for end of initialization with ACMD41(HCS) */
             				if (Timer1 && sdcardsend_cmd(_this,CMD58, 0) == 0) {		/* Check CCS bit in the OCR */
             					//for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);
+                                printf("Check CCS bit in the OCR:\n");
                                 ((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
+                                printf("OCR[0]=0x%X\n",ocr[0]);
             					ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;	/* Card id SDv2 */
             				}
             			}
             		} else {	/* Not SDv2 card */
             			if (sdcardsend_cmd(_this,ACMD41, 0) <= 1) 	{	/* SDv1 or MMC? */
             				ty = CT_SD1; cmd = ACMD41;	/* SDv1 (ACMD41(0)) */
             			} else {
             				ty = CT_MMC; cmd = CMD1;	/* MMCv3 (CMD1(0)) */
             			}
             			while (Timer1 && sdcardsend_cmd(_this,cmd, 0)) ;		/* Wait for end of initialization */
             			if (!Timer1 || sdcardsend_cmd(_this,CMD16, 512) != 0)	/* Set block length: 512 */
             				ty = 0;
             		}
             	}
             	((sdcardDev*)_this->phy)->CardType = ty;	/* Card type */
+                printf("CardType=0x%X\n",ty);
             	if (ty) {			/* OK */
             		((sdcardDev*)_this->phy)->Stat &= ~STA_NOINIT;	/* Clear STA_NOINIT flag */
             		sdcardsend_cmd(_this,CMD58, 0);
             		((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             		do
             		{
             			speed+=1000000;
             			((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,speed);
             			sdcardsend_cmd(_this,CMD58, 0);
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr2, 4);
             			for(n=0;n<4;n++)
             			{
             				if(ocr[n]!=ocr2[n])
             				{
             					n=0;
             					break;
             				}
             			}
-            			if(speed>(50*1000*1000))
+                        if((speed>(50*1000*1000)) || (speed >= getCpuFreq()))
             			{
             				break;
             			}
             		}while(n);
             		if(!n)
             		{
             			speed-=1000000;
             			((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,speed);
             		}
+                    printf("SDCARD speed = %dMHz\n",speed/1000000);
             	} else {			/* Failed */
             		//power_off();
             		((sdcardDev*)_this->phy)->Stat = STA_NOINIT;
             	}
             	sdcarddeselect (_this);
             	return ((sdcardDev*)_this->phy)->Stat;
             }
             DRESULT sdcarddisk_read (blkdeviceptr _this,char *buff,uint32_t sector,char count)
             {
             	DSTATUS s;
             	s = sdcarddisk_status(_this);
             	if (s & STA_NOINIT) return RES_NOTRDY;
             	if (!count) return RES_PARERR;
             	if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) sector *= 512;	/* Convert LBA to byte address if needed */
             	if (count == 1) {	/* Single block read */
             		if ((sdcardsend_cmd(_this,CMD17, sector) == 0) && sdcardrcvr_datablock((sdcardDev*)(_this->phy),buff, 512))
             			count = 0;
             	}
             	else {				/* Multiple block read */
             		if (sdcardsend_cmd(_this,CMD18, sector) == 0) {	/* READ_MULTIPLE_BLOCK */
             			do {
             				if (!sdcardrcvr_datablock (((sdcardDev*)_this->phy),buff, 512)) break;
             				buff += 512;
             			} while (--count);
             			sdcardsend_cmd(_this,CMD12, 0);				/* STOP_TRANSMISSION */
             		}
             	}
             	sdcarddeselect (_this);
             	return count ? RES_ERROR : RES_OK;
             }
             DRESULT sdcarddisk_write (blkdeviceptr _this,const char *buff,uint32_t sector,char count)
             {
             	DSTATUS s;
             	s = sdcarddisk_status(_this);
             	if (s & STA_NOINIT) return RES_NOTRDY;
             	if (s & STA_PROTECT) return RES_WRPRT;
             	if (!count) return RES_PARERR;
             	if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) sector *= 512;	/* Convert LBA to byte address if needed */
             	if (count == 1) {	/* Single block write */
             		if ((sdcardsend_cmd(_this,CMD24, sector) == 0)	/* WRITE_BLOCK */
             			&& sdcardxmit_datablock (((sdcardDev*)_this->phy),buff, 0xFE))
             			count = 0;
             	}
             	else {				/* Multiple block write */
             		if (((sdcardDev*)_this->phy)->CardType & CT_SDC) sdcardsend_cmd(_this,ACMD23, count);
             		if (sdcardsend_cmd(_this,CMD25, sector) == 0) {	/* WRITE_MULTIPLE_BLOCK */
             			do {
             				if (!sdcardxmit_datablock (((sdcardDev*)_this->phy),buff, 0xFC)) break;
             				buff += 512;
             			} while (--count);
             			if (!sdcardxmit_datablock (((sdcardDev*)_this->phy),0, 0xFD))	/* STOP_TRAN token */
             				count = 1;
             		}
             	}
             	sdcarddeselect (_this);
             	return count ? RES_ERROR : RES_OK;
             }
             DRESULT sdcarddisk_ioctl (blkdeviceptr _this,char ctrl,void *buff)
             {
             	DRESULT res;
                 const char dummy=0xff;
             	char n, csd[16], *ptr = buff;
                 uint16_t csize;
                 uint32_t *dp, st, ed;
             	if (_this==0) return RES_PARERR;					/* Check parameter */
             	if (((sdcardDev*)_this->phy)->Stat & STA_NOINIT) return RES_NOTRDY;	/* Check if drive is ready */
             	res = RES_ERROR;
             	switch (ctrl) {
             	case CTRL_SYNC :		/* Wait for end of internal write process of the drive */
             		if (sdcardselect (_this)) {
             			sdcarddeselect (_this);
             			res = RES_OK;
             		}
             		break;
             	case GET_SECTOR_COUNT :	/* Get drive capacity in unit of sector (DWORD) */
             		if ((sdcardsend_cmd(_this,CMD9, 0) == 0) && sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {
             			if ((csd[0] >> 6) == 1) {	/* SDC ver 2.00 */
                             csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
                             *(uint32_t*)buff = (uint32_t)csize << 10;
             			} else {					/* SDC ver 1.XX or MMC ver 3 */
             				n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
                             csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
                             *(uint32_t*)buff = (uint32_t)csize << (n - 9);
             			}
             			res = RES_OK;
             		}
             		break;
             	case GET_SECTOR_SIZE :	/* Get sector size in unit of byte (WORD) */
                     *(uint16_t*)buff = 512;
             		res = RES_OK;
             		break;
             	case GET_BLOCK_SIZE :	/* Get erase block size in unit of sector (DWORD) */
             		if (((sdcardDev*)_this->phy)->CardType & CT_SD2) {	/* SDC ver 2.00 */
             			if (sdcardsend_cmd(_this,ACMD13, 0) == 0) {	/* Read SD status */
             				((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             				if (sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {				/* Read partial block */
             					for (n = 64 - 16; n; n--) ((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);	/* Purge trailing data */
                                 *(uint32_t*)buff = 16UL << (csd[10] >> 4);
             					res = RES_OK;
             					((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             				}
             			}
             		} else {					/* SDC ver 1.XX or MMC */
             			if ((sdcardsend_cmd(_this,CMD9, 0) == 0) && sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {	/* Read CSD */
             				if (((sdcardDev*)_this->phy)->CardType & CT_SD1) {	/* SDC ver 1.XX */
                                 *(uint32_t*)buff = (((csd[10] & 63) << 1) + ((uint16_t)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
             				} else {					/* MMC */
                                 *(uint32_t*)buff = ((uint16_t)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
             				}
             				res = RES_OK;
             			}
             		}
             		break;
             	case CTRL_ERASE_SECTOR :	/* Erase a block of sectors (used when _USE_ERASE == 1) */
             		if (!(((sdcardDev*)_this->phy)->CardType & CT_SDC)) break;				/* Check if the card is SDC */
             		if (sdcarddisk_ioctl(_this, MMC_GET_CSD, csd)) break;	/* Get CSD */
             		if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break;	/* Check if sector erase can be applied to the card */
             		dp = buff; st = dp[0]; ed = dp[1];				/* Load sector block */
             		if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) {
             			st *= 512; ed *= 512;
             		}
             		if (sdcardsend_cmd(_this,CMD32, st) == 0 && sdcardsend_cmd(_this,CMD33, ed) == 0 && sdcardsend_cmd(_this,CMD38, 0) == 0 && sdcardwait_ready(((sdcardDev*)_this->phy)))	/* Erase sector block */
             			res = RES_OK;	/* FatFs does not check result of this command */
             		break;
             	/* Following command are not used by FatFs module */
             	case MMC_GET_TYPE :		/* Get MMC/SDC type (BYTE) */
             		*ptr = ((sdcardDev*)_this->phy)->CardType;
             		res = RES_OK;
             		break;
             	case MMC_GET_CSD :		/* Read CSD (16 bytes) */
             		if (sdcardsend_cmd(_this,CMD9, 0) == 0		/* READ_CSD */
             			&& sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 16))
             			res = RES_OK;
             		break;
             	case MMC_GET_CID :		/* Read CID (16 bytes) */
             		if (sdcardsend_cmd(_this,CMD10, 0) == 0		/* READ_CID */
             			&& sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 16))
             			res = RES_OK;
             		break;
             	case MMC_GET_OCR :		/* Read OCR (4 bytes) */
             		if (sdcardsend_cmd(_this,CMD58, 0) == 0) {	/* READ_OCR */
             			//for (n = 4; n; n--) *ptr++ =
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ptr, 4);
             			res = RES_OK;
             		}
             		break;
             	case MMC_GET_SDSTAT :	/* Read SD status (64 bytes) */
             		if (sdcardsend_cmd(_this,ACMD13, 0) == 0) {	/* SD_STATUS */
             			((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             			if (sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 64))
             				res = RES_OK;
             		}
             		break;
             	default:
             		res = RES_PARERR;
             	}
             	sdcarddeselect (_this);
             	return res;
             }
             void sdcardspimake(sdcardDev* sdcard,UHANDLE phy,void (*rcvr_mmc) (UHANDLE,char *,uint32_t),void (*xmit_mmc) (UHANDLE,const char *,uint32_t ),void (*setspeed) (UHANDLE phy,uint32_t speed),uint32_t (*getspeed) (UHANDLE phy))
             {
             	sdcard->phy = phy;
             	sdcard->rcvr_mmc = rcvr_mmc;
             	sdcard->xmit_mmc = xmit_mmc;
             	sdcard->setspeed = setspeed;
             	sdcard->getspeed = getspeed;
             }
              void sdcardspimakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected)
              {
              	dev->phy=sdcard;
              	dev->select=select;
              	dev->power = power;
              	dev->detect = detect;
              	dev->writeprotected = writeprotected;
              	dev->write = sdcarddisk_write;
              	dev->read = sdcarddisk_read;
              	dev->ioctl = sdcarddisk_ioctl;
              	dev->initialize = sdcarddisk_initialize;
              	dev->status = sdcarddisk_status;
              }

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal.c +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  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 3 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
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include <widget.h>
             #include <terminal.h>
             #include <stdint.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <core.h>
             #define CHARXPOS(terminal,charwidth) (((terminal)->column * charwidth) + (terminal)->Xpos)
             #define CHARYPOS(terminal,charheight) ((terminal)->line * charheight + (terminal)->Ypos+charheight)
             streamdevice_ops TERMINAL_OPS=
             {
                 .write = &terminal_write,
                 .read  = &terminal_read,
                 .setpos= &terminal_setpos,
                 .close = NULL
             };
             int terminal_init(terminal_t* terminal,LCD_t* LCD,sFONT* font,streamdevice* strdev)
             {
                 if((LCD!=NULL) && (font!=NULL) && (strdev!=NULL) && (terminal!=NULL))
                 {
                     terminal->LCD=LCD;
                     terminal->font=font;
                     terminal->line = 0;
                     terminal->column = 0;
-                    terminal->horizontalSpace=-2;
+                    terminal->horizontalSpace=0;
-                    terminal->verticalSpace=2;
+                    terminal->verticalSpace=0;
                     int charw=terminal->font->Width + terminal->horizontalSpace;
                     int charh=terminal->font->Height + terminal->verticalSpace;
                     terminal->textColor=0xFFFF;
                     terminal->backgroundColor=0x0000;
                     terminal_setgeometry(terminal,5,5,terminal->LCD->width-(10),terminal->LCD->height-(10));
                     strdev->_stream = (UHANDLE)terminal;
                     strdev->ops = &TERMINAL_OPS;
                     strdev->streamPt = 0;
                     terminal_clear(terminal);
                     terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
                     return 1;
                 }
                 return 0;
             }
             void terminal_setgeometry(terminal_t* terminal,uint16_t Xpos,uint16_t Ypos,uint16_t width,uint16_t height)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 if(terminal->LCD->height<(Ypos+height))
                     return;
                 if(terminal->LCD->width<(Xpos+width))
                     return;
                 terminal->Xpos = Xpos;
                 terminal->Ypos = Ypos;
                 terminal->height = height;
                 terminal->width = width;
                 terminal->lineCount = terminal->height/charh;
                 terminal->columnCount = (terminal->width/charw)-1;
                 terminal_clear(terminal);
             }
             void terminal_clear(terminal_t* terminal)
             {
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,terminal->Ypos,terminal->width,terminal->height,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             void terminal_setbackgroundColor(terminal_t* terminal, uint32_t backgrooundColor)
             {
                 terminal->backgroundColor = backgrooundColor;
             }
             void terminal_settextColor(terminal_t* terminal, uint32_t textColor)
             {
                 terminal->textColor = textColor;
             }
             void terminal_movecursor(terminal_t* terminal,int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal->column += n;
                 if(terminal->column>terminal->columnCount)
                 {
                     terminal->line += (terminal->column)/terminal->columnCount;
                     terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal,charh)-charh,charw*(terminal->columnCount-terminal->column),charh,terminal->backgroundColor,0,terminal->backgroundColor);
                     terminal->line = terminal->line % terminal->lineCount;
                     terminal->column = terminal->column % terminal->columnCount;
                 }
                 terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal,charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             void terminal_clearCurentLine(terminal_t* terminal)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,CHARYPOS(terminal, charh)-charh,terminal->width,charh,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             int terminal_writenc(terminal_t* terminal,char* data, int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 int l=0;
                 char buffer[2]=" ";
                 while(l<n)
                 {
                     buffer[0]=data[l];
                     if(buffer[0]=='\n')
                     {
                         terminal->line= (terminal->line+1) % terminal->lineCount;
                         terminal->column = 0;
                     }else {
                         if(buffer[0]=='\t')
                         {
                             for(int i=0;i<1;i++)terminal_movecursor(terminal,1);
                         }else
                             if(terminal->column==0)terminal_clearCurentLine(terminal);
                             if(buffer[0]!='\r'){
                                 terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
                                 terminal->LCD->paintText(terminal->LCD,buffer,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh),terminal->font,terminal->textColor);
                                 terminal_movecursor(terminal,1);
                             }
                     }
                     l++;
                 }
                 return n;
             }
             int terminal_write(streamdevice* device,void* data,int size, int n)
             {
                 return terminal_writenc((terminal_t*)device->_stream,(char*) data,size*n);
             }
             int terminal_read(streamdevice* device,void* data,int size, int n)
             {
                 return n*size;
             }
             int terminal_setpos(streamdevice* device,int pos)
             {
                 return 1;
             }
             int terminal_close( streamdevice* device)
             {
                 return 1;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages