1/* 68328serial.c: Serial port driver for 68328 microcontroller 2 * 3 * Copyright (C) 1995 David S. Miller <davem@caip.rutgers.edu> 4 * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com> 5 * Copyright (C) 1998, 1999 D. Jeff Dionne <jeff@uclinux.org> 6 * Copyright (C) 1999 Vladimir Gurevich <vgurevic@cisco.com> 7 * Copyright (C) 2002-2003 David McCullough <davidm@snapgear.com> 8 * Copyright (C) 2002 Greg Ungerer <gerg@snapgear.com> 9 * 10 * VZ Support/Fixes Evan Stawnyczy <e@lineo.ca> 11 * Multiple UART support Daniel Potts <danielp@cse.unsw.edu.au> 12 * Power management support Daniel Potts <danielp@cse.unsw.edu.au> 13 * VZ Second Serial Port enable Phil Wilshire 14 * 2.4/2.5 port David McCullough 15 */ 16 17#include <linux/module.h> 18#include <linux/errno.h> 19#include <linux/serial.h> 20#include <linux/signal.h> 21#include <linux/sched.h> 22#include <linux/timer.h> 23#include <linux/interrupt.h> 24#include <linux/tty.h> 25#include <linux/tty_flip.h> 26#include <linux/major.h> 27#include <linux/string.h> 28#include <linux/fcntl.h> 29#include <linux/mm.h> 30#include <linux/kernel.h> 31#include <linux/console.h> 32#include <linux/reboot.h> 33#include <linux/keyboard.h> 34#include <linux/init.h> 35#include <linux/pm.h> 36#include <linux/bitops.h> 37#include <linux/delay.h> 38#include <linux/gfp.h> 39 40#include <asm/io.h> 41#include <asm/irq.h> 42#include <asm/delay.h> 43#include <asm/uaccess.h> 44 45/* (es) */ 46/* note: perhaps we can murge these files, so that you can just 47 * define 1 of them, and they can sort that out for themselves 48 */ 49#if defined(CONFIG_M68EZ328) 50#include <asm/MC68EZ328.h> 51#else 52#if defined(CONFIG_M68VZ328) 53#include <asm/MC68VZ328.h> 54#else 55#include <asm/MC68328.h> 56#endif /* CONFIG_M68VZ328 */ 57#endif /* CONFIG_M68EZ328 */ 58 59/* Turn off usage of real serial interrupt code, to "support" Copilot */ 60#ifdef CONFIG_XCOPILOT_BUGS 61#undef USE_INTS 62#else 63#define USE_INTS 64#endif 65 66/* 67 * I believe this is the optimal setting that reduces the number of interrupts. 68 * At high speeds the output might become a little "bursted" (use USTCNT_TXHE 69 * if that bothers you), but in most cases it will not, since we try to 70 * transmit characters every time rs_interrupt is called. Thus, quite often 71 * you'll see that a receive interrupt occures before the transmit one. 72 * -- Vladimir Gurevich 73 */ 74#define USTCNT_TX_INTR_MASK (USTCNT_TXEE) 75 76/* 77 * 68328 and 68EZ328 UARTS are a little bit different. EZ328 has special 78 * "Old data interrupt" which occures whenever the data stay in the FIFO 79 * longer than 30 bits time. This allows us to use FIFO without compromising 80 * latency. '328 does not have this feature and without the real 328-based 81 * board I would assume that RXRE is the safest setting. 82 * 83 * For EZ328 I use RXHE (Half empty) interrupt to reduce the number of 84 * interrupts. RXFE (receive queue full) causes the system to lose data 85 * at least at 115200 baud 86 * 87 * If your board is busy doing other stuff, you might consider to use 88 * RXRE (data ready intrrupt) instead. 89 * 90 * The other option is to make these INTR masks run-time configurable, so 91 * that people can dynamically adapt them according to the current usage. 92 * -- Vladimir Gurevich 93 */ 94 95/* (es) */ 96#if defined(CONFIG_M68EZ328) || defined(CONFIG_M68VZ328) 97#define USTCNT_RX_INTR_MASK (USTCNT_RXHE | USTCNT_ODEN) 98#elif defined(CONFIG_M68328) 99#define USTCNT_RX_INTR_MASK (USTCNT_RXRE) 100#else 101#error Please, define the Rx interrupt events for your CPU 102#endif 103/* (/es) */ 104 105/* 106 * This is our internal structure for each serial port's state. 107 */ 108struct m68k_serial { 109 struct tty_port tport; 110 char is_cons; /* Is this our console. */ 111 int magic; 112 int baud_base; 113 int port; 114 int irq; 115 int type; /* UART type */ 116 int custom_divisor; 117 int x_char; /* xon/xoff character */ 118 int line; 119 unsigned char *xmit_buf; 120 int xmit_head; 121 int xmit_tail; 122 int xmit_cnt; 123}; 124 125#define SERIAL_MAGIC 0x5301 126 127/* 128 * Define the number of ports supported and their irqs. 129 */ 130#define NR_PORTS 1 131 132static struct m68k_serial m68k_soft[NR_PORTS]; 133 134static unsigned int uart_irqs[NR_PORTS] = { UART_IRQ_NUM }; 135 136/* multiple ports are contiguous in memory */ 137m68328_uart *uart_addr = (m68328_uart *)USTCNT_ADDR; 138 139struct tty_driver *serial_driver; 140 141static void change_speed(struct m68k_serial *info, struct tty_struct *tty); 142 143/* 144 * Setup for console. Argument comes from the boot command line. 145 */ 146 147/* note: this is messy, but it works, again, perhaps defined somewhere else?*/ 148#ifdef CONFIG_M68VZ328 149#define CONSOLE_BAUD_RATE 19200 150#define DEFAULT_CBAUD B19200 151#endif 152 153 154#ifndef CONSOLE_BAUD_RATE 155#define CONSOLE_BAUD_RATE 9600 156#define DEFAULT_CBAUD B9600 157#endif 158 159 160static int m68328_console_initted = 0; 161static int m68328_console_baud = CONSOLE_BAUD_RATE; 162static int m68328_console_cbaud = DEFAULT_CBAUD; 163 164 165static inline int serial_paranoia_check(struct m68k_serial *info, 166 char *name, const char *routine) 167{ 168#ifdef SERIAL_PARANOIA_CHECK 169 static const char *badmagic = 170 "Warning: bad magic number for serial struct %s in %s\n"; 171 static const char *badinfo = 172 "Warning: null m68k_serial for %s in %s\n"; 173 174 if (!info) { 175 printk(badinfo, name, routine); 176 return 1; 177 } 178 if (info->magic != SERIAL_MAGIC) { 179 printk(badmagic, name, routine); 180 return 1; 181 } 182#endif 183 return 0; 184} 185 186/* 187 * This is used to figure out the divisor speeds and the timeouts 188 */ 189static int baud_table[] = { 190 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 191 9600, 19200, 38400, 57600, 115200, 0 }; 192 193/* Utility routines */ 194static inline int get_baud(struct m68k_serial *ss) 195{ 196 unsigned long result = 115200; 197 unsigned short int baud = uart_addr[ss->line].ubaud; 198 if (GET_FIELD(baud, UBAUD_PRESCALER) == 0x38) result = 38400; 199 result >>= GET_FIELD(baud, UBAUD_DIVIDE); 200 201 return result; 202} 203 204/* 205 * ------------------------------------------------------------ 206 * rs_stop() and rs_start() 207 * 208 * This routines are called before setting or resetting tty->stopped. 209 * They enable or disable transmitter interrupts, as necessary. 210 * ------------------------------------------------------------ 211 */ 212static void rs_stop(struct tty_struct *tty) 213{ 214 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 215 m68328_uart *uart = &uart_addr[info->line]; 216 unsigned long flags; 217 218 if (serial_paranoia_check(info, tty->name, "rs_stop")) 219 return; 220 221 local_irq_save(flags); 222 uart->ustcnt &= ~USTCNT_TXEN; 223 local_irq_restore(flags); 224} 225 226static int rs_put_char(char ch) 227{ 228 unsigned long flags; 229 int loops = 0; 230 231 local_irq_save(flags); 232 233 while (!(UTX & UTX_TX_AVAIL) && (loops < 1000)) { 234 loops++; 235 udelay(5); 236 } 237 238 UTX_TXDATA = ch; 239 udelay(5); 240 local_irq_restore(flags); 241 return 1; 242} 243 244static void rs_start(struct tty_struct *tty) 245{ 246 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 247 m68328_uart *uart = &uart_addr[info->line]; 248 unsigned long flags; 249 250 if (serial_paranoia_check(info, tty->name, "rs_start")) 251 return; 252 253 local_irq_save(flags); 254 if (info->xmit_cnt && info->xmit_buf && !(uart->ustcnt & USTCNT_TXEN)) { 255#ifdef USE_INTS 256 uart->ustcnt |= USTCNT_TXEN | USTCNT_TX_INTR_MASK; 257#else 258 uart->ustcnt |= USTCNT_TXEN; 259#endif 260 } 261 local_irq_restore(flags); 262} 263 264static void receive_chars(struct m68k_serial *info, unsigned short rx) 265{ 266 m68328_uart *uart = &uart_addr[info->line]; 267 unsigned char ch, flag; 268 269 /* 270 * This do { } while() loop will get ALL chars out of Rx FIFO 271 */ 272#ifndef CONFIG_XCOPILOT_BUGS 273 do { 274#endif 275 ch = GET_FIELD(rx, URX_RXDATA); 276 277 if(info->is_cons) { 278 if(URX_BREAK & rx) { /* whee, break received */ 279 return; 280#ifdef CONFIG_MAGIC_SYSRQ 281 } else if (ch == 0x10) { /* ^P */ 282 show_state(); 283 show_free_areas(0); 284 show_buffers(); 285/* show_net_buffers(); */ 286 return; 287 } else if (ch == 0x12) { /* ^R */ 288 emergency_restart(); 289 return; 290#endif /* CONFIG_MAGIC_SYSRQ */ 291 } 292 } 293 294 flag = TTY_NORMAL; 295 296 if (rx & URX_PARITY_ERROR) 297 flag = TTY_PARITY; 298 else if (rx & URX_OVRUN) 299 flag = TTY_OVERRUN; 300 else if (rx & URX_FRAME_ERROR) 301 flag = TTY_FRAME; 302 303 tty_insert_flip_char(&info->tport, ch, flag); 304#ifndef CONFIG_XCOPILOT_BUGS 305 } while((rx = uart->urx.w) & URX_DATA_READY); 306#endif 307 308 tty_schedule_flip(&info->tport); 309} 310 311static void transmit_chars(struct m68k_serial *info, struct tty_struct *tty) 312{ 313 m68328_uart *uart = &uart_addr[info->line]; 314 315 if (info->x_char) { 316 /* Send next char */ 317 uart->utx.b.txdata = info->x_char; 318 info->x_char = 0; 319 goto clear_and_return; 320 } 321 322 if ((info->xmit_cnt <= 0) || !tty || tty->stopped) { 323 /* That's peculiar... TX ints off */ 324 uart->ustcnt &= ~USTCNT_TX_INTR_MASK; 325 goto clear_and_return; 326 } 327 328 /* Send char */ 329 uart->utx.b.txdata = info->xmit_buf[info->xmit_tail++]; 330 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1); 331 info->xmit_cnt--; 332 333 if(info->xmit_cnt <= 0) { 334 /* All done for now... TX ints off */ 335 uart->ustcnt &= ~USTCNT_TX_INTR_MASK; 336 goto clear_and_return; 337 } 338 339clear_and_return: 340 /* Clear interrupt (should be auto)*/ 341 return; 342} 343 344/* 345 * This is the serial driver's generic interrupt routine 346 */ 347irqreturn_t rs_interrupt(int irq, void *dev_id) 348{ 349 struct m68k_serial *info = dev_id; 350 struct tty_struct *tty = tty_port_tty_get(&info->tport); 351 m68328_uart *uart; 352 unsigned short rx; 353 unsigned short tx; 354 355 uart = &uart_addr[info->line]; 356 rx = uart->urx.w; 357 358#ifdef USE_INTS 359 tx = uart->utx.w; 360 361 if (rx & URX_DATA_READY) 362 receive_chars(info, rx); 363 if (tx & UTX_TX_AVAIL) 364 transmit_chars(info, tty); 365#else 366 receive_chars(info, rx); 367#endif 368 tty_kref_put(tty); 369 370 return IRQ_HANDLED; 371} 372 373static int startup(struct m68k_serial *info, struct tty_struct *tty) 374{ 375 m68328_uart *uart = &uart_addr[info->line]; 376 unsigned long flags; 377 378 if (info->tport.flags & ASYNC_INITIALIZED) 379 return 0; 380 381 if (!info->xmit_buf) { 382 info->xmit_buf = (unsigned char *) __get_free_page(GFP_KERNEL); 383 if (!info->xmit_buf) 384 return -ENOMEM; 385 } 386 387 local_irq_save(flags); 388 389 /* 390 * Clear the FIFO buffers and disable them 391 * (they will be reenabled in change_speed()) 392 */ 393 394 uart->ustcnt = USTCNT_UEN; 395 uart->ustcnt = USTCNT_UEN | USTCNT_RXEN | USTCNT_TXEN; 396 (void)uart->urx.w; 397 398 /* 399 * Finally, enable sequencing and interrupts 400 */ 401#ifdef USE_INTS 402 uart->ustcnt = USTCNT_UEN | USTCNT_RXEN | 403 USTCNT_RX_INTR_MASK | USTCNT_TX_INTR_MASK; 404#else 405 uart->ustcnt = USTCNT_UEN | USTCNT_RXEN | USTCNT_RX_INTR_MASK; 406#endif 407 408 if (tty) 409 clear_bit(TTY_IO_ERROR, &tty->flags); 410 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0; 411 412 /* 413 * and set the speed of the serial port 414 */ 415 416 change_speed(info, tty); 417 418 info->tport.flags |= ASYNC_INITIALIZED; 419 local_irq_restore(flags); 420 return 0; 421} 422 423/* 424 * This routine will shutdown a serial port; interrupts are disabled, and 425 * DTR is dropped if the hangup on close termio flag is on. 426 */ 427static void shutdown(struct m68k_serial *info, struct tty_struct *tty) 428{ 429 m68328_uart *uart = &uart_addr[info->line]; 430 unsigned long flags; 431 432 uart->ustcnt = 0; /* All off! */ 433 if (!(info->tport.flags & ASYNC_INITIALIZED)) 434 return; 435 436 local_irq_save(flags); 437 438 if (info->xmit_buf) { 439 free_page((unsigned long) info->xmit_buf); 440 info->xmit_buf = 0; 441 } 442 443 if (tty) 444 set_bit(TTY_IO_ERROR, &tty->flags); 445 446 info->tport.flags &= ~ASYNC_INITIALIZED; 447 local_irq_restore(flags); 448} 449 450struct { 451 int divisor, prescale; 452} 453#ifndef CONFIG_M68VZ328 454 hw_baud_table[18] = { 455 {0,0}, /* 0 */ 456 {0,0}, /* 50 */ 457 {0,0}, /* 75 */ 458 {0,0}, /* 110 */ 459 {0,0}, /* 134 */ 460 {0,0}, /* 150 */ 461 {0,0}, /* 200 */ 462 {7,0x26}, /* 300 */ 463 {6,0x26}, /* 600 */ 464 {5,0x26}, /* 1200 */ 465 {0,0}, /* 1800 */ 466 {4,0x26}, /* 2400 */ 467 {3,0x26}, /* 4800 */ 468 {2,0x26}, /* 9600 */ 469 {1,0x26}, /* 19200 */ 470 {0,0x26}, /* 38400 */ 471 {1,0x38}, /* 57600 */ 472 {0,0x38}, /* 115200 */ 473}; 474#else 475 hw_baud_table[18] = { 476 {0,0}, /* 0 */ 477 {0,0}, /* 50 */ 478 {0,0}, /* 75 */ 479 {0,0}, /* 110 */ 480 {0,0}, /* 134 */ 481 {0,0}, /* 150 */ 482 {0,0}, /* 200 */ 483 {0,0}, /* 300 */ 484 {7,0x26}, /* 600 */ 485 {6,0x26}, /* 1200 */ 486 {0,0}, /* 1800 */ 487 {5,0x26}, /* 2400 */ 488 {4,0x26}, /* 4800 */ 489 {3,0x26}, /* 9600 */ 490 {2,0x26}, /* 19200 */ 491 {1,0x26}, /* 38400 */ 492 {0,0x26}, /* 57600 */ 493 {1,0x38}, /* 115200 */ 494}; 495#endif 496/* rate = 1036800 / ((65 - prescale) * (1<<divider)) */ 497 498/* 499 * This routine is called to set the UART divisor registers to match 500 * the specified baud rate for a serial port. 501 */ 502static void change_speed(struct m68k_serial *info, struct tty_struct *tty) 503{ 504 m68328_uart *uart = &uart_addr[info->line]; 505 unsigned short port; 506 unsigned short ustcnt; 507 unsigned cflag; 508 int i; 509 510 cflag = tty->termios.c_cflag; 511 if (!(port = info->port)) 512 return; 513 514 ustcnt = uart->ustcnt; 515 uart->ustcnt = ustcnt & ~USTCNT_TXEN; 516 517 i = cflag & CBAUD; 518 if (i & CBAUDEX) { 519 i = (i & ~CBAUDEX) + B38400; 520 } 521 522 uart->ubaud = PUT_FIELD(UBAUD_DIVIDE, hw_baud_table[i].divisor) | 523 PUT_FIELD(UBAUD_PRESCALER, hw_baud_table[i].prescale); 524 525 ustcnt &= ~(USTCNT_PARITYEN | USTCNT_ODD_EVEN | USTCNT_STOP | USTCNT_8_7); 526 527 if ((cflag & CSIZE) == CS8) 528 ustcnt |= USTCNT_8_7; 529 530 if (cflag & CSTOPB) 531 ustcnt |= USTCNT_STOP; 532 533 if (cflag & PARENB) 534 ustcnt |= USTCNT_PARITYEN; 535 if (cflag & PARODD) 536 ustcnt |= USTCNT_ODD_EVEN; 537 538#ifdef CONFIG_SERIAL_68328_RTS_CTS 539 if (cflag & CRTSCTS) { 540 uart->utx.w &= ~ UTX_NOCTS; 541 } else { 542 uart->utx.w |= UTX_NOCTS; 543 } 544#endif 545 546 ustcnt |= USTCNT_TXEN; 547 548 uart->ustcnt = ustcnt; 549 return; 550} 551 552/* 553 * Fair output driver allows a process to speak. 554 */ 555static void rs_fair_output(void) 556{ 557 int left; /* Output no more than that */ 558 unsigned long flags; 559 struct m68k_serial *info = &m68k_soft[0]; 560 char c; 561 562 if (info == 0) return; 563 if (info->xmit_buf == 0) return; 564 565 local_irq_save(flags); 566 left = info->xmit_cnt; 567 while (left != 0) { 568 c = info->xmit_buf[info->xmit_tail]; 569 info->xmit_tail = (info->xmit_tail+1) & (SERIAL_XMIT_SIZE-1); 570 info->xmit_cnt--; 571 local_irq_restore(flags); 572 573 rs_put_char(c); 574 575 local_irq_save(flags); 576 left = min(info->xmit_cnt, left-1); 577 } 578 579 /* Last character is being transmitted now (hopefully). */ 580 udelay(5); 581 582 local_irq_restore(flags); 583 return; 584} 585 586/* 587 * m68k_console_print is registered for printk. 588 */ 589void console_print_68328(const char *p) 590{ 591 char c; 592 593 while((c=*(p++)) != 0) { 594 if(c == '\n') 595 rs_put_char('\r'); 596 rs_put_char(c); 597 } 598 599 /* Comment this if you want to have a strict interrupt-driven output */ 600 rs_fair_output(); 601 602 return; 603} 604 605static void rs_set_ldisc(struct tty_struct *tty) 606{ 607 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 608 609 if (serial_paranoia_check(info, tty->name, "rs_set_ldisc")) 610 return; 611 612 info->is_cons = (tty->termios.c_line == N_TTY); 613 614 printk("ttyS%d console mode %s\n", info->line, info->is_cons ? "on" : "off"); 615} 616 617static void rs_flush_chars(struct tty_struct *tty) 618{ 619 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 620 m68328_uart *uart = &uart_addr[info->line]; 621 unsigned long flags; 622 623 if (serial_paranoia_check(info, tty->name, "rs_flush_chars")) 624 return; 625#ifndef USE_INTS 626 for(;;) { 627#endif 628 629 /* Enable transmitter */ 630 local_irq_save(flags); 631 632 if (info->xmit_cnt <= 0 || tty->stopped || !info->xmit_buf) { 633 local_irq_restore(flags); 634 return; 635 } 636 637#ifdef USE_INTS 638 uart->ustcnt |= USTCNT_TXEN | USTCNT_TX_INTR_MASK; 639#else 640 uart->ustcnt |= USTCNT_TXEN; 641#endif 642 643#ifdef USE_INTS 644 if (uart->utx.w & UTX_TX_AVAIL) { 645#else 646 if (1) { 647#endif 648 /* Send char */ 649 uart->utx.b.txdata = info->xmit_buf[info->xmit_tail++]; 650 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1); 651 info->xmit_cnt--; 652 } 653 654#ifndef USE_INTS 655 while (!(uart->utx.w & UTX_TX_AVAIL)) udelay(5); 656 } 657#endif 658 local_irq_restore(flags); 659} 660 661extern void console_printn(const char * b, int count); 662 663static int rs_write(struct tty_struct * tty, 664 const unsigned char *buf, int count) 665{ 666 int c, total = 0; 667 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 668 m68328_uart *uart = &uart_addr[info->line]; 669 unsigned long flags; 670 671 if (serial_paranoia_check(info, tty->name, "rs_write")) 672 return 0; 673 674 if (!tty || !info->xmit_buf) 675 return 0; 676 677 local_save_flags(flags); 678 while (1) { 679 local_irq_disable(); 680 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1, 681 SERIAL_XMIT_SIZE - info->xmit_head)); 682 local_irq_restore(flags); 683 684 if (c <= 0) 685 break; 686 687 memcpy(info->xmit_buf + info->xmit_head, buf, c); 688 689 local_irq_disable(); 690 info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1); 691 info->xmit_cnt += c; 692 local_irq_restore(flags); 693 buf += c; 694 count -= c; 695 total += c; 696 } 697 698 if (info->xmit_cnt && !tty->stopped) { 699 /* Enable transmitter */ 700 local_irq_disable(); 701#ifndef USE_INTS 702 while(info->xmit_cnt) { 703#endif 704 705 uart->ustcnt |= USTCNT_TXEN; 706#ifdef USE_INTS 707 uart->ustcnt |= USTCNT_TX_INTR_MASK; 708#else 709 while (!(uart->utx.w & UTX_TX_AVAIL)) udelay(5); 710#endif 711 if (uart->utx.w & UTX_TX_AVAIL) { 712 uart->utx.b.txdata = info->xmit_buf[info->xmit_tail++]; 713 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1); 714 info->xmit_cnt--; 715 } 716 717#ifndef USE_INTS 718 } 719#endif 720 local_irq_restore(flags); 721 } 722 723 return total; 724} 725 726static int rs_write_room(struct tty_struct *tty) 727{ 728 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 729 int ret; 730 731 if (serial_paranoia_check(info, tty->name, "rs_write_room")) 732 return 0; 733 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1; 734 if (ret < 0) 735 ret = 0; 736 return ret; 737} 738 739static int rs_chars_in_buffer(struct tty_struct *tty) 740{ 741 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 742 743 if (serial_paranoia_check(info, tty->name, "rs_chars_in_buffer")) 744 return 0; 745 return info->xmit_cnt; 746} 747 748static void rs_flush_buffer(struct tty_struct *tty) 749{ 750 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 751 unsigned long flags; 752 753 if (serial_paranoia_check(info, tty->name, "rs_flush_buffer")) 754 return; 755 local_irq_save(flags); 756 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0; 757 local_irq_restore(flags); 758 tty_wakeup(tty); 759} 760 761/* 762 * ------------------------------------------------------------ 763 * rs_throttle() 764 * 765 * This routine is called by the upper-layer tty layer to signal that 766 * incoming characters should be throttled. 767 * ------------------------------------------------------------ 768 */ 769static void rs_throttle(struct tty_struct * tty) 770{ 771 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 772 773 if (serial_paranoia_check(info, tty->name, "rs_throttle")) 774 return; 775 776 if (I_IXOFF(tty)) 777 info->x_char = STOP_CHAR(tty); 778 779 /* Turn off RTS line (do this atomic) */ 780} 781 782static void rs_unthrottle(struct tty_struct * tty) 783{ 784 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 785 786 if (serial_paranoia_check(info, tty->name, "rs_unthrottle")) 787 return; 788 789 if (I_IXOFF(tty)) { 790 if (info->x_char) 791 info->x_char = 0; 792 else 793 info->x_char = START_CHAR(tty); 794 } 795 796 /* Assert RTS line (do this atomic) */ 797} 798 799/* 800 * ------------------------------------------------------------ 801 * rs_ioctl() and friends 802 * ------------------------------------------------------------ 803 */ 804 805static int get_serial_info(struct m68k_serial * info, 806 struct serial_struct * retinfo) 807{ 808 struct serial_struct tmp; 809 810 if (!retinfo) 811 return -EFAULT; 812 memset(&tmp, 0, sizeof(tmp)); 813 tmp.type = info->type; 814 tmp.line = info->line; 815 tmp.port = info->port; 816 tmp.irq = info->irq; 817 tmp.flags = info->tport.flags; 818 tmp.baud_base = info->baud_base; 819 tmp.close_delay = info->tport.close_delay; 820 tmp.closing_wait = info->tport.closing_wait; 821 tmp.custom_divisor = info->custom_divisor; 822 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 823 return -EFAULT; 824 825 return 0; 826} 827 828static int set_serial_info(struct m68k_serial *info, struct tty_struct *tty, 829 struct serial_struct * new_info) 830{ 831 struct tty_port *port = &info->tport; 832 struct serial_struct new_serial; 833 struct m68k_serial old_info; 834 int retval = 0; 835 836 if (!new_info) 837 return -EFAULT; 838 if (copy_from_user(&new_serial, new_info, sizeof(new_serial))) 839 return -EFAULT; 840 old_info = *info; 841 842 if (!capable(CAP_SYS_ADMIN)) { 843 if ((new_serial.baud_base != info->baud_base) || 844 (new_serial.type != info->type) || 845 (new_serial.close_delay != port->close_delay) || 846 ((new_serial.flags & ~ASYNC_USR_MASK) != 847 (port->flags & ~ASYNC_USR_MASK))) 848 return -EPERM; 849 port->flags = ((port->flags & ~ASYNC_USR_MASK) | 850 (new_serial.flags & ASYNC_USR_MASK)); 851 info->custom_divisor = new_serial.custom_divisor; 852 goto check_and_exit; 853 } 854 855 if (port->count > 1) 856 return -EBUSY; 857 858 /* 859 * OK, past this point, all the error checking has been done. 860 * At this point, we start making changes..... 861 */ 862 863 info->baud_base = new_serial.baud_base; 864 port->flags = ((port->flags & ~ASYNC_FLAGS) | 865 (new_serial.flags & ASYNC_FLAGS)); 866 info->type = new_serial.type; 867 port->close_delay = new_serial.close_delay; 868 port->closing_wait = new_serial.closing_wait; 869 870check_and_exit: 871 retval = startup(info, tty); 872 return retval; 873} 874 875/* 876 * get_lsr_info - get line status register info 877 * 878 * Purpose: Let user call ioctl() to get info when the UART physically 879 * is emptied. On bus types like RS485, the transmitter must 880 * release the bus after transmitting. This must be done when 881 * the transmit shift register is empty, not be done when the 882 * transmit holding register is empty. This functionality 883 * allows an RS485 driver to be written in user space. 884 */ 885static int get_lsr_info(struct m68k_serial * info, unsigned int *value) 886{ 887#ifdef CONFIG_SERIAL_68328_RTS_CTS 888 m68328_uart *uart = &uart_addr[info->line]; 889#endif 890 unsigned char status; 891 unsigned long flags; 892 893 local_irq_save(flags); 894#ifdef CONFIG_SERIAL_68328_RTS_CTS 895 status = (uart->utx.w & UTX_CTS_STAT) ? 1 : 0; 896#else 897 status = 0; 898#endif 899 local_irq_restore(flags); 900 return put_user(status, value); 901} 902 903/* 904 * This routine sends a break character out the serial port. 905 */ 906static void send_break(struct m68k_serial * info, unsigned int duration) 907{ 908 m68328_uart *uart = &uart_addr[info->line]; 909 unsigned long flags; 910 if (!info->port) 911 return; 912 local_irq_save(flags); 913#ifdef USE_INTS 914 uart->utx.w |= UTX_SEND_BREAK; 915 msleep_interruptible(duration); 916 uart->utx.w &= ~UTX_SEND_BREAK; 917#endif 918 local_irq_restore(flags); 919} 920 921static int rs_ioctl(struct tty_struct *tty, 922 unsigned int cmd, unsigned long arg) 923{ 924 struct m68k_serial * info = (struct m68k_serial *)tty->driver_data; 925 int retval; 926 927 if (serial_paranoia_check(info, tty->name, "rs_ioctl")) 928 return -ENODEV; 929 930 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && 931 (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD) && 932 (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) { 933 if (tty->flags & (1 << TTY_IO_ERROR)) 934 return -EIO; 935 } 936 937 switch (cmd) { 938 case TCSBRK: /* SVID version: non-zero arg --> no break */ 939 retval = tty_check_change(tty); 940 if (retval) 941 return retval; 942 tty_wait_until_sent(tty, 0); 943 if (!arg) 944 send_break(info, 250); /* 1/4 second */ 945 return 0; 946 case TCSBRKP: /* support for POSIX tcsendbreak() */ 947 retval = tty_check_change(tty); 948 if (retval) 949 return retval; 950 tty_wait_until_sent(tty, 0); 951 send_break(info, arg ? arg*(100) : 250); 952 return 0; 953 case TIOCGSERIAL: 954 return get_serial_info(info, 955 (struct serial_struct *) arg); 956 case TIOCSSERIAL: 957 return set_serial_info(info, tty, 958 (struct serial_struct *) arg); 959 case TIOCSERGETLSR: /* Get line status register */ 960 return get_lsr_info(info, (unsigned int *) arg); 961 case TIOCSERGSTRUCT: 962 if (copy_to_user((struct m68k_serial *) arg, 963 info, sizeof(struct m68k_serial))) 964 return -EFAULT; 965 return 0; 966 default: 967 return -ENOIOCTLCMD; 968 } 969 return 0; 970} 971 972static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios) 973{ 974 struct m68k_serial *info = (struct m68k_serial *)tty->driver_data; 975 976 change_speed(info, tty); 977 978 if ((old_termios->c_cflag & CRTSCTS) && 979 !(tty->termios.c_cflag & CRTSCTS)) 980 rs_start(tty); 981 982} 983 984/* 985 * ------------------------------------------------------------ 986 * rs_close() 987 * 988 * This routine is called when the serial port gets closed. First, we 989 * wait for the last remaining data to be sent. Then, we unlink its 990 * S structure from the interrupt chain if necessary, and we free 991 * that IRQ if nothing is left in the chain. 992 * ------------------------------------------------------------ 993 */ 994static void rs_close(struct tty_struct *tty, struct file * filp) 995{ 996 struct m68k_serial * info = (struct m68k_serial *)tty->driver_data; 997 struct tty_port *port = &info->tport; 998 m68328_uart *uart = &uart_addr[info->line]; 999 unsigned long flags; 1000 1001 if (serial_paranoia_check(info, tty->name, "rs_close")) 1002 return; 1003 1004 local_irq_save(flags); 1005 1006 if (tty_hung_up_p(filp)) { 1007 local_irq_restore(flags); 1008 return; 1009 } 1010 1011 if ((tty->count == 1) && (port->count != 1)) { 1012 /* 1013 * Uh, oh. tty->count is 1, which means that the tty 1014 * structure will be freed. Info->count should always 1015 * be one in these conditions. If it's greater than 1016 * one, we've got real problems, since it means the 1017 * serial port won't be shutdown. 1018 */ 1019 printk("rs_close: bad serial port count; tty->count is 1, " 1020 "port->count is %d\n", port->count); 1021 port->count = 1; 1022 } 1023 if (--port->count < 0) { 1024 printk("rs_close: bad serial port count for ttyS%d: %d\n", 1025 info->line, port->count); 1026 port->count = 0; 1027 } 1028 if (port->count) { 1029 local_irq_restore(flags); 1030 return; 1031 } 1032 port->flags |= ASYNC_CLOSING; 1033 /* 1034 * Now we wait for the transmit buffer to clear; and we notify 1035 * the line discipline to only process XON/XOFF characters. 1036 */ 1037 tty->closing = 1; 1038 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) 1039 tty_wait_until_sent(tty, port->closing_wait); 1040 /* 1041 * At this point we stop accepting input. To do this, we 1042 * disable the receive line status interrupts, and tell the 1043 * interrupt driver to stop checking the data ready bit in the 1044 * line status register. 1045 */ 1046 1047 uart->ustcnt &= ~USTCNT_RXEN; 1048 uart->ustcnt &= ~(USTCNT_RXEN | USTCNT_RX_INTR_MASK); 1049 1050 shutdown(info, tty); 1051 rs_flush_buffer(tty); 1052 1053 tty_ldisc_flush(tty); 1054 tty->closing = 0; 1055 tty_port_tty_set(&info->tport, NULL); 1056#warning "This is not and has never been valid so fix it" 1057#if 0 1058 if (tty->ldisc.num != ldiscs[N_TTY].num) { 1059 if (tty->ldisc.close) 1060 (tty->ldisc.close)(tty); 1061 tty->ldisc = ldiscs[N_TTY]; 1062 tty->termios.c_line = N_TTY; 1063 if (tty->ldisc.open) 1064 (tty->ldisc.open)(tty); 1065 } 1066#endif 1067 if (port->blocked_open) { 1068 if (port->close_delay) 1069 msleep_interruptible(jiffies_to_msecs(port->close_delay)); 1070 wake_up_interruptible(&port->open_wait); 1071 } 1072 port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING); 1073 wake_up_interruptible(&port->close_wait); 1074 local_irq_restore(flags); 1075} 1076 1077/* 1078 * rs_hangup() --- called by tty_hangup() when a hangup is signaled. 1079 */ 1080void rs_hangup(struct tty_struct *tty) 1081{ 1082 struct m68k_serial * info = (struct m68k_serial *)tty->driver_data; 1083 1084 if (serial_paranoia_check(info, tty->name, "rs_hangup")) 1085 return; 1086 1087 rs_flush_buffer(tty); 1088 shutdown(info, tty); 1089 info->tport.count = 0; 1090 info->tport.flags &= ~ASYNC_NORMAL_ACTIVE; 1091 tty_port_tty_set(&info->tport, NULL); 1092 wake_up_interruptible(&info->tport.open_wait); 1093} 1094 1095/* 1096 * This routine is called whenever a serial port is opened. It 1097 * enables interrupts for a serial port, linking in its S structure into 1098 * the IRQ chain. It also performs the serial-specific 1099 * initialization for the tty structure. 1100 */ 1101int rs_open(struct tty_struct *tty, struct file * filp) 1102{ 1103 struct m68k_serial *info; 1104 int retval; 1105 1106 info = &m68k_soft[tty->index]; 1107 1108 if (serial_paranoia_check(info, tty->name, "rs_open")) 1109 return -ENODEV; 1110 1111 info->tport.count++; 1112 tty->driver_data = info; 1113 tty_port_tty_set(&info->tport, tty); 1114 1115 /* 1116 * Start up serial port 1117 */ 1118 retval = startup(info, tty); 1119 if (retval) 1120 return retval; 1121 1122 return tty_port_block_til_ready(&info->tport, tty, filp); 1123} 1124 1125/* Finally, routines used to initialize the serial driver. */ 1126 1127static void show_serial_version(void) 1128{ 1129 printk("MC68328 serial driver version 1.00\n"); 1130} 1131 1132static const struct tty_operations rs_ops = { 1133 .open = rs_open, 1134 .close = rs_close, 1135 .write = rs_write, 1136 .flush_chars = rs_flush_chars, 1137 .write_room = rs_write_room, 1138 .chars_in_buffer = rs_chars_in_buffer, 1139 .flush_buffer = rs_flush_buffer, 1140 .ioctl = rs_ioctl, 1141 .throttle = rs_throttle, 1142 .unthrottle = rs_unthrottle, 1143 .set_termios = rs_set_termios, 1144 .stop = rs_stop, 1145 .start = rs_start, 1146 .hangup = rs_hangup, 1147 .set_ldisc = rs_set_ldisc, 1148}; 1149 1150static const struct tty_port_operations rs_port_ops = { 1151}; 1152 1153/* rs_init inits the driver */ 1154static int __init 1155rs68328_init(void) 1156{ 1157 unsigned long flags; 1158 int i; 1159 struct m68k_serial *info; 1160 1161 serial_driver = alloc_tty_driver(NR_PORTS); 1162 if (!serial_driver) 1163 return -ENOMEM; 1164 1165 show_serial_version(); 1166 1167 /* Initialize the tty_driver structure */ 1168 /* SPARC: Not all of this is exactly right for us. */ 1169 1170 serial_driver->name = "ttyS"; 1171 serial_driver->major = TTY_MAJOR; 1172 serial_driver->minor_start = 64; 1173 serial_driver->type = TTY_DRIVER_TYPE_SERIAL; 1174 serial_driver->subtype = SERIAL_TYPE_NORMAL; 1175 serial_driver->init_termios = tty_std_termios; 1176 serial_driver->init_termios.c_cflag = 1177 m68328_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL; 1178 serial_driver->flags = TTY_DRIVER_REAL_RAW; 1179 tty_set_operations(serial_driver, &rs_ops); 1180 1181 local_irq_save(flags); 1182 1183 for(i=0;i<NR_PORTS;i++) { 1184 1185 info = &m68k_soft[i]; 1186 tty_port_init(&info->tport); 1187 info->tport.ops = &rs_port_ops; 1188 info->magic = SERIAL_MAGIC; 1189 info->port = (int) &uart_addr[i]; 1190 info->irq = uart_irqs[i]; 1191 info->custom_divisor = 16; 1192 info->x_char = 0; 1193 info->line = i; 1194 info->is_cons = 1; /* Means shortcuts work */ 1195 1196 printk("%s%d at 0x%08x (irq = %d)", serial_driver->name, info->line, 1197 info->port, info->irq); 1198 printk(" is a builtin MC68328 UART\n"); 1199 1200#ifdef CONFIG_M68VZ328 1201 if (i > 0 ) 1202 PJSEL &= 0xCF; /* PSW enable second port output */ 1203#endif 1204 1205 if (request_irq(uart_irqs[i], 1206 rs_interrupt, 1207 0, 1208 "M68328_UART", info)) 1209 panic("Unable to attach 68328 serial interrupt\n"); 1210 1211 tty_port_link_device(&info->tport, serial_driver, i); 1212 } 1213 local_irq_restore(flags); 1214 1215 if (tty_register_driver(serial_driver)) { 1216 put_tty_driver(serial_driver); 1217 for (i = 0; i < NR_PORTS; i++) 1218 tty_port_destroy(&m68k_soft[i].tport); 1219 printk(KERN_ERR "Couldn't register serial driver\n"); 1220 return -ENOMEM; 1221 } 1222 1223 return 0; 1224} 1225 1226module_init(rs68328_init); 1227 1228 1229 1230static void m68328_set_baud(void) 1231{ 1232 unsigned short ustcnt; 1233 int i; 1234 1235 ustcnt = USTCNT; 1236 USTCNT = ustcnt & ~USTCNT_TXEN; 1237 1238again: 1239 for (i = 0; i < ARRAY_SIZE(baud_table); i++) 1240 if (baud_table[i] == m68328_console_baud) 1241 break; 1242 if (i >= ARRAY_SIZE(baud_table)) { 1243 m68328_console_baud = 9600; 1244 goto again; 1245 } 1246 1247 UBAUD = PUT_FIELD(UBAUD_DIVIDE, hw_baud_table[i].divisor) | 1248 PUT_FIELD(UBAUD_PRESCALER, hw_baud_table[i].prescale); 1249 ustcnt &= ~(USTCNT_PARITYEN | USTCNT_ODD_EVEN | USTCNT_STOP | USTCNT_8_7); 1250 ustcnt |= USTCNT_8_7; 1251 ustcnt |= USTCNT_TXEN; 1252 USTCNT = ustcnt; 1253 m68328_console_initted = 1; 1254 return; 1255} 1256 1257 1258int m68328_console_setup(struct console *cp, char *arg) 1259{ 1260 int i, n = CONSOLE_BAUD_RATE; 1261 1262 if (!cp) 1263 return(-1); 1264 1265 if (arg) 1266 n = simple_strtoul(arg,NULL,0); 1267 1268 for (i = 0; i < ARRAY_SIZE(baud_table); i++) 1269 if (baud_table[i] == n) 1270 break; 1271 if (i < ARRAY_SIZE(baud_table)) { 1272 m68328_console_baud = n; 1273 m68328_console_cbaud = 0; 1274 if (i > 15) { 1275 m68328_console_cbaud |= CBAUDEX; 1276 i -= 15; 1277 } 1278 m68328_console_cbaud |= i; 1279 } 1280 1281 m68328_set_baud(); /* make sure baud rate changes */ 1282 return(0); 1283} 1284 1285 1286static struct tty_driver *m68328_console_device(struct console *c, int *index) 1287{ 1288 *index = c->index; 1289 return serial_driver; 1290} 1291 1292 1293void m68328_console_write (struct console *co, const char *str, 1294 unsigned int count) 1295{ 1296 if (!m68328_console_initted) 1297 m68328_set_baud(); 1298 while (count--) { 1299 if (*str == '\n') 1300 rs_put_char('\r'); 1301 rs_put_char( *str++ ); 1302 } 1303} 1304 1305 1306static struct console m68328_driver = { 1307 .name = "ttyS", 1308 .write = m68328_console_write, 1309 .device = m68328_console_device, 1310 .setup = m68328_console_setup, 1311 .flags = CON_PRINTBUFFER, 1312 .index = -1, 1313}; 1314 1315 1316static int __init m68328_console_init(void) 1317{ 1318 register_console(&m68328_driver); 1319 return 0; 1320} 1321 1322console_initcall(m68328_console_init); 1323