/*------------------------------------------------------------------------------
--  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 "ssp.h"
#include "core.h"


void sspputw(sspDev dev,int c) {
	volatile int a;
	((_sspDev)dev)->SSPDataReg = c;
	while (((((_sspDev)dev)->SSPStatReg & (1<<4))));
	a=((_sspDev)dev)->SSPDataReg;
}

void sspputc(sspDev dev,char c) {
	volatile char a;
	((_sspDev)dev)->SSPDataReg = c;
	while (((((_sspDev)dev)->SSPStatReg & (1<<4))));
	a=((_sspDev)dev)->SSPDataReg;
}

void sspputnc(sspDev dev,const char *c,unsigned int n)
{
	volatile char a;
	while(n--)
	{
		((_sspDev)dev)->SSPDataReg = *c++;
		while (((((_sspDev)dev)->SSPStatReg & (1<<4))));
		a=((_sspDev)dev)->SSPDataReg;
	}
}

char sspgetc(sspDev dev) {
	((_sspDev)dev)->SSPDataReg = 0xffff;
	while ((((_sspDev)dev)->SSPStatReg & (0x10)));
	return ((char)((_sspDev)dev)->SSPDataReg);
}

void sspgetnc(sspDev dev,char *c,unsigned int n)
{
	volatile char a;
	while (((((_sspDev)dev)->SSPStatReg & (1<<2)))) a=((_sspDev)dev)->SSPDataReg;
	while(n)
	{
		((_sspDev)dev)->SSPDataReg = 0xff;
		while (((((_sspDev)dev)->SSPStatReg & (1<<4))));
		*c= (char)((_sspDev)dev)->SSPDataReg;
		c++;
		n--;
	}
}

int sspgetw(sspDev dev) {
	int dummy;
	while(((((_sspDev)dev)->SSPStatReg & (1<<2))))
		dummy = ((_sspDev)dev)->SSPDataReg;
	((_sspDev)dev)->SSPDataReg = 0xFFFF;
	while (((((_sspDev)dev)->SSPStatReg & (1<<4))));
	return (((_sspDev)dev)->SSPDataReg);
}


void sspputs(sspDev dev,char *s) {
	while (*s) sspputc(dev,*s++);
}


void sspgets(sspDev dev,char *s) {
	while (*s && (*s!=0xd)) *s++ = sspgetc(dev);
}

void sspsetup(sspDev dev,unsigned char bitscount,int sspCtrlRegValue0,int sspCtrlRegValue1, unsigned int  dataRate)
{
	((_sspDev)dev)->SSPCtrlReg0 = sspCtrlRegValue0;
	((_sspDev)dev)->SSPCtrlReg1 = sspCtrlRegValue1;
	sspsetupTRsize(dev,bitscount);
	sspsetdatarate(dev,dataRate);
}

void sspsetupTRsize(sspDev dev,unsigned char value)
{
	disableSSP(dev);
	if(value < 4)value =4;
	value--;
	((_sspDev)dev)->SSPCtrlReg0 |= value;
	((_sspDev)dev)->SSPCtrlReg0 &= 0xFFFFFFF0 | value;
	enableSSP(dev);
}

void enableSSP(sspDev dev)
{
	((_sspDev)dev)->SSPCtrlReg1 |= 1<<1;
}

void disableSSP(sspDev dev)
{
	((_sspDev)dev)->SSPCtrlReg1 &= -1 - (1<<1);
}

void ssppowerup(sspDev dev)
{
	switch((int)dev)
	{
	  case (int)SSP0_BASE_ADDR:
		PCONP |= ( 1 << 21 );
		break;
	  case (int)SSP1_BASE_ADDR:
		PCONP |= ( 1 << 10 );
		break;
	  default:
		break;
	}
}

void ssppowerdown(sspDev dev)
{
	switch((int)dev)
	{
	  case (int)SSP0_BASE_ADDR:
		PCONP &= ~( 1 << 21 );
		break;
	  case (int)SSP1_BASE_ADDR:
		PCONP &= ~( 1 << 10 );
		break;
	  default:
		break;
	}
}


sspDev sspopen(int count){
	sspDev dev;
	switch(count)
	{
	  case 0:
		dev = (sspDev)((unsigned long)SSP0_BASE_ADDR);
		break;
	  case 1:
		dev = (sspDev)((unsigned long)SSP1_BASE_ADDR);
		break;
	  default:
		dev = (sspDev)0;
		break;
	}
	return dev;
}








unsigned char sspgetpclkfactor(sspDev dev)
{
	unsigned int clksel=0;
	const char clkselDec[]={4,1,2,8};
	switch((int)dev)
	{
	  case (int)SSP0_BASE_ADDR:
		clksel = (PCLKSEL1>>10) & 3;
		break;
	  case (int)SSP1_BASE_ADDR:
		clksel = (PCLKSEL0>>20) & 3;
		break;
	  default:
		break;
	}
	return clkselDec[clksel];
}


void sspsetpclkfactor(sspDev dev,unsigned char pclkfactor)
{
	const char clkselDec[]={1,1,2,2,0,0,0,0,3};
	unsigned int clksel=0;
	switch((int)dev)
	{
	  case (int)SSP0_BASE_ADDR:
		PCLKSEL1 |= clkselDec[pclkfactor]<<10;
		PCLKSEL1 &= clkselDec[pclkfactor]<<10;
		break;
	  case (int)SSP1_BASE_ADDR:
		PCLKSEL0 |= clkselDec[pclkfactor]<<20;
		PCLKSEL0 &= clkselDec[pclkfactor]<<20;
		break;
	  default:
		break;
	}

}




void sspsetdatarate(sspDev dev,unsigned int  dataRate)
{
	unsigned int pclk = 0;
	unsigned int cpuclk=0;
	unsigned int sspsclkl=0;
	unsigned char error;
	if(dev==0)return;
	cpuclk = coregetCpuFreq();
	pclk = (cpuclk) / sspgetpclkfactor(dev);
	sspsclkl = ((pclk*32) / (dataRate));
	error = (unsigned char)(sspsclkl & 0x3F);
	if(error >= 0x1F) sspsclkl = sspsclkl + 0x1F;
	sspsclkl = sspsclkl / 32;
	if(sspisslave(dev))
	{
		if(sspsclkl<12) sspsclkl = 12;
	}
	else
	{
		if(sspsclkl<2) sspsclkl = 2;
	}
	sspsclkl &= 0xFE;
	((_sspDev)dev)->SSPClkPrescReg = sspsclkl;
}