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