Merge from vendor branch GCC:
[dragonfly.git] / sys / dev / misc / dcons / dcons_os.c
1 /*
2  * Copyright (C) 2003,2004
3  *      Hidetoshi Shimokawa. All rights reserved.
4  * 
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *
16  *      This product includes software developed by Hidetoshi Shimokawa.
17  *
18  * 4. Neither the name of the author nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  * 
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $FreeBSD: src/sys/dev/dcons/dcons_os.c,v 1.4 2004/10/24 12:41:04 simokawa Exp $
35  * $DragonFly: src/sys/dev/misc/dcons/dcons_os.c,v 1.13 2007/08/07 13:14:11 hasso Exp $
36  */
37
38 #include <sys/param.h>
39 #if __FreeBSD_version >= 502122
40 #include <sys/kdb.h>
41 #include <gdb/gdb.h>
42 #endif
43 #include <sys/kernel.h>
44 #include <sys/module.h>
45 #include <sys/systm.h>
46 #include <sys/types.h>
47 #include <sys/conf.h>
48 #include <sys/cons.h>
49 #include <sys/consio.h>
50 #include <sys/tty.h>
51 #include <sys/malloc.h>
52 #include <sys/proc.h>
53 #include <sys/thread2.h>
54 #include <sys/ucred.h>
55 #include <sys/bus.h>
56
57 #include "dcons.h"
58 #include "dcons_os.h"
59
60 #include <ddb/ddb.h>
61 #include <sys/reboot.h>
62
63 #include <sys/sysctl.h>
64
65 #include <vm/vm.h>
66 #include <vm/vm_param.h>
67 #include <vm/pmap.h>
68
69 #include "opt_ddb.h"
70 #include "opt_comconsole.h"
71 #include "opt_dcons.h"
72
73 #ifndef DCONS_POLL_HZ
74 #define DCONS_POLL_HZ   100
75 #endif
76
77 #ifndef DCONS_BUF_SIZE
78 #define DCONS_BUF_SIZE (16*1024)
79 #endif
80
81 #ifndef DCONS_FORCE_CONSOLE
82 #define DCONS_FORCE_CONSOLE     0       /* Mostly for FreeBSD-4/DragonFly */
83 #endif
84
85 #ifndef DCONS_FORCE_GDB
86 #define DCONS_FORCE_GDB 1
87 #endif
88
89 #define CDEV_MAJOR      184
90
91 static d_open_t         dcons_open;
92 static d_close_t        dcons_close;
93 static d_ioctl_t        dcons_ioctl;
94
95 static struct dev_ops dcons_ops = {
96         { "dcons", CDEV_MAJOR, D_TTY },
97         .d_open =       dcons_open,
98         .d_close =      dcons_close,
99         .d_read =       ttyread,
100         .d_write =      ttywrite,
101         .d_ioctl =      dcons_ioctl,
102         .d_poll =       ttypoll,
103 };
104
105 #ifndef KLD_MODULE
106 static char bssbuf[DCONS_BUF_SIZE];     /* buf in bss */
107 #endif
108
109 /* global data */
110 static struct dcons_global dg;
111 struct dcons_global *dcons_conf;
112 static int poll_hz = DCONS_POLL_HZ;
113
114 static struct dcons_softc sc[DCONS_NPORT];
115
116 SYSCTL_NODE(_kern, OID_AUTO, dcons, CTLFLAG_RD, 0, "Dumb Console");
117 SYSCTL_INT(_kern_dcons, OID_AUTO, poll_hz, CTLFLAG_RW, &poll_hz, 0,
118                                 "dcons polling rate");
119
120 static int drv_init = 0;
121 static struct callout dcons_callout;
122 struct dcons_buf *dcons_buf;            /* for local dconschat */
123
124 #ifdef __DragonFly__
125 #define DEV     cdev_t
126 #define THREAD  d_thread_t
127 #elif __FreeBSD_version < 500000
128 #define DEV     cdev_t
129 #define THREAD  struct proc
130 #else
131 #define DEV     struct cdev *
132 #define THREAD  struct thread
133 #endif
134
135
136 static void     dcons_tty_start(struct tty *);
137 static int      dcons_tty_param(struct tty *, struct termios *);
138 static void     dcons_timeout(void *);
139 static int      dcons_drv_init(int);
140
141 static cn_probe_t       dcons_cnprobe;
142 static cn_init_t        dcons_cninit;
143 static cn_init_fini_t   dcons_cninit_fini;
144 static cn_getc_t        dcons_cngetc;
145 static cn_checkc_t      dcons_cncheckc;
146 static cn_putc_t        dcons_cnputc;
147
148 CONS_DRIVER(dcons, dcons_cnprobe, dcons_cninit, dcons_cninit_fini,
149             NULL, dcons_cngetc, dcons_cncheckc, dcons_cnputc, NULL);
150
151 #if __FreeBSD_version >= 502122
152 static gdb_probe_f dcons_dbg_probe;
153 static gdb_init_f dcons_dbg_init;
154 static gdb_term_f dcons_dbg_term;
155 static gdb_getc_f dcons_dbg_getc;
156 static gdb_checkc_f dcons_dbg_checkc;
157 static gdb_putc_f dcons_dbg_putc;
158
159 GDB_DBGPORT(dcons, dcons_dbg_probe, dcons_dbg_init, dcons_dbg_term,
160     dcons_dbg_checkc, dcons_dbg_getc, dcons_dbg_putc);
161
162 extern struct gdb_dbgport *gdb_cur;
163 #endif
164
165 #if (KDB || DDB) && ALT_BREAK_TO_DEBUGGER
166 static int
167 dcons_check_break(struct dcons_softc *dc, int c)
168 {
169         if (c < 0)
170                 return (c);
171
172 #if __FreeBSD_version >= 502122
173         if (kdb_alt_break(c, &dc->brk_state)) {
174                 if ((dc->flags & DC_GDB) != 0) {
175                         if (gdb_cur == &dcons_gdb_dbgport) {
176                                 kdb_dbbe_select("gdb");
177                                 breakpoint();
178                         }
179                 } else
180                         breakpoint();
181         }
182 #else
183         switch (dc->brk_state) {
184         case STATE1:
185                 if (c == KEY_TILDE)
186                         dc->brk_state = STATE2;
187                 else
188                         dc->brk_state = STATE0;
189                 break;
190         case STATE2:
191                 dc->brk_state = STATE0;
192                 if (c == KEY_CTRLB) {
193 #if DCONS_FORCE_GDB
194                         if (dc->flags & DC_GDB)
195                                 boothowto |= RB_GDB;
196 #endif
197                         breakpoint();
198                 }
199         }
200         if (c == KEY_CR)
201                 dc->brk_state = STATE1;
202 #endif
203         return (c);
204 }
205 #else
206 #define dcons_check_break(dc, c)        (c)
207 #endif
208
209 static int
210 dcons_os_checkc(struct dcons_softc *dc)
211 {
212         int c;
213
214         if (dg.dma_tag != NULL)
215                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTREAD);
216   
217         c = dcons_check_break(dc, dcons_checkc(dc));
218
219         if (dg.dma_tag != NULL)
220                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREREAD);
221
222         return (c);
223 }
224
225 static int
226 dcons_os_getc(struct dcons_softc *dc)
227 {
228         int c;
229
230         while ((c = dcons_os_checkc(dc)) == -1);
231
232         return (c & 0xff);
233
234
235 static void
236 dcons_os_putc(struct dcons_softc *dc, int c)
237 {
238         if (dg.dma_tag != NULL)
239                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTWRITE);
240
241         dcons_putc(dc, c);
242
243         if (dg.dma_tag != NULL)
244                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREWRITE);
245 }
246 static int
247 dcons_open(struct dev_open_args *ap)
248 {
249         cdev_t dev = ap->a_head.a_dev;
250         struct tty *tp;
251         int unit, error;
252
253         unit = minor(dev);
254         if (unit != 0)
255                 return (ENXIO);
256
257         tp = dev->si_tty = ttymalloc(dev->si_tty);
258         tp->t_oproc = dcons_tty_start;
259         tp->t_param = dcons_tty_param;
260         tp->t_stop = nottystop;
261         tp->t_dev = dev;
262
263         error = 0;
264
265         crit_enter();
266         if ((tp->t_state & TS_ISOPEN) == 0) {
267                 tp->t_state |= TS_CARR_ON;
268                 ttychars(tp);
269                 tp->t_iflag = TTYDEF_IFLAG;
270                 tp->t_oflag = TTYDEF_OFLAG;
271                 tp->t_cflag = TTYDEF_CFLAG|CLOCAL;
272                 tp->t_lflag = TTYDEF_LFLAG;
273                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
274                 ttsetwater(tp);
275         } else if ((tp->t_state & TS_XCLUDE) && suser_cred(ap->a_cred, 0)) {
276                 crit_exit();
277                 return (EBUSY);
278         }
279         crit_exit();
280
281 #if __FreeBSD_version < 502113
282         error = (*linesw[tp->t_line].l_open)(dev, tp);
283 #else
284         error = ttyld_open(tp, dev);
285 #endif
286
287         return (error);
288 }
289
290 static int
291 dcons_close(struct dev_close_args *ap)
292 {
293         cdev_t dev = ap->a_head.a_dev;
294         int     unit;
295         struct  tty *tp;
296
297         unit = minor(dev);
298         if (unit != 0)
299                 return (ENXIO);
300
301         tp = dev->si_tty;
302         if (tp->t_state & TS_ISOPEN) {
303                 (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
304                 ttyclose(tp);
305         }
306
307         return (0);
308 }
309
310 static int
311 dcons_ioctl(struct dev_ioctl_args *ap)
312 {
313         cdev_t dev = ap->a_head.a_dev;
314         int     unit;
315         struct  tty *tp;
316         int     error;
317
318         unit = minor(dev);
319         if (unit != 0)
320                 return (ENXIO);
321
322         tp = dev->si_tty;
323         error = (*linesw[tp->t_line].l_ioctl)(tp, ap->a_cmd, ap->a_data, ap->a_fflag, ap->a_cred);
324         if (error != ENOIOCTL)
325                 return (error);
326
327         error = ttioctl(tp, ap->a_cmd, ap->a_data, ap->a_fflag);
328         if (error != ENOIOCTL)
329                 return (error);
330
331         return (ENOTTY);
332 }
333
334 static int
335 dcons_tty_param(struct tty *tp, struct termios *t)
336 {
337         tp->t_ispeed = t->c_ispeed;
338         tp->t_ospeed = t->c_ospeed;
339         tp->t_cflag = t->c_cflag;
340         return 0;
341 }
342
343 static void
344 dcons_tty_start(struct tty *tp)
345 {
346         struct dcons_softc *dc;
347
348         dc = (struct dcons_softc *)tp->t_dev->si_drv1;
349         crit_enter();
350         if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
351                 ttwwakeup(tp);
352                 return;
353         }
354
355         tp->t_state |= TS_BUSY;
356         while (tp->t_outq.c_cc != 0)
357                 dcons_os_putc(dc, clist_getc(&tp->t_outq));
358         tp->t_state &= ~TS_BUSY;
359
360         ttwwakeup(tp);
361         crit_exit();
362 }
363
364 static void
365 dcons_timeout(void *v)
366 {
367         struct  tty *tp;
368         struct dcons_softc *dc;
369         int i, c, polltime;
370
371         for (i = 0; i < DCONS_NPORT; i ++) {
372                 dc = &sc[i];
373                 tp = ((DEV)dc->dev)->si_tty;
374                 while ((c = dcons_os_checkc(dc)) != -1)
375                         if (tp->t_state & TS_ISOPEN)
376 #if __FreeBSD_version < 502113
377                                 (*linesw[tp->t_line].l_rint)(c, tp);
378 #else
379                                 ttyld_rint(tp, c);
380 #endif
381         }
382         polltime = hz / poll_hz;
383         if (polltime < 1)
384                 polltime = 1;
385         callout_reset(&dcons_callout, polltime, dcons_timeout, tp);
386 }
387
388 static void
389 dcons_cnprobe(struct consdev *cp)
390 {
391 #ifdef __DragonFly__
392         cp->cn_probegood = 1;
393 #elif __FreeBSD_version >= 501109
394         ksprintf(cp->cn_name, "dcons");
395 #else
396         cp->cn_dev = makedev(CDEV_MAJOR, DCONS_CON);
397 #endif
398 #if DCONS_FORCE_CONSOLE
399         cp->cn_pri = CN_REMOTE;
400 #else
401         cp->cn_pri = CN_NORMAL;
402 #endif
403 }
404
405 static void
406 dcons_cninit(struct consdev *cp)
407 {
408         dcons_drv_init(0);
409 #if CONS_NODEV
410         cp->cn_arg
411 #else
412         cp->cn_private
413 #endif
414                 = (void *)&sc[DCONS_CON]; /* share port0 with unit0 */
415 }
416
417 static void
418 dcons_cninit_fini(struct consdev *cp)
419 {
420         cp->cn_dev = make_dev(&dcons_ops, DCONS_CON,
421                               UID_ROOT, GID_WHEEL, 0600, "dcons");
422 }
423
424 #if CONS_NODEV
425 static int
426 dcons_cngetc(struct consdev *cp)
427 {
428         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
429         return (dcons_os_getc(dc));
430 }
431 static int
432 dcons_cncheckc(struct consdev *cp)
433 {
434         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
435         return (dcons_os_checkc(dc));
436 }
437 static void
438 dcons_cnputc(struct consdev *cp, int c)
439 {
440         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
441         dcons_os_putc(dc, c);
442 }
443 #else
444 static int
445 dcons_cngetc(void *private)
446 {
447         struct dcons_softc *dc = (struct dcons_softc *)private;
448         return (dcons_os_getc(dc));
449 }
450 static int
451 dcons_cncheckc(void *private)
452 {
453         struct dcons_softc *dc = (struct dcons_softc *)private;
454         return (dcons_os_checkc(dc));
455 }
456 static void
457 dcons_cnputc(void *private, int c)
458 {
459         struct dcons_softc *dc = (struct dcons_softc *)private;
460         dcons_os_putc(dc, c);
461 }
462 #endif
463
464 static int
465 dcons_drv_init(int stage)
466 {
467 #ifdef __i386__
468         quad_t addr, size;
469 #endif
470
471         if (drv_init)
472                 return(drv_init);
473
474         drv_init = -1;
475
476         bzero(&dg, sizeof(dg));
477         dcons_conf = &dg;
478         dg.cdev = &dcons_consdev;
479         dg.buf = NULL;
480         dg.size = DCONS_BUF_SIZE;
481
482 #ifdef __i386__
483         if (kgetenv_quad("dcons.addr", &addr) > 0 &&
484             kgetenv_quad("dcons.size", &size) > 0) {
485                 vm_paddr_t pa;
486                 /*
487                  * Allow read/write access to dcons buffer.
488                  */
489                 for (pa = trunc_page(addr); pa < addr + size; pa += PAGE_SIZE)
490                         pmap_kmodify_rw((vm_offset_t)(KERNBASE + pa));
491                 cpu_invltlb();
492                 /* XXX P to V */
493                 dg.buf = (struct dcons_buf *)(vm_offset_t)(KERNBASE + addr);
494                 dg.size = size;
495                 if (dcons_load_buffer(dg.buf, dg.size, sc) < 0)
496                         dg.buf = NULL;
497         }
498 #endif
499         if (dg.buf != NULL)
500                 goto ok;
501
502 #ifndef KLD_MODULE
503         if (stage == 0) { /* XXX or cold */
504                 /*
505                  * DCONS_FORCE_CONSOLE == 1 and statically linked.
506                  * called from cninit(). can't use contigmalloc yet .
507                  */
508                 dg.buf = (struct dcons_buf *) bssbuf;
509                 dcons_init(dg.buf, dg.size, sc);
510         } else
511 #endif
512         {
513                 /*
514                  * DCONS_FORCE_CONSOLE == 0 or kernel module case.
515                  * if the module is loaded after boot,
516                  * bssbuf could be non-continuous.
517                  */ 
518                 dg.buf = (struct dcons_buf *) contigmalloc(dg.size,
519                         M_DEVBUF, 0, 0x10000, 0xffffffff, PAGE_SIZE, 0ul);
520                 dcons_init(dg.buf, dg.size, sc);
521         }
522
523 ok:
524         dcons_buf = dg.buf;
525
526 #if DDB && DCONS_FORCE_GDB
527         if (gdb_tab == NULL) {
528                 gdb_tab = &dcons_consdev;
529                 dcons_consdev.cn_gdbprivate = &sc[DCONS_GDB];
530         }
531 #endif
532         drv_init = 1;
533
534         return 0;
535 }
536
537
538 static int
539 dcons_attach_port(int port, char *name, int flags)
540 {
541         struct dcons_softc *dc;
542         struct tty *tp;
543         DEV dev;
544
545         dc = &sc[port];
546         dc->flags = flags;
547         dev = make_dev(&dcons_ops, port,
548                         UID_ROOT, GID_WHEEL, 0600, name);
549         dc->dev = (void *)dev;
550         tp = ttymalloc(NULL);
551
552         dev->si_drv1 = (void *)dc;
553         dev->si_tty = tp;
554
555         tp->t_oproc = dcons_tty_start;
556         tp->t_param = dcons_tty_param;
557         tp->t_stop = nottystop;
558         tp->t_dev = dc->dev;
559
560         return(0);
561 }
562
563 static int
564 dcons_attach(void)
565 {
566         int polltime;
567
568 #ifdef __DragonFly__
569         dev_ops_add(&dcons_ops, -1, 0);
570 #endif
571         dcons_attach_port(DCONS_CON, "dcons", 0);
572         dcons_attach_port(DCONS_GDB, "dgdb", DC_GDB);
573 #if __FreeBSD_version < 500000
574         callout_init(&dcons_callout);
575 #else
576         callout_init(&dcons_callout, 0);
577 #endif
578         polltime = hz / poll_hz;
579         if (polltime < 1)
580                 polltime = 1;
581         callout_reset(&dcons_callout, polltime, dcons_timeout, NULL);
582         return(0);
583 }
584
585 static int
586 dcons_detach(int port)
587 {
588         struct  tty *tp;
589         struct dcons_softc *dc;
590
591         dc = &sc[port];
592
593         tp = ((DEV)dc->dev)->si_tty;
594
595         if (tp->t_state & TS_ISOPEN) {
596                 kprintf("dcons: still opened\n");
597 #if __FreeBSD_version < 502113
598                 (*linesw[tp->t_line].l_close)(tp, 0);
599                 ttyclose(tp);
600 #else
601                 ttyld_close(tp, 0);
602                 tty_close(tp);
603 #endif
604         }
605         /* XXX
606          * must wait until all device are closed.
607          */
608 #ifdef __DragonFly__
609         tsleep((void *)dc, 0, "dcodtc", hz/4);
610 #else
611         tsleep((void *)dc, PWAIT, "dcodtc", hz/4);
612 #endif
613         destroy_dev(dc->dev);
614
615         return(0);
616 }
617
618
619 /* cnXXX works only for FreeBSD-5 */
620 static int
621 dcons_modevent(module_t mode, int type, void *data)
622 {
623         int err = 0, ret;
624
625         switch (type) {
626         case MOD_LOAD:
627                 ret = dcons_drv_init(1);
628                 dcons_attach();
629 #if __FreeBSD_version >= 500000
630                 if (ret == 0) {
631                         dcons_cnprobe(&dcons_consdev);
632                         dcons_cninit(&dcons_consdev);
633                         cnadd(&dcons_consdev);
634                 }
635 #endif
636                 break;
637         case MOD_UNLOAD:
638                 kprintf("dcons: unload\n");
639                 callout_stop(&dcons_callout);
640 #if __FreeBSD_version < 502122
641 #if DDB && DCONS_FORCE_GDB
642 #if CONS_NODEV
643                 gdb_arg = NULL;
644 #else
645                 if (gdb_tab == &dcons_consdev)
646                         gdb_tab = NULL;
647 #endif
648 #endif
649 #endif
650 #if __FreeBSD_version >= 500000
651                 cnremove(&dcons_consdev);
652 #endif
653                 dcons_detach(DCONS_CON);
654                 dcons_detach(DCONS_GDB);
655                 dg.buf->magic = 0;
656
657                 contigfree(dg.buf, DCONS_BUF_SIZE, M_DEVBUF);
658
659                 break;
660         case MOD_SHUTDOWN:
661                 dg.buf->magic = 0;
662                 break;
663         default:
664                 err = EOPNOTSUPP;
665                 break;
666         }
667         return(err);
668 }
669
670 #if __FreeBSD_version >= 502122
671 /* Debugger interface */
672
673 static int
674 dcons_dbg_probe(void)
675 {
676         return(DCONS_FORCE_GDB);
677 }
678
679 static void
680 dcons_dbg_init(void)
681 {
682 }
683
684 static void
685 dcons_dbg_term(void)
686 {
687 }
688
689 static void
690 dcons_dbg_putc(int c)
691 {
692         struct dcons_softc *dc = &sc[DCONS_GDB];
693         dcons_os_putc(dc, c);
694 }
695
696 static int
697 dcons_dbg_checkc(void)
698 {
699         struct dcons_softc *dc = &sc[DCONS_GDB];
700         return (dcons_os_checkc(dc));
701 }
702
703 static int
704 dcons_dbg_getc(void)
705 {
706         struct dcons_softc *dc = &sc[DCONS_GDB];
707         return (dcons_os_getc(dc));
708 }
709 #endif
710
711 DEV_MODULE(dcons, dcons_modevent, NULL);
712 MODULE_VERSION(dcons, DCONS_VERSION);