Lines Matching refs:info

18  * -  rp_table[], accessed through passed "info" pointers, is a global (static) array of 
119 static int rp_baud_base[NUM_BOARDS]; /* Board config info (Someday make a per-board structure) */
281 static inline int rocket_paranoia_check(struct r_port *info,
285 if (!info)
287 if (info->magic != RPORT_MAGIC) {
301 static void rp_do_receive(struct r_port *info, CHANNEL_t *cp,
338 info->ignore_status_mask, info->read_status_mask);
349 if (CharNStat & info->ignore_status_mask) {
353 CharNStat &= info->read_status_mask;
364 tty_insert_flip_char(&info->port, CharNStat & 0xff,
385 space = tty_prepare_flip_string(&info->port, &cbuf, ToRecv);
401 tty_flip_buffer_push(&info->port);
408 * moved to the port's xmit FIFO. *info is critical data, protected by spinlocks.
410 static void rp_do_transmit(struct r_port *info)
413 CHANNEL_t *cp = &info->channel;
420 if (!info)
422 tty = tty_port_tty_get(&info->port);
426 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
430 spin_lock_irqsave(&info->slock, flags);
431 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
437 c = min(info->xmit_fifo_room, info->xmit_cnt);
438 c = min(c, XMIT_BUF_SIZE - info->xmit_tail);
439 if (c <= 0 || info->xmit_fifo_room <= 0)
441 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) (info->xmit_buf + info->xmit_tail), c / 2);
443 sOutB(sGetTxRxDataIO(cp), info->xmit_buf[info->xmit_tail + c - 1]);
444 info->xmit_tail += c;
445 info->xmit_tail &= XMIT_BUF_SIZE - 1;
446 info->xmit_cnt -= c;
447 info->xmit_fifo_room -= c;
453 if (info->xmit_cnt == 0)
454 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
456 if (info->xmit_cnt < WAKEUP_CHARS) {
463 spin_unlock_irqrestore(&info->slock, flags);
467 printk(KERN_DEBUG "(%d,%d,%d,%d)...\n", info->xmit_cnt, info->xmit_head,
468 info->xmit_tail, info->xmit_fifo_room);
477 static void rp_handle_port(struct r_port *info)
482 if (!info)
485 if (!tty_port_initialized(&info->port)) {
487 "info->flags & NOT_INIT\n");
491 cp = &info->channel;
493 IntMask = sGetChanIntID(cp) & info->intmask;
499 rp_do_receive(info, cp, ChanStatus);
503 printk(KERN_INFO "ttyR%d CD now %s...\n", info->line,
506 if (!(ChanStatus & CD_ACT) && info->cd_status) {
510 tty_port_tty_hangup(&info->port, false);
512 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
513 wake_up_interruptible(&info->port.open_wait);
609 struct r_port *info;
619 info = kzalloc(sizeof (struct r_port), GFP_KERNEL);
620 if (!info) {
621 printk(KERN_ERR "Couldn't allocate info struct for line #%d\n",
626 info->magic = RPORT_MAGIC;
627 info->line = line;
628 info->ctlp = ctlp;
629 info->board = board;
630 info->aiop = aiop;
631 info->chan = chan;
632 tty_port_init(&info->port);
633 info->port.ops = &rocket_port_ops;
634 info->flags &= ~ROCKET_MODE_MASK;
638 info->flags |= ROCKET_MODE_RS422;
641 info->flags |= ROCKET_MODE_RS485;
645 info->flags |= ROCKET_MODE_RS232;
649 info->flags |= ROCKET_MODE_RS232;
651 info->intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR;
652 if (sInitChan(ctlp, &info->channel, aiop, chan) == 0) {
655 tty_port_destroy(&info->port);
656 kfree(info);
660 rocketMode = info->flags & ROCKET_MODE_MASK;
662 if ((info->flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS485))
663 sEnRTSToggle(&info->channel);
665 sDisRTSToggle(&info->channel);
670 sSetInterfaceMode(&info->channel, InterfaceModeRS485);
673 sSetInterfaceMode(&info->channel, InterfaceModeRS422);
677 if (info->flags & ROCKET_RTS_TOGGLE)
678 sSetInterfaceMode(&info->channel, InterfaceModeRS232T);
680 sSetInterfaceMode(&info->channel, InterfaceModeRS232);
684 spin_lock_init(&info->slock);
685 mutex_init(&info->write_mtx);
686 rp_table[line] = info;
687 tty_port_register_device(&info->port, rocket_driver, line,
693 * user mode into the driver (exception handler). *info CD manipulation is spinlock protected.
695 static void configure_r_port(struct tty_struct *tty, struct r_port *info,
705 cp = &info->channel;
739 divisor = ((rp_baud_base[info->board] + (baud >> 1)) / baud) - 1;
744 divisor = (rp_baud_base[info->board] / baud) - 1;
748 divisor = (rp_baud_base[info->board] / baud) - 1;
750 info->cps = baud / bits;
757 info->intmask |= DELTA_CTS;
760 info->intmask &= ~DELTA_CTS;
764 info->intmask &= ~DELTA_CD;
766 spin_lock_irqsave(&info->slock, flags);
768 info->cd_status = 1;
770 info->cd_status = 0;
771 info->intmask |= DELTA_CD;
772 spin_unlock_irqrestore(&info->slock, flags);
798 info->read_status_mask = STMRCVROVRH | 0xFF;
800 info->read_status_mask |= STMFRAMEH | STMPARITYH;
802 info->read_status_mask |= STMBREAKH;
807 info->ignore_status_mask = 0;
809 info->ignore_status_mask |= STMFRAMEH | STMPARITYH;
811 info->ignore_status_mask |= STMBREAKH;
817 info->ignore_status_mask |= STMRCVROVRH;
820 rocketMode = info->flags & ROCKET_MODE_MASK;
822 if ((info->flags & ROCKET_RTS_TOGGLE)
828 sSetRTS(&info->channel);
840 if (info->flags & ROCKET_RTS_TOGGLE)
851 struct r_port *info = container_of(port, struct r_port, port);
852 return (sGetChanStatusLo(&info->channel) & CD_ACT) ? 1 : 0;
857 struct r_port *info = container_of(port, struct r_port, port);
859 sSetDTR(&info->channel);
860 sSetRTS(&info->channel);
862 sClrDTR(&info->channel);
863 sClrRTS(&info->channel);
873 struct r_port *info;
879 info = rp_table[tty->index];
880 if (info == NULL)
882 port = &info->port;
891 if (info->xmit_buf)
894 info->xmit_buf = (unsigned char *) page;
896 tty->driver_data = info;
908 printk(KERN_INFO "rp_open ttyR%d, count=%d\n", info->line, info->port.count);
915 cp = &info->channel;
918 info->cd_status = 1;
920 info->cd_status = 0;
938 tty_port_set_initialized(&info->port, 1);
940 configure_r_port(tty, info, NULL);
960 * Exception handler that closes a serial port. info->port.count is considered critical.
964 struct r_port *info = tty->driver_data;
965 struct tty_port *port = &info->port;
969 if (rocket_paranoia_check(info, "rp_close"))
973 printk(KERN_INFO "rp_close ttyR%d, count = %d\n", info->line, info->port.count);
980 cp = &info->channel;
986 timeout = (sGetTxCnt(cp) + 1) * HZ / info->cps;
990 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1007 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1018 if (info->xmit_buf) {
1019 free_page((unsigned long) info->xmit_buf);
1020 info->xmit_buf = NULL;
1036 printk(KERN_INFO "rp_close ttyR%d complete shutdown\n", info->line);
1044 struct r_port *info = tty->driver_data;
1048 if (rocket_paranoia_check(info, "rp_set_termios"))
1062 configure_r_port(tty, info, old_termios);
1064 cp = &info->channel;
1084 struct r_port *info = tty->driver_data;
1087 if (rocket_paranoia_check(info, "rp_break"))
1090 spin_lock_irqsave(&info->slock, flags);
1092 sSendBreak(&info->channel);
1094 sClrBreak(&info->channel);
1095 spin_unlock_irqrestore(&info->slock, flags);
1130 struct r_port *info = tty->driver_data;
1133 ChanStatus = sGetChanStatusLo(&info->channel);
1134 control = info->channel.TxControl[3];
1138 (sGetChanRI(&info->channel) ? TIOCM_RNG : 0) |
1151 struct r_port *info = tty->driver_data;
1154 info->channel.TxControl[3] |= SET_RTS;
1156 info->channel.TxControl[3] |= SET_DTR;
1158 info->channel.TxControl[3] &= ~SET_RTS;
1160 info->channel.TxControl[3] &= ~SET_DTR;
1162 out32(info->channel.IndexAddr, info->channel.TxControl);
1166 static int get_config(struct r_port *info, struct rocket_config __user *retinfo)
1171 mutex_lock(&info->port.mutex);
1172 tmp.line = info->line;
1173 tmp.flags = info->flags;
1174 tmp.close_delay = info->port.close_delay;
1175 tmp.closing_wait = info->port.closing_wait;
1176 tmp.port = rcktpt_io_addr[(info->line >> 5) & 3];
1177 mutex_unlock(&info->port.mutex);
1184 static int set_config(struct tty_struct *tty, struct r_port *info,
1192 mutex_lock(&info->port.mutex);
1195 if ((new_serial.flags & ~ROCKET_USR_MASK) != (info->flags & ~ROCKET_USR_MASK)) {
1196 mutex_unlock(&info->port.mutex);
1199 info->flags = ((info->flags & ~ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK));
1200 mutex_unlock(&info->port.mutex);
1204 if ((new_serial.flags ^ info->flags) & ROCKET_SPD_MASK) {
1210 info->flags = ((info->flags & ~ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS));
1211 info->port.close_delay = new_serial.close_delay;
1212 info->port.closing_wait = new_serial.closing_wait;
1214 mutex_unlock(&info->port.mutex);
1216 configure_r_port(tty, info, NULL);
1222 * about what boards/ports are in the system. This info is passed
1223 * to user space. See setrocket.c where the info is used to create
1226 static int get_ports(struct r_port *info, struct rocket_ports __user *retports)
1252 static int reset_rm2(struct r_port *info, void __user *arg)
1264 if (rcktpt_type[info->board] != ROCKET_TYPE_MODEMII &&
1265 rcktpt_type[info->board] != ROCKET_TYPE_MODEMIII)
1268 if (info->ctlp->BusType == isISA)
1269 sModemReset(info->ctlp, info->chan, reset);
1271 sPCIModemReset(info->ctlp, info->chan, reset);
1276 static int get_version(struct r_port *info, struct rocket_version __user *retvers)
1287 struct r_port *info = tty->driver_data;
1291 if (cmd != RCKP_GET_PORTS && rocket_paranoia_check(info, "rp_ioctl"))
1298 ret = get_config(info, argp);
1303 ret = set_config(tty, info, argp);
1308 ret = get_ports(info, argp);
1313 ret = reset_rm2(info, argp);
1318 ret = get_version(info, argp);
1328 struct r_port *info = tty->driver_data;
1331 if (rocket_paranoia_check(info, "rp_send_xchar"))
1334 cp = &info->channel;
1343 struct r_port *info = tty->driver_data;
1349 if (rocket_paranoia_check(info, "rp_throttle"))
1355 sClrRTS(&info->channel);
1360 struct r_port *info = tty->driver_data;
1365 if (rocket_paranoia_check(info, "rp_unthrottle"))
1371 sSetRTS(&info->channel);
1384 struct r_port *info = tty->driver_data;
1388 info->xmit_cnt, info->xmit_fifo_room);
1391 if (rocket_paranoia_check(info, "rp_stop"))
1394 if (sGetTxCnt(&info->channel))
1395 sDisTransmit(&info->channel);
1400 struct r_port *info = tty->driver_data;
1404 info->xmit_cnt, info->xmit_fifo_room);
1407 if (rocket_paranoia_check(info, "rp_stop"))
1410 sEnTransmit(&info->channel);
1411 set_bit((info->aiop * 8) + info->chan,
1412 (void *) &xmit_flags[info->board]);
1420 struct r_port *info = tty->driver_data;
1426 if (rocket_paranoia_check(info, "rp_wait_until_sent"))
1429 cp = &info->channel;
1435 printk(KERN_INFO "cps=%d...\n", info->cps);
1442 check_time = (HZ / info->cps) / 5;
1444 check_time = HZ * txcnt / info->cps;
1475 struct r_port *info = tty->driver_data;
1478 if (rocket_paranoia_check(info, "rp_hangup"))
1482 printk(KERN_INFO "rp_hangup of ttyR%d...\n", info->line);
1485 spin_lock_irqsave(&info->port.lock, flags);
1486 if (info->port.count)
1488 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1489 spin_unlock_irqrestore(&info->port.lock, flags);
1491 tty_port_hangup(&info->port);
1493 cp = &info->channel;
1500 tty_port_set_initialized(&info->port, 0);
1502 wake_up_interruptible(&info->port.open_wait);
1514 struct r_port *info = tty->driver_data;
1518 if (rocket_paranoia_check(info, "rp_put_char"))
1525 mutex_lock(&info->write_mtx);
1531 spin_lock_irqsave(&info->slock, flags);
1532 cp = &info->channel;
1534 if (!tty->stopped && info->xmit_fifo_room == 0)
1535 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1537 if (tty->stopped || info->xmit_fifo_room == 0 || info->xmit_cnt != 0) {
1538 info->xmit_buf[info->xmit_head++] = ch;
1539 info->xmit_head &= XMIT_BUF_SIZE - 1;
1540 info->xmit_cnt++;
1541 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1544 info->xmit_fifo_room--;
1546 spin_unlock_irqrestore(&info->slock, flags);
1547 mutex_unlock(&info->write_mtx);
1556 * Spinlocks protect the info xmit members.
1561 struct r_port *info = tty->driver_data;
1567 if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
1570 if (mutex_lock_interruptible(&info->write_mtx))
1576 cp = &info->channel;
1578 if (!tty->stopped && info->xmit_fifo_room < count)
1579 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1585 if (!tty->stopped && info->xmit_cnt == 0 && info->xmit_fifo_room > 0) {
1586 c = min(count, info->xmit_fifo_room);
1600 spin_lock_irqsave(&info->slock, flags);
1601 info->xmit_fifo_room -= c;
1602 spin_unlock_irqrestore(&info->slock, flags);
1612 if (!tty_port_active(&info->port))
1614 c = min(count, XMIT_BUF_SIZE - info->xmit_cnt - 1);
1615 c = min(c, XMIT_BUF_SIZE - info->xmit_head);
1620 memcpy(info->xmit_buf + info->xmit_head, b, c);
1622 spin_lock_irqsave(&info->slock, flags);
1623 info->xmit_head =
1624 (info->xmit_head + c) & (XMIT_BUF_SIZE - 1);
1625 info->xmit_cnt += c;
1626 spin_unlock_irqrestore(&info->slock, flags);
1634 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1637 if (info->xmit_cnt < WAKEUP_CHARS) {
1643 mutex_unlock(&info->write_mtx);
1654 struct r_port *info = tty->driver_data;
1657 if (rocket_paranoia_check(info, "rp_write_room"))
1660 ret = XMIT_BUF_SIZE - info->xmit_cnt - 1;
1675 struct r_port *info = tty->driver_data;
1677 if (rocket_paranoia_check(info, "rp_chars_in_buffer"))
1681 printk(KERN_INFO "rp_chars_in_buffer returns %d...\n", info->xmit_cnt);
1683 return info->xmit_cnt;
1688 * r_port struct for the port. Note that spinlock are used to protect info members,
1693 struct r_port *info = tty->driver_data;
1697 if (rocket_paranoia_check(info, "rp_flush_buffer"))
1700 spin_lock_irqsave(&info->slock, flags);
1701 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1702 spin_unlock_irqrestore(&info->slock, flags);
1709 cp = &info->channel;