drivers/tty/serial/msm_serial.c

   1 /*
   2  * Driver for msm7k serial device and console
   3  *
   4  * Copyright (C) 2007 Google, Inc.
   5  * Author: Robert Love <rlove@google.com>
   6  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #if defined(CONFIG_SERIAL_MSM_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  19 # define SUPPORT_SYSRQ
  20 #endif
  21
  22 #include <linux/atomic.h>
  23 #include <linux/hrtimer.h>
  24 #include <linux/module.h>
  25 #include <linux/io.h>
  26 #include <linux/ioport.h>
  27 #include <linux/irq.h>
  28 #include <linux/init.h>
  29 #include <linux/console.h>
  30 #include <linux/tty.h>
  31 #include <linux/tty_flip.h>
  32 #include <linux/serial_core.h>
  33 #include <linux/serial.h>
  34 #include <linux/clk.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/delay.h>
  37 #include <linux/of.h>
  38 #include <linux/of_device.h>
  39
  40 #include "msm_serial.h"
  41
  42 struct msm_port {
  43         struct uart_port        uart;
  44         char                    name[16];
  45         struct clk              *clk;
  46         struct clk              *pclk;
  47         unsigned int            imr;
  48         unsigned int            *gsbi_base;
  49         int                     is_uartdm;
  50         unsigned int            old_snap_state;
  51 };
  52
  53 static inline void wait_for_xmitr(struct uart_port *port, int bits)
  54 {
  55         if (!(msm_read(port, UART_SR) & UART_SR_TX_EMPTY))
  56                 while ((msm_read(port, UART_ISR) & bits) != bits)
  57                         cpu_relax();
  58 }
  59
  60 static void msm_stop_tx(struct uart_port *port)
  61 {
  62         struct msm_port *msm_port = UART_TO_MSM(port);
  63
  64         msm_port->imr &= ~UART_IMR_TXLEV;
  65         msm_write(port, msm_port->imr, UART_IMR);
  66 }
  67
  68 static void msm_start_tx(struct uart_port *port)
  69 {
  70         struct msm_port *msm_port = UART_TO_MSM(port);
  71
  72         msm_port->imr |= UART_IMR_TXLEV;
  73         msm_write(port, msm_port->imr, UART_IMR);
  74 }
  75
  76 static void msm_stop_rx(struct uart_port *port)
  77 {
  78         struct msm_port *msm_port = UART_TO_MSM(port);
  79
  80         msm_port->imr &= ~(UART_IMR_RXLEV | UART_IMR_RXSTALE);
  81         msm_write(port, msm_port->imr, UART_IMR);
  82 }
  83
  84 static void msm_enable_ms(struct uart_port *port)
  85 {
  86         struct msm_port *msm_port = UART_TO_MSM(port);
  87
  88         msm_port->imr |= UART_IMR_DELTA_CTS;
  89         msm_write(port, msm_port->imr, UART_IMR);
  90 }
  91
  92 static void handle_rx_dm(struct uart_port *port, unsigned int misr)
  93 {
  94         struct tty_port *tport = &port->state->port;
  95         struct tty_struct *tty = tport->tty;
  96         unsigned int sr;
  97         int count = 0;
  98         struct msm_port *msm_port = UART_TO_MSM(port);
  99
 100         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
 101                 port->icount.overrun++;
 102                 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 103                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 104         }
 105
 106         if (misr & UART_IMR_RXSTALE) {
 107                 count = msm_read(port, UARTDM_RX_TOTAL_SNAP) -
 108                         msm_port->old_snap_state;
 109                 msm_port->old_snap_state = 0;
 110         } else {
 111                 count = 4 * (msm_read(port, UART_RFWR));
 112                 msm_port->old_snap_state += count;
 113         }
 114
 115         /* TODO: Precise error reporting */
 116
 117         port->icount.rx += count;
 118
 119         while (count > 0) {
 120                 unsigned int c;
 121
 122                 sr = msm_read(port, UART_SR);
 123                 if ((sr & UART_SR_RX_READY) == 0) {
 124                         msm_port->old_snap_state -= count;
 125                         break;
 126                 }
 127                 c = msm_read(port, UARTDM_RF);
 128                 if (sr & UART_SR_RX_BREAK) {
 129                         port->icount.brk++;
 130                         if (uart_handle_break(port))
 131                                 continue;
 132                 } else if (sr & UART_SR_PAR_FRAME_ERR)
 133                         port->icount.frame++;
 134
 135                 /* TODO: handle sysrq */
 136                 tty_insert_flip_string(tport, (char *)&c,
 137                                        (count > 4) ? 4 : count);
 138                 count -= 4;
 139         }
 140
 141         tty_flip_buffer_push(tty);
 142         if (misr & (UART_IMR_RXSTALE))
 143                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 144         msm_write(port, 0xFFFFFF, UARTDM_DMRX);
 145         msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 146 }
 147
 148 static void handle_rx(struct uart_port *port)
 149 {
 150         struct tty_port *tport = &port->state->port;
 151         struct tty_struct *tty = tport->tty;
 152         unsigned int sr;
 153
 154         /*
 155          * Handle overrun. My understanding of the hardware is that overrun
 156          * is not tied to the RX buffer, so we handle the case out of band.
 157          */
 158         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
 159                 port->icount.overrun++;
 160                 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 161                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 162         }
 163
 164         /* and now the main RX loop */
 165         while ((sr = msm_read(port, UART_SR)) & UART_SR_RX_READY) {
 166                 unsigned int c;
 167                 char flag = TTY_NORMAL;
 168
 169                 c = msm_read(port, UART_RF);
 170
 171                 if (sr & UART_SR_RX_BREAK) {
 172                         port->icount.brk++;
 173                         if (uart_handle_break(port))
 174                                 continue;
 175                 } else if (sr & UART_SR_PAR_FRAME_ERR) {
 176                         port->icount.frame++;
 177                 } else {
 178                         port->icount.rx++;
 179                 }
 180
 181                 /* Mask conditions we're ignorning. */
 182                 sr &= port->read_status_mask;
 183
 184                 if (sr & UART_SR_RX_BREAK) {
 185                         flag = TTY_BREAK;
 186                 } else if (sr & UART_SR_PAR_FRAME_ERR) {
 187                         flag = TTY_FRAME;
 188                 }
 189
 190                 if (!uart_handle_sysrq_char(port, c))
 191                         tty_insert_flip_char(tport, c, flag);
 192         }
 193
 194         tty_flip_buffer_push(tty);
 195 }
 196
 197 static void reset_dm_count(struct uart_port *port)
 198 {
 199         wait_for_xmitr(port, UART_ISR_TX_READY);
 200         msm_write(port, 1, UARTDM_NCF_TX);
 201 }
 202
 203 static void handle_tx(struct uart_port *port)
 204 {
 205         struct circ_buf *xmit = &port->state->xmit;
 206         struct msm_port *msm_port = UART_TO_MSM(port);
 207         int sent_tx;
 208
 209         if (port->x_char) {
 210                 if (msm_port->is_uartdm)
 211                         reset_dm_count(port);
 212
 213                 msm_write(port, port->x_char,
 214                           msm_port->is_uartdm ? UARTDM_TF : UART_TF);
 215                 port->icount.tx++;
 216                 port->x_char = 0;
 217         }
 218
 219         if (msm_port->is_uartdm)
 220                 reset_dm_count(port);
 221
 222         while (msm_read(port, UART_SR) & UART_SR_TX_READY) {
 223                 if (uart_circ_empty(xmit)) {
 224                         /* disable tx interrupts */
 225                         msm_port->imr &= ~UART_IMR_TXLEV;
 226                         msm_write(port, msm_port->imr, UART_IMR);
 227                         break;
 228                 }
 229                 msm_write(port, xmit->buf[xmit->tail],
 230                           msm_port->is_uartdm ? UARTDM_TF : UART_TF);
 231
 232                 if (msm_port->is_uartdm)
 233                         reset_dm_count(port);
 234
 235                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 236                 port->icount.tx++;
 237                 sent_tx = 1;
 238         }
 239
 240         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 241                 uart_write_wakeup(port);
 242 }
 243
 244 static void handle_delta_cts(struct uart_port *port)
 245 {
 246         msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
 247         port->icount.cts++;
 248         wake_up_interruptible(&port->state->port.delta_msr_wait);
 249 }
 250
 251 static irqreturn_t msm_irq(int irq, void *dev_id)
 252 {
 253         struct uart_port *port = dev_id;
 254         struct msm_port *msm_port = UART_TO_MSM(port);
 255         unsigned int misr;
 256
 257         spin_lock(&port->lock);
 258         misr = msm_read(port, UART_MISR);
 259         msm_write(port, 0, UART_IMR); /* disable interrupt */
 260
 261         if (misr & (UART_IMR_RXLEV | UART_IMR_RXSTALE)) {
 262                 if (msm_port->is_uartdm)
 263                         handle_rx_dm(port, misr);
 264                 else
 265                         handle_rx(port);
 266         }
 267         if (misr & UART_IMR_TXLEV)
 268                 handle_tx(port);
 269         if (misr & UART_IMR_DELTA_CTS)
 270                 handle_delta_cts(port);
 271
 272         msm_write(port, msm_port->imr, UART_IMR); /* restore interrupt */
 273         spin_unlock(&port->lock);
 274
 275         return IRQ_HANDLED;
 276 }
 277
 278 static unsigned int msm_tx_empty(struct uart_port *port)
 279 {
 280         return (msm_read(port, UART_SR) & UART_SR_TX_EMPTY) ? TIOCSER_TEMT : 0;
 281 }
 282
 283 static unsigned int msm_get_mctrl(struct uart_port *port)
 284 {
 285         return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
 286 }
 287
 288
 289 static void msm_reset(struct uart_port *port)
 290 {
 291         /* reset everything */
 292         msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
 293         msm_write(port, UART_CR_CMD_RESET_TX, UART_CR);
 294         msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 295         msm_write(port, UART_CR_CMD_RESET_BREAK_INT, UART_CR);
 296         msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
 297         msm_write(port, UART_CR_CMD_SET_RFR, UART_CR);
 298 }
 299
 300 void msm_set_mctrl(struct uart_port *port, unsigned int mctrl)
 301 {
 302         unsigned int mr;
 303         mr = msm_read(port, UART_MR1);
 304
 305         if (!(mctrl & TIOCM_RTS)) {
 306                 mr &= ~UART_MR1_RX_RDY_CTL;
 307                 msm_write(port, mr, UART_MR1);
 308                 msm_write(port, UART_CR_CMD_RESET_RFR, UART_CR);
 309         } else {
 310                 mr |= UART_MR1_RX_RDY_CTL;
 311                 msm_write(port, mr, UART_MR1);
 312         }
 313 }
 314
 315 static void msm_break_ctl(struct uart_port *port, int break_ctl)
 316 {
 317         if (break_ctl)
 318                 msm_write(port, UART_CR_CMD_START_BREAK, UART_CR);
 319         else
 320                 msm_write(port, UART_CR_CMD_STOP_BREAK, UART_CR);
 321 }
 322
 323 static int msm_set_baud_rate(struct uart_port *port, unsigned int baud)
 324 {
 325         unsigned int baud_code, rxstale, watermark;
 326         struct msm_port *msm_port = UART_TO_MSM(port);
 327
 328         switch (baud) {
 329         case 300:
 330                 baud_code = UART_CSR_300;
 331                 rxstale = 1;
 332                 break;
 333         case 600:
 334                 baud_code = UART_CSR_600;
 335                 rxstale = 1;
 336                 break;
 337         case 1200:
 338                 baud_code = UART_CSR_1200;
 339                 rxstale = 1;
 340                 break;
 341         case 2400:
 342                 baud_code = UART_CSR_2400;
 343                 rxstale = 1;
 344                 break;
 345         case 4800:
 346                 baud_code = UART_CSR_4800;
 347                 rxstale = 1;
 348                 break;
 349         case 9600:
 350                 baud_code = UART_CSR_9600;
 351                 rxstale = 2;
 352                 break;
 353         case 14400:
 354                 baud_code = UART_CSR_14400;
 355                 rxstale = 3;
 356                 break;
 357         case 19200:
 358                 baud_code = UART_CSR_19200;
 359                 rxstale = 4;
 360                 break;
 361         case 28800:
 362                 baud_code = UART_CSR_28800;
 363                 rxstale = 6;
 364                 break;
 365         case 38400:
 366                 baud_code = UART_CSR_38400;
 367                 rxstale = 8;
 368                 break;
 369         case 57600:
 370                 baud_code = UART_CSR_57600;
 371                 rxstale = 16;
 372                 break;
 373         case 115200:
 374         default:
 375                 baud_code = UART_CSR_115200;
 376                 baud = 115200;
 377                 rxstale = 31;
 378                 break;
 379         }
 380
 381         if (msm_port->is_uartdm)
 382                 msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
 383
 384         msm_write(port, baud_code, UART_CSR);
 385
 386         /* RX stale watermark */
 387         watermark = UART_IPR_STALE_LSB & rxstale;
 388         watermark |= UART_IPR_RXSTALE_LAST;
 389         watermark |= UART_IPR_STALE_TIMEOUT_MSB & (rxstale << 2);
 390         msm_write(port, watermark, UART_IPR);
 391
 392         /* set RX watermark */
 393         watermark = (port->fifosize * 3) / 4;
 394         msm_write(port, watermark, UART_RFWR);
 395
 396         /* set TX watermark */
 397         msm_write(port, 10, UART_TFWR);
 398
 399         if (msm_port->is_uartdm) {
 400                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 401                 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
 402                 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 403         }
 404
 405         return baud;
 406 }
 407
 408
 409 static void msm_init_clock(struct uart_port *port)
 410 {
 411         struct msm_port *msm_port = UART_TO_MSM(port);
 412
 413         clk_enable(msm_port->clk);
 414         if (!IS_ERR(msm_port->pclk))
 415                 clk_enable(msm_port->pclk);
 416         msm_serial_set_mnd_regs(port);
 417 }
 418
 419 static int msm_startup(struct uart_port *port)
 420 {
 421         struct msm_port *msm_port = UART_TO_MSM(port);
 422         unsigned int data, rfr_level;
 423         int ret;
 424
 425         snprintf(msm_port->name, sizeof(msm_port->name),
 426                  "msm_serial%d", port->line);
 427
 428         ret = request_irq(port->irq, msm_irq, IRQF_TRIGGER_HIGH,
 429                           msm_port->name, port);
 430         if (unlikely(ret))
 431                 return ret;
 432
 433         msm_init_clock(port);
 434
 435         if (likely(port->fifosize > 12))
 436                 rfr_level = port->fifosize - 12;
 437         else
 438                 rfr_level = port->fifosize;
 439
 440         /* set automatic RFR level */
 441         data = msm_read(port, UART_MR1);
 442         data &= ~UART_MR1_AUTO_RFR_LEVEL1;
 443         data &= ~UART_MR1_AUTO_RFR_LEVEL0;
 444         data |= UART_MR1_AUTO_RFR_LEVEL1 & (rfr_level << 2);
 445         data |= UART_MR1_AUTO_RFR_LEVEL0 & rfr_level;
 446         msm_write(port, data, UART_MR1);
 447
 448         /* make sure that RXSTALE count is non-zero */
 449         data = msm_read(port, UART_IPR);
 450         if (unlikely(!data)) {
 451                 data |= UART_IPR_RXSTALE_LAST;
 452                 data |= UART_IPR_STALE_LSB;
 453                 msm_write(port, data, UART_IPR);
 454         }
 455
 456         data = 0;
 457         if (!port->cons || (port->cons && !(port->cons->flags & CON_ENABLED))) {
 458                 msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
 459                 msm_reset(port);
 460                 data = UART_CR_TX_ENABLE;
 461         }
 462
 463         data |= UART_CR_RX_ENABLE;
 464         msm_write(port, data, UART_CR); /* enable TX & RX */
 465
 466         /* Make sure IPR is not 0 to start with*/
 467         if (msm_port->is_uartdm)
 468                 msm_write(port, UART_IPR_STALE_LSB, UART_IPR);
 469
 470         /* turn on RX and CTS interrupts */
 471         msm_port->imr = UART_IMR_RXLEV | UART_IMR_RXSTALE |
 472                         UART_IMR_CURRENT_CTS;
 473
 474         if (msm_port->is_uartdm) {
 475                 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
 476                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 477                 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 478         }
 479
 480         msm_write(port, msm_port->imr, UART_IMR);
 481         return 0;
 482 }
 483
 484 static void msm_shutdown(struct uart_port *port)
 485 {
 486         struct msm_port *msm_port = UART_TO_MSM(port);
 487
 488         msm_port->imr = 0;
 489         msm_write(port, 0, UART_IMR); /* disable interrupts */
 490
 491         clk_disable(msm_port->clk);
 492
 493         free_irq(port->irq, port);
 494 }
 495
 496 static void msm_set_termios(struct uart_port *port, struct ktermios *termios,
 497                             struct ktermios *old)
 498 {
 499         unsigned long flags;
 500         unsigned int baud, mr;
 501
 502         spin_lock_irqsave(&port->lock, flags);
 503
 504         /* calculate and set baud rate */
 505         baud = uart_get_baud_rate(port, termios, old, 300, 115200);
 506         baud = msm_set_baud_rate(port, baud);
 507         if (tty_termios_baud_rate(termios))
 508                 tty_termios_encode_baud_rate(termios, baud, baud);
 509
 510         /* calculate parity */
 511         mr = msm_read(port, UART_MR2);
 512         mr &= ~UART_MR2_PARITY_MODE;
 513         if (termios->c_cflag & PARENB) {
 514                 if (termios->c_cflag & PARODD)
 515                         mr |= UART_MR2_PARITY_MODE_ODD;
 516                 else if (termios->c_cflag & CMSPAR)
 517                         mr |= UART_MR2_PARITY_MODE_SPACE;
 518                 else
 519                         mr |= UART_MR2_PARITY_MODE_EVEN;
 520         }
 521
 522         /* calculate bits per char */
 523         mr &= ~UART_MR2_BITS_PER_CHAR;
 524         switch (termios->c_cflag & CSIZE) {
 525         case CS5:
 526                 mr |= UART_MR2_BITS_PER_CHAR_5;
 527                 break;
 528         case CS6:
 529                 mr |= UART_MR2_BITS_PER_CHAR_6;
 530                 break;
 531         case CS7:
 532                 mr |= UART_MR2_BITS_PER_CHAR_7;
 533                 break;
 534         case CS8:
 535         default:
 536                 mr |= UART_MR2_BITS_PER_CHAR_8;
 537                 break;
 538         }
 539
 540         /* calculate stop bits */
 541         mr &= ~(UART_MR2_STOP_BIT_LEN_ONE | UART_MR2_STOP_BIT_LEN_TWO);
 542         if (termios->c_cflag & CSTOPB)
 543                 mr |= UART_MR2_STOP_BIT_LEN_TWO;
 544         else
 545                 mr |= UART_MR2_STOP_BIT_LEN_ONE;
 546
 547         /* set parity, bits per char, and stop bit */
 548         msm_write(port, mr, UART_MR2);
 549
 550         /* calculate and set hardware flow control */
 551         mr = msm_read(port, UART_MR1);
 552         mr &= ~(UART_MR1_CTS_CTL | UART_MR1_RX_RDY_CTL);
 553         if (termios->c_cflag & CRTSCTS) {
 554                 mr |= UART_MR1_CTS_CTL;
 555                 mr |= UART_MR1_RX_RDY_CTL;
 556         }
 557         msm_write(port, mr, UART_MR1);
 558
 559         /* Configure status bits to ignore based on termio flags. */
 560         port->read_status_mask = 0;
 561         if (termios->c_iflag & INPCK)
 562                 port->read_status_mask |= UART_SR_PAR_FRAME_ERR;
 563         if (termios->c_iflag & (BRKINT | PARMRK))
 564                 port->read_status_mask |= UART_SR_RX_BREAK;
 565
 566         uart_update_timeout(port, termios->c_cflag, baud);
 567
 568         spin_unlock_irqrestore(&port->lock, flags);
 569 }
 570
 571 static const char *msm_type(struct uart_port *port)
 572 {
 573         return "MSM";
 574 }
 575
 576 static void msm_release_port(struct uart_port *port)
 577 {
 578         struct platform_device *pdev = to_platform_device(port->dev);
 579         struct msm_port *msm_port = UART_TO_MSM(port);
 580         struct resource *uart_resource;
 581         struct resource *gsbi_resource;
 582         resource_size_t size;
 583
 584         uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 585         if (unlikely(!uart_resource))
 586                 return;
 587         size = resource_size(uart_resource);
 588
 589         release_mem_region(port->mapbase, size);
 590         iounmap(port->membase);
 591         port->membase = NULL;
 592
 593         if (msm_port->gsbi_base) {
 594                 iowrite32(GSBI_PROTOCOL_IDLE, msm_port->gsbi_base +
 595                           GSBI_CONTROL);
 596
 597                 gsbi_resource = platform_get_resource(pdev,
 598                                                         IORESOURCE_MEM, 1);
 599
 600                 if (unlikely(!gsbi_resource))
 601                         return;
 602
 603                 size = resource_size(gsbi_resource);
 604                 release_mem_region(gsbi_resource->start, size);
 605                 iounmap(msm_port->gsbi_base);
 606                 msm_port->gsbi_base = NULL;
 607         }
 608 }
 609
 610 static int msm_request_port(struct uart_port *port)
 611 {
 612         struct msm_port *msm_port = UART_TO_MSM(port);
 613         struct platform_device *pdev = to_platform_device(port->dev);
 614         struct resource *uart_resource;
 615         struct resource *gsbi_resource;
 616         resource_size_t size;
 617         int ret;
 618
 619         uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 620         if (unlikely(!uart_resource))
 621                 return -ENXIO;
 622
 623         size = resource_size(uart_resource);
 624
 625         if (!request_mem_region(port->mapbase, size, "msm_serial"))
 626                 return -EBUSY;
 627
 628         port->membase = ioremap(port->mapbase, size);
 629         if (!port->membase) {
 630                 ret = -EBUSY;
 631                 goto fail_release_port;
 632         }
 633
 634         gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 635         /* Is this a GSBI-based port? */
 636         if (gsbi_resource) {
 637                 size = resource_size(gsbi_resource);
 638
 639                 if (!request_mem_region(gsbi_resource->start, size,
 640                                                  "msm_serial")) {
 641                         ret = -EBUSY;
 642                         goto fail_release_port;
 643                 }
 644
 645                 msm_port->gsbi_base = ioremap(gsbi_resource->start, size);
 646                 if (!msm_port->gsbi_base) {
 647                         ret = -EBUSY;
 648                         goto fail_release_gsbi;
 649                 }
 650         }
 651
 652         return 0;
 653
 654 fail_release_gsbi:
 655         release_mem_region(gsbi_resource->start, size);
 656 fail_release_port:
 657         release_mem_region(port->mapbase, size);
 658         return ret;
 659 }
 660
 661 static void msm_config_port(struct uart_port *port, int flags)
 662 {
 663         struct msm_port *msm_port = UART_TO_MSM(port);
 664         int ret;
 665         if (flags & UART_CONFIG_TYPE) {
 666                 port->type = PORT_MSM;
 667                 ret = msm_request_port(port);
 668                 if (ret)
 669                         return;
 670         }
 671
 672         if (msm_port->is_uartdm)
 673                 iowrite32(GSBI_PROTOCOL_UART, msm_port->gsbi_base +
 674                           GSBI_CONTROL);
 675 }
 676
 677 static int msm_verify_port(struct uart_port *port, struct serial_struct *ser)
 678 {
 679         if (unlikely(ser->type != PORT_UNKNOWN && ser->type != PORT_MSM))
 680                 return -EINVAL;
 681         if (unlikely(port->irq != ser->irq))
 682                 return -EINVAL;
 683         return 0;
 684 }
 685
 686 static void msm_power(struct uart_port *port, unsigned int state,
 687                       unsigned int oldstate)
 688 {
 689         struct msm_port *msm_port = UART_TO_MSM(port);
 690
 691         switch (state) {
 692         case 0:
 693                 clk_enable(msm_port->clk);
 694                 if (!IS_ERR(msm_port->pclk))
 695                         clk_enable(msm_port->pclk);
 696                 break;
 697         case 3:
 698                 clk_disable(msm_port->clk);
 699                 if (!IS_ERR(msm_port->pclk))
 700                         clk_disable(msm_port->pclk);
 701                 break;
 702         default:
 703                 printk(KERN_ERR "msm_serial: Unknown PM state %d\n", state);
 704         }
 705 }
 706
 707 static struct uart_ops msm_uart_pops = {
 708         .tx_empty = msm_tx_empty,
 709         .set_mctrl = msm_set_mctrl,
 710         .get_mctrl = msm_get_mctrl,
 711         .stop_tx = msm_stop_tx,
 712         .start_tx = msm_start_tx,
 713         .stop_rx = msm_stop_rx,
 714         .enable_ms = msm_enable_ms,
 715         .break_ctl = msm_break_ctl,
 716         .startup = msm_startup,
 717         .shutdown = msm_shutdown,
 718         .set_termios = msm_set_termios,
 719         .type = msm_type,
 720         .release_port = msm_release_port,
 721         .request_port = msm_request_port,
 722         .config_port = msm_config_port,
 723         .verify_port = msm_verify_port,
 724         .pm = msm_power,
 725 };
 726
 727 static struct msm_port msm_uart_ports[] = {
 728         {
 729                 .uart = {
 730                         .iotype = UPIO_MEM,
 731                         .ops = &msm_uart_pops,
 732                         .flags = UPF_BOOT_AUTOCONF,
 733                         .fifosize = 64,
 734                         .line = 0,
 735                 },
 736         },
 737         {
 738                 .uart = {
 739                         .iotype = UPIO_MEM,
 740                         .ops = &msm_uart_pops,
 741                         .flags = UPF_BOOT_AUTOCONF,
 742                         .fifosize = 64,
 743                         .line = 1,
 744                 },
 745         },
 746         {
 747                 .uart = {
 748                         .iotype = UPIO_MEM,
 749                         .ops = &msm_uart_pops,
 750                         .flags = UPF_BOOT_AUTOCONF,
 751                         .fifosize = 64,
 752                         .line = 2,
 753                 },
 754         },
 755 };
 756
 757 #define UART_NR ARRAY_SIZE(msm_uart_ports)
 758
 759 static inline struct uart_port *get_port_from_line(unsigned int line)
 760 {
 761         return &msm_uart_ports[line].uart;
 762 }
 763
 764 #ifdef CONFIG_SERIAL_MSM_CONSOLE
 765
 766 static void msm_console_putchar(struct uart_port *port, int c)
 767 {
 768         struct msm_port *msm_port = UART_TO_MSM(port);
 769
 770         if (msm_port->is_uartdm)
 771                 reset_dm_count(port);
 772
 773         while (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
 774                 ;
 775         msm_write(port, c, msm_port->is_uartdm ? UARTDM_TF : UART_TF);
 776 }
 777
 778 static void msm_console_write(struct console *co, const char *s,
 779                               unsigned int count)
 780 {
 781         struct uart_port *port;
 782         struct msm_port *msm_port;
 783
 784         BUG_ON(co->index < 0 || co->index >= UART_NR);
 785
 786         port = get_port_from_line(co->index);
 787         msm_port = UART_TO_MSM(port);
 788
 789         spin_lock(&port->lock);
 790         uart_console_write(port, s, count, msm_console_putchar);
 791         spin_unlock(&port->lock);
 792 }
 793
 794 static int __init msm_console_setup(struct console *co, char *options)
 795 {
 796         struct uart_port *port;
 797         struct msm_port *msm_port;
 798         int baud, flow, bits, parity;
 799
 800         if (unlikely(co->index >= UART_NR || co->index < 0))
 801                 return -ENXIO;
 802
 803         port = get_port_from_line(co->index);
 804         msm_port = UART_TO_MSM(port);
 805
 806         if (unlikely(!port->membase))
 807                 return -ENXIO;
 808
 809         msm_init_clock(port);
 810
 811         if (options)
 812                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 813
 814         bits = 8;
 815         parity = 'n';
 816         flow = 'n';
 817         msm_write(port, UART_MR2_BITS_PER_CHAR_8 | UART_MR2_STOP_BIT_LEN_ONE,
 818                   UART_MR2);    /* 8N1 */
 819
 820         if (baud < 300 || baud > 115200)
 821                 baud = 115200;
 822         msm_set_baud_rate(port, baud);
 823
 824         msm_reset(port);
 825
 826         if (msm_port->is_uartdm) {
 827                 msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
 828                 msm_write(port, UART_CR_TX_ENABLE, UART_CR);
 829         }
 830
 831         printk(KERN_INFO "msm_serial: console setup on port #%d\n", port->line);
 832
 833         return uart_set_options(port, co, baud, parity, bits, flow);
 834 }
 835
 836 static struct uart_driver msm_uart_driver;
 837
 838 static struct console msm_console = {
 839         .name = "ttyMSM",
 840         .write = msm_console_write,
 841         .device = uart_console_device,
 842         .setup = msm_console_setup,
 843         .flags = CON_PRINTBUFFER,
 844         .index = -1,
 845         .data = &msm_uart_driver,
 846 };
 847
 848 #define MSM_CONSOLE     (&msm_console)
 849
 850 #else
 851 #define MSM_CONSOLE     NULL
 852 #endif
 853
 854 static struct uart_driver msm_uart_driver = {
 855         .owner = THIS_MODULE,
 856         .driver_name = "msm_serial",
 857         .dev_name = "ttyMSM",
 858         .nr = UART_NR,
 859         .cons = MSM_CONSOLE,
 860 };
 861
 862 static atomic_t msm_uart_next_id = ATOMIC_INIT(0);
 863
 864 static int __init msm_serial_probe(struct platform_device *pdev)
 865 {
 866         struct msm_port *msm_port;
 867         struct resource *resource;
 868         struct uart_port *port;
 869         int irq;
 870
 871         if (pdev->id == -1)
 872                 pdev->id = atomic_inc_return(&msm_uart_next_id) - 1;
 873
 874         if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
 875                 return -ENXIO;
 876
 877         printk(KERN_INFO "msm_serial: detected port #%d\n", pdev->id);
 878
 879         port = get_port_from_line(pdev->id);
 880         port->dev = &pdev->dev;
 881         msm_port = UART_TO_MSM(port);
 882
 883         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
 884                 msm_port->is_uartdm = 1;
 885         else
 886                 msm_port->is_uartdm = 0;
 887
 888         if (msm_port->is_uartdm) {
 889                 msm_port->clk = clk_get(&pdev->dev, "gsbi_uart_clk");
 890                 msm_port->pclk = clk_get(&pdev->dev, "gsbi_pclk");
 891         } else {
 892                 msm_port->clk = clk_get(&pdev->dev, "uart_clk");
 893                 msm_port->pclk = ERR_PTR(-ENOENT);
 894         }
 895
 896         if (unlikely(IS_ERR(msm_port->clk) || (IS_ERR(msm_port->pclk) &&
 897                                                msm_port->is_uartdm)))
 898                         return PTR_ERR(msm_port->clk);
 899
 900         if (msm_port->is_uartdm)
 901                 clk_set_rate(msm_port->clk, 1843200);
 902
 903         port->uartclk = clk_get_rate(msm_port->clk);
 904         printk(KERN_INFO "uartclk = %d\n", port->uartclk);
 905
 906
 907         resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 908         if (unlikely(!resource))
 909                 return -ENXIO;
 910         port->mapbase = resource->start;
 911
 912         irq = platform_get_irq(pdev, 0);
 913         if (unlikely(irq < 0))
 914                 return -ENXIO;
 915         port->irq = irq;
 916
 917         platform_set_drvdata(pdev, port);
 918
 919         return uart_add_one_port(&msm_uart_driver, port);
 920 }
 921
 922 static int msm_serial_remove(struct platform_device *pdev)
 923 {
 924         struct msm_port *msm_port = platform_get_drvdata(pdev);
 925
 926         clk_put(msm_port->clk);
 927
 928         return 0;
 929 }
 930
 931 static struct of_device_id msm_match_table[] = {
 932         { .compatible = "qcom,msm-uart" },
 933         {}
 934 };
 935
 936 static struct platform_driver msm_platform_driver = {
 937         .remove = msm_serial_remove,
 938         .driver = {
 939                 .name = "msm_serial",
 940                 .owner = THIS_MODULE,
 941                 .of_match_table = msm_match_table,
 942         },
 943 };
 944
 945 static int __init msm_serial_init(void)
 946 {
 947         int ret;
 948
 949         ret = uart_register_driver(&msm_uart_driver);
 950         if (unlikely(ret))
 951                 return ret;
 952
 953         ret = platform_driver_probe(&msm_platform_driver, msm_serial_probe);
 954         if (unlikely(ret))
 955                 uart_unregister_driver(&msm_uart_driver);
 956
 957         printk(KERN_INFO "msm_serial: driver initialized\n");
 958
 959         return ret;
 960 }
 961
 962 static void __exit msm_serial_exit(void)
 963 {
 964 #ifdef CONFIG_SERIAL_MSM_CONSOLE
 965         unregister_console(&msm_console);
 966 #endif
 967         platform_driver_unregister(&msm_platform_driver);
 968         uart_unregister_driver(&msm_uart_driver);
 969 }
 970
 971 module_init(msm_serial_init);
 972 module_exit(msm_serial_exit);
 973
 974 MODULE_AUTHOR("Robert Love <rlove@google.com>");
 975 MODULE_DESCRIPTION("Driver for msm7x serial device");
 976 MODULE_LICENSE("GPL");