HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r62:25c982b9ed94

Fat32 library partially working, can read a file.

jeandet -

r62:25c982b9ed94 dev_alexis

parent child

Context file:

r62:25c982b9ed94

Collapse all files

bsp/src/OPLAYER/bsp.c +105 -22

             /*------------------------------------------------------------------------------
             --  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;
+            sdcardDev sdcard2;
+            blkdevice sdcard2blkdev;
+            dikpartition sdcard2Part1;
+            FAT32fs sdcard2FAT32part1;
+            dikpartition sdcard2Part2;
+            FAT32fs sdcard2FAT32part2;
+            dikpartition sdcard2Part3;
+            FAT32fs sdcard2FAT32part3;
+            dikpartition sdcard2Part4;
+            FAT32fs sdcard2FAT32part4;
             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};
+                gpio_t GPIO_In_init_List[]={VS1053DREQ,SDCARD2CD,BP3};
-                for(int i=0;i<2;i++)
+                for(int i=0;i<3;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);
+                if(audioCodec0.VERSION!=UNKNOWN)
+                {
+                    printf("detected Audio codec ");
+                    switch (audioCodec0.VERSION) {
+                    case VS1001:
+                        printf("VS1001\n");
+                        break;
+                    case VS1011:
+                        printf("VS1011\n");
+                        break;
+                    case VS1002:
+                        printf("VS1002\n");
+                        break;
+                    case VS1003:
+                        printf("VS1003\n");
+                        break;
+                    case VS1053:
+                        printf("VS1053\n");
+                        break;
+                    case VS1033:
+                        printf("VS1033\n");
+                        break;
+                    case VS1103:
+                        printf("VS1103\n");
+                        break;
+                    default:
+                        printf("Unknown device\n");
+                        break;
+                    }
+                }
             }
             void bsp_SD_init()
             {
-            //    sdcardDev sdcard2;
+                if(bspsdcardpresent())
-            //    blkdevice sdcard2blkdev;
-            //    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);
+                    if(sdcard2blkdev.initialize(&sdcard2blkdev)!=STA_NOINIT)
-            //    sdcard2blkdev.initialize(&sdcard2blkdev);
-            //    mbropen(&sdcard2blkdev,&sdcard2Part1,1);
+                        if(mbropen(&sdcard2blkdev,&sdcard2Part1,1)==MBRnoErr)
+                        {
+                            if(FATnoErr!=fat32open(&sdcard2FAT32part1,&sdcard2Part1))
+                                printf("Can't open fat32 partition 1\n");
+                        }
+                        else
+                        {
+                            printf("Can't open or read MBR\n");
+                        }
+                        if(mbropen(&sdcard2blkdev,&sdcard2Part2,2)==MBRnoErr)
+                        {
+                            if(FATnoErr!=fat32open(&sdcard2FAT32part2,&sdcard2Part2))
+                                printf("Can't open fat32 partition 2\n");
+                        }
+                        else
+                        {
+                            printf("Can't open or read MBR\n");
+                        }
+                        if(mbropen(&sdcard2blkdev,&sdcard2Part3,3)==MBRnoErr)
+                        {
+                            if(FATnoErr!=fat32open(&sdcard2FAT32part3,&sdcard2Part3))
+                                printf("Can't open fat32 partition 3\n");
+                        }
+                        else
+                        {
+                            printf("Can't open or read MBR\n");
+                        }
+                        if(mbropen(&sdcard2blkdev,&sdcard2Part4,4)==MBRnoErr)
+                        {
+                            if(FATnoErr!=fat32open(&sdcard2FAT32part4,&sdcard2Part4))
+                                printf("Can't open fat32 partition 4\n");
+                        }
+                        else
+                        {
+                            printf("Can't open or read MBR\n");
+                        }
+                    }
+                    else
+                    {
+                        printf("Can't initialize SDCARD\n");
+                    }
+                }
             }
             void vs1052setXCS(char val)
             {
                 gpiosetval(VS1053xCS,(int)val);
             }
             void vs1052setXDCS(char val)
             {
+                //gpiosetval(LED1,(int)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)
             {
+             //   gpiosetval(LED1,(int)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
                 {
                 }
             }

bsp/src/OPLAYER/bsp.h +17 0

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #include <spi.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
+            #include <sdcard-spi.h>
+            #include <sdcard.h>
+            #include <mbr.h>
             #include <VS10XX.h>
+            #include <fat32.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             #define LED1 PC15
             #define LED2 PC14
+            #define BP3   PA0
             #define LCD_RESET PD10
             #define LCD_BACKL PE11
             #define VS1053SPI    spi1
             #define VS1053xCS    PA3
             #define VS1053xRESET PA2
             #define VS1053xDCS   PA4
             #define VS1053DREQ   PA1
             #define VS1053MISO   PA6
             #define VS1053MOSI   PA7
             #define VS1053SCK    PA5
             #define SDCARD2SPI   spi3
             #define SDCARD2CS    PB8
             #define SDCARD2CD    PB9
             #define SDCARD2MISO  PB4
             #define SDCARD2MOSI  PB5
             #define SDCARD2SCK   PB3
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern volatile vs10XXDev audioCodec0;
+            extern sdcardDev sdcard2;
+            extern blkdevice sdcard2blkdev;
+            extern dikpartition sdcard2Part1;
+            extern FAT32fs sdcard2FAT32part1;
+            extern dikpartition sdcard2Part2;
+            extern FAT32fs sdcard2FAT32part2;
+            extern dikpartition sdcard2Part3;
+            extern FAT32fs sdcard2FAT32part3;
+            extern dikpartition sdcard2Part4;
+            extern FAT32fs sdcard2FAT32part4;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern void bsp_Audio_init();
             extern void bsp_GTerm_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void vs1052setXCS(char val);
             extern void vs1052setXDCS(char val);
             extern void vs1052setRST(char val);
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

examples/SOLAR_PSU_HELLO/main.c +135 -61

@@ -1,108 +1,182
1	#include <stdio.h>	1	#include <stdio.h>
2	#include <fat32.h>	2	#include <fat32.h>
3	#include <gpio.h>	3	#include <gpio.h>
4	#include <uart.h>	4	#include <uart.h>
5	#include <stm32f4xx.h>	5	#include <stm32f4xx.h>
6	#include <bsp.h>	6	#include <bsp.h>
7	#include <core.h>	7	#include <core.h>
8	#include <VS10XX.h>	8	#include <VS10XX.h>
9	#include <bsp.h>	9	#include <bsp.h>
10	#include <spi.h>	10	#include <spi.h>
11	#include <sdcard.h>	11	#include <sdcard.h>
12	#include <sdcard-spi.h>	12	#include <sdcard-spi.h>
13	#include <fat32.h>	13	#include <fat32.h>
14	#include <ucdirent.h>	14	#include <ucdirent.h>
15	#include <string.h>	15	#include <string.h>
		16	#include <terminal.h>
16		17
17		18
18	extern streamdevice* __opnfiles__[];	19	extern streamdevice* __opnfiles__[];
		20	char buffer[512];
19		21
20	void randBoxesDemo()	22	void randBoxesDemo()
21	{	23	{
22	int16_t x,y,w,h,t,r;	24	int16_t x,y,w,h,t,r;
23	x=rand()%240;	25	x=rand()%240;
24	y=rand()%320;	26	y=rand()%320;
25	w=rand()%(240-x);	27	w=rand()%(240-x);
26	if(x>y)	28	if(x>y)
27	r=(rand()%(y))%(320-y);	29	r=(rand()%(y))%(320-y);
28	else	30	else
29	r=(rand()%(x))%(240-x);	31	r=(rand()%(x))%(240-x);
30	h=rand()%(320-y);	32	h=rand()%(320-y);
31	t=rand()%(10);	33	t=rand()%(10);
32	ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());	34	ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
33	//ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());	35	//ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
34	//delay_100us(10);	36	//delay_100us(10);
35	//for(volatile int i=0;i<(1024*2);i++);	37	//for(volatile int i=0;i<(1024*2);i++);
36	}	38	}
		39	void tryToplay1()
		40	{
		41
		42	extern FAT32fs sdcard2FAT32part1;
		43	extern volatile vs10XXDev audioCodec0;
		44	ucdirent root;
		45	char direntName[]=" \n";
		46	uint32_t fileLba,nextLba;
		47	int i=0;
		48	spisetspeed(audioCodec0.SPIdev,2000000);
		49	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))
		50	{
		51	if(DIRENT_noErr==fat32getrootfirstent(&root))
		52	{
		53	do{
		54	fat32getdirentname(&root,direntName);
		55	printf("%s\n",direntName);
		56	nextLba=fat32getdirentlba(&root);
		57	printf("Streaming File\n");
		58	do
		59	{
		60	fileLba = nextLba;
		61	if(sdcard2FAT32part1.part->phy->read(sdcard2FAT32part1.part->phy,buffer,fileLba,1)==RES_OK)
		62	{
		63	for(i=0;i<512;i+=32)
		64	{
		65	vs10XXstream32bytes(&audioCodec0,buffer+i);
		66	}
		67	}
		68	}while ((fat32nextsectorlba(&sdcard2FAT32part1,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
		69	//vs10XXsoftReset(&audioCodec0);
		70	while (gpiogetval(BP3))delay_100us(1000);
		71	printf("looking for next file\n");
		72	}while (DIRENT_noErr==fat32nextdirent(&root));
		73	}
		74	}
		75	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
		76	{
		77	if(DIRENT_noErr==fat32getrootfirstent(&root))
		78	{
		79	fat32getdirentname(&root,direntName);
		80	printf("%s\n",direntName);
		81	nextLba=fat32getdirentlba(&root);
		82	printf("Streaming File\n");
		83	do
		84	{
		85	fileLba = nextLba;
		86	if(sdcard2FAT32part2.part->phy->read(sdcard2FAT32part2.part->phy,buffer,fileLba,1)==RES_OK)
		87	{
		88	for(i=0;i<512;i+=32)
		89	{
		90	vs10XXstream32bytes(&audioCodec0,buffer+i);
		91	}
		92	}
		93	}while ((fat32nextsectorlba(&sdcard2FAT32part2,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
		94	while (gpiogetval(BP3))delay_100us(1000);
		95	}
		96	}
		97	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part3,&root))
		98	{
		99	if(DIRENT_noErr==fat32getrootfirstent(&root))
		100	{
		101	fat32getdirentname(&root,direntName);
		102	printf("%s\n",direntName);
		103	nextLba=fat32getdirentlba(&root);
		104	printf("Streaming File\n");
		105	do
		106	{
		107	fileLba = nextLba;
		108	if(sdcard2FAT32part3.part->phy->read(sdcard2FAT32part3.part->phy,buffer,fileLba,1)==RES_OK)
		109	{
		110	for(i=0;i<512;i+=32)
		111	{
		112	vs10XXstream32bytes(&audioCodec0,buffer+i);
		113	}
		114	}
		115	}while ((fat32nextsectorlba(&sdcard2FAT32part3,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
		116	while (gpiogetval(BP3))delay_100us(1000);
		117	}
		118	}
		119	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part4,&root))
		120	{
		121	if(DIRENT_noErr==fat32getrootfirstent(&root))
		122	{
		123	fat32getdirentname(&root,direntName);
		124	printf("%s\n",direntName);
		125	nextLba=fat32getdirentlba(&root);
		126	printf("Streaming File\n");
		127	do
		128	{
		129	fileLba = nextLba;
		130	if(sdcard2FAT32part4.part->phy->read(sdcard2FAT32part4.part->phy,buffer,fileLba,1)==RES_OK)
		131	{
		132	for(i=0;i<512;i+=32)
		133	{
		134	vs10XXstream32bytes(&audioCodec0,buffer+i);
		135	}
		136	}
		137	}while ((fat32nextsectorlba(&sdcard2FAT32part4,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
		138	while (gpiogetval(BP3))delay_100us(1000);
		139	}
		140	}
		141	}
		142	void tryToplay2()
		143	{
		144
		145	extern blkdevice sdcard2blkdev;
		146	int i=0,l=0;
		147
		148	spisetspeed(audioCodec0.SPIdev,4000000);
		149	printf("Streaming File\n");
		150
		151	//printf("New LBA=0x%X\n",nextLba);
		152
		153	while(sdcard2blkdev.read(&sdcard2blkdev,buffer,l++,1)==RES_OK)
		154	{
		155
		156	for(i=0;i<512;i+=32)
		157	{
		158	vs10XXstream32bytes(&audioCodec0,buffer+i);
		159	}
		160	}
		161	}
37		162
38	int main()	163	int main()
39	{	164	{
40	while(!bspsdcardpresent());	165	extern terminal_t terminal0;
41	delay_100us(5000);	166	extern volatile vs10XXDev audioCodec0;
42	printf("About to initialize SDCARD");	167	printf("Volume=0x%x\n",vs10XXcmdread(&audioCodec0,VSVOL));
43	sdcardDev sdcard2;	168	vs10XXcmdwrite(&audioCodec0,VSCLOCKF,0x2000);
44	blkdevice sdcard2blkdev;	169	vs10XXcmdwrite(&audioCodec0,VSVOL,0x2222);
45	dikpartition sdcard2Part1;	170	printf("VSCLOCKF=0x%x\n",vs10XXcmdread(&audioCodec0,VSCLOCKF));
46	FAT32fs partoche;	171	printf("VSMODE=0x%x\n",vs10XXcmdread(&audioCodec0,VSMODE));
47	sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);	172	terminal_clear(&terminal0);
48	sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);	173	// tryToplay2();
49	sdcard2blkdev.initialize(&sdcard2blkdev);	174	tryToplay1();
50	mbropen(&sdcard2blkdev,&sdcard2Part1,1);
51	if(FATnoErr==fat32open(&partoche,&sdcard2Part1))
52	{
53	printf("FAT32 partition opened\n");
54	char test[]=" \n";
55	ucdirent root,folder;
56	fat32mkdirent(&partoche,&root);
57	fat32getrootfirstent(&root);
58	fat32getVolName(&partoche,test);
59	printf("Vol Name=%s\n",test);
60	fat32getdirentname(&root,test);
61	printf("%s\n",test);
62	while (DIRENT_EndOfDir!=fat32nextdirent(&root))
63	{
64	if(test[0]=='m')
65	{
66	printf("enter music folder\n");
67	fat32enterdirent(&root,&folder);
68	while (DIRENT_EndOfDir!=fat32nextdirent(&folder))
69	{
70	printf("%s\n",test);
71	}
72	}
73	fat32getdirentname(&root,test);
74	printf("%s\n",test);
75	}
76	if(test[0]=='m')
77	{
78	printf("enter music folder\n");
79	fat32enterdirent(&root,&folder);
80	while (DIRENT_EndOfDir!=fat32nextdirent(&folder))
81	{
82	printf("%s\n",test);
83	}
84	}
85	}
86	while(1)
87	{
88	// printf("Audio Codec reg0=0x%x\n",vs10XXcmdread(&audioCodec0,0));
89	// printf("hello ");
90	// bsp_lcd0_write_reg(1,0x1234);
91	// delay_100us(10000);
92	// randBoxesDemo();
93
94	gpioset(LED1);
95	delay_100us(10000);
96	gpioclr(LED1);
97	delay_100us(10000);
98
99	}
100	printf("hello world\n\r");
101	return 0;	175	return 0;
102	}	176	}
103		177
104		178
105		179
106		180
107		181
108		182

lib/src/common/AUDIO/VS10XX/VS10XX.c +60 0

             /*------------------------------------------------------------------------------
             #--  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 <spi.h>
             #include <VS10XX.h>
             #include <core.h>
+            #include <stdio.h>
             //#include <bsp.h>
             void vs10XXopen(vs10XXDev *codec, spi_t dev, void (*setxCS)(char), void (*setxRST)(char), void (*setxDCS)(char), int (*getDREQ)())
             {
                 codec->SPIdev = dev;
                 codec->setxCS = setxCS;
                 codec->setxDCS = setxDCS;
                 codec->setxRST = setxRST;
                 codec->getDREQ = getDREQ;
                 codec->setxDCS(1);
                 codec->setxCS(1);
                 codec->setxRST(0);
                 delay_100us(2);
                 codec->setxRST(1);
+                int status;
+                do{
+                status= vs10XXcmdread(codec,VSSTATUS);
+                }while (status==0xc);
+                printf("Status=0x%x\n",status);
+                status = (status>>4) & 0xF;
+                switch (status) {
+                case 0:
+                    codec->VERSION = VS1001;
+                    break;
+                case 1:
+                    codec->VERSION = VS1011;
+                    break;
+                case 2:
+                    codec->VERSION = VS1002;
+                    break;
+                case 3:
+                    codec->VERSION = VS1003;
+                    break;
+                case 4:
+                    codec->VERSION = VS1053;
+                    break;
+                case 5:
+                    codec->VERSION = VS1033;
+                    break;
+                case 7:
+                    codec->VERSION = VS1103;
+                    break;
+                default:
+                    codec->VERSION = UNKNOWN;
+                    break;
+                }
             }
             void vs10XXsoftreset(vs10XXDev* dev)
             {
                 vs10XXcmdwrite(dev,VSMODE,(1<<2));
             }
+            void vs10XXsetCansel(vs10XXDev* dev)
+            {
+                int mode=vs10XXcmdread(dev,VSMODE);
+                vs10XXcmdwrite(dev,VSMODE,mode|8);
+            }
+            void vs10XXsoftReset(vs10XXDev* dev)
+            {
+                int mode=vs10XXcmdread(dev,VSMODE);
+                vs10XXcmdwrite(dev,VSMODE,mode|4);
+            }
+            int vs10XXcanselAccepted(vs10XXDev* dev)
+            {
+                int mode=vs10XXcmdread(dev,VSMODE);
+                return ((mode & 8)!=8);
+            }
             int vs10XXcmdread(vs10XXDev* dev,char address)
             {
                 int result;
                 while(!dev->getDREQ());
                 dev->setxCS(0);
                 spiputw(dev->SPIdev,3);
                 spiputw(dev->SPIdev,address);
                 result = (0xFF00 & (spigetw(dev->SPIdev)<<8)) + (0xFF & spigetw(dev->SPIdev));
                 dev->setxCS(1);
             	return result;
             }
             void vs10XXcmdwrite(vs10XXDev* dev,char address,int value)
             {
                 while(!dev->getDREQ());
                 dev->setxCS(0);
                 spiputw(dev->SPIdev,2<<8);
                 spiputw(dev->SPIdev,address);
                 spiputw(dev->SPIdev,value>>8);
                 spiputw(dev->SPIdev,value);
                 dev->setxCS(1);
             }
+            void vs10XXstream32bytes(vs10XXDev* dev,char* buffer)
+            {
+                while(!dev->getDREQ());
+                dev->setxCS(1);
+                dev->setxDCS(0);
+                spiputnc(dev->SPIdev,buffer,32);
+                dev->setxDCS(1);
+            }

lib/src/common/FILE_SYSTEM/FAT32/fat32.c +16 -6

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #define FAT32_PRIVATE
             #include <fat32.h>
             #include <stdio.h>
             #include <stdint.h>
             #include <hexviewer.h>
             char fat32buff[512];
             uint32_t lastSecAddrs=-1;
             FAT32fs* lastFATFS=0;
             int fat32open(FAT32fs* fs,dikpartition* part)
             {
             	char sector[512];
             	fs->part = part;
             	if(!isFat32(fs->part->TypeCode))return FATBadpart;
             	if(fs->part->phy->read(fs->part->phy,sector,fs->part->LBABegin,1)!=RES_OK)return FATReadErr;
                 fs->BPB_BytsPerSec = fat32Ui8_2_Ui16(sector,BPB_BytsPerSecoff);
                 fs->BPB_RsvdSecCnt = fat32Ui8_2_Ui16(sector,BPB_RsvdSecCntoff);
                 fs->BPB_FATSz32    = fat32Ui8_2_Ui32(sector,BPB_FATSz32off);
                 fs->BPB_RootClus   = fat32Ui8_2_Ui32(sector,BPB_RootClusoff);
             	fs->BPB_SecPerClus = sector[BPB_SecPerClusoff];
             	fs->BPB_NumFATs    = sector[BPB_NumFATsoff];
             	fs->fat_begin_lba  = (unsigned int)fs->part->LBABegin + (unsigned int)(unsigned short)fs->BPB_RsvdSecCnt;
             	fs->cluster_begin_lba = (unsigned int)fs->fat_begin_lba + ((unsigned int)fs->BPB_NumFATs * (unsigned int)fs->BPB_FATSz32 );
             	return FATnoErr;
             }
             int fat32mkdirent(FAT32fs* fs,ucdirent* dirent)
             {
             	if(fs==0) return DIRENT_BabArg;
             	if(dirent==0) return DIRENT_BabArg;
             	dirent->fs = (UHANDLE)fs;
             	dirent->getrootfirstent = &fat32getrootfirstent;
             	dirent->nextdirent = &fat32nextdirent;
             	return DIRENT_noErr;
             }
             int fat32getrootfirstent(ucdirent* entry)
             {
             	if(entry==0) return DIRENT_BabArg;
             	entry->CurrentSec = ((FAT32fs*)entry->fs)->cluster_begin_lba;
             	entry->Currententry = 0;
             	return fat32nextdirent(entry);
             }
             int fat32getVolName(FAT32fs* fs,char* Name)
             {
             	if(fs==0) return DIRENT_BabArg;
             	if(Name==0) return DIRENT_BabArg;
             	int i=0;
             	ucdirent entry;
             	if(DIRENT_noErr==fat32mkdirent(fs,&entry))
             	{
             		entry.CurrentSec = ((FAT32fs*)entry.fs)->cluster_begin_lba;
             		entry.Currententry = -1;
             		if(DIRENT_noErr!=fat32nextdirent(&entry))return DIRENT_ReadErr;
             		for(i=0;i<16;i++)
             		{
             			Name[i] = entry.DIR_Name[i];
             		}
             		return DIRENT_noErr;
             	}
             	return DIRENT_ReadErr;
             }
             int fat32enterdirent(ucdirent* currententry,ucdirent* firstentry)
             {
             	if(firstentry==0) return DIRENT_BabArg;
             	if(currententry==0) return DIRENT_BabArg;
                 fat32mkdirent(((FAT32fs*)currententry->fs),firstentry);
             	firstentry->CurrentSec = fat32getdirentlba(currententry);
             	firstentry->Currententry = -1;
             	return fat32nextdirent(firstentry);
             }
             int fat32nextdirent(ucdirent* entry)
             {
                 uint32_t n=0,res=DIRENT_noErr,k,j;
-            	k=(((signed char)entry->Currententry)+1)*32; /*Restart at last dir entry*/
+                k=(0xFF&((signed char)entry->Currententry)+1)*32; /*Restart at last dir entry*/
                 j=entry->CurrentSec;//  /*Restart at last sector*/
             	do
             	{
                     fat32sectorreadout(((FAT32fs*)entry->fs),j);
             		for(k=k;k<(512);k+=32)     /*512 Bytes per sector and 32 bytes per entry*/
             		{
                         if((fat32buff[DIR_Nameoff+k]!=(char)0xE5))   /*0xE5 = free entry*/
             			{
                             if(fat32buff[DIR_Nameoff+k]==(char)0)
                                 return DIRENT_EndOfDir;   /*0x00 = end of dir*/
             				else
-                                if((fat32buff[DIR_Attroff + k]==ATTR_DIRECTORY)||(fat32buff[DIR_Attroff + k]==ATTR_ARCHIVE)||(fat32buff[DIR_Attroff + k]==(ATTR_READ_ONLY)))
+                                if((fat32buff[DIR_Attroff + k]==(char)ATTR_DIRECTORY)||(fat32buff[DIR_Attroff + k]==(char)ATTR_ARCHIVE)||(fat32buff[DIR_Attroff + k]==(char)(ATTR_READ_ONLY)))
             					{
             						for(n=0;n<16;n++)entry->DIR_Name[n] = '\0';
             						for(n=0;n<11;n++)entry->DIR_Name[n] = fat32buff[n+DIR_Nameoff + k];
                                     entry->DIR_Attr         = (uint8_t)fat32buff[DIR_Attroff + k];
                                     entry->DIR_CrtTimeTenth = (uint8_t)fat32buff[DIR_CrtTimeTenthoff + k];
                                     entry->DIR_CrtTime      = fat32extract16b(fat32buff,(DIR_CrtTimeoff + k));
                                     entry->DIR_CrtDate      = fat32extract16b(fat32buff,(DIR_CrtDateoff + k));
                                     entry->DIR_LstAccDate   = fat32extract16b(fat32buff,(DIR_LstAccDateoff + k));
                                     entry->DIR_FstClusHI    = fat32extract16b(fat32buff, (DIR_FstClusHIoff + k));
                                     entry->DIR_WrtTime      = fat32extract16b(fat32buff,(DIR_WrtTimeoff + k));
                                     entry->DIR_FstClustLO   = fat32extract16b(fat32buff, (DIR_FstClusLOoff + k));
                                     entry->DIR_FileSize     = fat32extract32b(fat32buff,(DIR_FileSizeoff + k));
             						entry->CurrentSec = j;
             						entry->Currententry = (unsigned char)(k/32);
             						return DIRENT_noErr;
             					}
             			}
             		}
             		j=fat32nextsectorlba(((FAT32fs*)entry->fs),j,&k);
             		if(j!=DIRENT_noErr)
             		{
             			if(j==DIRENT_LastSect) return DIRENT_EndOfDir;   /*Not clean but can avoid some bugs*/
             			return j;
             		}
             		j=k;
             		k=0;
             	}while(res==DIRENT_noErr);
             	return res;
             }
             int fat32getdirentname(ucdirent* entry,char* nameBuffer)
             {
                 uint32_t j;
                 int k,n,i;
                 int res=DIRENT_noErr;
                 char longName=0;
                 k=(((signed char)entry->Currententry))*32;
                 j=entry->CurrentSec;
                 fat32sectorreadout(((FAT32fs*)entry->fs),j);
                 longName |= fat32buff[DIR_Nameoff + 6 + k]=='~';
                 if(k>=32)
                 {
                     longName |= ((fat32buff[DIR_Nameoff + k-32]&0x40)==0x40)&((fat32buff[DIR_Nameoff + k-32 +11])==ATTR_LONGNAME);
                 }
                 else
                 {
                     uint32_t j_old=j;
                     if(fat32prevsectorlba((FAT32fs*)entry->fs, j,&j)!=DIRENT_noErr)return DIRENT_ReadErr;
                     fat32sectorreadout(((FAT32fs*)entry->fs),j);
                     k=512;
                     longName |= ((fat32buff[DIR_Nameoff + k-32]&0x40)==0x40)&((fat32buff[DIR_Nameoff + k-32 +11])==ATTR_LONGNAME);
                     if(!longName)
                     {
                         k=0;
                         j=j_old;
                         fat32sectorreadout(((FAT32fs*)entry->fs),j);
                         k=0;
                     }
                 }
                 if(longName) //long Name? or lower case name
                 {
                     i=0;
                     do{
                         if(k==0)
                         {
                             //get previous sector
                             if(fat32prevsectorlba((FAT32fs*)entry->fs, j,&j)!=DIRENT_noErr)return DIRENT_ReadErr;
                             fat32sectorreadout(((FAT32fs*)entry->fs),j);
                             k=512-32;
                             for(n=0;n<5;n++)nameBuffer[i++] = fat32buff[((n<<1)|1) + k];
                             for(n=14;n<26;n+=2)nameBuffer[i++] = fat32buff[n + k];
                             for(n=28;n<32;n+=2)nameBuffer[i++] = fat32buff[n + k];
                         }
                         else
                         {
                             k-=32;
                             for(n=0;n<5;n++)nameBuffer[i++] = fat32buff[((n<<1)|1) + k];
                             for(n=14;n<26;n+=2)nameBuffer[i++] = fat32buff[n + k];
                             for(n=28;n<32;n+=2)nameBuffer[i++] = fat32buff[n + k];
                         }
                     }while((fat32buff[k]&0x40)!=0x40);
                     nameBuffer[i]='\0';
                 }
                 else
                 {
                     i=0;
                     for(n=0;n<8;n++)
                     {
                         nameBuffer[i] = 0x20 | fat32buff[n+DIR_Nameoff + k];
                         if(nameBuffer[i]!=0x20)i++;
                     }
                     if((((fat32buff[DIR_Nameoff + k +11])&ATTR_DIRECTORY)!=ATTR_DIRECTORY)&&(fat32buff[8+DIR_Nameoff + k]!=0x20))
                         nameBuffer[i++]='.';
                     for(n=8;n<11;n++)
                     {
                         nameBuffer[i] = 0x20 | fat32buff[n+DIR_Nameoff + k];
                         if(nameBuffer[i]!=0x20)i++;
                     }
                     nameBuffer[i]='\0';
                 }
                 return res;
             }
             uint32_t fat32getdirentlba(ucdirent* entry)
             {
                 uint32_t clusterNum = (uint32_t)((uint16_t)entry->DIR_FstClustLO) + ((uint32_t)((uint16_t)entry->DIR_FstClusHI) <<16);
                 uint32_t lba=clusterlba(((FAT32fs*)entry->fs),clusterNum);
             	return lba;
             }
             int fat32nextsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba)
             {
-                if(((lastsector_lba + 1 - fs->cluster_begin_lba) & (fs->BPB_SecPerClus-1))!=0)  /*Is it the last sector of the cluster?*/
+                if(((lastsector_lba + 1 - fs->cluster_begin_lba) & ((uint32_t)(fs->BPB_SecPerClus)-1))!=0)  /*Is it the last sector of the cluster?*/
             	{
                     *nextsector_lba = lastsector_lba+1;                                       /*if not just increment lba*/
             		return DIRENT_noErr;
+                }
                 uint32_t clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 uint32_t fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 fat32sectorreadout(fs,fatsec);
                 int i= fat32clusterinfatoff(clusternum);
                 *nextsector_lba=fat32Ui8_2_Ui32(fat32buff,i);
-                if(*nextsector_lba==0xFFFFFFF7)return DIRENT_BadSect;
+                if(*nextsector_lba==0xFFFFFFF7)
-                if(*nextsector_lba>=0xFFFFFFF6)return DIRENT_LastSect;
+                    printf("DIRENT_BadSect\n");
+                    return DIRENT_BadSect;
+                }
+                if((uint32_t)(*nextsector_lba)>=(uint32_t)0xFFFFFFF6)
+                {
+                    printf("DIRENT_LastSect\n");
+                    return DIRENT_LastSect;
+                }
             	*nextsector_lba = clusterlba(fs,*nextsector_lba);
             	return DIRENT_noErr;
             }
             int fat32prevsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba)
             {
                 uint32_t i=0,fatsec=0;
                 if(((lastsector_lba - 1 - fs->cluster_begin_lba) & (fs->BPB_SecPerClus-1))!=0)  /*Is it the first sector of the cluster?*/
                 {
                     *nextsector_lba = lastsector_lba-1;                                       /*if not just decrement lba*/
                     return DIRENT_noErr;
                 }
                 uint32_t clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 do
                 {
                     fat32sectorreadout(fs,fatsec);
                     fatsec--;
                     for(i=511;i>3;i-=4)
                     {
                         *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i-3);
                         if (*nextsector_lba ==clusternum)
                         {
                             *nextsector_lba = clusterlba(fs,*nextsector_lba);
                             return DIRENT_noErr;
                         }
                     }
                 }while(fatsec>=fs->fat_begin_lba);
                 clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 do
                 {
                     fat32sectorreadout(fs,fatsec);
                     fatsec++;
                     for(i=0;i<512;i+=4)
                     {
                         *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i);
                         if (*nextsector_lba ==clusternum)
                         {
                             *nextsector_lba = clusterlba(fs,*nextsector_lba);
                             return DIRENT_noErr;
                         }
                     }
                 }while(fatsec<=(fs->fat_begin_lba+fs->BPB_FATSz32));
                 return DIRENT_ReadErr;
             }

lib/src/common/FILE_SYSTEM/FAT32/fat32_STM32F4.pro +3 0

             TEMPLATE = lib
             OBJECTS_DIR = obj
             TARGET = fat32
             SOURCES += \
                 fat32.c
             INCLUDEPATH += ../../../includes \
             	../../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../../CPU/CMSIS/Include
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target
+            HEADERS += \
+                ../../../includes/fat32.h

lib/src/common/FILE_SYSTEM/SDCARD/sdcard.c +1 -1

             /*------------------------------------------------------------------------------
             --  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 = 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 = 100; tmr; tmr--) {	/* Wait for data packet in timeout of 100ms */
             		sdcard->rcvr_mmc(sdcard->phy,d, 1);
             		if (d[0] != 0xFF) break;
                     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 */
                 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);
             	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 */
+                for (n = 100; 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)) || (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 +1 0

             /*------------------------------------------------------------------------------
             --  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=0;
                     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;
+                        terminal_clearCurentLine(terminal);
                     }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;
             }

lib/src/includes/VS10XX.h +20 -5

             /*------------------------------------------------------------------------------
             #--  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
             #-------------------------------------------------------------------------------*/
             #ifndef VS10XX_H
             #define VS10XX_H
             #include <uhandle.h>
             #include <spi.h>
             #define VSMODE        0
             #define VSSTATUS      1
             #define VSBASS        2
             #define VSCLOCKF      3
             #define VSDECODE_TIME 4
             #define VSAUDATA      5
             #define VSWRAM        6
             #define VSWRAMADDR    7
             #define VSHDAT0       8
             #define VSHDAT1       9
             #define VSAIADDR      0xA
             #define VSVOL         0xB
             #define VSAICTRL0     0xC
             #define VSAICTRL1     0xD
             #define VSAICTRL2     0xE
             #define VSAICTRL3     0xF
+            typedef enum VS10XXVER_en
+            {
+                UNKNOWN,
+                VS1001,
+                VS1011,
+                VS1002,
+                VS1003,
+                VS1053,
+                VS1033,
+                VS1103
+            }VS10XXVER_en;
             typedef struct vs10XXDev
             {
              spi_t SPIdev;
              void (*setxCS)(char);
              void (*setxRST)(char);
              void (*setxDCS)(char);
              int (*getDREQ)();
-             int a;
+             VS10XXVER_en VERSION;
             }vs10XXDev;
             void vs10XXopen(vs10XXDev* codec,spi_t dev, void (*setxCS)(char),void (*setxRST)(char),void (*setxDCS)(char),int (*getDREQ)());
             void vs10XXsoftreset(vs10XXDev* dev);
             int vs10XXcmdread(vs10XXDev* dev,char address);
             void vs10XXcmdwrite(vs10XXDev* dev,char address,int value);
+            void vs10XXstream32bytes(vs10XXDev* dev,char* buffer);
-            extern void vs10XXclearXCS();
+            void vs10XXsetCansel(vs10XXDev* dev);
-            extern void vs10XXsetXCS();
+            int vs10XXcanselAccepted(vs10XXDev* dev);
-            extern int vs10XXDREQ();
+            void vs10XXsoftReset(vs10XXDev* dev);
+            //extern void vs10XXclearXCS();
+            //extern void vs10XXsetXCS();
+            //extern int vs10XXDREQ();
             #endif //VS10XX_H

lib/src/includes/fat32.h +1 -1

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #ifndef FAT32_H
             #define FAT32_H
             #include <mbr.h>
             #include <libucfs.h>
             #include <ucdirent.h>
             #include <stdint.h>
             #include <stdint-gcc.h>
             /*BPB (Boot Sector) Offsets  */
             #define BS_jmpBootoff 		0
             #define BS_OEMNameoff 		3
             #define BPB_BytsPerSecoff 	11
             #define BPB_SecPerClusoff	13
             #define BPB_RsvdSecCntoff	14
             #define BPB_NumFATsoff 		16
             #define BPB_RootEntCntoff	17
             #define BPB_TotSec16off		19
             #define BPB_Mediaoff 		21
             #define BPB_FATSz16off 		22
             #define BPB_SecPerTrkoff	24
             #define BPB_NumHeadsoff		26
             #define BPB_HiddSecoff 		28
             #define BPB_TotSec32off		32
             /*FAT16*/
             #define BS_DrvNumFAT16off	36
             #define BS_Reserved1FAT16off	37
             #define BS_BootSigFAT16off 	38
             #define BS_VolIDFAT16off	39
             #define BS_VolLabFAT16off	43
             #define BS_FilSysTypeFAT16off 	54
             /*FAT32*/
             #define BPB_FATSz32off 		36
             #define BPB_ExtFlagsoff		40
             #define BPB_FSVeroff 		42
             #define BPB_RootClusoff		44
             #define BPB_FSInfooff 		48
             #define BPB_BkBootSecoff	50
             #define BPB_Reservedoff		52
             #define BS_DrvNumFAT32off	64
             #define BS_Reserved1FAT32off	65
             #define BS_BootSigFAT32off 	66
             #define BS_VolIDFAT32off	67
             #define BS_VolLabFAT32off	71
             #define BS_FilSysTypeFAT32off 	82
             #define DIR_Nameoff             0
             #define DIR_Attroff             0xb
             #define DIR_FstClusHIoff        0x14
             #define DIR_FstClusLOoff        0x1A
             #define DIR_FileSizeoff         0x1c
             #define DIR_CrtTimeTenthoff     13
             #define DIR_CrtTimeoff          14
             #define DIR_CrtDateoff          16
             #define DIR_LstAccDateoff       18
             #define DIR_WrtTimeoff          22
             #define DIR_WrtDateoff          24
             #define FATBadpart 1
             #define FATBabArg 2
             #define FATReadErr 3
             #define FATnoErr 0
             typedef struct FAT32fs
             {
                 uint16_t BPB_BytsPerSec;
                 uint16_t BPB_RsvdSecCnt;
                 uint32_t   BPB_FATSz32;
                 uint32_t   BPB_RootClus;
                 uint32_t   fat_begin_lba;
                 uint32_t   cluster_begin_lba;
                 uint8_t  BPB_SecPerClus;
                 uint8_t  BPB_NumFATs;
             	dikpartition*  part;
             }FAT32fs;
             #define castUI64(val) ((uint64_t)(val))
             #define castUI32(val) ((uint32_t)(val))
             #define castUI16(val) ((uint16_t)(val))
             #define castUI8(val) ((uint8_t)(val))
             #define castI64(val) ((int64_t)(val))
             #define castI32(val) ((int32_t)(val))
             #define castI16(val) ((int16_t)(val))
             #define castI8(val) ((int8_t)(val))
             #define fat32Ui8_2_Ui32(table,lsBindex) ((uint32_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint32_t)table[lsBindex+1])<<8))+(0xFF0000&(((uint32_t)table[lsBindex+2])<<16))+(0xFF000000&(((uint32_t)table[lsBindex+3])<<24))))
             #define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
             /* Get the first sector lba of given cluster number*/
             #define clusterlba(fs,cluster_number) ((uint32_t)fs->cluster_begin_lba + (((uint32_t)cluster_number) - (2)) * (uint32_t)fs->BPB_SecPerClus)
             //#define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>6) + fs->fat_begin_lba)
             #define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>7) + fs->fat_begin_lba)
-            #define fat32clusterinfatoff(cluster_number) (((cluster_number)&0x3F)*4)
+            #define fat32clusterinfatoff(cluster_number) (((cluster_number)&0x7F)*4)
             /*Get cluster index in FAT Table from sector address*/
             #define fat32masksectorlba(sectorlba,fs) (sectorlba & (castUI32(-1)^castUI32(fs->BPB_SecPerClus-1)))
             #define fat32sectorlbatoclusternum(fs,sectorlba)  (((fat32masksectorlba(castUI32(sectorlba),fs) -(castUI32(fs->cluster_begin_lba)))/castUI32(fs->BPB_SecPerClus))+castUI32(2))
             #define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
             #define fat32extract32b(table, LSBOffset) (uint32_t)(( (uint32_t) ((uint8_t)table[(LSBOffset)]) ) + (uint32_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+2]) << 16 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+3]) << 24 ))
             #ifdef FAT32_PRIVATE
             #define fat32sectorreadout(fs,fatsec) \
                 if((lastSecAddrs!=(fatsec)) || (lastFATFS!=(fs)))                 /*Check if sector already buffered*/ \
                 {\
                     if((fs)->part->phy->read((fs)->part->phy,fat32buff,(fatsec),1)!=RES_OK) \
                     {\
                         return DIRENT_ReadErr;\
                     }\
                 }\
                 lastSecAddrs=(fatsec);\
                 lastFATFS=(fs);
             #endif
             extern int fat32open(FAT32fs* fs,dikpartition* part);
             extern int fat32mkdirent(FAT32fs* fs,ucdirent* dirent);
             extern int fat32getVolName(FAT32fs* fs,char* Name);
             extern int fat32getrootfirstent(ucdirent* entry);
             extern int fat32nextdirent(ucdirent* entry);
             extern int fat32nextsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t* nextsector_lba);
             extern int fat32prevsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba);
             extern uint32_t fat32getdirentlba(ucdirent* entry);
             extern int fat32getdirentname(ucdirent* entry,char* nameBuffer);
             #endif

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