Commit | Line | Data |
---|---|---|
e3b3d0f5 | 1 | // SPDX-License-Identifier: GPL-2.0 |
b5c6c1a7 CM |
2 | /* |
3 | * Copyright 2013 Tilera Corporation. All Rights Reserved. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License | |
7 | * as published by the Free Software Foundation, version 2. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, but | |
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or | |
12 | * NON INFRINGEMENT. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | * TILEGx UART driver. | |
16 | */ | |
17 | ||
18 | #include <linux/delay.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/interrupt.h> | |
21 | #include <linux/io.h> | |
22 | #include <linux/irq.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/serial_core.h> | |
25 | #include <linux/tty.h> | |
26 | #include <linux/tty_flip.h> | |
27 | ||
28 | #include <gxio/common.h> | |
29 | #include <gxio/iorpc_globals.h> | |
30 | #include <gxio/iorpc_uart.h> | |
31 | #include <gxio/kiorpc.h> | |
32 | ||
33 | #include <hv/drv_uart_intf.h> | |
34 | ||
35 | /* | |
36 | * Use device name ttyS, major 4, minor 64-65. | |
37 | * This is the usual serial port name, 8250 conventional range. | |
38 | */ | |
39 | #define TILEGX_UART_MAJOR TTY_MAJOR | |
40 | #define TILEGX_UART_MINOR 64 | |
41 | #define TILEGX_UART_NAME "ttyS" | |
42 | #define DRIVER_NAME_STRING "TILEGx_Serial" | |
43 | #define TILEGX_UART_REF_CLK 125000000; /* REF_CLK is always 125 MHz. */ | |
44 | ||
45 | struct tile_uart_port { | |
46 | /* UART port. */ | |
47 | struct uart_port uart; | |
48 | ||
49 | /* GXIO device context. */ | |
50 | gxio_uart_context_t context; | |
51 | ||
52 | /* UART access mutex. */ | |
53 | struct mutex mutex; | |
54 | ||
55 | /* CPU receiving interrupts. */ | |
56 | int irq_cpu; | |
57 | }; | |
58 | ||
59 | static struct tile_uart_port tile_uart_ports[TILEGX_UART_NR]; | |
60 | static struct uart_driver tilegx_uart_driver; | |
61 | ||
62 | ||
63 | /* | |
64 | * Read UART rx fifo, and insert the chars into tty buffer. | |
65 | */ | |
66 | static void receive_chars(struct tile_uart_port *tile_uart, | |
67 | struct tty_struct *tty) | |
68 | { | |
69 | int i; | |
70 | char c; | |
71 | UART_FIFO_COUNT_t count; | |
72 | gxio_uart_context_t *context = &tile_uart->context; | |
73 | struct tty_port *port = tty->port; | |
74 | ||
75 | count.word = gxio_uart_read(context, UART_FIFO_COUNT); | |
76 | for (i = 0; i < count.rfifo_count; i++) { | |
77 | c = (char)gxio_uart_read(context, UART_RECEIVE_DATA); | |
78 | tty_insert_flip_char(port, c, TTY_NORMAL); | |
79 | } | |
80 | } | |
81 | ||
82 | ||
83 | /* | |
84 | * Drain the Rx FIFO, called by interrupt handler. | |
85 | */ | |
86 | static void handle_receive(struct tile_uart_port *tile_uart) | |
87 | { | |
88 | struct tty_port *port = &tile_uart->uart.state->port; | |
89 | struct tty_struct *tty = tty_port_tty_get(port); | |
90 | gxio_uart_context_t *context = &tile_uart->context; | |
91 | ||
92 | if (!tty) | |
93 | return; | |
94 | ||
95 | /* First read UART rx fifo. */ | |
96 | receive_chars(tile_uart, tty); | |
97 | ||
98 | /* Reset RFIFO_WE interrupt. */ | |
99 | gxio_uart_write(context, UART_INTERRUPT_STATUS, | |
100 | UART_INTERRUPT_MASK__RFIFO_WE_MASK); | |
101 | ||
102 | /* Final read, if any chars comes between the first read and | |
103 | * the interrupt reset. | |
104 | */ | |
105 | receive_chars(tile_uart, tty); | |
106 | ||
107 | spin_unlock(&tile_uart->uart.lock); | |
108 | tty_flip_buffer_push(port); | |
109 | spin_lock(&tile_uart->uart.lock); | |
110 | tty_kref_put(tty); | |
111 | } | |
112 | ||
113 | ||
114 | /* | |
115 | * Push one char to UART Write FIFO. | |
116 | * Return 0 on success, -1 if write filo is full. | |
117 | */ | |
118 | static int tilegx_putchar(gxio_uart_context_t *context, char c) | |
119 | { | |
120 | UART_FLAG_t flag; | |
121 | flag.word = gxio_uart_read(context, UART_FLAG); | |
122 | if (flag.wfifo_full) | |
123 | return -1; | |
124 | ||
125 | gxio_uart_write(context, UART_TRANSMIT_DATA, (unsigned long)c); | |
126 | return 0; | |
127 | } | |
128 | ||
129 | ||
130 | /* | |
131 | * Send chars to UART Write FIFO; called by interrupt handler. | |
132 | */ | |
133 | static void handle_transmit(struct tile_uart_port *tile_uart) | |
134 | { | |
135 | unsigned char ch; | |
136 | struct uart_port *port; | |
137 | struct circ_buf *xmit; | |
138 | gxio_uart_context_t *context = &tile_uart->context; | |
139 | ||
140 | /* First reset WFIFO_RE interrupt. */ | |
141 | gxio_uart_write(context, UART_INTERRUPT_STATUS, | |
142 | UART_INTERRUPT_MASK__WFIFO_RE_MASK); | |
143 | ||
144 | port = &tile_uart->uart; | |
145 | xmit = &port->state->xmit; | |
146 | if (port->x_char) { | |
147 | if (tilegx_putchar(context, port->x_char)) | |
148 | return; | |
149 | port->x_char = 0; | |
150 | port->icount.tx++; | |
151 | } | |
152 | ||
153 | if (uart_circ_empty(xmit) || uart_tx_stopped(port)) | |
154 | return; | |
155 | ||
156 | while (!uart_circ_empty(xmit)) { | |
157 | ch = xmit->buf[xmit->tail]; | |
158 | if (tilegx_putchar(context, ch)) | |
159 | break; | |
160 | xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); | |
161 | port->icount.tx++; | |
162 | } | |
163 | ||
164 | /* Reset WFIFO_RE interrupt. */ | |
165 | gxio_uart_write(context, UART_INTERRUPT_STATUS, | |
166 | UART_INTERRUPT_MASK__WFIFO_RE_MASK); | |
167 | ||
168 | if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) | |
169 | uart_write_wakeup(port); | |
170 | } | |
171 | ||
172 | ||
173 | /* | |
174 | * UART Interrupt handler. | |
175 | */ | |
176 | static irqreturn_t tilegx_interrupt(int irq, void *dev_id) | |
177 | { | |
178 | unsigned long flags; | |
179 | UART_INTERRUPT_STATUS_t intr_stat; | |
180 | struct tile_uart_port *tile_uart; | |
181 | gxio_uart_context_t *context; | |
182 | struct uart_port *port = dev_id; | |
183 | irqreturn_t ret = IRQ_NONE; | |
184 | ||
185 | spin_lock_irqsave(&port->lock, flags); | |
186 | ||
187 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
188 | context = &tile_uart->context; | |
189 | intr_stat.word = gxio_uart_read(context, UART_INTERRUPT_STATUS); | |
190 | ||
191 | if (intr_stat.rfifo_we) { | |
192 | handle_receive(tile_uart); | |
193 | ret = IRQ_HANDLED; | |
194 | } | |
195 | if (intr_stat.wfifo_re) { | |
196 | handle_transmit(tile_uart); | |
197 | ret = IRQ_HANDLED; | |
198 | } | |
199 | ||
200 | spin_unlock_irqrestore(&port->lock, flags); | |
201 | return ret; | |
202 | } | |
203 | ||
204 | ||
205 | /* | |
206 | * Return TIOCSER_TEMT when transmitter FIFO is empty. | |
207 | */ | |
208 | static u_int tilegx_tx_empty(struct uart_port *port) | |
209 | { | |
210 | int ret; | |
211 | UART_FLAG_t flag; | |
212 | struct tile_uart_port *tile_uart; | |
213 | gxio_uart_context_t *context; | |
214 | ||
215 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
216 | if (!mutex_trylock(&tile_uart->mutex)) | |
217 | return 0; | |
218 | context = &tile_uart->context; | |
219 | ||
220 | flag.word = gxio_uart_read(context, UART_FLAG); | |
221 | ret = (flag.wfifo_empty) ? TIOCSER_TEMT : 0; | |
222 | mutex_unlock(&tile_uart->mutex); | |
223 | ||
224 | return ret; | |
225 | } | |
226 | ||
227 | ||
228 | /* | |
229 | * Set state of the modem control output lines. | |
230 | */ | |
231 | static void tilegx_set_mctrl(struct uart_port *port, u_int mctrl) | |
232 | { | |
233 | /* N/A */ | |
234 | } | |
235 | ||
236 | ||
237 | /* | |
238 | * Get state of the modem control input lines. | |
239 | */ | |
240 | static u_int tilegx_get_mctrl(struct uart_port *port) | |
241 | { | |
242 | return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; | |
243 | } | |
244 | ||
245 | ||
246 | /* | |
247 | * Stop transmitting. | |
248 | */ | |
249 | static void tilegx_stop_tx(struct uart_port *port) | |
250 | { | |
251 | /* N/A */ | |
252 | } | |
253 | ||
254 | ||
255 | /* | |
256 | * Start transmitting. | |
257 | */ | |
258 | static void tilegx_start_tx(struct uart_port *port) | |
259 | { | |
260 | unsigned char ch; | |
261 | struct circ_buf *xmit; | |
262 | struct tile_uart_port *tile_uart; | |
263 | gxio_uart_context_t *context; | |
264 | ||
265 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
266 | if (!mutex_trylock(&tile_uart->mutex)) | |
267 | return; | |
268 | context = &tile_uart->context; | |
269 | xmit = &port->state->xmit; | |
270 | if (port->x_char) { | |
271 | if (tilegx_putchar(context, port->x_char)) | |
272 | return; | |
273 | port->x_char = 0; | |
274 | port->icount.tx++; | |
275 | } | |
276 | ||
277 | if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { | |
278 | mutex_unlock(&tile_uart->mutex); | |
279 | return; | |
280 | } | |
281 | ||
282 | while (!uart_circ_empty(xmit)) { | |
283 | ch = xmit->buf[xmit->tail]; | |
284 | if (tilegx_putchar(context, ch)) | |
285 | break; | |
286 | xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); | |
287 | port->icount.tx++; | |
288 | } | |
289 | ||
290 | if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) | |
291 | uart_write_wakeup(port); | |
292 | ||
293 | mutex_unlock(&tile_uart->mutex); | |
294 | } | |
295 | ||
296 | ||
297 | /* | |
298 | * Stop receiving - port is in process of being closed. | |
299 | */ | |
300 | static void tilegx_stop_rx(struct uart_port *port) | |
301 | { | |
302 | int err; | |
303 | struct tile_uart_port *tile_uart; | |
304 | gxio_uart_context_t *context; | |
305 | int cpu; | |
306 | ||
307 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
308 | if (!mutex_trylock(&tile_uart->mutex)) | |
309 | return; | |
310 | ||
311 | context = &tile_uart->context; | |
312 | cpu = tile_uart->irq_cpu; | |
313 | err = gxio_uart_cfg_interrupt(context, cpu_x(cpu), cpu_y(cpu), | |
314 | KERNEL_PL, -1); | |
315 | mutex_unlock(&tile_uart->mutex); | |
316 | } | |
317 | ||
b5c6c1a7 CM |
318 | /* |
319 | * Control the transmission of a break signal. | |
320 | */ | |
321 | static void tilegx_break_ctl(struct uart_port *port, int break_state) | |
322 | { | |
323 | /* N/A */ | |
324 | } | |
325 | ||
326 | ||
327 | /* | |
328 | * Perform initialization and enable port for reception. | |
329 | */ | |
330 | static int tilegx_startup(struct uart_port *port) | |
331 | { | |
332 | struct tile_uart_port *tile_uart; | |
333 | gxio_uart_context_t *context; | |
334 | int ret = 0; | |
335 | int cpu = raw_smp_processor_id(); /* pick an arbitrary cpu */ | |
336 | ||
337 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
338 | if (mutex_lock_interruptible(&tile_uart->mutex)) | |
339 | return -EBUSY; | |
340 | context = &tile_uart->context; | |
341 | ||
342 | /* Now open the hypervisor device if we haven't already. */ | |
343 | if (context->fd < 0) { | |
344 | UART_INTERRUPT_MASK_t intr_mask; | |
345 | ||
346 | /* Initialize UART device. */ | |
347 | ret = gxio_uart_init(context, port->line); | |
348 | if (ret) { | |
349 | ret = -ENXIO; | |
350 | goto err; | |
351 | } | |
352 | ||
353 | /* Create our IRQs. */ | |
651fb139 TG |
354 | port->irq = irq_alloc_hwirq(-1); |
355 | if (!port->irq) | |
b5c6c1a7 CM |
356 | goto err_uart_dest; |
357 | tile_irq_activate(port->irq, TILE_IRQ_PERCPU); | |
358 | ||
359 | /* Register our IRQs. */ | |
360 | ret = request_irq(port->irq, tilegx_interrupt, 0, | |
361 | tilegx_uart_driver.driver_name, port); | |
362 | if (ret) | |
363 | goto err_dest_irq; | |
364 | ||
365 | /* Request that the hardware start sending us interrupts. */ | |
366 | tile_uart->irq_cpu = cpu; | |
367 | ret = gxio_uart_cfg_interrupt(context, cpu_x(cpu), cpu_y(cpu), | |
368 | KERNEL_PL, port->irq); | |
369 | if (ret) | |
370 | goto err_free_irq; | |
371 | ||
372 | /* Enable UART Tx/Rx Interrupt. */ | |
373 | intr_mask.word = gxio_uart_read(context, UART_INTERRUPT_MASK); | |
374 | intr_mask.wfifo_re = 0; | |
375 | intr_mask.rfifo_we = 0; | |
376 | gxio_uart_write(context, UART_INTERRUPT_MASK, intr_mask.word); | |
377 | ||
378 | /* Reset the Tx/Rx interrupt in case it's set. */ | |
379 | gxio_uart_write(context, UART_INTERRUPT_STATUS, | |
380 | UART_INTERRUPT_MASK__WFIFO_RE_MASK | | |
381 | UART_INTERRUPT_MASK__RFIFO_WE_MASK); | |
382 | } | |
383 | ||
384 | mutex_unlock(&tile_uart->mutex); | |
385 | return ret; | |
386 | ||
387 | err_free_irq: | |
388 | free_irq(port->irq, port); | |
389 | err_dest_irq: | |
651fb139 | 390 | irq_free_hwirq(port->irq); |
b5c6c1a7 CM |
391 | err_uart_dest: |
392 | gxio_uart_destroy(context); | |
393 | ret = -ENXIO; | |
394 | err: | |
395 | mutex_unlock(&tile_uart->mutex); | |
396 | return ret; | |
397 | } | |
398 | ||
399 | ||
400 | /* | |
401 | * Release kernel resources if it is the last close, disable the port, | |
402 | * free IRQ and close the port. | |
403 | */ | |
404 | static void tilegx_shutdown(struct uart_port *port) | |
405 | { | |
406 | int err; | |
407 | UART_INTERRUPT_MASK_t intr_mask; | |
408 | struct tile_uart_port *tile_uart; | |
409 | gxio_uart_context_t *context; | |
410 | int cpu; | |
411 | ||
412 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
413 | if (mutex_lock_interruptible(&tile_uart->mutex)) | |
414 | return; | |
415 | context = &tile_uart->context; | |
416 | ||
417 | /* Disable UART Tx/Rx Interrupt. */ | |
418 | intr_mask.word = gxio_uart_read(context, UART_INTERRUPT_MASK); | |
419 | intr_mask.wfifo_re = 1; | |
420 | intr_mask.rfifo_we = 1; | |
421 | gxio_uart_write(context, UART_INTERRUPT_MASK, intr_mask.word); | |
422 | ||
423 | /* Request that the hardware stop sending us interrupts. */ | |
424 | cpu = tile_uart->irq_cpu; | |
425 | err = gxio_uart_cfg_interrupt(context, cpu_x(cpu), cpu_y(cpu), | |
426 | KERNEL_PL, -1); | |
427 | ||
428 | if (port->irq > 0) { | |
429 | free_irq(port->irq, port); | |
651fb139 | 430 | irq_free_hwirq(port->irq); |
b5c6c1a7 CM |
431 | port->irq = 0; |
432 | } | |
433 | ||
434 | gxio_uart_destroy(context); | |
435 | ||
436 | mutex_unlock(&tile_uart->mutex); | |
437 | } | |
438 | ||
439 | ||
440 | /* | |
441 | * Flush the buffer. | |
442 | */ | |
443 | static void tilegx_flush_buffer(struct uart_port *port) | |
444 | { | |
445 | /* N/A */ | |
446 | } | |
447 | ||
448 | ||
449 | /* | |
450 | * Change the port parameters. | |
451 | */ | |
452 | static void tilegx_set_termios(struct uart_port *port, | |
453 | struct ktermios *termios, struct ktermios *old) | |
454 | { | |
455 | int err; | |
456 | UART_DIVISOR_t divisor; | |
457 | UART_TYPE_t type; | |
458 | unsigned int baud; | |
459 | struct tile_uart_port *tile_uart; | |
460 | gxio_uart_context_t *context; | |
461 | ||
462 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
463 | if (!mutex_trylock(&tile_uart->mutex)) | |
464 | return; | |
465 | context = &tile_uart->context; | |
466 | ||
467 | /* Open the hypervisor device if we haven't already. */ | |
468 | if (context->fd < 0) { | |
469 | err = gxio_uart_init(context, port->line); | |
470 | if (err) { | |
471 | mutex_unlock(&tile_uart->mutex); | |
472 | return; | |
473 | } | |
474 | } | |
475 | ||
476 | divisor.word = gxio_uart_read(context, UART_DIVISOR); | |
477 | type.word = gxio_uart_read(context, UART_TYPE); | |
478 | ||
479 | /* Divisor. */ | |
480 | baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16); | |
481 | divisor.divisor = uart_get_divisor(port, baud); | |
482 | ||
483 | /* Byte size. */ | |
484 | if ((termios->c_cflag & CSIZE) == CS7) | |
485 | type.dbits = UART_TYPE__DBITS_VAL_SEVEN_DBITS; | |
486 | else | |
487 | type.dbits = UART_TYPE__DBITS_VAL_EIGHT_DBITS; | |
488 | ||
489 | /* Parity. */ | |
490 | if (termios->c_cflag & PARENB) { | |
491 | /* Mark or Space parity. */ | |
492 | if (termios->c_cflag & CMSPAR) | |
493 | if (termios->c_cflag & PARODD) | |
494 | type.ptype = UART_TYPE__PTYPE_VAL_MARK; | |
495 | else | |
496 | type.ptype = UART_TYPE__PTYPE_VAL_SPACE; | |
497 | else if (termios->c_cflag & PARODD) | |
498 | type.ptype = UART_TYPE__PTYPE_VAL_ODD; | |
499 | else | |
500 | type.ptype = UART_TYPE__PTYPE_VAL_EVEN; | |
501 | } else | |
502 | type.ptype = UART_TYPE__PTYPE_VAL_NONE; | |
503 | ||
504 | /* Stop bits. */ | |
505 | if (termios->c_cflag & CSTOPB) | |
506 | type.sbits = UART_TYPE__SBITS_VAL_TWO_SBITS; | |
507 | else | |
508 | type.sbits = UART_TYPE__SBITS_VAL_ONE_SBITS; | |
509 | ||
510 | /* Set the uart paramters. */ | |
511 | gxio_uart_write(context, UART_DIVISOR, divisor.word); | |
512 | gxio_uart_write(context, UART_TYPE, type.word); | |
513 | ||
514 | mutex_unlock(&tile_uart->mutex); | |
515 | } | |
516 | ||
517 | ||
518 | /* | |
519 | * Return string describing the specified port. | |
520 | */ | |
521 | static const char *tilegx_type(struct uart_port *port) | |
522 | { | |
523 | return port->type == PORT_TILEGX ? DRIVER_NAME_STRING : NULL; | |
524 | } | |
525 | ||
526 | ||
527 | /* | |
528 | * Release the resources being used by 'port'. | |
529 | */ | |
530 | static void tilegx_release_port(struct uart_port *port) | |
531 | { | |
532 | /* Nothing to release. */ | |
533 | } | |
534 | ||
535 | ||
536 | /* | |
537 | * Request the resources being used by 'port'. | |
538 | */ | |
539 | static int tilegx_request_port(struct uart_port *port) | |
540 | { | |
541 | /* Always present. */ | |
542 | return 0; | |
543 | } | |
544 | ||
545 | ||
546 | /* | |
547 | * Configure/autoconfigure the port. | |
548 | */ | |
549 | static void tilegx_config_port(struct uart_port *port, int flags) | |
550 | { | |
551 | if (flags & UART_CONFIG_TYPE) | |
552 | port->type = PORT_TILEGX; | |
553 | } | |
554 | ||
555 | ||
556 | /* | |
557 | * Verify the new serial_struct (for TIOCSSERIAL). | |
558 | */ | |
559 | static int tilegx_verify_port(struct uart_port *port, | |
560 | struct serial_struct *ser) | |
561 | { | |
562 | if ((ser->type != PORT_UNKNOWN) && (ser->type != PORT_TILEGX)) | |
563 | return -EINVAL; | |
564 | ||
565 | return 0; | |
566 | } | |
567 | ||
568 | #ifdef CONFIG_CONSOLE_POLL | |
569 | ||
570 | /* | |
571 | * Console polling routines for writing and reading from the uart while | |
572 | * in an interrupt or debug context. | |
573 | */ | |
574 | ||
575 | static int tilegx_poll_get_char(struct uart_port *port) | |
576 | { | |
577 | UART_FIFO_COUNT_t count; | |
578 | gxio_uart_context_t *context; | |
579 | struct tile_uart_port *tile_uart; | |
580 | ||
581 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
582 | context = &tile_uart->context; | |
583 | count.word = gxio_uart_read(context, UART_FIFO_COUNT); | |
584 | if (count.rfifo_count == 0) | |
585 | return NO_POLL_CHAR; | |
586 | return (char)gxio_uart_read(context, UART_RECEIVE_DATA); | |
587 | } | |
588 | ||
589 | static void tilegx_poll_put_char(struct uart_port *port, unsigned char c) | |
590 | { | |
591 | gxio_uart_context_t *context; | |
592 | struct tile_uart_port *tile_uart; | |
593 | ||
594 | tile_uart = container_of(port, struct tile_uart_port, uart); | |
595 | context = &tile_uart->context; | |
596 | gxio_uart_write(context, UART_TRANSMIT_DATA, (unsigned long)c); | |
597 | } | |
598 | ||
599 | #endif /* CONFIG_CONSOLE_POLL */ | |
600 | ||
601 | ||
602 | static const struct uart_ops tilegx_ops = { | |
603 | .tx_empty = tilegx_tx_empty, | |
604 | .set_mctrl = tilegx_set_mctrl, | |
605 | .get_mctrl = tilegx_get_mctrl, | |
606 | .stop_tx = tilegx_stop_tx, | |
607 | .start_tx = tilegx_start_tx, | |
608 | .stop_rx = tilegx_stop_rx, | |
b5c6c1a7 CM |
609 | .break_ctl = tilegx_break_ctl, |
610 | .startup = tilegx_startup, | |
611 | .shutdown = tilegx_shutdown, | |
612 | .flush_buffer = tilegx_flush_buffer, | |
613 | .set_termios = tilegx_set_termios, | |
614 | .type = tilegx_type, | |
615 | .release_port = tilegx_release_port, | |
616 | .request_port = tilegx_request_port, | |
617 | .config_port = tilegx_config_port, | |
618 | .verify_port = tilegx_verify_port, | |
619 | #ifdef CONFIG_CONSOLE_POLL | |
620 | .poll_get_char = tilegx_poll_get_char, | |
621 | .poll_put_char = tilegx_poll_put_char, | |
622 | #endif | |
623 | }; | |
624 | ||
625 | ||
626 | static void tilegx_init_ports(void) | |
627 | { | |
628 | int i; | |
629 | struct uart_port *port; | |
630 | ||
631 | for (i = 0; i < TILEGX_UART_NR; i++) { | |
632 | port = &tile_uart_ports[i].uart; | |
633 | port->ops = &tilegx_ops; | |
634 | port->line = i; | |
635 | port->type = PORT_TILEGX; | |
636 | port->uartclk = TILEGX_UART_REF_CLK; | |
637 | port->flags = UPF_BOOT_AUTOCONF; | |
638 | ||
639 | tile_uart_ports[i].context.fd = -1; | |
640 | mutex_init(&tile_uart_ports[i].mutex); | |
641 | } | |
642 | } | |
643 | ||
644 | ||
645 | static struct uart_driver tilegx_uart_driver = { | |
646 | .owner = THIS_MODULE, | |
647 | .driver_name = DRIVER_NAME_STRING, | |
648 | .dev_name = TILEGX_UART_NAME, | |
649 | .major = TILEGX_UART_MAJOR, | |
650 | .minor = TILEGX_UART_MINOR, | |
651 | .nr = TILEGX_UART_NR, | |
652 | }; | |
653 | ||
654 | ||
655 | static int __init tilegx_init(void) | |
656 | { | |
657 | int i; | |
658 | int ret; | |
659 | struct tty_driver *tty_drv; | |
660 | ||
661 | ret = uart_register_driver(&tilegx_uart_driver); | |
662 | if (ret) | |
663 | return ret; | |
664 | tty_drv = tilegx_uart_driver.tty_driver; | |
665 | tty_drv->init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL; | |
666 | tty_drv->init_termios.c_ispeed = 115200; | |
667 | tty_drv->init_termios.c_ospeed = 115200; | |
668 | ||
669 | tilegx_init_ports(); | |
670 | ||
671 | for (i = 0; i < TILEGX_UART_NR; i++) { | |
672 | struct uart_port *port = &tile_uart_ports[i].uart; | |
673 | ret = uart_add_one_port(&tilegx_uart_driver, port); | |
674 | } | |
675 | ||
676 | return 0; | |
677 | } | |
678 | ||
679 | ||
680 | static void __exit tilegx_exit(void) | |
681 | { | |
682 | int i; | |
683 | struct uart_port *port; | |
684 | ||
685 | for (i = 0; i < TILEGX_UART_NR; i++) { | |
686 | port = &tile_uart_ports[i].uart; | |
687 | uart_remove_one_port(&tilegx_uart_driver, port); | |
688 | } | |
689 | ||
690 | uart_unregister_driver(&tilegx_uart_driver); | |
691 | } | |
692 | ||
693 | ||
694 | module_init(tilegx_init); | |
695 | module_exit(tilegx_exit); | |
696 | ||
697 | MODULE_AUTHOR("Tilera Corporation"); | |
698 | MODULE_DESCRIPTION("TILEGx serial port driver"); | |
699 | MODULE_LICENSE("GPL"); |