开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
8253xsyn.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：27k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

8253xsyn.c：源码内容
  1. /* -*- linux-c -*- */
  2. /* $Id: 8253xsyn.c,v 1.17 2002/02/10 22:17:25 martillo Exp $
  3.  * 8253xsyn.c: SYNC TTY Driver for the SIEMENS SAB8253X DUSCC.
  4.  *
  5.  * Implementation, modifications and extensions
  6.  * Copyright (C) 2001 By Joachim Martillo, Telford Tools, Inc.
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version
  11.  * 2 of the License, or (at your option) any later version.
  12.  */
  14. /* Standard in kernel modules */
  15. #define DEFINE_VARIABLE
  16. #include <linux/module.h>   /* Specifically, a module */
  17. #include <asm/io.h>
  18. #include <linux/timer.h>
  19. #include <linux/interrupt.h>
  20. #include <linux/tty.h>
  21. #include <linux/tty_flip.h>
  22. #include <linux/mm.h>
  23. #include <linux/version.h>
  24. #include <asm/uaccess.h>
  25. #include "8253xctl.h"
  26. #include "8253x.h"
  27. #include <linux/pci.h>
  28. #include <linux/fs.h>
  30. #ifdef MODULE
  31. #undef XCONFIG_SERIAL_CONSOLE
  32. #endif
  35. static void sab8253x_flush_to_ldiscS(void *private_) /* need a separate version for sync
  36.  there are no flags associated with
  37.  received sync TTY data*/
  38. {
  39. struct tty_struct *tty = (struct tty_struct *) private_;
  40. unsigned char *cp;
  41. int count;
  42. struct sab_port *port;
  43. struct sk_buff *skb;  
  45. if(tty)
  46. {
  47. port = (struct sab_port *)tty->driver_data;
  48. }
  49. else
  50. {
  51. return;
  52. }
  53. if(port == NULL)
  54. {
  55. return;
  56. }
  58. if (test_bit(TTY_DONT_FLIP, &tty->flags)) 
  59. {
  60. queue_task(&tty->flip.tqueue, &tq_timer);
  61. return;
  62. }
  63. /* note that a hangup may have occurred -- perhaps should check for that */
  64. port->DoingInterrupt = 1;
  65. while(port->sab8253xc_rcvbuflist && (skb_queue_len(port->sab8253xc_rcvbuflist) > 0))
  66. {
  67. skb = skb_dequeue(port->sab8253xc_rcvbuflist);
  68. count = skb->data_len;
  69. cp = skb->data;
  70. (*tty->ldisc.receive_buf)(tty, cp, 0, count);
  71. dev_kfree_skb_any(skb);
  72. }
  73. port->DoingInterrupt = 0;
  74. }
  76. void sab8253x_flush_charsS(struct tty_struct *tty)
  77. {
  78. struct sab_port *port = (struct sab_port *)tty->driver_data;
  80. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_flush_chars"))
  81. {
  82. return;
  83. }
  85. if ((Sab8253xCountTransmit(port) <= 0) || tty->stopped || tty->hw_stopped)
  86. { /* can't flush */
  87. return;
  88. }
  90. sab8253x_start_txS(port);
  91. }
  93. /*
  94.  * ------------------------------------------------------------
  95.  * sab8253x_stopS() and sab8253x_startS()
  96.  *
  97.  * This routines are called before setting or resetting tty->stopped.
  98.  * They enable or disable transmitter interrupts, as necessary.
  99.  * ------------------------------------------------------------
  100.  */
  102. void sab8253x_stopS(struct tty_struct *tty)
  103. {
  104. struct sab_port *port = (struct sab_port *)tty->driver_data;
  105. /* can't do anything here */
  106. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_stop"))
  107. {
  108. return;
  109. }
  110. /*  interrupt handles it all*/
  111. /* turning off XPR is not an option in sync mode */
  112. }
  114. void sab8253x_startS(struct tty_struct *tty)
  115. {
  116. struct sab_port *port = (struct sab_port *)tty->driver_data;
  118. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_start"))
  119. {
  120. return;
  121. }
  122. sab8253x_start_txS(port);
  123. }
  126. static void sab8253x_receive_charsS(struct sab_port *port,
  127.      union sab8253x_irq_status *stat)
  128. {
  129. struct tty_struct *tty = port->tty;
  130. unsigned char buf[32];
  131. int free_fifo = 0;
  132. int reset_fifo = 0;
  133. int msg_done = 0;
  134. int msg_bad = 0;
  135. int count = 0;
  136. int total_size = 0;
  137. int rstatus = 0;
  138. struct sk_buff *skb;
  140. /* Read number of BYTES (Character + Status) available. */
  142. if((stat->images[ISR1_IDX] & SAB82532_ISR1_RDO) || (stat->images[ISR0_IDX] & SAB82532_ISR0_RFO) )
  143. {
  144. ++msg_bad;
  145. ++free_fifo;
  146. ++reset_fifo;
  147. }
  148. else
  149. {
  150. if (stat->images[ISR0_IDX] & SAB82532_ISR0_RPF) 
  151. {
  152. count = port->recv_fifo_size;
  153. ++free_fifo;
  154. }
  156. if (stat->images[ISR0_IDX] & SAB82532_ISR0_RME) 
  157. {
  158. count = READB(port, rbcl);
  159. count &= (port->recv_fifo_size - 1);
  160. ++msg_done;
  161. ++free_fifo;
  163. total_size = READB(port, rbch);
  164. if(total_size & SAB82532_RBCH_OV) /* need to revisit for 4096 byte frames */
  165. {
  166. msg_bad++;
  167. }
  169. rstatus = READB(port, rsta);
  170. if((rstatus & SAB82532_RSTA_VFR) == 0)
  171. {
  172. msg_bad++;
  173. }
  174. if(rstatus & SAB82532_RSTA_RDO)
  175. {
  176. msg_bad++;
  177. }
  178. if((rstatus & SAB82532_RSTA_CRC) == 0)
  179. {
  180. msg_bad++;
  181. }
  182. if(rstatus & SAB82532_RSTA_RAB)
  183. {
  184. msg_bad++;
  185. }
  186. }
  187. }
  189. /* Read the FIFO. */
  191. (*port->readfifo)(port, buf, count);
  194. /* Issue Receive Message Complete command. */
  196. if (free_fifo) 
  197. {
  198. sab8253x_cec_wait(port);
  199. WRITEB(port, cmdr, SAB82532_CMDR_RMC);
  200. }
  202. if(reset_fifo)
  203. {
  204. sab8253x_cec_wait(port);
  205. WRITEB(port, cmdr, SAB82532_CMDR_RHR);
  206. }
  208. if(msg_bad)
  209. {
  210. port->msgbufindex = 0;
  211. return;
  212. }
  214. memcpy(&port->msgbuf[port->msgbufindex], buf, count);
  215. port->msgbufindex += count;
  217. #ifdef CONSOLE_SUPPORT
  218. if (port->is_console)
  219. {
  220. wake_up(&keypress_wait);
  221. }
  222. #endif
  224. if(msg_done)
  225. {
  227. if(port->msgbufindex <= 3) /* min is 1 char + 2 CRC + status byte */
  228. {
  229. port->msgbufindex = 0;
  230. return;
  231. }
  233. total_size = port->msgbufindex - 3; /* strip off the crc16 and the status byte */
  234. port->msgbufindex = 0;
  236. /* ignore the receive buffer waiting -- we know the correct size here */
  238. if (!tty)
  239. {
  240. return;
  241. }
  242. if(skb = dev_alloc_skb(total_size), skb)
  243. {
  244. memcpy(skb->data, &port->msgbuf[0], total_size);
  245. skb->tail = (skb->data + total_size);
  246. skb->data_len = total_size;
  247. skb->len = total_size;
  248. skb_queue_tail(port->sab8253xc_rcvbuflist, skb);
  249. }
  250. queue_task(&tty->flip.tqueue, &tq_timer); /* clear out flip buffer as fast as possible
  251.    * maybe should not be done unconditionally hear
  252.    * but should be within the above consequence
  253.    * clause */
  254. }
  255. }
  258. static void sab8253x_check_statusS(struct sab_port *port,
  259.     union sab8253x_irq_status *stat)
  260. {
  261. struct tty_struct *tty = port->tty;
  262. int modem_change = 0;
  263. mctlsig_t         *sig;
  265. if (!tty)
  266. {
  267. return;
  268. }
  270. /* check_modem:*/
  271. /* Checking DCD */
  272. sig = &port->dcd;
  273. if (stat->images[sig->irq] & sig->irqmask) 
  274. {
  275. sig->val = ISON(port,dcd);
  276. port->icount.dcd++;
  277. modem_change++;
  278. }
  279. /* Checking CTS */
  280. sig = &port->cts;
  281. if (stat->images[sig->irq] & sig->irqmask) 
  282. {
  283. sig->val = ISON(port,cts);
  284. port->icount.cts++;
  285. modem_change++;
  286. }
  287. /* Checking DSR */
  288. sig = &port->dsr;
  289. if (stat->images[sig->irq] & sig->irqmask) 
  290. {
  291. sig->val = ISON(port,dsr);
  292. port->icount.dsr++;
  293. modem_change++;
  294. }
  295. if (modem_change)
  296. {
  297. wake_up_interruptible(&port->delta_msr_wait);
  298. }
  300. sig = &port->dcd;
  301. if ((port->flags & FLAG8253X_CHECK_CD) &&
  302.     (stat->images[sig->irq] & sig->irqmask)) 
  303. {
  305. if (sig->val)
  306. {
  307. wake_up_interruptible(&port->open_wait);
  308. }
  309. else if (!((port->flags & FLAG8253X_CALLOUT_ACTIVE) &&
  310.    (port->flags & FLAG8253X_CALLOUT_NOHUP))) 
  311. {
  312. #if 0 /* requires more investigation */
  313. MOD_INC_USE_COUNT;
  314. if (schedule_task(&port->tqueue_hangup) == 0)
  315. {
  316. MOD_DEC_USE_COUNT;
  317. }
  318. #endif
  319. }
  320. }
  322. sig = &port->cts;
  323. if (port->flags & FLAG8253X_CTS_FLOW) 
  324. { /* not setting this yet */
  325. if (port->tty->hw_stopped) 
  326. {
  327. if (sig->val) 
  328. {
  329. port->tty->hw_stopped = 0;
  330. sab8253x_sched_event(port, SAB8253X_EVENT_WRITE_WAKEUP);
  331. sab8253x_start_txS(port);
  332. }
  333. } 
  335. else 
  336. {
  337. if(!(getccr2configS(port) & SAB82532_CCR2_TOE))
  338. {
  339. if (!(sig->val)) 
  340. {
  341. port->tty->hw_stopped = 1;
  342. }
  343. }
  344. }
  345. }
  346. }
  348. /*
  349.  * This routine is called to set the UART divisor registers to match
  350.  * the specified baud rate for a serial port.
  351.  */
  352. static void sab8253x_change_speedS(struct sab_port *port)
  353. {
  354. unsigned long flags,baud;
  355. tcflag_t cflag;
  356. u8         ccr2=0,ccr4=0,ebrg=0;
  357. int i, bits;
  358. #ifdef DEBUGGING
  359. printk("Change speed!  ");
  360. #endif
  361. if (!port->tty || !port->tty->termios) 
  362. {
  363. #ifdef DEBUGGING
  364. printk("NOT!n");
  365. #endif
  366. return;
  367. }
  369. #ifdef DEBUGGING
  370. printk(" for real.n");
  371. #endif
  373. cflag = port->tty->termios->c_cflag;
  375. /* Byte size and parity */
  376. switch (cflag & CSIZE) 
  377. {
  378. case CS5: 
  379. bits = 7; 
  380. break;
  381. case CS6: 
  382. bits = 8; 
  383. break;
  384. case CS7: 
  385. bits = 9; 
  386. break;
  387. default:
  388. case CS8: 
  389. bits = 10; 
  390. break;
  391. }
  393. if (cflag & CSTOPB) 
  394. {
  395. bits++;
  396. }
  398. if (cflag & PARENB) 
  399. {
  400. bits++;
  401. }
  403. /* Determine EBRG values based on the "encoded"baud rate */
  404. i = cflag & CBAUD;
  405. switch(i)
  406. {
  407. case B0:
  408. baud=0;
  409. break;
  410. case  B50:
  411. baud=100;
  412. break;
  413. case  B75:
  414. baud=150;
  415. break;
  416. case  B110:
  417. baud=220;
  418. break;
  419. case  B134:
  420. baud=269;
  421. break;
  422. case  B150:
  423. baud=300;
  424. break;
  425. case  B200:
  426. baud=400;
  427. break;
  428. case B300:
  429. baud=600;
  430. break;
  431. case B600:
  432. baud=1200;
  433. break;
  434. case B1200:
  435. baud=2400;
  436. break;
  437. case B1800:
  438. baud=3600;
  439. break;
  440. case B2400:
  441. baud=4800;
  442. break;
  443. case B4800:
  444. baud=9600;
  445. break;
  446. case B9600:
  447. baud=19200;
  448. break;
  449. case B19200:
  450. baud=38400;
  451. break;
  452. case  B38400:
  453. if(port->custspeed)
  454. {
  455. baud=port->custspeed<<1;
  456. }
  457. else
  458. {
  459. baud=76800;
  460. }
  461. break;
  462. case B57600:
  463. baud=115200;
  464. break;
  465. #ifdef SKIPTHIS
  466. case B76800:
  467. baud=153600;
  468. break;
  469. case B153600:
  470. baud=307200;
  471. break;
  472. #endif
  473. case B230400:
  474. baud=460800;
  475. break;
  476. case  B460800:
  477. baud=921600;
  478. break;
  479. case B115200:
  480. default:
  481. baud=230400;
  482. break;
  483. }
  485. if(!sab8253x_baud(port,baud,&ebrg,&ccr2,&ccr4,&(port->baud))) 
  486. {
  487. printk("Aurora Warning. baudrate %ld could not be set! Using 115200",baud);
  488. baud=230400;
  489. sab8253x_baud(port,baud,&ebrg,&ccr2,&ccr4,&(port->baud));
  490. }
  492. if (port->baud)
  493. port->timeout = (port->xmit_fifo_size * HZ * bits) / port->baud;
  494. else
  495. port->timeout = 0;
  496. port->timeout += HZ / 50; /* Add .02 seconds of slop */
  498. /* CTS flow control flags */
  499. if (cflag & CRTSCTS)
  500. port->flags |= FLAG8253X_CTS_FLOW;
  501. else
  502. port->flags &= ~(FLAG8253X_CTS_FLOW);
  504. if (cflag & CLOCAL)
  505. port->flags &= ~(FLAG8253X_CHECK_CD);
  506. else
  507. port->flags |= FLAG8253X_CHECK_CD;
  508. if (port->tty)
  509. port->tty->hw_stopped = 0;
  511. /*
  512.  * Set up parity check flag
  513.  * XXX: not implemented, yet.
  514.  */
  515. #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  517. /*
  518.  * Characters to ignore
  519.  * XXX: not implemented, yet.
  520.  */
  522. /*
  523.  * !!! ignore all characters if CREAD is not set
  524.  * XXX: not implemented, yet.
  525.  */
  526. if ((cflag & CREAD) == 0)
  527. port->ignore_status_mask |= SAB82532_ISR0_RPF;
  529. save_flags(flags); 
  530. cli();
  531. sab8253x_cec_wait(port);
  533. WRITEB(port, bgr, ebrg);
  534. WRITEB(port, ccr2, READB(port, ccr2) & ~(0xc0)); /* clear out current baud rage */
  535. WRITEB(port, ccr2, READB(port, ccr2) | ccr2);
  536. WRITEB(port, ccr4, (READB(port,ccr4) & ~SAB82532_CCR4_EBRG) | ccr4);
  538. if (port->flags & FLAG8253X_CTS_FLOW) 
  539. {
  540. WRITEB(port, mode, READB(port,mode) & ~(SAB82532_MODE_RTS));
  541. port->interrupt_mask1 &= ~(SAB82532_IMR1_CSC);
  542. WRITEB(port, imr1, port->interrupt_mask1);
  543. } 
  544. else 
  545. {
  546. WRITEB(port, mode, READB(port,mode) | SAB82532_MODE_RTS);
  547. port->interrupt_mask1 |= SAB82532_IMR1_CSC;
  548. WRITEB(port, imr1, port->interrupt_mask1);
  549. }
  550. WRITEB(port, mode, READB(port, mode) | SAB82532_MODE_RAC);
  551. restore_flags(flags);
  552. }
  554. void sab8253x_set_termiosS(struct tty_struct *tty,
  555.    struct termios *old_termios)
  556. {
  557. struct sab_port *port = (struct sab_port *)tty->driver_data;
  559. if((tty->termios->c_cflag == old_termios->c_cflag) && 
  560.    (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag)))
  561. {
  562. return;
  563. }
  564. if(!port)
  565. {
  566. return;
  567. }
  568. sab8253x_change_speedS(port);
  570. /* Handle transition to B0 status */
  571. if ((old_termios->c_cflag & CBAUD) &&
  572.     !(tty->termios->c_cflag & CBAUD)) 
  573. {
  574. LOWER(port,rts);
  575. LOWER(port,dtr);
  576. }
  578. /* Handle transition away from B0 status */
  579. if (!(old_termios->c_cflag & CBAUD) &&
  580.     (tty->termios->c_cflag & CBAUD)) 
  581. {
  582. RAISE(port,dtr);
  583. if (!tty->hw_stopped ||
  584.     !(tty->termios->c_cflag & CRTSCTS)) 
  585. {
  586. RAISE(port,rts);
  587. }
  588. }
  590. /* Handle turning off CRTSCTS */
  591. if ((old_termios->c_cflag & CRTSCTS) &&
  592.     !(tty->termios->c_cflag & CRTSCTS)) 
  593. {
  594. tty->hw_stopped = 0;
  595. sab8253x_startS(tty);
  596. }
  597. }
  599. static int sab8253x_startupS(struct sab_port *port)
  600. {
  601. unsigned long flags;
  602. int retval = 0;
  604. save_flags(flags); cli();
  606. port->msgbufindex = 0;
  607. port->xmit_buf = NULL;
  608. port->buffergreedy = 0;
  610. if (port->flags & FLAG8253X_INITIALIZED) 
  611. {
  612. goto errout;
  613. }
  615. if (!port->regs) 
  616. {
  617. if (port->tty)
  618. {
  619. set_bit(TTY_IO_ERROR, &port->tty->flags);
  620. }
  621. retval = -ENODEV;
  622. goto errout;
  623. }
  624. /*
  625.  * Initialize the Hardware
  626.  */
  627. sab8253x_init_lineS(port);
  629. #if 0 /* maybe should be conditional */
  630. if (port->tty->termios->c_cflag & CBAUD) 
  631. {
  632. #endif
  633. /* Activate RTS */
  634. RAISE(port,rts);
  635. /* Activate DTR */
  636. RAISE(port,dtr);
  637. #if 0
  638. }
  639. #endif
  641. /*
  642.  * Initialize the modem signals values
  643.  */
  644. port->dcd.val=ISON(port,dcd);
  645. port->cts.val=ISON(port,cts);
  646. port->dsr.val=ISON(port,dsr);
  647. /*
  648.  * Finally, enable interrupts
  649.  */
  651. port->interrupt_mask0 = SAB82532_IMR0_RFS | SAB82532_IMR0_PCE |
  652. SAB82532_IMR0_PLLA | SAB82532_IMR0_RSC | SAB82532_IMR0_CDSC;
  654. /*((port->ccontrol.ccr2 & SAB82532_CCR2_TOE) ? SAB82532_IMR0_CDSC : 0); */
  656. WRITEB(port,imr0,port->interrupt_mask0);
  657. port->interrupt_mask1 = SAB82532_IMR1_EOP | SAB82532_IMR1_XMR |
  658. SAB82532_IMR1_TIN | SAB82532_IMR1_XPR;
  659. WRITEB(port, imr1, port->interrupt_mask1);
  660. port->all_sent = 1;
  662. if (port->tty)
  663. {
  664. clear_bit(TTY_IO_ERROR, &port->tty->flags);
  665. }
  666. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  668. /*
  669.  * and set the speed of the serial port
  670.  */
  671. sab8253x_change_speedS(port);
  673. port->flags |= FLAG8253X_INITIALIZED;
  674. port->receive_chars = sab8253x_receive_charsS;
  675. port->transmit_chars = sab8253x_transmit_charsS;
  676. port->check_status = sab8253x_check_statusS;
  677. port->receive_test = (SAB82532_ISR0_RME | SAB82532_ISR0_RFO | SAB82532_ISR0_RPF);
  678. port->transmit_test = (SAB82532_ISR1_ALLS | SAB82532_ISR1_RDO | SAB82532_ISR1_XPR |
  679.        SAB82532_ISR1_XDU | SAB82532_ISR1_CSC);
  680. port->check_status_test = (SAB82532_ISR1_CSC);
  682. /*((port->ccontrol.ccr2 & SAB82532_CCR2_TOE) ? 0 : SAB82532_ISR0_CDSC));*/
  685. restore_flags(flags);
  686. return 0;
  688.  errout:
  689. restore_flags(flags);
  690. return retval;
  691. }
  693. static void sab8253x_shutdownS(struct sab_port *port)
  694. {
  695. unsigned long flags;
  697. if (!(port->flags & FLAG8253X_INITIALIZED))
  698. {
  699. return;
  700. }
  702. save_flags(flags); cli(); /* Disable interrupts */
  704. /*
  705.  * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
  706.  * here so the queue might never be waken up
  707.  */
  708. wake_up_interruptible(&port->delta_msr_wait);
  710. if (port->xmit_buf) 
  711. {
  712. port->xmit_buf = 0;
  713. }
  714. #ifdef XCONFIG_SERIAL_CONSOLE
  715. if (port->is_console) 
  716. {
  717. port->interrupt_mask0 = 
  718. SAB82532_IMR0_PERR | SAB82532_IMR0_FERR |
  719. /*SAB82532_IMR0_TIME |*/
  720. SAB82532_IMR0_PLLA | SAB82532_IMR0_CDSC;
  721. WRITEB(port,imr0,port->interrupt_mask0);
  722. port->interrupt_mask1 = 
  723. SAB82532_IMR1_BRKT | SAB82532_IMR1_ALLS |
  724. SAB82532_IMR1_XOFF | SAB82532_IMR1_TIN |
  725. SAB82532_IMR1_CSC | SAB82532_IMR1_XON |
  726. SAB82532_IMR1_XPR;
  727. WRITEB(port,imr1,port->interrupt_mask1);
  728. if (port->tty)
  729. {
  730. set_bit(TTY_IO_ERROR, &port->tty->flags);
  731. }
  732. port->flags &= ~FLAG8253X_INITIALIZED;
  733. restore_flags(flags);
  734. return;
  735. }
  736. #endif
  738. /* Disable Interrupts */
  740. port->interrupt_mask0 = 0xff;
  741. WRITEB(port, imr0, port->interrupt_mask0);
  742. port->interrupt_mask1 = 0xff;
  743. WRITEB(port, imr1, port->interrupt_mask1);
  745. if (!port->tty || (port->tty->termios->c_cflag & HUPCL)) 
  746. {
  747. LOWER(port,rts);
  748. LOWER(port,dtr);
  749. }
  751. /* Disable Receiver */
  752. CLEAR_REG_BIT(port,mode,SAB82532_MODE_RAC);
  754. /* Power Down */
  755. CLEAR_REG_BIT(port,ccr0,SAB82532_CCR0_PU);
  757. if (port->tty)
  758. {
  759. set_bit(TTY_IO_ERROR, &port->tty->flags);
  760. }
  762. port->flags &= ~FLAG8253X_INITIALIZED;
  763. restore_flags(flags);
  764. }
  766. int sab8253x_writeS(struct tty_struct * tty, int from_user,
  767.     const unsigned char *buf, int count)
  768. {
  769. struct sab_port *port = (struct sab_port *)tty->driver_data;
  770. struct sk_buff *skb;
  771. int truelength = 0;
  772. int do_queue = 1;
  774. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_write"))
  775. {
  776. return 0;
  777. }
  779. if(count == 0)
  780. {
  781. return 0;
  782. }
  784. if(port->active2.transmit == NULL)
  785. {
  786. return 0;
  787. }
  789. if((port->active2.transmit->Count & OWNER) == OWN_SAB)
  790. {
  791. sab8253x_start_txS(port); /* no descriptor slot */
  792. return 0;
  793. }
  795. #ifndef FREEININTERRUPT
  796. skb = port->active2.transmit->HostVaddr; /* current slot value */
  798. if(port->buffergreedy == 0) /* are we avoiding buffer free's */
  799. { /* no */
  800. if((skb != NULL) || /* not OWN_SAB from above */
  801.    (port->active2.transmit->crcindex != 0)) 
  802. {
  803. register RING_DESCRIPTOR *freeme;
  805. freeme = port->active2.transmit;
  806. do
  807. {
  808. if((freeme->crcindex == 0) && (freeme->HostVaddr == NULL))
  809. {
  810. break;
  811. }
  812. if(freeme->HostVaddr)
  813. {
  814. skb_unlink((struct sk_buff*)freeme->HostVaddr);
  815. dev_kfree_skb_any((struct sk_buff*)freeme->HostVaddr);
  816. freeme->HostVaddr = NULL;
  817. }
  818. freeme->sendcrc = 0;
  819. freeme->crcindex = 0;
  820. freeme = (RING_DESCRIPTOR*) freeme->VNext;
  821. }
  822. while((freeme->Count & OWNER) != OWN_SAB);
  823. }
  824. skb = NULL; /* buffer was freed */
  825. }
  827. if(skb != NULL) /* potentially useful */
  828. {
  829. truelength = (skb->end - skb->head);
  830. if(truelength >= count)
  831. {
  832. skb->data = skb->head; /* this buffer is already queued */
  833. skb->tail = skb->head;
  834. do_queue = 0;
  835. }
  836. else
  837. {
  838. skb_unlink(skb);
  839. dev_kfree_skb_any(skb);
  840. skb = NULL;
  841. port->active2.transmit->HostVaddr = NULL;
  842. }
  843. }
  844. /* in all cases the following is allowed */
  845. port->active2.transmit->sendcrc = 0;
  846. port->active2.transmit->crcindex = 0;
  847. #endif
  849. if(skb == NULL)
  850. {
  851. if(port->DoingInterrupt)
  852. {
  853. skb = alloc_skb(count, GFP_ATOMIC);
  854. }
  855. else
  856. {
  857. skb = alloc_skb(count, GFP_KERNEL);
  858. }
  859. }
  861. if(skb == NULL)
  862. {
  863. printk(KERN_ALERT "sab8253xs: no skbuffs available.n");
  864. return 0;
  865. }
  866. if(from_user)
  867. {
  868. copy_from_user(skb->data, buf, count);
  869. }
  870. else
  871. {
  872. memcpy(skb->data, buf, count);
  873. }
  874. skb->tail = (skb->data + count);
  875. skb->data_len = count;
  876. skb->len = count;
  878. if(do_queue)
  879. {
  880. skb_queue_head(port->sab8253xbuflist, skb);
  881. }
  883. port->active2.transmit->HostVaddr = skb;
  884. port->active2.transmit->sendcrc = 0;
  885. port->active2.transmit->crcindex = 0;
  886. port->active2.transmit->Count = (OWN_SAB|count);
  887. port->active2.transmit = port->active2.transmit->VNext;
  889. sab8253x_start_txS(port);
  890. return count;
  891. }
  893. void sab8253x_throttleS(struct tty_struct * tty)
  894. {
  895. struct sab_port *port = (struct sab_port *)tty->driver_data;
  897. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_throttleS"))
  898. {
  899. return;
  900. }
  902. if (!tty)
  903. {
  904. return;
  905. }
  907. if (I_IXOFF(tty))
  908. {
  909. sab8253x_send_xcharS(tty, STOP_CHAR(tty));
  910. }
  911. }
  913. void sab8253x_unthrottleS(struct tty_struct * tty)
  914. {
  915. struct sab_port *port = (struct sab_port *)tty->driver_data;
  917. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_unthrottle"))
  918. {
  919. return;
  920. }
  922. if (!tty)
  923. {
  924. return;
  925. }
  927. if (I_IXOFF(tty)) 
  928. {
  929. sab8253x_send_xcharS(tty, START_CHAR(tty));
  930. }
  931. }
  933. void sab8253x_send_xcharS(struct tty_struct *tty, char ch)
  934. {
  935. struct sab_port *port = (struct sab_port *)tty->driver_data;
  936. unsigned long flags;
  937. int stopped;
  938. int hw_stopped;
  940. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_send_xcharS"))
  941. {
  942. return;
  943. }
  945. if (!tty)
  946. {
  947. return;
  948. }
  950. if(port->sabnext2.transmit == NULL)
  951. {
  952. return;
  953. }
  955. save_flags(flags); cli();
  957. if((port->sabnext2.transmit->Count & OWNER) == OWN_SAB) /* may overwrite a character
  958.  * -- but putting subsequent
  959.  * XONs or XOFFs later in the
  960.  * stream could cause problems
  961.  * with the XON and XOFF protocol */
  962. {
  963. port->sabnext2.transmit->sendcrc = 1;
  964. port->sabnext2.transmit->crcindex = 3;
  965. port->sabnext2.transmit->crc = (ch << 24); /* LITTLE ENDIAN */
  966. restore_flags(flags);
  967. }
  968. else
  969. {
  970. restore_flags(flags);
  971. sab8253x_writeS(tty, 0, &ch, 1);
  972. }
  974. stopped = tty->stopped;
  975. hw_stopped = tty->hw_stopped;
  976. tty->stopped = 0;
  977. tty->hw_stopped = 0;
  979. sab8253x_start_txS(port);
  981. tty->stopped = stopped;
  982. tty->hw_stopped = hw_stopped;
  983. }
  986. void sab8253x_breakS(struct tty_struct *tty, int break_state)
  987. {
  988. struct sab_port *port = (struct sab_port *) tty->driver_data;
  990. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_breakS"))
  991. {
  992. return;
  993. } /* can't break in sync mode */
  994. }
  996. void sab8253x_closeS(struct tty_struct *tty, struct file * filp)
  997. {
  998. struct sab_port *port = (struct sab_port *)tty->driver_data;
  999. unsigned long flags;
  1001. MOD_DEC_USE_COUNT;
  1002. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_closeS"))
  1003. {
  1004. return;
  1005. }
  1007. if(port->open_type == OPEN_SYNC_NET)
  1008. { /* port->tty field should already be NULL */
  1009. return;
  1010. }
  1012. save_flags(flags); cli();
  1013. --(port->count);
  1014. if (tty_hung_up_p(filp)) 
  1015. {
  1016. if(port->count == 0) /* I think the reason for the weirdness
  1017.    relates to freeing of structures in
  1018.    the tty driver */
  1019. {
  1020. port->open_type = OPEN_NOT;
  1021. }
  1022. else if(port->count < 0)
  1023. {
  1024. printk(KERN_ALERT "XX20: port->count went negative.n");
  1025. port->count = 0;
  1026. port->open_type = OPEN_NOT;
  1027. }
  1028. restore_flags(flags);
  1029. return;
  1030. }
  1032. #if 0
  1033. if ((tty->count == 1) && (port->count != 0)) 
  1034. {
  1035. /*
  1036.  * Uh, oh.  tty->count is 1, which means that the tty
  1037.  * structure will be freed.  port->count should always
  1038.  * be one in these conditions.  If it's greater than
  1039.  * one, we've got real problems, since it means the
  1040.  * serial port won't be shutdown.
  1041.  */
  1042. printk("sab8253x_close: bad serial port count; tty->count is 1,"
  1043.        " port->count is %dn", port->count);
  1044. port->count = 0;
  1045. }
  1046. #endif
  1048. if (port->count < 0) 
  1049. {
  1050. printk(KERN_ALERT "sab8253x_close: bad serial port count for ttys%d: %dn",
  1051.        port->line, port->count);
  1052. port->count = 0;
  1053. }
  1054. if (port->count) 
  1055. {
  1056. restore_flags(flags);
  1057. return;
  1058. }
  1059. port->flags |= FLAG8253X_CLOSING;
  1061. /*
  1062.  * Save the termios structure, since this port may have
  1063.  * separate termios for callout and dialin.
  1064.  */
  1065. if (port->flags & FLAG8253X_NORMAL_ACTIVE)
  1066. {
  1067. port->normal_termios = *tty->termios;
  1068. }
  1069. if (port->flags & FLAG8253X_CALLOUT_ACTIVE)
  1070. {
  1071. port->callout_termios = *tty->termios;
  1072. }
  1073. /*
  1074.  * Now we wait for the transmit buffer to clear; and we notify 
  1075.  * the line discipline to only process XON/XOFF characters.
  1076.  */
  1077. tty->closing = 1;
  1078. if (port->closing_wait != SAB8253X_CLOSING_WAIT_NONE) 
  1079. {
  1080. tty_wait_until_sent(tty, port->closing_wait);
  1081. }
  1083. /*
  1084.  * At this point we stop accepting input.  To do this, we
  1085.  * disable the receive line status interrupts, and turn off
  1086.  * the receiver.
  1087.  */
  1089. #if 0
  1090. port->interrupt_mask0 |= SAB82532_IMR0_TCD; /* not needed for sync */
  1091. #endif
  1092. WRITEB(port,imr0,port->interrupt_mask0);
  1094. CLEAR_REG_BIT(port, mode, SAB82532_MODE_RAC); /* turn off receiver */
  1096. if (port->flags & FLAG8253X_INITIALIZED) 
  1097. {
  1098. /*
  1099.  * Before we drop DTR, make sure the UART transmitter
  1100.  * has completely drained; this is especially
  1101.  * important if there is a transmit FIFO!
  1102.  */
  1103. sab8253x_wait_until_sent(tty, port->timeout);
  1104. }
  1105. sab8253x_shutdownS(port);
  1106. Sab8253xCleanUpTransceiveN(port);
  1107. if (tty->driver.flush_buffer)
  1108. {
  1109. tty->driver.flush_buffer(tty);
  1110. }
  1111. if (tty->ldisc.flush_buffer)
  1112. {
  1113. tty->ldisc.flush_buffer(tty);
  1114. }
  1115. tty->closing = 0;
  1116. port->event = 0;
  1117. port->tty = 0;
  1118. if (port->blocked_open) 
  1119. {
  1120. if (port->close_delay) 
  1121. {
  1122. current->state = TASK_INTERRUPTIBLE;
  1123. schedule_timeout(port->close_delay);
  1124. }
  1125. wake_up_interruptible(&port->open_wait);
  1126. }
  1127. port->flags &= ~(FLAG8253X_NORMAL_ACTIVE|FLAG8253X_CALLOUT_ACTIVE|
  1128.  FLAG8253X_CLOSING);
  1129. wake_up_interruptible(&port->close_wait);
  1130. port->open_type = OPEN_NOT;
  1131. restore_flags(flags);
  1132. }
  1135. void sab8253x_hangupS(struct tty_struct *tty)
  1136. {
  1137. struct sab_port * port = (struct sab_port *)tty->driver_data;
  1139. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_hangupS"))
  1140. {
  1141. return;
  1142. }
  1144. #ifdef XCONFIG_SERIAL_CONSOLE
  1145. if (port->is_console)
  1146. {
  1147. return;
  1148. }
  1149. #endif
  1151. sab8253x_flush_buffer(tty);
  1152. if(port)
  1153. {
  1154. sab8253x_shutdownS(port);
  1155. Sab8253xCleanUpTransceiveN(port);
  1156. port->event = 0;
  1157. port->flags &= ~(FLAG8253X_NORMAL_ACTIVE|FLAG8253X_CALLOUT_ACTIVE);
  1158. port->tty = 0;
  1159. wake_up_interruptible(&port->open_wait);
  1160. }
  1161. }
  1163. int sab8253x_openS(struct tty_struct *tty, struct file * filp)
  1164. {
  1165. struct sab_port *port;
  1166. int retval, line;
  1167. int counter;
  1168. unsigned long flags;
  1170. MOD_INC_USE_COUNT;  
  1171. line = MINOR(tty->device) - tty->driver.minor_start;
  1173. for(counter = 0, port = AuraPortRoot; 
  1174.     (counter < line) && (port != NULL); 
  1175.     ++counter)
  1176. {
  1177. port = port->next;
  1178. }
  1180. if (!port) 
  1181. {
  1182. printk(KERN_ALERT "sab8253x_openS: can't find structure for line %dn",
  1183.        line);
  1184. return -ENODEV;
  1185. }
  1187. save_flags(flags); /* Need to protect port->tty element */
  1188. cli();
  1190. if(port->tty == 0)
  1191. {
  1192. port->tty = tty;
  1193. tty->flip.tqueue.routine = sab8253x_flush_to_ldiscS;
  1194. }
  1195. tty->driver_data = port;
  1197. if(port->function != FUNCTION_NR)
  1198. {
  1199. ++(port->count);
  1200. restore_flags(flags);
  1201. return -ENODEV; /* only allowed if there are no restrictions on the port */
  1202. }
  1204. if(port->open_type == OPEN_SYNC_NET)
  1205. {
  1206. port->tty = NULL; /* Don't bother with open counting here
  1207.    but make sure the tty field is NULL*/
  1208. restore_flags(flags);
  1209. return -EBUSY;
  1210. }
  1212. restore_flags(flags);
  1214. if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_openS"))
  1215. {
  1216. ++(port->count);
  1217. return -ENODEV;
  1218. }
  1220. #ifdef DEBUG_OPEN
  1221. printk("sab8253x_open %s%d, count = %dn", tty->driver.name, port->line,
  1222.        port->count);
  1223. #endif
  1225. /*
  1226.  * If the port is in the middle of closing, bail out now.
  1227.  */
  1228. if (tty_hung_up_p(filp) ||
  1229.     (port->flags & FLAG8253X_CLOSING)) 
  1230. {
  1232. if (port->flags & FLAG8253X_CLOSING)
  1233. {
  1234. interruptible_sleep_on(&port->close_wait);
  1235. }
  1236. #ifdef SERIAL_DO_RESTART
  1237. ++(port->count);
  1238. return ((port->flags & FLAG8253X_HUP_NOTIFY) ?
  1239. -EAGAIN : -ERESTARTSYS);
  1240. #else
  1241. ++(port->count);
  1242. return -EAGAIN;
  1243. #endif
  1244. }
  1246. if(port->flags & FLAG8253X_NORMAL_ACTIVE)
  1247. {
  1248. if(port->open_type == OPEN_ASYNC)
  1249. {
  1250. ++(port->count);
  1251. return -EBUSY; /* can't reopen in sync mode */
  1252. }
  1253. }
  1254. if(port->open_type > OPEN_SYNC) /* can reopen a SYNC_TTY */
  1255. {
  1256. return -EBUSY;
  1257. }
  1258. if(Sab8253xSetUpLists(port))
  1259. {
  1260. ++(port->count);
  1261. return -ENODEV;
  1262. }
  1263. if(Sab8253xInitDescriptors2(port, sab8253xs_listsize, sab8253xs_rbufsize))
  1264. {
  1265. ++(port->count);
  1266. return -ENODEV;
  1267. }
  1269. retval = sab8253x_startupS(port);
  1270. if (retval)
  1271. {
  1272. ++(port->count);
  1273. return retval; /* does not check channel mode */
  1274. }
  1276. retval = sab8253x_block_til_ready(tty, filp, port); /* checks channel mode */
  1277. ++(port->count);
  1278. if (retval) 
  1279. {
  1280. return retval;
  1281. }
  1283. port->tty = tty; /* may change here once through the block */
  1284. /* because now the port belongs to an new tty */
  1285. tty->flip.tqueue.routine = sab8253x_flush_to_ldiscS;
  1286. if(Sab8253xSetUpLists(port))
  1287. {
  1288. return -ENODEV;
  1289. }
  1290. if(Sab8253xInitDescriptors2(port, sab8253xs_listsize, sab8253xs_rbufsize))
  1291. {
  1292. Sab8253xCleanUpTransceiveN(port); /* the network functions should be okay -- only difference */
  1293. /* is the crc32 that is appended */
  1294. return -ENODEV;
  1295. }
  1297. /*
  1298.  * Start up serial port
  1299.  */
  1300. retval = sab8253x_startupS(port); /* in case cu was running the first time
  1301.    * the function was called*/
  1302. if (retval)
  1303. {
  1304. return retval; /* does not check channel mode */
  1305. }
  1307. if ((port->count == 1) &&
  1308.     (port->flags & FLAG8253X_SPLIT_TERMIOS)) 
  1309. {
  1310. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1311. {
  1312. *tty->termios = port->normal_termios;
  1313. }
  1314. else 
  1315. {
  1316. *tty->termios = port->callout_termios;
  1317. }
  1318. sab8253x_change_speedS(port);
  1319. }
  1322. #ifdef XCONFIG_SERIAL_CONSOLE
  1323. if (sab8253x_console.cflag && sab8253x_console.index == line) 
  1324. {
  1325. tty->termios->c_cflag = sab8253x_console.cflag;
  1326. sab8253x_console.cflag = 0;
  1327. change_speed(port);
  1328. }
  1329. #endif
  1331. port->session = current->session;
  1332. port->pgrp = current->pgrp;
  1333. port->open_type = OPEN_SYNC;
  1334. return 0;
  1335. }