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