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

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

Linux/Unix编程

开发平台：

Unix_Linux

sb1250_duart.c：源码内容
  1. /*
  2.  * Copyright (C) 2000, 2001 Broadcom Corporation
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  * 
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  20. /* 
  21.  * Driver support for the on-chip sb1250 dual-channel serial port,
  22.  * running in asynchronous mode.  Also, support for doing a serial console
  23.  * on one of those ports 
  24.  *
  25.  * The non-console part of this code is based heavily on the serial_21285.c
  26.  * driver also in this directory.  See tty_driver.h for a description of some
  27.  * of the driver functions, though it (like most of the inline code documentation :)
  28.  * is a bit out of date.  
  29.  */
  31. #include <linux/types.h>
  32. #include <linux/serial.h>
  33. #include <linux/module.h>
  34. #include <linux/console.h>
  35. #include <linux/kdev_t.h>
  36. #include <linux/major.h>
  37. #include <linux/termios.h>
  38. #include <linux/spinlock.h>
  39. #include <linux/irq.h>
  40. #include <linux/errno.h>
  41. #include <linux/tty.h>
  42. #include <linux/sched.h>
  43. #include <linux/tty_flip.h>
  44. #include <linux/timer.h>
  45. #include <linux/init.h>
  46. #include <asm/io.h>
  47. #include <asm/uaccess.h>
  48. #include <asm/sibyte/swarm.h>
  49. #include <asm/sibyte/sb1250.h>
  50. #include <asm/sibyte/sb1250_regs.h>
  51. #include <asm/sibyte/sb1250_uart.h>
  52. #include <asm/sibyte/sb1250_int.h>
  53. #include <asm/sibyte/64bit.h>
  55. /* Toggle spewing of debugging output */
  56. #undef DUART_SPEW
  58. #define DEFAULT_CFLAGS          (CS8 | B115200)
  61. /*
  62.   Still not sure what the termios structures set up here are for, 
  63.    but we have to supply pointers to them to register the tty driver
  64. */
  66. static struct tty_driver sb1250_duart_driver, sb1250_duart_callout_driver;
  67. static int ref_count;
  68. static struct tty_struct *duart_table[2];
  69. static struct termios    *duart_termios[2];
  70. static struct termios    *duart_termios_locked[2];
  72. /* This lock protects both the open flags for all the uart states as 
  73.    well as the reference count for the module */
  74. static spinlock_t          open_lock = SPIN_LOCK_UNLOCKED;
  76. /* Protect the writing stuff from contention */
  77. //static spinlock_t          console_lock = SPIN_LOCK_UNLOCKED;
  79. /* Bit fields of flags in the flags field below */
  81. #define SD_WRITE_WAKE       0x000000001
  84. typedef struct { 
  85. struct tty_struct   *tty;
  86. unsigned char       outp_buf[CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE];
  87. unsigned int        outp_head;
  88. unsigned int        outp_tail;
  89. unsigned int        outp_count;
  90. spinlock_t          outp_lock;
  91. unsigned int        outp_stopped;
  92. unsigned int        open;
  93. unsigned long       flags;
  94. unsigned int        last_cflags;
  95. } uart_state_t;
  97. static uart_state_t uart_states[2] = { [0 ... 1] = {
  98. tty:                0,
  99. outp_head:          0,
  100. outp_tail:          0,
  101. outp_lock:          SPIN_LOCK_UNLOCKED,
  102. outp_count:         0,
  103. open:               0,
  104. flags:              0,
  105. last_cflags:        0,
  106. }};
  108. /*
  109.  * Inline functions local to this module 
  110.  */
  113. /*
  114.  * Mask out the passed interrupt lines at the duart level.  This should be
  115.  * called while holding the associated outp_lock.
  116.  */
  117. static inline void duart_mask_ints(unsigned int line, unsigned int mask)
  118. {
  119. u64 tmp;
  120. tmp = in64(IO_SPACE_BASE | A_DUART_IMRREG(line));
  121. tmp &= ~mask;
  122. out64(tmp, IO_SPACE_BASE | A_DUART_IMRREG(line));
  123. }
  126. /* Unmask the passed interrupt lines at the duart level */
  127. static inline void duart_unmask_ints(unsigned int line, unsigned int mask)
  128. {
  129. u64 tmp;
  130. tmp = in64(IO_SPACE_BASE | A_DUART_IMRREG(line));
  131. tmp |= mask;
  132. out64(tmp, IO_SPACE_BASE | A_DUART_IMRREG(line));
  133. }
  135. static inline unsigned long get_status_reg(unsigned int line)
  136. {
  137. return in64(IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_STATUS));
  138. }
  140. /* Derive which uart a call is for from the passed tty line.  */
  141. static inline unsigned int get_line(struct tty_struct *tty) 
  142. {
  143. unsigned int line = MINOR(tty->device) - 64;
  144. if (line > 1)
  145. printk(KERN_CRIT "Invalid linen");
  147. return line;
  148. }
  152. #define MIN(a, b) (((a)<(b))?(a):(b))
  154. /* 
  155.  * Generic interrupt handler for both channels.  dev_id is a pointer
  156.  * to the proper uart_states structure, so from that we can derive 
  157.  * which port interrupted 
  158.  */
  160. static void duart_int(int irq, void *dev_id, struct pt_regs *regs)
  161. {
  162. unsigned int line;
  163. uart_state_t *us = (uart_state_t *)dev_id;
  164. line = us-uart_states;
  165. #ifdef DUART_SPEW
  166. // setleds("INT!");
  167.         printk("DUART INTn");
  168. #endif
  169. /* We could query the ISR to figure out why we are here, but since
  170.    we are here, we may as well just take care of both rx and tx */
  171. spin_lock(&us->outp_lock);
  172. if (get_status_reg(line) & M_DUART_RX_RDY) {
  173. do {
  174. unsigned int status = get_status_reg(line);
  175. unsigned int ch = in64(IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_RX_HOLD));
  176. unsigned int flag = 0;
  177. if (status & 0x10) {
  178. tty_insert_flip_char(us->tty, 0, TTY_OVERRUN); }
  179. if (status & 0x20) {
  180. printk("Parity error!n");
  181. flag = TTY_PARITY;
  182. } else if (status & 0x40) {
  183. printk("Frame error!n");
  184. flag = TTY_FRAME;
  185. }
  186. tty_insert_flip_char(us->tty, ch, flag);
  187. } while (get_status_reg(line) & M_DUART_RX_RDY);
  188. tty_flip_buffer_push(us->tty);
  189. } 
  190. if ((get_status_reg(line) & M_DUART_TX_RDY) && us->outp_count) {
  191. do {
  192. out64(us->outp_buf[us->outp_head], IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_TX_HOLD));
  193. us->outp_head = (us->outp_head + 1) & (CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE-1);
  194. us->outp_count--;
  195. } while ((get_status_reg(line) & M_DUART_TX_RDY) && us->outp_count);
  197. if (us->open && (us->flags & SD_WRITE_WAKE) &&
  198.     (us->outp_count < (CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE/2))) {
  199. /* We told the discipline at one point that we had no space, so it went
  200.    to sleep.  Wake it up when we hit half empty */
  201. wake_up_interruptible(&us->tty->write_wait);
  202. }
  203. if (!us->outp_count) {
  204. duart_mask_ints(line, M_DUART_IMR_TX);
  205. }
  206. }
  207. spin_unlock(&us->outp_lock);
  208. }
  210. /*
  211.  *  Actual driver functions
  212.  */
  214. /* Return the number of characters we can accomodate in a write at this instant */
  215. static int duart_write_room(struct tty_struct *tty)
  216. {
  217. unsigned long flags;
  218. int retval;
  219. uart_state_t *us = &uart_states[get_line(tty)];
  221. spin_lock_irqsave(&us->outp_lock, flags);
  222. retval = CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE - uart_states[get_line(tty)].outp_count;
  223. if (!retval) {
  224. us->flags |= SD_WRITE_WAKE;
  225. }
  226. spin_unlock_irqrestore(&us->outp_lock, flags);
  227. #ifdef DUART_SPEW
  228. printk("duart_write_room called, returning %in", retval);
  229. #endif
  230. return retval;
  231. }
  233. /* memcpy the data from src to destination, but take extra care if the
  234.    data is coming from user space */
  235. static inline int copy_buf(char *dest, const char *src, int size, int from_user) 
  236. {
  237. if (from_user) {
  238. (void) copy_from_user(dest, src, size); 
  239. } else {
  240. memcpy(dest, src, size);
  241. }
  242. return size;
  243. }
  245. /* Buffer up to count characters from buf to be written.  If we don't have other
  246.    characters buffered, enable the tx interrupt to start sending */
  247. static int duart_write(struct tty_struct * tty, int from_user,
  248.       const unsigned char *buf, int count)
  249. {
  250. uart_state_t *us;
  251. unsigned long flags;
  252. unsigned int line;
  253. int chars_written = 0;
  254. if (from_user && verify_area(VERIFY_READ, buf, count)) {
  255. return -EINVAL;
  256. }
  257. #ifdef DUART_SPEW
  258. printk("duart_write called for %i chars by %i (%s)n", count, current->pid, current->comm);
  259. #endif
  260. line = get_line(tty);
  261. us = &uart_states[line];
  262. spin_lock_irqsave(&us->outp_lock, flags);
  263. if (!count || (us->outp_count == CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE)) {
  264. spin_unlock_irqrestore(&us->outp_lock, flags);
  265. return 0;
  266. }
  267. if (us->outp_tail < us->outp_head) {
  268. /* Straightforward case; copy from tail to head */
  269. chars_written += copy_buf(us->outp_buf + us->outp_tail, buf, 
  270.   MIN(count, us->outp_head - us->outp_tail), from_user);
  271. } else {
  272. /* Copy from tail to end of buffer, wrap around and then
  273.    copy to head */
  274. chars_written += copy_buf(us->outp_buf + us->outp_tail, buf, 
  275.   MIN(CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE - us->outp_tail, count), 
  276.   from_user);
  277. if (chars_written < count) {
  278. chars_written += copy_buf(us->outp_buf, buf + chars_written,
  279.   MIN(us->outp_head, count - chars_written), from_user);
  280. }
  281. }
  282. us->outp_tail = (us->outp_tail + chars_written) &(CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE-1);
  283. if (!(us->outp_count || us->outp_stopped)) {
  284. duart_unmask_ints(line, M_DUART_IMR_TX);
  285. }
  286. us->outp_count += chars_written;
  287. spin_unlock_irqrestore(&us->outp_lock, flags);
  288. return chars_written;
  289. }
  292. /* Buffer one character to be written.  If there's not room for it, just drop
  293.    it on the floor.  This is used for echo, among other things */
  294. static void duart_put_char(struct tty_struct *tty, u_char ch)
  295. {
  296. unsigned long flags;
  297. unsigned int line = get_line(tty);
  298. uart_state_t *us = &uart_states[line];
  299. #ifdef DUART_SPEW
  300. printk("duart_put_char called.  Char is %x (%c)n", (int)ch, ch);
  301. #endif
  302. spin_lock_irqsave(&us->outp_lock, flags);
  303. if (us->outp_count != CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE) {
  304. us->outp_buf[us->outp_tail] = ch;
  305. us->outp_tail = (us->outp_tail + 1) &(CONFIG_SB1250_DUART_OUTPUT_BUF_SIZE-1);
  306. if (!(us->outp_count || us->outp_stopped)) {
  307. duart_unmask_ints(line, M_DUART_IMR_TX);
  308. }
  309. us->outp_count++;
  310. }
  311. spin_unlock_irqrestore(&us->outp_lock, flags);
  312. }
  314. /* Return the number of characters in the output buffer that have yet to be 
  315.    written */
  316. static int duart_chars_in_buffer(struct tty_struct *tty)
  317. {
  318. int retval;
  319. unsigned long flags;
  320. uart_state_t *us = &uart_states[get_line(tty)];
  321. spin_lock_irqsave(&us->outp_lock, flags);
  322. retval = us->outp_count;
  323. if (retval) {
  324. us->flags |= SD_WRITE_WAKE;
  325. }
  326. spin_unlock_irqrestore(&us->outp_lock, flags);
  327. #ifdef DUART_SPEW
  328. printk("duart_chars_in_buffer returning %in", retval);
  329. #endif
  330. return retval;
  331. }
  333. /* Kill everything we haven't yet shoved into the FIFO.  Turn off the
  334.    transmit interrupt since we've nothing more to transmit */
  335. static void duart_flush_buffer(struct tty_struct *tty)
  336. {
  337. unsigned long flags;
  338. unsigned int line = get_line(tty);
  339. uart_state_t *us = &uart_states[get_line(tty)];
  340. #ifdef DUART_SPEW
  341. printk("duart_flush_buffer calledn");
  342. #endif
  343. duart_mask_ints(line, M_DUART_IMR_TX);
  344. spin_lock_irqsave(&us->outp_lock, flags);
  345. us->outp_head = us->outp_tail = us->outp_count = 0;
  346. if (us->flags & SD_WRITE_WAKE) {
  347. wake_up_interruptible(&us->tty->write_wait);
  348. }
  349. spin_unlock_irqrestore(&us->outp_lock, flags);
  350. }
  353. /* See sb1250 user manual for details on these registers */
  354. static inline void duart_set_cflag(unsigned int line, unsigned int cflag)
  355. {
  356. unsigned int mode_reg1 = 0, mode_reg2 = 0;
  357. unsigned int clk_divisor;
  358. switch (cflag & CSIZE) {
  359. case CS7:
  360. mode_reg1 |= V_DUART_BITS_PER_CHAR_7;
  362. default:
  363. /* We don't handle CS5 or CS6...is there a way we're supposed to flag this? 
  364.    right now we just force them to CS8 */
  365. mode_reg1 |= 0x0;
  366. break;
  367. }
  368. if (cflag & CSTOPB) {
  369.         mode_reg2 |= M_DUART_STOP_BIT_LEN_2; /* XXX was: 0x4; */
  370. }
  371. if (!(cflag & PARENB)) {
  372.         mode_reg1 |= V_DUART_PARITY_MODE_NONE; /* XXX was: 0x8; */
  373. }
  374. if (cflag & PARODD) {
  375. mode_reg1 |= M_DUART_PARITY_TYPE_ODD;
  376. }
  378. /* Formula for this is (5000000/baud)-1, but we saturate
  379.    at 12 bits, which means we can't actually do anything less
  380.    that 1200 baud */
  381. switch (cflag & CBAUD) {
  382. case B200:
  383. case B300:
  384. case B1200: clk_divisor = 4095; break;
  385. case B1800: clk_divisor = 2776; break;
  386. case B2400: clk_divisor = 2082; break;
  387. case B4800: clk_divisor = 1040; break;
  388. default:
  389. case B9600: clk_divisor = 519; break;
  390. case B19200: clk_divisor = 259; break;
  391. case B38400: clk_divisor = 129; break;
  392. case B57600: clk_divisor = 85; break;
  393. case B115200: clk_divisor = 42; break;
  394. }
  395. out64(mode_reg1, IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_MODE_REG_1));
  396. out64(mode_reg2, IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_MODE_REG_2));
  397. out64(clk_divisor, IO_SPACE_BASE | A_DUART_CHANREG(line, R_DUART_CLK_SEL));
  398. uart_states[line].last_cflags = cflag;
  399. }
  402. /* Handle notification of a termios change.  */
  403. static void duart_set_termios(struct tty_struct *tty, struct termios *old)
  404. {
  405. #ifdef DUART_SPEW 
  406. printk("duart_set_termios called by %i (%s)n", current->pid, current->comm);
  407. #endif
  408. if (old && tty->termios->c_cflag == old->c_cflag)
  409. return;
  410. duart_set_cflag(get_line(tty), tty->termios->c_cflag);
  411. }
  413. /* Stop pushing stuff into the fifo, now.  Do the mask under the 
  414.    outp_lock to avoid races involving turning the interrupt line on/off */
  415. static void duart_stop(struct tty_struct *tty)
  416. {
  417. unsigned long flags;
  418. unsigned int line = get_line(tty);
  419. uart_state_t *us = &uart_states[line];
  420. #ifdef DUART_SPEW
  421. printk("duart_stop calledn");
  422. #endif
  423. spin_lock_irqsave(&us->outp_lock, flags);
  424. duart_mask_ints(get_line(tty), M_DUART_IMR_TX);
  425. us->outp_stopped = 1;
  426. spin_unlock_irqrestore(&us->outp_lock, flags);
  427. }
  429. static int duart_ioctl(struct tty_struct *tty, struct file * file,
  430.        unsigned int cmd, unsigned long arg)
  431. {
  432. /* if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  433. return -ENODEV;*/
  434. switch (cmd) {
  435. case TIOCMGET:
  436. printk("Ignoring TIOCMGETn");
  437. break;
  438. case TIOCMBIS:
  439. printk("Ignoring TIOCMBISn");
  440. break;
  441. case TIOCMBIC:
  442. printk("Ignoring TIOCMBICn");
  443. break;
  444. case TIOCMSET:
  445. printk("Ignoring TIOCMSETn");
  446. break;
  447. case TIOCGSERIAL:
  448. printk("Ignoring TIOCGSERIALn");
  449. break;
  450. case TIOCSSERIAL:
  451. printk("Ignoring TIOCSSERIALn");
  452. break;
  453. case TIOCSERCONFIG:
  454. printk("Ignoring TIOCSERCONFIGn");
  455. break;
  456. case TIOCSERGETLSR: /* Get line status register */
  457. printk("Ignoring TIOCSERGETLSRn");
  458. break;
  459. case TIOCSERGSTRUCT:
  460. printk("Ignoring TIOCSERGSTRUCTn");
  461. break;
  462. case TIOCMIWAIT:
  463. printk("Ignoring TIOCMIWAITn");
  464. break;
  465. case TIOCGICOUNT:
  466. printk("Ignoring TIOCGICOUNTn");
  467. break;
  468. case TIOCSERGWILD:
  469. printk("Ignoring TIOCSERGWILDn");
  470. break;
  471. case TIOCSERSWILD:
  472. printk("Ignoring TIOCSERSWILDn");
  473. break;
  474. default:
  475. break;
  476. }
  477. // printk("Ignoring IOCTL %x from pid %i (%s)n", cmd, current->pid, current->comm);
  478. return -ENOIOCTLCMD;
  479. #if 0
  480. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  481.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
  482.     (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
  483. if (tty->flags & (1 << TTY_IO_ERROR))
  484. return -EIO;
  485. }
  487. switch (cmd) {
  488. case TIOCMGET:
  489. case TIOCMBIS:
  490. case TIOCMBIC:
  491. case TIOCMSET:
  492. case TIOCGSERIAL:
  493. case TIOCSSERIAL:
  494. case TIOCSERCONFIG:
  495. case TIOCSERGETLSR: /* Get line status register */
  496. case TIOCSERGSTRUCT:
  497. case TIOCMIWAIT:
  498. case TIOCGICOUNT:
  499. case TIOCSERGWILD:
  500. case TIOCSERSWILD:
  501. /* XXX Implement me! */
  502. printk("IOCTL needs implementing: %xn", cmd);
  504. default:
  505. printk("Unknown ioctl: %xn", cmd);
  506. }
  507. #endif
  508. return 0;
  509. }
  511. /* Stop pushing stuff into the fifo, now.  Do the mask under the 
  512.    outp_lock to avoid races involving turning the interrupt line on/off */
  513. static void duart_start(struct tty_struct *tty)
  514. {
  515. unsigned long flags;
  516. unsigned int line = get_line(tty);
  517. uart_state_t *us = &uart_states[line];
  518. #ifdef DUART_SPEW
  519. printk("duart_start calledn");
  520. #endif
  521. spin_lock_irqsave(&us->outp_lock, flags);
  522. if (us->outp_count) {
  523. duart_unmask_ints(get_line(tty), M_DUART_IMR_TX);
  524. }
  525. us->outp_stopped = 0;
  526. spin_unlock_irqrestore(&us->outp_lock, flags);
  527. }
  529. /* Not sure on the semantics of this; are we supposed to wait until the stuff
  530.    already in the hardware FIFO drains, or are we supposed to wait until 
  531.    we've drained the output buffer, too?  I'm assuming the former, 'cause thats
  532.    what the other drivers seem to assume 
  533. */
  535. static void duart_wait_until_sent(struct tty_struct *tty, int timeout)
  536. {
  537. unsigned long target_time;
  538. unsigned int line;
  539. uart_state_t *us;
  540. #ifdef DUART_SPEW
  541. printk("duart_wait_until_sent(%d)+n", timeout);
  542. #endif
  543. target_time = jiffies + timeout;
  544. line = get_line(tty);
  545. us = &uart_states[line];
  546. while (!(get_status_reg(line) & M_DUART_TX_EMT) && (jiffies < target_time)) {
  547.   schedule_timeout(1);
  548. }
  549. #ifdef DUART_SPEW
  550. printk("duart_wait_until_sent()-n");
  551. #endif
  552. }
  554. /*
  555.  * Open a tty line.  Note that this can be called multiple times, so ->open can
  556.  * be >1.  Only set up the tty struct if this is a "new" open, e.g. ->open was
  557.  * zero
  558.  */
  559. static int duart_open(struct tty_struct *tty, struct file *filp)
  560. {
  561. unsigned long flags;
  562. unsigned int line;
  563. uart_state_t *us;
  565. MOD_INC_USE_COUNT;
  566. #ifndef CONFIG_SIBYTE_SB1250_DUART_NO_PORT_1
  567. if (get_line(tty) > 1)
  568. #else
  569. if (get_line(tty) > 0)
  570. #endif
  571.                       {
  572. MOD_DEC_USE_COUNT;
  573. return -ENODEV;
  574. }
  575. #ifdef DUART_SPEW
  576. printk("duart_open called by %i (%s), tty is %p, rw is %p, ww is %pn", current->pid, current->comm, tty,
  577.        tty->read_wait, tty->write_wait);
  578. #endif
  579. line = get_line(tty);
  580. tty->driver_data = NULL;
  581. us = &uart_states[line];
  583. spin_lock_irqsave(&open_lock, flags);
  584. if (!us->open) {
  585. us->tty = tty;
  586. us->tty->termios->c_cflag = us->last_cflags;
  587. }
  588. us->open++;
  589. #ifdef FORCED_INPUT
  590. if (!line && (us->open == 1)) {
  591. next_inp = inp_cmds;
  592. init_timer(&inp_timer);
  593. inp_timer.expires = jiffies + 20;
  594. inp_timer.data = 0;
  595. inp_timer.function = stuff_char;
  596. stuff_char_tty = tty;
  597. add_timer(&inp_timer);
  598. }
  599. #endif
  600. duart_unmask_ints(line, M_DUART_IMR_RX);
  601. spin_unlock_irqrestore(&open_lock, flags);
  602. return 0;
  603. }
  606. /*
  607.  * Close a reference count out.  If reference count hits zero, null the
  608.  * tty, kill the interrupts.  The tty_io driver is responsible for making
  609.  * sure we've cleared out our internal buffers before calling close()
  610.  */
  611. static void duart_close(struct tty_struct *tty, struct file *filp)
  612. {
  613. unsigned long flags;
  614. unsigned int line = get_line(tty);
  615. uart_state_t *us = &uart_states[line];
  616. #ifdef DUART_SPEW
  617. printk("duart_close called by %i (%s)n", current->pid, current->comm);
  618. #endif
  619. spin_lock_irqsave(&open_lock, flags);
  620. us->open--;
  621. #if 0
  622. if (!us->open) {
  623. /* Flushing TX stuff here is conservative */
  624. duart_mask_ints(line, M_DUART_IMR_IN | M_DUART_IMR_BRK | M_DUART_IMR_RX | M_DUART_IMR_TX);
  625. spin_lock(&us->outp_lock);
  626. us->outp_head = us->outp_tail = us->outp_count = us->outp_stopped = 0;
  627. us->tty = NULL;
  628. spin_unlock(&us->outp_lock);
  629. }
  630. #endif
  631. ref_count--;
  632. spin_unlock_irqrestore(&open_lock, flags);
  633. MOD_DEC_USE_COUNT;
  634. }
  637. /* Set up the driver and register it, register the 2 1250 UART interrupts.  This
  638.    is called from tty_init, or as a part of the module init */
  639. static int __init sb1250_duart_init(void) 
  640. {
  641. sb1250_duart_driver.magic            = TTY_DRIVER_MAGIC;
  642. sb1250_duart_driver.driver_name      = "serial";
  643. #ifdef CONFIG_DEVFS_FS
  644. sb1250_duart_driver.name             = "tts/%d";
  645. #else
  646. sb1250_duart_driver.name             = "ttyS";
  647. #endif
  648. sb1250_duart_driver.major            = TTY_MAJOR;
  649. sb1250_duart_driver.minor_start      = 64;
  650. sb1250_duart_driver.num              = 2;
  651. sb1250_duart_driver.type             = TTY_DRIVER_TYPE_SERIAL;
  652. sb1250_duart_driver.subtype          = SERIAL_TYPE_NORMAL;
  653. sb1250_duart_driver.init_termios     = tty_std_termios;
  654. sb1250_duart_driver.flags            = TTY_DRIVER_REAL_RAW;
  655. sb1250_duart_driver.refcount         = &ref_count;
  656. sb1250_duart_driver.table            = duart_table;
  657. sb1250_duart_driver.termios          = duart_termios;
  658. sb1250_duart_driver.termios_locked   = duart_termios_locked;
  660. sb1250_duart_driver.open             = duart_open;
  661. sb1250_duart_driver.close            = duart_close;
  662. sb1250_duart_driver.write            = duart_write;
  663. sb1250_duart_driver.put_char         = duart_put_char;
  664. sb1250_duart_driver.write_room       = duart_write_room;
  665. sb1250_duart_driver.chars_in_buffer  = duart_chars_in_buffer;
  666. sb1250_duart_driver.flush_buffer     = duart_flush_buffer;
  667. sb1250_duart_driver.ioctl            = duart_ioctl;
  668. sb1250_duart_driver.set_termios      = duart_set_termios;
  669. sb1250_duart_driver.stop             = duart_stop;
  670. sb1250_duart_driver.start            = duart_start;
  671. sb1250_duart_driver.wait_until_sent  = duart_wait_until_sent;
  673. sb1250_duart_callout_driver          = sb1250_duart_driver;
  674. #ifdef CONFIG_DEVFS_FS
  675. sb1250_duart_callout_driver.name     = "cua/%d";
  676. #else
  677. sb1250_duart_callout_driver.name     = "cua";
  678. #endif
  679. sb1250_duart_callout_driver.major    = TTYAUX_MAJOR;
  680. sb1250_duart_callout_driver.subtype  = SERIAL_TYPE_CALLOUT;
  682. duart_mask_ints(0, 0xf);
  683. if (request_irq(K_INT_UART_0, duart_int, 0, "uart0", &uart_states[0])) {
  684. panic("Couldn't get uart0 interrupt line");
  685. }
  686. #ifndef CONFIG_SIBYTE_SB1250_DUART_NO_PORT_1
  687. duart_mask_ints(1, 0xf);
  688. if (request_irq(K_INT_UART_1, duart_int, 0, "uart1", &uart_states[1])) {
  689. panic("Couldn't get uart1 interrupt line");
  690. }
  691. #endif
  693. /* Interrupts are now active, our ISR can be called. */
  695. if (tty_register_driver(&sb1250_duart_driver)) {
  696. printk(KERN_ERR "Couldn't register sb1250 duart serial drivern");
  697. }
  698. if (tty_register_driver(&sb1250_duart_callout_driver)) {
  699. printk(KERN_ERR "Couldn't register sb1250 duart callout drivern");
  700. }
  701. duart_set_cflag(0, DEFAULT_CFLAGS);
  702. #ifndef CONFIG_SIBYTE_SB1250_DUART_NO_PORT_1
  703. duart_set_cflag(1, DEFAULT_CFLAGS);
  704. #endif
  705. return 0;
  706. }
  708. /* Unload the driver.  Unregister stuff, get ready to go away */
  709. static void __exit sb1250_duart_fini(void)
  710. {
  711. unsigned long flags;
  712. int ret;
  714. save_flags(flags);
  715. cli();
  716. ret = tty_unregister_driver(&sb1250_duart_callout_driver);
  717. if (ret) {
  718. printk(KERN_ERR "Unable to unregister sb1250 duart callout driver (%d)n", ret);
  719. }
  720. ret = tty_unregister_driver(&sb1250_duart_driver);
  721. if (ret) {
  722. printk(KERN_ERR "Unable to unregister sb1250 duart serial driver (%d)n", ret);
  723. }
  724. free_irq(K_INT_UART_0, &uart_states[0]);
  725. free_irq(K_INT_UART_1, &uart_states[1]);
  727. /* mask lines in the scd */
  728. disable_irq(K_INT_UART_0);
  729. disable_irq(K_INT_UART_1);
  731. restore_flags(flags);
  732. }
  734. module_init(sb1250_duart_init);
  735. module_exit(sb1250_duart_fini);
  736. MODULE_DESCRIPTION("SB1250 Duart serial driver");
  737. MODULE_AUTHOR("Justin Carlson <carlson@sibyte.com>");
  739. #ifdef CONFIG_SERIAL_CONSOLE
  741. /*
  742.  * Serial console stuff. 
  743.  * Very basic, polling driver for doing serial console output. 
  744.  * FIXME; there is a race here; we can't be sure that
  745.  * the tx is still empty without holding outp_lock for this line.
  746.  * Worst that can happen for now, though, is dropped characters.
  747.  */
  749. static void ser_console_write(struct console *cons, const char *str,
  750.                               unsigned int count)
  751. {
  752. unsigned int i;
  753. unsigned long flags;
  754. spin_lock_irqsave(&uart_states[0].outp_lock, flags);
  756. for (i = 0; i < count; i++) {
  757.                 if (str[i] == 'n') {
  758.                         /* Expand LF -> CRLF */
  759.                         while (!(get_status_reg(0) & M_DUART_TX_RDY)) {
  760.                                 /* Spin, doing nothing.  */
  761.                         }
  762. out64('r', IO_SPACE_BASE | A_DUART_CHANREG(0, R_DUART_TX_HOLD));
  763.                 }
  764. while (!(get_status_reg(0) & M_DUART_TX_RDY)) {
  765. /* Spin, doing nothing.  */
  766. }
  767. out64(str[i], IO_SPACE_BASE | A_DUART_CHANREG(0, R_DUART_TX_HOLD));
  768. }
  769. spin_unlock_irqrestore(&uart_states[0].outp_lock, flags);
  770. }
  772. static kdev_t ser_console_device(struct console *c)
  773. {
  774. return MKDEV(TTY_MAJOR, 64 + c->index);
  775. }
  777. static int ser_console_setup(struct console *cons, char *str)
  778. {
  779. /* Initialize the transmitter */
  781. duart_set_cflag(0, DEFAULT_CFLAGS);
  782. return 0;
  783. }
  785. static struct console sb1250_ser_cons = {
  786. name: "ttyS",
  787. write: ser_console_write,
  788. device: ser_console_device,
  789. setup: ser_console_setup,
  790. flags: CON_PRINTBUFFER,
  791. index: -1,
  792. };
  794. void __init sb1250_serial_console_init(void)
  795. {
  796. register_console(&sb1250_ser_cons);
  797. }
  799. #endif /* CONFIG_SERIAL_CONSOLE */