diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-12-08 10:48:23 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-12-08 10:48:23 -0500 |
commit | ee1262dbc65ce0b6234a915d8432171e8d77f518 (patch) | |
tree | 3a4003800d170de691b2e6a9c93c0ca6795678bf /drivers | |
parent | a421018e8c10e5593a1fee076af72a66c3fe8ca3 (diff) | |
parent | 7f5620a5fcd658f219e85831d3691908f1eccbde (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6:
sparc: Set UTS_MACHINE correctly.
sparc,leon: init_leon srmmu cleanup
sparc32: Remove early interrupt enable.
sparc, leon: Added Aeroflex Gaisler entry in manufacturer_info structure
sparc64: Faster early-boot framebuffer console.
Revert "sparc: Make atomic locks raw"
sparc: remove unused nfsd #includes
sparc: Fixup last users of irq_chip->typename
Added sparc_leon3_snooping_enabled() and converted extern inline to static inline
No auxio on LEON
apbuart: Use of_find_node_by_path to find root node.
sparc: Replace old style lock initializer
sparc: Make atomic locks raw
apbuart: Fix build and missing driver unregister.
apbuart: Kill dependency on deprecated Sparc-only PROM interfaces.
apbuart: Fix build warning.
sparc: Support for GRLIB APBUART serial port
watchdog: Remove BKL from rio watchdog driver
sparc: Remove BKL from apc
sparc,leon: Sparc-Leon SMP support
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/serial/Kconfig | 13 | ||||
-rw-r--r-- | drivers/serial/Makefile | 1 | ||||
-rw-r--r-- | drivers/serial/apbuart.c | 710 | ||||
-rw-r--r-- | drivers/serial/apbuart.h | 64 | ||||
-rw-r--r-- | drivers/watchdog/riowd.c | 6 |
5 files changed, 791 insertions, 3 deletions
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig index e52257257279..50943ff78f4b 100644 --- a/drivers/serial/Kconfig +++ b/drivers/serial/Kconfig | |||
@@ -1477,4 +1477,17 @@ config SERIAL_BCM63XX_CONSOLE | |||
1477 | If you have enabled the serial port on the bcm63xx CPU | 1477 | If you have enabled the serial port on the bcm63xx CPU |
1478 | you can make it the console by answering Y to this option. | 1478 | you can make it the console by answering Y to this option. |
1479 | 1479 | ||
1480 | config SERIAL_GRLIB_GAISLER_APBUART | ||
1481 | tristate "GRLIB APBUART serial support" | ||
1482 | depends on OF | ||
1483 | ---help--- | ||
1484 | Add support for the GRLIB APBUART serial port. | ||
1485 | |||
1486 | config SERIAL_GRLIB_GAISLER_APBUART_CONSOLE | ||
1487 | bool "Console on GRLIB APBUART serial port" | ||
1488 | depends on SERIAL_GRLIB_GAISLER_APBUART=y | ||
1489 | select SERIAL_CORE_CONSOLE | ||
1490 | help | ||
1491 | Support for running a console on the GRLIB APBUART | ||
1492 | |||
1480 | endmenu | 1493 | endmenu |
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile index d21d5dd5d048..5548fe7df61d 100644 --- a/drivers/serial/Makefile +++ b/drivers/serial/Makefile | |||
@@ -81,3 +81,4 @@ obj-$(CONFIG_SERIAL_KS8695) += serial_ks8695.o | |||
81 | obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o | 81 | obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o |
82 | obj-$(CONFIG_SERIAL_QE) += ucc_uart.o | 82 | obj-$(CONFIG_SERIAL_QE) += ucc_uart.o |
83 | obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o | 83 | obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o |
84 | obj-$(CONFIG_SERIAL_GRLIB_GAISLER_APBUART) += apbuart.o | ||
diff --git a/drivers/serial/apbuart.c b/drivers/serial/apbuart.c new file mode 100644 index 000000000000..fe91319b5f65 --- /dev/null +++ b/drivers/serial/apbuart.c | |||
@@ -0,0 +1,710 @@ | |||
1 | /* | ||
2 | * Driver for GRLIB serial ports (APBUART) | ||
3 | * | ||
4 | * Based on linux/drivers/serial/amba.c | ||
5 | * | ||
6 | * Copyright (C) 2000 Deep Blue Solutions Ltd. | ||
7 | * Copyright (C) 2003 Konrad Eisele <eiselekd@web.de> | ||
8 | * Copyright (C) 2006 Daniel Hellstrom <daniel@gaisler.com>, Aeroflex Gaisler AB | ||
9 | * Copyright (C) 2008 Gilead Kutnick <kutnickg@zin-tech.com> | ||
10 | * Copyright (C) 2009 Kristoffer Glembo <kristoffer@gaisler.com>, Aeroflex Gaisler AB | ||
11 | */ | ||
12 | |||
13 | #if defined(CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) | ||
14 | #define SUPPORT_SYSRQ | ||
15 | #endif | ||
16 | |||
17 | #include <linux/module.h> | ||
18 | #include <linux/tty.h> | ||
19 | #include <linux/ioport.h> | ||
20 | #include <linux/init.h> | ||
21 | #include <linux/serial.h> | ||
22 | #include <linux/console.h> | ||
23 | #include <linux/sysrq.h> | ||
24 | #include <linux/kthread.h> | ||
25 | #include <linux/device.h> | ||
26 | #include <linux/of.h> | ||
27 | #include <linux/of_device.h> | ||
28 | #include <linux/of_platform.h> | ||
29 | #include <linux/platform_device.h> | ||
30 | #include <linux/io.h> | ||
31 | #include <linux/serial_core.h> | ||
32 | #include <asm/irq.h> | ||
33 | |||
34 | #include "apbuart.h" | ||
35 | |||
36 | #define SERIAL_APBUART_MAJOR TTY_MAJOR | ||
37 | #define SERIAL_APBUART_MINOR 64 | ||
38 | #define UART_DUMMY_RSR_RX 0x8000 /* for ignore all read */ | ||
39 | |||
40 | static void apbuart_tx_chars(struct uart_port *port); | ||
41 | |||
42 | static void apbuart_stop_tx(struct uart_port *port) | ||
43 | { | ||
44 | unsigned int cr; | ||
45 | |||
46 | cr = UART_GET_CTRL(port); | ||
47 | cr &= ~UART_CTRL_TI; | ||
48 | UART_PUT_CTRL(port, cr); | ||
49 | } | ||
50 | |||
51 | static void apbuart_start_tx(struct uart_port *port) | ||
52 | { | ||
53 | unsigned int cr; | ||
54 | |||
55 | cr = UART_GET_CTRL(port); | ||
56 | cr |= UART_CTRL_TI; | ||
57 | UART_PUT_CTRL(port, cr); | ||
58 | |||
59 | if (UART_GET_STATUS(port) & UART_STATUS_THE) | ||
60 | apbuart_tx_chars(port); | ||
61 | } | ||
62 | |||
63 | static void apbuart_stop_rx(struct uart_port *port) | ||
64 | { | ||
65 | unsigned int cr; | ||
66 | |||
67 | cr = UART_GET_CTRL(port); | ||
68 | cr &= ~(UART_CTRL_RI); | ||
69 | UART_PUT_CTRL(port, cr); | ||
70 | } | ||
71 | |||
72 | static void apbuart_enable_ms(struct uart_port *port) | ||
73 | { | ||
74 | /* No modem status change interrupts for APBUART */ | ||
75 | } | ||
76 | |||
77 | static void apbuart_rx_chars(struct uart_port *port) | ||
78 | { | ||
79 | struct tty_struct *tty = port->state->port.tty; | ||
80 | unsigned int status, ch, rsr, flag; | ||
81 | unsigned int max_chars = port->fifosize; | ||
82 | |||
83 | status = UART_GET_STATUS(port); | ||
84 | |||
85 | while (UART_RX_DATA(status) && (max_chars--)) { | ||
86 | |||
87 | ch = UART_GET_CHAR(port); | ||
88 | flag = TTY_NORMAL; | ||
89 | |||
90 | port->icount.rx++; | ||
91 | |||
92 | rsr = UART_GET_STATUS(port) | UART_DUMMY_RSR_RX; | ||
93 | UART_PUT_STATUS(port, 0); | ||
94 | if (rsr & UART_STATUS_ERR) { | ||
95 | |||
96 | if (rsr & UART_STATUS_BR) { | ||
97 | rsr &= ~(UART_STATUS_FE | UART_STATUS_PE); | ||
98 | port->icount.brk++; | ||
99 | if (uart_handle_break(port)) | ||
100 | goto ignore_char; | ||
101 | } else if (rsr & UART_STATUS_PE) { | ||
102 | port->icount.parity++; | ||
103 | } else if (rsr & UART_STATUS_FE) { | ||
104 | port->icount.frame++; | ||
105 | } | ||
106 | if (rsr & UART_STATUS_OE) | ||
107 | port->icount.overrun++; | ||
108 | |||
109 | rsr &= port->read_status_mask; | ||
110 | |||
111 | if (rsr & UART_STATUS_PE) | ||
112 | flag = TTY_PARITY; | ||
113 | else if (rsr & UART_STATUS_FE) | ||
114 | flag = TTY_FRAME; | ||
115 | } | ||
116 | |||
117 | if (uart_handle_sysrq_char(port, ch)) | ||
118 | goto ignore_char; | ||
119 | |||
120 | uart_insert_char(port, rsr, UART_STATUS_OE, ch, flag); | ||
121 | |||
122 | |||
123 | ignore_char: | ||
124 | status = UART_GET_STATUS(port); | ||
125 | } | ||
126 | |||
127 | tty_flip_buffer_push(tty); | ||
128 | } | ||
129 | |||
130 | static void apbuart_tx_chars(struct uart_port *port) | ||
131 | { | ||
132 | struct circ_buf *xmit = &port->state->xmit; | ||
133 | int count; | ||
134 | |||
135 | if (port->x_char) { | ||
136 | UART_PUT_CHAR(port, port->x_char); | ||
137 | port->icount.tx++; | ||
138 | port->x_char = 0; | ||
139 | return; | ||
140 | } | ||
141 | |||
142 | if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { | ||
143 | apbuart_stop_tx(port); | ||
144 | return; | ||
145 | } | ||
146 | |||
147 | /* amba: fill FIFO */ | ||
148 | count = port->fifosize >> 1; | ||
149 | do { | ||
150 | UART_PUT_CHAR(port, xmit->buf[xmit->tail]); | ||
151 | xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); | ||
152 | port->icount.tx++; | ||
153 | if (uart_circ_empty(xmit)) | ||
154 | break; | ||
155 | } while (--count > 0); | ||
156 | |||
157 | if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) | ||
158 | uart_write_wakeup(port); | ||
159 | |||
160 | if (uart_circ_empty(xmit)) | ||
161 | apbuart_stop_tx(port); | ||
162 | } | ||
163 | |||
164 | static irqreturn_t apbuart_int(int irq, void *dev_id) | ||
165 | { | ||
166 | struct uart_port *port = dev_id; | ||
167 | unsigned int status; | ||
168 | |||
169 | spin_lock(&port->lock); | ||
170 | |||
171 | status = UART_GET_STATUS(port); | ||
172 | if (status & UART_STATUS_DR) | ||
173 | apbuart_rx_chars(port); | ||
174 | if (status & UART_STATUS_THE) | ||
175 | apbuart_tx_chars(port); | ||
176 | |||
177 | spin_unlock(&port->lock); | ||
178 | |||
179 | return IRQ_HANDLED; | ||
180 | } | ||
181 | |||
182 | static unsigned int apbuart_tx_empty(struct uart_port *port) | ||
183 | { | ||
184 | unsigned int status = UART_GET_STATUS(port); | ||
185 | return status & UART_STATUS_THE ? TIOCSER_TEMT : 0; | ||
186 | } | ||
187 | |||
188 | static unsigned int apbuart_get_mctrl(struct uart_port *port) | ||
189 | { | ||
190 | /* The GRLIB APBUART handles flow control in hardware */ | ||
191 | return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS; | ||
192 | } | ||
193 | |||
194 | static void apbuart_set_mctrl(struct uart_port *port, unsigned int mctrl) | ||
195 | { | ||
196 | /* The GRLIB APBUART handles flow control in hardware */ | ||
197 | } | ||
198 | |||
199 | static void apbuart_break_ctl(struct uart_port *port, int break_state) | ||
200 | { | ||
201 | /* We don't support sending break */ | ||
202 | } | ||
203 | |||
204 | static int apbuart_startup(struct uart_port *port) | ||
205 | { | ||
206 | int retval; | ||
207 | unsigned int cr; | ||
208 | |||
209 | /* Allocate the IRQ */ | ||
210 | retval = request_irq(port->irq, apbuart_int, 0, "apbuart", port); | ||
211 | if (retval) | ||
212 | return retval; | ||
213 | |||
214 | /* Finally, enable interrupts */ | ||
215 | cr = UART_GET_CTRL(port); | ||
216 | UART_PUT_CTRL(port, | ||
217 | cr | UART_CTRL_RE | UART_CTRL_TE | | ||
218 | UART_CTRL_RI | UART_CTRL_TI); | ||
219 | |||
220 | return 0; | ||
221 | } | ||
222 | |||
223 | static void apbuart_shutdown(struct uart_port *port) | ||
224 | { | ||
225 | unsigned int cr; | ||
226 | |||
227 | /* disable all interrupts, disable the port */ | ||
228 | cr = UART_GET_CTRL(port); | ||
229 | UART_PUT_CTRL(port, | ||
230 | cr & ~(UART_CTRL_RE | UART_CTRL_TE | | ||
231 | UART_CTRL_RI | UART_CTRL_TI)); | ||
232 | |||
233 | /* Free the interrupt */ | ||
234 | free_irq(port->irq, port); | ||
235 | } | ||
236 | |||
237 | static void apbuart_set_termios(struct uart_port *port, | ||
238 | struct ktermios *termios, struct ktermios *old) | ||
239 | { | ||
240 | unsigned int cr; | ||
241 | unsigned long flags; | ||
242 | unsigned int baud, quot; | ||
243 | |||
244 | /* Ask the core to calculate the divisor for us. */ | ||
245 | baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16); | ||
246 | if (baud == 0) | ||
247 | panic("invalid baudrate %i\n", port->uartclk / 16); | ||
248 | |||
249 | /* uart_get_divisor calc a *16 uart freq, apbuart is *8 */ | ||
250 | quot = (uart_get_divisor(port, baud)) * 2; | ||
251 | cr = UART_GET_CTRL(port); | ||
252 | cr &= ~(UART_CTRL_PE | UART_CTRL_PS); | ||
253 | |||
254 | if (termios->c_cflag & PARENB) { | ||
255 | cr |= UART_CTRL_PE; | ||
256 | if ((termios->c_cflag & PARODD)) | ||
257 | cr |= UART_CTRL_PS; | ||
258 | } | ||
259 | |||
260 | /* Enable flow control. */ | ||
261 | if (termios->c_cflag & CRTSCTS) | ||
262 | cr |= UART_CTRL_FL; | ||
263 | |||
264 | spin_lock_irqsave(&port->lock, flags); | ||
265 | |||
266 | /* Update the per-port timeout. */ | ||
267 | uart_update_timeout(port, termios->c_cflag, baud); | ||
268 | |||
269 | port->read_status_mask = UART_STATUS_OE; | ||
270 | if (termios->c_iflag & INPCK) | ||
271 | port->read_status_mask |= UART_STATUS_FE | UART_STATUS_PE; | ||
272 | |||
273 | /* Characters to ignore */ | ||
274 | port->ignore_status_mask = 0; | ||
275 | if (termios->c_iflag & IGNPAR) | ||
276 | port->ignore_status_mask |= UART_STATUS_FE | UART_STATUS_PE; | ||
277 | |||
278 | /* Ignore all characters if CREAD is not set. */ | ||
279 | if ((termios->c_cflag & CREAD) == 0) | ||
280 | port->ignore_status_mask |= UART_DUMMY_RSR_RX; | ||
281 | |||
282 | /* Set baud rate */ | ||
283 | quot -= 1; | ||
284 | UART_PUT_SCAL(port, quot); | ||
285 | UART_PUT_CTRL(port, cr); | ||
286 | |||
287 | spin_unlock_irqrestore(&port->lock, flags); | ||
288 | } | ||
289 | |||
290 | static const char *apbuart_type(struct uart_port *port) | ||
291 | { | ||
292 | return port->type == PORT_APBUART ? "GRLIB/APBUART" : NULL; | ||
293 | } | ||
294 | |||
295 | static void apbuart_release_port(struct uart_port *port) | ||
296 | { | ||
297 | release_mem_region(port->mapbase, 0x100); | ||
298 | } | ||
299 | |||
300 | static int apbuart_request_port(struct uart_port *port) | ||
301 | { | ||
302 | return request_mem_region(port->mapbase, 0x100, "grlib-apbuart") | ||
303 | != NULL ? 0 : -EBUSY; | ||
304 | return 0; | ||
305 | } | ||
306 | |||
307 | /* Configure/autoconfigure the port */ | ||
308 | static void apbuart_config_port(struct uart_port *port, int flags) | ||
309 | { | ||
310 | if (flags & UART_CONFIG_TYPE) { | ||
311 | port->type = PORT_APBUART; | ||
312 | apbuart_request_port(port); | ||
313 | } | ||
314 | } | ||
315 | |||
316 | /* Verify the new serial_struct (for TIOCSSERIAL) */ | ||
317 | static int apbuart_verify_port(struct uart_port *port, | ||
318 | struct serial_struct *ser) | ||
319 | { | ||
320 | int ret = 0; | ||
321 | if (ser->type != PORT_UNKNOWN && ser->type != PORT_APBUART) | ||
322 | ret = -EINVAL; | ||
323 | if (ser->irq < 0 || ser->irq >= NR_IRQS) | ||
324 | ret = -EINVAL; | ||
325 | if (ser->baud_base < 9600) | ||
326 | ret = -EINVAL; | ||
327 | return ret; | ||
328 | } | ||
329 | |||
330 | static struct uart_ops grlib_apbuart_ops = { | ||
331 | .tx_empty = apbuart_tx_empty, | ||
332 | .set_mctrl = apbuart_set_mctrl, | ||
333 | .get_mctrl = apbuart_get_mctrl, | ||
334 | .stop_tx = apbuart_stop_tx, | ||
335 | .start_tx = apbuart_start_tx, | ||
336 | .stop_rx = apbuart_stop_rx, | ||
337 | .enable_ms = apbuart_enable_ms, | ||
338 | .break_ctl = apbuart_break_ctl, | ||
339 | .startup = apbuart_startup, | ||
340 | .shutdown = apbuart_shutdown, | ||
341 | .set_termios = apbuart_set_termios, | ||
342 | .type = apbuart_type, | ||
343 | .release_port = apbuart_release_port, | ||
344 | .request_port = apbuart_request_port, | ||
345 | .config_port = apbuart_config_port, | ||
346 | .verify_port = apbuart_verify_port, | ||
347 | }; | ||
348 | |||
349 | static struct uart_port grlib_apbuart_ports[UART_NR]; | ||
350 | static struct device_node *grlib_apbuart_nodes[UART_NR]; | ||
351 | |||
352 | static int apbuart_scan_fifo_size(struct uart_port *port, int portnumber) | ||
353 | { | ||
354 | int ctrl, loop = 0; | ||
355 | int status; | ||
356 | int fifosize; | ||
357 | unsigned long flags; | ||
358 | |||
359 | ctrl = UART_GET_CTRL(port); | ||
360 | |||
361 | /* | ||
362 | * Enable the transceiver and wait for it to be ready to send data. | ||
363 | * Clear interrupts so that this process will not be externally | ||
364 | * interrupted in the middle (which can cause the transceiver to | ||
365 | * drain prematurely). | ||
366 | */ | ||
367 | |||
368 | local_irq_save(flags); | ||
369 | |||
370 | UART_PUT_CTRL(port, ctrl | UART_CTRL_TE); | ||
371 | |||
372 | while (!UART_TX_READY(UART_GET_STATUS(port))) | ||
373 | loop++; | ||
374 | |||
375 | /* | ||
376 | * Disable the transceiver so data isn't actually sent during the | ||
377 | * actual test. | ||
378 | */ | ||
379 | |||
380 | UART_PUT_CTRL(port, ctrl & ~(UART_CTRL_TE)); | ||
381 | |||
382 | fifosize = 1; | ||
383 | UART_PUT_CHAR(port, 0); | ||
384 | |||
385 | /* | ||
386 | * So long as transmitting a character increments the tranceivier FIFO | ||
387 | * length the FIFO must be at least that big. These bytes will | ||
388 | * automatically drain off of the FIFO. | ||
389 | */ | ||
390 | |||
391 | status = UART_GET_STATUS(port); | ||
392 | while (((status >> 20) & 0x3F) == fifosize) { | ||
393 | fifosize++; | ||
394 | UART_PUT_CHAR(port, 0); | ||
395 | status = UART_GET_STATUS(port); | ||
396 | } | ||
397 | |||
398 | fifosize--; | ||
399 | |||
400 | UART_PUT_CTRL(port, ctrl); | ||
401 | local_irq_restore(flags); | ||
402 | |||
403 | if (fifosize == 0) | ||
404 | fifosize = 1; | ||
405 | |||
406 | return fifosize; | ||
407 | } | ||
408 | |||
409 | static void apbuart_flush_fifo(struct uart_port *port) | ||
410 | { | ||
411 | int i; | ||
412 | |||
413 | for (i = 0; i < port->fifosize; i++) | ||
414 | UART_GET_CHAR(port); | ||
415 | } | ||
416 | |||
417 | |||
418 | /* ======================================================================== */ | ||
419 | /* Console driver, if enabled */ | ||
420 | /* ======================================================================== */ | ||
421 | |||
422 | #ifdef CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE | ||
423 | |||
424 | static void apbuart_console_putchar(struct uart_port *port, int ch) | ||
425 | { | ||
426 | unsigned int status; | ||
427 | do { | ||
428 | status = UART_GET_STATUS(port); | ||
429 | } while (!UART_TX_READY(status)); | ||
430 | UART_PUT_CHAR(port, ch); | ||
431 | } | ||
432 | |||
433 | static void | ||
434 | apbuart_console_write(struct console *co, const char *s, unsigned int count) | ||
435 | { | ||
436 | struct uart_port *port = &grlib_apbuart_ports[co->index]; | ||
437 | unsigned int status, old_cr, new_cr; | ||
438 | |||
439 | /* First save the CR then disable the interrupts */ | ||
440 | old_cr = UART_GET_CTRL(port); | ||
441 | new_cr = old_cr & ~(UART_CTRL_RI | UART_CTRL_TI); | ||
442 | UART_PUT_CTRL(port, new_cr); | ||
443 | |||
444 | uart_console_write(port, s, count, apbuart_console_putchar); | ||
445 | |||
446 | /* | ||
447 | * Finally, wait for transmitter to become empty | ||
448 | * and restore the TCR | ||
449 | */ | ||
450 | do { | ||
451 | status = UART_GET_STATUS(port); | ||
452 | } while (!UART_TX_READY(status)); | ||
453 | UART_PUT_CTRL(port, old_cr); | ||
454 | } | ||
455 | |||
456 | static void __init | ||
457 | apbuart_console_get_options(struct uart_port *port, int *baud, | ||
458 | int *parity, int *bits) | ||
459 | { | ||
460 | if (UART_GET_CTRL(port) & (UART_CTRL_RE | UART_CTRL_TE)) { | ||
461 | |||
462 | unsigned int quot, status; | ||
463 | status = UART_GET_STATUS(port); | ||
464 | |||
465 | *parity = 'n'; | ||
466 | if (status & UART_CTRL_PE) { | ||
467 | if ((status & UART_CTRL_PS) == 0) | ||
468 | *parity = 'e'; | ||
469 | else | ||
470 | *parity = 'o'; | ||
471 | } | ||
472 | |||
473 | *bits = 8; | ||
474 | quot = UART_GET_SCAL(port) / 8; | ||
475 | *baud = port->uartclk / (16 * (quot + 1)); | ||
476 | } | ||
477 | } | ||
478 | |||
479 | static int __init apbuart_console_setup(struct console *co, char *options) | ||
480 | { | ||
481 | struct uart_port *port; | ||
482 | int baud = 38400; | ||
483 | int bits = 8; | ||
484 | int parity = 'n'; | ||
485 | int flow = 'n'; | ||
486 | |||
487 | pr_debug("apbuart_console_setup co=%p, co->index=%i, options=%s\n", | ||
488 | co, co->index, options); | ||
489 | |||
490 | /* | ||
491 | * Check whether an invalid uart number has been specified, and | ||
492 | * if so, search for the first available port that does have | ||
493 | * console support. | ||
494 | */ | ||
495 | if (co->index >= grlib_apbuart_port_nr) | ||
496 | co->index = 0; | ||
497 | |||
498 | port = &grlib_apbuart_ports[co->index]; | ||
499 | |||
500 | spin_lock_init(&port->lock); | ||
501 | |||
502 | if (options) | ||
503 | uart_parse_options(options, &baud, &parity, &bits, &flow); | ||
504 | else | ||
505 | apbuart_console_get_options(port, &baud, &parity, &bits); | ||
506 | |||
507 | return uart_set_options(port, co, baud, parity, bits, flow); | ||
508 | } | ||
509 | |||
510 | static struct uart_driver grlib_apbuart_driver; | ||
511 | |||
512 | static struct console grlib_apbuart_console = { | ||
513 | .name = "ttyS", | ||
514 | .write = apbuart_console_write, | ||
515 | .device = uart_console_device, | ||
516 | .setup = apbuart_console_setup, | ||
517 | .flags = CON_PRINTBUFFER, | ||
518 | .index = -1, | ||
519 | .data = &grlib_apbuart_driver, | ||
520 | }; | ||
521 | |||
522 | |||
523 | static void grlib_apbuart_configure(void); | ||
524 | |||
525 | static int __init apbuart_console_init(void) | ||
526 | { | ||
527 | grlib_apbuart_configure(); | ||
528 | register_console(&grlib_apbuart_console); | ||
529 | return 0; | ||
530 | } | ||
531 | |||
532 | console_initcall(apbuart_console_init); | ||
533 | |||
534 | #define APBUART_CONSOLE (&grlib_apbuart_console) | ||
535 | #else | ||
536 | #define APBUART_CONSOLE NULL | ||
537 | #endif | ||
538 | |||
539 | static struct uart_driver grlib_apbuart_driver = { | ||
540 | .owner = THIS_MODULE, | ||
541 | .driver_name = "serial", | ||
542 | .dev_name = "ttyS", | ||
543 | .major = SERIAL_APBUART_MAJOR, | ||
544 | .minor = SERIAL_APBUART_MINOR, | ||
545 | .nr = UART_NR, | ||
546 | .cons = APBUART_CONSOLE, | ||
547 | }; | ||
548 | |||
549 | |||
550 | /* ======================================================================== */ | ||
551 | /* OF Platform Driver */ | ||
552 | /* ======================================================================== */ | ||
553 | |||
554 | static int __devinit apbuart_probe(struct of_device *op, | ||
555 | const struct of_device_id *match) | ||
556 | { | ||
557 | int i = -1; | ||
558 | struct uart_port *port = NULL; | ||
559 | |||
560 | i = 0; | ||
561 | for (i = 0; i < grlib_apbuart_port_nr; i++) { | ||
562 | if (op->node == grlib_apbuart_nodes[i]) | ||
563 | break; | ||
564 | } | ||
565 | |||
566 | port = &grlib_apbuart_ports[i]; | ||
567 | port->dev = &op->dev; | ||
568 | |||
569 | uart_add_one_port(&grlib_apbuart_driver, (struct uart_port *) port); | ||
570 | |||
571 | apbuart_flush_fifo((struct uart_port *) port); | ||
572 | |||
573 | printk(KERN_INFO "grlib-apbuart at 0x%llx, irq %d\n", | ||
574 | (unsigned long long) port->mapbase, port->irq); | ||
575 | return 0; | ||
576 | |||
577 | } | ||
578 | |||
579 | static struct of_device_id __initdata apbuart_match[] = { | ||
580 | { | ||
581 | .name = "GAISLER_APBUART", | ||
582 | }, | ||
583 | {}, | ||
584 | }; | ||
585 | |||
586 | static struct of_platform_driver grlib_apbuart_of_driver = { | ||
587 | .match_table = apbuart_match, | ||
588 | .probe = apbuart_probe, | ||
589 | .driver = { | ||
590 | .owner = THIS_MODULE, | ||
591 | .name = "grlib-apbuart", | ||
592 | }, | ||
593 | }; | ||
594 | |||
595 | |||
596 | static void grlib_apbuart_configure(void) | ||
597 | { | ||
598 | static int enum_done; | ||
599 | struct device_node *np, *rp; | ||
600 | struct uart_port *port = NULL; | ||
601 | const u32 *prop; | ||
602 | int freq_khz; | ||
603 | int v = 0, d = 0; | ||
604 | unsigned int addr; | ||
605 | int irq, line; | ||
606 | struct amba_prom_registers *regs; | ||
607 | |||
608 | if (enum_done) | ||
609 | return; | ||
610 | |||
611 | /* Get bus frequency */ | ||
612 | rp = of_find_node_by_path("/"); | ||
613 | rp = of_get_next_child(rp, NULL); | ||
614 | prop = of_get_property(rp, "clock-frequency", NULL); | ||
615 | freq_khz = *prop; | ||
616 | |||
617 | line = 0; | ||
618 | for_each_matching_node(np, apbuart_match) { | ||
619 | |||
620 | int *vendor = (int *) of_get_property(np, "vendor", NULL); | ||
621 | int *device = (int *) of_get_property(np, "device", NULL); | ||
622 | int *irqs = (int *) of_get_property(np, "interrupts", NULL); | ||
623 | regs = (struct amba_prom_registers *) | ||
624 | of_get_property(np, "reg", NULL); | ||
625 | |||
626 | if (vendor) | ||
627 | v = *vendor; | ||
628 | if (device) | ||
629 | d = *device; | ||
630 | |||
631 | if (!irqs || !regs) | ||
632 | return; | ||
633 | |||
634 | grlib_apbuart_nodes[line] = np; | ||
635 | |||
636 | addr = regs->phys_addr; | ||
637 | irq = *irqs; | ||
638 | |||
639 | port = &grlib_apbuart_ports[line]; | ||
640 | |||
641 | port->mapbase = addr; | ||
642 | port->membase = ioremap(addr, sizeof(struct grlib_apbuart_regs_map)); | ||
643 | port->irq = irq; | ||
644 | port->iotype = UPIO_MEM; | ||
645 | port->ops = &grlib_apbuart_ops; | ||
646 | port->flags = UPF_BOOT_AUTOCONF; | ||
647 | port->line = line; | ||
648 | port->uartclk = freq_khz * 1000; | ||
649 | port->fifosize = apbuart_scan_fifo_size((struct uart_port *) port, line); | ||
650 | line++; | ||
651 | |||
652 | /* We support maximum UART_NR uarts ... */ | ||
653 | if (line == UART_NR) | ||
654 | break; | ||
655 | |||
656 | } | ||
657 | |||
658 | enum_done = 1; | ||
659 | |||
660 | grlib_apbuart_driver.nr = grlib_apbuart_port_nr = line; | ||
661 | } | ||
662 | |||
663 | static int __init grlib_apbuart_init(void) | ||
664 | { | ||
665 | int ret; | ||
666 | |||
667 | /* Find all APBUARTS in device the tree and initialize their ports */ | ||
668 | grlib_apbuart_configure(); | ||
669 | |||
670 | printk(KERN_INFO "Serial: GRLIB APBUART driver\n"); | ||
671 | |||
672 | ret = uart_register_driver(&grlib_apbuart_driver); | ||
673 | |||
674 | if (ret) { | ||
675 | printk(KERN_ERR "%s: uart_register_driver failed (%i)\n", | ||
676 | __FILE__, ret); | ||
677 | return ret; | ||
678 | } | ||
679 | |||
680 | ret = of_register_platform_driver(&grlib_apbuart_of_driver); | ||
681 | if (ret) { | ||
682 | printk(KERN_ERR | ||
683 | "%s: of_register_platform_driver failed (%i)\n", | ||
684 | __FILE__, ret); | ||
685 | uart_unregister_driver(&grlib_apbuart_driver); | ||
686 | return ret; | ||
687 | } | ||
688 | |||
689 | return ret; | ||
690 | } | ||
691 | |||
692 | static void __exit grlib_apbuart_exit(void) | ||
693 | { | ||
694 | int i; | ||
695 | |||
696 | for (i = 0; i < grlib_apbuart_port_nr; i++) | ||
697 | uart_remove_one_port(&grlib_apbuart_driver, | ||
698 | &grlib_apbuart_ports[i]); | ||
699 | |||
700 | uart_unregister_driver(&grlib_apbuart_driver); | ||
701 | of_unregister_platform_driver(&grlib_apbuart_of_driver); | ||
702 | } | ||
703 | |||
704 | module_init(grlib_apbuart_init); | ||
705 | module_exit(grlib_apbuart_exit); | ||
706 | |||
707 | MODULE_AUTHOR("Aeroflex Gaisler AB"); | ||
708 | MODULE_DESCRIPTION("GRLIB APBUART serial driver"); | ||
709 | MODULE_VERSION("2.1"); | ||
710 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/serial/apbuart.h b/drivers/serial/apbuart.h new file mode 100644 index 000000000000..5faf87c8d2bc --- /dev/null +++ b/drivers/serial/apbuart.h | |||
@@ -0,0 +1,64 @@ | |||
1 | #ifndef __GRLIB_APBUART_H__ | ||
2 | #define __GRLIB_APBUART_H__ | ||
3 | |||
4 | #include <asm/io.h> | ||
5 | |||
6 | #define UART_NR 8 | ||
7 | static int grlib_apbuart_port_nr; | ||
8 | |||
9 | struct grlib_apbuart_regs_map { | ||
10 | u32 data; | ||
11 | u32 status; | ||
12 | u32 ctrl; | ||
13 | u32 scaler; | ||
14 | }; | ||
15 | |||
16 | struct amba_prom_registers { | ||
17 | unsigned int phys_addr; | ||
18 | unsigned int reg_size; | ||
19 | }; | ||
20 | |||
21 | /* | ||
22 | * The following defines the bits in the APBUART Status Registers. | ||
23 | */ | ||
24 | #define UART_STATUS_DR 0x00000001 /* Data Ready */ | ||
25 | #define UART_STATUS_TSE 0x00000002 /* TX Send Register Empty */ | ||
26 | #define UART_STATUS_THE 0x00000004 /* TX Hold Register Empty */ | ||
27 | #define UART_STATUS_BR 0x00000008 /* Break Error */ | ||
28 | #define UART_STATUS_OE 0x00000010 /* RX Overrun Error */ | ||
29 | #define UART_STATUS_PE 0x00000020 /* RX Parity Error */ | ||
30 | #define UART_STATUS_FE 0x00000040 /* RX Framing Error */ | ||
31 | #define UART_STATUS_ERR 0x00000078 /* Error Mask */ | ||
32 | |||
33 | /* | ||
34 | * The following defines the bits in the APBUART Ctrl Registers. | ||
35 | */ | ||
36 | #define UART_CTRL_RE 0x00000001 /* Receiver enable */ | ||
37 | #define UART_CTRL_TE 0x00000002 /* Transmitter enable */ | ||
38 | #define UART_CTRL_RI 0x00000004 /* Receiver interrupt enable */ | ||
39 | #define UART_CTRL_TI 0x00000008 /* Transmitter irq */ | ||
40 | #define UART_CTRL_PS 0x00000010 /* Parity select */ | ||
41 | #define UART_CTRL_PE 0x00000020 /* Parity enable */ | ||
42 | #define UART_CTRL_FL 0x00000040 /* Flow control enable */ | ||
43 | #define UART_CTRL_LB 0x00000080 /* Loopback enable */ | ||
44 | |||
45 | #define APBBASE(port) ((struct grlib_apbuart_regs_map *)((port)->membase)) | ||
46 | |||
47 | #define APBBASE_DATA_P(port) (&(APBBASE(port)->data)) | ||
48 | #define APBBASE_STATUS_P(port) (&(APBBASE(port)->status)) | ||
49 | #define APBBASE_CTRL_P(port) (&(APBBASE(port)->ctrl)) | ||
50 | #define APBBASE_SCALAR_P(port) (&(APBBASE(port)->scaler)) | ||
51 | |||
52 | #define UART_GET_CHAR(port) (__raw_readl(APBBASE_DATA_P(port))) | ||
53 | #define UART_PUT_CHAR(port, v) (__raw_writel(v, APBBASE_DATA_P(port))) | ||
54 | #define UART_GET_STATUS(port) (__raw_readl(APBBASE_STATUS_P(port))) | ||
55 | #define UART_PUT_STATUS(port, v)(__raw_writel(v, APBBASE_STATUS_P(port))) | ||
56 | #define UART_GET_CTRL(port) (__raw_readl(APBBASE_CTRL_P(port))) | ||
57 | #define UART_PUT_CTRL(port, v) (__raw_writel(v, APBBASE_CTRL_P(port))) | ||
58 | #define UART_GET_SCAL(port) (__raw_readl(APBBASE_SCALAR_P(port))) | ||
59 | #define UART_PUT_SCAL(port, v) (__raw_writel(v, APBBASE_SCALAR_P(port))) | ||
60 | |||
61 | #define UART_RX_DATA(s) (((s) & UART_STATUS_DR) != 0) | ||
62 | #define UART_TX_READY(s) (((s) & UART_STATUS_THE) != 0) | ||
63 | |||
64 | #endif /* __GRLIB_APBUART_H__ */ | ||
diff --git a/drivers/watchdog/riowd.c b/drivers/watchdog/riowd.c index d3c824dc2358..c14ae8676903 100644 --- a/drivers/watchdog/riowd.c +++ b/drivers/watchdog/riowd.c | |||
@@ -10,7 +10,6 @@ | |||
10 | #include <linux/errno.h> | 10 | #include <linux/errno.h> |
11 | #include <linux/init.h> | 11 | #include <linux/init.h> |
12 | #include <linux/miscdevice.h> | 12 | #include <linux/miscdevice.h> |
13 | #include <linux/smp_lock.h> | ||
14 | #include <linux/watchdog.h> | 13 | #include <linux/watchdog.h> |
15 | #include <linux/of.h> | 14 | #include <linux/of.h> |
16 | #include <linux/of_device.h> | 15 | #include <linux/of_device.h> |
@@ -75,7 +74,6 @@ static void riowd_writereg(struct riowd *p, u8 val, int index) | |||
75 | 74 | ||
76 | static int riowd_open(struct inode *inode, struct file *filp) | 75 | static int riowd_open(struct inode *inode, struct file *filp) |
77 | { | 76 | { |
78 | cycle_kernel_lock(); | ||
79 | nonseekable_open(inode, filp); | 77 | nonseekable_open(inode, filp); |
80 | return 0; | 78 | return 0; |
81 | } | 79 | } |
@@ -194,6 +192,8 @@ static int __devinit riowd_probe(struct of_device *op, | |||
194 | printk(KERN_ERR PFX "Cannot map registers.\n"); | 192 | printk(KERN_ERR PFX "Cannot map registers.\n"); |
195 | goto out_free; | 193 | goto out_free; |
196 | } | 194 | } |
195 | /* Make miscdev useable right away */ | ||
196 | riowd_device = p; | ||
197 | 197 | ||
198 | err = misc_register(&riowd_miscdev); | 198 | err = misc_register(&riowd_miscdev); |
199 | if (err) { | 199 | if (err) { |
@@ -205,10 +205,10 @@ static int __devinit riowd_probe(struct of_device *op, | |||
205 | "regs at %p\n", riowd_timeout, p->regs); | 205 | "regs at %p\n", riowd_timeout, p->regs); |
206 | 206 | ||
207 | dev_set_drvdata(&op->dev, p); | 207 | dev_set_drvdata(&op->dev, p); |
208 | riowd_device = p; | ||
209 | return 0; | 208 | return 0; |
210 | 209 | ||
211 | out_iounmap: | 210 | out_iounmap: |
211 | riowd_device = NULL; | ||
212 | of_iounmap(&op->resource[0], p->regs, 2); | 212 | of_iounmap(&op->resource[0], p->regs, 2); |
213 | 213 | ||
214 | out_free: | 214 | out_free: |