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