| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #define ADK_INTERNAL |
| #include "fwk.h" |
| |
| #define TRACE_DEBUG(...) |
| #define assert(...) |
| |
| void PMC_EnablePeripheral( uint32_t dwId ) |
| { |
| assert( dwId < 45 ) ; |
| |
| if ( dwId < 32 ) |
| { |
| if ( (PMC->PMC_PCSR0 & ((uint32_t)1 << dwId)) == ((uint32_t)1 << dwId) ) |
| { |
| TRACE_DEBUG( "PMC_EnablePeripheral: clock of peripheral" " %u is already enabled\n\r", dwId ) ; |
| } |
| else |
| { |
| PMC->PMC_PCER0 = 1 << dwId ; |
| } |
| } |
| else |
| { |
| dwId -= 32; |
| if ((PMC->PMC_PCSR1 & ((uint32_t)1 << dwId)) == ((uint32_t)1 << dwId)) |
| { |
| TRACE_DEBUG( "PMC_EnablePeripheral: clock of peripheral" " %u is already enabled\n\r", dwId + 32 ) ; |
| } |
| else |
| { |
| PMC->PMC_PCER1 = 1 << dwId ; |
| } |
| } |
| } |
| |
| void SPI_Configure( Spi* spi, uint32_t dwId, uint32_t dwConfiguration ) |
| { |
| PMC_EnablePeripheral( dwId ) ; |
| spi->SPI_CR = SPI_CR_SPIDIS ; |
| |
| /* Execute a software reset of the SPI twice */ |
| spi->SPI_CR = SPI_CR_SWRST ; |
| spi->SPI_CR = SPI_CR_SWRST ; |
| spi->SPI_MR = dwConfiguration ; |
| } |
| |
| void SPI_ConfigureNPCS( Spi* spi, uint32_t dwNpcs, uint32_t dwConfiguration ) |
| { |
| spi->SPI_CSR[dwNpcs] = dwConfiguration ; |
| } |
| |
| void SPI_Enable( Spi* spi ) |
| { |
| spi->SPI_CR = SPI_CR_SPIEN; |
| } |
| |
| void DACC_Initialize( Dacc* pDACC, |
| uint8_t idDACC, |
| uint8_t trgEn, |
| uint8_t trgSel, |
| uint8_t word, |
| uint8_t sleepMode, |
| uint32_t mck, |
| uint8_t refresh, // refresh period |
| uint8_t user_sel, // user channel selection |
| uint32_t tag_mode, // using tag for channel number |
| uint32_t startup |
| ) |
| { |
| assert( 1024*refresh*1000/(mck>>1) < 20 ) ; |
| |
| // mck is for future usage, remove warnings. |
| mck = mck; |
| |
| // Enable peripheral clock |
| PMC_EnablePeripheral(idDACC); |
| |
| // Reset the controller |
| DACC_SoftReset(pDACC); |
| |
| // Write to the MR register |
| DACC_CfgModeReg( pDACC, |
| ( (trgEn<<0) & DACC_MR_TRGEN) |
| | DACC_MR_TRGSEL(trgSel) |
| | ( (word<<4) & DACC_MR_WORD) |
| | ( (sleepMode<<5) & DACC_MR_SLEEP) |
| | DACC_MR_REFRESH(refresh) |
| | ( (user_sel<<DACC_MR_USER_SEL_Pos)& DACC_MR_USER_SEL_Msk) |
| | ( (tag_mode<<20) & DACC_MR_TAG) |
| | ( (startup<<DACC_MR_STARTUP_Pos) & DACC_MR_STARTUP_Msk)); |
| } |
| |
| uint32_t DACC_WriteBuffer( Dacc* pDACC, uint16_t *pwBuffer, uint32_t dwSize ) |
| { |
| |
| // Check if the first PDC bank is free |
| if ( (pDACC->DACC_TCR == 0) && (pDACC->DACC_TNCR == 0) ) |
| { |
| pDACC->DACC_TPR = (uint32_t)pwBuffer ; |
| pDACC->DACC_TCR = dwSize ; |
| pDACC->DACC_PTCR = DACC_PTCR_TXTEN ; |
| |
| return 1 ; |
| } |
| // Check if the second PDC bank is free |
| else |
| { |
| if (pDACC->DACC_TNCR == 0) |
| { |
| pDACC->DACC_TNPR = (uint32_t)pwBuffer ; |
| pDACC->DACC_TNCR = dwSize ; |
| |
| return 1 ; |
| } |
| else |
| { |
| return 0 ; |
| } |
| } |
| } |
| |
| static uint16_t FindClockConfiguration( |
| uint32_t frequency, |
| uint32_t mck) |
| { |
| uint32_t divisors[11] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}; |
| uint8_t divisor = 0; |
| uint32_t prescaler; |
| |
| assert(frequency < mck); |
| |
| // Find prescaler and divisor values |
| prescaler = (mck / divisors[divisor]) / frequency; |
| while ((prescaler > 255) && (divisor < 11)) { |
| |
| divisor++; |
| prescaler = (mck / divisors[divisor]) / frequency; |
| } |
| |
| // Return result |
| if ( divisor < 11 ) |
| { |
| TRACE_DEBUG( "Found divisor=%u and prescaler=%u for freq=%uHz\n\r", divisors[divisor], prescaler, frequency ) ; |
| |
| return prescaler | (divisor << 8) ; |
| } |
| else |
| { |
| return 0 ; |
| } |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| typedef struct PeriodicNode{ |
| struct PeriodicNode* next; |
| PeriodicFunc pF; |
| void* pD; |
| uint32_t count; |
| uint32_t reload; |
| }PeriodicNode; |
| |
| |
| |
| volatile static uint64_t msec = 0; |
| volatile static PeriodicNode* periodics = 0; |
| |
| static uint8_t volume = 255; |
| |
| #define JOINER(x,y,z) x ## y ## z |
| #define CALLER(x,y,z) JOINER(x,y,z) |
| #define TIMER_NAME CALLER(TC, TIMER_FOR_ADK, _Handler) |
| #define IRQ_NAME CALLER(TC, TIMER_FOR_ADK, _IRQn) |
| |
| void TIMER_NAME(){ |
| |
| uint32_t unused = TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_SR; |
| PeriodicNode* n = periodics; |
| |
| msec++; |
| |
| while(n){ |
| |
| if(!--n->count){ |
| |
| n->pF(n->pD); |
| n->count = n->reload; |
| } |
| n = n->next; |
| } |
| } |
| |
| uint64_t fwkGetUptime(void){ |
| |
| uint64_t t; |
| |
| do{ |
| t = msec; |
| }while(t != msec); |
| |
| return t; |
| } |
| |
| uint64_t fwkGetTicks(void){ |
| |
| uint64_t hi; |
| uint32_t lo; |
| |
| do{ |
| lo = TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_CV; |
| hi = msec; |
| }while(lo > TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_CV); |
| |
| return (hi * TICKS_PER_MS) + lo; |
| } |
| |
| void fwkDelay(uint64_t ticks){ |
| |
| uint64_t start = fwkGetTicks(); |
| |
| while(fwkGetTicks() - start < ticks); |
| } |
| |
| void periodicAdd(PeriodicFunc f, void* data, uint32_t periodMs){ |
| |
| PeriodicNode* n = malloc(sizeof(PeriodicNode)); |
| uint32_t failed = 0; |
| |
| n->reload = n->count = periodMs; |
| n->pF = f; |
| n->pD = data; |
| |
| do{ |
| asm( |
| "ldrex r0, [%1] \n\t" //atomic linked list addition..booyah! |
| "str r0, [%2] \n\t" |
| "strex %0, %3, [%1] \n\t" |
| :"=r"(failed) |
| :"r"(&periodics), "r"(&n->next), "r"(n) |
| :"r0" |
| ); |
| }while(failed); |
| } |
| |
| void periodicDel(PeriodicFunc f){ |
| |
| uint32_t failed; |
| |
| PeriodicNode* p = 0; |
| PeriodicNode* n = periodics; |
| |
| while(n && n != f){ |
| |
| p = n; |
| n = n->next; |
| } |
| if(!n) return; //nothing to delete |
| |
| if(p) p->next = n->next; |
| else periodics = n->next; |
| free(n); |
| } |
| |
| static void __attribute__((naked)) cpuGetUniqIdFunc(uint32_t interfaceAddr, uint32_t cmd1, uint32_t cmd2, uint32_t* buf){ |
| |
| asm( |
| " cpsid i \n\t" // There is some pretty scary stuff that can happen |
| " mov r12, r2 \n\t" // if you reset the device while this code is in |
| " str r1, [r0, #4] \n\t" // the middle of doing its thing. Sometimes the |
| "lbl_wait_1: \n\t" // flash controller does not get reset to "code" |
| " ldr r1, [r0, #8] \n\t" // mode and stays in "read unique ID" mode, even |
| " lsrs r1, #1 \n\t" // when the chip itself is externally reset. This |
| " bcs lbl_wait_1 \n\t" // will cause the unique ID to be treated like the |
| " mov r2, #0x00080000 \n\t" // vector table. Needless to say: the chip unique |
| " ldr r1, [r2, #0] \n\t" // ID is not a suitable vector table. After reset, |
| " str r1, [r3, #0] \n\t" // this will likely cause the chip to take a hard |
| " ldr r1, [r2, #4] \n\t" // fault immediately. Worse yet, the hard fault |
| " str r1, [r3, #4] \n\t" // handler vector will also be invalid, causing |
| " ldr r1, [r2, #8] \n\t" // the chip to take yet another hard fault. This |
| " str r1, [r3, #8] \n\t" // will continue forever. The debug bridge, as it |
| " ldr r1, [r2, #12] \n\t" // currently is, cannot handle this chip state. |
| " str r1, [r3, #12] \n\t" // It will be unable to flash or debug the chip, |
| " str r12, [r0, #4] \n\t" // and you - the user - will be sad. The practical |
| "lbl_wait_2: \n\t" // upshot of all this: use this code rarely, and |
| " ldr r1, [r0, #8] \n\t" // if you interrupt it, power-cycle the system if |
| " lsrs r1, #1 \n\t" // you suspect that you somehow got into this |
| " bcc lbl_wait_2 \n\t" // weird state. It is possible that future revs |
| " cpsie i \n\t" // of SAM3X will fix this issue by properly |
| " bx lr \n\t" // resetting the flash controller at reset time. |
| ); |
| } |
| |
| void cpuGetUniqId(uint32_t* dst){ //produce the 128-bit unique ID |
| |
| const unsigned numInstr = 23; //it better match the above function... |
| uint16_t buffer[numInstr]; |
| uint16_t* src = (uint16_t*)(((uint32_t)&cpuGetUniqIdFunc) &~ 1); |
| unsigned i; |
| |
| for(i = 0; i < numInstr; i++) buffer[i] = *src++; |
| |
| ((void (*)(uint32_t,uint32_t,uint32_t,uint32_t*))(((uint32_t)buffer) + 1))(0x400E0A00, 0x5A00000E, 0x5A00000F, dst); |
| } |
| |
| void fwkInit(void){ |
| |
| //clock & periodic setup (MCLK/2, interrupt every ms) |
| PMC_EnablePeripheral(ID_TC0); |
| TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 | TC_CMR_WAVSEL_UP_RC | TC_CMR_WAVE; |
| TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_CV = 0; |
| TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_RC = TICKS_PER_MS; |
| TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_IER = TC_IER_CPCS; |
| TC0->TC_CHANNEL[TIMER_FOR_ADK].TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG; |
| NVIC_EnableIRQ(IRQ_NAME); |
| |
| //IO on |
| PMC_EnablePeripheral(ID_PIOC); |
| PMC_EnablePeripheral(ID_PIOB); |
| PMC_EnablePeripheral(ID_PIOA); |
| |
| //dma setup |
| PMC_EnablePeripheral(ID_DMAC); |
| DMAC->DMAC_EBCIDR = 0x003F3F3F; //disable all interrupts |
| DMAC->DMAC_CHDR = 0x0000003F; //disable all channels |
| DMAC->DMAC_EN = 1; |
| } |
| |
| #define PER 0 |
| #define PDR 1 |
| #define OER 4 |
| #define ODR 5 |
| #define SODR 12 |
| #define CODR 13 |
| #define PDSR 15 |
| #define PUDR 24 |
| #define PUER 25 |
| #define ABSR 28 |
| |
| static inline volatile uint32_t* gpioGetPort(uint8_t pin){ |
| |
| uint32_t addr = pin >> 5; |
| addr <<= 9; |
| addr += 0x400E0E00; |
| |
| return (volatile uint32_t*)addr; |
| } |
| |
| static inline uint32_t gpioGetBit(uint8_t pin){ |
| |
| return 1UL << (pin & 31); |
| } |
| |
| void gpioSetFun(uint8_t pin, uint8_t func){ |
| |
| volatile uint32_t* port = gpioGetPort(pin); |
| uint32_t bit = gpioGetBit(pin); |
| |
| if(func == GPIO_FUNC_GPIO){ |
| |
| port[PER] = bit; |
| } |
| else{ |
| |
| port[PDR] = bit; |
| if(func == GPIO_FUNC_A) port[ABSR] &=~ bit; |
| else port[ABSR] |= bit; |
| } |
| } |
| |
| void gpioSetDir(uint8_t pin, char in){ |
| |
| volatile uint32_t* port = gpioGetPort(pin); |
| uint32_t bit = gpioGetBit(pin); |
| |
| if(in) port[ODR] = bit; |
| else port[OER] = bit; |
| } |
| |
| void gpioSetVal(uint8_t pin, char on){ |
| |
| volatile uint32_t* port = gpioGetPort(pin); |
| uint32_t bit = gpioGetBit(pin); |
| |
| if(on) port[SODR] = bit; |
| else port[CODR] = bit; |
| } |
| |
| char gpioGetVal(uint8_t pin){ |
| |
| volatile uint32_t* port = gpioGetPort(pin); |
| uint32_t bit = gpioGetBit(pin); |
| |
| return (port[PDSR] & bit) != 0; |
| } |
| |
| void gpioSetPullup(uint8_t pin, char on){ |
| |
| volatile uint32_t* port = gpioGetPort(pin); |
| uint32_t bit = gpioGetBit(pin); |
| |
| if(on) port[PUER] = bit; |
| else port[PUDR] = bit; |
| } |
| |
| uint8_t getVolume(void){ |
| |
| return volume; |
| } |
| |
| void setVolume(uint8_t vol){ |
| |
| volume = vol; |
| } |
| |
| |
| |
