![[BACK]](/icons/back.gif){kind=icon}
Return to cy.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to cy.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: cy.c,v 1.25 2005/11/21 18:16:39 millert Exp $ */
2: /*
3: * Copyright (c) 1996 Timo Rossi.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. Neither the name of the author nor the names of contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: */
30:
31: /*
32: * cy.c
33: *
34: * Driver for Cyclades Cyclom-8/16/32 multiport serial cards
35: * (currently not tested with Cyclom-32 cards)
36: *
37: * Timo Rossi, 1996
38: *
39: * Supports both ISA and PCI Cyclom cards
40: *
41: * Uses CD1400 automatic CTS flow control, and
42: * if CY_HW_RTS is defined, uses CD1400 automatic input flow control.
43: * This requires a special cable that exchanges the RTS and DTR lines.
44: *
45: * Lots of debug output can be enabled by defining CY_DEBUG
46: * Some debugging counters (number of receive/transmit interrupts etc.)
47: * can be enabled by defining CY_DEBUG1
48: *
49: * This version uses the bus_space/io_??() stuff
50: *
51: */
52:
53: /* NCY is the number of Cyclom cards in the machine */
54: #include "cy.h"
55: #if NCY > 0
56:
57: #include <sys/types.h>
58: #include <sys/param.h>
59: #include <sys/ioctl.h>
60: #include <sys/syslog.h>
61: #include <sys/fcntl.h>
62: #include <sys/tty.h>
63: #include <sys/proc.h>
64: #include <sys/conf.h>
65: #include <sys/user.h>
66: #include <sys/selinfo.h>
67: #include <sys/device.h>
68: #include <sys/malloc.h>
69: #include <sys/systm.h>
70:
71: #include <machine/bus.h>
72: #include <machine/intr.h>
73:
74: #if NCY_ISA > 0
75: #include <dev/isa/isavar.h>
76: #include <dev/isa/isareg.h>
77: #endif /* NCY_ISA > 0 */
78: #if NCY_PCI > 0
79: #include <dev/pci/pcivar.h>
80: #include <dev/pci/pcireg.h>
81: #include <dev/pci/pcidevs.h>
82: #endif /* NCY_PCI > 0 */
83:
84: #include <dev/ic/cd1400reg.h>
85: #include <dev/ic/cyreg.h>
86:
87:
88: int cy_intr(void *);
89: int cyparam(struct tty *, struct termios *);
90: void cystart(struct tty *);
91: void cy_poll(void *);
92: int cy_modem_control(struct cy_port *, int, int);
93: void cy_enable_transmitter(struct cy_port *);
94: void cd1400_channel_cmd(struct cy_port *, int);
95: int cy_speed(speed_t, int *, int *, int);
96:
97: struct cfdriver cy_cd = {
98: NULL, "cy", DV_TTY
99: };
100:
101: /*
102: * Common probe routine
103: *
104: * returns the number of chips found.
105: */
106: int
107: cy_probe_common(bus_space_tag_t memt, bus_space_handle_t memh, int bustype)
108: {
109: int cy_chip, chip_offs;
110: u_char firmware_ver;
111: int nchips;
112:
113: /* Cyclom card hardware reset */
114: bus_space_write_1(memt, memh, CY16_RESET<<bustype, 0);
115: DELAY(500); /* wait for reset to complete */
116: bus_space_write_1(memt, memh, CY_CLEAR_INTR<<bustype, 0);
117:
118: #ifdef CY_DEBUG
119: printf("cy: card reset done\n");
120: #endif
121:
122: nchips = 0;
123:
124: for (cy_chip = 0, chip_offs = 0;
125: cy_chip < CY_MAX_CD1400s;
126: cy_chip++, chip_offs += (CY_CD1400_MEMSPACING << bustype)) {
127: int i;
128:
129: /* the last 4 cd1400s are 'interleaved'
130: with the first 4 on 32-port boards */
131: if (cy_chip == 4)
132: chip_offs -= (CY32_ADDR_FIX << bustype);
133:
134: #ifdef CY_DEBUG
135: printf("cy: probe chip %d offset 0x%lx ... ",
136: cy_chip, chip_offs);
137: #endif
138:
139: /* wait until the chip is ready for command */
140: DELAY(1000);
141: if (bus_space_read_1(memt, memh, chip_offs +
142: ((CD1400_CCR << 1) << bustype)) != 0) {
143: #ifdef CY_DEBUG
144: printf("not ready for command\n");
145: #endif
146: break;
147: }
148:
149: /* clear the firmware version reg. */
150: bus_space_write_1(memt, memh, chip_offs +
151: ((CD1400_GFRCR << 1) << bustype), 0);
152:
153: /*
154: * On Cyclom-16 references to non-existent chip 4
155: * actually access chip 0 (address line 9 not decoded).
156: * Here we check if the clearing of chip 4 GFRCR actually
157: * cleared chip 0 GFRCR. In that case we have a 16 port card.
158: */
159: if (cy_chip == 4 &&
160: bus_space_read_1(memt, memh, chip_offs +
161: ((CD1400_GFRCR << 1) << bustype)) == 0)
162: break;
163:
164: /* reset the chip */
165: bus_space_write_1(memt, memh, chip_offs +
166: ((CD1400_CCR << 1) << bustype),
167: CD1400_CCR_CMDRESET | CD1400_CCR_FULLRESET);
168:
169: /* wait for the chip to initialize itself */
170: for (i = 0; i < 200; i++) {
171: DELAY(50);
172: firmware_ver = bus_space_read_1(memt, memh, chip_offs +
173: ((CD1400_GFRCR << 1) << bustype));
174: if ((firmware_ver & 0xf0) == 0x40) /* found a CD1400 */
175: break;
176: }
177: #ifdef CY_DEBUG
178: printf("firmware version 0x%x\n", firmware_ver);
179: #endif
180:
181: if ((firmware_ver & 0xf0) != 0x40)
182: break;
183:
184: /* firmware version OK, CD1400 found */
185: nchips++;
186: }
187:
188: if (nchips == 0) {
189: #ifdef CY_DEBUG
190: printf("no CD1400s found\n");
191: #endif
192: return (0);
193: }
194:
195: #ifdef CY_DEBUG
196: printf("found %d CD1400s\n", nchips);
197: #endif
198:
199: return (nchips);
200: }
201:
202: void
203: cy_attach(parent, self)
204: struct device *parent, *self;
205: {
206: int card, port, cy_chip, num_chips, cdu, chip_offs, cy_clock;
207: struct cy_softc *sc = (void *)self;
208:
209: card = sc->sc_dev.dv_unit;
210: num_chips = sc->sc_nr_cd1400s;
211: if (num_chips == 0)
212: return;
213:
214: timeout_set(&sc->sc_poll_to, cy_poll, sc);
215: bzero(sc->sc_ports, sizeof(sc->sc_ports));
216: sc->sc_nports = num_chips * CD1400_NO_OF_CHANNELS;
217:
218: port = 0;
219: for (cy_chip = 0, chip_offs = 0;
220: cy_chip < num_chips;
221: cy_chip++, chip_offs += (CY_CD1400_MEMSPACING<<sc->sc_bustype)) {
222: if (cy_chip == 4)
223: chip_offs -= (CY32_ADDR_FIX<<sc->sc_bustype);
224:
225: #ifdef CY_DEBUG
226: printf("attach CD1400 #%d offset 0x%x\n", cy_chip, chip_offs);
227: #endif
228: sc->sc_cd1400_offs[cy_chip] = chip_offs;
229:
230: /* configure port 0 as serial port
231: (should already be after reset) */
232: cd_write_reg_sc(sc, cy_chip, CD1400_GCR, 0);
233:
234: /* Set cy_clock depending on firmware version */
235: if (cd_read_reg_sc(sc, cy_chip, CD1400_GFRCR) <= 0x46)
236: cy_clock = CY_CLOCK;
237: else
238: cy_clock = CY_CLOCK_60;
239:
240: /* set up a receive timeout period (1ms) */
241: cd_write_reg_sc(sc, cy_chip, CD1400_PPR,
242: (cy_clock / CD1400_PPR_PRESCALER / 1000) + 1);
243:
244: for (cdu = 0; cdu < CD1400_NO_OF_CHANNELS; cdu++) {
245: sc->sc_ports[port].cy_port_num = port;
246: sc->sc_ports[port].cy_memt = sc->sc_memt;
247: sc->sc_ports[port].cy_memh = sc->sc_memh;
248: sc->sc_ports[port].cy_chip_offs = chip_offs;
249: sc->sc_ports[port].cy_bustype = sc->sc_bustype;
250: sc->sc_ports[port].cy_clock = cy_clock;
251:
252: /* should we initialize anything else here? */
253: port++;
254: } /* for(each port on one CD1400...) */
255:
256: } /* for(each CD1400 on a card... ) */
257:
258: printf(": %d ports\n", port);
259:
260: /* ensure an edge for the next interrupt */
261: bus_space_write_1(sc->sc_memt, sc->sc_memh,
262: CY_CLEAR_INTR<<sc->sc_bustype, 0);
263: }
264:
265: /*
266: * open routine. returns zero if successful, else error code
267: */
268: int cyopen(dev_t, int, int, struct proc *);
269: int cyclose(dev_t, int, int, struct proc *);
270: int cyread(dev_t, struct uio *, int);
271: int cywrite(dev_t, struct uio *, int);
272: struct tty *cytty(dev_t);
273: int cyioctl(dev_t, u_long, caddr_t, int, struct proc *);
274: int cystop(struct tty *, int flag);
275:
276: int
277: cyopen(dev, flag, mode, p)
278: dev_t dev;
279: int flag, mode;
280: struct proc *p;
281: {
282: int card = CY_CARD(dev);
283: int port = CY_PORT(dev);
284: struct cy_softc *sc;
285: struct cy_port *cy;
286: struct tty *tp;
287: int s, error;
288:
289: if (card >= cy_cd.cd_ndevs ||
290: (sc = cy_cd.cd_devs[card]) == NULL) {
291: return (ENXIO);
292: }
293:
294: #ifdef CY_DEBUG
295: printf("%s open port %d flag 0x%x mode 0x%x\n", sc->sc_dev.dv_xname,
296: port, flag, mode);
297: #endif
298:
299: cy = &sc->sc_ports[port];
300:
301: s = spltty();
302: if (cy->cy_tty == NULL) {
303: cy->cy_tty = ttymalloc();
304: }
305: splx(s);
306:
307: tp = cy->cy_tty;
308: tp->t_oproc = cystart;
309: tp->t_param = cyparam;
310: tp->t_dev = dev;
311:
312: if (!ISSET(tp->t_state, TS_ISOPEN)) {
313: SET(tp->t_state, TS_WOPEN);
314: ttychars(tp);
315: tp->t_iflag = TTYDEF_IFLAG;
316: tp->t_oflag = TTYDEF_OFLAG;
317: tp->t_cflag = TTYDEF_CFLAG;
318: if (ISSET(cy->cy_openflags, TIOCFLAG_CLOCAL))
319: SET(tp->t_cflag, CLOCAL);
320: if (ISSET(cy->cy_openflags, TIOCFLAG_CRTSCTS))
321: SET(tp->t_cflag, CRTSCTS);
322: if (ISSET(cy->cy_openflags, TIOCFLAG_MDMBUF))
323: SET(tp->t_cflag, MDMBUF);
324: tp->t_lflag = TTYDEF_LFLAG;
325: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
326:
327: s = spltty();
328:
329: /*
330: * Allocate input ring buffer if we don't already have one
331: */
332: if (cy->cy_ibuf == NULL) {
333: cy->cy_ibuf = malloc(IBUF_SIZE, M_DEVBUF, M_NOWAIT);
334: if (cy->cy_ibuf == NULL) {
335: printf("%s: (port %d) can't allocate input buffer\n",
336: sc->sc_dev.dv_xname, port);
337: splx(s);
338: return (ENOMEM);
339: }
340: cy->cy_ibuf_end = cy->cy_ibuf + IBUF_SIZE;
341: }
342:
343: /* mark the ring buffer as empty */
344: cy->cy_ibuf_rd_ptr = cy->cy_ibuf_wr_ptr = cy->cy_ibuf;
345:
346: /* select CD1400 channel */
347: cd_write_reg(cy, CD1400_CAR, port & CD1400_CAR_CHAN);
348: /* reset the channel */
349: cd1400_channel_cmd(cy, CD1400_CCR_CMDRESET);
350: /* encode unit (port) number in LIVR */
351: /* there is just enough space for 5 bits (32 ports) */
352: cd_write_reg(cy, CD1400_LIVR, port << 3);
353:
354: cy->cy_channel_control = 0;
355:
356: if (!timeout_pending(&sc->sc_poll_to))
357: timeout_add(&sc->sc_poll_to, 1);
358:
359: /* this sets parameters and raises DTR */
360: cyparam(tp, &tp->t_termios);
361:
362: ttsetwater(tp);
363:
364: /* raise RTS too */
365: cy_modem_control(cy, TIOCM_RTS, DMBIS);
366:
367: cy->cy_carrier_stat = cd_read_reg(cy, CD1400_MSVR2);
368:
369: /* enable receiver and modem change interrupts */
370: cd_write_reg(cy, CD1400_SRER,
371: CD1400_SRER_MDMCH | CD1400_SRER_RXDATA);
372:
373: if (CY_DIALOUT(dev) ||
374: ISSET(cy->cy_openflags, TIOCFLAG_SOFTCAR) ||
375: ISSET(tp->t_cflag, MDMBUF) ||
376: ISSET(cy->cy_carrier_stat, CD1400_MSVR2_CD))
377: SET(tp->t_state, TS_CARR_ON);
378: else
379: CLR(tp->t_state, TS_CARR_ON);
380: } else if (ISSET(tp->t_state, TS_XCLUDE) && p->p_ucred->cr_uid != 0) {
381: return (EBUSY);
382: } else {
383: s = spltty();
384: }
385:
386: /* wait for carrier if necessary */
387: if (!ISSET(flag, O_NONBLOCK)) {
388: while (!ISSET(tp->t_cflag, CLOCAL) &&
389: !ISSET(tp->t_state, TS_CARR_ON)) {
390: SET(tp->t_state, TS_WOPEN);
391: error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
392: "cydcd", 0);
393: if (error != 0) {
394: splx(s);
395: CLR(tp->t_state, TS_WOPEN);
396: return (error);
397: }
398: }
399: }
400:
401: splx(s);
402:
403: return (*linesw[tp->t_line].l_open)(dev, tp);
404: }
405:
406: /*
407: * close routine. returns zero if successful, else error code
408: */
409: int
410: cyclose(dev, flag, mode, p)
411: dev_t dev;
412: int flag, mode;
413: struct proc *p;
414: {
415: int card = CY_CARD(dev);
416: int port = CY_PORT(dev);
417: struct cy_softc *sc = cy_cd.cd_devs[card];
418: struct cy_port *cy = &sc->sc_ports[port];
419: struct tty *tp = cy->cy_tty;
420: int s;
421:
422: #ifdef CY_DEBUG
423: printf("%s close port %d, flag 0x%x, mode 0x%x\n", sc->sc_dev.dv_xname,
424: port, flag, mode);
425: #endif
426:
427: (*linesw[tp->t_line].l_close)(tp, flag);
428: s = spltty();
429:
430: if (ISSET(tp->t_cflag, HUPCL) &&
431: !ISSET(cy->cy_openflags, TIOCFLAG_SOFTCAR)) {
432: /* drop DTR and RTS
433: (should we wait for output buffer to become empty first?) */
434: cy_modem_control(cy, 0, DMSET);
435: }
436:
437: /*
438: * XXX should we disable modem change and
439: * receive interrupts here or somewhere ?
440: */
441: CLR(tp->t_state, TS_BUSY | TS_FLUSH);
442:
443: splx(s);
444: ttyclose(tp);
445:
446: return (0);
447: }
448:
449: /*
450: * Read routine
451: */
452: int
453: cyread(dev, uio, flag)
454: dev_t dev;
455: struct uio *uio;
456: int flag;
457: {
458: int card = CY_CARD(dev);
459: int port = CY_PORT(dev);
460: struct cy_softc *sc = cy_cd.cd_devs[card];
461: struct cy_port *cy = &sc->sc_ports[port];
462: struct tty *tp = cy->cy_tty;
463:
464: #ifdef CY_DEBUG
465: printf("%s read port %d uio 0x%x flag 0x%x\n", sc->sc_dev.dv_xname,
466: port, uio, flag);
467: #endif
468:
469: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
470: }
471:
472: /*
473: * Write routine
474: */
475: int
476: cywrite(dev, uio, flag)
477: dev_t dev;
478: struct uio *uio;
479: int flag;
480: {
481: int card = CY_CARD(dev);
482: int port = CY_PORT(dev);
483: struct cy_softc *sc = cy_cd.cd_devs[card];
484: struct cy_port *cy = &sc->sc_ports[port];
485: struct tty *tp = cy->cy_tty;
486:
487: #ifdef CY_DEBUG
488: printf("%s write port %d uio 0x%x flag 0x%x\n", sc->sc_dev.dv_xname,
489: port, uio, flag);
490: #endif
491:
492: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
493: }
494:
495: /*
496: * return tty pointer
497: */
498: struct tty *
499: cytty(dev)
500: dev_t dev;
501: {
502: int card = CY_CARD(dev);
503: int port = CY_PORT(dev);
504: struct cy_softc *sc = cy_cd.cd_devs[card];
505: struct cy_port *cy = &sc->sc_ports[port];
506: struct tty *tp = cy->cy_tty;
507:
508: return (tp);
509: }
510:
511: /*
512: * ioctl routine
513: */
514: int
515: cyioctl(dev, cmd, data, flag, p)
516: dev_t dev;
517: u_long cmd;
518: caddr_t data;
519: int flag;
520: struct proc *p;
521: {
522: int card = CY_CARD(dev);
523: int port = CY_PORT(dev);
524: struct cy_softc *sc = cy_cd.cd_devs[card];
525: struct cy_port *cy = &sc->sc_ports[port];
526: struct tty *tp = cy->cy_tty;
527: int error;
528:
529: #ifdef CY_DEBUG
530: printf("%s port %d ioctl cmd 0x%x data 0x%x flag 0x%x\n",
531: sc->sc_dev.dv_xname, port, cmd, data, flag);
532: #endif
533:
534: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
535: if (error >= 0)
536: return (error);
537:
538: error = ttioctl(tp, cmd, data, flag, p);
539: if (error >= 0)
540: return (error);
541:
542: /* XXX should not allow dropping DTR when dialin? */
543:
544: switch (cmd) {
545: case TIOCSBRK: /* start break */
546: SET(cy->cy_flags, CYF_START_BREAK);
547: cy_enable_transmitter(cy);
548: break;
549:
550: case TIOCCBRK: /* stop break */
551: SET(cy->cy_flags, CYF_END_BREAK);
552: cy_enable_transmitter(cy);
553: break;
554:
555: case TIOCSDTR: /* DTR on */
556: cy_modem_control(cy, TIOCM_DTR, DMBIS);
557: break;
558:
559: case TIOCCDTR: /* DTR off */
560: cy_modem_control(cy, TIOCM_DTR, DMBIC);
561: break;
562:
563: case TIOCMSET: /* set new modem control line values */
564: cy_modem_control(cy, *((int *)data), DMSET);
565: break;
566:
567: case TIOCMBIS: /* turn modem control bits on */
568: cy_modem_control(cy, *((int *)data), DMBIS);
569: break;
570:
571: case TIOCMBIC: /* turn modem control bits off */
572: cy_modem_control(cy, *((int *)data), DMBIC);
573: break;
574:
575: case TIOCMGET: /* get modem control/status line state */
576: *((int *)data) = cy_modem_control(cy, 0, DMGET);
577: break;
578:
579: case TIOCGFLAGS:
580: *((int *)data) = cy->cy_openflags |
581: (CY_DIALOUT(dev) ? TIOCFLAG_SOFTCAR : 0);
582: break;
583:
584: case TIOCSFLAGS:
585: error = suser(p, 0);
586: if (error != 0)
587: return (EPERM);
588:
589: cy->cy_openflags = *((int *)data) &
590: (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL |
591: TIOCFLAG_CRTSCTS | TIOCFLAG_MDMBUF);
592: break;
593:
594: default:
595: return (ENOTTY);
596: }
597:
598: return (0);
599: }
600:
601: /*
602: * start output
603: */
604: void
605: cystart(tp)
606: struct tty *tp;
607: {
608: int card = CY_CARD(tp->t_dev);
609: int port = CY_PORT(tp->t_dev);
610: struct cy_softc *sc = cy_cd.cd_devs[card];
611: struct cy_port *cy = &sc->sc_ports[port];
612: int s;
613:
614: #ifdef CY_DEBUG
615: printf("%s port %d start, tty 0x%x\n", sc->sc_dev.dv_xname, port, tp);
616: #endif
617:
618: s = spltty();
619:
620: #ifdef CY_DEBUG1
621: cy->cy_start_count++;
622: #endif
623:
624: if (!ISSET(tp->t_state, TS_TTSTOP | TS_TIMEOUT | TS_BUSY)) {
625: if (tp->t_outq.c_cc <= tp->t_lowat) {
626: if (ISSET(tp->t_state, TS_ASLEEP)) {
627: CLR(tp->t_state, TS_ASLEEP);
628: wakeup(&tp->t_outq);
629: }
630:
631: selwakeup(&tp->t_wsel);
632:
633: if (tp->t_outq.c_cc == 0)
634: goto out;
635: }
636:
637: SET(tp->t_state, TS_BUSY);
638: cy_enable_transmitter(cy);
639: }
640: out:
641:
642: splx(s);
643: }
644:
645: /*
646: * stop output
647: */
648: int
649: cystop(tp, flag)
650: struct tty *tp;
651: int flag;
652: {
653: int card = CY_CARD(tp->t_dev);
654: int port = CY_PORT(tp->t_dev);
655: struct cy_softc *sc = cy_cd.cd_devs[card];
656: struct cy_port *cy = &sc->sc_ports[port];
657: int s;
658:
659: #ifdef CY_DEBUG
660: printf("%s port %d stop tty 0x%x flag 0x%x\n", sc->sc_dev.dv_xname,
661: port, tp, flag);
662: #endif
663:
664: s = spltty();
665:
666: if (ISSET(tp->t_state, TS_BUSY)) {
667: if (!ISSET(tp->t_state, TS_TTSTOP))
668: SET(tp->t_state, TS_FLUSH);
669:
670: /*
671: * the transmit interrupt routine will disable transmit when it
672: * notices that CYF_STOP has been set.
673: */
674: SET(cy->cy_flags, CYF_STOP);
675: }
676: splx(s);
677: return (0);
678: }
679:
680: /*
681: * parameter setting routine.
682: * returns 0 if successful, else returns error code
683: */
684: int
685: cyparam(tp, t)
686: struct tty *tp;
687: struct termios *t;
688: {
689: int card = CY_CARD(tp->t_dev);
690: int port = CY_PORT(tp->t_dev);
691: struct cy_softc *sc = cy_cd.cd_devs[card];
692: struct cy_port *cy = &sc->sc_ports[port];
693: int ibpr, obpr, i_clk_opt, o_clk_opt;
694: int s, opt;
695:
696: #ifdef CY_DEBUG
697: printf("%s port %d param tty 0x%x termios 0x%x\n", sc->sc_dev.dv_xname,
698: port, tp, t);
699: printf("ispeed %d ospeed %d\n", t->c_ispeed, t->c_ospeed);
700: #endif
701:
702: if (t->c_ospeed != 0 &&
703: cy_speed(t->c_ospeed, &o_clk_opt, &obpr, cy->cy_clock) < 0)
704: return (EINVAL);
705:
706: if (t->c_ispeed != 0 &&
707: cy_speed(t->c_ispeed, &i_clk_opt, &ibpr, cy->cy_clock) < 0)
708: return (EINVAL);
709:
710: s = spltty();
711:
712: /* hang up the line is ospeed is zero, else turn DTR on */
713: cy_modem_control(cy, TIOCM_DTR, (t->c_ospeed == 0 ? DMBIC : DMBIS));
714:
715: /* channel was selected by the above call to cy_modem_control() */
716: /* cd_write_reg(cy, CD1400_CAR, port & CD1400_CAR_CHAN); */
717:
718: /* set transmit speed */
719: if (t->c_ospeed != 0) {
720: cd_write_reg(cy, CD1400_TCOR, o_clk_opt);
721: cd_write_reg(cy, CD1400_TBPR, obpr);
722: }
723: /* set receive speed */
724: if (t->c_ispeed != 0) {
725: cd_write_reg(cy, CD1400_RCOR, i_clk_opt);
726: cd_write_reg(cy, CD1400_RBPR, ibpr);
727: }
728:
729: opt = CD1400_CCR_CMDCHANCTL | CD1400_CCR_XMTEN
730: | (ISSET(t->c_cflag, CREAD) ? CD1400_CCR_RCVEN : CD1400_CCR_RCVDIS);
731:
732: if (opt != cy->cy_channel_control) {
733: cy->cy_channel_control = opt;
734: cd1400_channel_cmd(cy, opt);
735: }
736:
737: /* compute COR1 contents */
738: opt = 0;
739: if (ISSET(t->c_cflag, PARENB)) {
740: if (ISSET(t->c_cflag, PARODD))
741: opt |= CD1400_COR1_PARODD;
742: opt |= CD1400_COR1_PARNORMAL;
743: }
744:
745: if (!ISSET(t->c_iflag, INPCK))
746: opt |= CD1400_COR1_NOINPCK; /* no parity checking */
747:
748: if (ISSET(t->c_cflag, CSTOPB))
749: opt |= CD1400_COR1_STOP2;
750:
751: switch (t->c_cflag & CSIZE) {
752: case CS5:
753: opt |= CD1400_COR1_CS5;
754: break;
755:
756: case CS6:
757: opt |= CD1400_COR1_CS6;
758: break;
759:
760: case CS7:
761: opt |= CD1400_COR1_CS7;
762: break;
763:
764: default:
765: opt |= CD1400_COR1_CS8;
766: break;
767: }
768:
769: cd_write_reg(cy, CD1400_COR1, opt);
770:
771: #ifdef CY_DEBUG
772: printf("cor1 = 0x%x...", opt);
773: #endif
774:
775: /*
776: * use the CD1400 automatic CTS flow control if CRTSCTS is set
777: *
778: * CD1400_COR2_ETC is used because breaks are generated with
779: * embedded transmit commands
780: */
781: cd_write_reg(cy, CD1400_COR2,
782: CD1400_COR2_ETC |
783: (ISSET(t->c_cflag, CRTSCTS) ? CD1400_COR2_CCTS_OFLOW : 0));
784:
785: cd_write_reg(cy, CD1400_COR3, RX_FIFO_THRESHOLD);
786:
787: cd1400_channel_cmd(cy,
788: CD1400_CCR_CMDCORCHG |
789: CD1400_CCR_COR1 | CD1400_CCR_COR2 | CD1400_CCR_COR3);
790:
791: cd_write_reg(cy, CD1400_COR4, CD1400_COR4_PFO_EXCEPTION);
792: cd_write_reg(cy, CD1400_COR5, 0);
793:
794: /*
795: * set modem change option registers to generate interrupts
796: * on carrier detect changes.
797: *
798: * if hardware RTS handshaking is used (CY_HW_RTS, DTR and RTS lines
799: * exchanged), also set the handshaking threshold.
800: */
801: #ifdef CY_HW_RTS
802: cd_write_reg(cy, CD1400_MCOR1, CD1400_MCOR1_CDzd |
803: (ISSET(t->c_cflag, CRTSCTS) ? RX_DTR_THRESHOLD : 0));
804: #else
805: cd_write_reg(cy, CD1400_MCOR1, CD1400_MCOR1_CDzd);
806: #endif /* CY_HW_RTS */
807:
808: cd_write_reg(cy, CD1400_MCOR2, CD1400_MCOR2_CDod);
809:
810: /*
811: * set receive timeout to approx. 2ms
812: * could use more complex logic here...
813: * (but is it actually needed or even useful?)
814: */
815: cd_write_reg(cy, CD1400_RTPR, 2);
816:
817: /*
818: * should do anything else here?
819: * XXX check MDMBUF handshaking like in com.c?
820: */
821:
822: splx(s);
823: return (0);
824: }
825:
826: /*
827: * set/get modem line status
828: *
829: * bits can be: TIOCM_DTR, TIOCM_RTS, TIOCM_CTS, TIOCM_CD, TIOCM_RI, TIOCM_DSR
830: *
831: * RTS and DTR are exchanged if CY_HW_RTS is set
832: *
833: */
834: int
835: cy_modem_control(cy, bits, howto)
836: struct cy_port *cy;
837: int bits;
838: int howto;
839: {
840: int s, msvr;
841:
842: s = spltty();
843:
844: /* select channel */
845: cd_write_reg(cy, CD1400_CAR, cy->cy_port_num & CD1400_CAR_CHAN);
846:
847: /* does not manipulate RTS if it is used for flow control */
848: switch (howto) {
849: case DMGET:
850: bits = 0;
851: if (cy->cy_channel_control & CD1400_CCR_RCVEN)
852: bits |= TIOCM_LE;
853: msvr = cd_read_reg(cy, CD1400_MSVR2);
854: #ifdef CY_HW_RTS
855: if (cd_read_reg(cy, CD1400_MSVR1) & CD1400_MSVR1_RTS)
856: bits |= TIOCM_DTR;
857: if (msvr & CD1400_MSVR2_DTR)
858: bits |= TIOCM_RTS;
859: #else
860: if (cd_read_reg(cy, CD1400_MSVR1) & CD1400_MSVR1_RTS)
861: bits |= TIOCM_RTS;
862: if (msvr & CD1400_MSVR2_DTR)
863: bits |= TIOCM_DTR;
864: #endif /* CY_HW_RTS */
865: if (msvr & CD1400_MSVR2_CTS)
866: bits |= TIOCM_CTS;
867: if (msvr & CD1400_MSVR2_CD)
868: bits |= TIOCM_CD;
869: if (msvr & CD1400_MSVR2_DSR) /* not connected on some
870: Cyclom cards? */
871: bits |= TIOCM_DSR;
872: if (msvr & CD1400_MSVR2_RI) /* not connected on
873: Cyclom-8Y cards? */
874: bits |= TIOCM_RI;
875: splx(s);
876: return (bits);
877:
878: case DMSET: /* replace old values with new ones */
879: #ifdef CY_HW_RTS
880: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS))
881: cd_write_reg(cy, CD1400_MSVR2,
882: ((bits & TIOCM_RTS) ? CD1400_MSVR2_DTR : 0));
883: cd_write_reg(cy, CD1400_MSVR1,
884: ((bits & TIOCM_DTR) ? CD1400_MSVR1_RTS : 0));
885: #else
886: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS))
887: cd_write_reg(cy, CD1400_MSVR1,
888: ((bits & TIOCM_RTS) ? CD1400_MSVR1_RTS : 0));
889: cd_write_reg(cy, CD1400_MSVR2,
890: ((bits & TIOCM_DTR) ? CD1400_MSVR2_DTR : 0));
891: #endif /* CY_HW_RTS */
892: break;
893:
894: case DMBIS: /* set bits */
895: #ifdef CY_HW_RTS
896: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS) &&
897: (bits & TIOCM_RTS) != 0)
898: cd_write_reg(cy, CD1400_MSVR2, CD1400_MSVR2_DTR);
899: if (bits & TIOCM_DTR)
900: cd_write_reg(cy, CD1400_MSVR1, CD1400_MSVR1_RTS);
901: #else
902: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS) &&
903: (bits & TIOCM_RTS) != 0)
904: cd_write_reg(cy, CD1400_MSVR1, CD1400_MSVR1_RTS);
905: if (bits & TIOCM_DTR)
906: cd_write_reg(cy, CD1400_MSVR2, CD1400_MSVR2_DTR);
907: #endif /* CY_HW_RTS */
908: break;
909:
910: case DMBIC: /* clear bits */
911: #ifdef CY_HW_RTS
912: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS) &&
913: (bits & TIOCM_RTS))
914: cd_write_reg(cy, CD1400_MSVR2, 0);
915: if (bits & TIOCM_DTR)
916: cd_write_reg(cy, CD1400_MSVR1, 0);
917: #else
918: if (!ISSET(cy->cy_tty->t_cflag, CRTSCTS) &&
919: (bits & TIOCM_RTS))
920: cd_write_reg(cy, CD1400_MSVR1, 0);
921: if (bits & TIOCM_DTR)
922: cd_write_reg(cy, CD1400_MSVR2, 0);
923: #endif /* CY_HW_RTS */
924: break;
925: }
926: splx(s);
927: return (0);
928: }
929:
930: /*
931: * Upper-level handler loop (called from timer interrupt?)
932: * This routine is common for multiple cards
933: */
934: void
935: cy_poll(void *arg)
936: {
937: int port;
938: struct cy_softc *sc = arg;
939: struct cy_port *cy;
940: struct tty *tp;
941: static int counter = 0;
942: #ifdef CY_DEBUG1
943: int did_something;
944: #endif
945:
946: int s;
947:
948: s = spltty();
949:
950: if (sc->sc_events == 0 && ++counter < 200) {
951: splx(s);
952: goto out;
953: }
954:
955: sc->sc_events = 0;
956: splx(s);
957:
958: #ifdef CY_DEBUG1
959: sc->sc_poll_count1++;
960: did_something = 0;
961: #endif
962:
963: for (port = 0; port < sc->sc_nports; port++) {
964: cy = &sc->sc_ports[port];
965: if ((tp = cy->cy_tty) == NULL || cy->cy_ibuf == NULL ||
966: !ISSET(tp->t_state, TS_ISOPEN | TS_WOPEN))
967: continue;
968:
969: /*
970: * handle received data
971: */
972: while (cy->cy_ibuf_rd_ptr != cy->cy_ibuf_wr_ptr) {
973: u_char line_stat;
974: int chr;
975:
976: line_stat = cy->cy_ibuf_rd_ptr[0];
977: chr = cy->cy_ibuf_rd_ptr[1];
978:
979: if (line_stat &
980: (CD1400_RDSR_BREAK|CD1400_RDSR_FE))
981: chr |= TTY_FE;
982: if (line_stat & CD1400_RDSR_PE)
983: chr |= TTY_PE;
984:
985: /*
986: * on an overrun error the data is treated as
987: * good just as it should be.
988: */
989:
990: #ifdef CY_DEBUG
991: printf("%s port %d ttyinput 0x%x\n",
992: sc->sc_dev.dv_xname, port, chr);
993: #endif
994:
995: (*linesw[tp->t_line].l_rint)(chr, tp);
996:
997: s = spltty(); /* really necessary? */
998: if ((cy->cy_ibuf_rd_ptr += 2) ==
999: cy->cy_ibuf_end)
1000: cy->cy_ibuf_rd_ptr = cy->cy_ibuf;
1001: splx(s);
1002:
1003: #ifdef CY_DEBUG1
1004: did_something = 1;
1005: #endif
1006: }
1007:
1008: #ifndef CY_HW_RTS
1009: /*
1010: * If we don't have any received data in ibuf and
1011: * CRTSCTS is on and RTS is turned off, it is time
1012: * to turn RTS back on
1013: */
1014: if (ISSET(tp->t_cflag, CRTSCTS)) {
1015: /* we can't use cy_modem_control() here as it
1016: doesn't change RTS if RTSCTS is on */
1017: cd_write_reg(cy, CD1400_CAR,
1018: port & CD1400_CAR_CHAN);
1019:
1020: if ((cd_read_reg(cy,
1021: CD1400_MSVR1) & CD1400_MSVR1_RTS) == 0) {
1022: cd_write_reg(cy, CD1400_MSVR1,
1023: CD1400_MSVR1_RTS);
1024: #ifdef CY_DEBUG1
1025: did_something = 1;
1026: #endif
1027: }
1028: }
1029: #endif /* CY_HW_RTS */
1030:
1031: /*
1032: * handle carrier changes
1033: */
1034: s = spltty();
1035: if (ISSET(cy->cy_flags, CYF_CARRIER_CHANGED)) {
1036: int carrier;
1037:
1038: CLR(cy->cy_flags, CYF_CARRIER_CHANGED);
1039: splx(s);
1040:
1041: carrier = ((cy->cy_carrier_stat &
1042: CD1400_MSVR2_CD) != 0);
1043:
1044: #ifdef CY_DEBUG
1045: printf("%s: cy_poll: carrier change "
1046: "(port %d, carrier %d)\n",
1047: sc->sc_dev.dv_xname, port, carrier);
1048: #endif
1049: if (CY_DIALIN(tp->t_dev) &&
1050: !(*linesw[tp->t_line].l_modem)(tp, carrier))
1051: cy_modem_control(cy, TIOCM_DTR, DMBIC);
1052:
1053: #ifdef CY_DEBUG1
1054: did_something = 1;
1055: #endif
1056: } else {
1057: splx(s);
1058: }
1059:
1060: s = spltty();
1061: if (ISSET(cy->cy_flags, CYF_START)) {
1062: CLR(cy->cy_flags, CYF_START);
1063: splx(s);
1064:
1065: (*linesw[tp->t_line].l_start)(tp);
1066:
1067: #ifdef CY_DEBUG1
1068: did_something = 1;
1069: #endif
1070: } else {
1071: splx(s);
1072: }
1073:
1074: /* could move this to even upper level... */
1075: if (cy->cy_fifo_overruns) {
1076: cy->cy_fifo_overruns = 0;
1077: /* doesn't report overrun count,
1078: but shouldn't really matter */
1079: log(LOG_WARNING, "%s: port %d fifo overrun\n",
1080: sc->sc_dev.dv_xname, port);
1081: }
1082: if (cy->cy_ibuf_overruns) {
1083: cy->cy_ibuf_overruns = 0;
1084: log(LOG_WARNING, "%s: port %d ibuf overrun\n",
1085: sc->sc_dev.dv_xname, port);
1086: }
1087: } /* for(port...) */
1088: #ifdef CY_DEBUG1
1089: if (did_something && counter >= 200)
1090: sc->sc_poll_count2++;
1091: #endif
1092:
1093: counter = 0;
1094:
1095: out:
1096: timeout_add(&sc->sc_poll_to, 1);
1097: }
1098:
1099: /*
1100: * hardware interrupt routine
1101: */
1102: int
1103: cy_intr(arg)
1104: void *arg;
1105: {
1106: struct cy_softc *sc = arg;
1107: struct cy_port *cy;
1108: int cy_chip, stat;
1109: int int_serviced = -1;
1110:
1111: /*
1112: * Check interrupt status of each CD1400 chip on this card
1113: * (multiple cards cannot share the same interrupt)
1114: */
1115: for (cy_chip = 0; cy_chip < sc->sc_nr_cd1400s; cy_chip++) {
1116:
1117: stat = cd_read_reg_sc(sc, cy_chip, CD1400_SVRR);
1118: if (stat == 0)
1119: continue;
1120:
1121: if (ISSET(stat, CD1400_SVRR_RXRDY)) {
1122: u_char save_car, save_rir, serv_type;
1123: u_char line_stat, recv_data, n_chars;
1124: u_char *buf_p;
1125:
1126: save_rir = cd_read_reg_sc(sc, cy_chip, CD1400_RIR);
1127: save_car = cd_read_reg_sc(sc, cy_chip, CD1400_CAR);
1128: /* enter rx service */
1129: cd_write_reg_sc(sc, cy_chip, CD1400_CAR, save_rir);
1130:
1131: serv_type = cd_read_reg_sc(sc, cy_chip, CD1400_RIVR);
1132: cy = &sc->sc_ports[serv_type >> 3];
1133:
1134: #ifdef CY_DEBUG1
1135: cy->cy_rx_int_count++;
1136: #endif
1137:
1138: buf_p = cy->cy_ibuf_wr_ptr;
1139:
1140: if (ISSET(serv_type, CD1400_RIVR_EXCEPTION)) {
1141: line_stat = cd_read_reg(cy, CD1400_RDSR);
1142: recv_data = cd_read_reg(cy, CD1400_RDSR);
1143:
1144: if (cy->cy_tty == NULL ||
1145: !ISSET(cy->cy_tty->t_state, TS_ISOPEN))
1146: goto end_rx_serv;
1147:
1148: #ifdef CY_DEBUG
1149: printf("%s port %d recv exception, "
1150: "line_stat 0x%x, char 0x%x\n",
1151: sc->sc_dev.dv_xname, cy->cy_port_num,
1152: line_stat, recv_data);
1153: #endif
1154: if (ISSET(line_stat, CD1400_RDSR_OE))
1155: cy->cy_fifo_overruns++;
1156:
1157: *buf_p++ = line_stat;
1158: *buf_p++ = recv_data;
1159: if (buf_p == cy->cy_ibuf_end)
1160: buf_p = cy->cy_ibuf;
1161:
1162: if (buf_p == cy->cy_ibuf_rd_ptr) {
1163: if (buf_p == cy->cy_ibuf)
1164: buf_p = cy->cy_ibuf_end;
1165: buf_p -= 2;
1166: cy->cy_ibuf_overruns++;
1167: }
1168: sc->sc_events = 1;
1169: } else { /* no exception, received data OK */
1170: n_chars = cd_read_reg(cy, CD1400_RDCR);
1171:
1172: /* If no tty or not open, discard data */
1173: if (cy->cy_tty == NULL ||
1174: !ISSET(cy->cy_tty->t_state, TS_ISOPEN)) {
1175: while (n_chars--)
1176: cd_read_reg(cy, CD1400_RDSR);
1177: goto end_rx_serv;
1178: }
1179:
1180: #ifdef CY_DEBUG
1181: printf("%s port %d receive ok %d chars\n",
1182: sc->sc_dev.dv_xname, cy->cy_port_num,
1183: n_chars);
1184: #endif
1185: while (n_chars--) {
1186: *buf_p++ = 0; /* status: OK */
1187: *buf_p++ = cd_read_reg(cy,
1188: CD1400_RDSR); /* data byte */
1189: if (buf_p == cy->cy_ibuf_end)
1190: buf_p = cy->cy_ibuf;
1191: if (buf_p == cy->cy_ibuf_rd_ptr) {
1192: if (buf_p == cy->cy_ibuf)
1193: buf_p = cy->cy_ibuf_end;
1194: buf_p -= 2;
1195: cy->cy_ibuf_overruns++;
1196: break;
1197: }
1198: }
1199: sc->sc_events = 1;
1200: }
1201:
1202: cy->cy_ibuf_wr_ptr = buf_p;
1203:
1204: #ifndef CY_HW_RTS
1205: /* RTS handshaking for incoming data */
1206: if (ISSET(cy->cy_tty->t_cflag, CRTSCTS)) {
1207: int bf;
1208:
1209: bf = buf_p - cy->cy_ibuf_rd_ptr;
1210: if (bf < 0)
1211: bf += IBUF_SIZE;
1212:
1213: if (bf > (IBUF_SIZE/2)) /* turn RTS off */
1214: cd_write_reg(cy, CD1400_MSVR1, 0);
1215: }
1216: #endif /* CY_HW_RTS */
1217:
1218: end_rx_serv:
1219: /* terminate service context */
1220: cd_write_reg(cy, CD1400_RIR, save_rir & 0x3f);
1221: cd_write_reg(cy, CD1400_CAR, save_car);
1222: int_serviced = 1;
1223: } /* if(rx_service...) */
1224:
1225: if (ISSET(stat, CD1400_SVRR_MDMCH)) {
1226: u_char save_car, save_mir, serv_type, modem_stat;
1227:
1228: save_mir = cd_read_reg_sc(sc, cy_chip, CD1400_MIR);
1229: save_car = cd_read_reg_sc(sc, cy_chip, CD1400_CAR);
1230: /* enter modem service */
1231: cd_write_reg_sc(sc, cy_chip, CD1400_CAR, save_mir);
1232:
1233: serv_type = cd_read_reg_sc(sc, cy_chip, CD1400_MIVR);
1234: cy = &sc->sc_ports[serv_type >> 3];
1235:
1236: #ifdef CY_DEBUG1
1237: cy->cy_modem_int_count++;
1238: #endif
1239:
1240: modem_stat = cd_read_reg(cy, CD1400_MSVR2);
1241:
1242: #ifdef CY_DEBUG
1243: printf("%s port %d modem line change, new stat 0x%x\n",
1244: sc->sc_dev.dv_xname, cy->cy_port_num, modem_stat);
1245: #endif
1246: if (ISSET((cy->cy_carrier_stat ^ modem_stat),
1247: CD1400_MSVR2_CD)) {
1248: SET(cy->cy_flags, CYF_CARRIER_CHANGED);
1249: sc->sc_events = 1;
1250: }
1251:
1252: cy->cy_carrier_stat = modem_stat;
1253:
1254: /* terminate service context */
1255: cd_write_reg(cy, CD1400_MIR, save_mir & 0x3f);
1256: cd_write_reg(cy, CD1400_CAR, save_car);
1257: int_serviced = 1;
1258: } /* if(modem_service...) */
1259:
1260: if (ISSET(stat, CD1400_SVRR_TXRDY)) {
1261: u_char save_car, save_tir, serv_type, count, ch;
1262: struct tty *tp;
1263:
1264: save_tir = cd_read_reg_sc(sc, cy_chip, CD1400_TIR);
1265: save_car = cd_read_reg_sc(sc, cy_chip, CD1400_CAR);
1266: /* enter tx service */
1267: cd_write_reg_sc(sc, cy_chip, CD1400_CAR, save_tir);
1268:
1269: serv_type = cd_read_reg_sc(sc, cy_chip, CD1400_TIVR);
1270: cy = &sc->sc_ports[serv_type >> 3];
1271:
1272: #ifdef CY_DEBUG1
1273: cy->cy_tx_int_count++;
1274: #endif
1275: #ifdef CY_DEBUG
1276: printf("%s port %d tx service\n", sc->sc_dev.dv_xname,
1277: cy->cy_port_num);
1278: #endif
1279:
1280: /* stop transmitting if no tty or CYF_STOP set */
1281: tp = cy->cy_tty;
1282: if (tp == NULL || ISSET(cy->cy_flags, CYF_STOP))
1283: goto txdone;
1284:
1285: count = 0;
1286: if (ISSET(cy->cy_flags, CYF_SEND_NUL)) {
1287: cd_write_reg(cy, CD1400_TDR, 0);
1288: cd_write_reg(cy, CD1400_TDR, 0);
1289: count += 2;
1290: CLR(cy->cy_flags, CYF_SEND_NUL);
1291: }
1292:
1293: if (tp->t_outq.c_cc > 0) {
1294: SET(tp->t_state, TS_BUSY);
1295: while (tp->t_outq.c_cc > 0 &&
1296: count < CD1400_TX_FIFO_SIZE) {
1297: ch = getc(&tp->t_outq);
1298: /* remember to double NUL characters
1299: because embedded transmit commands
1300: are enabled */
1301: if (ch == 0) {
1302: if (count >=
1303: CD1400_TX_FIFO_SIZE-2) {
1304: SET(cy->cy_flags,
1305: CYF_SEND_NUL);
1306: break;
1307: }
1308:
1309: cd_write_reg(cy, CD1400_TDR, ch);
1310: count++;
1311: }
1312:
1313: cd_write_reg(cy, CD1400_TDR, ch);
1314: count++;
1315: }
1316: } else {
1317: /* no data to send -- check if we should
1318: start/stop a break */
1319: /* XXX does this cause too much delay before
1320: breaks? */
1321: if (ISSET(cy->cy_flags, CYF_START_BREAK)) {
1322: cd_write_reg(cy, CD1400_TDR, 0);
1323: cd_write_reg(cy, CD1400_TDR, 0x81);
1324: CLR(cy->cy_flags, CYF_START_BREAK);
1325: }
1326: if (ISSET(cy->cy_flags, CYF_END_BREAK)) {
1327: cd_write_reg(cy, CD1400_TDR, 0);
1328: cd_write_reg(cy, CD1400_TDR, 0x83);
1329: CLR(cy->cy_flags, CYF_END_BREAK);
1330: }
1331: }
1332:
1333: if (tp->t_outq.c_cc == 0) {
1334: txdone:
1335: /*
1336: * No data to send or requested to stop.
1337: * Disable transmit interrupt
1338: */
1339: cd_write_reg(cy, CD1400_SRER,
1340: cd_read_reg(cy, CD1400_SRER)
1341: & ~CD1400_SRER_TXRDY);
1342: CLR(cy->cy_flags, CYF_STOP);
1343: CLR(tp->t_state, TS_BUSY);
1344: }
1345:
1346: if (tp->t_outq.c_cc <= tp->t_lowat) {
1347: SET(cy->cy_flags, CYF_START);
1348: sc->sc_events = 1;
1349: }
1350:
1351: /* terminate service context */
1352: cd_write_reg(cy, CD1400_TIR, save_tir & 0x3f);
1353: cd_write_reg(cy, CD1400_CAR, save_car);
1354: int_serviced = 1;
1355: } /* if(tx_service...) */
1356: } /* for(...all CD1400s on a card) */
1357:
1358: /* ensure an edge for next interrupt */
1359: bus_space_write_1(sc->sc_memt, sc->sc_memh,
1360: CY_CLEAR_INTR<<sc->sc_bustype, 0);
1361: return (int_serviced);
1362: }
1363:
1364: /*
1365: * subroutine to enable CD1400 transmitter
1366: */
1367: void
1368: cy_enable_transmitter(cy)
1369: struct cy_port *cy;
1370: {
1371: int s;
1372: s = spltty();
1373: cd_write_reg(cy, CD1400_CAR, cy->cy_port_num & CD1400_CAR_CHAN);
1374: cd_write_reg(cy, CD1400_SRER, cd_read_reg(cy, CD1400_SRER)
1375: | CD1400_SRER_TXRDY);
1376: splx(s);
1377: }
1378:
1379: /*
1380: * Execute a CD1400 channel command
1381: */
1382: void
1383: cd1400_channel_cmd(cy, cmd)
1384: struct cy_port *cy;
1385: int cmd;
1386: {
1387: u_int waitcnt = 5 * 8 * 1024; /* approx 5 ms */
1388:
1389: #ifdef CY_DEBUG
1390: printf("c1400_channel_cmd cy 0x%x command 0x%x\n", cy, cmd);
1391: #endif
1392:
1393: /* wait until cd1400 is ready to process a new command */
1394: while (cd_read_reg(cy, CD1400_CCR) != 0 && waitcnt-- > 0)
1395: ;
1396:
1397: if (waitcnt == 0)
1398: log(LOG_ERR, "cy: channel command timeout\n");
1399:
1400: cd_write_reg(cy, CD1400_CCR, cmd);
1401: }
1402:
1403: /*
1404: * Compute clock option register and baud rate register values
1405: * for a given speed. Return 0 on success, -1 on failure.
1406: *
1407: * The error between requested and actual speed seems
1408: * to be well within allowed limits (less than 3%)
1409: * with every speed value between 50 and 150000 bps.
1410: */
1411: int
1412: cy_speed(speed_t speed, int *cor, int *bpr, int cy_clock)
1413: {
1414: int c, co, br;
1415:
1416: if (speed < 50 || speed > 150000)
1417: return (-1);
1418:
1419: for (c = 0, co = 8; co <= 2048; co <<= 2, c++) {
1420: br = (cy_clock + (co * speed) / 2) / (co * speed);
1421: if (br < 0x100) {
1422: *bpr = br;
1423: *cor = c;
1424: return (0);
1425: }
1426: }
1427:
1428: return (-1);
1429: }
1430:
1431: #endif /* NCY > 0 */