term.c

picocom 是一款linux下的串口调试工具

			spd = B300;
			break;
		case 600:
			spd = B600;
			break;
		case 1200:
			spd = B1200;
			break;
		case 1800:
			spd = B1800;
			break;
		case 2400:
			spd = B2400;
			break;
		case 4800:
			spd = B4800;
			break;
		case 9600:
			spd = B9600;
			break;
		case 19200:
			spd = B19200;
			break;
		case 38400:
			spd = B38400;
			break;
		case 57600:
			spd = B57600;
			break;
		case 115200:
			spd = B115200;
			break;
		case 230400:
			spd = B230400;
			break;
		default:
			term_errno = TERM_EBAUD;
			rval = -1;
			break;
		}
		if ( rval < 0 ) break;

		r = cfsetospeed(&tio, spd);
		if ( r < 0 ) {
			term_errno = TERM_ESETOSPEED;
			rval = -1;
			break;
		}
			
		r = cfsetispeed(&tio, spd);
		if ( r < 0 ) {
			term_errno = TERM_ESETISPEED;
			rval = -1;
			break;
		}

		term.nexttermios[i] = tio;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set_parity (int fd, enum parity_e parity)
{
	int rval, i;
	struct termios *tiop;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

		tiop = &term.nexttermios[i];

		switch (parity) {
		case P_EVEN:
			tiop->c_cflag = (tiop->c_cflag & ~(PARENB | PARODD)) | PARENB;
			break;
		case P_ODD:
			tiop->c_cflag = (tiop->c_cflag & ~(PARENB | PARODD)) | PARODD;
			break;
		case P_NONE:
			tiop->c_cflag = (tiop->c_cflag & ~(PARENB | PARODD));
			break;
		default:
			term_errno = TERM_EPARITY;
			rval = -1;
			break;
		}
		if ( rval < 0 ) break;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set_databits (int fd, int databits)
{
	int rval, i;
	struct termios *tiop;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

		tiop = &term.nexttermios[i];
				
		switch (databits) {
		case 5:
			tiop->c_cflag = (tiop->c_cflag & ~CSIZE) | CS5;
			break;
		case 6:
			tiop->c_cflag = (tiop->c_cflag & ~CSIZE) | CS6;
			break;
		case 7:
			tiop->c_cflag = (tiop->c_cflag & ~CSIZE) | CS7;
			break;
		case 8:
			tiop->c_cflag = (tiop->c_cflag & ~CSIZE) | CS8;
			break;
		default:
			term_errno = TERM_EDATABITS;
			rval = -1;
			break;
		}
		if ( rval < 0 ) break;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set_flowcntrl (int fd, enum flowcntrl_e flowcntl)
{
	int rval, i;
	struct termios *tiop;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}
		
		tiop = &term.nexttermios[i];

		switch (flowcntl) {
		case FC_RTSCTS:
			tiop->c_cflag |= CRTSCTS;
			tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
			break;
		case FC_XONXOFF:
			tiop->c_cflag &= ~(CRTSCTS);
			tiop->c_iflag |= IXON | IXOFF;
			break;
		case FC_NONE:
			tiop->c_cflag &= ~(CRTSCTS);
			tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
			break;
		default:
			term_errno = TERM_EFLOW;
			rval = -1;
			break;
		}
		if ( rval < 0 ) break;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set_local(int fd, int local)
{
	int rval, i;
	struct termios *tiop;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

		tiop = &term.nexttermios[i];

		if ( local )
			tiop->c_cflag |= CLOCAL;
		else
			tiop->c_cflag &= ~CLOCAL;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set_hupcl (int fd, int on)
{
	int rval, i;
	struct termios *tiop;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

		tiop = &term.nexttermios[i];

		if ( on )
			tiop->c_cflag |= HUPCL;
		else
			tiop->c_cflag &= ~HUPCL;

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_set(int fd,
		 int raw,
		 int baud, enum parity_e parity, int bits, enum flowcntrl_e fc,
		 int local, int hup_close)
{
	int rval, r, i, ni;
	struct termios tio;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			ni = term_add(fd);
			if ( ni < 0 ) {
				rval = -1;
				break;
			}
		} else {
			ni = i;
		}

		tio = term.nexttermios[ni];

		do { /* dummy */

			if (raw) {
				r = term_set_raw(fd);
				if ( r < 0 ) { rval = -1; break; }
			}
			
			r = term_set_baudrate(fd, baud);
			if ( r < 0 ) { rval = -1; break; }
			
			r = term_set_parity(fd, parity);
			if ( r < 0 ) { rval = -1; break; }
			
			r = term_set_databits(fd, bits);
			if ( r < 0 ) { rval = -1; break; }
			
			r = term_set_flowcntrl(fd, fc);
			if ( r < 0 ) { rval = -1; break; }
			
			r = term_set_local(fd, local);
			if ( r < 0 ) { rval = -1; break; }
			
			r = term_set_hupcl(fd, hup_close);
			if ( r < 0 ) { rval = -1; break; }
			
		} while (0);

		if ( rval < 0 ) { 
			if ( i < 0 )
				/* new addition. must be removed */
				term.fd[ni] = -1;
			else
				/* just revert to previous settings */
				term.nexttermios[ni] = tio;
		}

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_pulse_dtr (int fd)
{
	int rval, r, i;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

#ifdef __linux__
		{
			int opins = TIOCM_DTR;

			r = ioctl(fd, TIOCMBIC, &opins);
			if ( r < 0 ) {
				term_errno = TERM_EDTRDOWN;
				rval = -1;
				break;
			}

			sleep(1);

			r = ioctl(fd, TIOCMBIS, &opins);
			if ( r < 0 ) {
				term_errno = TERM_EDTRUP;
				rval = -1;
				break;
			}
		}
#else
		{
			struct termios tio, tioold;

			r = tcgetattr(fd, &tio);
			if ( r < 0 ) {
				term_errno = TERM_ESETATTR;
				rval = -1;
				break;
			}
			
			tioold = tio;
			
			cfsetospeed(&tio, B0);
			cfsetispeed(&tio, B0);
			r = tcsetattr(fd, TCSANOW, &tio);
			if ( r < 0 ) {
				term_errno = TERM_ESETATTR;
				rval = -1;
				break;
			}
			
			sleep(1);
			
			r = tcsetattr(fd, TCSANOW, &tioold);
			if ( r < 0 ) {
				term.currtermios[i] = tio;
				term_errno = TERM_ESETATTR;
				rval = -1;
				break;
			}
		}
#endif /* of __linux__ */
			
	} while (0);

	return rval;
}

/***************************************************************************/

int
term_raise_dtr(int fd)
{
	int rval, r, i;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) {
			rval = -1;
			break;
		}

#ifdef __linux__
		{
			int opins = TIOCM_DTR;

			r = ioctl(fd, TIOCMBIS, &opins);
			if ( r < 0 ) {
				term_errno = TERM_EDTRUP;
				rval = -1;
				break;
			}
		}
#else
		r = tcsetattr(fd, TCSANOW, &term.currtermios[i]);
		if ( r < 0 ) {
			/* FIXME: perhaps try to update currtermios */
			term_errno = TERM_ESETATTR;
			rval = -1;
			break;
		}
#endif /* of __linux__ */
	} while (0);

	return rval;
}

/***************************************************************************/


int
term_lower_dtr(int fd)
{
	int rval, r, i;

	rval = 0;

	do { /* dummy */

		i = term_find(fd);
		if ( i < 0 ) { 
			rval = -1;
			break;
		}

#ifdef __linux__
		{
			int opins = TIOCM_DTR;

			r = ioctl(fd, TIOCMBIC, &opins);
			if ( r < 0 ) {
				term_errno = TERM_EDTRDOWN;
				rval = -1;
				break;
			}
		}
#else
		{
			struct termios tio;

			r = tcgetattr(fd, &tio);
			if ( r < 0 ) {
				term_errno = TERM_EGETATTR;
				rval = -1;
				break;
			}
			term.currtermios[i] = tio;
			
			cfsetospeed(&tio, B0);
			cfsetispeed(&tio, B0);
			
			r = tcsetattr(fd, TCSANOW, &tio);
			if ( r < 0 ) {
				term_errno = TERM_ESETATTR;
				rval = -1;
				break;
			}
		}
#endif /* of __linux__ */
	} while (0);
	
	return rval;
}

/***************************************************************************/

int
term_drain(int fd)
{
	int rval, r;

	rval = 0;

	do { /* dummy */

		r = term_find(fd);
		if ( r < 0 ) {
			rval = -1;
			break;
		}

		do {
			r = tcdrain(fd);
		} while ( r < 0 && errno == EINTR);
		if ( r < 0 ) {
			term_errno = TERM_EDRAIN;
			rval = -1;
			break;
		}

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_flush(int fd)
{
	int rval, r;

	rval = 0;

	do { /* dummy */

		r = term_find(fd);
		if ( r < 0 ) {
			rval = -1;
			break;
		}

		r = tcflush(fd, TCIOFLUSH);
		if ( r < 0 ) {
			rval = -1;
			break;
		}

	} while (0);

	return rval;
}

/***************************************************************************/

int
term_break(int fd)
{
	int rval, r;

	rval = 0;

	do { /* dummy */

		r = term_find(fd);
		if ( r < 0 ) {
			rval = -1;
			break;
		}
	
		r = tcsendbreak(fd, 0);
		if ( r < 0 ) {
			term_errno = TERM_EBREAK;
			rval = -1;
			break;
		}

	} while (0);

	return rval;
}

/**************************************************************************/

/*
 * Local Variables:
 * mode:c
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 */