/*
* Open the physical device.
*/
static int ProtocolPortOpen(void)
{
#ifdef PPP_DEV
int pppcom;
uint32_t lctl;
/* Open PPP device. Specify physical device, user and password. */
printf("Open PPP interface at " PPP_DEV_NAME "...");
pppcom = _open("ppp:" PPP_DEV_NAME "/" PPP_USER "/" PPP_PASS, _O_RDWR | _O_BINARY);
if (pppcom == -1) {
puts("failed");
return -1;
}
/*
* Set PPP line speed.
*/
lctl = PPP_SPEED;
_ioctl(pppcom, UART_SETSPEED, &lctl);
printf("%lu baud", lctl);
/*
* The PPP driver doesn't set any receive timeout, but
* may require it.
*/
lctl = PPP_RXTO;
_ioctl(pppcom, UART_SETREADTIMEOUT, &lctl);
printf(", %lu ms timeout\n", lctl);
return pppcom;
#else
/* Nothing to be done for Ethernet. */
return 0;
#endif
}
static int
read_frame(void)
{
struct v4l2_buffer buf;
CLEAR (buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
if (-1 == _ioctl (video.fd, VIDIOC_DQBUF, &buf)) {
switch (errno) {
case EAGAIN:
return 0;
case EIO:
/* Could ignore EIO, see spec. */
/* fall through */
default:
assert(0, "failure on ioctl.VIDIOC_DQBUF");
}
}
assert(buf.index < n_buffers, "non-fatal assert");
thread_lock(video.array);
video.array.val = buffers[buf.index].start;
thread_cond_broadcast(&video.array_new);
assert_fatal(-1 != _ioctl (video.fd, VIDIOC_QBUF, &buf),
"failure on ioctl.VIDIOC_QBUF");
return 1;
}
int
tcflow(int fd, int action)
{
struct termios term;
u_char c;
switch (action) {
case TCOOFF:
return (_ioctl(fd, TIOCSTOP, 0));
case TCOON:
return (_ioctl(fd, TIOCSTART, 0));
case TCION:
case TCIOFF:
if (tcgetattr(fd, &term) == -1)
return (-1);
c = term.c_cc[action == TCIOFF ? VSTOP : VSTART];
if (c != _POSIX_VDISABLE && _write(fd, &c, sizeof(c)) == -1)
return (-1);
return (0);
default:
errno = EINVAL;
return (-1);
}
/* NOTREACHED */
}
void devEthernet::_setFlag(const ACE_UINT32 flag, const bool newSetting) {
ACE_TRACE("devEthernet::_setFlag");
Linux::ifreq ifr;
try {
_ioctl(SIOCGIFFLAGS, ifr, "Error getting flags for interface " + getIfaceName() + " via SIOCGIFFLAGS: ");
}
catch (const IOCtlFailed& e) {
MOD_ERROR("%s", e.what());
return;
}
std::bitset<numFlags> flags(ifr.ifr_flags);
if ( flags[flag] != newSetting ) {
flags[flag] = newSetting;
ifr.ifr_flags = flags.to_ulong();
// IOCtlFailed is thrown if there's an error
try {
_ioctl(SIOCSIFFLAGS, ifr, "Error setting flags via SIOCGIFFLAGS: ");
}
catch (const IOCtlFailed& e) {
MOD_ERROR("%s", e.what());
return;
}
}
}
int
tcsendbreak(int fd, int len __unused)
{
struct timeval sleepytime;
sleepytime.tv_sec = 0;
sleepytime.tv_usec = 400000;
if (_ioctl(fd, TIOCSBRK, 0) == -1)
return (-1);
(void)_select(0, 0, 0, 0, &sleepytime);
if (_ioctl(fd, TIOCCBRK, 0) == -1)
return (-1);
return (0);
}
static void
init_mmap(void)
{
struct v4l2_requestbuffers req;
CLEAR (req);
req.count = 4;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
if (-1 == _ioctl (video.fd, VIDIOC_REQBUFS, &req)) {
if (EINVAL == errno) {
assert_fatal(0, "%s does not support "
"memory mapping", video.dev_name);
} else {
assert_fatal(0, "failure on ioctl.VIDIOC_REQBUFS");
}
}
assert_fatal(req.count >= 2, "Insufficient buffer memory on %s", video.dev_name);
buffers = calloc (req.count, sizeof (*buffers));
assert_fatal(buffers, "Out of memory");
for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
struct v4l2_buffer buf;
CLEAR (buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = n_buffers;
assert_fatal(-1 != _ioctl (video.fd, VIDIOC_QUERYBUF, &buf),
"failure on ioctl.VIDIOC_QUERYBUF");
buffers[n_buffers].length = buf.length;
buffers[n_buffers].start =
mmap (NULL /* start anywhere */,
buf.length,
PROT_READ | PROT_WRITE /* required */,
MAP_SHARED /* recommended */,
video.fd, buf.m.offset);
assert_fatal(MAP_FAILED != buffers[n_buffers].start, "mmap failed");
}
}
int
ioctl(int d, unsigned long request, ...)
{
libc_func(ioctl, int, int, unsigned long, ...);
int result;
va_list ap;
void* arg;
/* one cannot reliably forward arbitrary varargs
* (http://c-faq.com/varargs/handoff.html), but we know that ioctl gets at
* most one extra argument, and almost all of them are pointers or ints,
* both of which fit into a void*.
*/
va_start(ap, request);
arg = va_arg(ap, void*);
va_end(ap);
result = ioctl_emulate(d, request, arg);
if (result != UNHANDLED) {
DBG(DBG_IOCTL, "ioctl fd %i request %lX: emulated, result %i\n", d, request, result);
return result;
}
/* call original ioctl */
result = _ioctl(d, request, arg);
DBG(DBG_IOCTL, "ioctl fd %i request %lX: original, result %i\n", d, request, result);
if (result != -1 && ioctl_record_fd == d)
record_ioctl(request, arg, result);
return result;
}
/*!
* \brief Perform PPP control functions.
*
* \param dev Identifies the device that receives the device-control
* function.
* \param req Requested control function. May be set to one of the
* following constants:
* - LCP_OPEN
* - LCP_CLOSE
* - LCP_LOWERUP
* - LCP_LOWERDOWN
* Any other function will be passed to the physical driver.
*
* \param conf Points to a buffer that contains any data required for
* the given control function or receives data from that
* function.
* \return 0 on success, -1 otherwise.
*
*/
static int NutPppIOCtl(NUTDEVICE * dev, int req, void *conf)
{
int rc = 0;
switch (req) {
case LCP_OPEN:
LcpOpen(dev);
break;
case LCP_CLOSE:
LcpClose(dev);
break;
case LCP_LOWERUP:
LcpLowerUp(dev);
break;
case LCP_LOWERDOWN:
LcpLowerDown(dev);
break;
default:
rc = _ioctl(((PPPDCB *) (dev->dev_dcb))->dcb_fd, req, conf);
break;
}
return rc;
}
/*
* Main application routine.
*/
int main(void)
{
uint32_t baud = 115200;
/*
* Register the UART device, open it, assign stdout to it and set
* the baudrate.
*/
NutRegisterDevice(&DEV_CONSOLE, 0, 0);
freopen(DEV_CONSOLE.dev_name, "w", stdout);
_ioctl(_fileno(stdout), UART_SETSPEED, &baud);
puts("\n\nNut/OS timer sample");
/*
* Display some general info.
*/
printf("CPU running at %lu Hz\n", NutGetCpuClock());
printf("%lu system ticks per second\n", NutTimerMillisToTicks(1000));
/*
* Run the demos.
*/
OneShotDemo(10);
PeriodicDemo(2);
DelayDemo();
SleepDemo(); /* Never returns. */
return 0;
}
int getFrameSize( int fd, int index, uint32_t code, uint32_t frameSize[6] )
{
struct v4l2_frmsizeenum vfse;
CLEAR( vfse );
vfse.index = index;
vfse.pixel_format = code;
int res = _ioctl( fd, VIDIOC_ENUM_FRAMESIZES, &vfse );
if ( res < 0 ) { return res; }
switch ( vfse.type ) {
case V4L2_FRMSIZE_TYPE_DISCRETE:
frameSize[0] = vfse.discrete.width;
frameSize[1] = vfse.discrete.width;
frameSize[2] = 0;
frameSize[3] = vfse.discrete.height;
frameSize[4] = vfse.discrete.height;
frameSize[5] = 0;
return res;
case V4L2_FRMSIZE_TYPE_CONTINUOUS:
case V4L2_FRMSIZE_TYPE_STEPWISE:
frameSize[0] = vfse.stepwise.min_width;
frameSize[1] = vfse.stepwise.max_width;
frameSize[2] = vfse.stepwise.step_width;
frameSize[3] = vfse.stepwise.min_height;
frameSize[4] = vfse.stepwise.max_height;
frameSize[5] = vfse.stepwise.step_height;
return res;
}
return res;
}
int mmapQueryBuffer( int fd, uint32_t index, uint32_t* length, void** start )
{
struct v4l2_buffer buf;
CLEAR( buf );
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = index;
int res = _ioctl( fd, VIDIOC_QUERYBUF, &buf );
if ( res < 0 ) { return res; }
*length = buf.length;
*start = mmap( NULL /* start anywhere */,
buf.length,
PROT_READ | PROT_WRITE /* required */,
MAP_SHARED /* recommended */,
fd, buf.m.offset );
if ( *start == MAP_FAILED ) {
return -1;
} else {
return 0;
}
}
int
tcsetpgrp(int fd, pid_t pgrp)
{
int s;
s = pgrp;
return (_ioctl(fd, TIOCSPGRP, &s));
}
int sockatmark(int s)
{
int atmark;
if (_ioctl(s, SIOCATMARK, &atmark) == -1)
return -1;
return atmark;
}
/**
* Tells the webcam to go into streaming mode, or to
* stop streaming.
* When going into streaming mode, it also creates
* a thread running the webcam_streaming function.
* When exiting the streaming mode, it sets the streaming
* bit to false, and waits for the thread to finish.
*/
void webcam_stream(struct webcam *w, bool flag)
{
uint8_t i;
struct v4l2_buffer buf;
enum v4l2_buf_type type;
if (flag) {
// Clear buffers
for (i = 0; i < w->nbuffers; i++) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
if (-1 == _ioctl(w->fd, VIDIOC_QBUF, &buf)) {
fprintf(stderr, "[v4l2] Error clearing buffers on %s\n", w->name);
return;
}
}
// Turn on streaming
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == _ioctl(w->fd, VIDIOC_STREAMON, &type)) {
fprintf(stderr, "[v4l2] Could not turn on streaming on %s\n", w->name);
return;
}
// Set streaming to true and start thread
w->streaming = true;
pthread_create(&w->thread, NULL, webcam_streaming, (void *)w);
} else {
// Set streaming to false and wait for thread to finish
w->streaming = false;
pthread_join(w->thread, NULL);
// Turn off streaming
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == _ioctl(w->fd, VIDIOC_STREAMOFF, &type)) {
fprintf(stderr, "[v4l2] Could not turn streaming off on %s\n", w->name);
return;
}
}
}
/*
* Hang up.
*/
static void ProtocolPortClose(int pppcom)
{
#ifdef PPP_DEV
/* Set the UART back to normal mode. */
_ioctl(pppcom, HDLC_SETIFNET, NULL);
/* Close the physical port. This may or may not hang up. Please
check the modem's documentation. */
_close(pppcom);
#endif
}
void alarmBeep(void)
{
u_long baud = DBG_BAUDRATE;
NutRegisterDevice(&DBG_DEVICE, 0, 0);
freopen(DBG_DEVNAME, "w", stdout);
_ioctl(_fileno(stdout), UART_SETSPEED, &baud);
VsBeep(440,10000);
}
/*static */
void Main::init_term() {
FILE *uart_terminal;
u_long baud = 57600;
btn_hardware_init();
NutRegisterDevice(&APP_UART, 0, 0);
uart_terminal = fopen(APP_UART.dev_name, "r+");
_ioctl(_fileno(uart_terminal), UART_SETSPEED, &baud);
freopen(APP_UART.dev_name, "w", stdout);
}
pid_t
tcgetsid(int fd)
{
int s;
if (_ioctl(fd, TIOCGSID, &s) < 0)
return ((pid_t)-1);
return ((pid_t)s);
}
pid_t
tcgetpgrp(int fd)
{
int s;
if (_ioctl(fd, TIOCGPGRP, &s) < 0)
return ((pid_t)-1);
return ((pid_t)s);
}
/*
* Open serial debug port for standard output.
*/
static void DebugPortOpen(void)
{
uint32_t baud = 115200;
/* Register debug UART. */
NutRegisterDevice(&DEV_CONSOLE, 0, 0);
/* Open debug device for standard output. */
freopen(DEV_CONSOLE_NAME, "w", stdout);
/* Set baud rate. */
_ioctl(_fileno(stdout), UART_SETSPEED, &baud);
}
int
tcsetsid(int fd, pid_t pid)
{
if (pid != getsid(0)) {
errno = EINVAL;
return (-1);
}
return (_ioctl(fd, TIOCSCTTY, NULL));
}
bool devEthernet::_checkFlag(const ACE_UINT32 flag) {
ACE_TRACE("devEthernet::_checkFlag");
Linux::ifreq ifr;
_ioctl(SIOCGIFFLAGS, ifr, "Error getting flags for interface " + getIfaceName() + " via SIOCGIFFLAGS: ");
std::bitset<numFlags> flags(ifr.ifr_flags);
return flags[flag];
}
char *
fdevname_r(int fd, char *buf, int len)
{
struct fiodgname_arg fgn;
fgn.buf = buf;
fgn.len = len;
if (_ioctl(fd, FIODGNAME, &fgn) == -1)
return (NULL);
return (buf);
}
int mmapEnqueueBuffer( int fd, uint32_t index )
{
struct v4l2_buffer buf;
CLEAR( buf );
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = index;
int res = _ioctl( fd, VIDIOC_QBUF, &buf );
return res;
}
/**
* Reads a frame from the webcam, converts it into the RGB colorspace
* and stores it in the webcam structure
*/
static void webcam_read(struct webcam *w)
{
struct v4l2_buffer buf;
// Try getting an image from the device
for(;;) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
// Dequeue a (filled) buffer from the video device
if (-1 == _ioctl(w->fd, VIDIOC_DQBUF, &buf)) {
switch(errno) {
case EAGAIN:
continue;
case EIO:
default:
fprintf(stderr, "[v4l2] %d: Could not read from device %s\n", errno, w->name);
break;
}
}
// Make sure we are not out of bounds
assert(buf.index < w->nbuffers);
// Lock frame mutex, and store RGB
pthread_mutex_lock(&w->mtx_frame);
convertToRGB(w->buffers[buf.index], &w->frame);
pthread_mutex_unlock(&w->mtx_frame);
break;
}
// Queue buffer back into the video device
if (-1 == _ioctl(w->fd, VIDIOC_QBUF, &buf)) {
fprintf(stderr, "[v4l2] Error while swapping buffers on %s\n", w->name);
return;
}
}
int
tcsetattr(int fd, int opt, const struct termios *t)
{
struct termios localterm;
if (opt & TCSASOFT) {
localterm = *t;
localterm.c_cflag |= CIGNORE;
t = &localterm;
}
switch (opt & ~TCSASOFT) {
case TCSANOW:
return (_ioctl(fd, TIOCSETA, t));
case TCSADRAIN:
return (_ioctl(fd, TIOCSETAW, t));
case TCSAFLUSH:
return (_ioctl(fd, TIOCSETAF, t));
default:
errno = EINVAL;
return (-1);
}
}
void devEthernet::setMTU(const size_t mtu) {
ACE_TRACE("devEthernet::setMTU");
Linux::ifreq ifr;
ifr.ifr_mtu = mtu;
MOD_DEBUG("Setting MTU to %d.", mtu);
// IOCtlFailed is thrown if there's an error
_ioctl(SIOCSIFMTU, ifr, "Error setting MTU via SIOCSIFMTU: ");
CEcfg::instance()->getOrAddInt(cfgKey("MTU"), static_cast<int>(mtu));
MOD_DEBUG("Finished setting MTU.");
}
size_t devEthernet::getMTU() {
ACE_TRACE("devEthernet::getMTU");
Linux::ifreq ifr;
MOD_DEBUG("Getting MTU from device.");
// IOCtlFailed is thrown if there's an error
_ioctl(SIOCGIFMTU, ifr, "Error getting MTU via SIOCGIFMTU: ");
MOD_DEBUG("Found MTU to be %d.", ifr.ifr_mtu);
return ifr.ifr_mtu;
}
devEthernet::~devEthernet() {
MOD_DEBUG("Running ~devEthernet().");
try {
_ioctl(SIOCSIFFLAGS, _savedFlags, "Error restoring saved flags via SIOCSIFFLAGS: ");
}
catch (...) {
}
closeSocket();
if ( _netlinkSocket ) Linux::nl_socket_free(_netlinkSocket);
}
static int
handle_dkio_partitions(int des, int request, int arg)
{
struct s5_dk_cinfo cinfo;
struct dk_allmap map;
struct dk_map *part;
int ret;
extern int errno;
part = (struct dk_map *) arg;
ret = _ioctl(des, S5DKIOCINFO, &cinfo);
if ((cinfo.dki_partition < 0) || (cinfo.dki_partition >= NDKMAP)) {
errno = EINVAL;
return (-1);
}
if (ret != -1) {
ret = _ioctl(des, S5DKIOCGAPART, &map);
if (ret != -1) {
if (request == DKIOCGPART) {
part->dkl_cylno =
map.dka_map[cinfo.dki_partition].dkl_cylno;
part->dkl_nblk =
map.dka_map[cinfo.dki_partition].dkl_nblk;
} else {
map.dka_map[cinfo.dki_partition].dkl_cylno =
part->dkl_cylno;
map.dka_map[cinfo.dki_partition].dkl_nblk =
part->dkl_nblk;
ret = _ioctl(des, S5DKIOCSAPART, &map);
}
}
}
return (ret);
}
