?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branches 'master' and 'suser_to_priv'
[dragonfly.git] / sys / dev / netif / cx / cx.c
blob9249142e63e62b21dd1052174231224bb2feaddb
1 /*
2 * Cronyx-Sigma adapter driver for FreeBSD.
3 * Supports PPP/HDLC protocol in synchronous mode,
4 * and asyncronous channels with full modem control.
5 *
6 * Copyright (C) 1994 Cronyx Ltd.
7 * Author: Serge Vakulenko, <vak@zebub.msk.su>
8 *
9 * This software is distributed with NO WARRANTIES, not even the implied
10 * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Authors grant any other persons or organisations permission to use
13 * or modify this software as long as this message is kept with the software,
14 * all derivative works or modified versions.
15 *
16 * Version 1.9, Wed Oct 4 18:58:15 MSK 1995
17 *
18 * $FreeBSD: src/sys/i386/isa/cx.c,v 1.45.2.1 2001/02/26 04:23:09 jlemon Exp $
19 * $DragonFly: src/sys/dev/netif/cx/cx.c,v 1.20 2006/12/22 23:26:19 swildner Exp $
20 *
21 */
22 #undef DEBUG
23
24 #include "use_cx.h"
25
26 #include <sys/param.h>
27 #include <sys/systm.h>
28 #include <sys/kernel.h>
29 #include <sys/fcntl.h>
30 #include <sys/conf.h>
31 #include <sys/proc.h>
32 #include <sys/priv.h>
33 #include <sys/tty.h>
34 #include <sys/socket.h>
35 #include <sys/thread2.h>
36 #include <net/if.h>
37
38 #if defined(__DragonFly__) || defined(__FreeBSD__)
39 # if defined(__FreeBSD__) && __FreeBSD__ < 2
40 # include <machine/pio.h>
41 # define RB_GETC(q) getc(q)
42 # endif
43 #endif
44 #ifdef __bsdi__
45 # include <sys/ttystats.h>
46 # include <machine/inline.h>
47 # define tsleep(tp,pri,msg,x) ((tp)->t_state |= TS_WOPEN,\
48 ttysleep (tp, (caddr_t)&tp->t_rawq, pri, msg, x))
49 #endif
50 #if defined(__DragonFly__) || !defined (__FreeBSD__) || __FreeBSD__ >= 2
51 # define t_out t_outq
52 # define RB_LEN(q) ((q).c_cc)
53 # define RB_GETC(q) clist_getc(&q)
54 #ifndef TSA_CARR_ON /* FreeBSD 2.x before not long after 2.0.5 */
55 # define TSA_CARR_ON(tp) tp
56 # define TSA_OLOWAT(q) ((caddr_t)&(q)->t_out)
57 #endif
58 #endif
59
60 #include <machine/cronyx.h>
61 #include "cxreg.h"
62
63 /* XXX imported from if_cx.c. */
64 void cxswitch (cx_chan_t *c, cx_soft_opt_t new);
65
66 /* XXX exported. */
67 void cxmint (cx_chan_t *c);
68 int cxrinta (cx_chan_t *c);
69 void cxtinta (cx_chan_t *c);
70 timeout_t cxtimeout;
71 extern struct callout cxtimeout_ch;
72
73 #ifdef DEBUG
74 # define print(s) kprintf s
75 #else
76 # define print(s) {/*void*/}
77 #endif
78
79 #define DMABUFSZ (6*256) /* buffer size */
80 #define BYTE *(unsigned char*)&
81 #define UNIT(u) (minor(u) & 077)
82 #define UNIT_CTL 077
83
84 extern cx_board_t cxboard [NCX]; /* adapter state structures */
85 extern cx_chan_t *cxchan [NCX*NCHAN]; /* unit to channel struct pointer */
86 #if defined(__DragonFly__) || __FreeBSD__ >= 2
87 static struct tty cx_tty [NCX*NCHAN]; /* tty data */
88
89 static d_open_t cxopen;
90 static d_close_t cxclose;
91 static d_ioctl_t cxioctl;
92
93 #define CDEV_MAJOR 42
94 /* Don't make this static, since if_cx.c uses it. */
95 struct dev_ops cx_ops = {
96 { "cx", CDEV_MAJOR, D_TTY | D_KQFILTER },
97 .d_open = cxopen,
98 .d_close = cxclose,
99 .d_read = ttyread,
100 .d_write = ttywrite,
101 .d_ioctl = cxioctl,
102 .d_poll = ttypoll,
103 .d_kqfilter = ttykqfilter
104 };
105 #else
106 struct tty *cx_tty [NCX*NCHAN]; /* tty data */
107 #endif
108
109 static void cxoproc (struct tty *tp);
110 static void cxstop (struct tty *tp, int flag);
111 static int cxparam (struct tty *tp, struct termios *t);
112
113 int
114 cxopen (struct dev_open_args *ap)
115 {
116 cdev_t dev = ap->a_head.a_dev;
117 int unit = UNIT (dev);
118 cx_chan_t *c = cxchan[unit];
119 unsigned short port;
120 struct tty *tp;
121 int error = 0;
122
123 if (unit == UNIT_CTL) {
124 print (("cx: cxopen /dev/cronyx\n"));
125 return (0);
126 }
127 if (unit >= NCX*NCHAN || !c || c->type==T_NONE)
128 return (ENXIO);
129 port = c->chip->port;
130 print (("cx%d.%d: cxopen unit=%d\n", c->board->num, c->num, unit));
131 if (c->mode != M_ASYNC)
132 return (EBUSY);
133 if (! c->ttyp) {
134 #if defined(__DragonFly__) || defined(__FreeBSD__)
135 #if defined(__DragonFly__) || __FreeBSD__ >= 2
136 c->ttyp = &cx_tty[unit];
137 #else
138 c->ttyp = cx_tty[unit] = ttymalloc (cx_tty[unit]);
139 #endif
140 #else
141 MALLOC (cx_tty[unit], struct tty*, sizeof (struct tty), M_DEVBUF, M_WAITOK);
142 bzero (cx_tty[unit], sizeof (*cx_tty[unit]));
143 c->ttyp = cx_tty[unit];
144 #endif
145 c->ttyp->t_oproc = cxoproc;
146 c->ttyp->t_stop = cxstop;
147 c->ttyp->t_param = cxparam;
148 }
149 dev->si_tty = c->ttyp;
150 #ifdef __bsdi__
151 if (! c->ttydev) {
152 MALLOC (c->ttydev, struct ttydevice_tmp*,
153 sizeof (struct ttydevice_tmp), M_DEVBUF, M_WAITOK);
154 bzero (c->ttydev, sizeof (*c->ttydev));
155 strcpy (c->ttydev->tty_name, "cx");
156 c->ttydev->tty_unit = unit;
157 c->ttydev->tty_base = unit;
158 c->ttydev->tty_count = 1;
159 c->ttydev->tty_ttys = c->ttyp;
160 tty_attach (c->ttydev);
161 }
162 #endif
163 tp = c->ttyp;
164 tp->t_dev = dev;
165 if ((tp->t_state & TS_ISOPEN) && (tp->t_state & TS_XCLUDE) &&
166 priv_check_cred(ap->a_cred, PRIV_ROOT, 0))
167 return (EBUSY);
168 if (! (tp->t_state & TS_ISOPEN)) {
169 ttychars (tp);
170 if (tp->t_ispeed == 0) {
171 #ifdef __bsdi__
172 tp->t_termios = deftermios;
173 #else
174 tp->t_iflag = 0;
175 tp->t_oflag = 0;
176 tp->t_lflag = 0;
177 tp->t_cflag = CREAD | CS8 | HUPCL;
178 tp->t_ispeed = c->rxbaud;
179 tp->t_ospeed = c->txbaud;
180 #endif
181 }
182 cxparam (tp, &tp->t_termios);
183 ttsetwater (tp);
184 }
185
186 crit_enter();
187 if (! (tp->t_state & TS_ISOPEN)) {
188 /*
189 * Compute optimal receiver buffer length.
190 * The best choice is rxbaud/400.
191 * Make it even, to avoid byte-wide DMA transfers.
192 * --------------------------
193 * Baud rate Buffer length
194 * --------------------------
195 * 300 4
196 * 1200 4
197 * 9600 24
198 * 19200 48
199 * 38400 96
200 * 57600 192
201 * 115200 288
202 * --------------------------
203 */
204 int rbsz = (c->rxbaud + 800 - 1) / 800 * 2;
205 if (rbsz < 4)
206 rbsz = 4;
207 else if (rbsz > DMABUFSZ)
208 rbsz = DMABUFSZ;
209
210 /* Initialize channel, enable receiver. */
211 cx_cmd (port, CCR_INITCH | CCR_ENRX);
212 cx_cmd (port, CCR_INITCH | CCR_ENRX);
213
214 /* Start receiver. */
215 outw (ARBCNT(port), rbsz);
216 outw (BRBCNT(port), rbsz);
217 outw (ARBSTS(port), BSTS_OWN24);
218 outw (BRBSTS(port), BSTS_OWN24);
219
220 /* Enable interrupts. */
221 outb (IER(port), IER_RXD | IER_RET | IER_TXD | IER_MDM);
222
223 cx_chan_dtr (c, 1);
224 cx_chan_rts (c, 1);
225 }
226 if (cx_chan_cd (c))
227 (*linesw[tp->t_line].l_modem)(tp, 1);
228 if (! (ap->a_oflags & O_NONBLOCK)) {
229 /* Lock the channel against cxconfig while we are
230 * waiting for carrier. */
231 c->sopt.lock = 1;
232 while (!(tp->t_cflag & CLOCAL) && !(tp->t_state & TS_CARR_ON))
233 if ((error = tsleep (TSA_CARR_ON(tp), PCATCH,
234 "cxdcd", 0)))
235 break;
236 c->sopt.lock = 0; /* Unlock the channel. */
237 }
238 print (("cx%d.%d: cxopen done csr=%b\n", c->board->num, c->num,
239 inb(CSR(c->chip->port)), CSRA_BITS));
240 crit_exit();
241 if (error)
242 return (error);
243 #if defined(__DragonFly__) || __FreeBSD__ >= 2
244 error = (*linesw[tp->t_line].l_open) (dev, tp);
245 #else
246 error = (*linesw[tp->t_line].l_open) (dev, tp, 0);
247 #endif
248 return (error);
249 }
250
251 int
252 cxclose (struct dev_close_args *ap)
253 {
254 cdev_t dev = ap->a_head.a_dev;
255 int unit = UNIT (dev);
256 cx_chan_t *c = cxchan[unit];
257 struct tty *tp;
258
259 if (unit == UNIT_CTL)
260 return (0);
261 tp = c->ttyp;
262 (*linesw[tp->t_line].l_close) (tp, ap->a_fflag);
263
264 /* Disable receiver.
265 * Transmitter continues sending the queued data. */
266 crit_enter();
267
268 outb (CAR(c->chip->port), c->num & 3);
269 outb (IER(c->chip->port), IER_TXD | IER_MDM);
270 cx_cmd (c->chip->port, CCR_DISRX);
271
272 /* Clear DTR and RTS. */
273 if ((tp->t_cflag & HUPCL) || ! (tp->t_state & TS_ISOPEN)) {
274 cx_chan_dtr (c, 0);
275 cx_chan_rts (c, 0);
276 }
277
278 /* Stop sending break. */
279 if (c->brk == BRK_SEND) {
280 c->brk = BRK_STOP;
281 if (! (tp->t_state & TS_BUSY))
282 cxoproc (tp);
283 }
284 crit_exit();
285 ttyclose (tp);
286 return (0);
287 }
288
289 int
290 cxioctl (struct dev_ioctl_args *ap)
291 {
292 cdev_t dev = ap->a_head.a_dev;
293 caddr_t data = ap->a_data;
294 int unit = UNIT (dev);
295 cx_chan_t *c, *m;
296 cx_stat_t *st;
297 struct tty *tp;
298 int error;
299 unsigned char msv;
300 struct ifnet *master;
301
302 if (unit == UNIT_CTL) {
303 /* Process an ioctl request on /dev/cronyx */
304 cx_options_t *o = (cx_options_t*) data;
305
306 if (o->board >= NCX || o->channel >= NCHAN)
307 return (EINVAL);
308 c = &cxboard[o->board].chan[o->channel];
309 if (c->type == T_NONE)
310 return (ENXIO);
311 switch (ap->a_cmd) {
312 default:
313 return (EINVAL);
314
315 case CXIOCSETMODE:
316 print (("cx%d.%d: CXIOCSETMODE\n", o->board, o->channel));
317 if (c->type == T_NONE)
318 return (EINVAL);
319 if (c->type == T_ASYNC && o->mode != M_ASYNC)
320 return (EINVAL);
321 if (o->mode == M_ASYNC)
322 switch (c->type) {
323 case T_SYNC_RS232:
324 case T_SYNC_V35:
325 case T_SYNC_RS449:
326 return (EINVAL);
327 }
328 /* Somebody is waiting for carrier? */
329 if (c->sopt.lock)
330 return (EBUSY);
331 /* /dev/ttyXX is already opened by someone? */
332 if (c->mode == M_ASYNC && c->ttyp &&
333 (c->ttyp->t_state & TS_ISOPEN))
334 return (EBUSY);
335 /* Network interface is up? */
336 if (c->mode != M_ASYNC && (c->ifp->if_flags & IFF_UP))
337 return (EBUSY);
338
339 /* Find the master interface. */
340 master = *o->master ? ifunit (o->master) : c->ifp;
341 if (! master)
342 return (EINVAL);
343 m = cxchan[master->if_dunit];
344
345 /* Leave the previous master queue. */
346 if (c->master != c->ifp) {
347 cx_chan_t *p = cxchan[c->master->if_dunit];
348
349 for (; p; p=p->slaveq)
350 if (p->slaveq == c)
351 p->slaveq = c->slaveq;
352 }
353
354 /* Set up new master. */
355 c->master = master;
356 c->slaveq = 0;
357
358 /* Join the new master queue. */
359 if (c->master != c->ifp) {
360 c->slaveq = m->slaveq;
361 m->slaveq = c;
362 }
363
364 c->mode = o->mode;
365 c->rxbaud = o->rxbaud;
366 c->txbaud = o->txbaud;
367 c->opt = o->opt;
368 c->aopt = o->aopt;
369 c->hopt = o->hopt;
370 c->bopt = o->bopt;
371 c->xopt = o->xopt;
372 switch (c->num) {
373 case 0: c->board->if0type = o->iftype; break;
374 case 8: c->board->if8type = o->iftype; break;
375 }
376 crit_enter();
377 cxswitch (c, o->sopt);
378 cx_setup_chan (c);
379 outb (IER(c->chip->port), 0);
380 crit_exit();
381 break;
382
383 case CXIOCGETSTAT:
384 st = (cx_stat_t*) data;
385 st->rintr = c->stat->rintr;
386 st->tintr = c->stat->tintr;
387 st->mintr = c->stat->mintr;
388 st->ibytes = c->stat->ibytes;
389 st->ipkts = c->stat->ipkts;
390 st->ierrs = c->stat->ierrs;
391 st->obytes = c->stat->obytes;
392 st->opkts = c->stat->opkts;
393 st->oerrs = c->stat->oerrs;
394 break;
395
396 case CXIOCGETMODE:
397 print (("cx%d.%d: CXIOCGETMODE\n", o->board, o->channel));
398 o->type = c->type;
399 o->mode = c->mode;
400 o->rxbaud = c->rxbaud;
401 o->txbaud = c->txbaud;
402 o->opt = c->opt;
403 o->aopt = c->aopt;
404 o->hopt = c->hopt;
405 o->bopt = c->bopt;
406 o->xopt = c->xopt;
407 o->sopt = c->sopt;
408 switch (c->num) {
409 case 0: o->iftype = c->board->if0type; break;
410 case 8: o->iftype = c->board->if8type; break;
411 }
412 if (c->master != c->ifp)
413 strlcpy(o->master, c->master->if_xname, sizeof(o->master));
414 else
415 *o->master = 0;
416 break;
417 }
418 return (0);
419 }
420
421 c = cxchan[unit];
422 tp = c->ttyp;
423 if (! tp)
424 return (EINVAL);
425 error = (*linesw[tp->t_line].l_ioctl) (tp, ap->a_cmd, data,
426 ap->a_fflag, ap->a_cred);
427 if (error != ENOIOCTL)
428 return (error);
429 error = ttioctl (tp, ap->a_cmd, data, ap->a_fflag);
430 if (error != ENOIOCTL)
431 return (error);
432
433 crit_enter();
434
435 switch (ap->a_cmd) {
436 default:
437 crit_exit();
438 return (ENOTTY);
439 case TIOCSBRK: /* Start sending line break */
440 c->brk = BRK_SEND;
441 if (! (tp->t_state & TS_BUSY))
442 cxoproc (tp);
443 break;
444 case TIOCCBRK: /* Stop sending line break */
445 c->brk = BRK_STOP;
446 if (! (tp->t_state & TS_BUSY))
447 cxoproc (tp);
448 break;
449 case TIOCSDTR: /* Set DTR */
450 cx_chan_dtr (c, 1);
451 break;
452 case TIOCCDTR: /* Clear DTR */
453 cx_chan_dtr (c, 0);
454 break;
455 case TIOCMSET: /* Set DTR/RTS */
456 cx_chan_dtr (c, (*(int*)data & TIOCM_DTR) ? 1 : 0);
457 cx_chan_rts (c, (*(int*)data & TIOCM_RTS) ? 1 : 0);
458 break;
459 case TIOCMBIS: /* Add DTR/RTS */
460 if (*(int*)data & TIOCM_DTR) cx_chan_dtr (c, 1);
461 if (*(int*)data & TIOCM_RTS) cx_chan_rts (c, 1);
462 break;
463 case TIOCMBIC: /* Clear DTR/RTS */
464 if (*(int*)data & TIOCM_DTR) cx_chan_dtr (c, 0);
465 if (*(int*)data & TIOCM_RTS) cx_chan_rts (c, 0);
466 break;
467 case TIOCMGET: /* Get modem status */
468 msv = inb (MSVR(c->chip->port));
469 *(int*)data = TIOCM_LE; /* always enabled while open */
470 if (msv & MSV_DSR) *(int*)data |= TIOCM_DSR;
471 if (msv & MSV_CTS) *(int*)data |= TIOCM_CTS;
472 if (msv & MSV_CD) *(int*)data |= TIOCM_CD;
473 if (c->dtr) *(int*)data |= TIOCM_DTR;
474 if (c->rts) *(int*)data |= TIOCM_RTS;
475 break;
476 }
477
478 crit_exit();
479 return (0);
480 }
481
482 /*
483 * Fill transmitter buffer with data.
484 */
485 static void
486 cxout (cx_chan_t *c, char b)
487 {
488 unsigned char *buf, *p, sym;
489 unsigned short port = c->chip->port, len = 0, cnt_port, sts_port;
490 struct tty *tp = c->ttyp;
491
492 if (! tp)
493 return;
494
495 /* Choose the buffer. */
496 if (b == 'A') {
497 buf = c->atbuf;
498 cnt_port = ATBCNT(port);
499 sts_port = ATBSTS(port);
500 } else {
501 buf = c->btbuf;
502 cnt_port = BTBCNT(port);
503 sts_port = BTBSTS(port);
504 }
505
506 /* Is it busy? */
507 if (inb (sts_port) & BSTS_OWN24) {
508 tp->t_state |= TS_BUSY;
509 return;
510 }
511
512 switch (c->brk) {
513 case BRK_SEND:
514 *buf++ = 0; /* extended transmit command */
515 *buf++ = 0x81; /* send break */
516 *buf++ = 0; /* extended transmit command */
517 *buf++ = 0x82; /* insert delay */
518 *buf++ = 250; /* 1/4 of second */
519 *buf++ = 0; /* extended transmit command */
520 *buf++ = 0x82; /* insert delay */
521 *buf++ = 250; /* + 1/4 of second */
522 len = 8;
523 c->brk = BRK_IDLE;
524 break;
525 case BRK_STOP:
526 *buf++ = 0; /* extended transmit command */
527 *buf++ = 0x83; /* stop break */
528 len = 2;
529 c->brk = BRK_IDLE;
530 break;
531 case BRK_IDLE:
532 p = buf;
533 if (tp->t_iflag & IXOFF)
534 while (RB_LEN (tp->t_out) && p<buf+DMABUFSZ-1) {
535 sym = RB_GETC (tp->t_out);
536 /* Send XON/XOFF out of band. */
537 if (sym == tp->t_cc[VSTOP]) {
538 outb (STCR(port), STC_SNDSPC|STC_SSPC_2);
539 continue;
540 }
541 if (sym == tp->t_cc[VSTART]) {
542 outb (STCR(port), STC_SNDSPC|STC_SSPC_1);
543 continue;
544 }
545 /* Duplicate NULLs in ETC mode. */
546 if (! sym)
547 *p++ = 0;
548 *p++ = sym;
549 }
550 else
551 while (RB_LEN (tp->t_out) && p<buf+DMABUFSZ-1) {
552 sym = RB_GETC (tp->t_out);
553 /* Duplicate NULLs in ETC mode. */
554 if (! sym)
555 *p++ = 0;
556 *p++ = sym;
557 }
558 len = p - buf;
559 break;
560 }
561
562 /* Start transmitter. */
563 if (len) {
564 outw (cnt_port, len);
565 outb (sts_port, BSTS_INTR | BSTS_OWN24);
566 c->stat->obytes += len;
567 tp->t_state |= TS_BUSY;
568 print (("cx%d.%d: out %d bytes to %c\n",
569 c->board->num, c->num, len, b));
570 }
571 }
572
573 void
574 cxoproc (struct tty *tp)
575 {
576 int unit = UNIT (tp->t_dev);
577 cx_chan_t *c = cxchan[unit];
578 unsigned short port = c->chip->port;
579
580 crit_enter();
581
582 /* Set current channel number */
583 outb (CAR(port), c->num & 3);
584
585 if (! (tp->t_state & (TS_TIMEOUT | TS_TTSTOP))) {
586 /* Start transmitter. */
587 if (! (inb (CSR(port)) & CSRA_TXEN))
588 cx_cmd (port, CCR_ENTX);
589
590 /* Determine the buffer order. */
591 if (inb (DMABSTS(port)) & DMABSTS_NTBUF) {
592 cxout (c, 'B');
593 cxout (c, 'A');
594 } else {
595 cxout (c, 'A');
596 cxout (c, 'B');
597 }
598 }
599 #ifndef TS_ASLEEP /* FreeBSD some time after 2.0.5 */
600 ttwwakeup(tp);
601 #else
602 if (RB_LEN (tp->t_out) <= tp->t_lowat) {
603 if (tp->t_state & TS_ASLEEP) {
604 tp->t_state &= ~TS_ASLEEP;
605 wakeup(TSA_OLOWAT(tp));
606 }
607 selwakeup(&tp->t_wsel);
608 }
609 #endif
610 crit_exit();
611 }
612
613 static int
614 cxparam (struct tty *tp, struct termios *t)
615 {
616 int unit = UNIT (tp->t_dev);
617 cx_chan_t *c = cxchan[unit];
618 unsigned short port = c->chip->port;
619 int clock, period;
620 cx_cor1_async_t cor1;
621
622 if (t->c_ospeed == 0) {
623 /* Clear DTR and RTS. */
624 crit_enter();
625 cx_chan_dtr (c, 0);
626 cx_chan_rts (c, 0);
627 crit_exit();
628 print (("cx%d.%d: cxparam (hangup)\n", c->board->num, c->num));
629 return (0);
630 }
631 print (("cx%d.%d: cxparam\n", c->board->num, c->num));
632
633 /* Check requested parameters. */
634 if (t->c_ospeed < 300 || t->c_ospeed > 256*1024)
635 return(EINVAL);
636 if (t->c_ispeed && (t->c_ispeed < 300 || t->c_ispeed > 256*1024))
637 return(EINVAL);
638
639 #ifdef __bsdi__
640 /* CLOCAL flag set -- wakeup everybody who waits for CD. */
641 /* FreeBSD does this themselves. */
642 if (! (tp->t_cflag & CLOCAL) && (t->c_cflag & CLOCAL))
643 wakeup ((caddr_t) &tp->t_rawq);
644 #endif
645 /* And copy them to tty and channel structures. */
646 c->rxbaud = tp->t_ispeed = t->c_ispeed;
647 c->txbaud = tp->t_ospeed = t->c_ospeed;
648 tp->t_cflag = t->c_cflag;
649
650 /* Set character length and parity mode. */
651 BYTE cor1 = 0;
652 switch (t->c_cflag & CSIZE) {
653 default:
654 case CS8: cor1.charlen = 7; break;
655 case CS7: cor1.charlen = 6; break;
656 case CS6: cor1.charlen = 5; break;
657 case CS5: cor1.charlen = 4; break;
658 }
659 if (t->c_cflag & PARENB) {
660 cor1.parmode = PARM_NORMAL;
661 cor1.ignpar = 0;
662 cor1.parity = (t->c_cflag & PARODD) ? PAR_ODD : PAR_EVEN;
663 } else {
664 cor1.parmode = PARM_NOPAR;
665 cor1.ignpar = 1;
666 }
667
668 /* Enable/disable hardware CTS. */
669 c->aopt.cor2.ctsae = (t->c_cflag & CRTSCTS) ? 1 : 0;
670 /* Handle DSR as CTS. */
671 c->aopt.cor2.dsrae = (t->c_cflag & CRTSCTS) ? 1 : 0;
672 /* Enable extended transmit command mode.
673 * Unfortunately, there is no other method for sending break. */
674 c->aopt.cor2.etc = 1;
675 /* Enable/disable hardware XON/XOFF. */
676 c->aopt.cor2.ixon = (t->c_iflag & IXON) ? 1 : 0;
677 c->aopt.cor2.ixany = (t->c_iflag & IXANY) ? 1 : 0;
678
679 /* Set the number of stop bits. */
680 if (t->c_cflag & CSTOPB)
681 c->aopt.cor3.stopb = STOPB_2;
682 else
683 c->aopt.cor3.stopb = STOPB_1;
684 /* Disable/enable passing XON/XOFF chars to the host. */
685 c->aopt.cor3.scde = (t->c_iflag & IXON) ? 1 : 0;
686 c->aopt.cor3.flowct = (t->c_iflag & IXON) ? FLOWCC_NOTPASS : FLOWCC_PASS;
687
688 c->aopt.schr1 = t->c_cc[VSTART]; /* XON */
689 c->aopt.schr2 = t->c_cc[VSTOP]; /* XOFF */
690
691 /* Set current channel number. */
692 crit_enter();
693 outb (CAR(port), c->num & 3);
694
695 /* Set up receiver clock values. */
696 cx_clock (c->chip->oscfreq, c->rxbaud, &clock, &period);
697 c->opt.rcor.clk = clock;
698 outb (RCOR(port), BYTE c->opt.rcor);
699 outb (RBPR(port), period);
700
701 /* Set up transmitter clock values. */
702 cx_clock (c->chip->oscfreq, c->txbaud, &clock, &period);
703 c->opt.tcor.clk = clock;
704 c->opt.tcor.ext1x = 0;
705 outb (TCOR(port), BYTE c->opt.tcor);
706 outb (TBPR(port), period);
707
708 outb (COR2(port), BYTE c->aopt.cor2);
709 outb (COR3(port), BYTE c->aopt.cor3);
710 outb (SCHR1(port), c->aopt.schr1);
711 outb (SCHR2(port), c->aopt.schr2);
712
713 if (BYTE c->aopt.cor1 != BYTE cor1) {
714 BYTE c->aopt.cor1 = BYTE cor1;
715 outb (COR1(port), BYTE c->aopt.cor1);
716 /* Any change to COR1 require reinitialization. */
717 /* Unfortunately, it may cause transmitter glitches... */
718 cx_cmd (port, CCR_INITCH);
719 }
720
721 crit_exit();
722 return (0);
723 }
724
725 /*
726 * Stop output on a line
727 */
728 void
729 cxstop (struct tty *tp, int flag)
730 {
731 crit_enter();
732
733 if (tp->t_state & TS_BUSY) {
734 cx_chan_t *c = cxchan[UNIT(tp->t_dev)];
735 unsigned short port = c->chip->port;
736
737 print (("cx%d.%d: cxstop\n", c->board->num, c->num));
738
739 /* Set current channel number */
740 outb (CAR(port), c->num & 3);
741
742 /* Stop transmitter */
743 cx_cmd (port, CCR_DISTX);
744 }
745
746 crit_exit();
747 }
748
749 /*
750 * Handle receive interrupts, including receive errors and
751 * receive timeout interrupt.
752 */
753 int
754 cxrinta (cx_chan_t *c)
755 {
756 unsigned short port = c->chip->port;
757 unsigned short len = 0, risr = inw (RISR(port)), reoir = 0;
758 struct tty *tp = c->ttyp;
759
760 /* Compute optimal receiver buffer length. */
761 int rbsz = (c->rxbaud + 800 - 1) / 800 * 2;
762 if (rbsz < 4)
763 rbsz = 4;
764 else if (rbsz > DMABUFSZ)
765 rbsz = DMABUFSZ;
766
767 if (risr & RISA_TIMEOUT) {
768 unsigned long rcbadr = (unsigned short) inw (RCBADRL(port)) |
769 (long) inw (RCBADRU(port)) << 16;
770 unsigned char *buf = 0;
771 unsigned short cnt_port = 0, sts_port = 0;
772 if (rcbadr >= c->brphys && rcbadr < c->brphys+DMABUFSZ) {
773 buf = c->brbuf;
774 len = rcbadr - c->brphys;
775 cnt_port = BRBCNT(port);
776 sts_port = BRBSTS(port);
777 } else if (rcbadr >= c->arphys && rcbadr < c->arphys+DMABUFSZ) {
778 buf = c->arbuf;
779 len = rcbadr - c->arphys;
780 cnt_port = ARBCNT(port);
781 sts_port = ARBSTS(port);
782 } else
783 kprintf ("cx%d.%d: timeout: invalid buffer address\n",
784 c->board->num, c->num);
785
786 if (len) {
787 print (("cx%d.%d: async receive timeout (%d bytes), risr=%b, arbsts=%b, brbsts=%b\n",
788 c->board->num, c->num, len, risr, RISA_BITS,
789 inb (ARBSTS(port)), BSTS_BITS, inb (BRBSTS(port)), BSTS_BITS));
790 c->stat->ibytes += len;
791 if (tp && (tp->t_state & TS_ISOPEN)) {
792 int i;
793 int (*rint)(int, struct tty *) =
794 linesw[tp->t_line].l_rint;
795
796 for (i=0; i<len; ++i)
797 (*rint) (buf[i], tp);
798 }
799
800 /* Restart receiver. */
801 outw (cnt_port, rbsz);
802 outb (sts_port, BSTS_OWN24);
803 }
804 return (REOI_TERMBUFF);
805 }
806
807 print (("cx%d.%d: async receive interrupt, risr=%b, arbsts=%b, brbsts=%b\n",
808 c->board->num, c->num, risr, RISA_BITS,
809 inb (ARBSTS(port)), BSTS_BITS, inb (BRBSTS(port)), BSTS_BITS));
810
811 if (risr & RIS_BUSERR) {
812 kprintf ("cx%d.%d: receive bus error\n", c->board->num, c->num);
813 ++c->stat->ierrs;
814 }
815 if (risr & (RIS_OVERRUN | RISA_PARERR | RISA_FRERR | RISA_BREAK)) {
816 int err = 0;
817
818 if (risr & RISA_PARERR)
819 err |= TTY_PE;
820 if (risr & RISA_FRERR)
821 err |= TTY_FE;
822 #ifdef TTY_OE
823 if (risr & RIS_OVERRUN)
824 err |= TTY_OE;
825 #endif
826 #ifdef TTY_BI
827 if (risr & RISA_BREAK)
828 err |= TTY_BI;
829 #endif
830 print (("cx%d.%d: receive error %x\n", c->board->num, c->num, err));
831 if (tp && (tp->t_state & TS_ISOPEN))
832 (*linesw[tp->t_line].l_rint) (err, tp);
833 ++c->stat->ierrs;
834 }
835
836 /* Discard exception characters. */
837 if ((risr & RISA_SCMASK) && tp && (tp->t_iflag & IXON))
838 reoir |= REOI_DISCEXC;
839
840 /* Handle received data. */
841 if ((risr & RIS_EOBUF) && tp && (tp->t_state & TS_ISOPEN)) {
842 int (*rint)(int, struct tty *) = linesw[tp->t_line].l_rint;
843 unsigned char *buf;
844 int i;
845
846 len = (risr & RIS_BB) ? inw(BRBCNT(port)) : inw(ARBCNT(port));
847
848 print (("cx%d.%d: async: %d bytes received\n",
849 c->board->num, c->num, len));
850 c->stat->ibytes += len;
851
852 buf = (risr & RIS_BB) ? c->brbuf : c->arbuf;
853 for (i=0; i<len; ++i)
854 (*rint) (buf[i], tp);
855 }
856
857 /* Restart receiver. */
858 if (! (inb (ARBSTS(port)) & BSTS_OWN24)) {
859 outw (ARBCNT(port), rbsz);
860 outb (ARBSTS(port), BSTS_OWN24);
861 }
862 if (! (inb (BRBSTS(port)) & BSTS_OWN24)) {
863 outw (BRBCNT(port), rbsz);
864 outb (BRBSTS(port), BSTS_OWN24);
865 }
866 return (reoir);
867 }
868
869 /*
870 * Handle transmit interrupt.
871 */
872 void cxtinta (cx_chan_t *c)
873 {
874 struct tty *tp = c->ttyp;
875 unsigned short port = c->chip->port;
876 unsigned char tisr = inb (TISR(port));
877
878 print (("cx%d.%d: async transmit interrupt, tisr=%b, atbsts=%b, btbsts=%b\n",
879 c->board->num, c->num, tisr, TIS_BITS,
880 inb (ATBSTS(port)), BSTS_BITS, inb (BTBSTS(port)), BSTS_BITS));
881
882 if (tisr & TIS_BUSERR) {
883 kprintf ("cx%d.%d: transmit bus error\n",
884 c->board->num, c->num);
885 ++c->stat->oerrs;
886 } else if (tisr & TIS_UNDERRUN) {
887 kprintf ("cx%d.%d: transmit underrun error\n",
888 c->board->num, c->num);
889 ++c->stat->oerrs;
890 }
891 if (tp) {
892 tp->t_state &= ~(TS_BUSY | TS_FLUSH);
893 if (tp->t_line)
894 (*linesw[tp->t_line].l_start) (tp);
895 else
896 cxoproc (tp);
897 }
898 }
899
900 /*
901 * Handle modem interrupt.
902 */
903 void
904 cxmint (cx_chan_t *c)
905 {
906 unsigned short port = c->chip->port;
907 unsigned char misr = inb (MISR(port));
908 unsigned char msvr = inb (MSVR(port));
909 struct tty *tp = c->ttyp;
910
911 if (c->mode != M_ASYNC) {
912 kprintf ("cx%d.%d: unexpected modem interrupt, misr=%b, msvr=%b\n",
913 c->board->num, c->num, misr, MIS_BITS, msvr, MSV_BITS);
914 return;
915 }
916 print (("cx%d.%d: modem interrupt, misr=%b, msvr=%b\n",
917 c->board->num, c->num, misr, MIS_BITS, msvr, MSV_BITS));
918
919 /* Ignore DSR events. */
920 /* Ignore RTC/CTS events, handled by hardware. */
921 /* Handle carrier detect/loss. */
922 if (tp && (misr & MIS_CCD))
923 (*linesw[tp->t_line].l_modem) (tp, (msvr & MSV_CD) != 0);
924 }
925
926 /*
927 * Recover after lost transmit interrupts.
928 */
929 void
930 cxtimeout (void *a)
931 {
932 cx_board_t *b;
933 cx_chan_t *c;
934 struct tty *tp;
935
936 for (b = cxboard; b < cxboard + NCX; ++b) {
937 for (c = b->chan; c < b->chan + NCHAN; ++c) {
938 tp = c->ttyp;
939 if (c->type == T_NONE || c->mode != M_ASYNC || !tp)
940 continue;
941 crit_enter();
942 if (tp->t_state & TS_BUSY) {
943 tp->t_state &= ~TS_BUSY;
944 if (tp->t_line)
945 (*linesw[tp->t_line].l_start) (tp);
946 else
947 cxoproc (tp);
948 }
949 crit_exit();
950 }
951 }
952 callout_reset (&cxtimeout_ch, hz * 5, cxtimeout, NULL);
953 }
954
955
956 #if defined(__DragonFly__) || (defined(__FreeBSD__) && (__FreeBSD__ > 1 ))
957
958 static
959 void
960 cx_drvinit(void *unused)
961 {
962 }
963
964 SYSINIT(cxdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,cx_drvinit,NULL)
965
966 #endif
DragonFly BSD