lechu/go-serial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unix: move from syscall to golang.org/x/sys/unix

Browse Source 
Prepare to using `unix.TCFLSH`/`unix.TIOCFLUSH`
which is missing in `syscall` package
This commit is contained in:
Veniamin Albaev
2017-03-09 11:04:34 +03:00
parent ccc846995c
commit 4d886c1028
9 changed files with 203 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
serial_darwin.go
View File

@@ -6,10 +6,10 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
const devFolder = "/dev"
const regexFilter = "^(cu|tty)\\..*"
const ioctlTcgetattr = syscall.TIOCGETA
const ioctlTcsetattr = syscall.TIOCSETA
const ioctlTcgetattr = unix.TIOCGETA
const ioctlTcsetattr = unix.TIOCSETA

50
serial_darwin_386.go
View File

@@ -6,38 +6,38 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
// termios manipulation functions
var baudrateMap = map[int]uint32{
0: syscall.B9600, // Default to 9600
50: syscall.B50,
75: syscall.B75,
110: syscall.B110,
134: syscall.B134,
150: syscall.B150,
200: syscall.B200,
300: syscall.B300,
600: syscall.B600,
1200: syscall.B1200,
1800: syscall.B1800,
2400: syscall.B2400,
4800: syscall.B4800,
9600: syscall.B9600,
19200: syscall.B19200,
38400: syscall.B38400,
57600: syscall.B57600,
115200: syscall.B115200,
230400: syscall.B230400,
0: unix.B9600, // Default to 9600
50: unix.B50,
75: unix.B75,
110: unix.B110,
134: unix.B134,
150: unix.B150,
200: unix.B200,
300: unix.B300,
600: unix.B600,
1200: unix.B1200,
1800: unix.B1800,
2400: unix.B2400,
4800: unix.B4800,
9600: unix.B9600,
19200: unix.B19200,
38400: unix.B38400,
57600: unix.B57600,
115200: unix.B115200,
230400: unix.B230400,
}
var databitsMap = map[int]uint32{
0: syscall.CS8, // Default to 8 bits
5: syscall.CS5,
6: syscall.CS6,
7: syscall.CS7,
8: syscall.CS8,
0: unix.CS8, // Default to 8 bits
5: unix.CS5,
6: unix.CS6,
7: unix.CS7,
8: unix.CS8,
}
const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT

50
serial_darwin_amd64.go
View File

@@ -6,38 +6,38 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
// termios manipulation functions
var baudrateMap = map[int]uint64{
0: syscall.B9600, // Default to 9600
50: syscall.B50,
75: syscall.B75,
110: syscall.B110,
134: syscall.B134,
150: syscall.B150,
200: syscall.B200,
300: syscall.B300,
600: syscall.B600,
1200: syscall.B1200,
1800: syscall.B1800,
2400: syscall.B2400,
4800: syscall.B4800,
9600: syscall.B9600,
19200: syscall.B19200,
38400: syscall.B38400,
57600: syscall.B57600,
115200: syscall.B115200,
230400: syscall.B230400,
0: unix.B9600, // Default to 9600
50: unix.B50,
75: unix.B75,
110: unix.B110,
134: unix.B134,
150: unix.B150,
200: unix.B200,
300: unix.B300,
600: unix.B600,
1200: unix.B1200,
1800: unix.B1800,
2400: unix.B2400,
4800: unix.B4800,
9600: unix.B9600,
19200: unix.B19200,
38400: unix.B38400,
57600: unix.B57600,
115200: unix.B115200,
230400: unix.B230400,
}
var databitsMap = map[int]uint64{
0: syscall.CS8, // Default to 8 bits
5: syscall.CS5,
6: syscall.CS6,
7: syscall.CS7,
8: syscall.CS8,
0: unix.CS8, // Default to 8 bits
5: unix.CS5,
6: unix.CS6,
7: unix.CS7,
8: unix.CS8,
}
const tcCMSPAR uint64 = 0 // may be CMSPAR or PAREXT

58
serial_freebsd.go
View File

@@ -6,7 +6,7 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
const devFolder = "/dev"
const regexFilter = "^(cu|tty)\\..*"
@@ -14,35 +14,35 @@ const regexFilter = "^(cu|tty)\\..*"
// termios manipulation functions
var baudrateMap = map[int]uint32{
0: syscall.B9600, // Default to 9600
50: syscall.B50,
75: syscall.B75,
110: syscall.B110,
134: syscall.B134,
150: syscall.B150,
200: syscall.B200,
300: syscall.B300,
600: syscall.B600,
1200: syscall.B1200,
1800: syscall.B1800,
2400: syscall.B2400,
4800: syscall.B4800,
9600: syscall.B9600,
19200: syscall.B19200,
38400: syscall.B38400,
57600: syscall.B57600,
115200: syscall.B115200,
230400: syscall.B230400,
460800: syscall.B460800,
921600: syscall.B921600,
0: unix.B9600, // Default to 9600
50: unix.B50,
75: unix.B75,
110: unix.B110,
134: unix.B134,
150: unix.B150,
200: unix.B200,
300: unix.B300,
600: unix.B600,
1200: unix.B1200,
1800: unix.B1800,
2400: unix.B2400,
4800: unix.B4800,
9600: unix.B9600,
19200: unix.B19200,
38400: unix.B38400,
57600: unix.B57600,
115200: unix.B115200,
230400: unix.B230400,
460800: unix.B460800,
921600: unix.B921600,
}
var databitsMap = map[int]uint32{
0: syscall.CS8, // Default to 8 bits
5: syscall.CS5,
6: syscall.CS6,
7: syscall.CS7,
8: syscall.CS8,
0: unix.CS8, // Default to 8 bits
5: unix.CS5,
6: unix.CS6,
7: unix.CS7,
8: unix.CS8,
}
const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT
@@ -53,5 +53,5 @@ const tcCRTS_IFLOW uint32 = 0x00020000
const tcCRTSCTS uint32 = tcCCTS_OFLOW
const ioctlTcgetattr = syscall.TIOCGETA
const ioctlTcsetattr = syscall.TIOCSETA
const ioctlTcgetattr = unix.TIOCGETA
const ioctlTcsetattr = unix.TIOCSETA

80
serial_linux.go
View File

@@ -6,7 +6,7 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
const devFolder = "/dev"
const regexFilter = "(ttyS|ttyUSB|ttyACM|ttyAMA|rfcomm|ttyO)[0-9]{1,3}"
@@ -14,51 +14,51 @@ const regexFilter = "(ttyS|ttyUSB|ttyACM|ttyAMA|rfcomm|ttyO)[0-9]{1,3}"
// termios manipulation functions
var baudrateMap = map[int]uint32{
0: syscall.B9600, // Default to 9600
50: syscall.B50,
75: syscall.B75,
110: syscall.B110,
134: syscall.B134,
150: syscall.B150,
200: syscall.B200,
300: syscall.B300,
600: syscall.B600,
1200: syscall.B1200,
1800: syscall.B1800,
2400: syscall.B2400,
4800: syscall.B4800,
9600: syscall.B9600,
19200: syscall.B19200,
38400: syscall.B38400,
57600: syscall.B57600,
115200: syscall.B115200,
230400: syscall.B230400,
460800: syscall.B460800,
500000: syscall.B500000,
576000: syscall.B576000,
921600: syscall.B921600,
1000000: syscall.B1000000,
1152000: syscall.B1152000,
1500000: syscall.B1500000,
2000000: syscall.B2000000,
2500000: syscall.B2500000,
3000000: syscall.B3000000,
3500000: syscall.B3500000,
4000000: syscall.B4000000,
0: unix.B9600, // Default to 9600
50: unix.B50,
75: unix.B75,
110: unix.B110,
134: unix.B134,
150: unix.B150,
200: unix.B200,
300: unix.B300,
600: unix.B600,
1200: unix.B1200,
1800: unix.B1800,
2400: unix.B2400,
4800: unix.B4800,
9600: unix.B9600,
19200: unix.B19200,
38400: unix.B38400,
57600: unix.B57600,
115200: unix.B115200,
230400: unix.B230400,
460800: unix.B460800,
500000: unix.B500000,
576000: unix.B576000,
921600: unix.B921600,
1000000: unix.B1000000,
1152000: unix.B1152000,
1500000: unix.B1500000,
2000000: unix.B2000000,
2500000: unix.B2500000,
3000000: unix.B3000000,
3500000: unix.B3500000,
4000000: unix.B4000000,
}
var databitsMap = map[int]uint32{
0: syscall.CS8, // Default to 8 bits
5: syscall.CS5,
6: syscall.CS6,
7: syscall.CS7,
8: syscall.CS8,
0: unix.CS8, // Default to 8 bits
5: unix.CS5,
6: unix.CS6,
7: unix.CS7,
8: unix.CS8,
}
const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT
const tcIUCLC = syscall.IUCLC
const tcIUCLC = unix.IUCLC
const tcCRTSCTS uint32 = 0x80000000
const ioctlTcgetattr = syscall.TCGETS
const ioctlTcsetattr = syscall.TCSETS
const ioctlTcgetattr = unix.TCGETS
const ioctlTcsetattr = unix.TCSETS

149
serial_unix.go
View File

@@ -13,9 +13,10 @@ import (
"regexp"
"strings"
"sync"
"syscall"
"unsafe"
"golang.org/x/sys/unix"
"go.bug.st/serial.v1/unixutils"
)
@@ -30,7 +31,7 @@ type unixPort struct {
func (port *unixPort) Close() error {
// Close port
port.releaseExclusiveAccess()
if err := syscall.Close(port.handle); err != nil {
if err := unix.Close(port.handle); err != nil {
return err
}
port.opened = false
@@ -66,11 +67,11 @@ func (port *unixPort) Read(p []byte) (n int, err error) {
if res.IsReadable(port.closeSignal.ReadFD()) {
return 0, &PortError{code: PortClosed}
}
return syscall.Read(port.handle, p)
return unix.Read(port.handle, p)
}
func (port *unixPort) Write(p []byte) (n int, err error) {
return syscall.Write(port.handle, p)
return unix.Write(port.handle, p)
}
func (port *unixPort) SetMode(mode *Mode) error {
@@ -99,9 +100,9 @@ func (port *unixPort) SetDTR(dtr bool) error {
return err
}
if dtr {
status |= syscall.TIOCM_DTR
status |= unix.TIOCM_DTR
} else {
status &^= syscall.TIOCM_DTR
status &^= unix.TIOCM_DTR
}
return port.setModemBitsStatus(status)
}
@@ -112,9 +113,9 @@ func (port *unixPort) SetRTS(rts bool) error {
return err
}
if rts {
status |= syscall.TIOCM_RTS
status |= unix.TIOCM_RTS
} else {
status &^= syscall.TIOCM_RTS
status &^= unix.TIOCM_RTS
}
return port.setModemBitsStatus(status)
}
@@ -125,20 +126,20 @@ func (port *unixPort) GetModemStatusBits() (*ModemStatusBits, error) {
return nil, err
}
return &ModemStatusBits{
CTS: (status & syscall.TIOCM_CTS) != 0,
DCD: (status & syscall.TIOCM_CD) != 0,
DSR: (status & syscall.TIOCM_DSR) != 0,
RI: (status & syscall.TIOCM_RI) != 0,
CTS: (status & unix.TIOCM_CTS) != 0,
DCD: (status & unix.TIOCM_CD) != 0,
DSR: (status & unix.TIOCM_DSR) != 0,
RI: (status & unix.TIOCM_RI) != 0,
}, nil
}
func nativeOpen(portName string, mode *Mode) (*unixPort, error) {
h, err := syscall.Open(portName, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NDELAY, 0)
h, err := unix.Open(portName, unix.O_RDWR|unix.O_NOCTTY|unix.O_NDELAY, 0)
if err != nil {
switch err {
case syscall.EBUSY:
case unix.EBUSY:
return nil, &PortError{code: PortBusy}
case syscall.EACCES:
case unix.EACCES:
return nil, &PortError{code: PermissionDenied}
}
return nil, err
@@ -171,7 +172,7 @@ func nativeOpen(portName string, mode *Mode) (*unixPort, error) {
return nil, &PortError{code: InvalidSerialPort}
}
syscall.SetNonblock(h, false)
unix.SetNonblock(h, false)
port.acquireExclusiveAccess()
@@ -232,7 +233,7 @@ func nativeGetPortsList() ([]string, error) {
// termios manipulation functions
func setTermSettingsBaudrate(speed int, settings *syscall.Termios) error {
func setTermSettingsBaudrate(speed int, settings *unix.Termios) error {
baudrate, ok := baudrateMap[speed]
if !ok {
return &PortError{code: InvalidSpeed}
@@ -248,72 +249,72 @@ func setTermSettingsBaudrate(speed int, settings *syscall.Termios) error {
return nil
}
func setTermSettingsParity(parity Parity, settings *syscall.Termios) error {
func setTermSettingsParity(parity Parity, settings *unix.Termios) error {
switch parity {
case NoParity:
settings.Cflag &^= syscall.PARENB
settings.Cflag &^= syscall.PARODD
settings.Cflag &^= unix.PARENB
settings.Cflag &^= unix.PARODD
settings.Cflag &^= tcCMSPAR
settings.Iflag &^= syscall.INPCK
settings.Iflag &^= unix.INPCK
case OddParity:
settings.Cflag |= syscall.PARENB
settings.Cflag |= syscall.PARODD
settings.Cflag |= unix.PARENB
settings.Cflag |= unix.PARODD
settings.Cflag &^= tcCMSPAR
settings.Iflag |= syscall.INPCK
settings.Iflag |= unix.INPCK
case EvenParity:
settings.Cflag |= syscall.PARENB
settings.Cflag &^= syscall.PARODD
settings.Cflag |= unix.PARENB
settings.Cflag &^= unix.PARODD
settings.Cflag &^= tcCMSPAR
settings.Iflag |= syscall.INPCK
settings.Iflag |= unix.INPCK
case MarkParity:
if tcCMSPAR == 0 {
return &PortError{code: InvalidParity}
}
settings.Cflag |= syscall.PARENB
settings.Cflag |= syscall.PARODD
settings.Cflag |= unix.PARENB
settings.Cflag |= unix.PARODD
settings.Cflag |= tcCMSPAR
settings.Iflag |= syscall.INPCK
settings.Iflag |= unix.INPCK
case SpaceParity:
if tcCMSPAR == 0 {
return &PortError{code: InvalidParity}
}
settings.Cflag |= syscall.PARENB
settings.Cflag &^= syscall.PARODD
settings.Cflag |= unix.PARENB
settings.Cflag &^= unix.PARODD
settings.Cflag |= tcCMSPAR
settings.Iflag |= syscall.INPCK
settings.Iflag |= unix.INPCK
default:
return &PortError{code: InvalidParity}
}
return nil
}
func setTermSettingsDataBits(bits int, settings *syscall.Termios) error {
func setTermSettingsDataBits(bits int, settings *unix.Termios) error {
databits, ok := databitsMap[bits]
if !ok {
return &PortError{code: InvalidDataBits}
}
// Remove previous databits setting
settings.Cflag &^= syscall.CSIZE
settings.Cflag &^= unix.CSIZE
// Set requested databits
settings.Cflag |= databits
return nil
}
func setTermSettingsStopBits(bits StopBits, settings *syscall.Termios) error {
func setTermSettingsStopBits(bits StopBits, settings *unix.Termios) error {
switch bits {
case OneStopBit:
settings.Cflag &^= syscall.CSTOPB
settings.Cflag &^= unix.CSTOPB
case OnePointFiveStopBits:
return &PortError{code: InvalidStopBits}
case TwoStopBits:
settings.Cflag |= syscall.CSTOPB
settings.Cflag |= unix.CSTOPB
default:
return &PortError{code: InvalidStopBits}
}
return nil
}
func setTermSettingsCtsRts(enable bool, settings *syscall.Termios) {
func setTermSettingsCtsRts(enable bool, settings *unix.Termios) {
if enable {
settings.Cflag |= tcCRTSCTS
} else {
@@ -321,70 +322,70 @@ func setTermSettingsCtsRts(enable bool, settings *syscall.Termios) {
}
}
func setRawMode(settings *syscall.Termios) {
func setRawMode(settings *unix.Termios) {
// Set local mode
settings.Cflag |= syscall.CREAD
settings.Cflag |= syscall.CLOCAL
settings.Cflag |= unix.CREAD
settings.Cflag |= unix.CLOCAL
// Set raw mode
settings.Lflag &^= syscall.ICANON
settings.Lflag &^= syscall.ECHO
settings.Lflag &^= syscall.ECHOE
settings.Lflag &^= syscall.ECHOK
settings.Lflag &^= syscall.ECHONL
settings.Lflag &^= syscall.ECHOCTL
settings.Lflag &^= syscall.ECHOPRT
settings.Lflag &^= syscall.ECHOKE
settings.Lflag &^= syscall.ISIG
settings.Lflag &^= syscall.IEXTEN
settings.Lflag &^= unix.ICANON
settings.Lflag &^= unix.ECHO
settings.Lflag &^= unix.ECHOE
settings.Lflag &^= unix.ECHOK
settings.Lflag &^= unix.ECHONL
settings.Lflag &^= unix.ECHOCTL
settings.Lflag &^= unix.ECHOPRT
settings.Lflag &^= unix.ECHOKE
settings.Lflag &^= unix.ISIG
settings.Lflag &^= unix.IEXTEN
settings.Iflag &^= syscall.IXON
settings.Iflag &^= syscall.IXOFF
settings.Iflag &^= syscall.IXANY
settings.Iflag &^= syscall.INPCK
settings.Iflag &^= syscall.IGNPAR
settings.Iflag &^= syscall.PARMRK
settings.Iflag &^= syscall.ISTRIP
settings.Iflag &^= syscall.IGNBRK
settings.Iflag &^= syscall.BRKINT
settings.Iflag &^= syscall.INLCR
settings.Iflag &^= syscall.IGNCR
settings.Iflag &^= syscall.ICRNL
settings.Iflag &^= unix.IXON
settings.Iflag &^= unix.IXOFF
settings.Iflag &^= unix.IXANY
settings.Iflag &^= unix.INPCK
settings.Iflag &^= unix.IGNPAR
settings.Iflag &^= unix.PARMRK
settings.Iflag &^= unix.ISTRIP
settings.Iflag &^= unix.IGNBRK
settings.Iflag &^= unix.BRKINT
settings.Iflag &^= unix.INLCR
settings.Iflag &^= unix.IGNCR
settings.Iflag &^= unix.ICRNL
settings.Iflag &^= tcIUCLC
settings.Oflag &^= syscall.OPOST
settings.Oflag &^= unix.OPOST
// Block reads until at least one char is available (no timeout)
settings.Cc[syscall.VMIN] = 1
settings.Cc[syscall.VTIME] = 0
settings.Cc[unix.VMIN] = 1
settings.Cc[unix.VTIME] = 0
}
// native syscall wrapper functions
func (port *unixPort) getTermSettings() (*syscall.Termios, error) {
settings := &syscall.Termios{}
func (port *unixPort) getTermSettings() (*unix.Termios, error) {
settings := &unix.Termios{}
err := ioctl(port.handle, ioctlTcgetattr, uintptr(unsafe.Pointer(settings)))
return settings, err
}
func (port *unixPort) setTermSettings(settings *syscall.Termios) error {
func (port *unixPort) setTermSettings(settings *unix.Termios) error {
return ioctl(port.handle, ioctlTcsetattr, uintptr(unsafe.Pointer(settings)))
}
func (port *unixPort) getModemBitsStatus() (int, error) {
var status int
err := ioctl(port.handle, syscall.TIOCMGET, uintptr(unsafe.Pointer(&status)))
err := ioctl(port.handle, unix.TIOCMGET, uintptr(unsafe.Pointer(&status)))
return status, err
}
func (port *unixPort) setModemBitsStatus(status int) error {
return ioctl(port.handle, syscall.TIOCMSET, uintptr(unsafe.Pointer(&status)))
return ioctl(port.handle, unix.TIOCMSET, uintptr(unsafe.Pointer(&status)))
}
func (port *unixPort) acquireExclusiveAccess() error {
return ioctl(port.handle, syscall.TIOCEXCL, 0)
return ioctl(port.handle, unix.TIOCEXCL, 0)
}
func (port *unixPort) releaseExclusiveAccess() error {
return ioctl(port.handle, syscall.TIOCNXCL, 0)
return ioctl(port.handle, unix.TIOCNXCL, 0)
}

4
zsyscall_darwin.go
View File

@@ -10,10 +10,10 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
func ioctl(fd int, req uint64, data uintptr) (err error) {
_, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
_, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
if e1 != 0 {
err = e1
}

4
zsyscall_freebsd.go
View File

@@ -10,10 +10,10 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
func ioctl(fd int, req uint64, data uintptr) (err error) {
_, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
_, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
if e1 != 0 {
err = e1
}

4
zsyscall_linux.go
View File

@@ -10,10 +10,10 @@
package serial // import "go.bug.st/serial.v1"
import "syscall"
import "golang.org/x/sys/unix"
func ioctl(fd int, req uint64, data uintptr) (err error) {
_, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
_, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
if e1 != 0 {
err = e1
}