Source of moxa.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
static int MoxaPortLineStatus(struct moxa_port *);
static void MoxaPortFlushData(struct moxa_port *, int);
static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);
static int MoxaPortReadData(struct moxa_port *);
static int MoxaPortTxQueue(struct moxa_port *);
static int MoxaPortRxQueue(struct moxa_port *);
static int MoxaPortTxFree(struct moxa_port *);
static void MoxaPortTxDisable(struct moxa_port *);
static void MoxaPortTxEnable(struct moxa_port *);
static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
static int moxa_get_serial_info(struct tty_struct *, struct serial_struct *);
static int moxa_set_serial_info(struct tty_struct *, struct serial_struct *);
static void MoxaSetFifo(struct moxa_port *port, int enable);
​
/*
 * I/O functions
 */
​
static DEFINE_SPINLOCK(moxafunc_lock);
​
static void moxa_wait_finish(void __iomem *ofsAddr)
{
Show more
                else
                    tmp.cflag = ttyp->termios.c_cflag;
                tty_kref_put(ttyp);
copy:
                if (copy_to_user(argm, &tmp, sizeof(tmp)))
                    return -EFAULT;
            }
        }
        break;
    }
    case TIOCGSERIAL:
            mutex_lock(&ch->port.mutex);
        ret = moxa_get_serial_info(ch, argp);
        mutex_unlock(&ch->port.mutex);
        break;
    case TIOCSSERIAL:
            mutex_lock(&ch->port.mutex);
        ret = moxa_set_serial_info(ch, argp);
        mutex_unlock(&ch->port.mutex);
        break;
    default:
        ret = -ENOIOCTLCMD;
    }
    return ret;
}
​
static int moxa_break_ctl(struct tty_struct *tty, int state)
{
    struct moxa_port *port = tty->driver_data;
​
Show more
    .flush_buffer = moxa_flush_buffer,
    .chars_in_buffer = moxa_chars_in_buffer,
    .ioctl = moxa_ioctl,
    .set_termios = moxa_set_termios,
    .stop = moxa_stop,
    .start = moxa_start,
    .hangup = moxa_hangup,
    .break_ctl = moxa_break_ctl,
    .tiocmget = moxa_tiocmget,
    .tiocmset = moxa_tiocmset,
    .set_serial = moxa_set_serial_info,
    .get_serial = moxa_get_serial_info,
};
​
static const struct tty_port_operations moxa_port_ops = {
    .carrier_raised = moxa_carrier_raised,
    .dtr_rts = moxa_dtr_rts,
    .shutdown = moxa_shutdown,
};
​
static struct tty_driver *moxaDriver;
static DEFINE_TIMER(moxaTimer, moxa_poll);
Show more
static void MoxaPortTxDisable(struct moxa_port *port)
{
    moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
}
​
static void MoxaPortTxEnable(struct moxa_port *port)
{
    moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
}
​
static int moxa_get_serial_info(struct moxa_port *info,
        struct serial_struct __user *retinfo)
static int moxa_get_serial_info(struct tty_struct *tty,
        struct serial_struct *ss)
{
    struct serial_struct tmp = {
        .type = info->type,
        .line = info->port.tty->index,
        .flags = info->port.flags,
        .baud_base = 921600,
        .close_delay = info->port.close_delay
    };
    return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
    struct moxa_port *info = tty->driver_data;
​
    if (tty->index == MAX_PORTS)
        return -EINVAL;
    if (!info)
        return -ENODEV;
    mutex_lock(&info->port.mutex);
    ss->type = info->type,
    ss->line = info->port.tty->index,
    ss->flags = info->port.flags,
    ss->baud_base = 921600,
    ss->close_delay = info->port.close_delay;
    mutex_unlock(&info->port.mutex);
    return 0;
}
​
​
static int moxa_set_serial_info(struct moxa_port *info,
        struct serial_struct __user *new_info)
static int moxa_set_serial_info(struct tty_struct *tty,
        struct serial_struct *ss)
{
    struct serial_struct new_serial;
    struct moxa_port *info = tty->driver_data;
​
    if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
        return -EFAULT;
    if (tty->index == MAX_PORTS)
        return -EINVAL;
    if (!info)
        return -ENODEV;
​
    if (new_serial.irq != 0 || new_serial.port != 0 ||
            new_serial.custom_divisor != 0 ||
            new_serial.baud_base != 921600)
    if (ss->irq != 0 || ss->port != 0 ||
            ss->custom_divisor != 0 ||
            ss->baud_base != 921600)
        return -EPERM;
​
    mutex_lock(&info->port.mutex);
    if (!capable(CAP_SYS_ADMIN)) {
        if (((new_serial.flags & ~ASYNC_USR_MASK) !=
             (info->port.flags & ~ASYNC_USR_MASK)))
        if (((ss->flags & ~ASYNC_USR_MASK) !=
             (info->port.flags & ~ASYNC_USR_MASK))) {
            mutex_unlock(&info->port.mutex);
            return -EPERM;
    } else
        info->port.close_delay = new_serial.close_delay * HZ / 100;
​
    new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
    new_serial.flags |= (info->port.flags & ASYNC_FLAGS);
        }
    }
    info->port.close_delay = ss->close_delay * HZ / 100;
​
    MoxaSetFifo(info, new_serial.type == PORT_16550A);
    MoxaSetFifo(info, ss->type == PORT_16550A);
​
    info->type = new_serial.type;
    info->type = ss->type;
    mutex_unlock(&info->port.mutex);
    return 0;
}
​
​
​
/*****************************************************************************
 *  Static local functions:                          *
 *****************************************************************************/
​
static void MoxaSetFifo(struct moxa_port *port, int enable)