8 files changed, 239 insertions, 143 deletions

diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index 36a8d53ad2a2..f53755533e7e 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/sched.h>
 #include <linux/mutex.h>
 #include <linux/seq_file.h>
 #include <linux/serial_reg.h>
@@ -73,11 +74,10 @@ struct uart_icount {
 };
 
 struct sdio_uart_port {
+        struct tty_port         port;
         struct kref             kref;
         struct tty_struct       *tty;
         unsigned int            index;
-        unsigned int            opened;
-        struct mutex            open_lock;
         struct sdio_func        *func;
         struct mutex            func_lock;
         struct task_struct      *in_sdio_uart_irq;
@@ -87,6 +87,7 @@ struct sdio_uart_port {
         struct uart_icount      icount;
         unsigned int            uartclk;
         unsigned int            mctrl;
+        unsigned int            rx_mctrl;
         unsigned int            read_status_mask;
         unsigned int            ignore_status_mask;
         unsigned char           x_char;
@@ -102,7 +103,6 @@ static int sdio_uart_add_port(struct sdio_uart_port *port)
         int index, ret = -EBUSY;
 
         kref_init(&port->kref);
-        mutex_init(&port->open_lock);
         mutex_init(&port->func_lock);
         spin_lock_init(&port->write_lock);
 
@@ -151,6 +151,7 @@ static void sdio_uart_port_put(struct sdio_uart_port *port)
 static void sdio_uart_port_remove(struct sdio_uart_port *port)
 {
         struct sdio_func *func;
+        struct tty_struct *tty;
 
         BUG_ON(sdio_uart_table[port->index] != port);
 
@@ -165,15 +166,19 @@ static void sdio_uart_port_remove(struct sdio_uart_port *port)
          * give up on that port ASAP.
          * Beware: the lock ordering is critical.
          */
-        mutex_lock(&port->open_lock);
+        mutex_lock(&port->port.mutex);
         mutex_lock(&port->func_lock);
         func = port->func;
         sdio_claim_host(func);
         port->func = NULL;
         mutex_unlock(&port->func_lock);
-        if (port->opened)
-                tty_hangup(port->tty);
-        mutex_unlock(&port->open_lock);
+        tty = tty_port_tty_get(&port->port);
+        /* tty_hangup is async so is this safe as is ?? */
+        if (tty) {
+                tty_hangup(tty);
+                tty_kref_put(tty);
+        }
+        mutex_unlock(&port->port.mutex);
         sdio_release_irq(func);
         sdio_disable_func(func);
         sdio_release_host(func);
@@ -217,6 +222,8 @@ static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port *port)
         unsigned char status;
         unsigned int ret;
 
+        /* FIXME: What stops this losing the delta bits and breaking
+           sdio_uart_check_modem_status ? */
         status = sdio_in(port, UART_MSR);
 
         ret = 0;
@@ -231,7 +238,8 @@ static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port *port)
         return ret;
 }
 
-static void sdio_uart_write_mctrl(struct sdio_uart_port *port, unsigned int mctrl)
+static void sdio_uart_write_mctrl(struct sdio_uart_port *port,
+                                  unsigned int mctrl)
 {
         unsigned char mcr = 0;
 
@@ -387,9 +395,10 @@ static void sdio_uart_stop_rx(struct sdio_uart_port *port)
         sdio_out(port, UART_IER, port->ier);
 }
 
-static void sdio_uart_receive_chars(struct sdio_uart_port *port, unsigned int *status)
+static void sdio_uart_receive_chars(struct sdio_uart_port *port,
+                                    unsigned int *status)
 {
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = tty_port_tty_get(&port->port);
         unsigned int ch, flag;
         int max_count = 256;
 
@@ -399,7 +408,7 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port, unsigned int *s
                 port->icount.rx++;
 
                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
-                                        UART_LSR_FE | UART_LSR_OE))) {
+                                        UART_LSR_FE | UART_LSR_OE))) {
                         /*
                          * For statistics only
                          */
@@ -417,33 +426,39 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port, unsigned int *s
                          * Mask off conditions which should be ignored.
                          */
                         *status &= port->read_status_mask;
-                        if (*status & UART_LSR_BI) {
+                        if (*status & UART_LSR_BI)
                                 flag = TTY_BREAK;
-                        } else if (*status & UART_LSR_PE)
+                        else if (*status & UART_LSR_PE)
                                 flag = TTY_PARITY;
                         else if (*status & UART_LSR_FE)
                                 flag = TTY_FRAME;
                 }
 
                 if ((*status & port->ignore_status_mask & ~UART_LSR_OE) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        if (tty)
+                                tty_insert_flip_char(tty, ch, flag);
 
                 /*
                  * Overrun is special.  Since it's reported immediately,
                  * it doesn't affect the current character.
                  */
                 if (*status & ~port->ignore_status_mask & UART_LSR_OE)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        if (tty)
+                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 
                 *status = sdio_in(port, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        tty_flip_buffer_push(tty);
+        if (tty) {
+                tty_flip_buffer_push(tty);
+                tty_kref_put(tty);
+        }
 }
 
 static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
 {
         struct circ_buf *xmit = &port->xmit;
         int count;
+        struct tty_struct *tty;
 
         if (port->x_char) {
                 sdio_out(port, UART_TX, port->x_char);
@@ -451,8 +466,13 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
                 port->x_char = 0;
                 return;
         }
-        if (circ_empty(xmit) || port->tty->stopped || port->tty->hw_stopped) {
+
+        tty = tty_port_tty_get(&port->port);
+
+        if (tty == NULL || circ_empty(xmit) ||
+                                tty->stopped || tty->hw_stopped) {
                 sdio_uart_stop_tx(port);
+                tty_kref_put(tty);
                 return;
         }
 
@@ -466,15 +486,17 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
         } while (--count > 0);
 
         if (circ_chars_pending(xmit) < WAKEUP_CHARS)
-                tty_wakeup(port->tty);
+                tty_wakeup(tty);
 
         if (circ_empty(xmit))
                 sdio_uart_stop_tx(port);
+        tty_kref_put(tty);
 }
 
 static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
 {
         int status;
+        struct tty_struct *tty;
 
         status = sdio_in(port, UART_MSR);
 
@@ -485,25 +507,39 @@ static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
                 port->icount.rng++;
         if (status & UART_MSR_DDSR)
                 port->icount.dsr++;
-        if (status & UART_MSR_DDCD)
+        if (status & UART_MSR_DDCD) {
                 port->icount.dcd++;
+                /* DCD raise - wake for open */
+                if (status & UART_MSR_DCD)
+                        wake_up_interruptible(&port->port.open_wait);
+                else {
+                        /* DCD drop - hang up if tty attached */
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                tty_hangup(tty);
+                                tty_kref_put(tty);
+                        }
+                }
+        }
         if (status & UART_MSR_DCTS) {
                 port->icount.cts++;
-                if (port->tty->termios->c_cflag & CRTSCTS) {
+                tty = tty_port_tty_get(&port->port);
+                if (tty && (tty->termios->c_cflag & CRTSCTS)) {
                         int cts = (status & UART_MSR_CTS);
-                        if (port->tty->hw_stopped) {
+                        if (tty->hw_stopped) {
                                 if (cts) {
-                                        port->tty->hw_stopped = 0;
+                                        tty->hw_stopped = 0;
                                         sdio_uart_start_tx(port);
-                                        tty_wakeup(port->tty);
+                                        tty_wakeup(tty);
                                 }
                         } else {
                                 if (!cts) {
-                                        port->tty->hw_stopped = 1;
+                                        tty->hw_stopped = 1;
                                         sdio_uart_stop_tx(port);
                                 }
                         }
                 }
+                tty_kref_put(tty);
         }
 }
 
@@ -540,8 +576,62 @@ static void sdio_uart_irq(struct sdio_func *func)
         port->in_sdio_uart_irq = NULL;
 }
 
-static int sdio_uart_startup(struct sdio_uart_port *port)
+static int uart_carrier_raised(struct tty_port *tport)
+{
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
+        unsigned int ret = sdio_uart_claim_func(port);
+        if (ret)        /* Missing hardware shoudn't block for carrier */
+                return 1;
+        ret = sdio_uart_get_mctrl(port);
+        sdio_uart_release_func(port);
+        if (ret & TIOCM_CAR)
+                return 1;
+        return 0;
+}
+
+/**
+ *      uart_dtr_rts            -        port helper to set uart signals
+ *      @tport: tty port to be updated
+ *      @onoff: set to turn on DTR/RTS
+ *
+ *      Called by the tty port helpers when the modem signals need to be
+ *      adjusted during an open, close and hangup.
+ */
+
+static void uart_dtr_rts(struct tty_port *tport, int onoff)
 {
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
+        int ret = sdio_uart_claim_func(port);
+        if (ret)
+                return;
+        if (onoff == 0)
+                sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+        else
+                sdio_uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+        sdio_uart_release_func(port);
+}
+
+/**
+ *      sdio_uart_activate      -       start up hardware
+ *      @tport: tty port to activate
+ *      @tty: tty bound to this port
+ *
+ *      Activate a tty port. The port locking guarantees us this will be
+ *      run exactly once per set of opens, and if successful will see the
+ *      shutdown method run exactly once to match. Start up and shutdown are
+ *      protected from each other by the internal locking and will not run
+ *      at the same time even during a hangup event.
+ *
+ *      If we successfully start up the port we take an extra kref as we
+ *      will keep it around until shutdown when the kref is dropped.
+ */
+
+static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
+{
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
         unsigned long page;
         int ret;
 
@@ -549,7 +639,7 @@ static int sdio_uart_startup(struct sdio_uart_port *port)
          * Set the TTY IO error marker - we will only clear this
          * once we have successfully opened the port.
          */
-        set_bit(TTY_IO_ERROR, &port->tty->flags);
+        set_bit(TTY_IO_ERROR, &tty->flags);
 
         /* Initialise and allocate the transmit buffer. */
         page = __get_free_page(GFP_KERNEL);
@@ -574,7 +664,7 @@ static int sdio_uart_startup(struct sdio_uart_port *port)
          */
         sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
         sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO |
-                        UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
+                       UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
         sdio_out(port, UART_FCR, 0);
 
         /*
@@ -590,19 +680,19 @@ static int sdio_uart_startup(struct sdio_uart_port *port)
          */
         sdio_out(port, UART_LCR, UART_LCR_WLEN8);
 
-        port->ier = UART_IER_RLSI | UART_IER_RDI | UART_IER_RTOIE | UART_IER_UUE;
+        port->ier = UART_IER_RLSI|UART_IER_RDI|UART_IER_RTOIE|UART_IER_UUE;
         port->mctrl = TIOCM_OUT2;
 
-        sdio_uart_change_speed(port, port->tty->termios, NULL);
+        sdio_uart_change_speed(port, tty->termios, NULL);
 
-        if (port->tty->termios->c_cflag & CBAUD)
+        if (tty->termios->c_cflag & CBAUD)
                 sdio_uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
 
-        if (port->tty->termios->c_cflag & CRTSCTS)
+        if (tty->termios->c_cflag & CRTSCTS)
                 if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))
-                        port->tty->hw_stopped = 1;
+                        tty->hw_stopped = 1;
 
-        clear_bit(TTY_IO_ERROR, &port->tty->flags);
+        clear_bit(TTY_IO_ERROR, &tty->flags);
 
         /* Kick the IRQ handler once while we're still holding the host lock */
         sdio_uart_irq(port->func);
@@ -619,8 +709,20 @@ err1:
         return ret;
 }
 
-static void sdio_uart_shutdown(struct sdio_uart_port *port)
+/**
+ *      sdio_uart_shutdown      -       stop hardware
+ *      @tport: tty port to shut down
+ *
+ *      Deactivate a tty port. The port locking guarantees us this will be
+ *      run only if a successful matching activate already ran. The two are
+ *      protected from each other by the internal locking and will not run
+ *      at the same time even during a hangup event.
+ */
+
+static void sdio_uart_shutdown(struct tty_port *tport)
 {
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
         int ret;
 
         ret = sdio_uart_claim_func(port);
@@ -629,13 +731,7 @@ static void sdio_uart_shutdown(struct sdio_uart_port *port)
 
         sdio_uart_stop_rx(port);
 
-        /* TODO: wait here for TX FIFO to drain */
-
-        /* Turn off DTR and RTS early. */
-        if (port->tty->termios->c_cflag & HUPCL)
-                sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
-
-         /* Disable interrupts from this port */
+        /* Disable interrupts from this port */
         sdio_release_irq(port->func);
         port->ier = 0;
         sdio_out(port, UART_IER, 0);
@@ -659,77 +755,70 @@ skip:
         free_page((unsigned long)port->xmit.buf);
 }
 
-static int sdio_uart_open (struct tty_struct *tty, struct file * filp)
+/**
+ *      sdio_uart_install       -       install method
+ *      @driver: the driver in use (sdio_uart in our case)
+ *      @tty: the tty being bound
+ *
+ *      Look up and bind the tty and the driver together. Initialize
+ *      any needed private data (in our case the termios)
+ */
+
+static int sdio_uart_install(struct tty_driver *driver, struct tty_struct *tty)
 {
-        struct sdio_uart_port *port;
-        int ret;
+        int idx = tty->index;
+        struct sdio_uart_port *port = sdio_uart_port_get(idx);
+        int ret = tty_init_termios(tty);
+
+        if (ret == 0) {
+                tty_driver_kref_get(driver);
+                tty->count++;
+                /* This is the ref sdio_uart_port get provided */
+                tty->driver_data = port;
+                driver->ttys[idx] = tty;
+        } else
+                sdio_uart_port_put(port);
+        return ret;
+}
 
-        port = sdio_uart_port_get(tty->index);
-        if (!port)
-                return -ENODEV;
+/**
+ *      sdio_uart_cleanup       -       called on the last tty kref drop
+ *      @tty: the tty being destroyed
+ *
+ *      Called asynchronously when the last reference to the tty is dropped.
+ *      We cannot destroy the tty->driver_data port kref until this point
+ */
 
-        mutex_lock(&port->open_lock);
+static void sdio_uart_cleanup(struct tty_struct *tty)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        tty->driver_data = NULL;        /* Bug trap */
+        sdio_uart_port_put(port);
+}
 
-        /*
-         * Make sure not to mess up with a dead port
-         * which has not been closed yet.
-         */
-        if (tty->driver_data && tty->driver_data != port) {
-                mutex_unlock(&port->open_lock);
-                sdio_uart_port_put(port);
-                return -EBUSY;
-        }
+/*
+ *      Open/close/hangup is now entirely boilerplate
+ */
 
-        if (!port->opened) {
-                tty->driver_data = port;
-                port->tty = tty;
-                ret = sdio_uart_startup(port);
-                if (ret) {
-                        tty->driver_data = NULL;
-                        port->tty = NULL;
-                        mutex_unlock(&port->open_lock);
-                        sdio_uart_port_put(port);
-                        return ret;
-                }
-        }
-        port->opened++;
-        mutex_unlock(&port->open_lock);
-        return 0;
+static int sdio_uart_open(struct tty_struct *tty, struct file *filp)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        return tty_port_open(&port->port, tty, filp);
 }
 
 static void sdio_uart_close(struct tty_struct *tty, struct file * filp)
 {
         struct sdio_uart_port *port = tty->driver_data;
+        tty_port_close(&port->port, tty, filp);
+}
 
-        if (!port)
-                return;
-
-        mutex_lock(&port->open_lock);
-        BUG_ON(!port->opened);
-
-        /*
-         * This is messy.  The tty layer calls us even when open()
-         * returned an error.  Ignore this close request if tty->count
-         * is larger than port->count.
-         */
-        if (tty->count > port->opened) {
-                mutex_unlock(&port->open_lock);
-                return;
-        }
-
-        if (--port->opened == 0) {
-                tty->closing = 1;
-                sdio_uart_shutdown(port);
-                tty_ldisc_flush(tty);
-                port->tty = NULL;
-                tty->driver_data = NULL;
-                tty->closing = 0;
-        }
-        mutex_unlock(&port->open_lock);
-        sdio_uart_port_put(port);
+static void sdio_uart_hangup(struct tty_struct *tty)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        tty_port_hangup(&port->port);
 }
 
-static int sdio_uart_write(struct tty_struct * tty, const unsigned char *buf,
+static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
                            int count)
 {
         struct sdio_uart_port *port = tty->driver_data;
@@ -754,7 +843,7 @@ static int sdio_uart_write(struct tty_struct * tty, const unsigned char *buf,
         }
         spin_unlock(&port->write_lock);
 
-        if ( !(port->ier & UART_IER_THRI)) {
+        if (!(port->ier & UART_IER_THRI)) {
                 int err = sdio_uart_claim_func(port);
                 if (!err) {
                         sdio_uart_start_tx(port);
@@ -841,17 +930,12 @@ static void sdio_uart_unthrottle(struct tty_struct *tty)
         sdio_uart_release_func(port);
 }
 
-static void sdio_uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
+static void sdio_uart_set_termios(struct tty_struct *tty,
+                                                struct ktermios *old_termios)
 {
         struct sdio_uart_port *port = tty->driver_data;
         unsigned int cflag = tty->termios->c_cflag;
 
-#define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
-
-        if ((cflag ^ old_termios->c_cflag) == 0 &&
-            RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
-                return;
-
         if (sdio_uart_claim_func(port) != 0)
                 return;
 
@@ -925,8 +1009,8 @@ static int sdio_uart_tiocmset(struct tty_struct *tty, struct file *file,
         struct sdio_uart_port *port = tty->driver_data;
         int result;
 
-        result =sdio_uart_claim_func(port);
-        if(!result) {
+        result = sdio_uart_claim_func(port);
+        if (!result) {
                 sdio_uart_update_mctrl(port, set, clear);
                 sdio_uart_release_func(port);
         }
@@ -944,33 +1028,33 @@ static int sdio_uart_proc_show(struct seq_file *m, void *v)
                 struct sdio_uart_port *port = sdio_uart_port_get(i);
                 if (port) {
                         seq_printf(m, "%d: uart:SDIO", i);
-                        if(capable(CAP_SYS_ADMIN)) {
+                        if (capable(CAP_SYS_ADMIN)) {
                                 seq_printf(m, " tx:%d rx:%d",
-                                               port->icount.tx, port->icount.rx);
+                                              port->icount.tx, port->icount.rx);
                                 if (port->icount.frame)
                                         seq_printf(m, " fe:%d",
-                                                       port->icount.frame);
+                                                      port->icount.frame);
                                 if (port->icount.parity)
                                         seq_printf(m, " pe:%d",
-                                                       port->icount.parity);
+                                                      port->icount.parity);
                                 if (port->icount.brk)
                                         seq_printf(m, " brk:%d",
-                                                       port->icount.brk);
+                                                      port->icount.brk);
                                 if (port->icount.overrun)
                                         seq_printf(m, " oe:%d",
-                                                       port->icount.overrun);
+                                                      port->icount.overrun);
                                 if (port->icount.cts)
                                         seq_printf(m, " cts:%d",
-                                                       port->icount.cts);
+                                                      port->icount.cts);
                                 if (port->icount.dsr)
                                         seq_printf(m, " dsr:%d",
-                                                       port->icount.dsr);
+                                                      port->icount.dsr);
                                 if (port->icount.rng)
                                         seq_printf(m, " rng:%d",
-                                                       port->icount.rng);
+                                                      port->icount.rng);
                                 if (port->icount.dcd)
                                         seq_printf(m, " dcd:%d",
-                                                       port->icount.dcd);
+                                                      port->icount.dcd);
                         }
                         sdio_uart_port_put(port);
                         seq_putc(m, '\n');
@@ -992,6 +1076,13 @@ static const struct file_operations sdio_uart_proc_fops = {
         .release        = single_release,
 };
 
+static const struct tty_port_operations sdio_uart_port_ops = {
+        .dtr_rts = uart_dtr_rts,
+        .carrier_raised = uart_carrier_raised,
+        .shutdown = sdio_uart_shutdown,
+        .activate = sdio_uart_activate,
+};
+
 static const struct tty_operations sdio_uart_ops = {
         .open                   = sdio_uart_open,
         .close                  = sdio_uart_close,
@@ -1002,9 +1093,12 @@ static const struct tty_operations sdio_uart_ops = {
         .throttle               = sdio_uart_throttle,
         .unthrottle             = sdio_uart_unthrottle,
         .set_termios            = sdio_uart_set_termios,
+        .hangup                 = sdio_uart_hangup,
         .break_ctl              = sdio_uart_break_ctl,
         .tiocmget               = sdio_uart_tiocmget,
         .tiocmset               = sdio_uart_tiocmset,
+        .install                = sdio_uart_install,
+        .cleanup                = sdio_uart_cleanup,
         .proc_fops              = &sdio_uart_proc_fops,
 };
 
@@ -1041,7 +1135,7 @@ static int sdio_uart_probe(struct sdio_func *func,
                 }
                 if (!tpl) {
                         printk(KERN_WARNING
-                               "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
+       "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
                                sdio_func_id(func));
                         kfree(port);
                         return -EINVAL;
@@ -1066,13 +1160,16 @@ static int sdio_uart_probe(struct sdio_func *func,
 
         port->func = func;
         sdio_set_drvdata(func, port);
+        tty_port_init(&port->port);
+        port->port.ops = &sdio_uart_port_ops;
 
         ret = sdio_uart_add_port(port);
         if (ret) {
                 kfree(port);
         } else {
                 struct device *dev;
-                dev = tty_register_device(sdio_uart_tty_driver, port->index, &func->dev);
+                dev = tty_register_device(sdio_uart_tty_driver,
+                                                port->index, &func->dev);
                 if (IS_ERR(dev)) {
                         sdio_uart_port_remove(port);
                         ret = PTR_ERR(dev);
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 432ae8358c86..e04b751680d0 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -329,7 +329,7 @@ config MMC_SDRICOH_CS
 
 config MMC_TMIO
         tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"
-        depends on MFD_TMIO || MFD_ASIC3
+        depends on MFD_TMIO || MFD_ASIC3 || SUPERH
         help
           This provides support for the SD/MMC cell found in TC6393XB,
           T7L66XB and also HTC ASIC3
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 705a5894a6bb..90d168ad03b6 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -56,7 +56,7 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
                                 clk = 255;
                         host->cclk = host->mclk / (2 * (clk + 1));
                 }
-                if (host->hw_designer == 0x80)
+                if (host->hw_designer == AMBA_VENDOR_ST)
                         clk |= MCI_FCEN; /* Bug fix in ST IP block */
                 clk |= MCI_CLK_ENABLE;
                 /* This hasn't proven to be worthwhile */
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index dba4600bcdb4..b31946e0b4ca 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -38,10 +38,9 @@
 #include <asm/div64.h>
 #include <asm/sizes.h>
 
-#include <asm/mach/mmc.h>
+#include <mach/mmc.h>
 #include <mach/msm_iomap.h>
 #include <mach/dma.h>
-#include <mach/htc_pwrsink.h>
 
 #include "msm_sdcc.h"
 
@@ -775,13 +774,11 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
-                htc_pwrsink_set(PWRSINK_SDCARD, 0);
                 break;
         case MMC_POWER_UP:
                 pwr |= MCI_PWR_UP;
                 break;
         case MMC_POWER_ON:
-                htc_pwrsink_set(PWRSINK_SDCARD, 100);
                 pwr |= MCI_PWR_ON;
                 break;
         }
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index b8fd7af1ceeb..5f970e253e50 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -30,12 +30,12 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 
-#include <mach/board.h>
-#include <mach/mmc.h>
+#include <plat/board.h>
+#include <plat/mmc.h>
 #include <mach/gpio.h>
-#include <mach/dma.h>
-#include <mach/mux.h>
-#include <mach/fpga.h>
+#include <plat/dma.h>
+#include <plat/mux.h>
+#include <plat/fpga.h>
 
 #define OMAP_MMC_REG_CMD        0x00
 #define OMAP_MMC_REG_ARGL       0x04
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 0aecaaebef3d..4b2322518909 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -30,11 +30,11 @@
 #include <linux/mmc/core.h>
 #include <linux/io.h>
 #include <linux/semaphore.h>
-#include <mach/dma.h>
+#include <plat/dma.h>
 #include <mach/hardware.h>
-#include <mach/board.h>
-#include <mach/mmc.h>
-#include <mach/cpu.h>
+#include <plat/board.h>
+#include <plat/mmc.h>
+#include <plat/cpu.h>
 
 /* OMAP HSMMC Host Controller Registers */
 #define OMAP_HSMMC_SYSCONFIG    0x0010
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index b00d67319058..bb47ff465c04 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -43,6 +43,9 @@
 #define NR_SG   1
 #define CLKRT_OFF       (~0)
 
+#define mmc_has_26MHz()         (cpu_is_pxa300() || cpu_is_pxa310() \
+                                || cpu_is_pxa935())
+
 struct pxamci_host {
         struct mmc_host         *mmc;
         spinlock_t              lock;
@@ -457,7 +460,7 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         clk_enable(host->clk);
 
                 if (ios->clock == 26000000) {
-                        /* to support 26MHz on pxa300/pxa310 */
+                        /* to support 26MHz */
                         host->clkrt = 7;
                 } else {
                         /* to handle (19.5MHz, 26MHz) */
@@ -608,8 +611,7 @@ static int pxamci_probe(struct platform_device *pdev)
          * Calculate minimum clock rate, rounding up.
          */
         mmc->f_min = (host->clkrate + 63) / 64;
-        mmc->f_max = (cpu_is_pxa300() || cpu_is_pxa310()) ? 26000000
-                                                          : host->clkrate;
+        mmc->f_max = (mmc_has_26MHz()) ? 26000000 : host->clkrate;
 
         pxamci_init_ocr(host);
 
@@ -618,7 +620,7 @@ static int pxamci_probe(struct platform_device *pdev)
         if (!cpu_is_pxa25x()) {
                 mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
                 host->cmdat |= CMDAT_SDIO_INT_EN;
-                if (cpu_is_pxa300() || cpu_is_pxa310())
+                if (mmc_has_26MHz())
                         mmc->caps |= MMC_CAP_MMC_HIGHSPEED |
                                      MMC_CAP_SD_HIGHSPEED;
         }
@@ -760,6 +762,8 @@ static int pxamci_remove(struct platform_device *pdev)
         if (mmc) {
                 struct pxamci_host *host = mmc_priv(mmc);
 
+                mmc_remove_host(mmc);
+
                 if (host->pdata) {
                         gpio_cd = host->pdata->gpio_card_detect;
                         gpio_ro = host->pdata->gpio_card_ro;
@@ -779,8 +783,6 @@ static int pxamci_remove(struct platform_device *pdev)
                 if (host->pdata && host->pdata->exit)
                         host->pdata->exit(&pdev->dev, mmc);
 
-                mmc_remove_host(mmc);
-
                 pxamci_stop_clock(host);
                 writel(TXFIFO_WR_REQ|RXFIFO_RD_REQ|CLK_IS_OFF|STOP_CMD|
                        END_CMD_RES|PRG_DONE|DATA_TRAN_DONE,
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 99b74a351020..941a4d35ef8d 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1360,7 +1360,7 @@ static struct mmc_host_ops s3cmci_ops = {
 
 static struct s3c24xx_mci_pdata s3cmci_def_pdata = {
         /* This is currently here to avoid a number of if (host->pdata)
-         * checks. Any zero fields to ensure reaonable defaults are picked. */
+         * checks. Any zero fields to ensure reasonable defaults are picked. */
 };
 
 #ifdef CONFIG_CPU_FREQ