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/mutex.h>
33 #include <linux/seq_file.h>
34 #include <linux/serial_reg.h>
35 #include <linux/circ_buf.h>
36 #include <linux/gfp.h>
37 #include <linux/tty.h>
38 #include <linux/tty_flip.h>
40 #include <linux/mmc/core.h>
41 #include <linux/mmc/card.h>
42 #include <linux/mmc/sdio_func.h>
43 #include <linux/mmc/sdio_ids.h>
46 #define UART_NR 8 /* Number of UARTs this driver can handle */
49 #define UART_XMIT_SIZE PAGE_SIZE
50 #define WAKEUP_CHARS 256
52 #define circ_empty(circ) ((circ)->head == (circ)->tail)
53 #define circ_clear(circ) ((circ)->head = (circ)->tail = 0)
55 #define circ_chars_pending(circ) \
56 (CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
58 #define circ_chars_free(circ) \
59 (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
75 struct sdio_uart_port
{
78 struct tty_struct
*tty
;
81 struct mutex open_lock
;
82 struct sdio_func
*func
;
83 struct mutex func_lock
;
84 struct task_struct
*in_sdio_uart_irq
;
85 unsigned int regs_offset
;
87 spinlock_t write_lock
;
88 struct uart_icount icount
;
91 unsigned int read_status_mask
;
92 unsigned int ignore_status_mask
;
98 static struct sdio_uart_port
*sdio_uart_table
[UART_NR
];
99 static DEFINE_SPINLOCK(sdio_uart_table_lock
);
101 static int sdio_uart_add_port(struct sdio_uart_port
*port
)
103 int index
, ret
= -EBUSY
;
105 kref_init(&port
->kref
);
106 mutex_init(&port
->open_lock
);
107 mutex_init(&port
->func_lock
);
108 spin_lock_init(&port
->write_lock
);
110 spin_lock(&sdio_uart_table_lock
);
111 for (index
= 0; index
< UART_NR
; index
++) {
112 if (!sdio_uart_table
[index
]) {
114 sdio_uart_table
[index
] = port
;
119 spin_unlock(&sdio_uart_table_lock
);
124 static struct sdio_uart_port
*sdio_uart_port_get(unsigned index
)
126 struct sdio_uart_port
*port
;
128 if (index
>= UART_NR
)
131 spin_lock(&sdio_uart_table_lock
);
132 port
= sdio_uart_table
[index
];
134 kref_get(&port
->kref
);
135 spin_unlock(&sdio_uart_table_lock
);
140 static void sdio_uart_port_destroy(struct kref
*kref
)
142 struct sdio_uart_port
*port
=
143 container_of(kref
, struct sdio_uart_port
, kref
);
147 static void sdio_uart_port_put(struct sdio_uart_port
*port
)
149 kref_put(&port
->kref
, sdio_uart_port_destroy
);
152 static void sdio_uart_port_remove(struct sdio_uart_port
*port
)
154 struct sdio_func
*func
;
156 BUG_ON(sdio_uart_table
[port
->index
] != port
);
158 spin_lock(&sdio_uart_table_lock
);
159 sdio_uart_table
[port
->index
] = NULL
;
160 spin_unlock(&sdio_uart_table_lock
);
163 * We're killing a port that potentially still is in use by
164 * the tty layer. Be careful to prevent any further access
165 * to the SDIO function and arrange for the tty layer to
166 * give up on that port ASAP.
167 * Beware: the lock ordering is critical.
169 mutex_lock(&port
->open_lock
);
170 mutex_lock(&port
->func_lock
);
172 sdio_claim_host(func
);
174 mutex_unlock(&port
->func_lock
);
176 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
177 /* tty_hangup is async so is this safe as is ?? */
182 mutex_unlock(&port
->open_lock
);
183 sdio_release_irq(func
);
184 sdio_disable_func(func
);
185 sdio_release_host(func
);
187 sdio_uart_port_put(port
);
190 static int sdio_uart_claim_func(struct sdio_uart_port
*port
)
192 mutex_lock(&port
->func_lock
);
193 if (unlikely(!port
->func
)) {
194 mutex_unlock(&port
->func_lock
);
197 if (likely(port
->in_sdio_uart_irq
!= current
))
198 sdio_claim_host(port
->func
);
199 mutex_unlock(&port
->func_lock
);
203 static inline void sdio_uart_release_func(struct sdio_uart_port
*port
)
205 if (likely(port
->in_sdio_uart_irq
!= current
))
206 sdio_release_host(port
->func
);
209 static inline unsigned int sdio_in(struct sdio_uart_port
*port
, int offset
)
212 c
= sdio_readb(port
->func
, port
->regs_offset
+ offset
, NULL
);
216 static inline void sdio_out(struct sdio_uart_port
*port
, int offset
, int value
)
218 sdio_writeb(port
->func
, value
, port
->regs_offset
+ offset
, NULL
);
221 static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port
*port
)
223 unsigned char status
;
226 status
= sdio_in(port
, UART_MSR
);
229 if (status
& UART_MSR_DCD
)
231 if (status
& UART_MSR_RI
)
233 if (status
& UART_MSR_DSR
)
235 if (status
& UART_MSR_CTS
)
240 static void sdio_uart_write_mctrl(struct sdio_uart_port
*port
,
243 unsigned char mcr
= 0;
245 if (mctrl
& TIOCM_RTS
)
247 if (mctrl
& TIOCM_DTR
)
249 if (mctrl
& TIOCM_OUT1
)
250 mcr
|= UART_MCR_OUT1
;
251 if (mctrl
& TIOCM_OUT2
)
252 mcr
|= UART_MCR_OUT2
;
253 if (mctrl
& TIOCM_LOOP
)
254 mcr
|= UART_MCR_LOOP
;
256 sdio_out(port
, UART_MCR
, mcr
);
259 static inline void sdio_uart_update_mctrl(struct sdio_uart_port
*port
,
260 unsigned int set
, unsigned int clear
)
265 port
->mctrl
= (old
& ~clear
) | set
;
266 if (old
!= port
->mctrl
)
267 sdio_uart_write_mctrl(port
, port
->mctrl
);
270 #define sdio_uart_set_mctrl(port, x) sdio_uart_update_mctrl(port, x, 0)
271 #define sdio_uart_clear_mctrl(port, x) sdio_uart_update_mctrl(port, 0, x)
273 static void sdio_uart_change_speed(struct sdio_uart_port
*port
,
274 struct ktermios
*termios
,
275 struct ktermios
*old
)
277 unsigned char cval
, fcr
= 0;
278 unsigned int baud
, quot
;
280 switch (termios
->c_cflag
& CSIZE
) {
282 cval
= UART_LCR_WLEN5
;
285 cval
= UART_LCR_WLEN6
;
288 cval
= UART_LCR_WLEN7
;
292 cval
= UART_LCR_WLEN8
;
296 if (termios
->c_cflag
& CSTOPB
)
297 cval
|= UART_LCR_STOP
;
298 if (termios
->c_cflag
& PARENB
)
299 cval
|= UART_LCR_PARITY
;
300 if (!(termios
->c_cflag
& PARODD
))
301 cval
|= UART_LCR_EPAR
;
304 baud
= tty_termios_baud_rate(termios
);
306 baud
= 9600; /* Special case: B0 rate. */
307 if (baud
<= port
->uartclk
)
310 * Oops, the quotient was zero. Try again with the old
311 * baud rate if possible, otherwise default to 9600.
313 termios
->c_cflag
&= ~CBAUD
;
315 termios
->c_cflag
|= old
->c_cflag
& CBAUD
;
318 termios
->c_cflag
|= B9600
;
320 quot
= (2 * port
->uartclk
+ baud
) / (2 * baud
);
323 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_TRIGGER_1
;
325 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_R_TRIG_10
;
327 port
->read_status_mask
= UART_LSR_OE
| UART_LSR_THRE
| UART_LSR_DR
;
328 if (termios
->c_iflag
& INPCK
)
329 port
->read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
330 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
331 port
->read_status_mask
|= UART_LSR_BI
;
334 * Characters to ignore
336 port
->ignore_status_mask
= 0;
337 if (termios
->c_iflag
& IGNPAR
)
338 port
->ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
339 if (termios
->c_iflag
& IGNBRK
) {
340 port
->ignore_status_mask
|= UART_LSR_BI
;
342 * If we're ignoring parity and break indicators,
343 * ignore overruns too (for real raw support).
345 if (termios
->c_iflag
& IGNPAR
)
346 port
->ignore_status_mask
|= UART_LSR_OE
;
350 * ignore all characters if CREAD is not set
352 if ((termios
->c_cflag
& CREAD
) == 0)
353 port
->ignore_status_mask
|= UART_LSR_DR
;
356 * CTS flow control flag and modem status interrupts
358 port
->ier
&= ~UART_IER_MSI
;
359 if ((termios
->c_cflag
& CRTSCTS
) || !(termios
->c_cflag
& CLOCAL
))
360 port
->ier
|= UART_IER_MSI
;
364 sdio_out(port
, UART_IER
, port
->ier
);
365 sdio_out(port
, UART_LCR
, cval
| UART_LCR_DLAB
);
366 sdio_out(port
, UART_DLL
, quot
& 0xff);
367 sdio_out(port
, UART_DLM
, quot
>> 8);
368 sdio_out(port
, UART_LCR
, cval
);
369 sdio_out(port
, UART_FCR
, fcr
);
371 sdio_uart_write_mctrl(port
, port
->mctrl
);
374 static void sdio_uart_start_tx(struct sdio_uart_port
*port
)
376 if (!(port
->ier
& UART_IER_THRI
)) {
377 port
->ier
|= UART_IER_THRI
;
378 sdio_out(port
, UART_IER
, port
->ier
);
382 static void sdio_uart_stop_tx(struct sdio_uart_port
*port
)
384 if (port
->ier
& UART_IER_THRI
) {
385 port
->ier
&= ~UART_IER_THRI
;
386 sdio_out(port
, UART_IER
, port
->ier
);
390 static void sdio_uart_stop_rx(struct sdio_uart_port
*port
)
392 port
->ier
&= ~UART_IER_RLSI
;
393 port
->read_status_mask
&= ~UART_LSR_DR
;
394 sdio_out(port
, UART_IER
, port
->ier
);
397 static void sdio_uart_receive_chars(struct sdio_uart_port
*port
,
398 unsigned int *status
)
400 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
401 unsigned int ch
, flag
;
405 ch
= sdio_in(port
, UART_RX
);
409 if (unlikely(*status
& (UART_LSR_BI
| UART_LSR_PE
|
410 UART_LSR_FE
| UART_LSR_OE
))) {
412 * For statistics only
414 if (*status
& UART_LSR_BI
) {
415 *status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
417 } else if (*status
& UART_LSR_PE
)
418 port
->icount
.parity
++;
419 else if (*status
& UART_LSR_FE
)
420 port
->icount
.frame
++;
421 if (*status
& UART_LSR_OE
)
422 port
->icount
.overrun
++;
425 * Mask off conditions which should be ignored.
427 *status
&= port
->read_status_mask
;
428 if (*status
& UART_LSR_BI
)
430 else if (*status
& UART_LSR_PE
)
432 else if (*status
& UART_LSR_FE
)
436 if ((*status
& port
->ignore_status_mask
& ~UART_LSR_OE
) == 0)
438 tty_insert_flip_char(tty
, ch
, flag
);
441 * Overrun is special. Since it's reported immediately,
442 * it doesn't affect the current character.
444 if (*status
& ~port
->ignore_status_mask
& UART_LSR_OE
)
446 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
448 *status
= sdio_in(port
, UART_LSR
);
449 } while ((*status
& UART_LSR_DR
) && (max_count
-- > 0));
451 tty_flip_buffer_push(tty
);
456 static void sdio_uart_transmit_chars(struct sdio_uart_port
*port
)
458 struct circ_buf
*xmit
= &port
->xmit
;
460 struct tty_struct
*tty
;
463 sdio_out(port
, UART_TX
, port
->x_char
);
469 tty
= tty_port_tty_get(&port
->port
);
471 if (tty
== NULL
|| circ_empty(xmit
) || tty
->stopped
|| tty
->hw_stopped
) {
472 sdio_uart_stop_tx(port
);
479 sdio_out(port
, UART_TX
, xmit
->buf
[xmit
->tail
]);
480 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
482 if (circ_empty(xmit
))
484 } while (--count
> 0);
486 if (circ_chars_pending(xmit
) < WAKEUP_CHARS
)
489 if (circ_empty(xmit
))
490 sdio_uart_stop_tx(port
);
494 static void sdio_uart_check_modem_status(struct sdio_uart_port
*port
)
497 struct tty_struct
*tty
;
499 status
= sdio_in(port
, UART_MSR
);
501 if ((status
& UART_MSR_ANY_DELTA
) == 0)
504 if (status
& UART_MSR_TERI
)
506 if (status
& UART_MSR_DDSR
)
508 if (status
& UART_MSR_DDCD
)
510 if (status
& UART_MSR_DCTS
) {
512 tty
= tty_port_tty_get(&port
->port
);
513 if (tty
&& (tty
->termios
->c_cflag
& CRTSCTS
)) {
514 int cts
= (status
& UART_MSR_CTS
);
515 if (tty
->hw_stopped
) {
518 sdio_uart_start_tx(port
);
524 sdio_uart_stop_tx(port
);
533 * This handles the interrupt from one port.
535 static void sdio_uart_irq(struct sdio_func
*func
)
537 struct sdio_uart_port
*port
= sdio_get_drvdata(func
);
538 unsigned int iir
, lsr
;
541 * In a few places sdio_uart_irq() is called directly instead of
542 * waiting for the actual interrupt to be raised and the SDIO IRQ
543 * thread scheduled in order to reduce latency. However, some
544 * interaction with the tty core may end up calling us back
545 * (serial echo, flow control, etc.) through those same places
546 * causing undesirable effects. Let's stop the recursion here.
548 if (unlikely(port
->in_sdio_uart_irq
== current
))
551 iir
= sdio_in(port
, UART_IIR
);
552 if (iir
& UART_IIR_NO_INT
)
555 port
->in_sdio_uart_irq
= current
;
556 lsr
= sdio_in(port
, UART_LSR
);
557 if (lsr
& UART_LSR_DR
)
558 sdio_uart_receive_chars(port
, &lsr
);
559 sdio_uart_check_modem_status(port
);
560 if (lsr
& UART_LSR_THRE
)
561 sdio_uart_transmit_chars(port
);
562 port
->in_sdio_uart_irq
= NULL
;
565 static int sdio_uart_startup(struct sdio_uart_port
*port
)
569 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
571 /* FIXME: What if it is NULL ?? */
574 * Set the TTY IO error marker - we will only clear this
575 * once we have successfully opened the port.
577 set_bit(TTY_IO_ERROR
, &tty
->flags
);
579 /* Initialise and allocate the transmit buffer. */
580 page
= __get_free_page(GFP_KERNEL
);
583 port
->xmit
.buf
= (unsigned char *)page
;
584 circ_clear(&port
->xmit
);
586 ret
= sdio_uart_claim_func(port
);
589 ret
= sdio_enable_func(port
->func
);
592 ret
= sdio_claim_irq(port
->func
, sdio_uart_irq
);
597 * Clear the FIFO buffers and disable them.
598 * (they will be reenabled in sdio_change_speed())
600 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
601 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
602 UART_FCR_CLEAR_RCVR
| UART_FCR_CLEAR_XMIT
);
603 sdio_out(port
, UART_FCR
, 0);
606 * Clear the interrupt registers.
608 (void) sdio_in(port
, UART_LSR
);
609 (void) sdio_in(port
, UART_RX
);
610 (void) sdio_in(port
, UART_IIR
);
611 (void) sdio_in(port
, UART_MSR
);
614 * Now, initialize the UART
616 sdio_out(port
, UART_LCR
, UART_LCR_WLEN8
);
618 port
->ier
= UART_IER_RLSI
| UART_IER_RDI
| UART_IER_RTOIE
| UART_IER_UUE
;
619 port
->mctrl
= TIOCM_OUT2
;
621 sdio_uart_change_speed(port
, tty
->termios
, NULL
);
623 if (tty
->termios
->c_cflag
& CBAUD
)
624 sdio_uart_set_mctrl(port
, TIOCM_RTS
| TIOCM_DTR
);
626 if (tty
->termios
->c_cflag
& CRTSCTS
)
627 if (!(sdio_uart_get_mctrl(port
) & TIOCM_CTS
))
630 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
632 /* Kick the IRQ handler once while we're still holding the host lock */
633 sdio_uart_irq(port
->func
);
635 sdio_uart_release_func(port
);
640 sdio_disable_func(port
->func
);
642 sdio_uart_release_func(port
);
644 free_page((unsigned long)port
->xmit
.buf
);
650 static void sdio_uart_shutdown(struct sdio_uart_port
*port
)
653 struct tty_struct
*tty
;
655 ret
= sdio_uart_claim_func(port
);
659 sdio_uart_stop_rx(port
);
661 /* TODO: wait here for TX FIFO to drain */
663 tty
= tty_port_tty_get(&port
->port
);
664 /* Turn off DTR and RTS early. */
665 if (tty
&& (tty
->termios
->c_cflag
& HUPCL
))
666 sdio_uart_clear_mctrl(port
, TIOCM_DTR
| TIOCM_RTS
);
669 /* Disable interrupts from this port */
670 sdio_release_irq(port
->func
);
672 sdio_out(port
, UART_IER
, 0);
674 sdio_uart_clear_mctrl(port
, TIOCM_OUT2
);
676 /* Disable break condition and FIFOs. */
677 port
->lcr
&= ~UART_LCR_SBC
;
678 sdio_out(port
, UART_LCR
, port
->lcr
);
679 sdio_out(port
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
680 UART_FCR_CLEAR_RCVR
|
681 UART_FCR_CLEAR_XMIT
);
682 sdio_out(port
, UART_FCR
, 0);
684 sdio_disable_func(port
->func
);
686 sdio_uart_release_func(port
);
689 /* Free the transmit buffer page. */
690 free_page((unsigned long)port
->xmit
.buf
);
693 static int sdio_uart_open(struct tty_struct
*tty
, struct file
*filp
)
695 struct sdio_uart_port
*port
;
698 port
= sdio_uart_port_get(tty
->index
);
702 mutex_lock(&port
->open_lock
);
705 * Make sure not to mess up with a dead port
706 * which has not been closed yet.
708 if (tty
->driver_data
&& tty
->driver_data
!= port
) {
709 mutex_unlock(&port
->open_lock
);
710 sdio_uart_port_put(port
);
715 tty
->driver_data
= port
;
716 tty_port_tty_set(&port
->port
, tty
);
717 ret
= sdio_uart_startup(port
);
719 tty
->driver_data
= NULL
;
720 tty_port_tty_set(&port
->port
, NULL
);
721 mutex_unlock(&port
->open_lock
);
722 sdio_uart_port_put(port
);
727 mutex_unlock(&port
->open_lock
);
731 static void sdio_uart_close(struct tty_struct
*tty
, struct file
* filp
)
733 struct sdio_uart_port
*port
= tty
->driver_data
;
738 mutex_lock(&port
->open_lock
);
739 BUG_ON(!port
->opened
);
742 * This is messy. The tty layer calls us even when open()
743 * returned an error. Ignore this close request if tty->count
744 * is larger than port->count.
746 if (tty
->count
> port
->opened
) {
747 mutex_unlock(&port
->open_lock
);
751 if (--port
->opened
== 0) {
753 sdio_uart_shutdown(port
);
754 tty_ldisc_flush(tty
);
755 tty_port_tty_set(&port
->port
, NULL
);
756 tty
->driver_data
= NULL
;
759 mutex_unlock(&port
->open_lock
);
760 sdio_uart_port_put(port
);
763 static int sdio_uart_write(struct tty_struct
* tty
, const unsigned char *buf
,
766 struct sdio_uart_port
*port
= tty
->driver_data
;
767 struct circ_buf
*circ
= &port
->xmit
;
773 spin_lock(&port
->write_lock
);
775 c
= CIRC_SPACE_TO_END(circ
->head
, circ
->tail
, UART_XMIT_SIZE
);
780 memcpy(circ
->buf
+ circ
->head
, buf
, c
);
781 circ
->head
= (circ
->head
+ c
) & (UART_XMIT_SIZE
- 1);
786 spin_unlock(&port
->write_lock
);
788 if ( !(port
->ier
& UART_IER_THRI
)) {
789 int err
= sdio_uart_claim_func(port
);
791 sdio_uart_start_tx(port
);
792 sdio_uart_irq(port
->func
);
793 sdio_uart_release_func(port
);
801 static int sdio_uart_write_room(struct tty_struct
*tty
)
803 struct sdio_uart_port
*port
= tty
->driver_data
;
804 return port
? circ_chars_free(&port
->xmit
) : 0;
807 static int sdio_uart_chars_in_buffer(struct tty_struct
*tty
)
809 struct sdio_uart_port
*port
= tty
->driver_data
;
810 return port
? circ_chars_pending(&port
->xmit
) : 0;
813 static void sdio_uart_send_xchar(struct tty_struct
*tty
, char ch
)
815 struct sdio_uart_port
*port
= tty
->driver_data
;
818 if (ch
&& !(port
->ier
& UART_IER_THRI
)) {
819 if (sdio_uart_claim_func(port
) != 0)
821 sdio_uart_start_tx(port
);
822 sdio_uart_irq(port
->func
);
823 sdio_uart_release_func(port
);
827 static void sdio_uart_throttle(struct tty_struct
*tty
)
829 struct sdio_uart_port
*port
= tty
->driver_data
;
831 if (!I_IXOFF(tty
) && !(tty
->termios
->c_cflag
& CRTSCTS
))
834 if (sdio_uart_claim_func(port
) != 0)
838 port
->x_char
= STOP_CHAR(tty
);
839 sdio_uart_start_tx(port
);
842 if (tty
->termios
->c_cflag
& CRTSCTS
)
843 sdio_uart_clear_mctrl(port
, TIOCM_RTS
);
845 sdio_uart_irq(port
->func
);
846 sdio_uart_release_func(port
);
849 static void sdio_uart_unthrottle(struct tty_struct
*tty
)
851 struct sdio_uart_port
*port
= tty
->driver_data
;
853 if (!I_IXOFF(tty
) && !(tty
->termios
->c_cflag
& CRTSCTS
))
856 if (sdio_uart_claim_func(port
) != 0)
863 port
->x_char
= START_CHAR(tty
);
864 sdio_uart_start_tx(port
);
868 if (tty
->termios
->c_cflag
& CRTSCTS
)
869 sdio_uart_set_mctrl(port
, TIOCM_RTS
);
871 sdio_uart_irq(port
->func
);
872 sdio_uart_release_func(port
);
875 static void sdio_uart_set_termios(struct tty_struct
*tty
, struct ktermios
*old_termios
)
877 struct sdio_uart_port
*port
= tty
->driver_data
;
878 unsigned int cflag
= tty
->termios
->c_cflag
;
880 #define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
882 if ((cflag
^ old_termios
->c_cflag
) == 0 &&
883 RELEVANT_IFLAG(tty
->termios
->c_iflag
^ old_termios
->c_iflag
) == 0)
886 if (sdio_uart_claim_func(port
) != 0)
889 sdio_uart_change_speed(port
, tty
->termios
, old_termios
);
891 /* Handle transition to B0 status */
892 if ((old_termios
->c_cflag
& CBAUD
) && !(cflag
& CBAUD
))
893 sdio_uart_clear_mctrl(port
, TIOCM_RTS
| TIOCM_DTR
);
895 /* Handle transition away from B0 status */
896 if (!(old_termios
->c_cflag
& CBAUD
) && (cflag
& CBAUD
)) {
897 unsigned int mask
= TIOCM_DTR
;
898 if (!(cflag
& CRTSCTS
) || !test_bit(TTY_THROTTLED
, &tty
->flags
))
900 sdio_uart_set_mctrl(port
, mask
);
903 /* Handle turning off CRTSCTS */
904 if ((old_termios
->c_cflag
& CRTSCTS
) && !(cflag
& CRTSCTS
)) {
906 sdio_uart_start_tx(port
);
909 /* Handle turning on CRTSCTS */
910 if (!(old_termios
->c_cflag
& CRTSCTS
) && (cflag
& CRTSCTS
)) {
911 if (!(sdio_uart_get_mctrl(port
) & TIOCM_CTS
)) {
913 sdio_uart_stop_tx(port
);
917 sdio_uart_release_func(port
);
920 static int sdio_uart_break_ctl(struct tty_struct
*tty
, int break_state
)
922 struct sdio_uart_port
*port
= tty
->driver_data
;
925 result
= sdio_uart_claim_func(port
);
929 if (break_state
== -1)
930 port
->lcr
|= UART_LCR_SBC
;
932 port
->lcr
&= ~UART_LCR_SBC
;
933 sdio_out(port
, UART_LCR
, port
->lcr
);
935 sdio_uart_release_func(port
);
939 static int sdio_uart_tiocmget(struct tty_struct
*tty
, struct file
*file
)
941 struct sdio_uart_port
*port
= tty
->driver_data
;
944 result
= sdio_uart_claim_func(port
);
946 result
= port
->mctrl
| sdio_uart_get_mctrl(port
);
947 sdio_uart_release_func(port
);
953 static int sdio_uart_tiocmset(struct tty_struct
*tty
, struct file
*file
,
954 unsigned int set
, unsigned int clear
)
956 struct sdio_uart_port
*port
= tty
->driver_data
;
959 result
= sdio_uart_claim_func(port
);
961 sdio_uart_update_mctrl(port
, set
, clear
);
962 sdio_uart_release_func(port
);
968 static int sdio_uart_proc_show(struct seq_file
*m
, void *v
)
972 seq_printf(m
, "serinfo:1.0 driver%s%s revision:%s\n",
974 for (i
= 0; i
< UART_NR
; i
++) {
975 struct sdio_uart_port
*port
= sdio_uart_port_get(i
);
977 seq_printf(m
, "%d: uart:SDIO", i
);
978 if(capable(CAP_SYS_ADMIN
)) {
979 seq_printf(m
, " tx:%d rx:%d",
980 port
->icount
.tx
, port
->icount
.rx
);
981 if (port
->icount
.frame
)
982 seq_printf(m
, " fe:%d",
984 if (port
->icount
.parity
)
985 seq_printf(m
, " pe:%d",
986 port
->icount
.parity
);
987 if (port
->icount
.brk
)
988 seq_printf(m
, " brk:%d",
990 if (port
->icount
.overrun
)
991 seq_printf(m
, " oe:%d",
992 port
->icount
.overrun
);
993 if (port
->icount
.cts
)
994 seq_printf(m
, " cts:%d",
996 if (port
->icount
.dsr
)
997 seq_printf(m
, " dsr:%d",
999 if (port
->icount
.rng
)
1000 seq_printf(m
, " rng:%d",
1002 if (port
->icount
.dcd
)
1003 seq_printf(m
, " dcd:%d",
1006 sdio_uart_port_put(port
);
1013 static int sdio_uart_proc_open(struct inode
*inode
, struct file
*file
)
1015 return single_open(file
, sdio_uart_proc_show
, NULL
);
1018 static const struct file_operations sdio_uart_proc_fops
= {
1019 .owner
= THIS_MODULE
,
1020 .open
= sdio_uart_proc_open
,
1022 .llseek
= seq_lseek
,
1023 .release
= single_release
,
1026 static const struct tty_operations sdio_uart_ops
= {
1027 .open
= sdio_uart_open
,
1028 .close
= sdio_uart_close
,
1029 .write
= sdio_uart_write
,
1030 .write_room
= sdio_uart_write_room
,
1031 .chars_in_buffer
= sdio_uart_chars_in_buffer
,
1032 .send_xchar
= sdio_uart_send_xchar
,
1033 .throttle
= sdio_uart_throttle
,
1034 .unthrottle
= sdio_uart_unthrottle
,
1035 .set_termios
= sdio_uart_set_termios
,
1036 .break_ctl
= sdio_uart_break_ctl
,
1037 .tiocmget
= sdio_uart_tiocmget
,
1038 .tiocmset
= sdio_uart_tiocmset
,
1039 .proc_fops
= &sdio_uart_proc_fops
,
1042 static struct tty_driver
*sdio_uart_tty_driver
;
1044 static int sdio_uart_probe(struct sdio_func
*func
,
1045 const struct sdio_device_id
*id
)
1047 struct sdio_uart_port
*port
;
1050 port
= kzalloc(sizeof(struct sdio_uart_port
), GFP_KERNEL
);
1054 if (func
->class == SDIO_CLASS_UART
) {
1055 printk(KERN_WARNING
"%s: need info on UART class basic setup\n",
1056 sdio_func_id(func
));
1059 } else if (func
->class == SDIO_CLASS_GPS
) {
1061 * We need tuple 0x91. It contains SUBTPL_SIOREG
1062 * and SUBTPL_RCVCAPS.
1064 struct sdio_func_tuple
*tpl
;
1065 for (tpl
= func
->tuples
; tpl
; tpl
= tpl
->next
) {
1066 if (tpl
->code
!= 0x91)
1070 if (tpl
->data
[1] == 0) /* SUBTPL_SIOREG */
1075 "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
1076 sdio_func_id(func
));
1080 printk(KERN_DEBUG
"%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
1081 sdio_func_id(func
), tpl
->data
[2], tpl
->data
[3]);
1082 port
->regs_offset
= (tpl
->data
[4] << 0) |
1083 (tpl
->data
[5] << 8) |
1084 (tpl
->data
[6] << 16);
1085 printk(KERN_DEBUG
"%s: regs offset = 0x%x\n",
1086 sdio_func_id(func
), port
->regs_offset
);
1087 port
->uartclk
= tpl
->data
[7] * 115200;
1088 if (port
->uartclk
== 0)
1089 port
->uartclk
= 115200;
1090 printk(KERN_DEBUG
"%s: clk %d baudcode %u 4800-div %u\n",
1091 sdio_func_id(func
), port
->uartclk
,
1092 tpl
->data
[7], tpl
->data
[8] | (tpl
->data
[9] << 8));
1099 sdio_set_drvdata(func
, port
);
1100 tty_port_init(&port
->port
);
1102 ret
= sdio_uart_add_port(port
);
1107 dev
= tty_register_device(sdio_uart_tty_driver
, port
->index
, &func
->dev
);
1109 sdio_uart_port_remove(port
);
1117 static void sdio_uart_remove(struct sdio_func
*func
)
1119 struct sdio_uart_port
*port
= sdio_get_drvdata(func
);
1121 tty_unregister_device(sdio_uart_tty_driver
, port
->index
);
1122 sdio_uart_port_remove(port
);
1125 static const struct sdio_device_id sdio_uart_ids
[] = {
1126 { SDIO_DEVICE_CLASS(SDIO_CLASS_UART
) },
1127 { SDIO_DEVICE_CLASS(SDIO_CLASS_GPS
) },
1128 { /* end: all zeroes */ },
1131 MODULE_DEVICE_TABLE(sdio
, sdio_uart_ids
);
1133 static struct sdio_driver sdio_uart_driver
= {
1134 .probe
= sdio_uart_probe
,
1135 .remove
= sdio_uart_remove
,
1136 .name
= "sdio_uart",
1137 .id_table
= sdio_uart_ids
,
1140 static int __init
sdio_uart_init(void)
1143 struct tty_driver
*tty_drv
;
1145 sdio_uart_tty_driver
= tty_drv
= alloc_tty_driver(UART_NR
);
1149 tty_drv
->owner
= THIS_MODULE
;
1150 tty_drv
->driver_name
= "sdio_uart";
1151 tty_drv
->name
= "ttySDIO";
1152 tty_drv
->major
= 0; /* dynamically allocated */
1153 tty_drv
->minor_start
= 0;
1154 tty_drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
1155 tty_drv
->subtype
= SERIAL_TYPE_NORMAL
;
1156 tty_drv
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1157 tty_drv
->init_termios
= tty_std_termios
;
1158 tty_drv
->init_termios
.c_cflag
= B4800
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1159 tty_drv
->init_termios
.c_ispeed
= 4800;
1160 tty_drv
->init_termios
.c_ospeed
= 4800;
1161 tty_set_operations(tty_drv
, &sdio_uart_ops
);
1163 ret
= tty_register_driver(tty_drv
);
1167 ret
= sdio_register_driver(&sdio_uart_driver
);
1174 tty_unregister_driver(tty_drv
);
1176 put_tty_driver(tty_drv
);
1180 static void __exit
sdio_uart_exit(void)
1182 sdio_unregister_driver(&sdio_uart_driver
);
1183 tty_unregister_driver(sdio_uart_tty_driver
);
1184 put_tty_driver(sdio_uart_tty_driver
);
1187 module_init(sdio_uart_init
);
1188 module_exit(sdio_uart_exit
);
1190 MODULE_AUTHOR("Nicolas Pitre");
1191 MODULE_LICENSE("GPL");