1/* $NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $ */
2
3/*
4 * Copyright (c) 1994, 1995 Scott Bartram
5 * All rights reserved.
6 *
7 * based on compat/sunos/sun_ioctl.c
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
| 1/* $NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $ */
2
3/*
4 * Copyright (c) 1994, 1995 Scott Bartram
5 * All rights reserved.
6 *
7 * based on compat/sunos/sun_ioctl.c
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
|
28 * $FreeBSD: head/sys/i386/ibcs2/ibcs2_ioctl.c 86468 2001-11-16 20:32:32Z iedowse $
| 28 * $FreeBSD: head/sys/i386/ibcs2/ibcs2_ioctl.c 89306 2002-01-13 11:58:06Z alfred $
|
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/consio.h>
34#include <sys/fcntl.h>
35#include <sys/file.h>
36#include <sys/filedesc.h>
37#include <sys/filio.h>
38#include <sys/ioctl_compat.h>
39#include <sys/kbio.h>
40#include <sys/lock.h>
41#include <sys/mutex.h>
42#include <sys/sysproto.h>
43#include <sys/tty.h>
44
45#include <i386/ibcs2/ibcs2_signal.h>
46#include <i386/ibcs2/ibcs2_socksys.h>
47#include <i386/ibcs2/ibcs2_stropts.h>
48#include <i386/ibcs2/ibcs2_proto.h>
49#include <i386/ibcs2/ibcs2_termios.h>
50#include <i386/ibcs2/ibcs2_util.h>
51#include <i386/ibcs2/ibcs2_ioctl.h>
52
53static void stios2btios __P((struct ibcs2_termios *, struct termios *));
54static void btios2stios __P((struct termios *, struct ibcs2_termios *));
55static void stios2stio __P((struct ibcs2_termios *, struct ibcs2_termio *));
56static void stio2stios __P((struct ibcs2_termio *, struct ibcs2_termios *));
| 29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/consio.h>
34#include <sys/fcntl.h>
35#include <sys/file.h>
36#include <sys/filedesc.h>
37#include <sys/filio.h>
38#include <sys/ioctl_compat.h>
39#include <sys/kbio.h>
40#include <sys/lock.h>
41#include <sys/mutex.h>
42#include <sys/sysproto.h>
43#include <sys/tty.h>
44
45#include <i386/ibcs2/ibcs2_signal.h>
46#include <i386/ibcs2/ibcs2_socksys.h>
47#include <i386/ibcs2/ibcs2_stropts.h>
48#include <i386/ibcs2/ibcs2_proto.h>
49#include <i386/ibcs2/ibcs2_termios.h>
50#include <i386/ibcs2/ibcs2_util.h>
51#include <i386/ibcs2/ibcs2_ioctl.h>
52
53static void stios2btios __P((struct ibcs2_termios *, struct termios *));
54static void btios2stios __P((struct termios *, struct ibcs2_termios *));
55static void stios2stio __P((struct ibcs2_termios *, struct ibcs2_termio *));
56static void stio2stios __P((struct ibcs2_termio *, struct ibcs2_termios *));
|
| 57static int ibcs2_do_ioctl __P((struct proc *, struct ibcs2_ioctl_args *,
58 struct file *));
|
57
58
59int
60ibcs2_gtty(struct thread *td, struct ibcs2_gtty_args *args)
61{
62 struct ioctl_args ioctl_arg;
63
64 ioctl_arg.fd = args->fd;
65 ioctl_arg.com = TIOCGETC;
66 ioctl_arg.data = (caddr_t)args->buf;
67
68 return ioctl(td, &ioctl_arg);
69}
70
71int
72ibcs2_stty(struct thread *td, struct ibcs2_stty_args *args)
73{
74 struct ioctl_args ioctl_arg;
75
76 ioctl_arg.fd = args->fd;
77 ioctl_arg.com = TIOCSETC;
78 ioctl_arg.data = (caddr_t)args->buf;
79
80 return ioctl(td, &ioctl_arg);
81}
82
83
84/*
85 * iBCS2 ioctl calls.
86 */
87
88static struct speedtab sptab[] = {
89 { 0, 0 },
90 { 50, 1 },
91 { 75, 2 },
92 { 110, 3 },
93 { 134, 4 },
94 { 135, 4 },
95 { 150, 5 },
96 { 200, 6 },
97 { 300, 7 },
98 { 600, 8 },
99 { 1200, 9 },
100 { 1800, 10 },
101 { 2400, 11 },
102 { 4800, 12 },
103 { 9600, 13 },
104 { 19200, 14 },
105 { 38400, 15 },
106 { -1, -1 }
107};
108
109static u_long s2btab[] = {
110 0,
111 50,
112 75,
113 110,
114 134,
115 150,
116 200,
117 300,
118 600,
119 1200,
120 1800,
121 2400,
122 4800,
123 9600,
124 19200,
125 38400,
126};
127
128static void
129stios2btios(st, bt)
130 struct ibcs2_termios *st;
131 struct termios *bt;
132{
133 register u_long l, r;
134
135 l = st->c_iflag; r = 0;
136 if (l & IBCS2_IGNBRK) r |= IGNBRK;
137 if (l & IBCS2_BRKINT) r |= BRKINT;
138 if (l & IBCS2_IGNPAR) r |= IGNPAR;
139 if (l & IBCS2_PARMRK) r |= PARMRK;
140 if (l & IBCS2_INPCK) r |= INPCK;
141 if (l & IBCS2_ISTRIP) r |= ISTRIP;
142 if (l & IBCS2_INLCR) r |= INLCR;
143 if (l & IBCS2_IGNCR) r |= IGNCR;
144 if (l & IBCS2_ICRNL) r |= ICRNL;
145 if (l & IBCS2_IXON) r |= IXON;
146 if (l & IBCS2_IXANY) r |= IXANY;
147 if (l & IBCS2_IXOFF) r |= IXOFF;
148 if (l & IBCS2_IMAXBEL) r |= IMAXBEL;
149 bt->c_iflag = r;
150
151 l = st->c_oflag; r = 0;
152 if (l & IBCS2_OPOST) r |= OPOST;
153 if (l & IBCS2_ONLCR) r |= ONLCR;
154 if (l & IBCS2_TAB3) r |= OXTABS;
155 bt->c_oflag = r;
156
157 l = st->c_cflag; r = 0;
158 switch (l & IBCS2_CSIZE) {
159 case IBCS2_CS5: r |= CS5; break;
160 case IBCS2_CS6: r |= CS6; break;
161 case IBCS2_CS7: r |= CS7; break;
162 case IBCS2_CS8: r |= CS8; break;
163 }
164 if (l & IBCS2_CSTOPB) r |= CSTOPB;
165 if (l & IBCS2_CREAD) r |= CREAD;
166 if (l & IBCS2_PARENB) r |= PARENB;
167 if (l & IBCS2_PARODD) r |= PARODD;
168 if (l & IBCS2_HUPCL) r |= HUPCL;
169 if (l & IBCS2_CLOCAL) r |= CLOCAL;
170 bt->c_cflag = r;
171
172 bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
173
174 l = st->c_lflag; r = 0;
175 if (l & IBCS2_ISIG) r |= ISIG;
176 if (l & IBCS2_ICANON) r |= ICANON;
177 if (l & IBCS2_ECHO) r |= ECHO;
178 if (l & IBCS2_ECHOE) r |= ECHOE;
179 if (l & IBCS2_ECHOK) r |= ECHOK;
180 if (l & IBCS2_ECHONL) r |= ECHONL;
181 if (l & IBCS2_NOFLSH) r |= NOFLSH;
182 if (l & IBCS2_TOSTOP) r |= TOSTOP;
183 bt->c_lflag = r;
184
185 bt->c_cc[VINTR] =
186 st->c_cc[IBCS2_VINTR] ? st->c_cc[IBCS2_VINTR] : _POSIX_VDISABLE;
187 bt->c_cc[VQUIT] =
188 st->c_cc[IBCS2_VQUIT] ? st->c_cc[IBCS2_VQUIT] : _POSIX_VDISABLE;
189 bt->c_cc[VERASE] =
190 st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
191 bt->c_cc[VKILL] =
192 st->c_cc[IBCS2_VKILL] ? st->c_cc[IBCS2_VKILL] : _POSIX_VDISABLE;
193 if (bt->c_lflag & ICANON) {
194 bt->c_cc[VEOF] =
195 st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
196 bt->c_cc[VEOL] =
197 st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
198 } else {
199 bt->c_cc[VMIN] = st->c_cc[IBCS2_VMIN];
200 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
201 }
202 bt->c_cc[VEOL2] =
203 st->c_cc[IBCS2_VEOL2] ? st->c_cc[IBCS2_VEOL2] : _POSIX_VDISABLE;
204#if 0
205 bt->c_cc[VSWTCH] =
206 st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
207#endif
208 bt->c_cc[VSTART] =
209 st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
210 bt->c_cc[VSTOP] =
211 st->c_cc[IBCS2_VSTOP] ? st->c_cc[IBCS2_VSTOP] : _POSIX_VDISABLE;
212 bt->c_cc[VSUSP] =
213 st->c_cc[IBCS2_VSUSP] ? st->c_cc[IBCS2_VSUSP] : _POSIX_VDISABLE;
214 bt->c_cc[VDSUSP] = _POSIX_VDISABLE;
215 bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
216 bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
217 bt->c_cc[VWERASE] = _POSIX_VDISABLE;
218 bt->c_cc[VLNEXT] = _POSIX_VDISABLE;
219 bt->c_cc[VSTATUS] = _POSIX_VDISABLE;
220}
221
222static void
223btios2stios(bt, st)
224 struct termios *bt;
225 struct ibcs2_termios *st;
226{
227 register u_long l, r;
228
229 l = bt->c_iflag; r = 0;
230 if (l & IGNBRK) r |= IBCS2_IGNBRK;
231 if (l & BRKINT) r |= IBCS2_BRKINT;
232 if (l & IGNPAR) r |= IBCS2_IGNPAR;
233 if (l & PARMRK) r |= IBCS2_PARMRK;
234 if (l & INPCK) r |= IBCS2_INPCK;
235 if (l & ISTRIP) r |= IBCS2_ISTRIP;
236 if (l & INLCR) r |= IBCS2_INLCR;
237 if (l & IGNCR) r |= IBCS2_IGNCR;
238 if (l & ICRNL) r |= IBCS2_ICRNL;
239 if (l & IXON) r |= IBCS2_IXON;
240 if (l & IXANY) r |= IBCS2_IXANY;
241 if (l & IXOFF) r |= IBCS2_IXOFF;
242 if (l & IMAXBEL) r |= IBCS2_IMAXBEL;
243 st->c_iflag = r;
244
245 l = bt->c_oflag; r = 0;
246 if (l & OPOST) r |= IBCS2_OPOST;
247 if (l & ONLCR) r |= IBCS2_ONLCR;
248 if (l & OXTABS) r |= IBCS2_TAB3;
249 st->c_oflag = r;
250
251 l = bt->c_cflag; r = 0;
252 switch (l & CSIZE) {
253 case CS5: r |= IBCS2_CS5; break;
254 case CS6: r |= IBCS2_CS6; break;
255 case CS7: r |= IBCS2_CS7; break;
256 case CS8: r |= IBCS2_CS8; break;
257 }
258 if (l & CSTOPB) r |= IBCS2_CSTOPB;
259 if (l & CREAD) r |= IBCS2_CREAD;
260 if (l & PARENB) r |= IBCS2_PARENB;
261 if (l & PARODD) r |= IBCS2_PARODD;
262 if (l & HUPCL) r |= IBCS2_HUPCL;
263 if (l & CLOCAL) r |= IBCS2_CLOCAL;
264 st->c_cflag = r;
265
266 l = bt->c_lflag; r = 0;
267 if (l & ISIG) r |= IBCS2_ISIG;
268 if (l & ICANON) r |= IBCS2_ICANON;
269 if (l & ECHO) r |= IBCS2_ECHO;
270 if (l & ECHOE) r |= IBCS2_ECHOE;
271 if (l & ECHOK) r |= IBCS2_ECHOK;
272 if (l & ECHONL) r |= IBCS2_ECHONL;
273 if (l & NOFLSH) r |= IBCS2_NOFLSH;
274 if (l & TOSTOP) r |= IBCS2_TOSTOP;
275 st->c_lflag = r;
276
277 l = ttspeedtab(bt->c_ospeed, sptab);
278 if ((int)l >= 0)
279 st->c_cflag |= l;
280
281 st->c_cc[IBCS2_VINTR] =
282 bt->c_cc[VINTR] != _POSIX_VDISABLE ? bt->c_cc[VINTR] : 0;
283 st->c_cc[IBCS2_VQUIT] =
284 bt->c_cc[VQUIT] != _POSIX_VDISABLE ? bt->c_cc[VQUIT] : 0;
285 st->c_cc[IBCS2_VERASE] =
286 bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
287 st->c_cc[IBCS2_VKILL] =
288 bt->c_cc[VKILL] != _POSIX_VDISABLE ? bt->c_cc[VKILL] : 0;
289 if (bt->c_lflag & ICANON) {
290 st->c_cc[IBCS2_VEOF] =
291 bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
292 st->c_cc[IBCS2_VEOL] =
293 bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
294 } else {
295 st->c_cc[IBCS2_VMIN] = bt->c_cc[VMIN];
296 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
297 }
298 st->c_cc[IBCS2_VEOL2] =
299 bt->c_cc[VEOL2] != _POSIX_VDISABLE ? bt->c_cc[VEOL2] : 0;
300 st->c_cc[IBCS2_VSWTCH] =
301 0;
302 st->c_cc[IBCS2_VSUSP] =
303 bt->c_cc[VSUSP] != _POSIX_VDISABLE ? bt->c_cc[VSUSP] : 0;
304 st->c_cc[IBCS2_VSTART] =
305 bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
306 st->c_cc[IBCS2_VSTOP] =
307 bt->c_cc[VSTOP] != _POSIX_VDISABLE ? bt->c_cc[VSTOP] : 0;
308
309 st->c_line = 0;
310}
311
312static void
313stios2stio(ts, t)
314 struct ibcs2_termios *ts;
315 struct ibcs2_termio *t;
316{
317 t->c_iflag = ts->c_iflag;
318 t->c_oflag = ts->c_oflag;
319 t->c_cflag = ts->c_cflag;
320 t->c_lflag = ts->c_lflag;
321 t->c_line = ts->c_line;
322 bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
323}
324
325static void
326stio2stios(t, ts)
327 struct ibcs2_termio *t;
328 struct ibcs2_termios *ts;
329{
330 ts->c_iflag = t->c_iflag;
331 ts->c_oflag = t->c_oflag;
332 ts->c_cflag = t->c_cflag;
333 ts->c_lflag = t->c_lflag;
334 ts->c_line = t->c_line;
335 bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
336}
337
338int
339ibcs2_ioctl(td, uap)
340 struct thread *td;
341 struct ibcs2_ioctl_args *uap;
342{
343 struct proc *p = td->td_proc;
| 59
60
61int
62ibcs2_gtty(struct thread *td, struct ibcs2_gtty_args *args)
63{
64 struct ioctl_args ioctl_arg;
65
66 ioctl_arg.fd = args->fd;
67 ioctl_arg.com = TIOCGETC;
68 ioctl_arg.data = (caddr_t)args->buf;
69
70 return ioctl(td, &ioctl_arg);
71}
72
73int
74ibcs2_stty(struct thread *td, struct ibcs2_stty_args *args)
75{
76 struct ioctl_args ioctl_arg;
77
78 ioctl_arg.fd = args->fd;
79 ioctl_arg.com = TIOCSETC;
80 ioctl_arg.data = (caddr_t)args->buf;
81
82 return ioctl(td, &ioctl_arg);
83}
84
85
86/*
87 * iBCS2 ioctl calls.
88 */
89
90static struct speedtab sptab[] = {
91 { 0, 0 },
92 { 50, 1 },
93 { 75, 2 },
94 { 110, 3 },
95 { 134, 4 },
96 { 135, 4 },
97 { 150, 5 },
98 { 200, 6 },
99 { 300, 7 },
100 { 600, 8 },
101 { 1200, 9 },
102 { 1800, 10 },
103 { 2400, 11 },
104 { 4800, 12 },
105 { 9600, 13 },
106 { 19200, 14 },
107 { 38400, 15 },
108 { -1, -1 }
109};
110
111static u_long s2btab[] = {
112 0,
113 50,
114 75,
115 110,
116 134,
117 150,
118 200,
119 300,
120 600,
121 1200,
122 1800,
123 2400,
124 4800,
125 9600,
126 19200,
127 38400,
128};
129
130static void
131stios2btios(st, bt)
132 struct ibcs2_termios *st;
133 struct termios *bt;
134{
135 register u_long l, r;
136
137 l = st->c_iflag; r = 0;
138 if (l & IBCS2_IGNBRK) r |= IGNBRK;
139 if (l & IBCS2_BRKINT) r |= BRKINT;
140 if (l & IBCS2_IGNPAR) r |= IGNPAR;
141 if (l & IBCS2_PARMRK) r |= PARMRK;
142 if (l & IBCS2_INPCK) r |= INPCK;
143 if (l & IBCS2_ISTRIP) r |= ISTRIP;
144 if (l & IBCS2_INLCR) r |= INLCR;
145 if (l & IBCS2_IGNCR) r |= IGNCR;
146 if (l & IBCS2_ICRNL) r |= ICRNL;
147 if (l & IBCS2_IXON) r |= IXON;
148 if (l & IBCS2_IXANY) r |= IXANY;
149 if (l & IBCS2_IXOFF) r |= IXOFF;
150 if (l & IBCS2_IMAXBEL) r |= IMAXBEL;
151 bt->c_iflag = r;
152
153 l = st->c_oflag; r = 0;
154 if (l & IBCS2_OPOST) r |= OPOST;
155 if (l & IBCS2_ONLCR) r |= ONLCR;
156 if (l & IBCS2_TAB3) r |= OXTABS;
157 bt->c_oflag = r;
158
159 l = st->c_cflag; r = 0;
160 switch (l & IBCS2_CSIZE) {
161 case IBCS2_CS5: r |= CS5; break;
162 case IBCS2_CS6: r |= CS6; break;
163 case IBCS2_CS7: r |= CS7; break;
164 case IBCS2_CS8: r |= CS8; break;
165 }
166 if (l & IBCS2_CSTOPB) r |= CSTOPB;
167 if (l & IBCS2_CREAD) r |= CREAD;
168 if (l & IBCS2_PARENB) r |= PARENB;
169 if (l & IBCS2_PARODD) r |= PARODD;
170 if (l & IBCS2_HUPCL) r |= HUPCL;
171 if (l & IBCS2_CLOCAL) r |= CLOCAL;
172 bt->c_cflag = r;
173
174 bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
175
176 l = st->c_lflag; r = 0;
177 if (l & IBCS2_ISIG) r |= ISIG;
178 if (l & IBCS2_ICANON) r |= ICANON;
179 if (l & IBCS2_ECHO) r |= ECHO;
180 if (l & IBCS2_ECHOE) r |= ECHOE;
181 if (l & IBCS2_ECHOK) r |= ECHOK;
182 if (l & IBCS2_ECHONL) r |= ECHONL;
183 if (l & IBCS2_NOFLSH) r |= NOFLSH;
184 if (l & IBCS2_TOSTOP) r |= TOSTOP;
185 bt->c_lflag = r;
186
187 bt->c_cc[VINTR] =
188 st->c_cc[IBCS2_VINTR] ? st->c_cc[IBCS2_VINTR] : _POSIX_VDISABLE;
189 bt->c_cc[VQUIT] =
190 st->c_cc[IBCS2_VQUIT] ? st->c_cc[IBCS2_VQUIT] : _POSIX_VDISABLE;
191 bt->c_cc[VERASE] =
192 st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
193 bt->c_cc[VKILL] =
194 st->c_cc[IBCS2_VKILL] ? st->c_cc[IBCS2_VKILL] : _POSIX_VDISABLE;
195 if (bt->c_lflag & ICANON) {
196 bt->c_cc[VEOF] =
197 st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
198 bt->c_cc[VEOL] =
199 st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
200 } else {
201 bt->c_cc[VMIN] = st->c_cc[IBCS2_VMIN];
202 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
203 }
204 bt->c_cc[VEOL2] =
205 st->c_cc[IBCS2_VEOL2] ? st->c_cc[IBCS2_VEOL2] : _POSIX_VDISABLE;
206#if 0
207 bt->c_cc[VSWTCH] =
208 st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
209#endif
210 bt->c_cc[VSTART] =
211 st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
212 bt->c_cc[VSTOP] =
213 st->c_cc[IBCS2_VSTOP] ? st->c_cc[IBCS2_VSTOP] : _POSIX_VDISABLE;
214 bt->c_cc[VSUSP] =
215 st->c_cc[IBCS2_VSUSP] ? st->c_cc[IBCS2_VSUSP] : _POSIX_VDISABLE;
216 bt->c_cc[VDSUSP] = _POSIX_VDISABLE;
217 bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
218 bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
219 bt->c_cc[VWERASE] = _POSIX_VDISABLE;
220 bt->c_cc[VLNEXT] = _POSIX_VDISABLE;
221 bt->c_cc[VSTATUS] = _POSIX_VDISABLE;
222}
223
224static void
225btios2stios(bt, st)
226 struct termios *bt;
227 struct ibcs2_termios *st;
228{
229 register u_long l, r;
230
231 l = bt->c_iflag; r = 0;
232 if (l & IGNBRK) r |= IBCS2_IGNBRK;
233 if (l & BRKINT) r |= IBCS2_BRKINT;
234 if (l & IGNPAR) r |= IBCS2_IGNPAR;
235 if (l & PARMRK) r |= IBCS2_PARMRK;
236 if (l & INPCK) r |= IBCS2_INPCK;
237 if (l & ISTRIP) r |= IBCS2_ISTRIP;
238 if (l & INLCR) r |= IBCS2_INLCR;
239 if (l & IGNCR) r |= IBCS2_IGNCR;
240 if (l & ICRNL) r |= IBCS2_ICRNL;
241 if (l & IXON) r |= IBCS2_IXON;
242 if (l & IXANY) r |= IBCS2_IXANY;
243 if (l & IXOFF) r |= IBCS2_IXOFF;
244 if (l & IMAXBEL) r |= IBCS2_IMAXBEL;
245 st->c_iflag = r;
246
247 l = bt->c_oflag; r = 0;
248 if (l & OPOST) r |= IBCS2_OPOST;
249 if (l & ONLCR) r |= IBCS2_ONLCR;
250 if (l & OXTABS) r |= IBCS2_TAB3;
251 st->c_oflag = r;
252
253 l = bt->c_cflag; r = 0;
254 switch (l & CSIZE) {
255 case CS5: r |= IBCS2_CS5; break;
256 case CS6: r |= IBCS2_CS6; break;
257 case CS7: r |= IBCS2_CS7; break;
258 case CS8: r |= IBCS2_CS8; break;
259 }
260 if (l & CSTOPB) r |= IBCS2_CSTOPB;
261 if (l & CREAD) r |= IBCS2_CREAD;
262 if (l & PARENB) r |= IBCS2_PARENB;
263 if (l & PARODD) r |= IBCS2_PARODD;
264 if (l & HUPCL) r |= IBCS2_HUPCL;
265 if (l & CLOCAL) r |= IBCS2_CLOCAL;
266 st->c_cflag = r;
267
268 l = bt->c_lflag; r = 0;
269 if (l & ISIG) r |= IBCS2_ISIG;
270 if (l & ICANON) r |= IBCS2_ICANON;
271 if (l & ECHO) r |= IBCS2_ECHO;
272 if (l & ECHOE) r |= IBCS2_ECHOE;
273 if (l & ECHOK) r |= IBCS2_ECHOK;
274 if (l & ECHONL) r |= IBCS2_ECHONL;
275 if (l & NOFLSH) r |= IBCS2_NOFLSH;
276 if (l & TOSTOP) r |= IBCS2_TOSTOP;
277 st->c_lflag = r;
278
279 l = ttspeedtab(bt->c_ospeed, sptab);
280 if ((int)l >= 0)
281 st->c_cflag |= l;
282
283 st->c_cc[IBCS2_VINTR] =
284 bt->c_cc[VINTR] != _POSIX_VDISABLE ? bt->c_cc[VINTR] : 0;
285 st->c_cc[IBCS2_VQUIT] =
286 bt->c_cc[VQUIT] != _POSIX_VDISABLE ? bt->c_cc[VQUIT] : 0;
287 st->c_cc[IBCS2_VERASE] =
288 bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
289 st->c_cc[IBCS2_VKILL] =
290 bt->c_cc[VKILL] != _POSIX_VDISABLE ? bt->c_cc[VKILL] : 0;
291 if (bt->c_lflag & ICANON) {
292 st->c_cc[IBCS2_VEOF] =
293 bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
294 st->c_cc[IBCS2_VEOL] =
295 bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
296 } else {
297 st->c_cc[IBCS2_VMIN] = bt->c_cc[VMIN];
298 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
299 }
300 st->c_cc[IBCS2_VEOL2] =
301 bt->c_cc[VEOL2] != _POSIX_VDISABLE ? bt->c_cc[VEOL2] : 0;
302 st->c_cc[IBCS2_VSWTCH] =
303 0;
304 st->c_cc[IBCS2_VSUSP] =
305 bt->c_cc[VSUSP] != _POSIX_VDISABLE ? bt->c_cc[VSUSP] : 0;
306 st->c_cc[IBCS2_VSTART] =
307 bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
308 st->c_cc[IBCS2_VSTOP] =
309 bt->c_cc[VSTOP] != _POSIX_VDISABLE ? bt->c_cc[VSTOP] : 0;
310
311 st->c_line = 0;
312}
313
314static void
315stios2stio(ts, t)
316 struct ibcs2_termios *ts;
317 struct ibcs2_termio *t;
318{
319 t->c_iflag = ts->c_iflag;
320 t->c_oflag = ts->c_oflag;
321 t->c_cflag = ts->c_cflag;
322 t->c_lflag = ts->c_lflag;
323 t->c_line = ts->c_line;
324 bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
325}
326
327static void
328stio2stios(t, ts)
329 struct ibcs2_termio *t;
330 struct ibcs2_termios *ts;
331{
332 ts->c_iflag = t->c_iflag;
333 ts->c_oflag = t->c_oflag;
334 ts->c_cflag = t->c_cflag;
335 ts->c_lflag = t->c_lflag;
336 ts->c_line = t->c_line;
337 bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
338}
339
340int
341ibcs2_ioctl(td, uap)
342 struct thread *td;
343 struct ibcs2_ioctl_args *uap;
344{
345 struct proc *p = td->td_proc;
|
344 struct filedesc *fdp = p->p_fd;
| |
345 struct file *fp;
346 int error;
347
| 346 struct file *fp;
347 int error;
348
|
348 if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
349 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
| 349 fp = ffind_hold(td, uap->fd);
350 if (fp == NULL) {
|
350 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
351 SCARG(uap, fd)));
352 return EBADF;
353 }
354
355 if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
| 351 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
352 SCARG(uap, fd)));
353 return EBADF;
354 }
355
356 if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
|
| 357 fdrop(fp, td);
|
356 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
357 return EBADF;
358 }
359
360 switch (SCARG(uap, cmd)) {
361 case IBCS2_TCGETA:
362 case IBCS2_XCGETA:
363 case IBCS2_OXCGETA:
364 {
365 struct termios bts;
366 struct ibcs2_termios sts;
367 struct ibcs2_termio st;
368
369 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0)
| 358 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
359 return EBADF;
360 }
361
362 switch (SCARG(uap, cmd)) {
363 case IBCS2_TCGETA:
364 case IBCS2_XCGETA:
365 case IBCS2_OXCGETA:
366 {
367 struct termios bts;
368 struct ibcs2_termios sts;
369 struct ibcs2_termio st;
370
371 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0)
|
370 return error;
| 372 break;
|
371
372 btios2stios (&bts, &sts);
373 if (SCARG(uap, cmd) == IBCS2_TCGETA) {
374 stios2stio (&sts, &st);
375 error = copyout((caddr_t)&st, SCARG(uap, data),
376 sizeof (st));
377#ifdef DEBUG_IBCS2
378 if (error)
379 DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
380 p->p_pid));
381#endif
| 373
374 btios2stios (&bts, &sts);
375 if (SCARG(uap, cmd) == IBCS2_TCGETA) {
376 stios2stio (&sts, &st);
377 error = copyout((caddr_t)&st, SCARG(uap, data),
378 sizeof (st));
379#ifdef DEBUG_IBCS2
380 if (error)
381 DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
382 p->p_pid));
383#endif
|
382 return error;
383 } else
384 return copyout((caddr_t)&sts, SCARG(uap, data),
| 384 break;
385 } else {
386 error = copyout((caddr_t)&sts, SCARG(uap, data),
|
385 sizeof (sts));
| 387 sizeof (sts));
|
| 388 break;
389 }
|
386 /*NOTREACHED*/
387 }
388
389 case IBCS2_TCSETA:
390 case IBCS2_TCSETAW:
391 case IBCS2_TCSETAF:
392 {
393 struct termios bts;
394 struct ibcs2_termios sts;
395 struct ibcs2_termio st;
396
397 if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
398 sizeof(st))) != 0) {
399 DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
400 p->p_pid));
| 390 /*NOTREACHED*/
391 }
392
393 case IBCS2_TCSETA:
394 case IBCS2_TCSETAW:
395 case IBCS2_TCSETAF:
396 {
397 struct termios bts;
398 struct ibcs2_termios sts;
399 struct ibcs2_termio st;
400
401 if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
402 sizeof(st))) != 0) {
403 DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
404 p->p_pid));
|
401 return error;
| 405 break;
|
402 }
403
404 /* get full BSD termios so we don't lose information */
405 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) {
406 DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
407 p->p_pid, SCARG(uap, fd)));
| 406 }
407
408 /* get full BSD termios so we don't lose information */
409 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) {
410 DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
411 p->p_pid, SCARG(uap, fd)));
|
408 return error;
| 412 break;
|
409 }
410
411 /*
412 * convert to iBCS2 termios, copy in information from
413 * termio, and convert back, then set new values.
414 */
415 btios2stios(&bts, &sts);
416 stio2stios(&st, &sts);
417 stios2btios(&sts, &bts);
418
| 413 }
414
415 /*
416 * convert to iBCS2 termios, copy in information from
417 * termio, and convert back, then set new values.
418 */
419 btios2stios(&bts, &sts);
420 stio2stios(&st, &sts);
421 stios2btios(&sts, &bts);
422
|
419 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
| 423 error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
|
420 (caddr_t)&bts, td);
| 424 (caddr_t)&bts, td);
|
| 425 break;
|
421 }
422
423 case IBCS2_XCSETA:
424 case IBCS2_XCSETAW:
425 case IBCS2_XCSETAF:
426 {
427 struct termios bts;
428 struct ibcs2_termios sts;
429
430 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
| 426 }
427
428 case IBCS2_XCSETA:
429 case IBCS2_XCSETAW:
430 case IBCS2_XCSETAF:
431 {
432 struct termios bts;
433 struct ibcs2_termios sts;
434
435 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
|
431 sizeof (sts))) != 0) {
432 return error;
433 }
| 436 sizeof (sts))) != 0)
437 break;
|
434 stios2btios (&sts, &bts);
| 438 stios2btios (&sts, &bts);
|
435 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
| 439 error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
|
436 (caddr_t)&bts, td);
| 440 (caddr_t)&bts, td);
|
| 441 break;
|
437 }
438
439 case IBCS2_OXCSETA:
440 case IBCS2_OXCSETAW:
441 case IBCS2_OXCSETAF:
442 {
443 struct termios bts;
444 struct ibcs2_termios sts;
445
446 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
| 442 }
443
444 case IBCS2_OXCSETA:
445 case IBCS2_OXCSETAW:
446 case IBCS2_OXCSETAF:
447 {
448 struct termios bts;
449 struct ibcs2_termios sts;
450
451 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
|
447 sizeof (sts))) != 0) {
448 return error;
449 }
| 452 sizeof (sts))) != 0)
453 break;
|
450 stios2btios (&sts, &bts);
| 454 stios2btios (&sts, &bts);
|
451 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
| 455 error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
|
452 (caddr_t)&bts, td);
| 456 (caddr_t)&bts, td);
|
| 457 break;
|
453 }
454
455 case IBCS2_TCSBRK:
456 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
| 458 }
459
460 case IBCS2_TCSBRK:
461 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
|
457 return ENOSYS;
| 462 error = ENOSYS;
463 break;
|
458
459 case IBCS2_TCXONC:
460 {
461 switch ((int)SCARG(uap, data)) {
462 case 0:
463 case 1:
464 DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
| 464
465 case IBCS2_TCXONC:
466 {
467 switch ((int)SCARG(uap, data)) {
468 case 0:
469 case 1:
470 DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
|
465 return ENOSYS;
| 471 error = ENOSYS;
472 break;
|
466 case 2:
| 473 case 2:
|
467 return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, td);
| 474 error = fo_ioctl(fp, TIOCSTOP, (caddr_t)0, td);
475 break;
|
468 case 3:
| 476 case 3:
|
469 return fo_ioctl(fp, TIOCSTART, (caddr_t)1, td);
| 477 error = fo_ioctl(fp, TIOCSTART, (caddr_t)1, td);
478 break;
|
470 default:
| 479 default:
|
471 return EINVAL;
| 480 error = EINVAL;
481 break;
|
472 }
| 482 }
|
| 483 break;
|
473 }
474
475 case IBCS2_TCFLSH:
476 {
477 int arg;
478
479 switch ((int)SCARG(uap, data)) {
480 case 0:
481 arg = FREAD;
482 break;
483 case 1:
484 arg = FWRITE;
485 break;
486 case 2:
487 arg = FREAD | FWRITE;
488 break;
489 default:
| 484 }
485
486 case IBCS2_TCFLSH:
487 {
488 int arg;
489
490 switch ((int)SCARG(uap, data)) {
491 case 0:
492 arg = FREAD;
493 break;
494 case 1:
495 arg = FWRITE;
496 break;
497 case 2:
498 arg = FREAD | FWRITE;
499 break;
500 default:
|
| 501 fdrop(fp, td);
|
490 return EINVAL;
491 }
| 502 return EINVAL;
503 }
|
492 return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td);
| 504 error = fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td);
505 break;
|
493 }
494
495 case IBCS2_TIOCGWINSZ:
496 SCARG(uap, cmd) = TIOCGWINSZ;
| 506 }
507
508 case IBCS2_TIOCGWINSZ:
509 SCARG(uap, cmd) = TIOCGWINSZ;
|
497 return ioctl(td, (struct ioctl_args *)uap);
| 510 error = ioctl(td, (struct ioctl_args *)uap);
511 break;
|
498
499 case IBCS2_TIOCSWINSZ:
500 SCARG(uap, cmd) = TIOCSWINSZ;
| 512
513 case IBCS2_TIOCSWINSZ:
514 SCARG(uap, cmd) = TIOCSWINSZ;
|
501 return ioctl(td, (struct ioctl_args *)uap);
| 515 error = ioctl(td, (struct ioctl_args *)uap);
516 break;
|
502
503 case IBCS2_TIOCGPGRP:
| 517
518 case IBCS2_TIOCGPGRP:
|
| 519 {
520 pid_t pg_id;
521
|
504 PROC_LOCK(p);
| 522 PROC_LOCK(p);
|
505 error = copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
506 sizeof(p->p_pgrp->pg_id));
| 523 pg_id = p->p_pgrp->pg_id;
|
507 PROC_UNLOCK(p);
| 524 PROC_UNLOCK(p);
|
508 return error;
| 525 error = copyout((caddr_t)&pg_id, SCARG(uap, data),
526 sizeof(pg_id));
527 break;
528 }
|
509
510 case IBCS2_TIOCSPGRP: /* XXX - is uap->data a pointer to pgid? */
511 {
512 struct setpgid_args sa;
513
514 SCARG(&sa, pid) = 0;
515 SCARG(&sa, pgid) = (int)SCARG(uap, data);
| 529
530 case IBCS2_TIOCSPGRP: /* XXX - is uap->data a pointer to pgid? */
531 {
532 struct setpgid_args sa;
533
534 SCARG(&sa, pid) = 0;
535 SCARG(&sa, pgid) = (int)SCARG(uap, data);
|
516 if ((error = setpgid(td, &sa)) != 0)
517 return error;
518 return 0;
| 536 error = setpgid(td, &sa);
537 break;
|
519 }
520
521 case IBCS2_TCGETSC: /* SCO console - get scancode flags */
| 538 }
539
540 case IBCS2_TCGETSC: /* SCO console - get scancode flags */
|
522 return EINTR; /* ENOSYS; */
| 541 error = EINTR; /* ENOSYS; */
542 break;
|
523
524 case IBCS2_TCSETSC: /* SCO console - set scancode flags */
| 543
544 case IBCS2_TCSETSC: /* SCO console - set scancode flags */
|
525 return 0; /* ENOSYS; */
| 545 error = 0; /* ENOSYS; */
546 break;
|
526
527 case IBCS2_JWINSIZE: /* Unix to Jerq I/O control */
528 {
529 struct ibcs2_jwinsize {
530 char bytex, bytey;
531 short bitx, bity;
532 } ibcs2_jwinsize;
533
534 PROC_LOCK(p);
535 ibcs2_jwinsize.bytex = 80;
536 /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */
537 ibcs2_jwinsize.bytey = 25;
538 /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */
539 ibcs2_jwinsize.bitx =
540 p->p_session->s_ttyp->t_winsize.ws_xpixel;
541 ibcs2_jwinsize.bity =
542 p->p_session->s_ttyp->t_winsize.ws_ypixel;
543 PROC_UNLOCK(p);
| 547
548 case IBCS2_JWINSIZE: /* Unix to Jerq I/O control */
549 {
550 struct ibcs2_jwinsize {
551 char bytex, bytey;
552 short bitx, bity;
553 } ibcs2_jwinsize;
554
555 PROC_LOCK(p);
556 ibcs2_jwinsize.bytex = 80;
557 /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */
558 ibcs2_jwinsize.bytey = 25;
559 /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */
560 ibcs2_jwinsize.bitx =
561 p->p_session->s_ttyp->t_winsize.ws_xpixel;
562 ibcs2_jwinsize.bity =
563 p->p_session->s_ttyp->t_winsize.ws_ypixel;
564 PROC_UNLOCK(p);
|
544 return copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
| 565 error = copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
|
545 sizeof(ibcs2_jwinsize));
| 566 sizeof(ibcs2_jwinsize));
|
| 567 break;
|
546 }
547
548 /* keyboard and display ioctl's -- type 'K' */
549 case IBCS2_KDGKBMODE: /* get keyboard translation mode */
550 SCARG(uap, cmd) = KDGKBMODE;
551/* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
| 568 }
569
570 /* keyboard and display ioctl's -- type 'K' */
571 case IBCS2_KDGKBMODE: /* get keyboard translation mode */
572 SCARG(uap, cmd) = KDGKBMODE;
573/* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
|
552 return ioctl(td, (struct ioctl_args *)uap);
| 574 error = ioctl(td, (struct ioctl_args *)uap);
575 break;
|
553
554 case IBCS2_KDSKBMODE: /* set keyboard translation mode */
555 SCARG(uap, cmd) = KDSKBMODE;
| 576
577 case IBCS2_KDSKBMODE: /* set keyboard translation mode */
578 SCARG(uap, cmd) = KDSKBMODE;
|
556 return ioctl(td, (struct ioctl_args *)uap);
| 579 error = ioctl(td, (struct ioctl_args *)uap);
580 break;
|
557
558 case IBCS2_KDMKTONE: /* sound tone */
559 SCARG(uap, cmd) = KDMKTONE;
| 581
582 case IBCS2_KDMKTONE: /* sound tone */
583 SCARG(uap, cmd) = KDMKTONE;
|
560 return ioctl(td, (struct ioctl_args *)uap);
| 584 error = ioctl(td, (struct ioctl_args *)uap);
585 break;
|
561
562 case IBCS2_KDGETMODE: /* get text/graphics mode */
563 SCARG(uap, cmd) = KDGETMODE;
| 586
587 case IBCS2_KDGETMODE: /* get text/graphics mode */
588 SCARG(uap, cmd) = KDGETMODE;
|
564 return ioctl(td, (struct ioctl_args *)uap);
| 589 error = ioctl(td, (struct ioctl_args *)uap);
590 break;
|
565
566 case IBCS2_KDSETMODE: /* set text/graphics mode */
567 SCARG(uap, cmd) = KDSETMODE;
| 591
592 case IBCS2_KDSETMODE: /* set text/graphics mode */
593 SCARG(uap, cmd) = KDSETMODE;
|
568 return ioctl(td, (struct ioctl_args *)uap);
| 594 error = ioctl(td, (struct ioctl_args *)uap);
595 break;
|
569
570 case IBCS2_KDSBORDER: /* set ega color border */
571 SCARG(uap, cmd) = KDSBORDER;
| 596
597 case IBCS2_KDSBORDER: /* set ega color border */
598 SCARG(uap, cmd) = KDSBORDER;
|
572 return ioctl(td, (struct ioctl_args *)uap);
| 599 error = ioctl(td, (struct ioctl_args *)uap);
600 break;
|
573
574 case IBCS2_KDGKBSTATE:
575 SCARG(uap, cmd) = KDGKBSTATE;
| 601
602 case IBCS2_KDGKBSTATE:
603 SCARG(uap, cmd) = KDGKBSTATE;
|
576 return ioctl(td, (struct ioctl_args *)uap);
| 604 error = ioctl(td, (struct ioctl_args *)uap);
605 break;
|
577
578 case IBCS2_KDSETRAD:
579 SCARG(uap, cmd) = KDSETRAD;
| 606
607 case IBCS2_KDSETRAD:
608 SCARG(uap, cmd) = KDSETRAD;
|
580 return ioctl(td, (struct ioctl_args *)uap);
| 609 error = ioctl(td, (struct ioctl_args *)uap);
610 break;
|
581
582 case IBCS2_KDENABIO: /* enable direct I/O to ports */
583 SCARG(uap, cmd) = KDENABIO;
| 611
612 case IBCS2_KDENABIO: /* enable direct I/O to ports */
613 SCARG(uap, cmd) = KDENABIO;
|
584 return ioctl(td, (struct ioctl_args *)uap);
| 614 error = ioctl(td, (struct ioctl_args *)uap);
615 break;
|
585
586 case IBCS2_KDDISABIO: /* disable direct I/O to ports */
587 SCARG(uap, cmd) = KDDISABIO;
| 616
617 case IBCS2_KDDISABIO: /* disable direct I/O to ports */
618 SCARG(uap, cmd) = KDDISABIO;
|
588 return ioctl(td, (struct ioctl_args *)uap);
| 619 error = ioctl(td, (struct ioctl_args *)uap);
620 break;
|
589
590 case IBCS2_KIOCSOUND: /* start sound generation */
591 SCARG(uap, cmd) = KIOCSOUND;
| 621
622 case IBCS2_KIOCSOUND: /* start sound generation */
623 SCARG(uap, cmd) = KIOCSOUND;
|
592 return ioctl(td, (struct ioctl_args *)uap);
| 624 error = ioctl(td, (struct ioctl_args *)uap);
625 break;
|
593
594 case IBCS2_KDGKBTYPE: /* get keyboard type */
595 SCARG(uap, cmd) = KDGKBTYPE;
| 626
627 case IBCS2_KDGKBTYPE: /* get keyboard type */
628 SCARG(uap, cmd) = KDGKBTYPE;
|
596 return ioctl(td, (struct ioctl_args *)uap);
| 629 error = ioctl(td, (struct ioctl_args *)uap);
630 break;
|
597
598 case IBCS2_KDGETLED: /* get keyboard LED status */
599 SCARG(uap, cmd) = KDGETLED;
| 631
632 case IBCS2_KDGETLED: /* get keyboard LED status */
633 SCARG(uap, cmd) = KDGETLED;
|
600 return ioctl(td, (struct ioctl_args *)uap);
| 634 error = ioctl(td, (struct ioctl_args *)uap);
635 break;
|
601
602 case IBCS2_KDSETLED: /* set keyboard LED status */
603 SCARG(uap, cmd) = KDSETLED;
| 636
637 case IBCS2_KDSETLED: /* set keyboard LED status */
638 SCARG(uap, cmd) = KDSETLED;
|
604 return ioctl(td, (struct ioctl_args *)uap);
| 639 error = ioctl(td, (struct ioctl_args *)uap);
640 break;
|
605
606 /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
607 case IBCS2_GETFKEY: /* Get function key */
608 SCARG(uap, cmd) = GETFKEY;
| 641
642 /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
643 case IBCS2_GETFKEY: /* Get function key */
644 SCARG(uap, cmd) = GETFKEY;
|
609 return ioctl(td, (struct ioctl_args *)uap);
| 645 error = ioctl(td, (struct ioctl_args *)uap);
646 break;
|
610
611 case IBCS2_SETFKEY: /* Set function key */
612 SCARG(uap, cmd) = SETFKEY;
| 647
648 case IBCS2_SETFKEY: /* Set function key */
649 SCARG(uap, cmd) = SETFKEY;
|
613 return ioctl(td, (struct ioctl_args *)uap);
| 650 error = ioctl(td, (struct ioctl_args *)uap);
651 break;
|
614
615 case IBCS2_GIO_SCRNMAP: /* Get screen output map table */
616 SCARG(uap, cmd) = GIO_SCRNMAP;
| 652
653 case IBCS2_GIO_SCRNMAP: /* Get screen output map table */
654 SCARG(uap, cmd) = GIO_SCRNMAP;
|
617 return ioctl(td, (struct ioctl_args *)uap);
| 655 error = ioctl(td, (struct ioctl_args *)uap);
656 break;
|
618
619 case IBCS2_PIO_SCRNMAP: /* Set screen output map table */
620 SCARG(uap, cmd) = PIO_SCRNMAP;
| 657
658 case IBCS2_PIO_SCRNMAP: /* Set screen output map table */
659 SCARG(uap, cmd) = PIO_SCRNMAP;
|
621 return ioctl(td, (struct ioctl_args *)uap);
| 660 error = ioctl(td, (struct ioctl_args *)uap);
661 break;
|
622
623 case IBCS2_GIO_KEYMAP: /* Get keyboard map table */
624 SCARG(uap, cmd) = GIO_KEYMAP;
| 662
663 case IBCS2_GIO_KEYMAP: /* Get keyboard map table */
664 SCARG(uap, cmd) = GIO_KEYMAP;
|
625 return ioctl(td, (struct ioctl_args *)uap);
| 665 error = ioctl(td, (struct ioctl_args *)uap);
666 break;
|
626
627 case IBCS2_PIO_KEYMAP: /* Set keyboard map table */
628 SCARG(uap, cmd) = PIO_KEYMAP;
| 667
668 case IBCS2_PIO_KEYMAP: /* Set keyboard map table */
669 SCARG(uap, cmd) = PIO_KEYMAP;
|
629 return ioctl(td, (struct ioctl_args *)uap);
| 670 error = ioctl(td, (struct ioctl_args *)uap);
671 break;
|
630
631 /* socksys */
632 case IBCS2_SIOCSOCKSYS:
| 672
673 /* socksys */
674 case IBCS2_SIOCSOCKSYS:
|
633 return ibcs2_socksys(td, (struct ibcs2_socksys_args *)uap);
| 675 error = ibcs2_socksys(td, (struct ibcs2_socksys_args *)uap);
676 break;
|
634
635 case IBCS2_FIONREAD:
636 case IBCS2_I_NREAD: /* STREAMS */
637 SCARG(uap, cmd) = FIONREAD;
| 677
678 case IBCS2_FIONREAD:
679 case IBCS2_I_NREAD: /* STREAMS */
680 SCARG(uap, cmd) = FIONREAD;
|
638 return ioctl(td, (struct ioctl_args *)uap);
| 681 error = ioctl(td, (struct ioctl_args *)uap);
682 break;
|
639
640 default:
641 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
642 td->proc->p_pid, SCARG(uap, cmd)));
| 683
684 default:
685 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
686 td->proc->p_pid, SCARG(uap, cmd)));
|
643 return ENOSYS;
| 687 error = ENOSYS;
688 break;
|
644 }
| 689 }
|
645 return ENOSYS;
| 690
691 fdrop(fp, td);
692 return error;
|
646}
| 693}
|