/**
* @brief s_open - open a serial port
*
* @param t_port -port number
*
* @return success/fail
*/
signed char s_open(char *t_port)
{
int x;
char cmd[200];
if (fd) {
S_ERROR("Port is already open\n");
return SERIAL_FAILED;
}
/* Check if serial port is used by other process */
/* NOTE: it is a bad idea to use lsof, but the alternative
* is to write large amount of code..
*/
sprintf(cmd, "lsof |grep %s 2>&1 >/dev/null", t_port);
x = system(cmd);
if (x == 0) {
S_ERROR("device %s being used already?\n", t_port);
sprintf(cmd, "lsof |grep %s", t_port);
system(cmd);
return SERIAL_FAILED;
}
fd = open(t_port, O_RDWR | O_NOCTTY);
if (fd < 0) {
S_ERROR("failed to open %s\n", t_port);
perror(t_port);
return SERIAL_FAILED;
}
strncpy((char *)port, t_port, 30);
S_INFO("Serial port %s opend fine\n", port);
return SERIAL_OK;
}
void __init rockchip_timer_clock_source_init( int apb_clk )
{
int v = apb_clk / TIMER_MIN_PCLK;
/* 20101008,HSL,do not warn for 2818.*/
//WARN_ON(v * TIMER_MIN_PCLK != apb_clk); /* have bug */
S_INFO("%s::apb=%d,timer apb=%d\n",__func__,apb_clk,v);
spin_lock( &rockchip_timer_spinlock );
rockchip_apb_clk = v ;
RK_TIMER_DISABLE(TIMER_CLKSRC);
TIMER_SET_ROUNDUS();
#if !CHIP_RK281X
RK_TIMER_INT_ENABLE( TIMER_CLKSRC );
#else
RK_TIMER_INT_DISABLE( TIMER_CLKSRC );
#endif
RK_TIMER_SETMODE_USER( TIMER_CLKSRC );
RK_TIMER_DISABLE(TIMER_CLKEVT);
RK_TIMER_INT_ENABLE( TIMER_CLKEVT );
RK_TIMER_SETMODE_USER( TIMER_CLKEVT );
spin_unlock( &rockchip_timer_spinlock );
}
RpcStringBinding::RpcStringBinding
(
DUALSTRINGARRAY* pdsa,
int portNumber
)
: m_ipAddress (0),
m_portNumber (portNumber),
m_protocolSeq (0),
m_strFormat (0),
m_strFormatNoPortNumber (0)
{
// Check the DUALSTRINGARRAY entries, to find one which can be
// 'resolved' into an IP address on this machine. Win2K sometimes
// provides hostnames as well as the IP numbers that NT usually
// sends, so we need to scan the array to find an IP number...
OLECHAR* pStart = pdsa->aStringArray;
OLECHAR* pCurr = pStart;
while ((pCurr - pStart) < pdsa->wNumEntries)
{
// Make a string-binding out of the DSA entry...
char * pStr = new char [comWideStrLen (pCurr + 1) + 1];
comWideToAscii (pStr, pCurr + 1, comWideStrLen (pCurr + 1) + 1);
initialiseFromString (pStr);
delete []pStr;
m_protocolSeq = *pCurr;
// See if it can be 'resolved' into a viable IP number...
if (! resolve ())
{
S_ERR (LOG_DCOM, "Could not resolve " << ipAddress ());
// Free up the allocated strings.
delString (m_ipAddress);
delString (m_strFormat);
delString (m_strFormatNoPortNumber);
// Could not make sense of the address, so move on through
// the array to the next entry, or the end of the array...
while (((pCurr - pStart) < pdsa->wNumEntries) && (*pCurr))
++pCurr;
++pCurr;
}
else
{
S_INFO (LOG_DCOM, "Resolved " << ipAddress ());
// Take the first one that is viable...
break;
}
}
// at this point the string binding may have worked or not so the calling
// routine must make a call to resolve to determine if a valid address was
// bound since the constructor can't /init
}
/**
* @brief s_putc - put a character into serial port
*
* @param x - character to write
*
* @return character written or error
*/
signed int s_putc(char x)
{
int ret = 0;
S_INFO("[%c] 0x%02x", x, (unsigned char)x);
ret = s_write((unsigned char *)&x, 1);
if (ret < 0) {
S_ERROR("putc failed-%d\n", ret);
return ret;
}
return x;
}
/**
* @brief s_getc - get a character from serial port
*
* @return character read or error
*/
signed int s_getc(void)
{
unsigned char x = 0;
int ret = 0;
ret = s_read(&x, 1);
if (ret < 0) {
S_ERROR("getc failed-%d\n", ret);
return ret;
}
S_INFO("[%c]%x", x, x);
return x;
}
/*
* return 1:need to quit suspend , 0 :reenter suspend
* 20091010,由于拔掉USB会产生我们不希望的中断，因此USB只能通过
* VBUS的变化来判断，不能通过中断判断.
* 关于VBUS的判断，统一放到 dwc_otg_pcd.c 文件里面.
*/
int rockchip_timer_clocksource_irq_checkandclear( void )
{
unsigned int t0,t;
volatile unsigned int *intc_reg = (volatile unsigned int *)(INTC_BASE_ADDR_VA); // +0x28
#if 0
printk("intc regs0:\n0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x\n"
,
intc_reg[0],intc_reg[1],intc_reg[2],intc_reg[3],
intc_reg[4],intc_reg[5],intc_reg[6],intc_reg[7],
intc_reg[8],intc_reg[9],intc_reg[10],intc_reg[11],
intc_reg[12],intc_reg[13]
);
t0 = intc_reg[IRQ_REG_MASKSTATUS_L/4];
t = intc_reg[IRQ_REG_MASKSTATUS_H/4];
//debug_gpio_reverse();
printk("irq0=0x%x!,irq1=0x%x(%d)!\n" ,
t0 , t , (t>>IRQ_NR_TIMER2)&1 );
if( t0 == 0 && t == 0 ) {
intc_reg[IRQ_REG_INTEN_L/4] = (1<<IRQ_NR_GPIO1);
intc_reg[IRQ_REG_INTEN_H/4] = 0;
}
printk("intc regs1:\n0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x 0x%08x 0x%08x\n"
"0x%08x 0x%08x\n"
,
intc_reg[0],intc_reg[1],intc_reg[2],intc_reg[3],
intc_reg[4],intc_reg[5],intc_reg[6],intc_reg[7],
intc_reg[8],intc_reg[9],intc_reg[10],intc_reg[11],
intc_reg[12],intc_reg[13]
);
#else
t0 = intc_reg[IRQ_REG_MASKSTATUS_L/4];
t = intc_reg[IRQ_REG_MASKSTATUS_H/4];
#endif
S_INFO("wake up,t0=0x%x,t1=0x%x\n" , t0,t);
/* clock source irq */
if( t0&(1<<(IRQ_NR_TIMER1+TIMER_CLKEVT)) ) {
RK_TIMER_INT_CLEAR(TIMER_CLKEVT);
rktimer_update_suspend_ms(CHECK_VBUS_MS);
t0 &= ~(1<<(IRQ_NR_TIMER1+TIMER_CLKEVT)); // remove for test deep sleep and wakeup.
}
/* 20091103,HSL@RK,all irq must be handle !*/
t0 |= (t&0xffff);
return t0;
}
/**
* @brief Flush the serial port data
*
* @param rx_bytes return bytes that remains(TBD)
* @param tx_bytes the bytes that are to be send(TBD)
*
* @return error/fail
*/
signed int s_flush(unsigned int *rx_bytes, unsigned int *tx_bytes)
{
int ret;
if (!fd) {
S_ERROR("terminal is not open!\n");
return SERIAL_FAILED;
}
ret = tcflush(fd, TCIFLUSH);
if (ret < 0) {
S_ERROR("failed to flush buffers2\n");
return SERIAL_FAILED;
}
S_INFO("Serial port %s flushed fine\n", port);
return SERIAL_OK;
}
/*
* 20091120,HSL@RK,disable irq for enable timer and set count .
*
*/
void rockchip_timer_clocksource_suspend_resume(int suspend )
{
unsigned long flags;
local_irq_save( flags );
RK_TIMER_DISABLE(TIMER_CLKEVT);
#if 0
if( suspend ) {
RK_TIMER_SETCOUNT(TIMER_CLKEVT,RK_CHECK_VBUS_COUNT*rockchip_apb_clk);
RK_TIMER_ENABLE(TIMER_CLKEVT);
} else {
int cyl = RK_TIMER_GETCOUNT(TIMER_CLKEVT) -
RK_TIMER_READVALUE(TIMER_CLKEVT);
rktimer_update_suspend_ms( CHECK_VBUS_MS*cyl / RK_TIMER_GETCOUNT(TIMER_CLKEVT) );
}
S_INFO("r/s timer,load cnt=0x%x,clk_source_suspend=%ld\n" ,
RK_TIMER_GETCOUNT(TIMER_CLKEVT), clk_source_suspend_second);
#endif
local_irq_restore(flags);
}
static inline cputime64_t rkusb_get_cpu_idle_time(unsigned int cpu)
{
cputime64_t idle_time;
cputime64_t cur_jiffies;
cputime64_t busy_time;
cur_jiffies = jiffies64_to_cputime64(get_jiffies_64());
busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,
kstat_cpu(cpu).cpustat.system);
busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);
busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);
busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);
busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);
idle_time = cputime64_sub(cur_jiffies, busy_time);
S_INFO("%s:jiffies=%Ld,busy=%Ld,idle=%Ld" , __FILE__,
cur_jiffies,busy_time,idle_time);
return idle_time;
}
/**
* @brief s_read - serial port read
*
* @param p_buffer buffer
* @param size buffer length
*
* @return bytes read if ok, else SERIAL_FAILED
*/
signed int s_read(unsigned char *p_buffer, unsigned long size)
{
int ret = 0;
if (!fd) {
S_ERROR("terminal is not open!\n");
return SERIAL_FAILED;
}
/* read entire chunk.. no giving up! */
newtio.c_cc[VMIN] = size;
newtio.c_cc[VTIME] = VTIME_SET;
ret = tcsetattr(fd, TCSANOW, &newtio);
ret = read(fd, p_buffer, size);
if (ret < 0) {
S_ERROR("failed to read data\n");
return SERIAL_FAILED;
}
S_INFO("Serial read requested=%d, read=%d\n", size, ret);
return ret;
}
int rockchip_timer_change_pclk( ip_id ip , int input_clk , int stage )
{
int clk;
//unsigned int cur_cyl0;
//S_INFO("%s::new clk=%d,old rockchip_apb_clk=%d\n" ,__func__,input_clk, rockchip_apb_clk);
#ifdef CONFIG_CHIP_RK2818
if( stage != STAGE_AFTER_CHG )
return 0;
#endif
clk = input_clk/TIMER_MIN_PCLK;
if( clk == rockchip_apb_clk )
return 0;
spin_lock( &rockchip_timer_spinlock );
rockchip_apb_clk = clk ;
spin_unlock( &rockchip_timer_spinlock );
TIMER_SET_ROUNDUS();
S_INFO("%s::apb clk=%d,rockchip_apb_clk=%d\n" ,__func__ ,
input_clk , rockchip_apb_clk);
return 0;
}
/**
* @brief s_write - write to serial port
*
* @param p_buffer - buffer pointer
* @param size -size of buffer
*
* @return bytes wrote if ok, else SERIAL_FAILED
*/
signed int s_write(unsigned char *p_buffer, unsigned long size)
{
int ret = 0, ret1;
if (!fd) {
S_ERROR("terminal is not open!\n");
return SERIAL_FAILED;
}
ret = write(fd, p_buffer, size);
if (ret < 0) {
S_ERROR("failed to write data\n");
return SERIAL_FAILED;
}
/* Wait till it is emptied */
ret1 = tcdrain(fd);
if (ret1 < 0) {
S_ERROR("failed in datai drain\n");
perror(NULL);
return ret1;
}
S_INFO("Serial wrote Requested=%ld wrote=%d\n", size, ret);
return ret;
}
/**
* @brief s_close - close the serial port
*
* @return sucess/fail
*/
signed char s_close(void)
{
int ret = 0;
if (!fd) {
S_ERROR("terminal is not open!\n");
return SERIAL_FAILED;
}
/*
* To prevent switching modes before the last vestiges
* of the data bits have been send, sleep a second.
* This seems to be especially true for usb2serial
* convertors.. it does look as if the data is buffered
* at the usb2serial device itself and closing/changing
* attribs before the final data is pushed is going to
* kill the last bits which need to be send
*/
sleep(1);
/* restore the old port settings */
ret = tcsetattr(fd, TCSANOW, &oldtio);
if (ret < 0) {
S_ERROR("failed to rest old settings\n");
return SERIAL_FAILED;
}
ret = tcflush(fd, TCIFLUSH);
if (ret < 0) {
S_ERROR("failed to flush serial file handle\n");
}
ret = close(fd);
fd = 0;
if (ret < 0) {
S_ERROR("failed to close serial file handle\n");
return SERIAL_FAILED;
}
S_INFO("Serial closed %s fine\n", port);
return SERIAL_OK;
}
/**
* @brief s_configure - configure the serial port
*
* @param s_baud_rate -baudrate
* @param s_parity -parity
* @param s_stop_bits -num stop bits
* @param s_data_bits -data bits
*
* @return -success/failure
*/
signed char s_configure(unsigned long s_baud_rate, unsigned char s_parity,
unsigned char s_stop_bits, unsigned char s_data_bits)
{
int ret;
if (!fd) {
S_ERROR("terminal is not open!\n");
return SERIAL_FAILED;
}
/* save current port settings */
ret = tcgetattr(fd, &oldtio);
if (ret < 0) {
S_ERROR("failed to set get old attribs\n");
return SERIAL_FAILED;
}
/* get current settings, and modify as needed */
ret = tcgetattr(fd, &newtio);
if (ret < 0) {
S_ERROR("failed to get current attribs\n");
return SERIAL_FAILED;
}
switch (s_baud_rate) {
case 57600:
s_baud_rate = B57600;
break;
case 115200:
s_baud_rate = B115200;
break;
/* Add other baudrates - see /usr/include/bits/termios.h */
default:
S_ERROR("Unknown baudrate %d\n", (unsigned int)s_baud_rate);
return SERIAL_FAILED;
}
cfsetospeed(&newtio, s_baud_rate);
cfsetispeed(&newtio, s_baud_rate);
newtio.c_cflag &= ~(CS5 | CS6 | CS7 | CS8);
switch (s_data_bits) {
case 5:
newtio.c_cflag |= CS5;
break;
case 6:
newtio.c_cflag |= CS6;
break;
case 7:
newtio.c_cflag |= CS7;
break;
case 8:
newtio.c_cflag |= CS8;
break;
default:
S_ERROR("unknown data bit %d\n", s_data_bits);
return SERIAL_FAILED;
}
switch (s_stop_bits) {
case ONE_STOP_BIT:
newtio.c_cflag &= ~CSTOPB;
break;
case TWO_STOP_BIT:
newtio.c_cflag |= CSTOPB;
break;
default:
S_ERROR("unknown stop bit %d\n", s_stop_bits);
return SERIAL_FAILED;
}
newtio.c_cflag &= ~(PARENB | PARODD);
newtio.c_iflag &= ~(IGNPAR);
switch (s_parity) {
case ODDPARITY: /* odd */
newtio.c_cflag |= PARENB | PARODD;
newtio.c_iflag |= IGNPAR;
break;
case EVENPARITY: /* even */
newtio.c_cflag |= PARENB;
newtio.c_iflag = 0;
break;
case NOPARITY: /* none */
break;
default:
S_ERROR("unknown parity %d", s_parity);
return SERIAL_FAILED;
}
newtio.c_iflag |= IGNBRK;
newtio.c_cflag |= CLOCAL | CREAD;
S_INFO("c_cflag: 0x%08x\n", (unsigned int)(newtio.c_cflag));
newtio.c_oflag = 0;
/* set input mode (non-canonical, no echo,...) */
newtio.c_lflag = 0;
newtio.c_cc[VTIME] = VTIME_SET;
newtio.c_cc[VMIN] = 1;
newtio.c_cc[VSWTC] = 0;
ret = tcflush(fd, TCIFLUSH);
if (ret < 0) {
S_ERROR("failed to set flush buffers\n");
return SERIAL_FAILED;
}
ret = tcsetattr(fd, TCSANOW, &newtio);
if (ret < 0) {
S_INFO("tcsetattr -> %s (%d) fd=%d", strerror(errno), ret, fd);
S_ERROR("failed to set new attribs\n");
return SERIAL_FAILED;
}
S_INFO("Serial port %s configured fine\n", port);
return SERIAL_OK;
}
