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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
aurora.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：62k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

aurora.c：源码内容
  1. /* $Id: aurora.c,v 1.18.2.1 2002/02/04 22:37:43 davem Exp $
  2.  * linux/drivers/sbus/char/aurora.c -- Aurora multiport driver
  3.  *
  4.  * Copyright (c) 1999 by Oliver Aldulea (oli at bv dot ro)
  5.  *
  6.  * This code is based on the RISCom/8 multiport serial driver written
  7.  * by Dmitry Gorodchanin (pgmdsg@ibi.com), based on the Linux serial
  8.  * driver, written by Linus Torvalds, Theodore T'so and others.
  9.  * The Aurora multiport programming info was obtained mainly from the
  10.  * Cirrus Logic CD180 documentation (available on the web), and by
  11.  * doing heavy tests on the board. Many thanks to Eddie C. Dost for the
  12.  * help on the sbus interface.
  13.  *
  14.  * This program is free software; you can redistribute it and/or modify
  15.  * it under the terms of the GNU General Public License as published by
  16.  * the Free Software Foundation; either version 2 of the License, or
  17.  * (at your option) any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software
  26.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  *
  28.  * Revision 1.0
  29.  *
  30.  * This is the first public release.
  31.  *
  32.  * Most of the information you need is in the aurora.h file. Please
  33.  * read that file before reading this one.
  34.  *
  35.  * Several parts of the code do not have comments yet.
  36.  * 
  37.  * n.b.  The board can support 115.2 bit rates, but only on a few
  38.  * ports. The total badwidth of one chip (ports 0-7 or 8-15) is equal
  39.  * to OSC_FREQ div 16. In case of my board, each chip can take 6
  40.  * channels of 115.2 kbaud.  This information is not well-tested.
  41.  * 
  42.  * Fixed to use tty_get_baud_rate().
  43.  *   Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
  44.  */
  46. #include <linux/module.h>
  48. #include <linux/errno.h>
  49. #include <linux/sched.h>
  50. #ifdef AURORA_INT_DEBUG
  51. #include <linux/timer.h>
  52. #endif
  53. #include <linux/interrupt.h>
  54. #include <linux/tty.h>
  55. #include <linux/tty_flip.h>
  56. #include <linux/major.h>
  57. #include <linux/string.h>
  58. #include <linux/fcntl.h>
  59. #include <linux/mm.h>
  60. #include <linux/kernel.h>
  61. #include <linux/init.h>
  62. #include <linux/tqueue.h>
  63. #include <linux/delay.h>
  65. #include <asm/io.h>
  66. #include <asm/irq.h>
  67. #include <asm/oplib.h>
  68. #include <asm/system.h>
  69. #include <asm/segment.h>
  70. #include <asm/bitops.h>
  71. #include <asm/kdebug.h>
  72. #include <asm/sbus.h>
  73. #include <asm/uaccess.h>
  75. #include "aurora.h"
  76. #include "cd180.h"
  78. unsigned char irqs[4] = {
  79. 0, 0, 0, 0
  80. };
  82. #ifdef AURORA_INT_DEBUG
  83. int irqhit=0;
  84. #endif
  86. #ifndef MIN
  87. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  88. #endif
  90. #define AURORA_TYPE_NORMAL 1
  92. static struct tty_driver aurora_driver;
  93. static struct Aurora_board aurora_board[AURORA_NBOARD] = {
  94. {0,},
  95. };
  97. static struct Aurora_port aurora_port[AURORA_TNPORTS] =  {
  98. { 0, },
  99. };
  101. /* no longer used. static struct Aurora_board * IRQ_to_board[16] = { NULL, } ;*/
  102. static unsigned char * tmp_buf = NULL;
  103. static DECLARE_MUTEX(tmp_buf_sem);
  104. static int    aurora_refcount = 0;
  105. static struct tty_struct * aurora_table[AURORA_TNPORTS] = { NULL, };
  106. static struct termios * aurora_termios[AURORA_TNPORTS] = { NULL, };
  107. static struct termios * aurora_termios_locked[AURORA_TNPORTS] = { NULL, };
  109. DECLARE_TASK_QUEUE(tq_aurora);
  111. static inline int aurora_paranoia_check(struct Aurora_port const * port,
  112.     kdev_t device, const char *routine)
  113. {
  114. #ifdef AURORA_PARANOIA_CHECK
  115. static const char *badmagic =
  116. KERN_DEBUG "aurora: Warning: bad aurora port magic number for device %s in %sn";
  117. static const char *badinfo =
  118. KERN_DEBUG "aurora: Warning: null aurora port for device %s in %sn";
  120. if (!port) {
  121. printk(badinfo, kdevname(device), routine);
  122. return 1;
  123. }
  124. if (port->magic != AURORA_MAGIC) {
  125. printk(badmagic, kdevname(device), routine);
  126. return 1;
  127. }
  128. #endif
  129. return 0;
  130. }
  132. /*
  133.  * 
  134.  *  Service functions for aurora driver.
  135.  * 
  136.  */
  138. /* Get board number from pointer */
  139. extern inline int board_No (struct Aurora_board const * bp)
  140. {
  141. return bp - aurora_board;
  142. }
  144. /* Get port number from pointer */
  145. extern inline int port_No (struct Aurora_port const * port)
  146. {
  147. return AURORA_PORT(port - aurora_port); 
  148. }
  150. /* Get pointer to board from pointer to port */
  151. extern inline struct Aurora_board * port_Board(struct Aurora_port const * port)
  152. {
  153. return &aurora_board[AURORA_BOARD(port - aurora_port)];
  154. }
  156. /* Wait for Channel Command Register ready */
  157. extern inline void aurora_wait_CCR(struct aurora_reg128 * r)
  158. {
  159. unsigned long delay;
  161. #ifdef AURORA_DEBUG
  162. printk("aurora_wait_CCRn");
  163. #endif
  164. /* FIXME: need something more descriptive than 100000 :) */
  165. for (delay = 100000; delay; delay--) 
  166. if (!sbus_readb(&r->r[CD180_CCR]))
  167. return;
  168. printk(KERN_DEBUG "aurora: Timeout waiting for CCR.n");
  169. }
  171. /*
  172.  *  aurora probe functions.
  173.  */
  175. /* Must be called with enabled interrupts */
  176. extern inline void aurora_long_delay(unsigned long delay)
  177. {
  178. unsigned long i;
  180. #ifdef AURORA_DEBUG
  181. printk("aurora_long_delay: startn");
  182. #endif
  183. for (i = jiffies + delay; time_before(jiffies, i); ) ;
  184. #ifdef AURORA_DEBUG
  185. printk("aurora_long_delay: endn");
  186. #endif
  187. }
  189. /* Reset and setup CD180 chip */
  190. static int aurora_init_CD180(struct Aurora_board * bp, int chip)
  191. {
  192. unsigned long flags;
  193. int id;
  195. #ifdef AURORA_DEBUG
  196. printk("aurora_init_CD180: start %d:%dn",
  197.        board_No(bp), chip);
  198. #endif
  199. save_flags(flags); cli();
  200. sbus_writeb(0, &bp->r[chip]->r[CD180_CAR]);
  201. sbus_writeb(0, &bp->r[chip]->r[CD180_GSVR]);
  203. /* Wait for CCR ready        */
  204. aurora_wait_CCR(bp->r[chip]);
  206. /* Reset CD180 chip          */
  207. sbus_writeb(CCR_HARDRESET, &bp->r[chip]->r[CD180_CCR]);
  208. udelay(1);
  209. sti();
  210. id=1000;
  211. while((--id) &&
  212.       (sbus_readb(&bp->r[chip]->r[CD180_GSVR])!=0xff))udelay(100);
  213. if(!id) {
  214. printk(KERN_ERR "aurora%d: Chip %d failed init.n",
  215.        board_No(bp), chip);
  216. restore_flags(flags);
  217. return(-1);
  218. }
  219. cli();
  220. sbus_writeb((board_No(bp)<<5)|((chip+1)<<3),
  221.     &bp->r[chip]->r[CD180_GSVR]); /* Set ID for this chip      */
  222. sbus_writeb(0x80|bp->ACK_MINT,
  223.     &bp->r[chip]->r[CD180_MSMR]); /* Prio for modem intr       */
  224. sbus_writeb(0x80|bp->ACK_TINT,
  225.     &bp->r[chip]->r[CD180_TSMR]); /* Prio for transmitter intr */
  226. sbus_writeb(0x80|bp->ACK_RINT,
  227.     &bp->r[chip]->r[CD180_RSMR]); /* Prio for receiver intr    */
  228. /* Setting up prescaler. We need 4 tick per 1 ms */
  229. sbus_writeb((bp->oscfreq/(1000000/AURORA_TPS)) >> 8,
  230.     &bp->r[chip]->r[CD180_PPRH]);
  231. sbus_writeb((bp->oscfreq/(1000000/AURORA_TPS)) & 0xff,
  232.     &bp->r[chip]->r[CD180_PPRL]);
  234. sbus_writeb(SRCR_AUTOPRI|SRCR_GLOBPRI,
  235.     &bp->r[chip]->r[CD180_SRCR]);
  237. id = sbus_readb(&bp->r[chip]->r[CD180_GFRCR]);
  238. printk(KERN_INFO "aurora%d: Chip %d id %02x: ",
  239.        board_No(bp), chip,id);
  240. if(sbus_readb(&bp->r[chip]->r[CD180_SRCR]) & 128) {
  241. switch (id) {
  242. case 0x82:printk("CL-CD1864 rev An");break;
  243. case 0x83:printk("CL-CD1865 rev An");break;
  244. case 0x84:printk("CL-CD1865 rev Bn");break;
  245. case 0x85:printk("CL-CD1865 rev Cn");break;
  246. default:printk("Unknown.n");
  247. };
  248. } else {
  249. switch (id) {
  250. case 0x81:printk("CL-CD180 rev Bn");break;
  251. case 0x82:printk("CL-CD180 rev Cn");break;
  252. default:printk("Unknown.n");
  253. };
  254. }
  255. restore_flags(flags);
  256. #ifdef AURORA_DEBUG
  257. printk("aurora_init_CD180: endn");
  258. #endif
  259. return 0;
  260. }
  262. static int valid_irq(unsigned char irq)
  263. {
  264. int i;
  265. for(i=0;i<TYPE_1_IRQS;i++)
  266. if (type_1_irq[i]==irq) return 1;
  267. return 0;
  268. }
  270. static void aurora_interrupt(int irq, void * dev_id, struct pt_regs * regs);
  272. /* Main probing routine, also sets irq. */
  273. static int aurora_probe(void)
  274. {
  275. struct sbus_bus *sbus;
  276. struct sbus_dev *sdev;
  277. int grrr;
  278. char buf[30];
  279. int bn = 0;
  280. struct Aurora_board *bp;
  282. for_each_sbus(sbus) {
  283. for_each_sbusdev(sdev, sbus) {
  284. /* printk("Try: %x %sn",sdev,sdev->prom_name);*/
  285. if (!strcmp(sdev->prom_name, "sio16")) {
  286. #ifdef AURORA_DEBUG
  287. printk(KERN_INFO "aurora: sio16 at %pn",sdev);
  288. #endif
  289. if((sdev->reg_addrs[0].reg_size!=1) &&
  290.    (sdev->reg_addrs[1].reg_size!=128) &&
  291.    (sdev->reg_addrs[2].reg_size!=128) &&
  292.    (sdev->reg_addrs[3].reg_size!=4)) {
  293.     printk(KERN_ERR "aurora%d: registers' sizes "
  294.        "do not match.n", bn);
  295.     break;
  296. }
  297. bp = &aurora_board[bn];
  298. bp->r0 = (struct aurora_reg1 *)
  299. sbus_ioremap(&sdev->resource[0], 0,
  300.      sdev->reg_addrs[0].reg_size,
  301.      "sio16");
  302. if (bp->r0 == NULL) {
  303. printk(KERN_ERR "aurora%d: can't map "
  304.        "reg_addrs[0]n", bn);
  305. break;
  306. }
  307. #ifdef AURORA_DEBUG
  308. printk("Map reg 0: %pn", bp->r0);
  309. #endif
  310. bp->r[0] = (struct aurora_reg128 *)
  311. sbus_ioremap(&sdev->resource[1], 0,
  312.      sdev->reg_addrs[1].reg_size,
  313.      "sio16");
  314. if (bp->r[0] == NULL) {
  315. printk(KERN_ERR "aurora%d: can't map "
  316.        "reg_addrs[1]n", bn);
  317. break;
  318. }
  319. #ifdef AURORA_DEBUG
  320. printk("Map reg 1: %pn", bp->r[0]);
  321. #endif
  322. bp->r[1] = (struct aurora_reg128 *)
  323. sbus_ioremap(&sdev->resource[2], 0,
  324.      sdev->reg_addrs[2].reg_size,
  325.      "sio16");
  326. if (bp->r[1] == NULL) {
  327. printk(KERN_ERR "aurora%d: can't map "
  328.        "reg_addrs[2]n", bn);
  329. break;
  330. }
  331. #ifdef AURORA_DEBUG
  332. printk("Map reg 2: %pn", bp->r[1]);
  333. #endif
  334. bp->r3 = (struct aurora_reg4 *)
  335. sbus_ioremap(&sdev->resource[3], 0,
  336.      sdev->reg_addrs[3].reg_size,
  337.      "sio16");
  338. if (bp->r3 == NULL) {
  339. printk(KERN_ERR "aurora%d: can't map "
  340.        "reg_addrs[3]n", bn);
  341. break;
  342. }
  343. #ifdef AURORA_DEBUG
  344. printk("Map reg 3: %pn", bp->r3);
  345. #endif
  346. /* Variables setup */
  347. bp->flags = 0;
  348. #ifdef AURORA_DEBUG
  349. grrr=prom_getint(sdev->prom_node,"intr");
  350. printk("intr pri %dn", grrr);
  351. #endif
  352. if ((bp->irq=irqs[bn]) && valid_irq(bp->irq) &&
  353.     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
  354. free_irq(bp->irq|0x30, bp);
  355. } else
  356. if ((bp->irq=prom_getint(sdev->prom_node, "bintr")) && valid_irq(bp->irq) &&
  357.     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
  358. free_irq(bp->irq|0x30, bp);
  359. } else
  360. if ((bp->irq=prom_getint(sdev->prom_node, "intr")) && valid_irq(bp->irq) &&
  361.     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
  362. free_irq(bp->irq|0x30, bp);
  363. } else
  364. for(grrr=0;grrr<TYPE_1_IRQS;grrr++) {
  365. if ((bp->irq=type_1_irq[grrr])&&!request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
  366. free_irq(bp->irq|0x30, bp);
  367. break;
  368. } else {
  369. printk(KERN_ERR "aurora%d: Could not get an irq for this board !!!n",bn);
  370. bp->flags=0xff;
  371. }
  372. }
  373. if(bp->flags==0xff)break;
  374. printk(KERN_INFO "aurora%d: irq %dn",bn,bp->irq&0x0f);
  375. buf[0]=0;
  376. grrr=prom_getproperty(sdev->prom_node,"dtr_rts",buf,sizeof(buf));
  377. if(!strcmp(buf,"swapped")){
  378. printk(KERN_INFO "aurora%d: Swapped DTR and RTSn",bn);
  379. bp->DTR=MSVR_RTS;
  380. bp->RTS=MSVR_DTR;
  381. bp->MSVDTR=CD180_MSVRTS;
  382. bp->MSVRTS=CD180_MSVDTR;
  383. bp->flags|=AURORA_BOARD_DTR_FLOW_OK;
  384. }else{
  385. #ifdef AURORA_FORCE_DTR_FLOW
  386. printk(KERN_INFO "aurora%d: Forcing swapped DTR-RTSn",bn);
  387. bp->DTR=MSVR_RTS;
  388. bp->RTS=MSVR_DTR;
  389. bp->MSVDTR=CD180_MSVRTS;
  390. bp->MSVRTS=CD180_MSVDTR;
  391. bp->flags|=AURORA_BOARD_DTR_FLOW_OK;
  392. #else
  393. printk(KERN_INFO "aurora%d: Normal DTR and RTSn",bn);
  394. bp->DTR=MSVR_DTR;
  395. bp->RTS=MSVR_RTS;
  396. bp->MSVDTR=CD180_MSVDTR;
  397. bp->MSVRTS=CD180_MSVRTS;
  398. #endif
  399. }
  400. bp->oscfreq=prom_getint(sdev->prom_node,"clk")*100;
  401. printk(KERN_INFO "aurora%d: Oscillator: %d Hzn",bn,bp->oscfreq);
  402. grrr=prom_getproperty(sdev->prom_node,"chip",buf,sizeof(buf));
  403. printk(KERN_INFO "aurora%d: Chips: %sn",bn,buf);
  404. grrr=prom_getproperty(sdev->prom_node,"manu",buf,sizeof(buf));
  405. printk(KERN_INFO "aurora%d: Manufacturer: %sn",bn,buf);
  406. grrr=prom_getproperty(sdev->prom_node,"model",buf,sizeof(buf));
  407. printk(KERN_INFO "aurora%d: Model: %sn",bn,buf);
  408. grrr=prom_getproperty(sdev->prom_node,"rev",buf,sizeof(buf));
  409. printk(KERN_INFO "aurora%d: Revision: %sn",bn,buf);
  410. grrr=prom_getproperty(sdev->prom_node,"mode",buf,sizeof(buf));
  411. printk(KERN_INFO "aurora%d: Mode: %sn",bn,buf);
  412. #ifdef MODULE
  413. bp->count=0;
  414. #endif
  415. bp->flags = AURORA_BOARD_PRESENT;
  416. /* hardware ack */
  417. bp->ACK_MINT=1;
  418. bp->ACK_TINT=2;
  419. bp->ACK_RINT=3;
  420. bn++;
  421. }
  422. }
  423. }
  424. return bn;
  425. }
  427. static void aurora_release_io_range(struct Aurora_board *bp)
  428. {
  429. sbus_iounmap((unsigned long)bp->r0, 1);
  430. sbus_iounmap((unsigned long)bp->r[0], 128);
  431. sbus_iounmap((unsigned long)bp->r[1], 128);
  432. sbus_iounmap((unsigned long)bp->r3, 4);
  433. }
  435. extern inline void aurora_mark_event(struct Aurora_port * port, int event)
  436. {
  437. #ifdef AURORA_DEBUG
  438. printk("aurora_mark_event: startn");
  439. #endif
  440. set_bit(event, &port->event);
  441. queue_task(&port->tqueue, &tq_aurora);
  442. mark_bh(AURORA_BH);
  443. #ifdef AURORA_DEBUG
  444. printk("aurora_mark_event: endn");
  445. #endif
  446. }
  448. static __inline__ struct Aurora_port * aurora_get_port(struct Aurora_board const * bp,
  449.        int chip,
  450.        unsigned char const *what)
  451. {
  452. unsigned char channel;
  453. struct Aurora_port * port;
  455. channel = ((chip << 3) |
  456.    ((sbus_readb(&bp->r[chip]->r[CD180_GSCR]) & GSCR_CHAN) >> GSCR_CHAN_OFF));
  457. port = &aurora_port[board_No(bp) * AURORA_NPORT * AURORA_NCD180 + channel];
  458. if (port->flags & ASYNC_INITIALIZED)
  459. return port;
  461. printk(KERN_DEBUG "aurora%d: %s interrupt from invalid port %dn",
  462.        board_No(bp), what, channel);
  463. return NULL;
  464. }
  466. static void aurora_receive_exc(struct Aurora_board const * bp, int chip)
  467. {
  468. struct Aurora_port *port;
  469. struct tty_struct *tty;
  470. unsigned char status;
  471. unsigned char ch;
  473. if (!(port = aurora_get_port(bp, chip, "Receive_x")))
  474. return;
  476. tty = port->tty;
  477. if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
  478. #ifdef AURORA_INTNORM
  479. printk("aurora%d: port %d: Working around flip buffer overflow.n",
  480.        board_No(bp), port_No(port));
  481. #endif
  482. return;
  483. }
  485. #ifdef AURORA_REPORT_OVERRUN
  486. status = sbus_readb(&bp->r[chip]->r[CD180_RCSR]);
  487. if (status & RCSR_OE)  {
  488. port->overrun++;
  489. #if 1
  490. printk("aurora%d: port %d: Overrun. Total %ld overruns.n",
  491.        board_No(bp), port_No(port), port->overrun);
  492. #endif
  493. }
  494. status &= port->mark_mask;
  495. #else
  496. status = sbus_readb(&bp->r[chip]->r[CD180_RCSR]) & port->mark_mask;
  497. #endif
  498. ch = sbus_readb(&bp->r[chip]->r[CD180_RDR]);
  499. if (!status)
  500. return;
  502. if (status & RCSR_TOUT)  {
  503. /* printk("aurora%d: port %d: Receiver timeout. Hardware problems ?n",
  504.        board_No(bp), port_No(port));*/
  505. return;
  507. } else if (status & RCSR_BREAK)  {
  508. printk(KERN_DEBUG "aurora%d: port %d: Handling break...n",
  509.        board_No(bp), port_No(port));
  510. *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  511. if (port->flags & ASYNC_SAK)
  512. do_SAK(tty);
  514. } else if (status & RCSR_PE) 
  515. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  517. else if (status & RCSR_FE) 
  518. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  520.         else if (status & RCSR_OE)
  521. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  523. else
  524. *tty->flip.flag_buf_ptr++ = 0;
  526. *tty->flip.char_buf_ptr++ = ch;
  527. tty->flip.count++;
  528. queue_task(&tty->flip.tqueue, &tq_timer);
  529. }
  531. static void aurora_receive(struct Aurora_board const * bp, int chip)
  532. {
  533. struct Aurora_port *port;
  534. struct tty_struct *tty;
  535. unsigned char count,cnt;
  537. if (!(port = aurora_get_port(bp, chip, "Receive")))
  538. return;
  540. tty = port->tty;
  542. count = sbus_readb(&bp->r[chip]->r[CD180_RDCR]);
  544. #ifdef AURORA_REPORT_FIFO
  545. port->hits[count > 8 ? 9 : count]++;
  546. #endif
  548. while (count--)  {
  549. if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
  550. #ifdef AURORA_INTNORM
  551. printk("aurora%d: port %d: Working around flip buffer overflow.n",
  552.        board_No(bp), port_No(port));
  553. #endif
  554. break;
  555. }
  556. cnt = sbus_readb(&bp->r[chip]->r[CD180_RDR]);
  557. *tty->flip.char_buf_ptr++ = cnt;
  558. *tty->flip.flag_buf_ptr++ = 0;
  559. tty->flip.count++;
  560. }
  561. queue_task(&tty->flip.tqueue, &tq_timer);
  562. }
  564. static void aurora_transmit(struct Aurora_board const * bp, int chip)
  565. {
  566. struct Aurora_port *port;
  567. struct tty_struct *tty;
  568. unsigned char count;
  570. if (!(port = aurora_get_port(bp, chip, "Transmit")))
  571. return;
  573. tty = port->tty;
  575. if (port->SRER & SRER_TXEMPTY)  {
  576. /* FIFO drained */
  577. sbus_writeb(port_No(port) & 7,
  578.     &bp->r[chip]->r[CD180_CAR]);
  579. udelay(1);
  580. port->SRER &= ~SRER_TXEMPTY;
  581. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  582. return;
  583. }
  585. if ((port->xmit_cnt <= 0 && !port->break_length)
  586.     || tty->stopped || tty->hw_stopped)  {
  587. sbus_writeb(port_No(port) & 7,
  588.     &bp->r[chip]->r[CD180_CAR]);
  589. udelay(1);
  590. port->SRER &= ~SRER_TXRDY;
  591. sbus_writeb(port->SRER,
  592.     &bp->r[chip]->r[CD180_SRER]);
  593. return;
  594. }
  596. if (port->break_length)  {
  597. if (port->break_length > 0)  {
  598. if (port->COR2 & COR2_ETC)  {
  599. sbus_writeb(CD180_C_ESC,
  600.     &bp->r[chip]->r[CD180_TDR]);
  601. sbus_writeb(CD180_C_SBRK,
  602.     &bp->r[chip]->r[CD180_TDR]);
  603. port->COR2 &= ~COR2_ETC;
  604. }
  605. count = MIN(port->break_length, 0xff);
  606. sbus_writeb(CD180_C_ESC,
  607.     &bp->r[chip]->r[CD180_TDR]);
  608. sbus_writeb(CD180_C_DELAY,
  609.     &bp->r[chip]->r[CD180_TDR]);
  610. sbus_writeb(count,
  611.     &bp->r[chip]->r[CD180_TDR]);
  612. if (!(port->break_length -= count))
  613. port->break_length--;
  614. } else  {
  615. sbus_writeb(CD180_C_ESC,
  616.     &bp->r[chip]->r[CD180_TDR]);
  617. sbus_writeb(CD180_C_EBRK,
  618.     &bp->r[chip]->r[CD180_TDR]);
  619. sbus_writeb(port->COR2,
  620.     &bp->r[chip]->r[CD180_COR2]);
  621. aurora_wait_CCR(bp->r[chip]);
  622. sbus_writeb(CCR_CORCHG2,
  623.     &bp->r[chip]->r[CD180_CCR]);
  624. port->break_length = 0;
  625. }
  626. return;
  627. }
  629. count = CD180_NFIFO;
  630. do {
  631. u8 byte = port->xmit_buf[port->xmit_tail++];
  633. sbus_writeb(byte, &bp->r[chip]->r[CD180_TDR]);
  634. port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
  635. if (--port->xmit_cnt <= 0)
  636. break;
  637. } while (--count > 0);
  639. if (port->xmit_cnt <= 0)  {
  640. sbus_writeb(port_No(port) & 7,
  641.     &bp->r[chip]->r[CD180_CAR]);
  642. udelay(1);
  643. port->SRER &= ~SRER_TXRDY;
  644. sbus_writeb(port->SRER,
  645.     &bp->r[chip]->r[CD180_SRER]);
  646. }
  647. if (port->xmit_cnt <= port->wakeup_chars)
  648. aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  649. }
  651. static void aurora_check_modem(struct Aurora_board const * bp, int chip)
  652. {
  653. struct Aurora_port *port;
  654. struct tty_struct *tty;
  655. unsigned char mcr;
  657. if (!(port = aurora_get_port(bp, chip, "Modem")))
  658. return;
  660. tty = port->tty;
  662. mcr = sbus_readb(&bp->r[chip]->r[CD180_MCR]);
  663. if (mcr & MCR_CDCHG)  {
  664. if (sbus_readb(&bp->r[chip]->r[CD180_MSVR]) & MSVR_CD) 
  665. wake_up_interruptible(&port->open_wait);
  666. else if (!((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  667.    (port->flags & ASYNC_CALLOUT_NOHUP))) {
  668. MOD_INC_USE_COUNT;
  669. if (schedule_task(&port->tqueue_hangup) == 0)
  670. MOD_DEC_USE_COUNT;
  671. }
  672. }
  674. /* We don't have such things yet. My aurora board has DTR and RTS swapped, but that doesn't count in this driver. Let's hope
  675.  * Aurora didn't made any boards with CTS or DSR broken...
  676.  */
  677. /* #ifdef AURORA_BRAIN_DAMAGED_CTS
  678. if (mcr & MCR_CTSCHG)  {
  679. if (aurora_in(bp, CD180_MSVR) & MSVR_CTS)  {
  680. tty->hw_stopped = 0;
  681. port->SRER |= SRER_TXRDY;
  682. if (port->xmit_cnt <= port->wakeup_chars)
  683. aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  684. } else  {
  685. tty->hw_stopped = 1;
  686. port->SRER &= ~SRER_TXRDY;
  687. }
  688. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  689. }
  690. if (mcr & MCR_DSRCHG)  {
  691. if (aurora_in(bp, CD180_MSVR) & MSVR_DSR)  {
  692. tty->hw_stopped = 0;
  693. port->SRER |= SRER_TXRDY;
  694. if (port->xmit_cnt <= port->wakeup_chars)
  695. aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  696. } else  {
  697. tty->hw_stopped = 1;
  698. port->SRER &= ~SRER_TXRDY;
  699. }
  700. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  701. }
  702. #endif AURORA_BRAIN_DAMAGED_CTS */
  704. /* Clear change bits */
  705. sbus_writeb(0, &bp->r[chip]->r[CD180_MCR]);
  706. }
  708. /* The main interrupt processing routine */
  709. static void aurora_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  710. {
  711. unsigned char status;
  712. unsigned char ack,chip/*,chip_id*/;
  713. struct Aurora_board * bp = (struct Aurora_board *) dev_id;
  714. unsigned long loop = 0;
  716. #ifdef AURORA_INT_DEBUG
  717. printk("IRQ%d %dn",irq,++irqhit);
  718. #ifdef AURORA_FLOODPRO
  719. if (irqhit>=AURORA_FLOODPRO)
  720. sbus_writeb(8, &bp->r0->r);
  721. #endif
  722. #endif
  724. /* old bp = IRQ_to_board[irq&0x0f];*/
  726. if (!bp || !(bp->flags & AURORA_BOARD_ACTIVE))
  727. return;
  729. /* The while() below takes care of this.
  730. status = sbus_readb(&bp->r[0]->r[CD180_SRSR]);
  731. #ifdef AURORA_INT_DEBUG
  732. printk("mumu: %02xn", status);
  733. #endif
  734. if (!(status&SRSR_ANYINT))
  735. return; * Nobody has anything to say, so exit *
  736. */
  737. while ((loop++ < 48) &&
  738.        (status = sbus_readb(&bp->r[0]->r[CD180_SRSR]) & SRSR_ANYINT)){
  739. #ifdef AURORA_INT_DEBUG
  740. printk("SRSR: %02xn", status);
  741. #endif
  742. if (status & SRSR_REXT) {
  743. ack = sbus_readb(&bp->r3->r[bp->ACK_RINT]);
  744. #ifdef AURORA_INT_DEBUG
  745. printk("R-ACK %02xn", ack);
  746. #endif
  747. if ((ack >> 5) == board_No(bp)) {
  748. if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
  749. if ((ack&GSVR_ITMASK)==GSVR_IT_RGD) {
  750. aurora_receive(bp,chip);
  751. sbus_writeb(0,
  752.  &bp->r[chip]->r[CD180_EOSRR]);
  753. } else if ((ack & GSVR_ITMASK) == GSVR_IT_REXC) {
  754. aurora_receive_exc(bp,chip);
  755. sbus_writeb(0,
  756.  &bp->r[chip]->r[CD180_EOSRR]);
  757. }
  758. }
  759. }
  760. } else if (status & SRSR_TEXT) {
  761. ack = sbus_readb(&bp->r3->r[bp->ACK_TINT]);
  762. #ifdef AURORA_INT_DEBUG
  763. printk("T-ACK %02xn", ack);
  764. #endif
  765. if ((ack >> 5) == board_No(bp)) {
  766. if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
  767. if ((ack&GSVR_ITMASK)==GSVR_IT_TX) {
  768. aurora_transmit(bp,chip);
  769. sbus_writeb(0,
  770.  &bp->r[chip]->r[CD180_EOSRR]);
  771. }
  772. }
  773. }
  774. } else if (status & SRSR_MEXT) {
  775. ack = sbus_readb(&bp->r3->r[bp->ACK_MINT]);
  776. #ifdef AURORA_INT_DEBUG
  777. printk("M-ACK %02xn", ack);
  778. #endif
  779. if ((ack >> 5) == board_No(bp)) {
  780. if ((chip = ((ack>>3)&3)-1) < AURORA_NCD180) {
  781. if ((ack&GSVR_ITMASK)==GSVR_IT_MDM) {
  782. aurora_check_modem(bp,chip);
  783. sbus_writeb(0,
  784.  &bp->r[chip]->r[CD180_EOSRR]);
  785. }
  786. }
  787. }
  788. }
  789. }
  790. /* I guess this faster code can be used with CD1865, using AUROPRI and GLOBPRI. */
  791. #if 0
  792. while ((loop++ < 48)&&(status=bp->r[0]->r[CD180_SRSR]&SRSR_ANYINT)){
  793. #ifdef AURORA_INT_DEBUG
  794. printk("SRSR: %02xn",status);
  795. #endif
  796. ack = sbus_readb(&bp->r3->r[0]);
  797. #ifdef AURORA_INT_DEBUG
  798. printk("ACK: %02xn",ack);
  799. #endif
  800. if ((ack>>5)==board_No(bp)) {
  801. if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
  802. ack&=GSVR_ITMASK;
  803. if (ack==GSVR_IT_RGD) {
  804. aurora_receive(bp,chip);
  805. sbus_writeb(0,
  806.     &bp->r[chip]->r[CD180_EOSRR]);
  807. } else if (ack==GSVR_IT_REXC) {
  808. aurora_receive_exc(bp,chip);
  809. sbus_writeb(0,
  810.     &bp->r[chip]->r[CD180_EOSRR]);
  811. } else if (ack==GSVR_IT_TX) {
  812. aurora_transmit(bp,chip);
  813. sbus_writeb(0,
  814.     &bp->r[chip]->r[CD180_EOSRR]);
  815. } else if (ack==GSVR_IT_MDM) {
  816. aurora_check_modem(bp,chip);
  817. sbus_writeb(0,
  818.     &bp->r[chip]->r[CD180_EOSRR]);
  819. }
  820. }
  821. }
  822. }
  823. #endif
  825. /* This is the old handling routine, used in riscom8 for only one CD180. I keep it here for reference. */
  826. #if 0
  827. for(chip=0;chip<AURORA_NCD180;chip++){
  828. chip_id=(board_No(bp)<<5)|((chip+1)<<3);
  829. loop=0;
  830. while ((loop++ < 1) &&
  831.        ((status = sbus_readb(&bp->r[chip]->r[CD180_SRSR])) &
  832. (SRSR_TEXT | SRSR_MEXT | SRSR_REXT))) {
  834. if (status & SRSR_REXT) {
  835. ack = sbus_readb(&bp->r3->r[bp->ACK_RINT]);
  836. if (ack == (chip_id | GSVR_IT_RGD)) {
  837. #ifdef AURORA_INTMSG
  838. printk("RX ACKn");
  839. #endif
  840. aurora_receive(bp,chip);
  841. } else if (ack == (chip_id | GSVR_IT_REXC)) {
  842. #ifdef AURORA_INTMSG
  843. printk("RXC ACKn");
  844. #endif
  845. aurora_receive_exc(bp,chip);
  846. } else {
  847. #ifdef AURORA_INTNORM
  848. printk("aurora%d-%d: Bad receive ack 0x%02x.n",
  849.        board_No(bp), chip, ack);
  850. #endif
  851. }
  852. } else if (status & SRSR_TEXT) {
  853. ack = sbus_readb(&bp->r3->r[bp->ACK_TINT]);
  854. if (ack == (chip_id | GSVR_IT_TX)){
  855. #ifdef AURORA_INTMSG
  856. printk("TX ACKn");
  857. #endif
  858. aurora_transmit(bp,chip);
  859. } else {
  860. #ifdef AURORA_INTNORM
  861. printk("aurora%d-%d: Bad transmit ack 0x%02x.n",
  862.        board_No(bp), chip, ack);
  863. #endif
  864. }
  865. } else  if (status & SRSR_MEXT)  {
  866. ack = sbus_readb(&bp->r3->r[bp->ACK_MINT]);
  867. if (ack == (chip_id | GSVR_IT_MDM)){
  868. #ifdef AURORA_INTMSG
  869. printk("MDM ACKn");
  870. #endif
  871. aurora_check_modem(bp,chip);
  872. } else {
  873. #ifdef AURORA_INTNORM
  874. printk("aurora%d-%d: Bad modem ack 0x%02x.n",
  875.        board_No(bp), chip, ack);
  876. #endif
  877. }
  878. }
  879. sbus_writeb(0, &bp->r[chip]->r[CD180_EOSRR]);
  880. }
  881. }
  882. #endif
  883. }
  885. #ifdef AURORA_INT_DEBUG
  886. static void aurora_timer (unsigned long ignored);
  888. static struct timer_list
  889. aurora_poll_timer = { NULL, NULL, 0, 0, aurora_timer };
  891. static void
  892. aurora_timer (unsigned long ignored)
  893. {
  894. unsigned long flags;
  895. int i;
  897. save_flags(flags); cli();
  899. printk("SRSR: %02x,%02x - ",
  900.        sbus_readb(&aurora_board[0].r[0]->r[CD180_SRSR]),
  901.        sbus_readb(&aurora_board[0].r[1]->r[CD180_SRSR]));
  902. for (i = 0; i < 4; i++) {
  903. udelay(1);
  904. printk("%02x ",
  905.        sbus_readb(&aurora_board[0].r3->r[i]));
  906. }
  907. printk("n");
  909. aurora_poll_timer.expires = jiffies + 300;
  910. add_timer (&aurora_poll_timer);
  912. restore_flags(flags);
  913. }
  914. #endif
  916. /*
  917.  *  Routines for open & close processing.
  918.  */
  920. /* Called with disabled interrupts */
  921. static int aurora_setup_board(struct Aurora_board * bp)
  922. {
  923. int error;
  925. #ifdef AURORA_ALLIRQ
  926. int i;
  927. for (i = 0; i < AURORA_ALLIRQ; i++) {
  928. error = request_irq(allirq[i]|0x30, aurora_interrupt, SA_SHIRQ,
  929.     "sio16", bp);
  930. if (error)
  931. printk(KERN_ERR "IRQ%d request error %dn",
  932.        allirq[i], error);
  933. }
  934. #else
  935. error = request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ,
  936.     "sio16", bp);
  937. if (error) {
  938. printk(KERN_ERR "IRQ request error %dn", error);
  939. return error;
  940. }
  941. #endif
  942. /* Board reset */
  943. sbus_writeb(0, &bp->r0->r);
  944. udelay(1);
  945. if (bp->flags & AURORA_BOARD_TYPE_2) {
  946. /* unknown yet */
  947. } else {
  948. sbus_writeb((AURORA_CFG_ENABLE_IO | AURORA_CFG_ENABLE_IRQ |
  949.      (((bp->irq)&0x0f)>>2)),
  950.     &bp->r0->r);
  951. }
  952. udelay(10000);
  954. if (aurora_init_CD180(bp,0))error=1;error=0;
  955. if (aurora_init_CD180(bp,1))error++;
  956. if (error == AURORA_NCD180) {
  957. printk(KERN_ERR "Both chips failed initialisation.n");
  958. return -EIO;
  959. }
  961. #ifdef AURORA_INT_DEBUG
  962. aurora_poll_timer.expires= jiffies + 1;
  963. add_timer(&aurora_poll_timer);
  964. #endif
  965. #ifdef AURORA_DEBUG
  966. printk("aurora_setup_board: endn");
  967. #endif
  968. return 0;
  969. }
  971. /* Called with disabled interrupts */
  972. static void aurora_shutdown_board(struct Aurora_board *bp)
  973. {
  974. int i;
  976. #ifdef AURORA_DEBUG
  977. printk("aurora_shutdown_board: startn");
  978. #endif
  980. #ifdef AURORA_INT_DEBUG
  981. del_timer(&aurora_poll_timer);
  982. #endif
  984. #ifdef AURORA_ALLIRQ
  985. for(i=0;i<AURORA_ALLIRQ;i++){
  986. free_irq(allirq[i]|0x30, bp);
  987. /* IRQ_to_board[allirq[i]&0xf] = NULL;*/
  988. }
  989. #else
  990. free_irq(bp->irq|0x30, bp);
  991. /* IRQ_to_board[bp->irq&0xf] = NULL;*/
  992. #endif
  993. /* Drop all DTR's */
  994. for(i=0;i<16;i++){
  995. sbus_writeb(i & 7, &bp->r[i>>3]->r[CD180_CAR]);
  996. udelay(1);
  997. sbus_writeb(0, &bp->r[i>>3]->r[CD180_MSVR]);
  998. udelay(1);
  999. }
  1000. /* Board shutdown */
  1001. sbus_writeb(0, &bp->r0->r);
  1003. #ifdef AURORA_DEBUG
  1004. printk("aurora_shutdown_board: endn");
  1005. #endif
  1006. }
  1008. /* Setting up port characteristics. 
  1009.  * Must be called with disabled interrupts
  1010.  */
  1011. static void aurora_change_speed(struct Aurora_board *bp, struct Aurora_port *port)
  1012. {
  1013. struct tty_struct *tty;
  1014. unsigned long baud;
  1015. long tmp;
  1016. unsigned char cor1 = 0, cor3 = 0;
  1017. unsigned char mcor1 = 0, mcor2 = 0,chip;
  1019. #ifdef AURORA_DEBUG
  1020. printk("aurora_change_speed: startn");
  1021. #endif
  1022. if (!(tty = port->tty) || !tty->termios)
  1023. return;
  1025. chip = AURORA_CD180(port_No(port));
  1027. port->SRER  = 0;
  1028. port->COR2 = 0;
  1029. port->MSVR = MSVR_RTS|MSVR_DTR;
  1031. baud = tty_get_baud_rate(tty);
  1033. /* Select port on the board */
  1034. sbus_writeb(port_No(port) & 7,
  1035.     &bp->r[chip]->r[CD180_CAR]);
  1036. udelay(1);
  1038. if (!baud)  {
  1039. /* Drop DTR & exit */
  1040. port->MSVR &= ~(bp->DTR|bp->RTS);
  1041. sbus_writeb(port->MSVR,
  1042.     &bp->r[chip]->r[CD180_MSVR]);
  1043. return;
  1044. } else  {
  1045. /* Set DTR on */
  1046. port->MSVR |= bp->DTR;
  1047. sbus_writeb(port->MSVR,
  1048.     &bp->r[chip]->r[CD180_MSVR]);
  1049. }
  1051. /* Now we must calculate some speed dependant things. */
  1053. /* Set baud rate for port. */
  1054. tmp = (((bp->oscfreq + baud/2) / baud +
  1055. CD180_TPC/2) / CD180_TPC);
  1057. /* tmp = (bp->oscfreq/7)/baud;
  1058. if((tmp%10)>4)tmp=tmp/10+1;else tmp=tmp/10;*/
  1059. /* printk("Prescaler period: %dn",tmp);*/
  1061. sbus_writeb((tmp >> 8) & 0xff,
  1062.     &bp->r[chip]->r[CD180_RBPRH]);
  1063. sbus_writeb((tmp >> 8) & 0xff,
  1064.     &bp->r[chip]->r[CD180_TBPRH]);
  1065. sbus_writeb(tmp & 0xff, &bp->r[chip]->r[CD180_RBPRL]);
  1066. sbus_writeb(tmp & 0xff, &bp->r[chip]->r[CD180_TBPRL]);
  1068. baud = (baud + 5) / 10;   /* Estimated CPS */
  1070. /* Two timer ticks seems enough to wakeup something like SLIP driver */
  1071. tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
  1072. port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
  1073.       SERIAL_XMIT_SIZE - 1 : tmp);
  1075. /* Receiver timeout will be transmission time for 1.5 chars */
  1076. tmp = (AURORA_TPS + AURORA_TPS/2 + baud/2) / baud;
  1077. tmp = (tmp > 0xff) ? 0xff : tmp;
  1078. sbus_writeb(tmp, &bp->r[chip]->r[CD180_RTPR]);
  1080. switch (C_CSIZE(tty))  {
  1081.  case CS5:
  1082. cor1 |= COR1_5BITS;
  1083. break;
  1084.  case CS6:
  1085. cor1 |= COR1_6BITS;
  1086. break;
  1087.  case CS7:
  1088. cor1 |= COR1_7BITS;
  1089. break;
  1090.  case CS8:
  1091. cor1 |= COR1_8BITS;
  1092. break;
  1093. }
  1095. if (C_CSTOPB(tty)) 
  1096. cor1 |= COR1_2SB;
  1098. cor1 |= COR1_IGNORE;
  1099. if (C_PARENB(tty))  {
  1100. cor1 |= COR1_NORMPAR;
  1101. if (C_PARODD(tty)) 
  1102. cor1 |= COR1_ODDP;
  1103. if (I_INPCK(tty)) 
  1104. cor1 &= ~COR1_IGNORE;
  1105. }
  1106. /* Set marking of some errors */
  1107. port->mark_mask = RCSR_OE | RCSR_TOUT;
  1108. if (I_INPCK(tty)) 
  1109. port->mark_mask |= RCSR_FE | RCSR_PE;
  1110. if (I_BRKINT(tty) || I_PARMRK(tty)) 
  1111. port->mark_mask |= RCSR_BREAK;
  1112. if (I_IGNPAR(tty)) 
  1113. port->mark_mask &= ~(RCSR_FE | RCSR_PE);
  1114. if (I_IGNBRK(tty))  {
  1115. port->mark_mask &= ~RCSR_BREAK;
  1116. if (I_IGNPAR(tty)) 
  1117. /* Real raw mode. Ignore all */
  1118. port->mark_mask &= ~RCSR_OE;
  1119. }
  1120. /* Enable Hardware Flow Control */
  1121. if (C_CRTSCTS(tty))  {
  1122. /*#ifdef AURORA_BRAIN_DAMAGED_CTS
  1123. port->SRER |= SRER_DSR | SRER_CTS;
  1124. mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
  1125. mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
  1126. tty->hw_stopped = !(aurora_in(bp, CD180_MSVR) & (MSVR_CTS|MSVR_DSR));
  1127. #else*/
  1128. port->COR2 |= COR2_CTSAE;
  1129. /*#endif*/
  1130. if (bp->flags&AURORA_BOARD_DTR_FLOW_OK) {
  1131. mcor1 |= AURORA_RXTH;
  1132. }
  1133. }
  1134. /* Enable Software Flow Control. FIXME: I'm not sure about this */
  1135. /* Some people reported that it works, but I still doubt */
  1136. if (I_IXON(tty))  {
  1137. port->COR2 |= COR2_TXIBE;
  1138. cor3 |= (COR3_FCT | COR3_SCDE);
  1139. if (I_IXANY(tty))
  1140. port->COR2 |= COR2_IXM;
  1141. sbus_writeb(START_CHAR(tty),
  1142.     &bp->r[chip]->r[CD180_SCHR1]);
  1143. sbus_writeb(STOP_CHAR(tty),
  1144.     &bp->r[chip]->r[CD180_SCHR2]);
  1145. sbus_writeb(START_CHAR(tty),
  1146.     &bp->r[chip]->r[CD180_SCHR3]);
  1147. sbus_writeb(STOP_CHAR(tty),
  1148.     &bp->r[chip]->r[CD180_SCHR4]);
  1149. }
  1150. if (!C_CLOCAL(tty))  {
  1151. /* Enable CD check */
  1152. port->SRER |= SRER_CD;
  1153. mcor1 |= MCOR1_CDZD;
  1154. mcor2 |= MCOR2_CDOD;
  1155. }
  1157. if (C_CREAD(tty)) 
  1158. /* Enable receiver */
  1159. port->SRER |= SRER_RXD;
  1161. /* Set input FIFO size (1-8 bytes) */
  1162. cor3 |= AURORA_RXFIFO; 
  1163. /* Setting up CD180 channel registers */
  1164. sbus_writeb(cor1, &bp->r[chip]->r[CD180_COR1]);
  1165. sbus_writeb(port->COR2, &bp->r[chip]->r[CD180_COR2]);
  1166. sbus_writeb(cor3, &bp->r[chip]->r[CD180_COR3]);
  1167. /* Make CD180 know about registers change */
  1168. aurora_wait_CCR(bp->r[chip]);
  1169. sbus_writeb(CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3,
  1170.     &bp->r[chip]->r[CD180_CCR]);
  1171. /* Setting up modem option registers */
  1172. sbus_writeb(mcor1, &bp->r[chip]->r[CD180_MCOR1]);
  1173. sbus_writeb(mcor2, &bp->r[chip]->r[CD180_MCOR2]);
  1174. /* Enable CD180 transmitter & receiver */
  1175. aurora_wait_CCR(bp->r[chip]);
  1176. sbus_writeb(CCR_TXEN | CCR_RXEN, &bp->r[chip]->r[CD180_CCR]);
  1177. /* Enable interrupts */
  1178. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  1179. /* And finally set RTS on */
  1180. sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
  1181. #ifdef AURORA_DEBUG
  1182. printk("aurora_change_speed: endn");
  1183. #endif
  1184. }
  1186. /* Must be called with interrupts enabled */
  1187. static int aurora_setup_port(struct Aurora_board *bp, struct Aurora_port *port)
  1188. {
  1189. unsigned long flags;
  1191. #ifdef AURORA_DEBUG
  1192. printk("aurora_setup_port: start %dn",port_No(port));
  1193. #endif
  1194. if (port->flags & ASYNC_INITIALIZED)
  1195. return 0;
  1197. if (!port->xmit_buf) {
  1198. /* We may sleep in get_free_page() */
  1199. unsigned long tmp;
  1201. if (!(tmp = get_free_page(GFP_KERNEL)))
  1202. return -ENOMEM;
  1203.     
  1204. if (port->xmit_buf) {
  1205. free_page(tmp);
  1206. return -ERESTARTSYS;
  1207. }
  1208. port->xmit_buf = (unsigned char *) tmp;
  1209. }
  1211. save_flags(flags); cli();
  1213. if (port->tty) 
  1214. clear_bit(TTY_IO_ERROR, &port->tty->flags);
  1216. #ifdef MODULE
  1217. if (port->count == 1) {
  1218. MOD_INC_USE_COUNT;
  1219. if((++bp->count) == 1)
  1220. bp->flags |= AURORA_BOARD_ACTIVE;
  1221. }
  1222. #endif
  1224. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  1225. aurora_change_speed(bp, port);
  1226. port->flags |= ASYNC_INITIALIZED;
  1228. restore_flags(flags);
  1229. #ifdef AURORA_DEBUG
  1230. printk("aurora_setup_port: endn");
  1231. #endif
  1232. return 0;
  1233. }
  1235. /* Must be called with interrupts disabled */
  1236. static void aurora_shutdown_port(struct Aurora_board *bp, struct Aurora_port *port)
  1237. {
  1238. struct tty_struct *tty;
  1239. unsigned char chip;
  1241. #ifdef AURORA_DEBUG
  1242. printk("aurora_shutdown_port: startn");
  1243. #endif
  1244. if (!(port->flags & ASYNC_INITIALIZED)) 
  1245. return;
  1247. chip = AURORA_CD180(port_No(port));
  1249. #ifdef AURORA_REPORT_OVERRUN
  1250. printk("aurora%d: port %d: Total %ld overruns were detected.n",
  1251.        board_No(bp), port_No(port), port->overrun);
  1252. #endif
  1253. #ifdef AURORA_REPORT_FIFO
  1254. {
  1255. int i;
  1257. printk("aurora%d: port %d: FIFO hits [ ",
  1258.        board_No(bp), port_No(port));
  1259. for (i = 0; i < 10; i++)  {
  1260. printk("%ld ", port->hits[i]);
  1261. }
  1262. printk("].n");
  1263. }
  1264. #endif
  1265. if (port->xmit_buf)  {
  1266. free_page((unsigned long) port->xmit_buf);
  1267. port->xmit_buf = NULL;
  1268. }
  1270. if (!(tty = port->tty) || C_HUPCL(tty))  {
  1271. /* Drop DTR */
  1272. port->MSVR &= ~(bp->DTR|bp->RTS);
  1273. sbus_writeb(port->MSVR,
  1274.     &bp->r[chip]->r[CD180_MSVR]);
  1275. }
  1277.         /* Select port */
  1278. sbus_writeb(port_No(port) & 7,
  1279.     &bp->r[chip]->r[CD180_CAR]);
  1280. udelay(1);
  1282. /* Reset port */
  1283. aurora_wait_CCR(bp->r[chip]);
  1284. sbus_writeb(CCR_SOFTRESET, &bp->r[chip]->r[CD180_CCR]);
  1286. /* Disable all interrupts from this port */
  1287. port->SRER = 0;
  1288. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  1290. if (tty)  
  1291. set_bit(TTY_IO_ERROR, &tty->flags);
  1292. port->flags &= ~ASYNC_INITIALIZED;
  1294. #ifdef MODULE
  1295. if (--bp->count < 0)  {
  1296. printk(KERN_DEBUG "aurora%d: aurora_shutdown_port: "
  1297.        "bad board count: %dn",
  1298.        board_No(bp), bp->count);
  1299. bp->count = 0;
  1300. }
  1302. MOD_DEC_USE_COUNT;
  1303. if (!bp->count)
  1304. bp->flags &= ~AURORA_BOARD_ACTIVE;
  1305. #endif
  1307. #ifdef AURORA_DEBUG
  1308. printk("aurora_shutdown_port: endn");
  1309. #endif
  1310. }
  1313. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1314.    struct Aurora_port *port)
  1315. {
  1316. DECLARE_WAITQUEUE(wait, current);
  1317. struct Aurora_board *bp = port_Board(port);
  1318. int    retval;
  1319. int    do_clocal = 0;
  1320. int    CD;
  1321. unsigned char chip;
  1323. #ifdef AURORA_DEBUG
  1324. printk("block_til_ready: startn");
  1325. #endif
  1326. chip = AURORA_CD180(port_No(port));
  1328. /* If the device is in the middle of being closed, then block
  1329.  * until it's done, and then try again.
  1330.  */
  1331. if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
  1332. interruptible_sleep_on(&port->close_wait);
  1333. if (port->flags & ASYNC_HUP_NOTIFY)
  1334. return -EAGAIN;
  1335. else
  1336. return -ERESTARTSYS;
  1337. }
  1339. /* If non-blocking mode is set, or the port is not enabled,
  1340.  * then make the check up front and then exit.
  1341.  */
  1342. if ((filp->f_flags & O_NONBLOCK) ||
  1343.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1344. if (port->flags & ASYNC_CALLOUT_ACTIVE)
  1345. return -EBUSY;
  1346. port->flags |= ASYNC_NORMAL_ACTIVE;
  1347. return 0;
  1348. }
  1350. if (port->flags & ASYNC_CALLOUT_ACTIVE) {
  1351. if (port->normal_termios.c_cflag & CLOCAL) 
  1352. do_clocal = 1;
  1353. } else {
  1354. if (C_CLOCAL(tty))  
  1355. do_clocal = 1;
  1356. }
  1358. /* Block waiting for the carrier detect and the line to become
  1359.  * free (i.e., not in use by the callout).  While we are in
  1360.  * this loop, info->count is dropped by one, so that
  1361.  * rs_close() knows when to free things.  We restore it upon
  1362.  * exit, either normal or abnormal.
  1363.  */
  1364. retval = 0;
  1365. add_wait_queue(&port->open_wait, &wait);
  1366. cli();
  1367. if (!tty_hung_up_p(filp))
  1368. port->count--;
  1369. sti();
  1370. port->blocked_open++;
  1371. while (1) {
  1372. cli();
  1373. sbus_writeb(port_No(port) & 7,
  1374.     &bp->r[chip]->r[CD180_CAR]);
  1375. udelay(1);
  1376. CD = sbus_readb(&bp->r[chip]->r[CD180_MSVR]) & MSVR_CD;
  1377. if (!(port->flags & ASYNC_CALLOUT_ACTIVE))  {
  1378. port->MSVR=bp->RTS;
  1380. /* auto drops DTR */
  1381. sbus_writeb(port->MSVR,
  1382.     &bp->r[chip]->r[CD180_MSVR]);
  1383. }
  1384. sti();
  1385. set_current_state(TASK_INTERRUPTIBLE);
  1386. if (tty_hung_up_p(filp) ||
  1387.     !(port->flags & ASYNC_INITIALIZED)) {
  1388. if (port->flags & ASYNC_HUP_NOTIFY)
  1389. retval = -EAGAIN;
  1390. else
  1391. retval = -ERESTARTSYS;
  1392. break;
  1393. }
  1394. if (/*!(port->flags & ASYNC_CALLOUT_ACTIVE) &&*/
  1395.     !(port->flags & ASYNC_CLOSING) &&
  1396.     (do_clocal || CD))
  1397. break;
  1398. if (signal_pending(current)) {
  1399. retval = -ERESTARTSYS;
  1400. break;
  1401. }
  1402. schedule();
  1403. }
  1404. current->state = TASK_RUNNING;
  1405. remove_wait_queue(&port->open_wait, &wait);
  1406. if (!tty_hung_up_p(filp))
  1407. port->count++;
  1408. port->blocked_open--;
  1409. if (retval)
  1410. return retval;
  1412. port->flags |= ASYNC_NORMAL_ACTIVE;
  1413. #ifdef AURORA_DEBUG
  1414. printk("block_til_ready: endn");
  1415. #endif
  1416. return 0;
  1417. }
  1419. static int aurora_open(struct tty_struct * tty, struct file * filp)
  1420. {
  1421. int board;
  1422. int error;
  1423. struct Aurora_port * port;
  1424. struct Aurora_board * bp;
  1425. unsigned long flags;
  1427. #ifdef AURORA_DEBUG
  1428. printk("aurora_open: startn");
  1429. #endif
  1431. board = AURORA_BOARD(MINOR(tty->device));
  1432. if (board > AURORA_NBOARD ||
  1433.     !(aurora_board[board].flags & AURORA_BOARD_PRESENT)) {
  1434. #ifdef AURORA_DEBUG
  1435. printk("aurora_open: error board %d present %dn",
  1436.        board, aurora_board[board].flags & AURORA_BOARD_PRESENT);
  1437. #endif
  1438. return -ENODEV;
  1439. }
  1441. bp = &aurora_board[board];
  1442. port = aurora_port + board * AURORA_NPORT * AURORA_NCD180 + AURORA_PORT(MINOR(tty->device));
  1443. if (aurora_paranoia_check(port, tty->device, "aurora_open")) {
  1444. #ifdef AURORA_DEBUG
  1445. printk("aurora_open: error paranoia checkn");
  1446. #endif
  1447. return -ENODEV;
  1448. }
  1450. port->count++;
  1451. tty->driver_data = port;
  1452. port->tty = tty;
  1454. if ((error = aurora_setup_port(bp, port))) {
  1455. #ifdef AURORA_DEBUG
  1456. printk("aurora_open: error aurora_setup_port ret %dn",error);
  1457. #endif
  1458. return error;
  1459. }
  1461. if ((error = block_til_ready(tty, filp, port))) {
  1462. #ifdef AURORA_DEBUG
  1463. printk("aurora_open: error block_til_ready ret %dn",error);
  1464. #endif
  1465. return error;
  1466. }
  1468. if ((port->count == 1) && (port->flags & ASYNC_SPLIT_TERMIOS)) {
  1469. *tty->termios = port->normal_termios;
  1470. save_flags(flags); cli();
  1471. aurora_change_speed(bp, port);
  1472. restore_flags(flags);
  1473. }
  1475. port->session = current->session;
  1476. port->pgrp = current->pgrp;
  1477. #ifdef AURORA_DEBUG
  1478. printk("aurora_open: endn");
  1479. #endif
  1480. return 0;
  1481. }
  1483. static void aurora_close(struct tty_struct * tty, struct file * filp)
  1484. {
  1485. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1486. struct Aurora_board *bp;
  1487. unsigned long flags;
  1488. unsigned long timeout;
  1489. unsigned char chip;
  1491. #ifdef AURORA_DEBUG
  1492. printk("aurora_close: startn");
  1493. #endif
  1495. if (!port || aurora_paranoia_check(port, tty->device, "close"))
  1496. return;
  1498. chip = AURORA_CD180(port_No(port));
  1500. save_flags(flags); cli();
  1501. if (tty_hung_up_p(filp))  {
  1502. restore_flags(flags);
  1503. return;
  1504. }
  1506. bp = port_Board(port);
  1507. if ((tty->count == 1) && (port->count != 1))  {
  1508. printk(KERN_DEBUG "aurora%d: aurora_close: bad port count; "
  1509.        "tty->count is 1, port count is %dn",
  1510.        board_No(bp), port->count);
  1511. port->count = 1;
  1512. }
  1513. if (--port->count < 0)  {
  1514. printk(KERN_DEBUG "aurora%d: aurora_close: bad port "
  1515.        "count for tty%d: %dn",
  1516.        board_No(bp), port_No(port), port->count);
  1517. port->count = 0;
  1518. }
  1519. if (port->count)  {
  1520. restore_flags(flags);
  1521. return;
  1522. }
  1523. port->flags |= ASYNC_CLOSING;
  1525. /* Save the termios structure, since this port may have
  1526.  * separate termios for callout and dialin.
  1527.  */
  1528. if (port->flags & ASYNC_NORMAL_ACTIVE)
  1529. port->normal_termios = *tty->termios;
  1530. /* if (port->flags & ASYNC_CALLOUT_ACTIVE)
  1531. port->callout_termios = *tty->termios;*/
  1533. /* Now we wait for the transmit buffer to clear; and we notify 
  1534.  * the line discipline to only process XON/XOFF characters.
  1535.  */
  1536. tty->closing = 1;
  1537. if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE){
  1538. #ifdef AURORA_DEBUG
  1539. printk("aurora_close: waiting to flush...n");
  1540. #endif
  1541. tty_wait_until_sent(tty, port->closing_wait);
  1542. }
  1544. /* At this point we stop accepting input.  To do this, we
  1545.  * disable the receive line status interrupts, and tell the
  1546.  * interrupt driver to stop checking the data ready bit in the
  1547.  * line status register.
  1548.  */
  1549. port->SRER &= ~SRER_RXD;
  1550. if (port->flags & ASYNC_INITIALIZED) {
  1551. port->SRER &= ~SRER_TXRDY;
  1552. port->SRER |= SRER_TXEMPTY;
  1553. sbus_writeb(port_No(port) & 7,
  1554.     &bp->r[chip]->r[CD180_CAR]);
  1555. udelay(1);
  1556. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  1557. /*
  1558.  * Before we drop DTR, make sure the UART transmitter
  1559.  * has completely drained; this is especially
  1560.  * important if there is a transmit FIFO!
  1561.  */
  1562. timeout = jiffies+HZ;
  1563. while(port->SRER & SRER_TXEMPTY)  {
  1564. current->state = TASK_INTERRUPTIBLE;
  1565. schedule_timeout(port->timeout);
  1566. if (time_after(jiffies, timeout))
  1567. break;
  1568. }
  1569. }
  1570. #ifdef AURORA_DEBUG
  1571. printk("aurora_close: shutdown_portn");
  1572. #endif
  1573. aurora_shutdown_port(bp, port);
  1574. if (tty->driver.flush_buffer)
  1575. tty->driver.flush_buffer(tty);
  1576. if (tty->ldisc.flush_buffer)
  1577. tty->ldisc.flush_buffer(tty);
  1578. tty->closing = 0;
  1579. port->event = 0;
  1580. port->tty = 0;
  1581. if (port->blocked_open) {
  1582. if (port->close_delay) {
  1583. current->state = TASK_INTERRUPTIBLE;
  1584. schedule_timeout(port->close_delay);
  1585. }
  1586. wake_up_interruptible(&port->open_wait);
  1587. }
  1588. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  1589.  ASYNC_CLOSING);
  1590. wake_up_interruptible(&port->close_wait);
  1591. restore_flags(flags);
  1592. #ifdef AURORA_DEBUG
  1593. printk("aurora_close: endn");
  1594. #endif
  1595. }
  1597. static int aurora_write(struct tty_struct * tty, int from_user, 
  1598. const unsigned char *buf, int count)
  1599. {
  1600. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1601. struct Aurora_board *bp;
  1602. int c, total = 0;
  1603. unsigned long flags;
  1604. unsigned char chip;
  1606. #ifdef AURORA_DEBUG
  1607. printk("aurora_write: start %dn",count);
  1608. #endif
  1609. if (aurora_paranoia_check(port, tty->device, "aurora_write"))
  1610. return 0;
  1612. chip = AURORA_CD180(port_No(port));
  1614. bp = port_Board(port);
  1616. if (!tty || !port->xmit_buf || !tmp_buf)
  1617. return 0;
  1619. save_flags(flags);
  1620. if (from_user) {
  1621. down(&tmp_buf_sem);
  1622. while (1) {
  1623. c = MIN(count, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1624.    SERIAL_XMIT_SIZE - port->xmit_head));
  1625. if (c <= 0)
  1626. break;
  1628. c -= copy_from_user(tmp_buf, buf, c);
  1629. if (!c) {
  1630. if (!total)
  1631. total = -EFAULT;
  1632. break;
  1633. }
  1634. cli();
  1635. c = MIN(c, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1636.        SERIAL_XMIT_SIZE - port->xmit_head));
  1637. memcpy(port->xmit_buf + port->xmit_head, tmp_buf, c);
  1638. port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  1639. port->xmit_cnt += c;
  1640. restore_flags(flags);
  1642. buf += c;
  1643. count -= c;
  1644. total += c;
  1645. }
  1646. up(&tmp_buf_sem);
  1647. } else {
  1648. while (1) {
  1649. cli();
  1650. c = MIN(count, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1651.    SERIAL_XMIT_SIZE - port->xmit_head));
  1652. if (c <= 0) {
  1653. restore_flags(flags);
  1654. break;
  1655. }
  1656. memcpy(port->xmit_buf + port->xmit_head, buf, c);
  1657. port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  1658. port->xmit_cnt += c;
  1659. restore_flags(flags);
  1661. buf += c;
  1662. count -= c;
  1663. total += c;
  1664. }
  1665. }
  1667. cli();
  1668. if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  1669.     !(port->SRER & SRER_TXRDY)) {
  1670. port->SRER |= SRER_TXRDY;
  1671. sbus_writeb(port_No(port) & 7,
  1672.     &bp->r[chip]->r[CD180_CAR]);
  1673. udelay(1);
  1674. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  1675. }
  1676. restore_flags(flags);
  1677. #ifdef AURORA_DEBUG
  1678. printk("aurora_write: end %dn",total);
  1679. #endif
  1680. return total;
  1681. }
  1683. static void aurora_put_char(struct tty_struct * tty, unsigned char ch)
  1684. {
  1685. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1686. unsigned long flags;
  1688. #ifdef AURORA_DEBUG
  1689. printk("aurora_put_char: start %cn",ch);
  1690. #endif
  1691. if (aurora_paranoia_check(port, tty->device, "aurora_put_char"))
  1692. return;
  1694. if (!tty || !port->xmit_buf)
  1695. return;
  1697. save_flags(flags); cli();
  1699. if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  1700. restore_flags(flags);
  1701. return;
  1702. }
  1704. port->xmit_buf[port->xmit_head++] = ch;
  1705. port->xmit_head &= SERIAL_XMIT_SIZE - 1;
  1706. port->xmit_cnt++;
  1707. restore_flags(flags);
  1708. #ifdef AURORA_DEBUG
  1709. printk("aurora_put_char: endn");
  1710. #endif
  1711. }
  1713. static void aurora_flush_chars(struct tty_struct * tty)
  1714. {
  1715. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1716. unsigned long flags;
  1717. unsigned char chip;
  1719. /*#ifdef AURORA_DEBUG
  1720. printk("aurora_flush_chars: startn");
  1721. #endif*/
  1722. if (aurora_paranoia_check(port, tty->device, "aurora_flush_chars"))
  1723. return;
  1725. chip = AURORA_CD180(port_No(port));
  1727. if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  1728.     !port->xmit_buf)
  1729. return;
  1731. save_flags(flags); cli();
  1732. port->SRER |= SRER_TXRDY;
  1733. sbus_writeb(port_No(port) & 7,
  1734.     &port_Board(port)->r[chip]->r[CD180_CAR]);
  1735. udelay(1);
  1736. sbus_writeb(port->SRER,
  1737.     &port_Board(port)->r[chip]->r[CD180_SRER]);
  1738. restore_flags(flags);
  1739. /*#ifdef AURORA_DEBUG
  1740. printk("aurora_flush_chars: endn");
  1741. #endif*/
  1742. }
  1744. static int aurora_write_room(struct tty_struct * tty)
  1745. {
  1746. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1747. int ret;
  1749. #ifdef AURORA_DEBUG
  1750. printk("aurora_write_room: startn");
  1751. #endif
  1752. if (aurora_paranoia_check(port, tty->device, "aurora_write_room"))
  1753. return 0;
  1755. ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
  1756. if (ret < 0)
  1757. ret = 0;
  1758. #ifdef AURORA_DEBUG
  1759. printk("aurora_write_room: endn");
  1760. #endif
  1761. return ret;
  1762. }
  1764. static int aurora_chars_in_buffer(struct tty_struct *tty)
  1765. {
  1766. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1768. if (aurora_paranoia_check(port, tty->device, "aurora_chars_in_buffer"))
  1769. return 0;
  1771. return port->xmit_cnt;
  1772. }
  1774. static void aurora_flush_buffer(struct tty_struct *tty)
  1775. {
  1776. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  1777. unsigned long flags;
  1779. #ifdef AURORA_DEBUG
  1780. printk("aurora_flush_buffer: startn");
  1781. #endif
  1782. if (aurora_paranoia_check(port, tty->device, "aurora_flush_buffer"))
  1783. return;
  1785. save_flags(flags); cli();
  1786. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  1787. restore_flags(flags);
  1789. wake_up_interruptible(&tty->write_wait);
  1790. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1791.     tty->ldisc.write_wakeup)
  1792. (tty->ldisc.write_wakeup)(tty);
  1793. #ifdef AURORA_DEBUG
  1794. printk("aurora_flush_buffer: endn");
  1795. #endif
  1796. }
  1798. static int aurora_get_modem_info(struct Aurora_port * port, unsigned int *value)
  1799. {
  1800. struct Aurora_board * bp;
  1801. unsigned char status,chip;
  1802. unsigned int result;
  1803. unsigned long flags;
  1805. #ifdef AURORA_DEBUG
  1806. printk("aurora_get_modem_info: startn");
  1807. #endif
  1808. chip = AURORA_CD180(port_No(port));
  1810. bp = port_Board(port);
  1812. save_flags(flags); cli();
  1814. sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
  1815. udelay(1);
  1817. status = sbus_readb(&bp->r[chip]->r[CD180_MSVR]);
  1818. result = 0/*bp->r[chip]->r[AURORA_RI] & (1u << port_No(port)) ? 0 : TIOCM_RNG*/;
  1820. restore_flags(flags);
  1822. result |= ((status & bp->RTS) ? TIOCM_RTS : 0)
  1823. | ((status & bp->DTR) ? TIOCM_DTR : 0)
  1824. | ((status & MSVR_CD)  ? TIOCM_CAR : 0)
  1825. | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
  1826. | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
  1828. put_user(result,(unsigned long *) value);
  1829. #ifdef AURORA_DEBUG
  1830. printk("aurora_get_modem_info: endn");
  1831. #endif
  1832. return 0;
  1833. }
  1835. static int aurora_set_modem_info(struct Aurora_port * port, unsigned int cmd,
  1836.  unsigned int *value)
  1837. {
  1838. unsigned int arg;
  1839. unsigned long flags;
  1840. struct Aurora_board *bp = port_Board(port);
  1841. unsigned char chip;
  1843. #ifdef AURORA_DEBUG
  1844. printk("aurora_set_modem_info: startn");
  1845. #endif
  1846. if (get_user(arg, value))
  1847. return -EFAULT;
  1848. chip = AURORA_CD180(port_No(port));
  1849. switch (cmd) {
  1850.  case TIOCMBIS: 
  1851. if (arg & TIOCM_RTS) 
  1852. port->MSVR |= bp->RTS;
  1853. if (arg & TIOCM_DTR)
  1854. port->MSVR |= bp->DTR;
  1855. break;
  1856. case TIOCMBIC:
  1857. if (arg & TIOCM_RTS)
  1858. port->MSVR &= ~bp->RTS;
  1859. if (arg & TIOCM_DTR)
  1860. port->MSVR &= ~bp->DTR;
  1861. break;
  1862. case TIOCMSET:
  1863. port->MSVR = (arg & TIOCM_RTS) ? (port->MSVR | bp->RTS) : 
  1864.          (port->MSVR & ~bp->RTS);
  1865. port->MSVR = (arg & TIOCM_DTR) ? (port->MSVR | bp->RTS) :
  1866.  (port->MSVR & ~bp->RTS);
  1867. break;
  1868.  default:
  1869. return -EINVAL;
  1870. };
  1872. save_flags(flags); cli();
  1874. sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
  1875. udelay(1);
  1877. sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
  1879. restore_flags(flags);
  1880. #ifdef AURORA_DEBUG
  1881. printk("aurora_set_modem_info: endn");
  1882. #endif
  1883. return 0;
  1884. }
  1886. static void aurora_send_break(struct Aurora_port * port, unsigned long length)
  1887. {
  1888. struct Aurora_board *bp = port_Board(port);
  1889. unsigned long flags;
  1890. unsigned char chip;
  1892. #ifdef AURORA_DEBUG
  1893. printk("aurora_send_break: startn");
  1894. #endif
  1895. chip = AURORA_CD180(port_No(port));
  1897. save_flags(flags); cli();
  1899. port->break_length = AURORA_TPS / HZ * length;
  1900. port->COR2 |= COR2_ETC;
  1901. port->SRER  |= SRER_TXRDY;
  1902. sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
  1903. udelay(1);
  1905. sbus_writeb(port->COR2, &bp->r[chip]->r[CD180_COR2]);
  1906. sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
  1907. aurora_wait_CCR(bp->r[chip]);
  1909. sbus_writeb(CCR_CORCHG2, &bp->r[chip]->r[CD180_CCR]);
  1910. aurora_wait_CCR(bp->r[chip]);
  1912. restore_flags(flags);
  1913. #ifdef AURORA_DEBUG
  1914. printk("aurora_send_break: endn");
  1915. #endif
  1916. }
  1918. static int aurora_set_serial_info(struct Aurora_port * port,
  1919.   struct serial_struct * newinfo)
  1920. {
  1921. struct serial_struct tmp;
  1922. struct Aurora_board *bp = port_Board(port);
  1923. int change_speed;
  1924. unsigned long flags;
  1926. #ifdef AURORA_DEBUG
  1927. printk("aurora_set_serial_info: startn");
  1928. #endif
  1929. if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
  1930. return -EFAULT;
  1931. #if 0
  1932. if ((tmp.irq != bp->irq) ||
  1933.     (tmp.port != bp->base) ||
  1934.     (tmp.type != PORT_CIRRUS) ||
  1935.     (tmp.baud_base != (bp->oscfreq + CD180_TPC/2) / CD180_TPC) ||
  1936.     (tmp.custom_divisor != 0) ||
  1937.     (tmp.xmit_fifo_size != CD180_NFIFO) ||
  1938.     (tmp.flags & ~AURORA_LEGAL_FLAGS))
  1939. return -EINVAL;
  1940. #endif
  1942. change_speed = ((port->flags & ASYNC_SPD_MASK) !=
  1943. (tmp.flags & ASYNC_SPD_MASK));
  1945. if (!capable(CAP_SYS_ADMIN)) {
  1946. if ((tmp.close_delay != port->close_delay) ||
  1947.     (tmp.closing_wait != port->closing_wait) ||
  1948.     ((tmp.flags & ~ASYNC_USR_MASK) !=
  1949.      (port->flags & ~ASYNC_USR_MASK)))  
  1950. return -EPERM;
  1951. port->flags = ((port->flags & ~ASYNC_USR_MASK) |
  1952.        (tmp.flags & ASYNC_USR_MASK));
  1953. } else  {
  1954. port->flags = ((port->flags & ~ASYNC_FLAGS) |
  1955.        (tmp.flags & ASYNC_FLAGS));
  1956. port->close_delay = tmp.close_delay;
  1957. port->closing_wait = tmp.closing_wait;
  1958. }
  1959. if (change_speed)  {
  1960. save_flags(flags); cli();
  1961. aurora_change_speed(bp, port);
  1962. restore_flags(flags);
  1963. }
  1964. #ifdef AURORA_DEBUG
  1965. printk("aurora_set_serial_info: endn");
  1966. #endif
  1967. return 0;
  1968. }
  1970. extern int aurora_get_serial_info(struct Aurora_port * port,
  1971.   struct serial_struct * retinfo)
  1972. {
  1973. struct serial_struct tmp;
  1974. struct Aurora_board *bp = port_Board(port);
  1975. int error;
  1977. #ifdef AURORA_DEBUG
  1978. printk("aurora_get_serial_info: startn");
  1979. #endif
  1980. error = verify_area(VERIFY_WRITE, (void *) retinfo, sizeof(tmp));
  1981. if (error)
  1982. return error;
  1984. memset(&tmp, 0, sizeof(tmp));
  1985. tmp.type = PORT_CIRRUS;
  1986. tmp.line = port - aurora_port;
  1987. tmp.port = 0;
  1988. tmp.irq  = bp->irq;
  1989. tmp.flags = port->flags;
  1990. tmp.baud_base = (bp->oscfreq + CD180_TPC/2) / CD180_TPC;
  1991. tmp.close_delay = port->close_delay * HZ/100;
  1992. tmp.closing_wait = port->closing_wait * HZ/100;
  1993. tmp.xmit_fifo_size = CD180_NFIFO;
  1994. copy_to_user(retinfo, &tmp, sizeof(tmp));
  1995. #ifdef AURORA_DEBUG
  1996. printk("aurora_get_serial_info: endn");
  1997. #endif
  1998. return 0;
  1999. }
  2001. static int aurora_ioctl(struct tty_struct * tty, struct file * filp, 
  2002.     unsigned int cmd, unsigned long arg)
  2003.     
  2004. {
  2005. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2006. int retval;
  2008. #ifdef AURORA_DEBUG
  2009. printk("aurora_ioctl: startn");
  2010. #endif
  2011. if (aurora_paranoia_check(port, tty->device, "aurora_ioctl"))
  2012. return -ENODEV;
  2014. switch (cmd) {
  2015. case TCSBRK: /* SVID version: non-zero arg --> no break */
  2016. retval = tty_check_change(tty);
  2017. if (retval)
  2018. return retval;
  2019. tty_wait_until_sent(tty, 0);
  2020. if (!arg)
  2021. aurora_send_break(port, HZ/4); /* 1/4 second */
  2022. return 0;
  2023. case TCSBRKP: /* support for POSIX tcsendbreak() */
  2024. retval = tty_check_change(tty);
  2025. if (retval)
  2026. return retval;
  2027. tty_wait_until_sent(tty, 0);
  2028. aurora_send_break(port, arg ? arg*(HZ/10) : HZ/4);
  2029. return 0;
  2030. case TIOCGSOFTCAR:
  2031. return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *)arg);
  2032. case TIOCSSOFTCAR:
  2033. if (get_user(arg,(unsigned long *)arg))
  2034. return -EFAULT;
  2035. tty->termios->c_cflag =
  2036. ((tty->termios->c_cflag & ~CLOCAL) |
  2037.  (arg ? CLOCAL : 0));
  2038. return 0;
  2039. case TIOCMGET:
  2040. retval = verify_area(VERIFY_WRITE, (void *) arg,
  2041.     sizeof(unsigned int));
  2042. if (retval)
  2043. return retval;
  2044. return aurora_get_modem_info(port, (unsigned int *) arg);
  2045. case TIOCMBIS:
  2046. case TIOCMBIC:
  2047. case TIOCMSET:
  2048. return aurora_set_modem_info(port, cmd, (unsigned int *) arg);
  2049. case TIOCGSERIAL:
  2050. return aurora_get_serial_info(port, (struct serial_struct *) arg);
  2051. case TIOCSSERIAL:
  2052. return aurora_set_serial_info(port, (struct serial_struct *) arg);
  2053. default:
  2054. return -ENOIOCTLCMD;
  2055. };
  2056. #ifdef AURORA_DEBUG
  2057. printk("aurora_ioctl: endn");
  2058. #endif
  2059. return 0;
  2060. }
  2062. static void aurora_throttle(struct tty_struct * tty)
  2063. {
  2064. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2065. struct Aurora_board *bp;
  2066. unsigned long flags;
  2067. unsigned char chip;
  2069. #ifdef AURORA_DEBUG
  2070. printk("aurora_throttle: startn");
  2071. #endif
  2072. if (aurora_paranoia_check(port, tty->device, "aurora_throttle"))
  2073. return;
  2075. bp = port_Board(port);
  2076. chip = AURORA_CD180(port_No(port));
  2078. save_flags(flags); cli();
  2079. port->MSVR &= ~bp->RTS;
  2080. sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
  2081. udelay(1);
  2082. if (I_IXOFF(tty))  {
  2083. aurora_wait_CCR(bp->r[chip]);
  2084. sbus_writeb(CCR_SSCH2, &bp->r[chip]->r[CD180_CCR]);
  2085. aurora_wait_CCR(bp->r[chip]);
  2086. }
  2087. sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
  2088. restore_flags(flags);
  2089. #ifdef AURORA_DEBUG
  2090. printk("aurora_throttle: endn");
  2091. #endif
  2092. }
  2094. static void aurora_unthrottle(struct tty_struct * tty)
  2095. {
  2096. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2097. struct Aurora_board *bp;
  2098. unsigned long flags;
  2099. unsigned char chip;
  2101. #ifdef AURORA_DEBUG
  2102. printk("aurora_unthrottle: startn");
  2103. #endif
  2104. if (aurora_paranoia_check(port, tty->device, "aurora_unthrottle"))
  2105. return;
  2107. bp = port_Board(port);
  2109. chip = AURORA_CD180(port_No(port));
  2111. save_flags(flags); cli();
  2112. port->MSVR |= bp->RTS;
  2113. sbus_writeb(port_No(port) & 7,
  2114.     &bp->r[chip]->r[CD180_CAR]);
  2115. udelay(1);
  2116. if (I_IXOFF(tty))  {
  2117. aurora_wait_CCR(bp->r[chip]);
  2118. sbus_writeb(CCR_SSCH1,
  2119.     &bp->r[chip]->r[CD180_CCR]);
  2120. aurora_wait_CCR(bp->r[chip]);
  2121. }
  2122. sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
  2123. restore_flags(flags);
  2124. #ifdef AURORA_DEBUG
  2125. printk("aurora_unthrottle: endn");
  2126. #endif
  2127. }
  2129. static void aurora_stop(struct tty_struct * tty)
  2130. {
  2131. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2132. struct Aurora_board *bp;
  2133. unsigned long flags;
  2134. unsigned char chip;
  2136. #ifdef AURORA_DEBUG
  2137. printk("aurora_stop: startn");
  2138. #endif
  2139. if (aurora_paranoia_check(port, tty->device, "aurora_stop"))
  2140. return;
  2142. bp = port_Board(port);
  2144. chip = AURORA_CD180(port_No(port));
  2146. save_flags(flags); cli();
  2147. port->SRER &= ~SRER_TXRDY;
  2148. sbus_writeb(port_No(port) & 7,
  2149.     &bp->r[chip]->r[CD180_CAR]);
  2150. udelay(1);
  2151. sbus_writeb(port->SRER,
  2152.     &bp->r[chip]->r[CD180_SRER]);
  2153. restore_flags(flags);
  2154. #ifdef AURORA_DEBUG
  2155. printk("aurora_stop: endn");
  2156. #endif
  2157. }
  2159. static void aurora_start(struct tty_struct * tty)
  2160. {
  2161. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2162. struct Aurora_board *bp;
  2163. unsigned long flags;
  2164. unsigned char chip;
  2166. #ifdef AURORA_DEBUG
  2167. printk("aurora_start: startn");
  2168. #endif
  2169. if (aurora_paranoia_check(port, tty->device, "aurora_start"))
  2170. return;
  2172. bp = port_Board(port);
  2174. chip = AURORA_CD180(port_No(port));
  2176. save_flags(flags); cli();
  2177. if (port->xmit_cnt && port->xmit_buf && !(port->SRER & SRER_TXRDY))  {
  2178. port->SRER |= SRER_TXRDY;
  2179. sbus_writeb(port_No(port) & 7,
  2180.     &bp->r[chip]->r[CD180_CAR]);
  2181. udelay(1);
  2182. sbus_writeb(port->SRER,
  2183.     &bp->r[chip]->r[CD180_SRER]);
  2184. }
  2185. restore_flags(flags);
  2186. #ifdef AURORA_DEBUG
  2187. printk("aurora_start: endn");
  2188. #endif
  2189. }
  2191. /*
  2192.  * This routine is called from the scheduler tqueue when the interrupt
  2193.  * routine has signalled that a hangup has occurred.  The path of
  2194.  * hangup processing is:
  2195.  *
  2196.  *  serial interrupt routine -> (scheduler tqueue) ->
  2197.  *  do_aurora_hangup() -> tty->hangup() -> aurora_hangup()
  2198.  * 
  2199.  */
  2200. static void do_aurora_hangup(void *private_)
  2201. {
  2202. struct Aurora_port *port = (struct Aurora_port *) private_;
  2203. struct tty_struct *tty;
  2205. #ifdef AURORA_DEBUG
  2206. printk("do_aurora_hangup: startn");
  2207. #endif
  2208. tty = port->tty;
  2209. if (tty != NULL) {
  2210. tty_hangup(tty); /* FIXME: module removal race - AKPM */
  2211. #ifdef AURORA_DEBUG
  2212. printk("do_aurora_hangup: endn");
  2213. #endif
  2214. }
  2215. MOD_DEC_USE_COUNT;
  2216. }
  2218. static void aurora_hangup(struct tty_struct * tty)
  2219. {
  2220. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2221. struct Aurora_board *bp;
  2223. #ifdef AURORA_DEBUG
  2224. printk("aurora_hangup: startn");
  2225. #endif
  2226. if (aurora_paranoia_check(port, tty->device, "aurora_hangup"))
  2227. return;
  2229. bp = port_Board(port);
  2231. aurora_shutdown_port(bp, port);
  2232. port->event = 0;
  2233. port->count = 0;
  2234. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  2235. port->tty = 0;
  2236. wake_up_interruptible(&port->open_wait);
  2237. #ifdef AURORA_DEBUG
  2238. printk("aurora_hangup: endn");
  2239. #endif
  2240. }
  2242. static void aurora_set_termios(struct tty_struct * tty, struct termios * old_termios)
  2243. {
  2244. struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
  2245. unsigned long flags;
  2247. #ifdef AURORA_DEBUG
  2248. printk("aurora_set_termios: startn");
  2249. #endif
  2250. if (aurora_paranoia_check(port, tty->device, "aurora_set_termios"))
  2251. return;
  2253. if (tty->termios->c_cflag == old_termios->c_cflag &&
  2254.     tty->termios->c_iflag == old_termios->c_iflag)
  2255. return;
  2257. save_flags(flags); cli();
  2258. aurora_change_speed(port_Board(port), port);
  2259. restore_flags(flags);
  2261. if ((old_termios->c_cflag & CRTSCTS) &&
  2262.     !(tty->termios->c_cflag & CRTSCTS)) {
  2263. tty->hw_stopped = 0;
  2264. aurora_start(tty);
  2265. }
  2266. #ifdef AURORA_DEBUG
  2267. printk("aurora_set_termios: endn");
  2268. #endif
  2269. }
  2271. static void do_aurora_bh(void)
  2272. {
  2273.  run_task_queue(&tq_aurora);
  2274. }
  2276. static void do_softint(void *private_)
  2277. {
  2278. struct Aurora_port *port = (struct Aurora_port *) private_;
  2279. struct tty_struct *tty;
  2281. #ifdef AURORA_DEBUG
  2282. printk("do_softint: startn");
  2283. #endif
  2284. tty = port->tty;
  2285. if (tty == NULL)
  2286. return;
  2288. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
  2289. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  2290.     tty->ldisc.write_wakeup)
  2291. (tty->ldisc.write_wakeup)(tty);
  2292. wake_up_interruptible(&tty->write_wait);
  2293. }
  2294. #ifdef AURORA_DEBUG
  2295. printk("do_softint: endn");
  2296. #endif
  2297. }
  2299. static int aurora_init_drivers(void)
  2300. {
  2301. int error;
  2302. int i;
  2304. #ifdef AURORA_DEBUG
  2305. printk("aurora_init_drivers: startn");
  2306. #endif
  2307. tmp_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  2308. if (tmp_buf == NULL) {
  2309. printk(KERN_ERR "aurora: Couldn't get free page.n");
  2310. return 1;
  2311. }
  2312. init_bh(AURORA_BH, do_aurora_bh);
  2313. /* memset(IRQ_to_board, 0, sizeof(IRQ_to_board));*/
  2314. memset(&aurora_driver, 0, sizeof(aurora_driver));
  2315. aurora_driver.magic = TTY_DRIVER_MAGIC;
  2316. aurora_driver.name = "ttyA";
  2317. aurora_driver.major = AURORA_MAJOR;
  2318. aurora_driver.num = AURORA_TNPORTS;
  2319. aurora_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2320. aurora_driver.subtype = AURORA_TYPE_NORMAL;
  2321. aurora_driver.init_termios = tty_std_termios;
  2322. aurora_driver.init_termios.c_cflag =
  2323. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  2324. aurora_driver.flags = TTY_DRIVER_REAL_RAW;
  2325. aurora_driver.refcount = &aurora_refcount;
  2326. aurora_driver.table = aurora_table;
  2327. aurora_driver.termios = aurora_termios;
  2328. aurora_driver.termios_locked = aurora_termios_locked;
  2330. aurora_driver.open  = aurora_open;
  2331. aurora_driver.close = aurora_close;
  2332. aurora_driver.write = aurora_write;
  2333. aurora_driver.put_char = aurora_put_char;
  2334. aurora_driver.flush_chars = aurora_flush_chars;
  2335. aurora_driver.write_room = aurora_write_room;
  2336. aurora_driver.chars_in_buffer = aurora_chars_in_buffer;
  2337. aurora_driver.flush_buffer = aurora_flush_buffer;
  2338. aurora_driver.ioctl = aurora_ioctl;
  2339. aurora_driver.throttle = aurora_throttle;
  2340. aurora_driver.unthrottle = aurora_unthrottle;
  2341. aurora_driver.set_termios = aurora_set_termios;
  2342. aurora_driver.stop = aurora_stop;
  2343. aurora_driver.start = aurora_start;
  2344. aurora_driver.hangup = aurora_hangup;
  2346. error = tty_register_driver(&aurora_driver);
  2347. if (error) {
  2348. free_page((unsigned long) tmp_buf);
  2349. printk(KERN_ERR "aurora: Couldn't register aurora driver, error = %dn",
  2350.        error);
  2351. return 1;
  2352. }
  2354. memset(aurora_port, 0, sizeof(aurora_port));
  2355. for (i = 0; i < AURORA_TNPORTS; i++)  {
  2356. aurora_port[i].normal_termios  = aurora_driver.init_termios;
  2357. aurora_port[i].magic = AURORA_MAGIC;
  2358. aurora_port[i].tqueue.routine = do_softint;
  2359. aurora_port[i].tqueue.data = &aurora_port[i];
  2360. aurora_port[i].tqueue_hangup.routine = do_aurora_hangup;
  2361. aurora_port[i].tqueue_hangup.data = &aurora_port[i];
  2362. aurora_port[i].close_delay = 50 * HZ/100;
  2363. aurora_port[i].closing_wait = 3000 * HZ/100;
  2364. init_waitqueue_head(&aurora_port[i].open_wait);
  2365. init_waitqueue_head(&aurora_port[i].close_wait);
  2366. }
  2367. #ifdef AURORA_DEBUG
  2368. printk("aurora_init_drivers: endn");
  2369. #endif
  2370. return 0;
  2371. }
  2373. static void aurora_release_drivers(void)
  2374. {
  2375. #ifdef AURORA_DEBUG
  2376. printk("aurora_release_drivers: startn");
  2377. #endif
  2378. free_page((unsigned long)tmp_buf);
  2379. tty_unregister_driver(&aurora_driver);
  2380. #ifdef AURORA_DEBUG
  2381. printk("aurora_release_drivers: endn");
  2382. #endif
  2383. }
  2385. /*
  2386.  * Called at boot time.
  2387.  *
  2388.  * You can specify IO base for up to RC_NBOARD cards,
  2389.  * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
  2390.  * Note that there will be no probing at default
  2391.  * addresses in this case.
  2392.  *
  2393.  */
  2394. void __init aurora_setup(char *str, int *ints)
  2395. {
  2396. int i;
  2398. for(i=0;(i<ints[0])&&(i<4);i++) {
  2399. if (ints[i+1]) irqs[i]=ints[i+1];
  2400. }
  2401. }
  2403. static int __init aurora_real_init(void)
  2404. {
  2405. int found;
  2406. int i;
  2408. printk(KERN_INFO "aurora: Driver starting.n");
  2409. if(aurora_init_drivers())
  2410. return -EIO;
  2411. found = aurora_probe();
  2412. if(!found) {
  2413. aurora_release_drivers();
  2414. printk(KERN_INFO "aurora: No Aurora Multiport boards detected.n");
  2415. return -EIO;
  2416. } else {
  2417. printk(KERN_INFO "aurora: %d boards found.n", found);
  2418. }
  2419. for (i = 0; i < found; i++) {
  2420. int ret = aurora_setup_board(&aurora_board[i]);
  2422. if (ret) {
  2423. #ifdef AURORA_DEBUG
  2424. printk(KERN_ERR "aurora_init: error aurora_setup_board ret %dn",
  2425.        ret);
  2426. #endif
  2427. return ret;
  2428. }
  2429. }
  2430. return 0;
  2431. }
  2433. int irq  = 0;
  2434. int irq1 = 0;
  2435. int irq2 = 0;
  2436. int irq3 = 0;
  2437. MODULE_PARM(irq , "i");
  2438. MODULE_PARM(irq1, "i");
  2439. MODULE_PARM(irq2, "i");
  2440. MODULE_PARM(irq3, "i");
  2442. static int __init aurora_init(void) 
  2443. {
  2444. if (irq ) irqs[0]=irq ;
  2445. if (irq1) irqs[1]=irq1;
  2446. if (irq2) irqs[2]=irq2;
  2447. if (irq3) irqs[3]=irq3;
  2448. return aurora_real_init();
  2449. }
  2451. static void __exit aurora_cleanup(void)
  2452. {
  2453. int i;
  2455. #ifdef AURORA_DEBUG
  2456. printk("cleanup_module: aurora_release_driversn");
  2457. #endif
  2459. aurora_release_drivers();
  2460. for (i = 0; i < AURORA_NBOARD; i++)
  2461. if (aurora_board[i].flags & AURORA_BOARD_PRESENT) {
  2462. aurora_shutdown_board(&aurora_board[i]);
  2463. aurora_release_io_range(&aurora_board[i]);
  2464. }
  2465. }
  2467. module_init(aurora_init);
  2468. module_exit(aurora_cleanup);
  2469. MODULE_LICENSE("GPL");