1 /* 2 * Driver for the PSC of the Freescale MPC52xx PSCs configured as UARTs. 3 * 4 * FIXME According to the usermanual the status bits in the status register 5 * are only updated when the peripherals access the FIFO and not when the 6 * CPU access them. So since we use this bits to know when we stop writing 7 * and reading, they may not be updated in-time and a race condition may 8 * exists. But I haven't be able to prove this and I don't care. But if 9 * any problem arises, it might worth checking. The TX/RX FIFO Stats 10 * registers should be used in addition. 11 * Update: Actually, they seem updated ... At least the bits we use. 12 * 13 * 14 * Maintainer : Sylvain Munaut <tnt@246tNt.com> 15 * 16 * Some of the code has been inspired/copied from the 2.4 code written 17 * by Dale Farnsworth <dfarnsworth@mvista.com>. 18 * 19 * Copyright (C) 2008 Freescale Semiconductor Inc. 20 * John Rigby <jrigby@gmail.com> 21 * Added support for MPC5121 22 * Copyright (C) 2006 Secret Lab Technologies Ltd. 23 * Grant Likely <grant.likely@secretlab.ca> 24 * Copyright (C) 2004-2006 Sylvain Munaut <tnt@246tNt.com> 25 * Copyright (C) 2003 MontaVista, Software, Inc. 26 * 27 * This file is licensed under the terms of the GNU General Public License 28 * version 2. This program is licensed "as is" without any warranty of any 29 * kind, whether express or implied. 30 */ 31 32 #undef DEBUG 33 34 #include <linux/device.h> 35 #include <linux/module.h> 36 #include <linux/tty.h> 37 #include <linux/tty_flip.h> 38 #include <linux/serial.h> 39 #include <linux/sysrq.h> 40 #include <linux/console.h> 41 #include <linux/delay.h> 42 #include <linux/io.h> 43 #include <linux/of.h> 44 #include <linux/of_platform.h> 45 #include <linux/clk.h> 46 47 #include <asm/mpc52xx.h> 48 #include <asm/mpc52xx_psc.h> 49 50 #if defined(CONFIG_SERIAL_MPC52xx_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 51 #define SUPPORT_SYSRQ 52 #endif 53 54 #include <linux/serial_core.h> 55 56 57 /* We've been assigned a range on the "Low-density serial ports" major */ 58 #define SERIAL_PSC_MAJOR 204 59 #define SERIAL_PSC_MINOR 148 60 61 62 #define ISR_PASS_LIMIT 256 /* Max number of iteration in the interrupt */ 63 64 65 static struct uart_port mpc52xx_uart_ports[MPC52xx_PSC_MAXNUM]; 66 /* Rem: - We use the read_status_mask as a shadow of 67 * psc->mpc52xx_psc_imr 68 * - It's important that is array is all zero on start as we 69 * use it to know if it's initialized or not ! If it's not sure 70 * it's cleared, then a memset(...,0,...) should be added to 71 * the console_init 72 */ 73 74 /* lookup table for matching device nodes to index numbers */ 75 static struct device_node *mpc52xx_uart_nodes[MPC52xx_PSC_MAXNUM]; 76 77 static void mpc52xx_uart_of_enumerate(void); 78 79 80 #define PSC(port) ((struct mpc52xx_psc __iomem *)((port)->membase)) 81 82 83 /* Forward declaration of the interruption handling routine */ 84 static irqreturn_t mpc52xx_uart_int(int irq, void *dev_id); 85 static irqreturn_t mpc5xxx_uart_process_int(struct uart_port *port); 86 87 /* ======================================================================== */ 88 /* PSC fifo operations for isolating differences between 52xx and 512x */ 89 /* ======================================================================== */ 90 91 struct psc_ops { 92 void (*fifo_init)(struct uart_port *port); 93 int (*raw_rx_rdy)(struct uart_port *port); 94 int (*raw_tx_rdy)(struct uart_port *port); 95 int (*rx_rdy)(struct uart_port *port); 96 int (*tx_rdy)(struct uart_port *port); 97 int (*tx_empty)(struct uart_port *port); 98 void (*stop_rx)(struct uart_port *port); 99 void (*start_tx)(struct uart_port *port); 100 void (*stop_tx)(struct uart_port *port); 101 void (*rx_clr_irq)(struct uart_port *port); 102 void (*tx_clr_irq)(struct uart_port *port); 103 void (*write_char)(struct uart_port *port, unsigned char c); 104 unsigned char (*read_char)(struct uart_port *port); 105 void (*cw_disable_ints)(struct uart_port *port); 106 void (*cw_restore_ints)(struct uart_port *port); 107 unsigned int (*set_baudrate)(struct uart_port *port, 108 struct ktermios *new, 109 struct ktermios *old); 110 int (*clock_alloc)(struct uart_port *port); 111 void (*clock_relse)(struct uart_port *port); 112 int (*clock)(struct uart_port *port, int enable); 113 int (*fifoc_init)(void); 114 void (*fifoc_uninit)(void); 115 void (*get_irq)(struct uart_port *, struct device_node *); 116 irqreturn_t (*handle_irq)(struct uart_port *port); 117 u16 (*get_status)(struct uart_port *port); 118 u8 (*get_ipcr)(struct uart_port *port); 119 void (*command)(struct uart_port *port, u8 cmd); 120 void (*set_mode)(struct uart_port *port, u8 mr1, u8 mr2); 121 void (*set_rts)(struct uart_port *port, int state); 122 void (*enable_ms)(struct uart_port *port); 123 void (*set_sicr)(struct uart_port *port, u32 val); 124 void (*set_imr)(struct uart_port *port, u16 val); 125 u8 (*get_mr1)(struct uart_port *port); 126 }; 127 128 /* setting the prescaler and divisor reg is common for all chips */ 129 static inline void mpc52xx_set_divisor(struct mpc52xx_psc __iomem *psc, 130 u16 prescaler, unsigned int divisor) 131 { 132 /* select prescaler */ 133 out_be16(&psc->mpc52xx_psc_clock_select, prescaler); 134 out_8(&psc->ctur, divisor >> 8); 135 out_8(&psc->ctlr, divisor & 0xff); 136 } 137 138 static u16 mpc52xx_psc_get_status(struct uart_port *port) 139 { 140 return in_be16(&PSC(port)->mpc52xx_psc_status); 141 } 142 143 static u8 mpc52xx_psc_get_ipcr(struct uart_port *port) 144 { 145 return in_8(&PSC(port)->mpc52xx_psc_ipcr); 146 } 147 148 static void mpc52xx_psc_command(struct uart_port *port, u8 cmd) 149 { 150 out_8(&PSC(port)->command, cmd); 151 } 152 153 static void mpc52xx_psc_set_mode(struct uart_port *port, u8 mr1, u8 mr2) 154 { 155 out_8(&PSC(port)->command, MPC52xx_PSC_SEL_MODE_REG_1); 156 out_8(&PSC(port)->mode, mr1); 157 out_8(&PSC(port)->mode, mr2); 158 } 159 160 static void mpc52xx_psc_set_rts(struct uart_port *port, int state) 161 { 162 if (state) 163 out_8(&PSC(port)->op1, MPC52xx_PSC_OP_RTS); 164 else 165 out_8(&PSC(port)->op0, MPC52xx_PSC_OP_RTS); 166 } 167 168 static void mpc52xx_psc_enable_ms(struct uart_port *port) 169 { 170 struct mpc52xx_psc __iomem *psc = PSC(port); 171 172 /* clear D_*-bits by reading them */ 173 in_8(&psc->mpc52xx_psc_ipcr); 174 /* enable CTS and DCD as IPC interrupts */ 175 out_8(&psc->mpc52xx_psc_acr, MPC52xx_PSC_IEC_CTS | MPC52xx_PSC_IEC_DCD); 176 177 port->read_status_mask |= MPC52xx_PSC_IMR_IPC; 178 out_be16(&psc->mpc52xx_psc_imr, port->read_status_mask); 179 } 180 181 static void mpc52xx_psc_set_sicr(struct uart_port *port, u32 val) 182 { 183 out_be32(&PSC(port)->sicr, val); 184 } 185 186 static void mpc52xx_psc_set_imr(struct uart_port *port, u16 val) 187 { 188 out_be16(&PSC(port)->mpc52xx_psc_imr, val); 189 } 190 191 static u8 mpc52xx_psc_get_mr1(struct uart_port *port) 192 { 193 out_8(&PSC(port)->command, MPC52xx_PSC_SEL_MODE_REG_1); 194 return in_8(&PSC(port)->mode); 195 } 196 197 #ifdef CONFIG_PPC_MPC52xx 198 #define FIFO_52xx(port) ((struct mpc52xx_psc_fifo __iomem *)(PSC(port)+1)) 199 static void mpc52xx_psc_fifo_init(struct uart_port *port) 200 { 201 struct mpc52xx_psc __iomem *psc = PSC(port); 202 struct mpc52xx_psc_fifo __iomem *fifo = FIFO_52xx(port); 203 204 out_8(&fifo->rfcntl, 0x00); 205 out_be16(&fifo->rfalarm, 0x1ff); 206 out_8(&fifo->tfcntl, 0x07); 207 out_be16(&fifo->tfalarm, 0x80); 208 209 port->read_status_mask |= MPC52xx_PSC_IMR_RXRDY | MPC52xx_PSC_IMR_TXRDY; 210 out_be16(&psc->mpc52xx_psc_imr, port->read_status_mask); 211 } 212 213 static int mpc52xx_psc_raw_rx_rdy(struct uart_port *port) 214 { 215 return in_be16(&PSC(port)->mpc52xx_psc_status) 216 & MPC52xx_PSC_SR_RXRDY; 217 } 218 219 static int mpc52xx_psc_raw_tx_rdy(struct uart_port *port) 220 { 221 return in_be16(&PSC(port)->mpc52xx_psc_status) 222 & MPC52xx_PSC_SR_TXRDY; 223 } 224 225 226 static int mpc52xx_psc_rx_rdy(struct uart_port *port) 227 { 228 return in_be16(&PSC(port)->mpc52xx_psc_isr) 229 & port->read_status_mask 230 & MPC52xx_PSC_IMR_RXRDY; 231 } 232 233 static int mpc52xx_psc_tx_rdy(struct uart_port *port) 234 { 235 return in_be16(&PSC(port)->mpc52xx_psc_isr) 236 & port->read_status_mask 237 & MPC52xx_PSC_IMR_TXRDY; 238 } 239 240 static int mpc52xx_psc_tx_empty(struct uart_port *port) 241 { 242 return in_be16(&PSC(port)->mpc52xx_psc_status) 243 & MPC52xx_PSC_SR_TXEMP; 244 } 245 246 static void mpc52xx_psc_start_tx(struct uart_port *port) 247 { 248 port->read_status_mask |= MPC52xx_PSC_IMR_TXRDY; 249 out_be16(&PSC(port)->mpc52xx_psc_imr, port->read_status_mask); 250 } 251 252 static void mpc52xx_psc_stop_tx(struct uart_port *port) 253 { 254 port->read_status_mask &= ~MPC52xx_PSC_IMR_TXRDY; 255 out_be16(&PSC(port)->mpc52xx_psc_imr, port->read_status_mask); 256 } 257 258 static void mpc52xx_psc_stop_rx(struct uart_port *port) 259 { 260 port->read_status_mask &= ~MPC52xx_PSC_IMR_RXRDY; 261 out_be16(&PSC(port)->mpc52xx_psc_imr, port->read_status_mask); 262 } 263 264 static void mpc52xx_psc_rx_clr_irq(struct uart_port *port) 265 { 266 } 267 268 static void mpc52xx_psc_tx_clr_irq(struct uart_port *port) 269 { 270 } 271 272 static void mpc52xx_psc_write_char(struct uart_port *port, unsigned char c) 273 { 274 out_8(&PSC(port)->mpc52xx_psc_buffer_8, c); 275 } 276 277 static unsigned char mpc52xx_psc_read_char(struct uart_port *port) 278 { 279 return in_8(&PSC(port)->mpc52xx_psc_buffer_8); 280 } 281 282 static void mpc52xx_psc_cw_disable_ints(struct uart_port *port) 283 { 284 out_be16(&PSC(port)->mpc52xx_psc_imr, 0); 285 } 286 287 static void mpc52xx_psc_cw_restore_ints(struct uart_port *port) 288 { 289 out_be16(&PSC(port)->mpc52xx_psc_imr, port->read_status_mask); 290 } 291 292 static unsigned int mpc5200_psc_set_baudrate(struct uart_port *port, 293 struct ktermios *new, 294 struct ktermios *old) 295 { 296 unsigned int baud; 297 unsigned int divisor; 298 299 /* The 5200 has a fixed /32 prescaler, uartclk contains the ipb freq */ 300 baud = uart_get_baud_rate(port, new, old, 301 port->uartclk / (32 * 0xffff) + 1, 302 port->uartclk / 32); 303 divisor = (port->uartclk + 16 * baud) / (32 * baud); 304 305 /* enable the /32 prescaler and set the divisor */ 306 mpc52xx_set_divisor(PSC(port), 0xdd00, divisor); 307 return baud; 308 } 309 310 static unsigned int mpc5200b_psc_set_baudrate(struct uart_port *port, 311 struct ktermios *new, 312 struct ktermios *old) 313 { 314 unsigned int baud; 315 unsigned int divisor; 316 u16 prescaler; 317 318 /* The 5200B has a selectable /4 or /32 prescaler, uartclk contains the 319 * ipb freq */ 320 baud = uart_get_baud_rate(port, new, old, 321 port->uartclk / (32 * 0xffff) + 1, 322 port->uartclk / 4); 323 divisor = (port->uartclk + 2 * baud) / (4 * baud); 324 325 /* select the proper prescaler and set the divisor 326 * prefer high prescaler for more tolerance on low baudrates */ 327 if (divisor > 0xffff || baud <= 115200) { 328 divisor = (divisor + 4) / 8; 329 prescaler = 0xdd00; /* /32 */ 330 } else 331 prescaler = 0xff00; /* /4 */ 332 mpc52xx_set_divisor(PSC(port), prescaler, divisor); 333 return baud; 334 } 335 336 static void mpc52xx_psc_get_irq(struct uart_port *port, struct device_node *np) 337 { 338 port->irqflags = 0; 339 port->irq = irq_of_parse_and_map(np, 0); 340 } 341 342 /* 52xx specific interrupt handler. The caller holds the port lock */ 343 static irqreturn_t mpc52xx_psc_handle_irq(struct uart_port *port) 344 { 345 return mpc5xxx_uart_process_int(port); 346 } 347 348 static struct psc_ops mpc52xx_psc_ops = { 349 .fifo_init = mpc52xx_psc_fifo_init, 350 .raw_rx_rdy = mpc52xx_psc_raw_rx_rdy, 351 .raw_tx_rdy = mpc52xx_psc_raw_tx_rdy, 352 .rx_rdy = mpc52xx_psc_rx_rdy, 353 .tx_rdy = mpc52xx_psc_tx_rdy, 354 .tx_empty = mpc52xx_psc_tx_empty, 355 .stop_rx = mpc52xx_psc_stop_rx, 356 .start_tx = mpc52xx_psc_start_tx, 357 .stop_tx = mpc52xx_psc_stop_tx, 358 .rx_clr_irq = mpc52xx_psc_rx_clr_irq, 359 .tx_clr_irq = mpc52xx_psc_tx_clr_irq, 360 .write_char = mpc52xx_psc_write_char, 361 .read_char = mpc52xx_psc_read_char, 362 .cw_disable_ints = mpc52xx_psc_cw_disable_ints, 363 .cw_restore_ints = mpc52xx_psc_cw_restore_ints, 364 .set_baudrate = mpc5200_psc_set_baudrate, 365 .get_irq = mpc52xx_psc_get_irq, 366 .handle_irq = mpc52xx_psc_handle_irq, 367 .get_status = mpc52xx_psc_get_status, 368 .get_ipcr = mpc52xx_psc_get_ipcr, 369 .command = mpc52xx_psc_command, 370 .set_mode = mpc52xx_psc_set_mode, 371 .set_rts = mpc52xx_psc_set_rts, 372 .enable_ms = mpc52xx_psc_enable_ms, 373 .set_sicr = mpc52xx_psc_set_sicr, 374 .set_imr = mpc52xx_psc_set_imr, 375 .get_mr1 = mpc52xx_psc_get_mr1, 376 }; 377 378 static struct psc_ops mpc5200b_psc_ops = { 379 .fifo_init = mpc52xx_psc_fifo_init, 380 .raw_rx_rdy = mpc52xx_psc_raw_rx_rdy, 381 .raw_tx_rdy = mpc52xx_psc_raw_tx_rdy, 382 .rx_rdy = mpc52xx_psc_rx_rdy, 383 .tx_rdy = mpc52xx_psc_tx_rdy, 384 .tx_empty = mpc52xx_psc_tx_empty, 385 .stop_rx = mpc52xx_psc_stop_rx, 386 .start_tx = mpc52xx_psc_start_tx, 387 .stop_tx = mpc52xx_psc_stop_tx, 388 .rx_clr_irq = mpc52xx_psc_rx_clr_irq, 389 .tx_clr_irq = mpc52xx_psc_tx_clr_irq, 390 .write_char = mpc52xx_psc_write_char, 391 .read_char = mpc52xx_psc_read_char, 392 .cw_disable_ints = mpc52xx_psc_cw_disable_ints, 393 .cw_restore_ints = mpc52xx_psc_cw_restore_ints, 394 .set_baudrate = mpc5200b_psc_set_baudrate, 395 .get_irq = mpc52xx_psc_get_irq, 396 .handle_irq = mpc52xx_psc_handle_irq, 397 .get_status = mpc52xx_psc_get_status, 398 .get_ipcr = mpc52xx_psc_get_ipcr, 399 .command = mpc52xx_psc_command, 400 .set_mode = mpc52xx_psc_set_mode, 401 .set_rts = mpc52xx_psc_set_rts, 402 .enable_ms = mpc52xx_psc_enable_ms, 403 .set_sicr = mpc52xx_psc_set_sicr, 404 .set_imr = mpc52xx_psc_set_imr, 405 .get_mr1 = mpc52xx_psc_get_mr1, 406 }; 407 408 #endif /* CONFIG_MPC52xx */ 409 410 #ifdef CONFIG_PPC_MPC512x 411 #define FIFO_512x(port) ((struct mpc512x_psc_fifo __iomem *)(PSC(port)+1)) 412 413 /* PSC FIFO Controller for mpc512x */ 414 struct psc_fifoc { 415 u32 fifoc_cmd; 416 u32 fifoc_int; 417 u32 fifoc_dma; 418 u32 fifoc_axe; 419 u32 fifoc_debug; 420 }; 421 422 static struct psc_fifoc __iomem *psc_fifoc; 423 static unsigned int psc_fifoc_irq; 424 425 static void mpc512x_psc_fifo_init(struct uart_port *port) 426 { 427 /* /32 prescaler */ 428 out_be16(&PSC(port)->mpc52xx_psc_clock_select, 0xdd00); 429 430 out_be32(&FIFO_512x(port)->txcmd, MPC512x_PSC_FIFO_RESET_SLICE); 431 out_be32(&FIFO_512x(port)->txcmd, MPC512x_PSC_FIFO_ENABLE_SLICE); 432 out_be32(&FIFO_512x(port)->txalarm, 1); 433 out_be32(&FIFO_512x(port)->tximr, 0); 434 435 out_be32(&FIFO_512x(port)->rxcmd, MPC512x_PSC_FIFO_RESET_SLICE); 436 out_be32(&FIFO_512x(port)->rxcmd, MPC512x_PSC_FIFO_ENABLE_SLICE); 437 out_be32(&FIFO_512x(port)->rxalarm, 1); 438 out_be32(&FIFO_512x(port)->rximr, 0); 439 440 out_be32(&FIFO_512x(port)->tximr, MPC512x_PSC_FIFO_ALARM); 441 out_be32(&FIFO_512x(port)->rximr, MPC512x_PSC_FIFO_ALARM); 442 } 443 444 static int mpc512x_psc_raw_rx_rdy(struct uart_port *port) 445 { 446 return !(in_be32(&FIFO_512x(port)->rxsr) & MPC512x_PSC_FIFO_EMPTY); 447 } 448 449 static int mpc512x_psc_raw_tx_rdy(struct uart_port *port) 450 { 451 return !(in_be32(&FIFO_512x(port)->txsr) & MPC512x_PSC_FIFO_FULL); 452 } 453 454 static int mpc512x_psc_rx_rdy(struct uart_port *port) 455 { 456 return in_be32(&FIFO_512x(port)->rxsr) 457 & in_be32(&FIFO_512x(port)->rximr) 458 & MPC512x_PSC_FIFO_ALARM; 459 } 460 461 static int mpc512x_psc_tx_rdy(struct uart_port *port) 462 { 463 return in_be32(&FIFO_512x(port)->txsr) 464 & in_be32(&FIFO_512x(port)->tximr) 465 & MPC512x_PSC_FIFO_ALARM; 466 } 467 468 static int mpc512x_psc_tx_empty(struct uart_port *port) 469 { 470 return in_be32(&FIFO_512x(port)->txsr) 471 & MPC512x_PSC_FIFO_EMPTY; 472 } 473 474 static void mpc512x_psc_stop_rx(struct uart_port *port) 475 { 476 unsigned long rx_fifo_imr; 477 478 rx_fifo_imr = in_be32(&FIFO_512x(port)->rximr); 479 rx_fifo_imr &= ~MPC512x_PSC_FIFO_ALARM; 480 out_be32(&FIFO_512x(port)->rximr, rx_fifo_imr); 481 } 482 483 static void mpc512x_psc_start_tx(struct uart_port *port) 484 { 485 unsigned long tx_fifo_imr; 486 487 tx_fifo_imr = in_be32(&FIFO_512x(port)->tximr); 488 tx_fifo_imr |= MPC512x_PSC_FIFO_ALARM; 489 out_be32(&FIFO_512x(port)->tximr, tx_fifo_imr); 490 } 491 492 static void mpc512x_psc_stop_tx(struct uart_port *port) 493 { 494 unsigned long tx_fifo_imr; 495 496 tx_fifo_imr = in_be32(&FIFO_512x(port)->tximr); 497 tx_fifo_imr &= ~MPC512x_PSC_FIFO_ALARM; 498 out_be32(&FIFO_512x(port)->tximr, tx_fifo_imr); 499 } 500 501 static void mpc512x_psc_rx_clr_irq(struct uart_port *port) 502 { 503 out_be32(&FIFO_512x(port)->rxisr, in_be32(&FIFO_512x(port)->rxisr)); 504 } 505 506 static void mpc512x_psc_tx_clr_irq(struct uart_port *port) 507 { 508 out_be32(&FIFO_512x(port)->txisr, in_be32(&FIFO_512x(port)->txisr)); 509 } 510 511 static void mpc512x_psc_write_char(struct uart_port *port, unsigned char c) 512 { 513 out_8(&FIFO_512x(port)->txdata_8, c); 514 } 515 516 static unsigned char mpc512x_psc_read_char(struct uart_port *port) 517 { 518 return in_8(&FIFO_512x(port)->rxdata_8); 519 } 520 521 static void mpc512x_psc_cw_disable_ints(struct uart_port *port) 522 { 523 port->read_status_mask = 524 in_be32(&FIFO_512x(port)->tximr) << 16 | 525 in_be32(&FIFO_512x(port)->rximr); 526 out_be32(&FIFO_512x(port)->tximr, 0); 527 out_be32(&FIFO_512x(port)->rximr, 0); 528 } 529 530 static void mpc512x_psc_cw_restore_ints(struct uart_port *port) 531 { 532 out_be32(&FIFO_512x(port)->tximr, 533 (port->read_status_mask >> 16) & 0x7f); 534 out_be32(&FIFO_512x(port)->rximr, port->read_status_mask & 0x7f); 535 } 536 537 static unsigned int mpc512x_psc_set_baudrate(struct uart_port *port, 538 struct ktermios *new, 539 struct ktermios *old) 540 { 541 unsigned int baud; 542 unsigned int divisor; 543 544 /* 545 * The "MPC5121e Microcontroller Reference Manual, Rev. 3" says on 546 * pg. 30-10 that the chip supports a /32 and a /10 prescaler. 547 * Furthermore, it states that "After reset, the prescaler by 10 548 * for the UART mode is selected", but the reset register value is 549 * 0x0000 which means a /32 prescaler. This is wrong. 550 * 551 * In reality using /32 prescaler doesn't work, as it is not supported! 552 * Use /16 or /10 prescaler, see "MPC5121e Hardware Design Guide", 553 * Chapter 4.1 PSC in UART Mode. 554 * Calculate with a /16 prescaler here. 555 */ 556 557 /* uartclk contains the ips freq */ 558 baud = uart_get_baud_rate(port, new, old, 559 port->uartclk / (16 * 0xffff) + 1, 560 port->uartclk / 16); 561 divisor = (port->uartclk + 8 * baud) / (16 * baud); 562 563 /* enable the /16 prescaler and set the divisor */ 564 mpc52xx_set_divisor(PSC(port), 0xdd00, divisor); 565 return baud; 566 } 567 568 /* Init PSC FIFO Controller */ 569 static int __init mpc512x_psc_fifoc_init(void) 570 { 571 struct device_node *np; 572 573 np = of_find_compatible_node(NULL, NULL, 574 "fsl,mpc5121-psc-fifo"); 575 if (!np) { 576 pr_err("%s: Can't find FIFOC node\n", __func__); 577 return -ENODEV; 578 } 579 580 psc_fifoc = of_iomap(np, 0); 581 if (!psc_fifoc) { 582 pr_err("%s: Can't map FIFOC\n", __func__); 583 of_node_put(np); 584 return -ENODEV; 585 } 586 587 psc_fifoc_irq = irq_of_parse_and_map(np, 0); 588 of_node_put(np); 589 if (psc_fifoc_irq == 0) { 590 pr_err("%s: Can't get FIFOC irq\n", __func__); 591 iounmap(psc_fifoc); 592 return -ENODEV; 593 } 594 595 return 0; 596 } 597 598 static void __exit mpc512x_psc_fifoc_uninit(void) 599 { 600 iounmap(psc_fifoc); 601 } 602 603 /* 512x specific interrupt handler. The caller holds the port lock */ 604 static irqreturn_t mpc512x_psc_handle_irq(struct uart_port *port) 605 { 606 unsigned long fifoc_int; 607 int psc_num; 608 609 /* Read pending PSC FIFOC interrupts */ 610 fifoc_int = in_be32(&psc_fifoc->fifoc_int); 611 612 /* Check if it is an interrupt for this port */ 613 psc_num = (port->mapbase & 0xf00) >> 8; 614 if (test_bit(psc_num, &fifoc_int) || 615 test_bit(psc_num + 16, &fifoc_int)) 616 return mpc5xxx_uart_process_int(port); 617 618 return IRQ_NONE; 619 } 620 621 static struct clk *psc_mclk_clk[MPC52xx_PSC_MAXNUM]; 622 623 /* called from within the .request_port() callback (allocation) */ 624 static int mpc512x_psc_alloc_clock(struct uart_port *port) 625 { 626 int psc_num; 627 char clk_name[16]; 628 struct clk *clk; 629 int err; 630 631 psc_num = (port->mapbase & 0xf00) >> 8; 632 snprintf(clk_name, sizeof(clk_name), "psc%d_mclk", psc_num); 633 clk = devm_clk_get(port->dev, clk_name); 634 if (IS_ERR(clk)) { 635 dev_err(port->dev, "Failed to get MCLK!\n"); 636 return PTR_ERR(clk); 637 } 638 err = clk_prepare_enable(clk); 639 if (err) { 640 dev_err(port->dev, "Failed to enable MCLK!\n"); 641 return err; 642 } 643 psc_mclk_clk[psc_num] = clk; 644 return 0; 645 } 646 647 /* called from within the .release_port() callback (release) */ 648 static void mpc512x_psc_relse_clock(struct uart_port *port) 649 { 650 int psc_num; 651 struct clk *clk; 652 653 psc_num = (port->mapbase & 0xf00) >> 8; 654 clk = psc_mclk_clk[psc_num]; 655 if (clk) { 656 clk_disable_unprepare(clk); 657 psc_mclk_clk[psc_num] = NULL; 658 } 659 } 660 661 /* implementation of the .clock() callback (enable/disable) */ 662 static int mpc512x_psc_endis_clock(struct uart_port *port, int enable) 663 { 664 int psc_num; 665 struct clk *psc_clk; 666 int ret; 667 668 if (uart_console(port)) 669 return 0; 670 671 psc_num = (port->mapbase & 0xf00) >> 8; 672 psc_clk = psc_mclk_clk[psc_num]; 673 if (!psc_clk) { 674 dev_err(port->dev, "Failed to get PSC clock entry!\n"); 675 return -ENODEV; 676 } 677 678 dev_dbg(port->dev, "mclk %sable\n", enable ? "en" : "dis"); 679 if (enable) { 680 ret = clk_enable(psc_clk); 681 if (ret) 682 dev_err(port->dev, "Failed to enable MCLK!\n"); 683 return ret; 684 } else { 685 clk_disable(psc_clk); 686 return 0; 687 } 688 } 689 690 static void mpc512x_psc_get_irq(struct uart_port *port, struct device_node *np) 691 { 692 port->irqflags = IRQF_SHARED; 693 port->irq = psc_fifoc_irq; 694 } 695 #endif 696 697 #ifdef CONFIG_PPC_MPC512x 698 699 #define PSC_5125(port) ((struct mpc5125_psc __iomem *)((port)->membase)) 700 #define FIFO_5125(port) ((struct mpc512x_psc_fifo __iomem *)(PSC_5125(port)+1)) 701 702 static void mpc5125_psc_fifo_init(struct uart_port *port) 703 { 704 /* /32 prescaler */ 705 out_8(&PSC_5125(port)->mpc52xx_psc_clock_select, 0xdd); 706 707 out_be32(&FIFO_5125(port)->txcmd, MPC512x_PSC_FIFO_RESET_SLICE); 708 out_be32(&FIFO_5125(port)->txcmd, MPC512x_PSC_FIFO_ENABLE_SLICE); 709 out_be32(&FIFO_5125(port)->txalarm, 1); 710 out_be32(&FIFO_5125(port)->tximr, 0); 711 712 out_be32(&FIFO_5125(port)->rxcmd, MPC512x_PSC_FIFO_RESET_SLICE); 713 out_be32(&FIFO_5125(port)->rxcmd, MPC512x_PSC_FIFO_ENABLE_SLICE); 714 out_be32(&FIFO_5125(port)->rxalarm, 1); 715 out_be32(&FIFO_5125(port)->rximr, 0); 716 717 out_be32(&FIFO_5125(port)->tximr, MPC512x_PSC_FIFO_ALARM); 718 out_be32(&FIFO_5125(port)->rximr, MPC512x_PSC_FIFO_ALARM); 719 } 720 721 static int mpc5125_psc_raw_rx_rdy(struct uart_port *port) 722 { 723 return !(in_be32(&FIFO_5125(port)->rxsr) & MPC512x_PSC_FIFO_EMPTY); 724 } 725 726 static int mpc5125_psc_raw_tx_rdy(struct uart_port *port) 727 { 728 return !(in_be32(&FIFO_5125(port)->txsr) & MPC512x_PSC_FIFO_FULL); 729 } 730 731 static int mpc5125_psc_rx_rdy(struct uart_port *port) 732 { 733 return in_be32(&FIFO_5125(port)->rxsr) & 734 in_be32(&FIFO_5125(port)->rximr) & MPC512x_PSC_FIFO_ALARM; 735 } 736 737 static int mpc5125_psc_tx_rdy(struct uart_port *port) 738 { 739 return in_be32(&FIFO_5125(port)->txsr) & 740 in_be32(&FIFO_5125(port)->tximr) & MPC512x_PSC_FIFO_ALARM; 741 } 742 743 static int mpc5125_psc_tx_empty(struct uart_port *port) 744 { 745 return in_be32(&FIFO_5125(port)->txsr) & MPC512x_PSC_FIFO_EMPTY; 746 } 747 748 static void mpc5125_psc_stop_rx(struct uart_port *port) 749 { 750 unsigned long rx_fifo_imr; 751 752 rx_fifo_imr = in_be32(&FIFO_5125(port)->rximr); 753 rx_fifo_imr &= ~MPC512x_PSC_FIFO_ALARM; 754 out_be32(&FIFO_5125(port)->rximr, rx_fifo_imr); 755 } 756 757 static void mpc5125_psc_start_tx(struct uart_port *port) 758 { 759 unsigned long tx_fifo_imr; 760 761 tx_fifo_imr = in_be32(&FIFO_5125(port)->tximr); 762 tx_fifo_imr |= MPC512x_PSC_FIFO_ALARM; 763 out_be32(&FIFO_5125(port)->tximr, tx_fifo_imr); 764 } 765 766 static void mpc5125_psc_stop_tx(struct uart_port *port) 767 { 768 unsigned long tx_fifo_imr; 769 770 tx_fifo_imr = in_be32(&FIFO_5125(port)->tximr); 771 tx_fifo_imr &= ~MPC512x_PSC_FIFO_ALARM; 772 out_be32(&FIFO_5125(port)->tximr, tx_fifo_imr); 773 } 774 775 static void mpc5125_psc_rx_clr_irq(struct uart_port *port) 776 { 777 out_be32(&FIFO_5125(port)->rxisr, in_be32(&FIFO_5125(port)->rxisr)); 778 } 779 780 static void mpc5125_psc_tx_clr_irq(struct uart_port *port) 781 { 782 out_be32(&FIFO_5125(port)->txisr, in_be32(&FIFO_5125(port)->txisr)); 783 } 784 785 static void mpc5125_psc_write_char(struct uart_port *port, unsigned char c) 786 { 787 out_8(&FIFO_5125(port)->txdata_8, c); 788 } 789 790 static unsigned char mpc5125_psc_read_char(struct uart_port *port) 791 { 792 return in_8(&FIFO_5125(port)->rxdata_8); 793 } 794 795 static void mpc5125_psc_cw_disable_ints(struct uart_port *port) 796 { 797 port->read_status_mask = 798 in_be32(&FIFO_5125(port)->tximr) << 16 | 799 in_be32(&FIFO_5125(port)->rximr); 800 out_be32(&FIFO_5125(port)->tximr, 0); 801 out_be32(&FIFO_5125(port)->rximr, 0); 802 } 803 804 static void mpc5125_psc_cw_restore_ints(struct uart_port *port) 805 { 806 out_be32(&FIFO_5125(port)->tximr, 807 (port->read_status_mask >> 16) & 0x7f); 808 out_be32(&FIFO_5125(port)->rximr, port->read_status_mask & 0x7f); 809 } 810 811 static inline void mpc5125_set_divisor(struct mpc5125_psc __iomem *psc, 812 u8 prescaler, unsigned int divisor) 813 { 814 /* select prescaler */ 815 out_8(&psc->mpc52xx_psc_clock_select, prescaler); 816 out_8(&psc->ctur, divisor >> 8); 817 out_8(&psc->ctlr, divisor & 0xff); 818 } 819 820 static unsigned int mpc5125_psc_set_baudrate(struct uart_port *port, 821 struct ktermios *new, 822 struct ktermios *old) 823 { 824 unsigned int baud; 825 unsigned int divisor; 826 827 /* 828 * Calculate with a /16 prescaler here. 829 */ 830 831 /* uartclk contains the ips freq */ 832 baud = uart_get_baud_rate(port, new, old, 833 port->uartclk / (16 * 0xffff) + 1, 834 port->uartclk / 16); 835 divisor = (port->uartclk + 8 * baud) / (16 * baud); 836 837 /* enable the /16 prescaler and set the divisor */ 838 mpc5125_set_divisor(PSC_5125(port), 0xdd, divisor); 839 return baud; 840 } 841 842 /* 843 * MPC5125 have compatible PSC FIFO Controller. 844 * Special init not needed. 845 */ 846 static u16 mpc5125_psc_get_status(struct uart_port *port) 847 { 848 return in_be16(&PSC_5125(port)->mpc52xx_psc_status); 849 } 850 851 static u8 mpc5125_psc_get_ipcr(struct uart_port *port) 852 { 853 return in_8(&PSC_5125(port)->mpc52xx_psc_ipcr); 854 } 855 856 static void mpc5125_psc_command(struct uart_port *port, u8 cmd) 857 { 858 out_8(&PSC_5125(port)->command, cmd); 859 } 860 861 static void mpc5125_psc_set_mode(struct uart_port *port, u8 mr1, u8 mr2) 862 { 863 out_8(&PSC_5125(port)->mr1, mr1); 864 out_8(&PSC_5125(port)->mr2, mr2); 865 } 866 867 static void mpc5125_psc_set_rts(struct uart_port *port, int state) 868 { 869 if (state & TIOCM_RTS) 870 out_8(&PSC_5125(port)->op1, MPC52xx_PSC_OP_RTS); 871 else 872 out_8(&PSC_5125(port)->op0, MPC52xx_PSC_OP_RTS); 873 } 874 875 static void mpc5125_psc_enable_ms(struct uart_port *port) 876 { 877 struct mpc5125_psc __iomem *psc = PSC_5125(port); 878 879 /* clear D_*-bits by reading them */ 880 in_8(&psc->mpc52xx_psc_ipcr); 881 /* enable CTS and DCD as IPC interrupts */ 882 out_8(&psc->mpc52xx_psc_acr, MPC52xx_PSC_IEC_CTS | MPC52xx_PSC_IEC_DCD); 883 884 port->read_status_mask |= MPC52xx_PSC_IMR_IPC; 885 out_be16(&psc->mpc52xx_psc_imr, port->read_status_mask); 886 } 887 888 static void mpc5125_psc_set_sicr(struct uart_port *port, u32 val) 889 { 890 out_be32(&PSC_5125(port)->sicr, val); 891 } 892 893 static void mpc5125_psc_set_imr(struct uart_port *port, u16 val) 894 { 895 out_be16(&PSC_5125(port)->mpc52xx_psc_imr, val); 896 } 897 898 static u8 mpc5125_psc_get_mr1(struct uart_port *port) 899 { 900 return in_8(&PSC_5125(port)->mr1); 901 } 902 903 static struct psc_ops mpc5125_psc_ops = { 904 .fifo_init = mpc5125_psc_fifo_init, 905 .raw_rx_rdy = mpc5125_psc_raw_rx_rdy, 906 .raw_tx_rdy = mpc5125_psc_raw_tx_rdy, 907 .rx_rdy = mpc5125_psc_rx_rdy, 908 .tx_rdy = mpc5125_psc_tx_rdy, 909 .tx_empty = mpc5125_psc_tx_empty, 910 .stop_rx = mpc5125_psc_stop_rx, 911 .start_tx = mpc5125_psc_start_tx, 912 .stop_tx = mpc5125_psc_stop_tx, 913 .rx_clr_irq = mpc5125_psc_rx_clr_irq, 914 .tx_clr_irq = mpc5125_psc_tx_clr_irq, 915 .write_char = mpc5125_psc_write_char, 916 .read_char = mpc5125_psc_read_char, 917 .cw_disable_ints = mpc5125_psc_cw_disable_ints, 918 .cw_restore_ints = mpc5125_psc_cw_restore_ints, 919 .set_baudrate = mpc5125_psc_set_baudrate, 920 .clock_alloc = mpc512x_psc_alloc_clock, 921 .clock_relse = mpc512x_psc_relse_clock, 922 .clock = mpc512x_psc_endis_clock, 923 .fifoc_init = mpc512x_psc_fifoc_init, 924 .fifoc_uninit = mpc512x_psc_fifoc_uninit, 925 .get_irq = mpc512x_psc_get_irq, 926 .handle_irq = mpc512x_psc_handle_irq, 927 .get_status = mpc5125_psc_get_status, 928 .get_ipcr = mpc5125_psc_get_ipcr, 929 .command = mpc5125_psc_command, 930 .set_mode = mpc5125_psc_set_mode, 931 .set_rts = mpc5125_psc_set_rts, 932 .enable_ms = mpc5125_psc_enable_ms, 933 .set_sicr = mpc5125_psc_set_sicr, 934 .set_imr = mpc5125_psc_set_imr, 935 .get_mr1 = mpc5125_psc_get_mr1, 936 }; 937 938 static struct psc_ops mpc512x_psc_ops = { 939 .fifo_init = mpc512x_psc_fifo_init, 940 .raw_rx_rdy = mpc512x_psc_raw_rx_rdy, 941 .raw_tx_rdy = mpc512x_psc_raw_tx_rdy, 942 .rx_rdy = mpc512x_psc_rx_rdy, 943 .tx_rdy = mpc512x_psc_tx_rdy, 944 .tx_empty = mpc512x_psc_tx_empty, 945 .stop_rx = mpc512x_psc_stop_rx, 946 .start_tx = mpc512x_psc_start_tx, 947 .stop_tx = mpc512x_psc_stop_tx, 948 .rx_clr_irq = mpc512x_psc_rx_clr_irq, 949 .tx_clr_irq = mpc512x_psc_tx_clr_irq, 950 .write_char = mpc512x_psc_write_char, 951 .read_char = mpc512x_psc_read_char, 952 .cw_disable_ints = mpc512x_psc_cw_disable_ints, 953 .cw_restore_ints = mpc512x_psc_cw_restore_ints, 954 .set_baudrate = mpc512x_psc_set_baudrate, 955 .clock_alloc = mpc512x_psc_alloc_clock, 956 .clock_relse = mpc512x_psc_relse_clock, 957 .clock = mpc512x_psc_endis_clock, 958 .fifoc_init = mpc512x_psc_fifoc_init, 959 .fifoc_uninit = mpc512x_psc_fifoc_uninit, 960 .get_irq = mpc512x_psc_get_irq, 961 .handle_irq = mpc512x_psc_handle_irq, 962 .get_status = mpc52xx_psc_get_status, 963 .get_ipcr = mpc52xx_psc_get_ipcr, 964 .command = mpc52xx_psc_command, 965 .set_mode = mpc52xx_psc_set_mode, 966 .set_rts = mpc52xx_psc_set_rts, 967 .enable_ms = mpc52xx_psc_enable_ms, 968 .set_sicr = mpc52xx_psc_set_sicr, 969 .set_imr = mpc52xx_psc_set_imr, 970 .get_mr1 = mpc52xx_psc_get_mr1, 971 }; 972 #endif /* CONFIG_PPC_MPC512x */ 973 974 975 static const struct psc_ops *psc_ops; 976 977 /* ======================================================================== */ 978 /* UART operations */ 979 /* ======================================================================== */ 980 981 static unsigned int 982 mpc52xx_uart_tx_empty(struct uart_port *port) 983 { 984 return psc_ops->tx_empty(port) ? TIOCSER_TEMT : 0; 985 } 986 987 static void 988 mpc52xx_uart_set_mctrl(struct uart_port *port, unsigned int mctrl) 989 { 990 psc_ops->set_rts(port, mctrl & TIOCM_RTS); 991 } 992 993 static unsigned int 994 mpc52xx_uart_get_mctrl(struct uart_port *port) 995 { 996 unsigned int ret = TIOCM_DSR; 997 u8 status = psc_ops->get_ipcr(port); 998 999 if (!(status & MPC52xx_PSC_CTS)) 1000 ret |= TIOCM_CTS; 1001 if (!(status & MPC52xx_PSC_DCD)) 1002 ret |= TIOCM_CAR; 1003 1004 return ret; 1005 } 1006 1007 static void 1008 mpc52xx_uart_stop_tx(struct uart_port *port) 1009 { 1010 /* port->lock taken by caller */ 1011 psc_ops->stop_tx(port); 1012 } 1013 1014 static void 1015 mpc52xx_uart_start_tx(struct uart_port *port) 1016 { 1017 /* port->lock taken by caller */ 1018 psc_ops->start_tx(port); 1019 } 1020 1021 static void 1022 mpc52xx_uart_send_xchar(struct uart_port *port, char ch) 1023 { 1024 unsigned long flags; 1025 spin_lock_irqsave(&port->lock, flags); 1026 1027 port->x_char = ch; 1028 if (ch) { 1029 /* Make sure tx interrupts are on */ 1030 /* Truly necessary ??? They should be anyway */ 1031 psc_ops->start_tx(port); 1032 } 1033 1034 spin_unlock_irqrestore(&port->lock, flags); 1035 } 1036 1037 static void 1038 mpc52xx_uart_stop_rx(struct uart_port *port) 1039 { 1040 /* port->lock taken by caller */ 1041 psc_ops->stop_rx(port); 1042 } 1043 1044 static void 1045 mpc52xx_uart_enable_ms(struct uart_port *port) 1046 { 1047 psc_ops->enable_ms(port); 1048 } 1049 1050 static void 1051 mpc52xx_uart_break_ctl(struct uart_port *port, int ctl) 1052 { 1053 unsigned long flags; 1054 spin_lock_irqsave(&port->lock, flags); 1055 1056 if (ctl == -1) 1057 psc_ops->command(port, MPC52xx_PSC_START_BRK); 1058 else 1059 psc_ops->command(port, MPC52xx_PSC_STOP_BRK); 1060 1061 spin_unlock_irqrestore(&port->lock, flags); 1062 } 1063 1064 static int 1065 mpc52xx_uart_startup(struct uart_port *port) 1066 { 1067 int ret; 1068 1069 if (psc_ops->clock) { 1070 ret = psc_ops->clock(port, 1); 1071 if (ret) 1072 return ret; 1073 } 1074 1075 /* Request IRQ */ 1076 ret = request_irq(port->irq, mpc52xx_uart_int, 1077 port->irqflags, "mpc52xx_psc_uart", port); 1078 if (ret) 1079 return ret; 1080 1081 /* Reset/activate the port, clear and enable interrupts */ 1082 psc_ops->command(port, MPC52xx_PSC_RST_RX); 1083 psc_ops->command(port, MPC52xx_PSC_RST_TX); 1084 1085 psc_ops->set_sicr(port, 0); /* UART mode DCD ignored */ 1086 1087 psc_ops->fifo_init(port); 1088 1089 psc_ops->command(port, MPC52xx_PSC_TX_ENABLE); 1090 psc_ops->command(port, MPC52xx_PSC_RX_ENABLE); 1091 1092 return 0; 1093 } 1094 1095 static void 1096 mpc52xx_uart_shutdown(struct uart_port *port) 1097 { 1098 /* Shut down the port. Leave TX active if on a console port */ 1099 psc_ops->command(port, MPC52xx_PSC_RST_RX); 1100 if (!uart_console(port)) 1101 psc_ops->command(port, MPC52xx_PSC_RST_TX); 1102 1103 port->read_status_mask = 0; 1104 psc_ops->set_imr(port, port->read_status_mask); 1105 1106 if (psc_ops->clock) 1107 psc_ops->clock(port, 0); 1108 1109 /* Disable interrupt */ 1110 psc_ops->cw_disable_ints(port); 1111 1112 /* Release interrupt */ 1113 free_irq(port->irq, port); 1114 } 1115 1116 static void 1117 mpc52xx_uart_set_termios(struct uart_port *port, struct ktermios *new, 1118 struct ktermios *old) 1119 { 1120 unsigned long flags; 1121 unsigned char mr1, mr2; 1122 unsigned int j; 1123 unsigned int baud; 1124 1125 /* Prepare what we're gonna write */ 1126 mr1 = 0; 1127 1128 switch (new->c_cflag & CSIZE) { 1129 case CS5: mr1 |= MPC52xx_PSC_MODE_5_BITS; 1130 break; 1131 case CS6: mr1 |= MPC52xx_PSC_MODE_6_BITS; 1132 break; 1133 case CS7: mr1 |= MPC52xx_PSC_MODE_7_BITS; 1134 break; 1135 case CS8: 1136 default: mr1 |= MPC52xx_PSC_MODE_8_BITS; 1137 } 1138 1139 if (new->c_cflag & PARENB) { 1140 if (new->c_cflag & CMSPAR) 1141 mr1 |= MPC52xx_PSC_MODE_PARFORCE; 1142 1143 /* With CMSPAR, PARODD also means high parity (same as termios) */ 1144 mr1 |= (new->c_cflag & PARODD) ? 1145 MPC52xx_PSC_MODE_PARODD : MPC52xx_PSC_MODE_PAREVEN; 1146 } else { 1147 mr1 |= MPC52xx_PSC_MODE_PARNONE; 1148 } 1149 1150 mr2 = 0; 1151 1152 if (new->c_cflag & CSTOPB) 1153 mr2 |= MPC52xx_PSC_MODE_TWO_STOP; 1154 else 1155 mr2 |= ((new->c_cflag & CSIZE) == CS5) ? 1156 MPC52xx_PSC_MODE_ONE_STOP_5_BITS : 1157 MPC52xx_PSC_MODE_ONE_STOP; 1158 1159 if (new->c_cflag & CRTSCTS) { 1160 mr1 |= MPC52xx_PSC_MODE_RXRTS; 1161 mr2 |= MPC52xx_PSC_MODE_TXCTS; 1162 } 1163 1164 /* Get the lock */ 1165 spin_lock_irqsave(&port->lock, flags); 1166 1167 /* Do our best to flush TX & RX, so we don't lose anything */ 1168 /* But we don't wait indefinitely ! */ 1169 j = 5000000; /* Maximum wait */ 1170 /* FIXME Can't receive chars since set_termios might be called at early 1171 * boot for the console, all stuff is not yet ready to receive at that 1172 * time and that just makes the kernel oops */ 1173 /* while (j-- && mpc52xx_uart_int_rx_chars(port)); */ 1174 while (!mpc52xx_uart_tx_empty(port) && --j) 1175 udelay(1); 1176 1177 if (!j) 1178 printk(KERN_ERR "mpc52xx_uart.c: " 1179 "Unable to flush RX & TX fifos in-time in set_termios." 1180 "Some chars may have been lost.\n"); 1181 1182 /* Reset the TX & RX */ 1183 psc_ops->command(port, MPC52xx_PSC_RST_RX); 1184 psc_ops->command(port, MPC52xx_PSC_RST_TX); 1185 1186 /* Send new mode settings */ 1187 psc_ops->set_mode(port, mr1, mr2); 1188 baud = psc_ops->set_baudrate(port, new, old); 1189 1190 /* Update the per-port timeout */ 1191 uart_update_timeout(port, new->c_cflag, baud); 1192 1193 if (UART_ENABLE_MS(port, new->c_cflag)) 1194 mpc52xx_uart_enable_ms(port); 1195 1196 /* Reenable TX & RX */ 1197 psc_ops->command(port, MPC52xx_PSC_TX_ENABLE); 1198 psc_ops->command(port, MPC52xx_PSC_RX_ENABLE); 1199 1200 /* We're all set, release the lock */ 1201 spin_unlock_irqrestore(&port->lock, flags); 1202 } 1203 1204 static const char * 1205 mpc52xx_uart_type(struct uart_port *port) 1206 { 1207 /* 1208 * We keep using PORT_MPC52xx for historic reasons although it applies 1209 * for MPC512x, too, but print "MPC5xxx" to not irritate users 1210 */ 1211 return port->type == PORT_MPC52xx ? "MPC5xxx PSC" : NULL; 1212 } 1213 1214 static void 1215 mpc52xx_uart_release_port(struct uart_port *port) 1216 { 1217 if (psc_ops->clock_relse) 1218 psc_ops->clock_relse(port); 1219 1220 /* remapped by us ? */ 1221 if (port->flags & UPF_IOREMAP) { 1222 iounmap(port->membase); 1223 port->membase = NULL; 1224 } 1225 1226 release_mem_region(port->mapbase, sizeof(struct mpc52xx_psc)); 1227 } 1228 1229 static int 1230 mpc52xx_uart_request_port(struct uart_port *port) 1231 { 1232 int err; 1233 1234 if (port->flags & UPF_IOREMAP) /* Need to remap ? */ 1235 port->membase = ioremap(port->mapbase, 1236 sizeof(struct mpc52xx_psc)); 1237 1238 if (!port->membase) 1239 return -EINVAL; 1240 1241 err = request_mem_region(port->mapbase, sizeof(struct mpc52xx_psc), 1242 "mpc52xx_psc_uart") != NULL ? 0 : -EBUSY; 1243 1244 if (err) 1245 goto out_membase; 1246 1247 if (psc_ops->clock_alloc) { 1248 err = psc_ops->clock_alloc(port); 1249 if (err) 1250 goto out_mapregion; 1251 } 1252 1253 return 0; 1254 1255 out_mapregion: 1256 release_mem_region(port->mapbase, sizeof(struct mpc52xx_psc)); 1257 out_membase: 1258 if (port->flags & UPF_IOREMAP) { 1259 iounmap(port->membase); 1260 port->membase = NULL; 1261 } 1262 return err; 1263 } 1264 1265 static void 1266 mpc52xx_uart_config_port(struct uart_port *port, int flags) 1267 { 1268 if ((flags & UART_CONFIG_TYPE) 1269 && (mpc52xx_uart_request_port(port) == 0)) 1270 port->type = PORT_MPC52xx; 1271 } 1272 1273 static int 1274 mpc52xx_uart_verify_port(struct uart_port *port, struct serial_struct *ser) 1275 { 1276 if (ser->type != PORT_UNKNOWN && ser->type != PORT_MPC52xx) 1277 return -EINVAL; 1278 1279 if ((ser->irq != port->irq) || 1280 (ser->io_type != UPIO_MEM) || 1281 (ser->baud_base != port->uartclk) || 1282 (ser->iomem_base != (void *)port->mapbase) || 1283 (ser->hub6 != 0)) 1284 return -EINVAL; 1285 1286 return 0; 1287 } 1288 1289 1290 static struct uart_ops mpc52xx_uart_ops = { 1291 .tx_empty = mpc52xx_uart_tx_empty, 1292 .set_mctrl = mpc52xx_uart_set_mctrl, 1293 .get_mctrl = mpc52xx_uart_get_mctrl, 1294 .stop_tx = mpc52xx_uart_stop_tx, 1295 .start_tx = mpc52xx_uart_start_tx, 1296 .send_xchar = mpc52xx_uart_send_xchar, 1297 .stop_rx = mpc52xx_uart_stop_rx, 1298 .enable_ms = mpc52xx_uart_enable_ms, 1299 .break_ctl = mpc52xx_uart_break_ctl, 1300 .startup = mpc52xx_uart_startup, 1301 .shutdown = mpc52xx_uart_shutdown, 1302 .set_termios = mpc52xx_uart_set_termios, 1303 /* .pm = mpc52xx_uart_pm, Not supported yet */ 1304 .type = mpc52xx_uart_type, 1305 .release_port = mpc52xx_uart_release_port, 1306 .request_port = mpc52xx_uart_request_port, 1307 .config_port = mpc52xx_uart_config_port, 1308 .verify_port = mpc52xx_uart_verify_port 1309 }; 1310 1311 1312 /* ======================================================================== */ 1313 /* Interrupt handling */ 1314 /* ======================================================================== */ 1315 1316 static inline int 1317 mpc52xx_uart_int_rx_chars(struct uart_port *port) 1318 { 1319 struct tty_port *tport = &port->state->port; 1320 unsigned char ch, flag; 1321 unsigned short status; 1322 1323 /* While we can read, do so ! */ 1324 while (psc_ops->raw_rx_rdy(port)) { 1325 /* Get the char */ 1326 ch = psc_ops->read_char(port); 1327 1328 /* Handle sysreq char */ 1329 #ifdef SUPPORT_SYSRQ 1330 if (uart_handle_sysrq_char(port, ch)) { 1331 port->sysrq = 0; 1332 continue; 1333 } 1334 #endif 1335 1336 /* Store it */ 1337 1338 flag = TTY_NORMAL; 1339 port->icount.rx++; 1340 1341 status = psc_ops->get_status(port); 1342 1343 if (status & (MPC52xx_PSC_SR_PE | 1344 MPC52xx_PSC_SR_FE | 1345 MPC52xx_PSC_SR_RB)) { 1346 1347 if (status & MPC52xx_PSC_SR_RB) { 1348 flag = TTY_BREAK; 1349 uart_handle_break(port); 1350 port->icount.brk++; 1351 } else if (status & MPC52xx_PSC_SR_PE) { 1352 flag = TTY_PARITY; 1353 port->icount.parity++; 1354 } 1355 else if (status & MPC52xx_PSC_SR_FE) { 1356 flag = TTY_FRAME; 1357 port->icount.frame++; 1358 } 1359 1360 /* Clear error condition */ 1361 psc_ops->command(port, MPC52xx_PSC_RST_ERR_STAT); 1362 1363 } 1364 tty_insert_flip_char(tport, ch, flag); 1365 if (status & MPC52xx_PSC_SR_OE) { 1366 /* 1367 * Overrun is special, since it's 1368 * reported immediately, and doesn't 1369 * affect the current character 1370 */ 1371 tty_insert_flip_char(tport, 0, TTY_OVERRUN); 1372 port->icount.overrun++; 1373 } 1374 } 1375 1376 spin_unlock(&port->lock); 1377 tty_flip_buffer_push(tport); 1378 spin_lock(&port->lock); 1379 1380 return psc_ops->raw_rx_rdy(port); 1381 } 1382 1383 static inline int 1384 mpc52xx_uart_int_tx_chars(struct uart_port *port) 1385 { 1386 struct circ_buf *xmit = &port->state->xmit; 1387 1388 /* Process out of band chars */ 1389 if (port->x_char) { 1390 psc_ops->write_char(port, port->x_char); 1391 port->icount.tx++; 1392 port->x_char = 0; 1393 return 1; 1394 } 1395 1396 /* Nothing to do ? */ 1397 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { 1398 mpc52xx_uart_stop_tx(port); 1399 return 0; 1400 } 1401 1402 /* Send chars */ 1403 while (psc_ops->raw_tx_rdy(port)) { 1404 psc_ops->write_char(port, xmit->buf[xmit->tail]); 1405 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 1406 port->icount.tx++; 1407 if (uart_circ_empty(xmit)) 1408 break; 1409 } 1410 1411 /* Wake up */ 1412 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 1413 uart_write_wakeup(port); 1414 1415 /* Maybe we're done after all */ 1416 if (uart_circ_empty(xmit)) { 1417 mpc52xx_uart_stop_tx(port); 1418 return 0; 1419 } 1420 1421 return 1; 1422 } 1423 1424 static irqreturn_t 1425 mpc5xxx_uart_process_int(struct uart_port *port) 1426 { 1427 unsigned long pass = ISR_PASS_LIMIT; 1428 unsigned int keepgoing; 1429 u8 status; 1430 1431 /* While we have stuff to do, we continue */ 1432 do { 1433 /* If we don't find anything to do, we stop */ 1434 keepgoing = 0; 1435 1436 psc_ops->rx_clr_irq(port); 1437 if (psc_ops->rx_rdy(port)) 1438 keepgoing |= mpc52xx_uart_int_rx_chars(port); 1439 1440 psc_ops->tx_clr_irq(port); 1441 if (psc_ops->tx_rdy(port)) 1442 keepgoing |= mpc52xx_uart_int_tx_chars(port); 1443 1444 status = psc_ops->get_ipcr(port); 1445 if (status & MPC52xx_PSC_D_DCD) 1446 uart_handle_dcd_change(port, !(status & MPC52xx_PSC_DCD)); 1447 1448 if (status & MPC52xx_PSC_D_CTS) 1449 uart_handle_cts_change(port, !(status & MPC52xx_PSC_CTS)); 1450 1451 /* Limit number of iteration */ 1452 if (!(--pass)) 1453 keepgoing = 0; 1454 1455 } while (keepgoing); 1456 1457 return IRQ_HANDLED; 1458 } 1459 1460 static irqreturn_t 1461 mpc52xx_uart_int(int irq, void *dev_id) 1462 { 1463 struct uart_port *port = dev_id; 1464 irqreturn_t ret; 1465 1466 spin_lock(&port->lock); 1467 1468 ret = psc_ops->handle_irq(port); 1469 1470 spin_unlock(&port->lock); 1471 1472 return ret; 1473 } 1474 1475 /* ======================================================================== */ 1476 /* Console ( if applicable ) */ 1477 /* ======================================================================== */ 1478 1479 #ifdef CONFIG_SERIAL_MPC52xx_CONSOLE 1480 1481 static void __init 1482 mpc52xx_console_get_options(struct uart_port *port, 1483 int *baud, int *parity, int *bits, int *flow) 1484 { 1485 unsigned char mr1; 1486 1487 pr_debug("mpc52xx_console_get_options(port=%p)\n", port); 1488 1489 /* Read the mode registers */ 1490 mr1 = psc_ops->get_mr1(port); 1491 1492 /* CT{U,L}R are write-only ! */ 1493 *baud = CONFIG_SERIAL_MPC52xx_CONSOLE_BAUD; 1494 1495 /* Parse them */ 1496 switch (mr1 & MPC52xx_PSC_MODE_BITS_MASK) { 1497 case MPC52xx_PSC_MODE_5_BITS: 1498 *bits = 5; 1499 break; 1500 case MPC52xx_PSC_MODE_6_BITS: 1501 *bits = 6; 1502 break; 1503 case MPC52xx_PSC_MODE_7_BITS: 1504 *bits = 7; 1505 break; 1506 case MPC52xx_PSC_MODE_8_BITS: 1507 default: 1508 *bits = 8; 1509 } 1510 1511 if (mr1 & MPC52xx_PSC_MODE_PARNONE) 1512 *parity = 'n'; 1513 else 1514 *parity = mr1 & MPC52xx_PSC_MODE_PARODD ? 'o' : 'e'; 1515 } 1516 1517 static void 1518 mpc52xx_console_write(struct console *co, const char *s, unsigned int count) 1519 { 1520 struct uart_port *port = &mpc52xx_uart_ports[co->index]; 1521 unsigned int i, j; 1522 1523 /* Disable interrupts */ 1524 psc_ops->cw_disable_ints(port); 1525 1526 /* Wait the TX buffer to be empty */ 1527 j = 5000000; /* Maximum wait */ 1528 while (!mpc52xx_uart_tx_empty(port) && --j) 1529 udelay(1); 1530 1531 /* Write all the chars */ 1532 for (i = 0; i < count; i++, s++) { 1533 /* Line return handling */ 1534 if (*s == '\n') 1535 psc_ops->write_char(port, '\r'); 1536 1537 /* Send the char */ 1538 psc_ops->write_char(port, *s); 1539 1540 /* Wait the TX buffer to be empty */ 1541 j = 20000; /* Maximum wait */ 1542 while (!mpc52xx_uart_tx_empty(port) && --j) 1543 udelay(1); 1544 } 1545 1546 /* Restore interrupt state */ 1547 psc_ops->cw_restore_ints(port); 1548 } 1549 1550 1551 static int __init 1552 mpc52xx_console_setup(struct console *co, char *options) 1553 { 1554 struct uart_port *port = &mpc52xx_uart_ports[co->index]; 1555 struct device_node *np = mpc52xx_uart_nodes[co->index]; 1556 unsigned int uartclk; 1557 struct resource res; 1558 int ret; 1559 1560 int baud = CONFIG_SERIAL_MPC52xx_CONSOLE_BAUD; 1561 int bits = 8; 1562 int parity = 'n'; 1563 int flow = 'n'; 1564 1565 pr_debug("mpc52xx_console_setup co=%p, co->index=%i, options=%s\n", 1566 co, co->index, options); 1567 1568 if ((co->index < 0) || (co->index >= MPC52xx_PSC_MAXNUM)) { 1569 pr_debug("PSC%x out of range\n", co->index); 1570 return -EINVAL; 1571 } 1572 1573 if (!np) { 1574 pr_debug("PSC%x not found in device tree\n", co->index); 1575 return -EINVAL; 1576 } 1577 1578 pr_debug("Console on ttyPSC%x is %s\n", 1579 co->index, mpc52xx_uart_nodes[co->index]->full_name); 1580 1581 /* Fetch register locations */ 1582 ret = of_address_to_resource(np, 0, &res); 1583 if (ret) { 1584 pr_debug("Could not get resources for PSC%x\n", co->index); 1585 return ret; 1586 } 1587 1588 uartclk = mpc5xxx_get_bus_frequency(np); 1589 if (uartclk == 0) { 1590 pr_debug("Could not find uart clock frequency!\n"); 1591 return -EINVAL; 1592 } 1593 1594 /* Basic port init. Needed since we use some uart_??? func before 1595 * real init for early access */ 1596 spin_lock_init(&port->lock); 1597 port->uartclk = uartclk; 1598 port->ops = &mpc52xx_uart_ops; 1599 port->mapbase = res.start; 1600 port->membase = ioremap(res.start, sizeof(struct mpc52xx_psc)); 1601 port->irq = irq_of_parse_and_map(np, 0); 1602 1603 if (port->membase == NULL) 1604 return -EINVAL; 1605 1606 pr_debug("mpc52xx-psc uart at %p, mapped to %p, irq=%x, freq=%i\n", 1607 (void *)port->mapbase, port->membase, 1608 port->irq, port->uartclk); 1609 1610 /* Setup the port parameters accoding to options */ 1611 if (options) 1612 uart_parse_options(options, &baud, &parity, &bits, &flow); 1613 else 1614 mpc52xx_console_get_options(port, &baud, &parity, &bits, &flow); 1615 1616 pr_debug("Setting console parameters: %i %i%c1 flow=%c\n", 1617 baud, bits, parity, flow); 1618 1619 return uart_set_options(port, co, baud, parity, bits, flow); 1620 } 1621 1622 1623 static struct uart_driver mpc52xx_uart_driver; 1624 1625 static struct console mpc52xx_console = { 1626 .name = "ttyPSC", 1627 .write = mpc52xx_console_write, 1628 .device = uart_console_device, 1629 .setup = mpc52xx_console_setup, 1630 .flags = CON_PRINTBUFFER, 1631 .index = -1, /* Specified on the cmdline (e.g. console=ttyPSC0) */ 1632 .data = &mpc52xx_uart_driver, 1633 }; 1634 1635 1636 static int __init 1637 mpc52xx_console_init(void) 1638 { 1639 mpc52xx_uart_of_enumerate(); 1640 register_console(&mpc52xx_console); 1641 return 0; 1642 } 1643 1644 console_initcall(mpc52xx_console_init); 1645 1646 #define MPC52xx_PSC_CONSOLE &mpc52xx_console 1647 #else 1648 #define MPC52xx_PSC_CONSOLE NULL 1649 #endif 1650 1651 1652 /* ======================================================================== */ 1653 /* UART Driver */ 1654 /* ======================================================================== */ 1655 1656 static struct uart_driver mpc52xx_uart_driver = { 1657 .driver_name = "mpc52xx_psc_uart", 1658 .dev_name = "ttyPSC", 1659 .major = SERIAL_PSC_MAJOR, 1660 .minor = SERIAL_PSC_MINOR, 1661 .nr = MPC52xx_PSC_MAXNUM, 1662 .cons = MPC52xx_PSC_CONSOLE, 1663 }; 1664 1665 /* ======================================================================== */ 1666 /* OF Platform Driver */ 1667 /* ======================================================================== */ 1668 1669 static struct of_device_id mpc52xx_uart_of_match[] = { 1670 #ifdef CONFIG_PPC_MPC52xx 1671 { .compatible = "fsl,mpc5200b-psc-uart", .data = &mpc5200b_psc_ops, }, 1672 { .compatible = "fsl,mpc5200-psc-uart", .data = &mpc52xx_psc_ops, }, 1673 /* binding used by old lite5200 device trees: */ 1674 { .compatible = "mpc5200-psc-uart", .data = &mpc52xx_psc_ops, }, 1675 /* binding used by efika: */ 1676 { .compatible = "mpc5200-serial", .data = &mpc52xx_psc_ops, }, 1677 #endif 1678 #ifdef CONFIG_PPC_MPC512x 1679 { .compatible = "fsl,mpc5121-psc-uart", .data = &mpc512x_psc_ops, }, 1680 { .compatible = "fsl,mpc5125-psc-uart", .data = &mpc5125_psc_ops, }, 1681 #endif 1682 {}, 1683 }; 1684 1685 static int mpc52xx_uart_of_probe(struct platform_device *op) 1686 { 1687 int idx = -1; 1688 unsigned int uartclk; 1689 struct uart_port *port = NULL; 1690 struct resource res; 1691 int ret; 1692 1693 /* Check validity & presence */ 1694 for (idx = 0; idx < MPC52xx_PSC_MAXNUM; idx++) 1695 if (mpc52xx_uart_nodes[idx] == op->dev.of_node) 1696 break; 1697 if (idx >= MPC52xx_PSC_MAXNUM) 1698 return -EINVAL; 1699 pr_debug("Found %s assigned to ttyPSC%x\n", 1700 mpc52xx_uart_nodes[idx]->full_name, idx); 1701 1702 /* set the uart clock to the input clock of the psc, the different 1703 * prescalers are taken into account in the set_baudrate() methods 1704 * of the respective chip */ 1705 uartclk = mpc5xxx_get_bus_frequency(op->dev.of_node); 1706 if (uartclk == 0) { 1707 dev_dbg(&op->dev, "Could not find uart clock frequency!\n"); 1708 return -EINVAL; 1709 } 1710 1711 /* Init the port structure */ 1712 port = &mpc52xx_uart_ports[idx]; 1713 1714 spin_lock_init(&port->lock); 1715 port->uartclk = uartclk; 1716 port->fifosize = 512; 1717 port->iotype = UPIO_MEM; 1718 port->flags = UPF_BOOT_AUTOCONF | 1719 (uart_console(port) ? 0 : UPF_IOREMAP); 1720 port->line = idx; 1721 port->ops = &mpc52xx_uart_ops; 1722 port->dev = &op->dev; 1723 1724 /* Search for IRQ and mapbase */ 1725 ret = of_address_to_resource(op->dev.of_node, 0, &res); 1726 if (ret) 1727 return ret; 1728 1729 port->mapbase = res.start; 1730 if (!port->mapbase) { 1731 dev_dbg(&op->dev, "Could not allocate resources for PSC\n"); 1732 return -EINVAL; 1733 } 1734 1735 psc_ops->get_irq(port, op->dev.of_node); 1736 if (port->irq == 0) { 1737 dev_dbg(&op->dev, "Could not get irq\n"); 1738 return -EINVAL; 1739 } 1740 1741 dev_dbg(&op->dev, "mpc52xx-psc uart at %p, irq=%x, freq=%i\n", 1742 (void *)port->mapbase, port->irq, port->uartclk); 1743 1744 /* Add the port to the uart sub-system */ 1745 ret = uart_add_one_port(&mpc52xx_uart_driver, port); 1746 if (ret) 1747 return ret; 1748 1749 platform_set_drvdata(op, (void *)port); 1750 return 0; 1751 } 1752 1753 static int 1754 mpc52xx_uart_of_remove(struct platform_device *op) 1755 { 1756 struct uart_port *port = platform_get_drvdata(op); 1757 1758 if (port) 1759 uart_remove_one_port(&mpc52xx_uart_driver, port); 1760 1761 return 0; 1762 } 1763 1764 #ifdef CONFIG_PM 1765 static int 1766 mpc52xx_uart_of_suspend(struct platform_device *op, pm_message_t state) 1767 { 1768 struct uart_port *port = platform_get_drvdata(op); 1769 1770 if (port) 1771 uart_suspend_port(&mpc52xx_uart_driver, port); 1772 1773 return 0; 1774 } 1775 1776 static int 1777 mpc52xx_uart_of_resume(struct platform_device *op) 1778 { 1779 struct uart_port *port = platform_get_drvdata(op); 1780 1781 if (port) 1782 uart_resume_port(&mpc52xx_uart_driver, port); 1783 1784 return 0; 1785 } 1786 #endif 1787 1788 static void 1789 mpc52xx_uart_of_assign(struct device_node *np) 1790 { 1791 int i; 1792 1793 /* Find the first free PSC number */ 1794 for (i = 0; i < MPC52xx_PSC_MAXNUM; i++) { 1795 if (mpc52xx_uart_nodes[i] == NULL) { 1796 of_node_get(np); 1797 mpc52xx_uart_nodes[i] = np; 1798 return; 1799 } 1800 } 1801 } 1802 1803 static void 1804 mpc52xx_uart_of_enumerate(void) 1805 { 1806 static int enum_done; 1807 struct device_node *np; 1808 const struct of_device_id *match; 1809 int i; 1810 1811 if (enum_done) 1812 return; 1813 1814 /* Assign index to each PSC in device tree */ 1815 for_each_matching_node(np, mpc52xx_uart_of_match) { 1816 match = of_match_node(mpc52xx_uart_of_match, np); 1817 psc_ops = match->data; 1818 mpc52xx_uart_of_assign(np); 1819 } 1820 1821 enum_done = 1; 1822 1823 for (i = 0; i < MPC52xx_PSC_MAXNUM; i++) { 1824 if (mpc52xx_uart_nodes[i]) 1825 pr_debug("%s assigned to ttyPSC%x\n", 1826 mpc52xx_uart_nodes[i]->full_name, i); 1827 } 1828 } 1829 1830 MODULE_DEVICE_TABLE(of, mpc52xx_uart_of_match); 1831 1832 static struct platform_driver mpc52xx_uart_of_driver = { 1833 .probe = mpc52xx_uart_of_probe, 1834 .remove = mpc52xx_uart_of_remove, 1835 #ifdef CONFIG_PM 1836 .suspend = mpc52xx_uart_of_suspend, 1837 .resume = mpc52xx_uart_of_resume, 1838 #endif 1839 .driver = { 1840 .name = "mpc52xx-psc-uart", 1841 .owner = THIS_MODULE, 1842 .of_match_table = mpc52xx_uart_of_match, 1843 }, 1844 }; 1845 1846 1847 /* ======================================================================== */ 1848 /* Module */ 1849 /* ======================================================================== */ 1850 1851 static int __init 1852 mpc52xx_uart_init(void) 1853 { 1854 int ret; 1855 1856 printk(KERN_INFO "Serial: MPC52xx PSC UART driver\n"); 1857 1858 ret = uart_register_driver(&mpc52xx_uart_driver); 1859 if (ret) { 1860 printk(KERN_ERR "%s: uart_register_driver failed (%i)\n", 1861 __FILE__, ret); 1862 return ret; 1863 } 1864 1865 mpc52xx_uart_of_enumerate(); 1866 1867 /* 1868 * Map the PSC FIFO Controller and init if on MPC512x. 1869 */ 1870 if (psc_ops && psc_ops->fifoc_init) { 1871 ret = psc_ops->fifoc_init(); 1872 if (ret) 1873 goto err_init; 1874 } 1875 1876 ret = platform_driver_register(&mpc52xx_uart_of_driver); 1877 if (ret) { 1878 printk(KERN_ERR "%s: platform_driver_register failed (%i)\n", 1879 __FILE__, ret); 1880 goto err_reg; 1881 } 1882 1883 return 0; 1884 err_reg: 1885 if (psc_ops && psc_ops->fifoc_uninit) 1886 psc_ops->fifoc_uninit(); 1887 err_init: 1888 uart_unregister_driver(&mpc52xx_uart_driver); 1889 return ret; 1890 } 1891 1892 static void __exit 1893 mpc52xx_uart_exit(void) 1894 { 1895 if (psc_ops->fifoc_uninit) 1896 psc_ops->fifoc_uninit(); 1897 1898 platform_driver_unregister(&mpc52xx_uart_of_driver); 1899 uart_unregister_driver(&mpc52xx_uart_driver); 1900 } 1901 1902 1903 module_init(mpc52xx_uart_init); 1904 module_exit(mpc52xx_uart_exit); 1905 1906 MODULE_AUTHOR("Sylvain Munaut <tnt@246tNt.com>"); 1907 MODULE_DESCRIPTION("Freescale MPC52xx PSC UART"); 1908 MODULE_LICENSE("GPL"); 1909