HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r54:e6f450090662

Fixed one more spi driver bug.

jeandet -

r54:e6f450090662 dev_alexis

parent child

Context file:

r54:e6f450090662

Collapse all files

examples/N25Q128_test/main.c +2 -2

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <core.h>
             #include <N25Q128.h>
             #include <spi.h>
             extern streamdevice* __opnfiles__[];
             /*
                 N25Q128 pinout:
                 MISO       => PB14
                 MOSI       => PB15
                 SCK        => PB13
                 CS         => PB12
                 WP         => PC1
                 RESET/HOLD => PC2
             */
             void cs(int csstate)
             {
                 gpiosetval(PB12,csstate);
             }
             void wp(int wpstate)
             {
                 gpiosetval(PC1,wpstate);
             }
             void resetHold(int rhstate)
             {
                 gpiosetval(PC2,rhstate);
             }
             int main()
             {
                spiopenandconfig(spi2,spiclkfirstedge|spimaster|spimsbfirst|spi8bits,10000,PB15,PB14,PB13,(uint32_t)NULL);
                //spiopenandconfig(spi2,spiclkfirstedge|spimaster|spimsbfirst|spi8bits,10000,PB15,PB14,PB13,PB12);
                gpio_t PC1pin= gpioopen(PC1);
                gpiosetdir(&PC1pin,gpiooutdir);
                gpio_t PC2pin= gpioopen(PC2);
                gpiosetdir(&PC2pin,gpiooutdir);
                gpio_t PB12pin= gpioopen(PB12);
                gpiosetdir(&PB12pin,gpiooutdir);
                gpioset(PC1);
                gpioset(PB12);
                gpioclr(PC2);
                eepromN25Q128Dev eeprom;
                eepromN25Q128open(&eeprom,spi2,&cs,&wp,&resetHold);
                //eepromN25Q128open(&eeprom,spi2,NULL,&wp,&resetHold);
                delay_100us(10);
                gpioset(PC2);
                gpioclr(PB12);
                spiputw(spi2,0x9E);
                char res[22];
                spigetnc(spi2,res,22);
                gpioset(PB12);
                for(int i=0;i<22;i++)
                {
                    printf("res[%d] = 0x%x\n\r",i,(int)res[i]);
                }
                eepromN25Q128enablewrite(&eeprom);
                delay_100us(10);
                eepromN25Q128writen(&eeprom,0,"hello World",11);
                delay_100us(10);
                eepromN25Q128readn(&eeprom,0,res,11);
                res[11]='\n';
                res[12]='\r';
                res[13]=0;
-               //printf("read: %s",res);
+               printf("read: %s",res);
-               //printf("\n");
+               printf("\n");
                for(int i=0;i<11;i++)
                {
                    printf("res[%d] = 0x%x\n\r",i,(int)res[i]);
                }
                while(1)
                 {
                     gpioset(LED3);
                     delay_100us(10000);
                     gpioclr(LED3);
                     delay_100us(10000);
                 }
                 printf("hello world\n\r");
                 return 0;
             }

lib/src/includes/N25Q128.h +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
             -------------------------------------------------------------------------------*/
             #ifndef N25Q128_H
             #define N25Q128_H
             #include <spi.h>
             #include <uhandle.h>
             #include <stdint.h>
             typedef struct eepromN25Q128Dev
             {
              spi_t spidev;
              void (*select)(int sel);
              void (*writeprotect)(int wp);
              void (*holdreset)(int hr);
             }eepromN25Q128Dev;
             #define N25Q128_PAGE_SZ  256
+            #define N25Q128_CAPACITY_IN_BYTES (1024*1024*16)  /*16MB*/
             #define N25Q128_READID   0x9E
             #define N25Q128_READ     0x03
             #define N25Q128_FASTREAD 0x0B
             #define N25Q128_DOFR     0x3B
             #define N25Q128_DIOFR    0xBB
             #define N25Q128_QOFR     0x6B
             #define N25Q128_QIOFR    0xEB
             #define N25Q128_ROTP     0x4B
             #define N25Q128_WREN     0x06
             #define N25Q128_WRDI     0x04
             #define N25Q128_PP       0x02
             extern void eepromN25Q128open(eepromN25Q128Dev* dev,spi_t spidev,void (*select)(int sel),void (*writeprotect)(int wp),void (*holdreset)(int hr));
             extern void eepromN25Q128pagewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
             extern void eepromN25Q128pageread(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
             extern void eepromN25Q128bytewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char data);
             extern unsigned char eepromN25Q128byteread(eepromN25Q128Dev* dev,uint32_t address);
             extern void eepromN25Q128readn(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
             extern void eepromN25Q128writen(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
             extern void eepromN25Q128enablewrite(eepromN25Q128Dev* dev);
             #endif

lib/src/stm32f4/SPI/spi.c +5 -4

             /*------------------------------------------------------------------------------
             --  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 <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #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)
             SPI_TypeDef* _spi_dev_table[3]={SPI1,SPI2,SPI3};
             spi_t spiopen(int count)
             {
             #define _INIT_DEV(_RCC_) \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, DISABLE); \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE);
                 switch(count)
                 {
                 case spi1:
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE);
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
                     return spi1;
                     break;
                 case spi2:
                     _INIT_DEV(RCC_APB1Periph_SPI2);
                     return spi2;
                     break;
                 case spi3:
                     _INIT_DEV(RCC_APB1Periph_SPI3);
                     return spi3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             spi_t spiopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t MOSIpin, uint32_t MISOpin, uint32_t SCKpin, uint32_t SCSpin)
             {
                 spi_t dev = spiopen(count);
                 if(dev!=-1)
                 {
                     spidisable(dev);
                     spisetpins(dev,MOSIpin, MISOpin, SCKpin, SCSpin);
                     spienable(dev);
                     spisetconfig(dev,cfg,speed);
                 }
                 return dev;
             }
             int spiclose(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     switch(spidev)
                     {
                     case spi1:
                         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
                         break;
                     case spi2:
                         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
                         break;
                     case spi3:
                         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI3, ENABLE);
                         break;
                     default:
                         return -1;
                         break;
                     }
                     return 1;
                 }
                 return -1;
             }
             int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     gpio_t MISO,MOSI,SCK,SCS;
                     uint8_t gpioAFspix = GPIO_AF_SPI1;
                     switch(spidev)
                     {
                     case spi1:
                         gpioAFspix = GPIO_AF_SPI1;
                         break;
                     case spi2:
                         gpioAFspix = GPIO_AF_SPI2;
                         break;
                     case spi3:
                         gpioAFspix = GPIO_AF_SPI3;
                         break;
                     default:
                         break;
                     }
                     if(MISOpin!=-1)
                     {
                         MISO = gpioopen(MISOpin);
                         MISO |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&MISO);
                         GPIO_PinAFConfig(GPIOGETPORT(MISO), (uint8_t)(MISO & 0xF), gpioAFspix);
                     }
                     if(MOSIpin!=-1)
                     {
                         MOSI = gpioopen(MOSIpin);
                         MOSI |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&MOSI);
                         GPIO_PinAFConfig(GPIOGETPORT(MOSI), (uint8_t)(MOSI & 0xF), gpioAFspix);
                     }
                     if(SCKpin!=-1)
                     {
                         SCK  = gpioopen(SCKpin);
                         SCK  |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&SCK);
                         GPIO_PinAFConfig(GPIOGETPORT(SCK), (uint8_t)(SCK  & 0xF), gpioAFspix);
                     }
                     if(SCSpin!=-1)
                     {
                         SCS = gpioopen(SCSpin);
                         SCS |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&SCS);
                         GPIO_PinAFConfig(GPIOGETPORT(SCS), (uint8_t)(SCS & 0xF), gpioAFspix);
                         _dev_->CR2  |= (1<<2);
                     }
                     else
                     {
                         _dev_->CR2  &= ~(1<<2);
                     }
                     return 1;
                 }
                 return -1;
             }
             int spienable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR1  |= (1<<6);
                     return 1;
                 }
                 return -1;
             }
             int spidisable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR1  &= ~(1<<6);
                     return 1;
                 }
                 return -1;
             }
             int spisetconfig(spi_t spidev, uint32_t config, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR2 |= (1<<2);
                     _dev_->CR1 |= (1<<2);
                     spisetspeed(spidev,speed);
                     spisetdatabits(spidev,config & SPIBITSMASK);
                     spisetbitorder(spidev,config & SPIBITORDERMASK);
                     spisetclkinhlevel(spidev,config & SPICLKINHLVLMASK);
                     spisetclkphase(spidev,config & SPICLKPHASEMASK);
                     return 0;
                 }
                 return 1;
             }
             int spisetspeed(spi_t spidev, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     uint32_t apbclock = 0x00;
                     RCC_ClocksTypeDef RCC_ClocksStatus;
                     RCC_GetClocksFreq(&RCC_ClocksStatus);
                     if (_dev_ == SPI1)
                     {
                         apbclock = RCC_ClocksStatus.PCLK2_Frequency;
                     }
                     else
                     {
                         apbclock = RCC_ClocksStatus.PCLK1_Frequency;
                     }
                     int32_t speederror = 0x7FFFFFFF; //max error
                     int32_t prev_speederror = 0x7FFFFFFF;
                     int32_t realspeed = 0;
                     unsigned char divider = 0;
                     do
                     {
                         divider ++;
                         prev_speederror = speederror;
                         realspeed = apbclock>>(divider);
                         speederror = realspeed - speed;
                         if(speederror<0)speederror=-speederror;
                         if(divider>8)break;
                     }while(speederror<prev_speederror);
                     speed = apbclock>>(divider-1);
                     divider-=2;
                     _dev_->CR1 &= 0xFFD7;  // clear prescaler bits 3:5
                     _dev_->CR1 |= ((0x7 & divider)<<3);
                     return 1;
                 }
                 return -1;
             }
             int spisetdatabits(spi_t spidev,spibits_t bitscnt)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     int result = 0;
                     switch(bitscnt)
                     {
                     case spi8bits:
                         _dev_->CR1 &= ~(1<<11);
                         result = 1;
                         break;
                     case spi16bits:
                         _dev_->CR1 |= (1<<11);
                         result = 1;
                         break;
                     default:
                         result =-1;
                         break;
                     }
                     return result;
                 }
                 return -1;
             }
             int spisetbitorder(spi_t spidev,spibitorder_t order)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(order==spimsbfirst)
                     {
                         _dev_->CR1 &= ~(1<<7);
                         return 1;
                     }
                     else
                     {
                         if(order==spilsbfirst)
                         {
                             _dev_->CR1 |= (1<<7);
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(level==spiclkinhlow)
                     {
                         _dev_->CR1 &= ~(1<<1);
                         return 1;
                     }
                     else
                     {
                         if(level==spiclkinhhigh)
                         {
                             _dev_->CR1 |= (1<<1);
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spisetclkphase(spi_t spidev,spiclkphase_t phase)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(phase==spiclkfirstedge)
                     {
                         _dev_->CR1 &= ~1;
                         return 1;
                     }
                     else
                     {
                         if(phase==spiclksecondedge)
                         {
                             _dev_->CR1 |= 1;
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spiputw(spi_t spidev,uint16_t data)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
+                    while(((_dev_->SR & (1<<1)) == 0) );
                     _dev_->DR = data;
-                    while((_dev_->SR & (1<<7)) == (1<<7));
+                    while(((_dev_->SR & (1<<0)) == 0) );
-                    return 1;
+                    return _dev_->DR;
                 }
                 return -1;
             }
             uint16_t spigetw(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
-                    while((_dev_->SR & (1<<7)) == (1<<7));
+                    while(((_dev_->SR & (1<<1)) == 0) );
                     _dev_->DR = 0xFFFF;
-                    while(((_dev_->SR & (1<<0)) == 0) || (_dev_->SR & (1<<7)) == (1<<7));
+                    while(((_dev_->SR & (1<<0)) == 0) );
                     return _dev_->DR;
                 }
                 return -1;
             }
             int spiputs(spi_t spidev,char* s)
             {
                 while (*s) spiputw(spidev,*s++);
                 return 1;
             }
             int spigets(spi_t spidev,char* s)
             {
                 do
                 {
                     (*s) =  spigetw(spidev);
                 }
                 while(*s++);
                 return 1;
             }
             int spiputnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*w++);
                     n--;
                 }
                 return 1;
             }
             int spigetnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     *w++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiputnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*c++);
                     n--;
                 }
                 return 1;
             }
             int spigetnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     *c++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiavailiabledata(spi_t spidev)
             {
                 return 0;
             }
             int spitransactionfinished(spi_t spidev)
             {
                 SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                 if((spidev<3)&&(spidev>=0))
                 {
                     if((_dev_->SR & (1<<7)) == (1<<7))return 1;
                 }
                 return 0;
             }

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