2 * linux/drivers/mmc/card/sdio_uart.c - SDIO UART/GPS driver
4 * Based on drivers/serial/8250.c and drivers/serial/serial_core.c
7 * Author: Nicolas Pitre
8 * Created: June 15, 2007
9 * Copyright: MontaVista Software, Inc.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
18 * Note: Although this driver assumes a 16550A-like UART implementation,
19 * it is not possible to leverage the common 8250/16550 driver, nor the
20 * core UART infrastructure, as they assumes direct access to the hardware
21 * registers, often under a spinlock. This is not possible in the SDIO
22 * context as SDIO access functions must be able to sleep.
24 * Because we need to lock the SDIO host to ensure an exclusive access to
25 * the card, we simply rely on that lock to also prevent and serialize
26 * concurrent access to the same port.
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/kernel.h>
32 #include <linux/sched.h>
33 #include <linux/mutex.h>
34 #include <linux/seq_file.h>
35 #include <linux/serial_reg.h>
36 #include <linux/circ_buf.h>
37 #include <linux/tty.h>
38 #include <linux/tty_flip.h>
39 #include <linux/kfifo.h>
40 #include <linux/slab.h>
42 #include <linux/mmc/core.h>
43 #include <linux/mmc/card.h>
44 #include <linux/mmc/sdio_func.h>
45 #include <linux/mmc/sdio_ids.h>
48 #define UART_NR 8 /* Number of UARTs this driver can handle */
51 #define FIFO_SIZE PAGE_SIZE
52 #define WAKEUP_CHARS 256
67 struct sdio_uart_port
{
70 struct tty_struct
*tty
;
72 struct sdio_func
*func
;
73 struct mutex func_lock
;
74 struct task_struct
*in_sdio_uart_irq
;
75 unsigned int regs_offset
;
76 struct kfifo xmit_fifo
;
77 spinlock_t write_lock
;
78 struct uart_icount icount
;
81 unsigned int rx_mctrl
;
82 unsigned int read_status_mask
;
83 unsigned int ignore_status_mask
;
89 static struct sdio_uart_port
*sdio_uart_table
[UART_NR
];
90 static DEFINE_SPINLOCK(sdio_uart_table_lock
);
92 static int sdio_uart_add_port(struct sdio_uart_port
*port
)
94 int index
, ret
= -EBUSY
;
96 kref_init(&port
->kref
);
97 mutex_init(&port
->func_lock
);
98 spin_lock_init(&port
->write_lock
);
99 if (kfifo_alloc(&port
->xmit_fifo
, FIFO_SIZE
, GFP_KERNEL
))
102 spin_lock(&sdio_uart_table_lock
);
103 for (index
= 0; index
< UART_NR
; index
++) {
104 if (!sdio_uart_table
[index
]) {
106 sdio_uart_table
[index
] = port
;
111 spin_unlock(&sdio_uart_table_lock
);
116 static struct sdio_uart_port
*sdio_uart_port_get(unsigned index
)
118 struct sdio_uart_port
*port
;
120 if (index
>= UART_NR
)
123 spin_lock(&sdio_uart_table_lock
);
124 port
= sdio_uart_table
[index
];
126 kref_get(&port
->kref
);
127 spin_unlock(&sdio_uart_table_lock
);
132 static void sdio_uart_port_destroy(struct kref
*kref
)
134 struct sdio_uart_port
*port
=
135 container_of(kref
, struct sdio_uart_port
, kref
);
136 kfifo_free(&port
->xmit_fifo
);
140 static void sdio_uart_port_put(struct sdio_uart_port
*port
)
142 kref_put(&port
->kref
, sdio_uart_port_destroy
);
145 static void sdio_uart_port_remove(struct sdio_uart_port
*port
)
147 struct sdio_func
*func
;
148 struct tty_struct
*tty
;
150 BUG_ON(sdio_uart_table
[port
->index
] != port
);
152 spin_lock(&sdio_uart_table_lock
);
153 sdio_uart_table
[port
->index
] = NULL
;
154 spin_unlock(&sdio_uart_table_lock
);
157 * We're killing a port that potentially still is in use by
158 * the tty layer. Be careful to prevent any further access
159 * to the SDIO function and arrange for the tty layer to
160 * give up on that port ASAP.
161 * Beware: the lock ordering is critical.
163 mutex_lock(&port
->port
.mutex
);
164 mutex_lock(&port
->func_lock
);
166 sdio_claim_host(func
);
168 mutex_unlock(&port
->func_lock
);
169 tty
= tty_port_tty_get(&port
->port
);
170 /* tty_hangup is async so is this safe as is ?? */
175 mutex_unlock(&port
->port
.mutex
);
176 sdio_release_irq(func
);
177 sdio_disable_func(func
);
178 sdio_release_host(func
);
180 sdio_uart_port_put(port
);
183 static int sdio_uart_claim_func(struct sdio_uart_port
*port
)
185 mutex_lock(&port
->func_lock
);
186 if (unlikely(!port
->func
)) {
187 mutex_unlock(&port
->func_lock
);
190 if (likely(port
->in_sdio_uart_irq
!= current
))
191 sdio_claim_host(port
->func
);
192 mutex_unlock(&port
->func_lock
);
196 static inline void sdio_uart_release_func(struct sdio_uart_port
*port
)
198 if (likely(port
->in_sdio_uart_irq
!= current
))
199 sdio_release_host(port
->func
);
202 static inline unsigned int sdio_in(struct sdio_uart_port
*port
, int offset
)
205 c
= sdio_readb(port
->func
, port
->regs_offset
+ offset
, NULL
);
209 static inline void sdio_out(struct sdio_uart_port
*port
, int offset
, int value
)
211 sdio_writeb(port
->func
, value
, port
->regs_offset
+ offset
, NULL
);
214 static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port
*port
)
216 unsigned char status
;
219 status
= sdio_in(port
, UART_MSR
);
222 if (status
& UART_MSR_DCD
)
224 if (status
& UART_MSR_RI
)
226 if (status
& UART_MSR_DSR
)
228 if (status
& UART_MSR_CTS
)
233 static void sdio_uart_write_mctrl(struct sdio_uart_port
*port
,
236 unsigned char mcr
= 0;
238 if (mctrl
& TIOCM_RTS
)
240 if (mctrl
& TIOCM_DTR
)
242 if (mctrl
& TIOCM_OUT1
)
243 mcr
|= UART_MCR_OUT1
;
244 if (mctrl
& TIOCM_OUT2
)
245 mcr
|= UART_MCR_OUT2
;
246 if (mctrl
& TIOCM_LOOP
)
247 mcr
|= UART_MCR_LOOP
;
249 sdio_out(port
, UART_MCR
, mcr
);
252 static inline void sdio_uart_update_mctrl(struct sdio_uart_port
*port
,
253 unsigned int set
, unsigned int clear
)
258 port
->mctrl
= (old
& ~clear
) | set
;
259 if (old
!= port
->mctrl
)
260 sdio_uart_write_mctrl(port
, port
->mctrl
);
263 #define sdio_uart_set_mctrl(port, x) sdio_uart_update_mctrl(port, x, 0)
264 #define sdio_uart_clear_mctrl(port, x) sdio_uart_update_mctrl(port, 0, x)
266 static void sdio_uart_change_speed(struct sdio_uart_port
*port
,
267 struct ktermios
*termios
,
268 struct ktermios
*old
)
270 unsigned char cval
, fcr
= 0;
271 unsigned int baud
, quot
;
273 switch (termios
->c_cflag
& CSIZE
) {
275 cval
= UART_LCR_WLEN5
;
278 cval
= UART_LCR_WLEN6
;
281 cval
= UART_LCR_WLEN7
;
285 cval
= UART_LCR_WLEN8
;
289 if (termios
->c_cflag
& CSTOPB
)
290 cval
|= UART_LCR_STOP
;
291 if (termios
->c_cflag
& PARENB
)
292 cval
|= UART_LCR_PARITY
;
293 if (!(termios
->c_cflag
& PARODD
))
294 cval
|= UART_LCR_EPAR
;
297 baud
= tty_termios_baud_rate(termios
);
299 baud
= 9600; /* Special case: B0 rate. */
300 if (baud
<= port
->uartclk
)
303 * Oops, the quotient was zero. Try again with the old
304 * baud rate if possible, otherwise default to 9600.
306 termios
->c_cflag
&= ~CBAUD
;
308 termios
->c_cflag
|= old
->c_cflag
& CBAUD
;
311 termios
->c_cflag
|= B9600
;
313 quot
= (2 * port
->uartclk
+ baud
) / (2 * baud
);
316 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_TRIGGER_1
;
318 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_R_TRIG_10
;
320 port
->read_status_mask
= UART_LSR_OE
| UART_LSR_THRE
| UART_LSR_DR
;
321 if (termios
->c_iflag
& INPCK
)
322 port
->read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
323 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
324 port
->read_status_mask
|= UART_LSR_BI
;
327 * Characters to ignore
329 port
->ignore_status_mask
= 0;
330 if (termios
->c_iflag
& IGNPAR
)
331 port
->ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
332 if (termios
->c_iflag
& IGNBRK
) {
333 port
->ignore_status_mask
|= UART_LSR_BI
;
335 * If we're ignoring parity and break indicators,
336 * ignore overruns too (for real raw support).
338 if (termios
->c_iflag
& IGNPAR
)
339 port
->ignore_status_mask
|= UART_LSR_OE
;
343 * ignore all characters if CREAD is not set
345 if ((termios
->c_cflag
& CREAD
) == 0)
346 port
->ignore_status_mask
|= UART_LSR_DR
;
349 * CTS flow control flag and modem status interrupts
351 port
->ier
&= ~UART_IER_MSI
;
352 if ((termios
->c_cflag
& CRTSCTS
) || !(termios
->c_cflag
& CLOCAL
))
353 port
->ier
|= UART_IER_MSI
;
357 sdio_out(port
, UART_IER
, port
->ier
);
358 sdio_out(port
, UART_LCR
, cval
| UART_LCR_DLAB
);
359 sdio_out(port
, UART_DLL
, quot
& 0xff);
360 sdio_out(port
, UART_DLM
, quot
>> 8);
361 sdio_out(port
, UART_LCR
, cval
);
362 sdio_out(port
, UART_FCR
, fcr
);
364 sdio_uart_write_mctrl(port
, port
->mctrl
);
367 static void sdio_uart_start_tx(struct sdio_uart_port
*port
)
369 if (!(port
->ier
& UART_IER_THRI
)) {
370 port
->ier
|= UART_IER_THRI
;
371 sdio_out(port
, UART_IER
, port
->ier
);
375 static void sdio_uart_stop_tx(struct sdio_uart_port
*port
)
377 if (port
->ier
& UART_IER_THRI
) {
378 port
->ier
&= ~UART_IER_THRI
;
379 sdio_out(port
, UART_IER
, port
->ier
);
383 static void sdio_uart_stop_rx(struct sdio_uart_port
*port
)
385 port
->ier
&= ~UART_IER_RLSI
;
386 port
->read_status_mask
&= ~UART_LSR_DR
;
387 sdio_out(port
, UART_IER
, port
->ier
);
390 static void sdio_uart_receive_chars(struct sdio_uart_port
*port
,
391 unsigned int *status
)
393 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
394 unsigned int ch
, flag
;
398 ch
= sdio_in(port
, UART_RX
);
402 if (unlikely(*status
& (UART_LSR_BI
| UART_LSR_PE
|
403 UART_LSR_FE
| UART_LSR_OE
))) {
405 * For statistics only
407 if (*status
& UART_LSR_BI
) {
408 *status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
410 } else if (*status
& UART_LSR_PE
)
411 port
->icount
.parity
++;
412 else if (*status
& UART_LSR_FE
)
413 port
->icount
.frame
++;
414 if (*status
& UART_LSR_OE
)
415 port
->icount
.overrun
++;
418 * Mask off conditions which should be ignored.
420 *status
&= port
->read_status_mask
;
421 if (*status
& UART_LSR_BI
)
423 else if (*status
& UART_LSR_PE
)
425 else if (*status
& UART_LSR_FE
)
429 if ((*status
& port
->ignore_status_mask
& ~UART_LSR_OE
) == 0)
431 tty_insert_flip_char(tty
, ch
, flag
);
434 * Overrun is special. Since it's reported immediately,
435 * it doesn't affect the current character.
437 if (*status
& ~port
->ignore_status_mask
& UART_LSR_OE
)
439 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
441 *status
= sdio_in(port
, UART_LSR
);
442 } while ((*status
& UART_LSR_DR
) && (max_count
-- > 0));
444 tty_flip_buffer_push(tty
);
449 static void sdio_uart_transmit_chars(struct sdio_uart_port
*port
)
451 struct kfifo
*xmit
= &port
->xmit_fifo
;
453 struct tty_struct
*tty
;
458 sdio_out(port
, UART_TX
, port
->x_char
);
464 tty
= tty_port_tty_get(&port
->port
);
466 if (tty
== NULL
|| !kfifo_len(xmit
) ||
467 tty
->stopped
|| tty
->hw_stopped
) {
468 sdio_uart_stop_tx(port
);
473 len
= kfifo_out_locked(xmit
, iobuf
, 16, &port
->write_lock
);
474 for (count
= 0; count
< len
; count
++) {
475 sdio_out(port
, UART_TX
, iobuf
[count
]);
479 len
= kfifo_len(xmit
);
480 if (len
< WAKEUP_CHARS
) {
483 sdio_uart_stop_tx(port
);
488 static void sdio_uart_check_modem_status(struct sdio_uart_port
*port
)
491 struct tty_struct
*tty
;
493 status
= sdio_in(port
, UART_MSR
);
495 if ((status
& UART_MSR_ANY_DELTA
) == 0)
498 if (status
& UART_MSR_TERI
)
500 if (status
& UART_MSR_DDSR
)
502 if (status
& UART_MSR_DDCD
) {
504 /* DCD raise - wake for open */
505 if (status
& UART_MSR_DCD
)
506 wake_up_interruptible(&port
->port
.open_wait
);
508 /* DCD drop - hang up if tty attached */
509 tty
= tty_port_tty_get(&port
->port
);
516 if (status
& UART_MSR_DCTS
) {
518 tty
= tty_port_tty_get(&port
->port
);
519 if (tty
&& (tty
->termios
->c_cflag
& CRTSCTS
)) {
520 int cts
= (status
& UART_MSR_CTS
);
521 if (tty
->hw_stopped
) {
524 sdio_uart_start_tx(port
);
530 sdio_uart_stop_tx(port
);
539 * This handles the interrupt from one port.
541 static void sdio_uart_irq(struct sdio_func
*func
)
543 struct sdio_uart_port
*port
= sdio_get_drvdata(func
);
544 unsigned int iir
, lsr
;
547 * In a few places sdio_uart_irq() is called directly instead of
548 * waiting for the actual interrupt to be raised and the SDIO IRQ
549 * thread scheduled in order to reduce latency. However, some
550 * interaction with the tty core may end up calling us back
551 * (serial echo, flow control, etc.) through those same places
552 * causing undesirable effects. Let's stop the recursion here.
554 if (unlikely(port
->in_sdio_uart_irq
== current
))
557 iir
= sdio_in(port
, UART_IIR
);
558 if (iir
& UART_IIR_NO_INT
)
561 port
->in_sdio_uart_irq
= current
;
562 lsr
= sdio_in(port
, UART_LSR
);
563 if (lsr
& UART_LSR_DR
)
564 sdio_uart_receive_chars(port
, &lsr
);
565 sdio_uart_check_modem_status(port
);
566 if (lsr
& UART_LSR_THRE
)
567 sdio_uart_transmit_chars(port
);
568 port
->in_sdio_uart_irq
= NULL
;
571 static int uart_carrier_raised(struct tty_port
*tport
)
573 struct sdio_uart_port
*port
=
574 container_of(tport
, struct sdio_uart_port
, port
);
575 unsigned int ret
= sdio_uart_claim_func(port
);
576 if (ret
) /* Missing hardware shouldn't block for carrier */
578 ret
= sdio_uart_get_mctrl(port
);
579 sdio_uart_release_func(port
);
586 * uart_dtr_rts - port helper to set uart signals
587 * @tport: tty port to be updated
588 * @onoff: set to turn on DTR/RTS
590 * Called by the tty port helpers when the modem signals need to be
591 * adjusted during an open, close and hangup.
594 static void uart_dtr_rts(struct tty_port
*tport
, int onoff
)
596 struct sdio_uart_port
*port
=
597 container_of(tport
, struct sdio_uart_port
, port
);
598 int ret
= sdio_uart_claim_func(port
);
602 sdio_uart_clear_mctrl(port
, TIOCM_DTR
| TIOCM_RTS
);
604 sdio_uart_set_mctrl(port
, TIOCM_DTR
| TIOCM_RTS
);
605 sdio_uart_release_func(port
);
609 * sdio_uart_activate - start up hardware
610 * @tport: tty port to activate
611 * @tty: tty bound to this port
613 * Activate a tty port. The port locking guarantees us this will be
614 * run exactly once per set of opens, and if successful will see the
615 * shutdown method run exactly once to match. Start up and shutdown are
616 * protected from each other by the internal locking and will not run
617 * at the same time even during a hangup event.
619 * If we successfully start up the port we take an extra kref as we
620 * will keep it around until shutdown when the kref is dropped.
623 static int sdio_uart_activate(struct tty_port
*tport
, struct tty_struct
*tty
)
625 struct sdio_uart_port
*port
=
626 container_of(tport
, struct sdio_uart_port
, port
);
630 * Set the TTY IO error marker - we will only clear this
631 * once we have successfully opened the port.
633 set_bit(TTY_IO_ERROR
, &tty
->flags
);
635 kfifo_reset(&port
->xmit_fifo
);
637 ret
= sdio_uart_claim_func(port
);
640 ret
= sdio_enable_func(port
->func
);
643 ret
= sdio_claim_irq(port
->func
, sdio_uart_irq
);
648 * Clear the FIFO buffers and disable them.
649 * (they will be reenabled in sdio_change_speed())
651 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
652 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
653 UART_FCR_CLEAR_RCVR
| UART_FCR_CLEAR_XMIT
);
654 sdio_out(port
, UART_FCR
, 0);
657 * Clear the interrupt registers.
659 (void) sdio_in(port
, UART_LSR
);
660 (void) sdio_in(port
, UART_RX
);
661 (void) sdio_in(port
, UART_IIR
);
662 (void) sdio_in(port
, UART_MSR
);
665 * Now, initialize the UART
667 sdio_out(port
, UART_LCR
, UART_LCR_WLEN8
);
669 port
->ier
= UART_IER_RLSI
|UART_IER_RDI
|UART_IER_RTOIE
|UART_IER_UUE
;
670 port
->mctrl
= TIOCM_OUT2
;
672 sdio_uart_change_speed(port
, tty
->termios
, NULL
);
674 if (tty
->termios
->c_cflag
& CBAUD
)
675 sdio_uart_set_mctrl(port
, TIOCM_RTS
| TIOCM_DTR
);
677 if (tty
->termios
->c_cflag
& CRTSCTS
)
678 if (!(sdio_uart_get_mctrl(port
) & TIOCM_CTS
))
681 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
683 /* Kick the IRQ handler once while we're still holding the host lock */
684 sdio_uart_irq(port
->func
);
686 sdio_uart_release_func(port
);
690 sdio_disable_func(port
->func
);
692 sdio_uart_release_func(port
);
697 * sdio_uart_shutdown - stop hardware
698 * @tport: tty port to shut down
700 * Deactivate a tty port. The port locking guarantees us this will be
701 * run only if a successful matching activate already ran. The two are
702 * protected from each other by the internal locking and will not run
703 * at the same time even during a hangup event.
706 static void sdio_uart_shutdown(struct tty_port
*tport
)
708 struct sdio_uart_port
*port
=
709 container_of(tport
, struct sdio_uart_port
, port
);
712 ret
= sdio_uart_claim_func(port
);
716 sdio_uart_stop_rx(port
);
718 /* Disable interrupts from this port */
719 sdio_release_irq(port
->func
);
721 sdio_out(port
, UART_IER
, 0);
723 sdio_uart_clear_mctrl(port
, TIOCM_OUT2
);
725 /* Disable break condition and FIFOs. */
726 port
->lcr
&= ~UART_LCR_SBC
;
727 sdio_out(port
, UART_LCR
, port
->lcr
);
728 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
729 UART_FCR_CLEAR_RCVR
|
730 UART_FCR_CLEAR_XMIT
);
731 sdio_out(port
, UART_FCR
, 0);
733 sdio_disable_func(port
->func
);
735 sdio_uart_release_func(port
);
739 * sdio_uart_install - install method
740 * @driver: the driver in use (sdio_uart in our case)
741 * @tty: the tty being bound
743 * Look up and bind the tty and the driver together. Initialize
744 * any needed private data (in our case the termios)
747 static int sdio_uart_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
749 int idx
= tty
->index
;
750 struct sdio_uart_port
*port
= sdio_uart_port_get(idx
);
751 int ret
= tty_init_termios(tty
);
754 tty_driver_kref_get(driver
);
756 /* This is the ref sdio_uart_port get provided */
757 tty
->driver_data
= port
;
758 driver
->ttys
[idx
] = tty
;
760 sdio_uart_port_put(port
);
765 * sdio_uart_cleanup - called on the last tty kref drop
766 * @tty: the tty being destroyed
768 * Called asynchronously when the last reference to the tty is dropped.
769 * We cannot destroy the tty->driver_data port kref until this point
772 static void sdio_uart_cleanup(struct tty_struct
*tty
)
774 struct sdio_uart_port
*port
= tty
->driver_data
;
775 tty
->driver_data
= NULL
; /* Bug trap */
776 sdio_uart_port_put(port
);
780 * Open/close/hangup is now entirely boilerplate
783 static int sdio_uart_open(struct tty_struct
*tty
, struct file
*filp
)
785 struct sdio_uart_port
*port
= tty
->driver_data
;
786 return tty_port_open(&port
->port
, tty
, filp
);
789 static void sdio_uart_close(struct tty_struct
*tty
, struct file
* filp
)
791 struct sdio_uart_port
*port
= tty
->driver_data
;
792 tty_port_close(&port
->port
, tty
, filp
);
795 static void sdio_uart_hangup(struct tty_struct
*tty
)
797 struct sdio_uart_port
*port
= tty
->driver_data
;
798 tty_port_hangup(&port
->port
);
801 static int sdio_uart_write(struct tty_struct
*tty
, const unsigned char *buf
,
804 struct sdio_uart_port
*port
= tty
->driver_data
;
810 ret
= kfifo_in_locked(&port
->xmit_fifo
, buf
, count
, &port
->write_lock
);
811 if (!(port
->ier
& UART_IER_THRI
)) {
812 int err
= sdio_uart_claim_func(port
);
814 sdio_uart_start_tx(port
);
815 sdio_uart_irq(port
->func
);
816 sdio_uart_release_func(port
);
824 static int sdio_uart_write_room(struct tty_struct
*tty
)
826 struct sdio_uart_port
*port
= tty
->driver_data
;
827 return FIFO_SIZE
- kfifo_len(&port
->xmit_fifo
);
830 static int sdio_uart_chars_in_buffer(struct tty_struct
*tty
)
832 struct sdio_uart_port
*port
= tty
->driver_data
;
833 return kfifo_len(&port
->xmit_fifo
);
836 static void sdio_uart_send_xchar(struct tty_struct
*tty
, char ch
)
838 struct sdio_uart_port
*port
= tty
->driver_data
;
841 if (ch
&& !(port
->ier
& UART_IER_THRI
)) {
842 if (sdio_uart_claim_func(port
) != 0)
844 sdio_uart_start_tx(port
);
845 sdio_uart_irq(port
->func
);
846 sdio_uart_release_func(port
);
850 static void sdio_uart_throttle(struct tty_struct
*tty
)
852 struct sdio_uart_port
*port
= tty
->driver_data
;
854 if (!I_IXOFF(tty
) && !(tty
->termios
->c_cflag
& CRTSCTS
))
857 if (sdio_uart_claim_func(port
) != 0)
861 port
->x_char
= STOP_CHAR(tty
);
862 sdio_uart_start_tx(port
);
865 if (tty
->termios
->c_cflag
& CRTSCTS
)
866 sdio_uart_clear_mctrl(port
, TIOCM_RTS
);
868 sdio_uart_irq(port
->func
);
869 sdio_uart_release_func(port
);
872 static void sdio_uart_unthrottle(struct tty_struct
*tty
)
874 struct sdio_uart_port
*port
= tty
->driver_data
;
876 if (!I_IXOFF(tty
) && !(tty
->termios
->c_cflag
& CRTSCTS
))
879 if (sdio_uart_claim_func(port
) != 0)
886 port
->x_char
= START_CHAR(tty
);
887 sdio_uart_start_tx(port
);
891 if (tty
->termios
->c_cflag
& CRTSCTS
)
892 sdio_uart_set_mctrl(port
, TIOCM_RTS
);
894 sdio_uart_irq(port
->func
);
895 sdio_uart_release_func(port
);
898 static void sdio_uart_set_termios(struct tty_struct
*tty
,
899 struct ktermios
*old_termios
)
901 struct sdio_uart_port
*port
= tty
->driver_data
;
902 unsigned int cflag
= tty
->termios
->c_cflag
;
904 if (sdio_uart_claim_func(port
) != 0)
907 sdio_uart_change_speed(port
, tty
->termios
, old_termios
);
909 /* Handle transition to B0 status */
910 if ((old_termios
->c_cflag
& CBAUD
) && !(cflag
& CBAUD
))
911 sdio_uart_clear_mctrl(port
, TIOCM_RTS
| TIOCM_DTR
);
913 /* Handle transition away from B0 status */
914 if (!(old_termios
->c_cflag
& CBAUD
) && (cflag
& CBAUD
)) {
915 unsigned int mask
= TIOCM_DTR
;
916 if (!(cflag
& CRTSCTS
) || !test_bit(TTY_THROTTLED
, &tty
->flags
))
918 sdio_uart_set_mctrl(port
, mask
);
921 /* Handle turning off CRTSCTS */
922 if ((old_termios
->c_cflag
& CRTSCTS
) && !(cflag
& CRTSCTS
)) {
924 sdio_uart_start_tx(port
);
927 /* Handle turning on CRTSCTS */
928 if (!(old_termios
->c_cflag
& CRTSCTS
) && (cflag
& CRTSCTS
)) {
929 if (!(sdio_uart_get_mctrl(port
) & TIOCM_CTS
)) {
931 sdio_uart_stop_tx(port
);
935 sdio_uart_release_func(port
);
938 static int sdio_uart_break_ctl(struct tty_struct
*tty
, int break_state
)
940 struct sdio_uart_port
*port
= tty
->driver_data
;
943 result
= sdio_uart_claim_func(port
);
947 if (break_state
== -1)
948 port
->lcr
|= UART_LCR_SBC
;
950 port
->lcr
&= ~UART_LCR_SBC
;
951 sdio_out(port
, UART_LCR
, port
->lcr
);
953 sdio_uart_release_func(port
);
957 static int sdio_uart_tiocmget(struct tty_struct
*tty
, struct file
*file
)
959 struct sdio_uart_port
*port
= tty
->driver_data
;
962 result
= sdio_uart_claim_func(port
);
964 result
= port
->mctrl
| sdio_uart_get_mctrl(port
);
965 sdio_uart_release_func(port
);
971 static int sdio_uart_tiocmset(struct tty_struct
*tty
, struct file
*file
,
972 unsigned int set
, unsigned int clear
)
974 struct sdio_uart_port
*port
= tty
->driver_data
;
977 result
= sdio_uart_claim_func(port
);
979 sdio_uart_update_mctrl(port
, set
, clear
);
980 sdio_uart_release_func(port
);
986 static int sdio_uart_proc_show(struct seq_file
*m
, void *v
)
990 seq_printf(m
, "serinfo:1.0 driver%s%s revision:%s\n",
992 for (i
= 0; i
< UART_NR
; i
++) {
993 struct sdio_uart_port
*port
= sdio_uart_port_get(i
);
995 seq_printf(m
, "%d: uart:SDIO", i
);
996 if (capable(CAP_SYS_ADMIN
)) {
997 seq_printf(m
, " tx:%d rx:%d",
998 port
->icount
.tx
, port
->icount
.rx
);
999 if (port
->icount
.frame
)
1000 seq_printf(m
, " fe:%d",
1001 port
->icount
.frame
);
1002 if (port
->icount
.parity
)
1003 seq_printf(m
, " pe:%d",
1004 port
->icount
.parity
);
1005 if (port
->icount
.brk
)
1006 seq_printf(m
, " brk:%d",
1008 if (port
->icount
.overrun
)
1009 seq_printf(m
, " oe:%d",
1010 port
->icount
.overrun
);
1011 if (port
->icount
.cts
)
1012 seq_printf(m
, " cts:%d",
1014 if (port
->icount
.dsr
)
1015 seq_printf(m
, " dsr:%d",
1017 if (port
->icount
.rng
)
1018 seq_printf(m
, " rng:%d",
1020 if (port
->icount
.dcd
)
1021 seq_printf(m
, " dcd:%d",
1024 sdio_uart_port_put(port
);
1031 static int sdio_uart_proc_open(struct inode
*inode
, struct file
*file
)
1033 return single_open(file
, sdio_uart_proc_show
, NULL
);
1036 static const struct file_operations sdio_uart_proc_fops
= {
1037 .owner
= THIS_MODULE
,
1038 .open
= sdio_uart_proc_open
,
1040 .llseek
= seq_lseek
,
1041 .release
= single_release
,
1044 static const struct tty_port_operations sdio_uart_port_ops
= {
1045 .dtr_rts
= uart_dtr_rts
,
1046 .carrier_raised
= uart_carrier_raised
,
1047 .shutdown
= sdio_uart_shutdown
,
1048 .activate
= sdio_uart_activate
,
1051 static const struct tty_operations sdio_uart_ops
= {
1052 .open
= sdio_uart_open
,
1053 .close
= sdio_uart_close
,
1054 .write
= sdio_uart_write
,
1055 .write_room
= sdio_uart_write_room
,
1056 .chars_in_buffer
= sdio_uart_chars_in_buffer
,
1057 .send_xchar
= sdio_uart_send_xchar
,
1058 .throttle
= sdio_uart_throttle
,
1059 .unthrottle
= sdio_uart_unthrottle
,
1060 .set_termios
= sdio_uart_set_termios
,
1061 .hangup
= sdio_uart_hangup
,
1062 .break_ctl
= sdio_uart_break_ctl
,
1063 .tiocmget
= sdio_uart_tiocmget
,
1064 .tiocmset
= sdio_uart_tiocmset
,
1065 .install
= sdio_uart_install
,
1066 .cleanup
= sdio_uart_cleanup
,
1067 .proc_fops
= &sdio_uart_proc_fops
,
1070 static struct tty_driver
*sdio_uart_tty_driver
;
1072 static int sdio_uart_probe(struct sdio_func
*func
,
1073 const struct sdio_device_id
*id
)
1075 struct sdio_uart_port
*port
;
1078 port
= kzalloc(sizeof(struct sdio_uart_port
), GFP_KERNEL
);
1082 if (func
->class == SDIO_CLASS_UART
) {
1083 printk(KERN_WARNING
"%s: need info on UART class basic setup\n",
1084 sdio_func_id(func
));
1087 } else if (func
->class == SDIO_CLASS_GPS
) {
1089 * We need tuple 0x91. It contains SUBTPL_SIOREG
1090 * and SUBTPL_RCVCAPS.
1092 struct sdio_func_tuple
*tpl
;
1093 for (tpl
= func
->tuples
; tpl
; tpl
= tpl
->next
) {
1094 if (tpl
->code
!= 0x91)
1098 if (tpl
->data
[1] == 0) /* SUBTPL_SIOREG */
1103 "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
1104 sdio_func_id(func
));
1108 printk(KERN_DEBUG
"%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
1109 sdio_func_id(func
), tpl
->data
[2], tpl
->data
[3]);
1110 port
->regs_offset
= (tpl
->data
[4] << 0) |
1111 (tpl
->data
[5] << 8) |
1112 (tpl
->data
[6] << 16);
1113 printk(KERN_DEBUG
"%s: regs offset = 0x%x\n",
1114 sdio_func_id(func
), port
->regs_offset
);
1115 port
->uartclk
= tpl
->data
[7] * 115200;
1116 if (port
->uartclk
== 0)
1117 port
->uartclk
= 115200;
1118 printk(KERN_DEBUG
"%s: clk %d baudcode %u 4800-div %u\n",
1119 sdio_func_id(func
), port
->uartclk
,
1120 tpl
->data
[7], tpl
->data
[8] | (tpl
->data
[9] << 8));
1127 sdio_set_drvdata(func
, port
);
1128 tty_port_init(&port
->port
);
1129 port
->port
.ops
= &sdio_uart_port_ops
;
1131 ret
= sdio_uart_add_port(port
);
1136 dev
= tty_register_device(sdio_uart_tty_driver
,
1137 port
->index
, &func
->dev
);
1139 sdio_uart_port_remove(port
);
1147 static void sdio_uart_remove(struct sdio_func
*func
)
1149 struct sdio_uart_port
*port
= sdio_get_drvdata(func
);
1151 tty_unregister_device(sdio_uart_tty_driver
, port
->index
);
1152 sdio_uart_port_remove(port
);
1155 static const struct sdio_device_id sdio_uart_ids
[] = {
1156 { SDIO_DEVICE_CLASS(SDIO_CLASS_UART
) },
1157 { SDIO_DEVICE_CLASS(SDIO_CLASS_GPS
) },
1158 { /* end: all zeroes */ },
1161 MODULE_DEVICE_TABLE(sdio
, sdio_uart_ids
);
1163 static struct sdio_driver sdio_uart_driver
= {
1164 .probe
= sdio_uart_probe
,
1165 .remove
= sdio_uart_remove
,
1166 .name
= "sdio_uart",
1167 .id_table
= sdio_uart_ids
,
1170 static int __init
sdio_uart_init(void)
1173 struct tty_driver
*tty_drv
;
1175 sdio_uart_tty_driver
= tty_drv
= alloc_tty_driver(UART_NR
);
1179 tty_drv
->owner
= THIS_MODULE
;
1180 tty_drv
->driver_name
= "sdio_uart";
1181 tty_drv
->name
= "ttySDIO";
1182 tty_drv
->major
= 0; /* dynamically allocated */
1183 tty_drv
->minor_start
= 0;
1184 tty_drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
1185 tty_drv
->subtype
= SERIAL_TYPE_NORMAL
;
1186 tty_drv
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1187 tty_drv
->init_termios
= tty_std_termios
;
1188 tty_drv
->init_termios
.c_cflag
= B4800
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1189 tty_drv
->init_termios
.c_ispeed
= 4800;
1190 tty_drv
->init_termios
.c_ospeed
= 4800;
1191 tty_set_operations(tty_drv
, &sdio_uart_ops
);
1193 ret
= tty_register_driver(tty_drv
);
1197 ret
= sdio_register_driver(&sdio_uart_driver
);
1204 tty_unregister_driver(tty_drv
);
1206 put_tty_driver(tty_drv
);
1210 static void __exit
sdio_uart_exit(void)
1212 sdio_unregister_driver(&sdio_uart_driver
);
1213 tty_unregister_driver(sdio_uart_tty_driver
);
1214 put_tty_driver(sdio_uart_tty_driver
);
1217 module_init(sdio_uart_init
);
1218 module_exit(sdio_uart_exit
);
1220 MODULE_AUTHOR("Nicolas Pitre");
1221 MODULE_LICENSE("GPL");