// NewSPI returns a new SPI object that is connected to the // specified SPI device interface. // // NewSPI(X,Y) will open /dev/spidev-X.Y // // SPI is an object type that allows SPI transactions // on hosts running the Linux kernel. The host kernel must have SPI // support and SPI device interface support. // All of these can be either built-in to the kernel, or loaded from modules. // // Because the SPI device interface is opened R/W, users of this // module usually must have root permissions. func NewSPI(bus, device int) (spi *SPI, err error) { err = embedded.LoadDeviceTree(fmt.Sprintf("%s%d", deviceTreePrefix, bus)) if err != nil { return nil, err } spi = &SPI{bus: bus, device: device} path := fmt.Sprintf("/dev/spidev%d.%d", bus+1, device) spi.file, err = os.OpenFile(path, os.O_RDWR, 0) if err != nil { return nil, err } r, _, err := syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_MODE, uintptr(unsafe.Pointer(&spi.mode))) if r != 0 { return nil, err } r, _, err = syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_BITS_PER_WORD, uintptr(unsafe.Pointer(&spi.bitsPerWord))) if r != 0 { return nil, err } r, _, err = syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_MAX_SPEED_HZ, uintptr(unsafe.Pointer(&spi.maxSpeedHz))) if r != 0 { return nil, err } return spi, nil }
func setCommState(h syscall.Handle) error { var params structDCB params.DCBlength = uint32(unsafe.Sizeof(params)) //params.flags[0] = 0x01 // fBinary //params.flags[0] |= 0x10 // Assert DSR params.flags[0] = 0x00 params.BaudRate = uint32(9600) params.ByteSize = 8 params.Parity = 0 params.StopBits = 0 //Public Declare Auto Function SetCommState Lib "kernel32.dll" (ByVal nCid As IntPtr, _ // ByRef lpDCB As DCB) As Boolean r, _, err := syscall.Syscall(nSetCommState, 2, uintptr(h), uintptr(unsafe.Pointer(¶ms)), 0) fmt.Println("SetCommState : ", r, err) if r == 0 { _, _, err := syscall.Syscall(nGetLastError, 1, uintptr(h), 0, 0) fmt.Println("LastError : ", err) return nil } return nil }
func TestFormatMessage(t *testing.T) { dll := windows.MustLoadDLL("pdh.dll") pdhOpenQuery := func(datasrc *uint16, userdata uint32, query *windows.Handle) (errno uintptr) { r0, _, _ := syscall.Syscall(dll.MustFindProc("PdhOpenQueryW").Addr(), 3, uintptr(unsafe.Pointer(datasrc)), uintptr(userdata), uintptr(unsafe.Pointer(query))) return r0 } pdhCloseQuery := func(query windows.Handle) (errno uintptr) { r0, _, _ := syscall.Syscall(dll.MustFindProc("PdhCloseQuery").Addr(), 1, uintptr(query), 0, 0) return r0 } var q windows.Handle name, err := windows.UTF16PtrFromString("no_such_source") if err != nil { t.Fatal(err) } errno := pdhOpenQuery(name, 0, &q) if errno == 0 { pdhCloseQuery(q) t.Fatal("PdhOpenQuery succeeded, but expected to fail.") } const flags uint32 = syscall.FORMAT_MESSAGE_FROM_HMODULE | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS buf := make([]uint16, 300) _, err = windows.FormatMessage(flags, uintptr(dll.Handle), uint32(errno), 0, buf, nil) if err != nil { t.Fatal("FormatMessage for handle=%x and errno=%x failed: %v", dll.Handle, errno, err) } }
// Tested on Suzy-Q and BeagleBone. func openConsole(con string) (rc io.ReadCloser, err error) { fd, err := syscall.Open(con, syscall.O_RDONLY|syscall.O_NOCTTY|syscall.O_SYNC, 0) if err != nil { return nil, fmt.Errorf("failed to open console file: %v", err) } defer func() { if fd != -1 { syscall.Close(fd) } }() var term Termios if _, _, errno := syscall.Syscall(SYS_IOCTL, uintptr(fd), TCGETS2, uintptr(unsafe.Pointer(&term))); errno != 0 { return nil, fmt.Errorf("failed to get console termios: %v", errno) } // no parity bit, only need 1 stop bit, no hardware flowcontrol term.Cflag &^= CBAUD | CSIZE | PARENB | CSTOPB | CRTSCTS // ignore modem controls term.Cflag |= B115200 | CS8 | CLOCAL | CREAD // setup for non-canonical mode term.Iflag &^= IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON term.Lflag &^= ECHO | ECHONL | ICANON | ISIG | IEXTEN term.Oflag &^= OPOST term.Cc[VMIN] = 0 term.Cc[VTIME] = 10 // 1 second timeout if _, _, errno := syscall.Syscall(SYS_IOCTL, uintptr(fd), TCSETS2, uintptr(unsafe.Pointer(&term))); errno != 0 { return nil, fmt.Errorf("failed to get console termios: %v", errno) } tmp := fd fd = -1 return &tty{fd: tmp}, nil }
// Xfer performs a SPI transaction. // CS will be released and reactivated between blocks. // delay specifies delay in usec between blocks. func (spi *SPI) Xfer(txBuf []byte, delay_usecs uint16) (rxBuf []byte, err error) { length := len(txBuf) rxBuf = make([]byte, length) xfer := make([]spi_ioc_transfer, length) for i := range xfer { xfer[i].tx_buf = uintptr(unsafe.Pointer(&txBuf[i])) xfer[i].rx_buf = uintptr(unsafe.Pointer(&rxBuf[i])) xfer[i].len = 1 xfer[i].delay_usecs = delay_usecs } SPI_IOC_MESSAGE := C._IOC_WRITE<<C._IOC_DIRSHIFT | C.SPI_IOC_MAGIC<<C._IOC_TYPESHIFT | length<<C._IOC_SIZESHIFT r, _, err := syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), uintptr(SPI_IOC_MESSAGE), uintptr(unsafe.Pointer(&xfer[0]))) if r != 0 { return nil, err } // WA: // in CS_HIGH mode CS isn't pulled to low after transfer, but after read // reading 0 bytes doesnt matter but brings cs down syscall.Syscall(syscall.SYS_READ, spi.file.Fd(), uintptr(unsafe.Pointer(&rxBuf[0])), 0) return rxBuf, nil }
// Configure configures f as a 8N1 serial port with the specified baudrate. func Configure(f fder, baudrate uint32) error { var termios syscall.Termios if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(f.Fd()), uintptr(syscall.TCGETS), uintptr(unsafe.Pointer(&termios))); err != 0 { return err } termios.Ispeed = baudrate termios.Ospeed = baudrate termios.Cflag &^= CBAUD termios.Cflag &^= CBAUDEX termios.Cflag |= baudrate // set 8N1 termios.Cflag &^= syscall.PARENB termios.Cflag &^= syscall.CSTOPB termios.Cflag &^= syscall.CSIZE termios.Cflag |= syscall.CS8 // Local connection, no modem control termios.Cflag |= (syscall.CLOCAL | syscall.CREAD) // Disable hardware flow control termios.Cflag &^= CRTSCTS // Block on a zero read (instead of returning EOF) termios.Cc[syscall.VMIN] = 1 if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(f.Fd()), syscall.TCSETS, uintptr(unsafe.Pointer(&termios))); err != 0 { return err } return nil }
func Console1(forward bool) { // const ( xdm = 7 msg = 10 // messages ) var s stat syscall.Syscall(syscall.SYS_IOCTL, 0, _GETSTATE, uintptr(unsafe.Pointer(&s))) a := s.active if forward { switch a { case xdm - 1: a = xdm + 1 case msg - 1: a = msg + 1 case maxConsole: a = 1 default: a++ } } else { switch a { case 1: a = maxConsole case xdm + 1: a = xdm - 1 case msg + 1: a = msg - 1 default: a-- } } syscall.Syscall(syscall.SYS_IOCTL, 0, _ACTIVATE, uintptr(a)) syscall.Syscall(syscall.SYS_IOCTL, 0, _WAITACTIVE, uintptr(a)) }
// SaferDLLLoading sets DLL load path to be safer. func SaferDLLLoading() error { kernel32, err := syscall.LoadDLL("kernel32.dll") if err != nil { return err } procSetDllDirectoryW, err := kernel32.FindProc("SetDllDirectoryW") if err != nil { return err } var zero uint16 r1, _, e1 := syscall.Syscall(procSetDllDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(&zero)), 0, 0) procSetDefaultDllDirectories, err := kernel32.FindProc("SetDefaultDllDirectories") if err == nil && procSetDefaultDllDirectories.Addr() != 0 { r1, _, e1 = syscall.Syscall(procSetDefaultDllDirectories.Addr(), 1, loadLibrarySearchSystem32, 0, 0) if r1 == 0 { return e1 } } else { return errors.New("SetDefaultDllDirectories not found - please install KB2533623 for safer DLL loading") } return nil }
// enable raw mode and gather metrics, like number of columns func (l *LineReader) raw() { // STD_OUTPUT_HANDLE h, errno := syscall.GetStdHandle(-11) t.h = uintptr(h) if int32(t.h) == -1 { err := os.Errno(errno) panic(err) } ok, _, e := syscall.Syscall(procGetConsoleMode, 2, t.h, uintptr(unsafe.Pointer(&t.origTerm)), 0) if ok == 0 { err := os.NewSyscallError("GetConsoleMode", int(e)) panic(err) } raw := t.origTerm raw &^= _ENABLE_LINE_INPUT | _ENABLE_ECHO_INPUT | _ENABLE_PROCESSED_INPUT | _ENABLE_WINDOW_INPUT ok, _, e = syscall.Syscall(procSetConsoleMode, 2, t.h, uintptr(raw), 0) if ok == 0 { err := os.NewSyscallError("SetConsoleMode", int(e)) panic(err) } win := t.getConsoleInfo() t.cols = int(win.dwSize.x) t.rows = int(win.dwSize.y) t.buf = new(buffer) }
func (p *Port) setControlSignal(sigmask uint, level bool) error { state := uint(0) // get current state _, _, errno := syscall.Syscall( syscall.SYS_IOCTL, p.file.Fd(), uintptr(syscall.TIOCMGET), uintptr(unsafe.Pointer(&state))) if errno != 0 { return fmt.Errorf("ioctl TIOCMGET %d", errno) } // modify state switch level { case true: state |= sigmask // set case false: state &^= sigmask // clear } // set new state _, _, errno = syscall.Syscall( syscall.SYS_IOCTL, p.file.Fd(), uintptr(syscall.TIOCMSET), uintptr(unsafe.Pointer(&state))) if errno != 0 { return fmt.Errorf("ioctl TIOCMSET %d", errno) } return nil }
// SetNOCOWFile sets NOCOW flag for file func SetNOCOWFile(path string) error { file, err := os.Open(path) if err != nil { return err } defer file.Close() fileinfo, err := file.Stat() if err != nil { return err } if fileinfo.IsDir() { return fmt.Errorf("skip directory") } if fileinfo.Size() != 0 { return fmt.Errorf("skip nonempty file") } var attr int if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, file.Fd(), FS_IOC_GETFLAGS, uintptr(unsafe.Pointer(&attr))); errno != 0 { return errno } attr |= FS_NOCOW_FL if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, file.Fd(), FS_IOC_SETFLAGS, uintptr(unsafe.Pointer(&attr))); errno != 0 { return errno } log.Infof("Set NOCOW to path %v succeeded", path) return nil }
// NewSPI returns a new SPI object that is connected to the // specified SPI device interface. // // NewSPI(X,Y) will open /dev/spidev-X.Y // // SPI is an object type that allows SPI transactions // on hosts running the Linux kernel. The host kernel must have SPI // support and SPI device interface support. // All of these can be either built-in to the kernel, or loaded from modules. // // Because the SPI device interface is opened R/W, users of this // module usually must have root permissions. func NewSPI(bus, device int) (*SPI, error) { deviceTreeName := fmt.Sprintf("ADAFRUIT-SPI%d", bus) err := LoadDeviceTree(deviceTreeName) if err != nil { return nil, err } spi := new(SPI) path := fmt.Sprintf("/dev/spidev%d.%d", bus+1, device) spi.file, err = os.OpenFile(path, os.O_RDWR, 0) if err != nil { return nil, err } r, _, err := syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_MODE, uintptr(unsafe.Pointer(&spi.mode))) if r != 0 { return nil, err } r, _, err = syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_BITS_PER_WORD, uintptr(unsafe.Pointer(&spi.bitsPerWord))) if r != 0 { return nil, err } r, _, err = syscall.Syscall(syscall.SYS_IOCTL, spi.file.Fd(), C.SPI_IOC_RD_MAX_SPEED_HZ, uintptr(unsafe.Pointer(&spi.maxSpeedHz))) if r != 0 { return nil, err } return spi, nil }
func main() { flag.Usage = usage flag.Parse() if flag.NArg() < 1 { usage() } vtnum, err := strconv.Atoi(flag.Arg(0)) ck(err) consoles := []string{"/dev/console", "/dev/vc/0", "/dev/tty"} var f *os.File for _, cc := range consoles { f, err = os.OpenFile(cc, os.O_RDWR, 0644) if err == nil { break } } if f == nil { fmt.Fprintln(os.Stderr, "chvt: couldn't get file descriptor referring to console") os.Exit(1) } fd := f.Fd() _, _, err = syscall.Syscall(syscall.SYS_IOCTL, fd, 0x5606, uintptr(vtnum)) if err != nil { _, _, err = syscall.Syscall(syscall.SYS_IOCTL, fd, 0x5607, uintptr(vtnum)) } f.Close() if err != nil { fmt.Fprintln(os.Stderr, "chvt:", err) os.Exit(1) } }
// NewLiner initializes a new *State, and sets the terminal into raw mode. To // restore the terminal to its previous state, call State.Close(). // NewLiner handles SIGWINCH, so it will leak a channel every time you call // it. Therefore, it is recommened that NewLiner only be called once. func NewLiner() *State { bad := map[string]bool{"": true, "dumb": true, "cons25": true} var s State s.r = bufio.NewReader(os.Stdin) s.supported = !bad[strings.ToLower(os.Getenv("TERM"))] if s.supported { syscall.Syscall(syscall.SYS_IOCTL, uintptr(syscall.Stdin), getTermios, uintptr(unsafe.Pointer(&s.origMode))) mode := s.origMode mode.Iflag &^= icrnl | inpck | istrip | ixon mode.Cflag |= cs8 mode.Lflag &^= syscall.ECHO | icanon | iexten syscall.Syscall(syscall.SYS_IOCTL, uintptr(syscall.Stdin), setTermios, uintptr(unsafe.Pointer(&mode))) winch := make(chan os.Signal, 1) signal.Notify(winch, syscall.SIGWINCH) s.winch = winch next := make(chan nexter) go func() { for { var n nexter n.r, _, n.err = s.r.ReadRune() next <- n } }() s.next = next } return &s }
// MsglvlSet returns the read-msglvl, post-set-msglvl of the given interface. func (e *Ethtool) MsglvlSet(intf string, valset uint32) (uint32, uint32, error) { edata := ethtoolValue{ cmd: ETHTOOL_GMSGLVL, } var name [IFNAMSIZ]byte copy(name[:], []byte(intf)) ifr := ifreq{ ifr_name: name, ifr_data: uintptr(unsafe.Pointer(&edata)), } _, _, ep := syscall.Syscall(syscall.SYS_IOCTL, uintptr(e.fd), SIOCETHTOOL, uintptr(unsafe.Pointer(&ifr))) if ep != 0 { return 0, 0, syscall.Errno(ep) } readval := edata.data edata.cmd = ETHTOOL_SMSGLVL edata.data = valset _, _, ep = syscall.Syscall(syscall.SYS_IOCTL, uintptr(e.fd), SIOCETHTOOL, uintptr(unsafe.Pointer(&ifr))) if ep != 0 { return 0, 0, syscall.Errno(ep) } return readval, edata.data, nil }
func Console(a uint8) { // if a <= 0 || a > maxConsole { return } syscall.Syscall(syscall.SYS_IOCTL, 0, _ACTIVATE, uintptr(a)) syscall.Syscall(syscall.SYS_IOCTL, 0, _WAITACTIVE, uintptr(a)) }
func (w *Window) MoveToScreenCenter() { r := w.GetRect() sw, _, _ := syscall.Syscall(getSystemMetrics, 1, sm_cxscreen, 0, 0) sh, _, _ := syscall.Syscall(getSystemMetrics, 1, sm_cyscreen, 0, 0) r.Left = (int(sw) - r.Width) / 2 r.Top = (int(sh) - r.Height) / 2 w.SetRect(r) }
func openInternal(options OpenOptions) (io.ReadWriteCloser, error) { // Open the serial port in non-blocking mode, since otherwise the OS will // wait for the CARRIER line to be asserted. file, err := os.OpenFile( options.PortName, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0600) if err != nil { return nil, err } // We want to do blocking I/O, so clear the non-blocking flag set above. r1, _, errno := syscall.Syscall( syscall.SYS_FCNTL, uintptr(file.Fd()), uintptr(syscall.F_SETFL), uintptr(0)) if errno != 0 { return nil, os.NewSyscallError("SYS_FCNTL", errno) } if r1 != 0 { return nil, errors.New("Unknown error from SYS_FCNTL.") } // Set standard termios options. terminalOptions, err := convertOptions(options) if err != nil { return nil, err } err = setTermios(file.Fd(), terminalOptions) if err != nil { return nil, err } // Set baud rate with the IOSSIOSPEED ioctl, to support non-standard speeds. r2, _, errno2 := syscall.Syscall( syscall.SYS_IOCTL, uintptr(file.Fd()), uintptr(kIOSSIOSPEED), uintptr(unsafe.Pointer(&options.BaudRate))) if errno2 != 0 { return nil, os.NewSyscallError("SYS_IOCTL", errno2) } if r2 != 0 { return nil, errors.New("Unknown error from SYS_IOCTL.") } // We're done. return file, nil }
func syscallEvent(handle syscall.Handle, event string) error { switch event { case "setup": const cio = 64 if r, _, err := syscall.Syscall(nSetupComm, 3, uintptr(handle), cio, cio); r == 0 { return err } return nil case "state": var params DCB params.DCBlength = uint32(unsafe.Sizeof(params)) params.flags[0] = 0x01 // fBinary params.flags[0] |= 0x10 // Assert DSR // params.BaudRate = uint32(250000) params.BaudRate = uint32(115200) params.ByteSize = 8 if r, _, err := syscall.Syscall(nSetCommState, 2, uintptr(handle), uintptr(unsafe.Pointer(¶ms)), 0); r == 0 { return err } return nil case "timeouts": // // we have to set some actual values here // or else the Read() will only return 1 // character and nothing else var timeouts Timeouts timeouts.ReadIntervalTimeout = 20 timeouts.ReadTotalTimeoutMultiplier = 10 timeouts.ReadTotalTimeoutConstant = 100 if r, _, err := syscall.Syscall(nSetCommTimeouts, 2, uintptr(handle), uintptr(unsafe.Pointer(&timeouts)), 0); r == 0 { return err } return nil case "mask": const EV_RXFLAG = 0x0002 if r, _, err := syscall.Syscall(nSetCommMask, 2, uintptr(handle), EV_RXFLAG, 0); r == 0 { return err } return nil case "reset": if r, _, err := syscall.Syscall(nResetEvent, 1, uintptr(handle), 0, 0); r == 0 { return err } return nil default: return fmt.Errorf("[ERROR] invalid event type: %v", event) } return nil }
func handleEvents() bool { msgRst, _, _ := syscall.Syscall6(GetMessage, 4, msgPtr, 0, 0, 0, 0, 0) if msgRst == 0 { return false } syscall.Syscall(TranslateMessage, 1, msgPtr, 0, 0) syscall.Syscall(DispatchMessage, 1, msgPtr, 0, 0) return true }
func InitConsole() { // var m mode syscall.Syscall(syscall.SYS_IOCTL, 0, _GETMODE, uintptr(unsafe.Pointer(&m))) m.mode = _PROCESS m.waitv = 0 m.relsig = int16(syscall.SIGUSR1) m.acqsig = int16(syscall.SIGUSR2) syscall.Syscall(syscall.SYS_IOCTL, 0, _SETMODE, uintptr(unsafe.Pointer(&m))) }
func init_terminal() { syscall.Syscall(syscall.SYS_IOCTL, 0, tcgets, uintptr(unsafe.Pointer(&oldtermios))) var newtermios = oldtermios newtermios.c_lflag &^= 010 // turn off echo newtermios.c_lflag &^= 02 // turn off canonical mode newtermios.c_cc[6] = 1 // set VMIN to 1 newtermios.c_cc[5] = 0 // set VTIME to 0 syscall.Syscall(syscall.SYS_IOCTL, 0, tcsetsf, uintptr(unsafe.Pointer(&newtermios))) }
func Printf(color int, format string, args ...interface{}) { if color < 0 || color >= 16 { fmt.Printf(format, args...) return } syscall.Syscall(uintptr(GetConsoleScreenBufferInfo), 2, hnd, uintptr(unsafe.Pointer(&tmp)), 0) syscall.Syscall(uintptr(SetConsoleTextAttribute), 2, hnd, uintptr(color), 0) fmt.Printf(format, args...) syscall.Syscall(uintptr(SetConsoleTextAttribute), 2, hnd, uintptr(tmp.attributes), 0) }
func resetEvent(h syscall.Handle) error { r, _, err := syscall.Syscall(nResetEvent, 1, uintptr(h), 0, 0) fmt.Println("SetCommMask : ", r, err) if r == 0 { _, _, err := syscall.Syscall(nGetLastError, 1, uintptr(h), 0, 0) fmt.Println("LastError :", err) return nil } return nil }
// see https://github.com/skarnet/skalibs/blob/master/src/libstddjb/ndelay_off.c func ndelay_off(fd FileDescriptor) error { // 32-bit will likely break because it needs SYS_FCNTL64 got, _, e := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(syscall.F_GETFL), 0) if e != 0 { return e } _, _, e = syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(syscall.F_SETFL), uintptr(int(got) & ^syscall.O_NONBLOCK)) if e != 0 { return e } return nil }
func setCommMask(h syscall.Handle) error { const EV_RXCHAR = 0x0001 r, _, err := syscall.Syscall(nSetCommMask, 2, uintptr(h), EV_RXCHAR, 0) fmt.Println("SetCommMask : ", r, err) if r == 0 { _, _, err := syscall.Syscall(nGetLastError, 1, uintptr(h), 0, 0) fmt.Println("LastError :", err) return nil } return nil }
// MakeRaw put the terminal connected to the given file descriptor into raw // mode and returns the previous state of the terminal so that it can be // restored. func MakeRaw(fd int) (*State, error) { var st uint32 _, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0) if e != 0 { return nil, error(e) } raw := st &^ (enableEchoInput | enableProcessedInput | enableLineInput | enableProcessedOutput) _, _, e = syscall.Syscall(procSetConsoleMode.Addr(), 2, uintptr(fd), uintptr(raw), 0) if e != 0 { return nil, error(e) } return &State{st}, nil }
func (port *SerialPort) SetDTR(level bool) error { var status uint _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(port.handle), uintptr(syscall.TIOCMGET), uintptr(unsafe.Pointer(&status))) if err == 0 { if level == false { status &= ^uint(syscall.TIOCM_DTR) } else { status |= syscall.TIOCM_DTR } _, _, err = syscall.Syscall(syscall.SYS_IOCTL, uintptr(port.handle), uintptr(syscall.TIOCMSET), uintptr(unsafe.Pointer(&status))) } return err }
func (s *Serial) SetRTS(state uint8) { if s.Opened { var status uint _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s.f.Fd()), uintptr(C.TIOCMGET), uintptr(unsafe.Pointer(&status))) if err == 0 { if state == 0 { status &= ^uint(C.TIOCM_RTS) } else { status |= C.TIOCM_RTS } syscall.Syscall(syscall.SYS_IOCTL, uintptr(s.f.Fd()), uintptr(C.TIOCMSET), uintptr(unsafe.Pointer(&status))) } } }
// Delete the actual bridge device. func DeleteBridge(name string) error { s, err := getIfSocket() if err != nil { return err } defer syscall.Close(s) nameBytePtr, err := syscall.BytePtrFromString(name) if err != nil { return err } var ifr ifreqFlags copy(ifr.IfrnName[:len(ifr.IfrnName)-1], []byte(name)) if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), syscall.SIOCSIFFLAGS, uintptr(unsafe.Pointer(&ifr))); err != 0 { return err } if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), SIOC_BRDELBR, uintptr(unsafe.Pointer(nameBytePtr))); err != 0 { return err } return nil }