Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/char/vme_scc.c: MVME147, MVME162, BVME6000 SCC serial ports | |
3 | * implementation. | |
4 | * Copyright 1999 Richard Hirst <richard@sleepie.demon.co.uk> | |
5 | * | |
6 | * Based on atari_SCC.c which was | |
7 | * Copyright 1994-95 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> | |
8 | * Partially based on PC-Linux serial.c by Linus Torvalds and Theodore Ts'o | |
9 | * | |
10 | * This file is subject to the terms and conditions of the GNU General Public | |
11 | * License. See the file COPYING in the main directory of this archive | |
12 | * for more details. | |
13 | * | |
14 | */ | |
15 | ||
16 | #include <linux/module.h> | |
1da177e4 LT |
17 | #include <linux/kdev_t.h> |
18 | #include <asm/io.h> | |
19 | #include <linux/kernel.h> | |
1da177e4 LT |
20 | #include <linux/ioport.h> |
21 | #include <linux/interrupt.h> | |
22 | #include <linux/errno.h> | |
23 | #include <linux/tty.h> | |
24 | #include <linux/tty_flip.h> | |
25 | #include <linux/mm.h> | |
26 | #include <linux/serial.h> | |
27 | #include <linux/fcntl.h> | |
28 | #include <linux/major.h> | |
29 | #include <linux/delay.h> | |
30 | #include <linux/slab.h> | |
31 | #include <linux/miscdevice.h> | |
32 | #include <linux/console.h> | |
33 | #include <linux/init.h> | |
34 | #include <asm/setup.h> | |
35 | #include <asm/bootinfo.h> | |
36 | ||
37 | #ifdef CONFIG_MVME147_SCC | |
38 | #include <asm/mvme147hw.h> | |
39 | #endif | |
40 | #ifdef CONFIG_MVME162_SCC | |
41 | #include <asm/mvme16xhw.h> | |
42 | #endif | |
43 | #ifdef CONFIG_BVME6000_SCC | |
44 | #include <asm/bvme6000hw.h> | |
45 | #endif | |
46 | ||
47 | #include <linux/generic_serial.h> | |
48 | #include "scc.h" | |
49 | ||
50 | ||
51 | #define CHANNEL_A 0 | |
52 | #define CHANNEL_B 1 | |
53 | ||
54 | #define SCC_MINOR_BASE 64 | |
55 | ||
56 | /* Shadows for all SCC write registers */ | |
57 | static unsigned char scc_shadow[2][16]; | |
58 | ||
59 | /* Location to access for SCC register access delay */ | |
60 | static volatile unsigned char *scc_del = NULL; | |
61 | ||
62 | /* To keep track of STATUS_REG state for detection of Ext/Status int source */ | |
63 | static unsigned char scc_last_status_reg[2]; | |
64 | ||
65 | /***************************** Prototypes *****************************/ | |
66 | ||
67 | /* Function prototypes */ | |
68 | static void scc_disable_tx_interrupts(void * ptr); | |
69 | static void scc_enable_tx_interrupts(void * ptr); | |
70 | static void scc_disable_rx_interrupts(void * ptr); | |
71 | static void scc_enable_rx_interrupts(void * ptr); | |
31f35939 | 72 | static int scc_carrier_raised(struct tty_port *port); |
1da177e4 LT |
73 | static void scc_shutdown_port(void * ptr); |
74 | static int scc_set_real_termios(void *ptr); | |
75 | static void scc_hungup(void *ptr); | |
76 | static void scc_close(void *ptr); | |
77 | static int scc_chars_in_buffer(void * ptr); | |
78 | static int scc_open(struct tty_struct * tty, struct file * filp); | |
79 | static int scc_ioctl(struct tty_struct * tty, struct file * filp, | |
80 | unsigned int cmd, unsigned long arg); | |
81 | static void scc_throttle(struct tty_struct *tty); | |
82 | static void scc_unthrottle(struct tty_struct *tty); | |
7d12e780 DH |
83 | static irqreturn_t scc_tx_int(int irq, void *data); |
84 | static irqreturn_t scc_rx_int(int irq, void *data); | |
85 | static irqreturn_t scc_stat_int(int irq, void *data); | |
86 | static irqreturn_t scc_spcond_int(int irq, void *data); | |
1da177e4 | 87 | static void scc_setsignals(struct scc_port *port, int dtr, int rts); |
9e98966c | 88 | static int scc_break_ctl(struct tty_struct *tty, int break_state); |
1da177e4 LT |
89 | |
90 | static struct tty_driver *scc_driver; | |
91 | ||
eb4db450 | 92 | static struct scc_port scc_ports[2]; |
1da177e4 LT |
93 | |
94 | /*--------------------------------------------------------------------------- | |
95 | * Interface from generic_serial.c back here | |
96 | *--------------------------------------------------------------------------*/ | |
97 | ||
98 | static struct real_driver scc_real_driver = { | |
99 | scc_disable_tx_interrupts, | |
100 | scc_enable_tx_interrupts, | |
101 | scc_disable_rx_interrupts, | |
102 | scc_enable_rx_interrupts, | |
1da177e4 LT |
103 | scc_shutdown_port, |
104 | scc_set_real_termios, | |
105 | scc_chars_in_buffer, | |
106 | scc_close, | |
107 | scc_hungup, | |
108 | NULL | |
109 | }; | |
110 | ||
111 | ||
b68e31d0 | 112 | static const struct tty_operations scc_ops = { |
1da177e4 LT |
113 | .open = scc_open, |
114 | .close = gs_close, | |
115 | .write = gs_write, | |
116 | .put_char = gs_put_char, | |
117 | .flush_chars = gs_flush_chars, | |
118 | .write_room = gs_write_room, | |
119 | .chars_in_buffer = gs_chars_in_buffer, | |
120 | .flush_buffer = gs_flush_buffer, | |
121 | .ioctl = scc_ioctl, | |
122 | .throttle = scc_throttle, | |
123 | .unthrottle = scc_unthrottle, | |
124 | .set_termios = gs_set_termios, | |
125 | .stop = gs_stop, | |
126 | .start = gs_start, | |
127 | .hangup = gs_hangup, | |
128 | .break_ctl = scc_break_ctl, | |
129 | }; | |
130 | ||
31f35939 AC |
131 | static const struct tty_port_operations scc_port_ops = { |
132 | .carrier_raised = scc_carrier_raised, | |
133 | }; | |
134 | ||
1da177e4 LT |
135 | /*---------------------------------------------------------------------------- |
136 | * vme_scc_init() and support functions | |
137 | *---------------------------------------------------------------------------*/ | |
138 | ||
eb054e3b | 139 | static int __init scc_init_drivers(void) |
1da177e4 LT |
140 | { |
141 | int error; | |
142 | ||
143 | scc_driver = alloc_tty_driver(2); | |
144 | if (!scc_driver) | |
145 | return -ENOMEM; | |
146 | scc_driver->owner = THIS_MODULE; | |
147 | scc_driver->driver_name = "scc"; | |
148 | scc_driver->name = "ttyS"; | |
1da177e4 LT |
149 | scc_driver->major = TTY_MAJOR; |
150 | scc_driver->minor_start = SCC_MINOR_BASE; | |
151 | scc_driver->type = TTY_DRIVER_TYPE_SERIAL; | |
152 | scc_driver->subtype = SERIAL_TYPE_NORMAL; | |
153 | scc_driver->init_termios = tty_std_termios; | |
154 | scc_driver->init_termios.c_cflag = | |
155 | B9600 | CS8 | CREAD | HUPCL | CLOCAL; | |
606d099c AC |
156 | scc_driver->init_termios.c_ispeed = 9600; |
157 | scc_driver->init_termios.c_ospeed = 9600; | |
1da177e4 LT |
158 | scc_driver->flags = TTY_DRIVER_REAL_RAW; |
159 | tty_set_operations(scc_driver, &scc_ops); | |
160 | ||
161 | if ((error = tty_register_driver(scc_driver))) { | |
162 | printk(KERN_ERR "scc: Couldn't register scc driver, error = %d\n", | |
163 | error); | |
164 | put_tty_driver(scc_driver); | |
165 | return 1; | |
166 | } | |
167 | ||
168 | return 0; | |
169 | } | |
170 | ||
171 | ||
172 | /* ports[] array is indexed by line no (i.e. [0] for ttyS0, [1] for ttyS1). | |
173 | */ | |
174 | ||
eb054e3b | 175 | static void __init scc_init_portstructs(void) |
1da177e4 LT |
176 | { |
177 | struct scc_port *port; | |
178 | int i; | |
179 | ||
180 | for (i = 0; i < 2; i++) { | |
181 | port = scc_ports + i; | |
31f35939 AC |
182 | tty_port_init(&port->gs.port); |
183 | port->gs.port.ops = &scc_port_ops; | |
1da177e4 LT |
184 | port->gs.magic = SCC_MAGIC; |
185 | port->gs.close_delay = HZ/2; | |
186 | port->gs.closing_wait = 30 * HZ; | |
187 | port->gs.rd = &scc_real_driver; | |
188 | #ifdef NEW_WRITE_LOCKING | |
81861d78 | 189 | port->gs.port_write_mutex = MUTEX; |
1da177e4 | 190 | #endif |
732730d4 GU |
191 | init_waitqueue_head(&port->gs.port.open_wait); |
192 | init_waitqueue_head(&port->gs.port.close_wait); | |
1da177e4 LT |
193 | } |
194 | } | |
195 | ||
196 | ||
197 | #ifdef CONFIG_MVME147_SCC | |
eb054e3b | 198 | static int __init mvme147_scc_init(void) |
1da177e4 LT |
199 | { |
200 | struct scc_port *port; | |
c36a4e40 | 201 | int error; |
1da177e4 LT |
202 | |
203 | printk(KERN_INFO "SCC: MVME147 Serial Driver\n"); | |
204 | /* Init channel A */ | |
205 | port = &scc_ports[0]; | |
206 | port->channel = CHANNEL_A; | |
207 | port->ctrlp = (volatile unsigned char *)M147_SCC_A_ADDR; | |
208 | port->datap = port->ctrlp + 1; | |
209 | port->port_a = &scc_ports[0]; | |
210 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 211 | error = request_irq(MVME147_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 212 | "SCC-A TX", port); |
c36a4e40 GU |
213 | if (error) |
214 | goto fail; | |
215 | error = request_irq(MVME147_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 216 | "SCC-A status", port); |
c36a4e40 GU |
217 | if (error) |
218 | goto fail_free_a_tx; | |
219 | error = request_irq(MVME147_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 220 | "SCC-A RX", port); |
c36a4e40 GU |
221 | if (error) |
222 | goto fail_free_a_stat; | |
223 | error = request_irq(MVME147_IRQ_SCCA_SPCOND, scc_spcond_int, | |
224 | IRQF_DISABLED, "SCC-A special cond", port); | |
225 | if (error) | |
226 | goto fail_free_a_rx; | |
227 | ||
1da177e4 LT |
228 | { |
229 | SCC_ACCESS_INIT(port); | |
230 | ||
231 | /* disable interrupts for this channel */ | |
232 | SCCwrite(INT_AND_DMA_REG, 0); | |
233 | /* Set the interrupt vector */ | |
234 | SCCwrite(INT_VECTOR_REG, MVME147_IRQ_SCC_BASE); | |
235 | /* Interrupt parameters: vector includes status, status low */ | |
236 | SCCwrite(MASTER_INT_CTRL, MIC_VEC_INCL_STAT); | |
237 | SCCmod(MASTER_INT_CTRL, 0xff, MIC_MASTER_INT_ENAB); | |
238 | } | |
239 | ||
240 | /* Init channel B */ | |
241 | port = &scc_ports[1]; | |
242 | port->channel = CHANNEL_B; | |
243 | port->ctrlp = (volatile unsigned char *)M147_SCC_B_ADDR; | |
244 | port->datap = port->ctrlp + 1; | |
245 | port->port_a = &scc_ports[0]; | |
246 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 247 | error = request_irq(MVME147_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 248 | "SCC-B TX", port); |
c36a4e40 GU |
249 | if (error) |
250 | goto fail_free_a_spcond; | |
251 | error = request_irq(MVME147_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 252 | "SCC-B status", port); |
c36a4e40 GU |
253 | if (error) |
254 | goto fail_free_b_tx; | |
255 | error = request_irq(MVME147_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 256 | "SCC-B RX", port); |
c36a4e40 GU |
257 | if (error) |
258 | goto fail_free_b_stat; | |
259 | error = request_irq(MVME147_IRQ_SCCB_SPCOND, scc_spcond_int, | |
260 | IRQF_DISABLED, "SCC-B special cond", port); | |
261 | if (error) | |
262 | goto fail_free_b_rx; | |
263 | ||
1da177e4 LT |
264 | { |
265 | SCC_ACCESS_INIT(port); | |
266 | ||
267 | /* disable interrupts for this channel */ | |
268 | SCCwrite(INT_AND_DMA_REG, 0); | |
269 | } | |
270 | ||
271 | /* Ensure interrupts are enabled in the PCC chip */ | |
272 | m147_pcc->serial_cntrl=PCC_LEVEL_SERIAL|PCC_INT_ENAB; | |
273 | ||
274 | /* Initialise the tty driver structures and register */ | |
275 | scc_init_portstructs(); | |
276 | scc_init_drivers(); | |
277 | ||
278 | return 0; | |
c36a4e40 GU |
279 | |
280 | fail_free_b_rx: | |
281 | free_irq(MVME147_IRQ_SCCB_RX, port); | |
282 | fail_free_b_stat: | |
283 | free_irq(MVME147_IRQ_SCCB_STAT, port); | |
284 | fail_free_b_tx: | |
285 | free_irq(MVME147_IRQ_SCCB_TX, port); | |
286 | fail_free_a_spcond: | |
287 | free_irq(MVME147_IRQ_SCCA_SPCOND, port); | |
288 | fail_free_a_rx: | |
289 | free_irq(MVME147_IRQ_SCCA_RX, port); | |
290 | fail_free_a_stat: | |
291 | free_irq(MVME147_IRQ_SCCA_STAT, port); | |
292 | fail_free_a_tx: | |
293 | free_irq(MVME147_IRQ_SCCA_TX, port); | |
294 | fail: | |
295 | return error; | |
1da177e4 LT |
296 | } |
297 | #endif | |
298 | ||
299 | ||
300 | #ifdef CONFIG_MVME162_SCC | |
eb054e3b | 301 | static int __init mvme162_scc_init(void) |
1da177e4 LT |
302 | { |
303 | struct scc_port *port; | |
c36a4e40 | 304 | int error; |
1da177e4 LT |
305 | |
306 | if (!(mvme16x_config & MVME16x_CONFIG_GOT_SCCA)) | |
307 | return (-ENODEV); | |
308 | ||
309 | printk(KERN_INFO "SCC: MVME162 Serial Driver\n"); | |
310 | /* Init channel A */ | |
311 | port = &scc_ports[0]; | |
312 | port->channel = CHANNEL_A; | |
313 | port->ctrlp = (volatile unsigned char *)MVME_SCC_A_ADDR; | |
314 | port->datap = port->ctrlp + 2; | |
315 | port->port_a = &scc_ports[0]; | |
316 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 317 | error = request_irq(MVME162_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 318 | "SCC-A TX", port); |
c36a4e40 GU |
319 | if (error) |
320 | goto fail; | |
321 | error = request_irq(MVME162_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 322 | "SCC-A status", port); |
c36a4e40 GU |
323 | if (error) |
324 | goto fail_free_a_tx; | |
325 | error = request_irq(MVME162_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 326 | "SCC-A RX", port); |
c36a4e40 GU |
327 | if (error) |
328 | goto fail_free_a_stat; | |
329 | error = request_irq(MVME162_IRQ_SCCA_SPCOND, scc_spcond_int, | |
330 | IRQF_DISABLED, "SCC-A special cond", port); | |
331 | if (error) | |
332 | goto fail_free_a_rx; | |
333 | ||
1da177e4 LT |
334 | { |
335 | SCC_ACCESS_INIT(port); | |
336 | ||
337 | /* disable interrupts for this channel */ | |
338 | SCCwrite(INT_AND_DMA_REG, 0); | |
339 | /* Set the interrupt vector */ | |
340 | SCCwrite(INT_VECTOR_REG, MVME162_IRQ_SCC_BASE); | |
341 | /* Interrupt parameters: vector includes status, status low */ | |
342 | SCCwrite(MASTER_INT_CTRL, MIC_VEC_INCL_STAT); | |
343 | SCCmod(MASTER_INT_CTRL, 0xff, MIC_MASTER_INT_ENAB); | |
344 | } | |
345 | ||
346 | /* Init channel B */ | |
347 | port = &scc_ports[1]; | |
348 | port->channel = CHANNEL_B; | |
349 | port->ctrlp = (volatile unsigned char *)MVME_SCC_B_ADDR; | |
350 | port->datap = port->ctrlp + 2; | |
351 | port->port_a = &scc_ports[0]; | |
352 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 353 | error = request_irq(MVME162_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 354 | "SCC-B TX", port); |
c36a4e40 GU |
355 | if (error) |
356 | goto fail_free_a_spcond; | |
357 | error = request_irq(MVME162_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 358 | "SCC-B status", port); |
c36a4e40 GU |
359 | if (error) |
360 | goto fail_free_b_tx; | |
361 | error = request_irq(MVME162_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 362 | "SCC-B RX", port); |
c36a4e40 GU |
363 | if (error) |
364 | goto fail_free_b_stat; | |
365 | error = request_irq(MVME162_IRQ_SCCB_SPCOND, scc_spcond_int, | |
366 | IRQF_DISABLED, "SCC-B special cond", port); | |
367 | if (error) | |
368 | goto fail_free_b_rx; | |
1da177e4 LT |
369 | |
370 | { | |
371 | SCC_ACCESS_INIT(port); /* Either channel will do */ | |
372 | ||
373 | /* disable interrupts for this channel */ | |
374 | SCCwrite(INT_AND_DMA_REG, 0); | |
375 | } | |
376 | ||
377 | /* Ensure interrupts are enabled in the MC2 chip */ | |
378 | *(volatile char *)0xfff4201d = 0x14; | |
379 | ||
380 | /* Initialise the tty driver structures and register */ | |
381 | scc_init_portstructs(); | |
382 | scc_init_drivers(); | |
383 | ||
384 | return 0; | |
c36a4e40 GU |
385 | |
386 | fail_free_b_rx: | |
387 | free_irq(MVME162_IRQ_SCCB_RX, port); | |
388 | fail_free_b_stat: | |
389 | free_irq(MVME162_IRQ_SCCB_STAT, port); | |
390 | fail_free_b_tx: | |
391 | free_irq(MVME162_IRQ_SCCB_TX, port); | |
392 | fail_free_a_spcond: | |
393 | free_irq(MVME162_IRQ_SCCA_SPCOND, port); | |
394 | fail_free_a_rx: | |
395 | free_irq(MVME162_IRQ_SCCA_RX, port); | |
396 | fail_free_a_stat: | |
397 | free_irq(MVME162_IRQ_SCCA_STAT, port); | |
398 | fail_free_a_tx: | |
399 | free_irq(MVME162_IRQ_SCCA_TX, port); | |
400 | fail: | |
401 | return error; | |
1da177e4 LT |
402 | } |
403 | #endif | |
404 | ||
405 | ||
406 | #ifdef CONFIG_BVME6000_SCC | |
eb054e3b | 407 | static int __init bvme6000_scc_init(void) |
1da177e4 LT |
408 | { |
409 | struct scc_port *port; | |
c36a4e40 | 410 | int error; |
1da177e4 LT |
411 | |
412 | printk(KERN_INFO "SCC: BVME6000 Serial Driver\n"); | |
413 | /* Init channel A */ | |
414 | port = &scc_ports[0]; | |
415 | port->channel = CHANNEL_A; | |
416 | port->ctrlp = (volatile unsigned char *)BVME_SCC_A_ADDR; | |
417 | port->datap = port->ctrlp + 4; | |
418 | port->port_a = &scc_ports[0]; | |
419 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 420 | error = request_irq(BVME_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 421 | "SCC-A TX", port); |
c36a4e40 GU |
422 | if (error) |
423 | goto fail; | |
424 | error = request_irq(BVME_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 425 | "SCC-A status", port); |
c36a4e40 GU |
426 | if (error) |
427 | goto fail_free_a_tx; | |
428 | error = request_irq(BVME_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 429 | "SCC-A RX", port); |
c36a4e40 GU |
430 | if (error) |
431 | goto fail_free_a_stat; | |
432 | error = request_irq(BVME_IRQ_SCCA_SPCOND, scc_spcond_int, | |
433 | IRQF_DISABLED, "SCC-A special cond", port); | |
434 | if (error) | |
435 | goto fail_free_a_rx; | |
436 | ||
1da177e4 LT |
437 | { |
438 | SCC_ACCESS_INIT(port); | |
439 | ||
440 | /* disable interrupts for this channel */ | |
441 | SCCwrite(INT_AND_DMA_REG, 0); | |
442 | /* Set the interrupt vector */ | |
443 | SCCwrite(INT_VECTOR_REG, BVME_IRQ_SCC_BASE); | |
444 | /* Interrupt parameters: vector includes status, status low */ | |
445 | SCCwrite(MASTER_INT_CTRL, MIC_VEC_INCL_STAT); | |
446 | SCCmod(MASTER_INT_CTRL, 0xff, MIC_MASTER_INT_ENAB); | |
447 | } | |
448 | ||
449 | /* Init channel B */ | |
450 | port = &scc_ports[1]; | |
451 | port->channel = CHANNEL_B; | |
452 | port->ctrlp = (volatile unsigned char *)BVME_SCC_B_ADDR; | |
453 | port->datap = port->ctrlp + 4; | |
454 | port->port_a = &scc_ports[0]; | |
455 | port->port_b = &scc_ports[1]; | |
c36a4e40 | 456 | error = request_irq(BVME_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED, |
1da177e4 | 457 | "SCC-B TX", port); |
c36a4e40 GU |
458 | if (error) |
459 | goto fail_free_a_spcond; | |
460 | error = request_irq(BVME_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED, | |
1da177e4 | 461 | "SCC-B status", port); |
c36a4e40 GU |
462 | if (error) |
463 | goto fail_free_b_tx; | |
464 | error = request_irq(BVME_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED, | |
1da177e4 | 465 | "SCC-B RX", port); |
c36a4e40 GU |
466 | if (error) |
467 | goto fail_free_b_stat; | |
468 | error = request_irq(BVME_IRQ_SCCB_SPCOND, scc_spcond_int, | |
469 | IRQF_DISABLED, "SCC-B special cond", port); | |
470 | if (error) | |
471 | goto fail_free_b_rx; | |
1da177e4 LT |
472 | |
473 | { | |
474 | SCC_ACCESS_INIT(port); /* Either channel will do */ | |
475 | ||
476 | /* disable interrupts for this channel */ | |
477 | SCCwrite(INT_AND_DMA_REG, 0); | |
478 | } | |
479 | ||
480 | /* Initialise the tty driver structures and register */ | |
481 | scc_init_portstructs(); | |
482 | scc_init_drivers(); | |
483 | ||
484 | return 0; | |
c36a4e40 GU |
485 | |
486 | fail: | |
487 | free_irq(BVME_IRQ_SCCA_STAT, port); | |
488 | fail_free_a_tx: | |
489 | free_irq(BVME_IRQ_SCCA_RX, port); | |
490 | fail_free_a_stat: | |
491 | free_irq(BVME_IRQ_SCCA_SPCOND, port); | |
492 | fail_free_a_rx: | |
493 | free_irq(BVME_IRQ_SCCB_TX, port); | |
494 | fail_free_a_spcond: | |
495 | free_irq(BVME_IRQ_SCCB_STAT, port); | |
496 | fail_free_b_tx: | |
497 | free_irq(BVME_IRQ_SCCB_RX, port); | |
498 | fail_free_b_stat: | |
499 | free_irq(BVME_IRQ_SCCB_SPCOND, port); | |
500 | fail_free_b_rx: | |
501 | return error; | |
1da177e4 LT |
502 | } |
503 | #endif | |
504 | ||
505 | ||
eb054e3b | 506 | static int __init vme_scc_init(void) |
1da177e4 LT |
507 | { |
508 | int res = -ENODEV; | |
509 | ||
510 | #ifdef CONFIG_MVME147_SCC | |
511 | if (MACH_IS_MVME147) | |
512 | res = mvme147_scc_init(); | |
513 | #endif | |
514 | #ifdef CONFIG_MVME162_SCC | |
515 | if (MACH_IS_MVME16x) | |
516 | res = mvme162_scc_init(); | |
517 | #endif | |
518 | #ifdef CONFIG_BVME6000_SCC | |
519 | if (MACH_IS_BVME6000) | |
520 | res = bvme6000_scc_init(); | |
521 | #endif | |
522 | return res; | |
523 | } | |
524 | ||
525 | module_init(vme_scc_init); | |
526 | ||
527 | ||
528 | /*--------------------------------------------------------------------------- | |
529 | * Interrupt handlers | |
530 | *--------------------------------------------------------------------------*/ | |
531 | ||
7d12e780 | 532 | static irqreturn_t scc_rx_int(int irq, void *data) |
1da177e4 LT |
533 | { |
534 | unsigned char ch; | |
535 | struct scc_port *port = data; | |
732730d4 | 536 | struct tty_struct *tty = port->gs.port.tty; |
1da177e4 LT |
537 | SCC_ACCESS_INIT(port); |
538 | ||
539 | ch = SCCread_NB(RX_DATA_REG); | |
540 | if (!tty) { | |
541 | printk(KERN_WARNING "scc_rx_int with NULL tty!\n"); | |
542 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
543 | return IRQ_HANDLED; | |
544 | } | |
33f0f88f | 545 | tty_insert_flip_char(tty, ch, 0); |
1da177e4 LT |
546 | |
547 | /* Check if another character is already ready; in that case, the | |
548 | * spcond_int() function must be used, because this character may have an | |
549 | * error condition that isn't signalled by the interrupt vector used! | |
550 | */ | |
551 | if (SCCread(INT_PENDING_REG) & | |
552 | (port->channel == CHANNEL_A ? IPR_A_RX : IPR_B_RX)) { | |
7d12e780 | 553 | scc_spcond_int (irq, data); |
1da177e4 LT |
554 | return IRQ_HANDLED; |
555 | } | |
556 | ||
557 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
558 | ||
559 | tty_flip_buffer_push(tty); | |
560 | return IRQ_HANDLED; | |
561 | } | |
562 | ||
563 | ||
7d12e780 | 564 | static irqreturn_t scc_spcond_int(int irq, void *data) |
1da177e4 LT |
565 | { |
566 | struct scc_port *port = data; | |
732730d4 | 567 | struct tty_struct *tty = port->gs.port.tty; |
1da177e4 LT |
568 | unsigned char stat, ch, err; |
569 | int int_pending_mask = port->channel == CHANNEL_A ? | |
570 | IPR_A_RX : IPR_B_RX; | |
571 | SCC_ACCESS_INIT(port); | |
572 | ||
573 | if (!tty) { | |
574 | printk(KERN_WARNING "scc_spcond_int with NULL tty!\n"); | |
575 | SCCwrite(COMMAND_REG, CR_ERROR_RESET); | |
576 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
577 | return IRQ_HANDLED; | |
578 | } | |
579 | do { | |
580 | stat = SCCread(SPCOND_STATUS_REG); | |
581 | ch = SCCread_NB(RX_DATA_REG); | |
582 | ||
583 | if (stat & SCSR_RX_OVERRUN) | |
584 | err = TTY_OVERRUN; | |
585 | else if (stat & SCSR_PARITY_ERR) | |
586 | err = TTY_PARITY; | |
587 | else if (stat & SCSR_CRC_FRAME_ERR) | |
588 | err = TTY_FRAME; | |
589 | else | |
590 | err = 0; | |
591 | ||
33f0f88f | 592 | tty_insert_flip_char(tty, ch, err); |
1da177e4 LT |
593 | |
594 | /* ++TeSche: *All* errors have to be cleared manually, | |
595 | * else the condition persists for the next chars | |
596 | */ | |
597 | if (err) | |
598 | SCCwrite(COMMAND_REG, CR_ERROR_RESET); | |
599 | ||
600 | } while(SCCread(INT_PENDING_REG) & int_pending_mask); | |
601 | ||
602 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
603 | ||
604 | tty_flip_buffer_push(tty); | |
605 | return IRQ_HANDLED; | |
606 | } | |
607 | ||
608 | ||
7d12e780 | 609 | static irqreturn_t scc_tx_int(int irq, void *data) |
1da177e4 LT |
610 | { |
611 | struct scc_port *port = data; | |
612 | SCC_ACCESS_INIT(port); | |
613 | ||
732730d4 | 614 | if (!port->gs.port.tty) { |
1da177e4 LT |
615 | printk(KERN_WARNING "scc_tx_int with NULL tty!\n"); |
616 | SCCmod (INT_AND_DMA_REG, ~IDR_TX_INT_ENAB, 0); | |
617 | SCCwrite(COMMAND_REG, CR_TX_PENDING_RESET); | |
618 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
619 | return IRQ_HANDLED; | |
620 | } | |
621 | while ((SCCread_NB(STATUS_REG) & SR_TX_BUF_EMPTY)) { | |
622 | if (port->x_char) { | |
623 | SCCwrite(TX_DATA_REG, port->x_char); | |
624 | port->x_char = 0; | |
625 | } | |
732730d4 GU |
626 | else if ((port->gs.xmit_cnt <= 0) || |
627 | port->gs.port.tty->stopped || | |
628 | port->gs.port.tty->hw_stopped) | |
1da177e4 LT |
629 | break; |
630 | else { | |
631 | SCCwrite(TX_DATA_REG, port->gs.xmit_buf[port->gs.xmit_tail++]); | |
632 | port->gs.xmit_tail = port->gs.xmit_tail & (SERIAL_XMIT_SIZE-1); | |
633 | if (--port->gs.xmit_cnt <= 0) | |
634 | break; | |
635 | } | |
636 | } | |
732730d4 GU |
637 | if ((port->gs.xmit_cnt <= 0) || port->gs.port.tty->stopped || |
638 | port->gs.port.tty->hw_stopped) { | |
1da177e4 LT |
639 | /* disable tx interrupts */ |
640 | SCCmod (INT_AND_DMA_REG, ~IDR_TX_INT_ENAB, 0); | |
641 | SCCwrite(COMMAND_REG, CR_TX_PENDING_RESET); /* disable tx_int on next tx underrun? */ | |
732730d4 | 642 | port->gs.port.flags &= ~GS_TX_INTEN; |
1da177e4 | 643 | } |
732730d4 GU |
644 | if (port->gs.port.tty && port->gs.xmit_cnt <= port->gs.wakeup_chars) |
645 | tty_wakeup(port->gs.port.tty); | |
1da177e4 LT |
646 | |
647 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
648 | return IRQ_HANDLED; | |
649 | } | |
650 | ||
651 | ||
7d12e780 | 652 | static irqreturn_t scc_stat_int(int irq, void *data) |
1da177e4 LT |
653 | { |
654 | struct scc_port *port = data; | |
655 | unsigned channel = port->channel; | |
656 | unsigned char last_sr, sr, changed; | |
657 | SCC_ACCESS_INIT(port); | |
658 | ||
659 | last_sr = scc_last_status_reg[channel]; | |
660 | sr = scc_last_status_reg[channel] = SCCread_NB(STATUS_REG); | |
661 | changed = last_sr ^ sr; | |
662 | ||
663 | if (changed & SR_DCD) { | |
664 | port->c_dcd = !!(sr & SR_DCD); | |
732730d4 | 665 | if (!(port->gs.port.flags & ASYNC_CHECK_CD)) |
1da177e4 LT |
666 | ; /* Don't report DCD changes */ |
667 | else if (port->c_dcd) { | |
732730d4 | 668 | wake_up_interruptible(&port->gs.port.open_wait); |
1da177e4 LT |
669 | } |
670 | else { | |
732730d4 GU |
671 | if (port->gs.port.tty) |
672 | tty_hangup (port->gs.port.tty); | |
1da177e4 LT |
673 | } |
674 | } | |
675 | SCCwrite(COMMAND_REG, CR_EXTSTAT_RESET); | |
676 | SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET); | |
677 | return IRQ_HANDLED; | |
678 | } | |
679 | ||
680 | ||
681 | /*--------------------------------------------------------------------------- | |
682 | * generic_serial.c callback funtions | |
683 | *--------------------------------------------------------------------------*/ | |
684 | ||
685 | static void scc_disable_tx_interrupts(void *ptr) | |
686 | { | |
687 | struct scc_port *port = ptr; | |
688 | unsigned long flags; | |
689 | SCC_ACCESS_INIT(port); | |
690 | ||
691 | local_irq_save(flags); | |
692 | SCCmod(INT_AND_DMA_REG, ~IDR_TX_INT_ENAB, 0); | |
732730d4 | 693 | port->gs.port.flags &= ~GS_TX_INTEN; |
1da177e4 LT |
694 | local_irq_restore(flags); |
695 | } | |
696 | ||
697 | ||
698 | static void scc_enable_tx_interrupts(void *ptr) | |
699 | { | |
700 | struct scc_port *port = ptr; | |
701 | unsigned long flags; | |
702 | SCC_ACCESS_INIT(port); | |
703 | ||
704 | local_irq_save(flags); | |
705 | SCCmod(INT_AND_DMA_REG, 0xff, IDR_TX_INT_ENAB); | |
706 | /* restart the transmitter */ | |
2850bc27 | 707 | scc_tx_int (0, port); |
1da177e4 LT |
708 | local_irq_restore(flags); |
709 | } | |
710 | ||
711 | ||
712 | static void scc_disable_rx_interrupts(void *ptr) | |
713 | { | |
714 | struct scc_port *port = ptr; | |
715 | unsigned long flags; | |
716 | SCC_ACCESS_INIT(port); | |
717 | ||
718 | local_irq_save(flags); | |
719 | SCCmod(INT_AND_DMA_REG, | |
720 | ~(IDR_RX_INT_MASK|IDR_PARERR_AS_SPCOND|IDR_EXTSTAT_INT_ENAB), 0); | |
721 | local_irq_restore(flags); | |
722 | } | |
723 | ||
724 | ||
725 | static void scc_enable_rx_interrupts(void *ptr) | |
726 | { | |
727 | struct scc_port *port = ptr; | |
728 | unsigned long flags; | |
729 | SCC_ACCESS_INIT(port); | |
730 | ||
731 | local_irq_save(flags); | |
732 | SCCmod(INT_AND_DMA_REG, 0xff, | |
733 | IDR_EXTSTAT_INT_ENAB|IDR_PARERR_AS_SPCOND|IDR_RX_INT_ALL); | |
734 | local_irq_restore(flags); | |
735 | } | |
736 | ||
737 | ||
31f35939 | 738 | static int scc_carrier_raised(struct tty_port *port) |
1da177e4 | 739 | { |
36c621d8 AC |
740 | struct scc_port *sc = container_of(port, struct scc_port, gs.port); |
741 | unsigned channel = sc->channel; | |
1da177e4 LT |
742 | |
743 | return !!(scc_last_status_reg[channel] & SR_DCD); | |
744 | } | |
745 | ||
746 | ||
747 | static void scc_shutdown_port(void *ptr) | |
748 | { | |
749 | struct scc_port *port = ptr; | |
750 | ||
732730d4 | 751 | port->gs.port.flags &= ~ GS_ACTIVE; |
36c621d8 | 752 | if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) { |
1da177e4 LT |
753 | scc_setsignals (port, 0, 0); |
754 | } | |
755 | } | |
756 | ||
757 | ||
758 | static int scc_set_real_termios (void *ptr) | |
759 | { | |
760 | /* the SCC has char sizes 5,7,6,8 in that order! */ | |
761 | static int chsize_map[4] = { 0, 2, 1, 3 }; | |
762 | unsigned cflag, baud, chsize, channel, brgval = 0; | |
763 | unsigned long flags; | |
764 | struct scc_port *port = ptr; | |
765 | SCC_ACCESS_INIT(port); | |
766 | ||
732730d4 | 767 | if (!port->gs.port.tty || !port->gs.port.tty->termios) return 0; |
1da177e4 LT |
768 | |
769 | channel = port->channel; | |
770 | ||
771 | if (channel == CHANNEL_A) | |
772 | return 0; /* Settings controlled by boot PROM */ | |
773 | ||
732730d4 | 774 | cflag = port->gs.port.tty->termios->c_cflag; |
1da177e4 LT |
775 | baud = port->gs.baud; |
776 | chsize = (cflag & CSIZE) >> 4; | |
777 | ||
778 | if (baud == 0) { | |
779 | /* speed == 0 -> drop DTR */ | |
780 | local_irq_save(flags); | |
781 | SCCmod(TX_CTRL_REG, ~TCR_DTR, 0); | |
782 | local_irq_restore(flags); | |
783 | return 0; | |
784 | } | |
785 | else if ((MACH_IS_MVME16x && (baud < 50 || baud > 38400)) || | |
786 | (MACH_IS_MVME147 && (baud < 50 || baud > 19200)) || | |
787 | (MACH_IS_BVME6000 &&(baud < 50 || baud > 76800))) { | |
788 | printk(KERN_NOTICE "SCC: Bad speed requested, %d\n", baud); | |
789 | return 0; | |
790 | } | |
791 | ||
792 | if (cflag & CLOCAL) | |
732730d4 | 793 | port->gs.port.flags &= ~ASYNC_CHECK_CD; |
1da177e4 | 794 | else |
732730d4 | 795 | port->gs.port.flags |= ASYNC_CHECK_CD; |
1da177e4 LT |
796 | |
797 | #ifdef CONFIG_MVME147_SCC | |
798 | if (MACH_IS_MVME147) | |
799 | brgval = (M147_SCC_PCLK + baud/2) / (16 * 2 * baud) - 2; | |
800 | #endif | |
801 | #ifdef CONFIG_MVME162_SCC | |
802 | if (MACH_IS_MVME16x) | |
803 | brgval = (MVME_SCC_PCLK + baud/2) / (16 * 2 * baud) - 2; | |
804 | #endif | |
805 | #ifdef CONFIG_BVME6000_SCC | |
806 | if (MACH_IS_BVME6000) | |
807 | brgval = (BVME_SCC_RTxC + baud/2) / (16 * 2 * baud) - 2; | |
808 | #endif | |
809 | /* Now we have all parameters and can go to set them: */ | |
810 | local_irq_save(flags); | |
811 | ||
812 | /* receiver's character size and auto-enables */ | |
813 | SCCmod(RX_CTRL_REG, ~(RCR_CHSIZE_MASK|RCR_AUTO_ENAB_MODE), | |
814 | (chsize_map[chsize] << 6) | | |
815 | ((cflag & CRTSCTS) ? RCR_AUTO_ENAB_MODE : 0)); | |
816 | /* parity and stop bits (both, Tx and Rx), clock mode never changes */ | |
817 | SCCmod (AUX1_CTRL_REG, | |
818 | ~(A1CR_PARITY_MASK | A1CR_MODE_MASK), | |
819 | ((cflag & PARENB | |
820 | ? (cflag & PARODD ? A1CR_PARITY_ODD : A1CR_PARITY_EVEN) | |
821 | : A1CR_PARITY_NONE) | |
822 | | (cflag & CSTOPB ? A1CR_MODE_ASYNC_2 : A1CR_MODE_ASYNC_1))); | |
823 | /* sender's character size, set DTR for valid baud rate */ | |
824 | SCCmod(TX_CTRL_REG, ~TCR_CHSIZE_MASK, chsize_map[chsize] << 5 | TCR_DTR); | |
825 | /* clock sources never change */ | |
826 | /* disable BRG before changing the value */ | |
827 | SCCmod(DPLL_CTRL_REG, ~DCR_BRG_ENAB, 0); | |
828 | /* BRG value */ | |
829 | SCCwrite(TIMER_LOW_REG, brgval & 0xff); | |
830 | SCCwrite(TIMER_HIGH_REG, (brgval >> 8) & 0xff); | |
831 | /* BRG enable, and clock source never changes */ | |
832 | SCCmod(DPLL_CTRL_REG, 0xff, DCR_BRG_ENAB); | |
833 | ||
834 | local_irq_restore(flags); | |
835 | ||
836 | return 0; | |
837 | } | |
838 | ||
839 | ||
840 | static int scc_chars_in_buffer (void *ptr) | |
841 | { | |
842 | struct scc_port *port = ptr; | |
843 | SCC_ACCESS_INIT(port); | |
844 | ||
845 | return (SCCread (SPCOND_STATUS_REG) & SCSR_ALL_SENT) ? 0 : 1; | |
846 | } | |
847 | ||
848 | ||
849 | /* Comment taken from sx.c (2.4.0): | |
850 | I haven't the foggiest why the decrement use count has to happen | |
851 | here. The whole linux serial drivers stuff needs to be redesigned. | |
852 | My guess is that this is a hack to minimize the impact of a bug | |
853 | elsewhere. Thinking about it some more. (try it sometime) Try | |
854 | running minicom on a serial port that is driven by a modularized | |
855 | driver. Have the modem hangup. Then remove the driver module. Then | |
856 | exit minicom. I expect an "oops". -- REW */ | |
857 | ||
858 | static void scc_hungup(void *ptr) | |
859 | { | |
860 | scc_disable_tx_interrupts(ptr); | |
861 | scc_disable_rx_interrupts(ptr); | |
862 | } | |
863 | ||
864 | ||
865 | static void scc_close(void *ptr) | |
866 | { | |
867 | scc_disable_tx_interrupts(ptr); | |
868 | scc_disable_rx_interrupts(ptr); | |
869 | } | |
870 | ||
871 | ||
872 | /*--------------------------------------------------------------------------- | |
873 | * Internal support functions | |
874 | *--------------------------------------------------------------------------*/ | |
875 | ||
876 | static void scc_setsignals(struct scc_port *port, int dtr, int rts) | |
877 | { | |
878 | unsigned long flags; | |
879 | unsigned char t; | |
880 | SCC_ACCESS_INIT(port); | |
881 | ||
882 | local_irq_save(flags); | |
883 | t = SCCread(TX_CTRL_REG); | |
884 | if (dtr >= 0) t = dtr? (t | TCR_DTR): (t & ~TCR_DTR); | |
885 | if (rts >= 0) t = rts? (t | TCR_RTS): (t & ~TCR_RTS); | |
886 | SCCwrite(TX_CTRL_REG, t); | |
887 | local_irq_restore(flags); | |
888 | } | |
889 | ||
890 | ||
891 | static void scc_send_xchar(struct tty_struct *tty, char ch) | |
892 | { | |
c9f19e96 | 893 | struct scc_port *port = tty->driver_data; |
1da177e4 LT |
894 | |
895 | port->x_char = ch; | |
896 | if (ch) | |
897 | scc_enable_tx_interrupts(port); | |
898 | } | |
899 | ||
900 | ||
901 | /*--------------------------------------------------------------------------- | |
902 | * Driver entrypoints referenced from above | |
903 | *--------------------------------------------------------------------------*/ | |
904 | ||
905 | static int scc_open (struct tty_struct * tty, struct file * filp) | |
906 | { | |
907 | int line = tty->index; | |
908 | int retval; | |
909 | struct scc_port *port = &scc_ports[line]; | |
910 | int i, channel = port->channel; | |
911 | unsigned long flags; | |
912 | SCC_ACCESS_INIT(port); | |
913 | #if defined(CONFIG_MVME162_SCC) || defined(CONFIG_MVME147_SCC) | |
914 | static const struct { | |
915 | unsigned reg, val; | |
916 | } mvme_init_tab[] = { | |
917 | /* Values for MVME162 and MVME147 */ | |
918 | /* no parity, 1 stop bit, async, 1:16 */ | |
919 | { AUX1_CTRL_REG, A1CR_PARITY_NONE|A1CR_MODE_ASYNC_1|A1CR_CLKMODE_x16 }, | |
920 | /* parity error is special cond, ints disabled, no DMA */ | |
921 | { INT_AND_DMA_REG, IDR_PARERR_AS_SPCOND | IDR_RX_INT_DISAB }, | |
922 | /* Rx 8 bits/char, no auto enable, Rx off */ | |
923 | { RX_CTRL_REG, RCR_CHSIZE_8 }, | |
924 | /* DTR off, Tx 8 bits/char, RTS off, Tx off */ | |
925 | { TX_CTRL_REG, TCR_CHSIZE_8 }, | |
926 | /* special features off */ | |
927 | { AUX2_CTRL_REG, 0 }, | |
928 | { CLK_CTRL_REG, CCR_RXCLK_BRG | CCR_TXCLK_BRG }, | |
929 | { DPLL_CTRL_REG, DCR_BRG_ENAB | DCR_BRG_USE_PCLK }, | |
930 | /* Start Rx */ | |
931 | { RX_CTRL_REG, RCR_RX_ENAB | RCR_CHSIZE_8 }, | |
932 | /* Start Tx */ | |
933 | { TX_CTRL_REG, TCR_TX_ENAB | TCR_RTS | TCR_DTR | TCR_CHSIZE_8 }, | |
934 | /* Ext/Stat ints: DCD only */ | |
935 | { INT_CTRL_REG, ICR_ENAB_DCD_INT }, | |
936 | /* Reset Ext/Stat ints */ | |
937 | { COMMAND_REG, CR_EXTSTAT_RESET }, | |
938 | /* ...again */ | |
939 | { COMMAND_REG, CR_EXTSTAT_RESET }, | |
940 | }; | |
941 | #endif | |
942 | #if defined(CONFIG_BVME6000_SCC) | |
943 | static const struct { | |
944 | unsigned reg, val; | |
945 | } bvme_init_tab[] = { | |
946 | /* Values for BVME6000 */ | |
947 | /* no parity, 1 stop bit, async, 1:16 */ | |
948 | { AUX1_CTRL_REG, A1CR_PARITY_NONE|A1CR_MODE_ASYNC_1|A1CR_CLKMODE_x16 }, | |
949 | /* parity error is special cond, ints disabled, no DMA */ | |
950 | { INT_AND_DMA_REG, IDR_PARERR_AS_SPCOND | IDR_RX_INT_DISAB }, | |
951 | /* Rx 8 bits/char, no auto enable, Rx off */ | |
952 | { RX_CTRL_REG, RCR_CHSIZE_8 }, | |
953 | /* DTR off, Tx 8 bits/char, RTS off, Tx off */ | |
954 | { TX_CTRL_REG, TCR_CHSIZE_8 }, | |
955 | /* special features off */ | |
956 | { AUX2_CTRL_REG, 0 }, | |
957 | { CLK_CTRL_REG, CCR_RTxC_XTAL | CCR_RXCLK_BRG | CCR_TXCLK_BRG }, | |
958 | { DPLL_CTRL_REG, DCR_BRG_ENAB }, | |
959 | /* Start Rx */ | |
960 | { RX_CTRL_REG, RCR_RX_ENAB | RCR_CHSIZE_8 }, | |
961 | /* Start Tx */ | |
962 | { TX_CTRL_REG, TCR_TX_ENAB | TCR_RTS | TCR_DTR | TCR_CHSIZE_8 }, | |
963 | /* Ext/Stat ints: DCD only */ | |
964 | { INT_CTRL_REG, ICR_ENAB_DCD_INT }, | |
965 | /* Reset Ext/Stat ints */ | |
966 | { COMMAND_REG, CR_EXTSTAT_RESET }, | |
967 | /* ...again */ | |
968 | { COMMAND_REG, CR_EXTSTAT_RESET }, | |
969 | }; | |
970 | #endif | |
732730d4 | 971 | if (!(port->gs.port.flags & ASYNC_INITIALIZED)) { |
1da177e4 LT |
972 | local_irq_save(flags); |
973 | #if defined(CONFIG_MVME147_SCC) || defined(CONFIG_MVME162_SCC) | |
974 | if (MACH_IS_MVME147 || MACH_IS_MVME16x) { | |
fe971071 | 975 | for (i = 0; i < ARRAY_SIZE(mvme_init_tab); ++i) |
1da177e4 LT |
976 | SCCwrite(mvme_init_tab[i].reg, mvme_init_tab[i].val); |
977 | } | |
978 | #endif | |
979 | #if defined(CONFIG_BVME6000_SCC) | |
980 | if (MACH_IS_BVME6000) { | |
fe971071 | 981 | for (i = 0; i < ARRAY_SIZE(bvme_init_tab); ++i) |
1da177e4 LT |
982 | SCCwrite(bvme_init_tab[i].reg, bvme_init_tab[i].val); |
983 | } | |
984 | #endif | |
985 | ||
986 | /* remember status register for detection of DCD and CTS changes */ | |
987 | scc_last_status_reg[channel] = SCCread(STATUS_REG); | |
988 | ||
989 | port->c_dcd = 0; /* Prevent initial 1->0 interrupt */ | |
990 | scc_setsignals (port, 1,1); | |
991 | local_irq_restore(flags); | |
992 | } | |
993 | ||
994 | tty->driver_data = port; | |
732730d4 GU |
995 | port->gs.port.tty = tty; |
996 | port->gs.port.count++; | |
1da177e4 LT |
997 | retval = gs_init_port(&port->gs); |
998 | if (retval) { | |
732730d4 | 999 | port->gs.port.count--; |
1da177e4 LT |
1000 | return retval; |
1001 | } | |
732730d4 | 1002 | port->gs.port.flags |= GS_ACTIVE; |
1da177e4 LT |
1003 | retval = gs_block_til_ready(port, filp); |
1004 | ||
1005 | if (retval) { | |
732730d4 | 1006 | port->gs.port.count--; |
1da177e4 LT |
1007 | return retval; |
1008 | } | |
1009 | ||
31f35939 | 1010 | port->c_dcd = tty_port_carrier_raised(&port->gs.port); |
1da177e4 LT |
1011 | |
1012 | scc_enable_rx_interrupts(port); | |
1013 | ||
1014 | return 0; | |
1015 | } | |
1016 | ||
1017 | ||
1018 | static void scc_throttle (struct tty_struct * tty) | |
1019 | { | |
c9f19e96 | 1020 | struct scc_port *port = tty->driver_data; |
1da177e4 LT |
1021 | unsigned long flags; |
1022 | SCC_ACCESS_INIT(port); | |
1023 | ||
1024 | if (tty->termios->c_cflag & CRTSCTS) { | |
1025 | local_irq_save(flags); | |
1026 | SCCmod(TX_CTRL_REG, ~TCR_RTS, 0); | |
1027 | local_irq_restore(flags); | |
1028 | } | |
1029 | if (I_IXOFF(tty)) | |
1030 | scc_send_xchar(tty, STOP_CHAR(tty)); | |
1031 | } | |
1032 | ||
1033 | ||
1034 | static void scc_unthrottle (struct tty_struct * tty) | |
1035 | { | |
c9f19e96 | 1036 | struct scc_port *port = tty->driver_data; |
1da177e4 LT |
1037 | unsigned long flags; |
1038 | SCC_ACCESS_INIT(port); | |
1039 | ||
1040 | if (tty->termios->c_cflag & CRTSCTS) { | |
1041 | local_irq_save(flags); | |
1042 | SCCmod(TX_CTRL_REG, 0xff, TCR_RTS); | |
1043 | local_irq_restore(flags); | |
1044 | } | |
1045 | if (I_IXOFF(tty)) | |
1046 | scc_send_xchar(tty, START_CHAR(tty)); | |
1047 | } | |
1048 | ||
1049 | ||
1050 | static int scc_ioctl(struct tty_struct *tty, struct file *file, | |
1051 | unsigned int cmd, unsigned long arg) | |
1052 | { | |
1053 | return -ENOIOCTLCMD; | |
1054 | } | |
1055 | ||
1056 | ||
9e98966c | 1057 | static int scc_break_ctl(struct tty_struct *tty, int break_state) |
1da177e4 | 1058 | { |
c9f19e96 | 1059 | struct scc_port *port = tty->driver_data; |
1da177e4 LT |
1060 | unsigned long flags; |
1061 | SCC_ACCESS_INIT(port); | |
1062 | ||
1063 | local_irq_save(flags); | |
1064 | SCCmod(TX_CTRL_REG, ~TCR_SEND_BREAK, | |
1065 | break_state ? TCR_SEND_BREAK : 0); | |
1066 | local_irq_restore(flags); | |
9e98966c | 1067 | return 0; |
1da177e4 LT |
1068 | } |
1069 | ||
1070 | ||
1071 | /*--------------------------------------------------------------------------- | |
1072 | * Serial console stuff... | |
1073 | *--------------------------------------------------------------------------*/ | |
1074 | ||
1075 | #define scc_delay() do { __asm__ __volatile__ (" nop; nop"); } while (0) | |
1076 | ||
1077 | static void scc_ch_write (char ch) | |
1078 | { | |
1079 | volatile char *p = NULL; | |
1080 | ||
1081 | #ifdef CONFIG_MVME147_SCC | |
1082 | if (MACH_IS_MVME147) | |
1083 | p = (volatile char *)M147_SCC_A_ADDR; | |
1084 | #endif | |
1085 | #ifdef CONFIG_MVME162_SCC | |
1086 | if (MACH_IS_MVME16x) | |
1087 | p = (volatile char *)MVME_SCC_A_ADDR; | |
1088 | #endif | |
1089 | #ifdef CONFIG_BVME6000_SCC | |
1090 | if (MACH_IS_BVME6000) | |
1091 | p = (volatile char *)BVME_SCC_A_ADDR; | |
1092 | #endif | |
1093 | ||
1094 | do { | |
1095 | scc_delay(); | |
1096 | } | |
1097 | while (!(*p & 4)); | |
1098 | scc_delay(); | |
1099 | *p = 8; | |
1100 | scc_delay(); | |
1101 | *p = ch; | |
1102 | } | |
1103 | ||
1104 | /* The console must be locked when we get here. */ | |
1105 | ||
1106 | static void scc_console_write (struct console *co, const char *str, unsigned count) | |
1107 | { | |
1108 | unsigned long flags; | |
1109 | ||
1110 | local_irq_save(flags); | |
1111 | ||
1112 | while (count--) | |
1113 | { | |
1114 | if (*str == '\n') | |
1115 | scc_ch_write ('\r'); | |
1116 | scc_ch_write (*str++); | |
1117 | } | |
1118 | local_irq_restore(flags); | |
1119 | } | |
1120 | ||
1121 | static struct tty_driver *scc_console_device(struct console *c, int *index) | |
1122 | { | |
1123 | *index = c->index; | |
1124 | return scc_driver; | |
1125 | } | |
1126 | ||
1da177e4 LT |
1127 | static struct console sercons = { |
1128 | .name = "ttyS", | |
1129 | .write = scc_console_write, | |
1130 | .device = scc_console_device, | |
1da177e4 LT |
1131 | .flags = CON_PRINTBUFFER, |
1132 | .index = -1, | |
1133 | }; | |
1134 | ||
1135 | ||
1136 | static int __init vme_scc_console_init(void) | |
1137 | { | |
1138 | if (vme_brdtype == VME_TYPE_MVME147 || | |
1139 | vme_brdtype == VME_TYPE_MVME162 || | |
1140 | vme_brdtype == VME_TYPE_MVME172 || | |
1141 | vme_brdtype == VME_TYPE_BVME4000 || | |
1142 | vme_brdtype == VME_TYPE_BVME6000) | |
1143 | register_console(&sercons); | |
1144 | return 0; | |
1145 | } | |
1146 | console_initcall(vme_scc_console_init); |