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

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

嵌入式Linux

开发平台：

Unix_Linux

pcxx.c：源码内容
  1. /*
  2.  *  linux/drivers/char/pcxx.c
  3.  * 
  4.  *  Written by Troy De Jongh, November, 1994
  5.  *
  6.  *  Copyright (C) 1994,1995 Troy De Jongh
  7.  *  This software may be used and distributed according to the terms 
  8.  *  of the GNU General Public License.
  9.  *
  10.  *  This driver is for the DigiBoard PC/Xe and PC/Xi line of products.
  11.  *
  12.  *  This driver does NOT support DigiBoard's fastcook FEP option and
  13.  *  does not support the transparent print (i.e. digiprint) option.
  14.  *
  15.  * This Driver is currently maintained by Christoph Lameter (christoph@lameter.com)
  16.  *
  17.  * Please contact digi for support issues at digilnux@dgii.com.
  18.  * Some more information can be found at
  19.  * http://lameter.com/digi.
  20.  *
  21.  *  1.5.2 Fall 1995 Bug fixes by David Nugent
  22.  *  1.5.3 March 9, 1996 Christoph Lameter: Fixed 115.2K Support. Memory
  23.  * allocation harmonized with 1.3.X Series.
  24.  *  1.5.4 March 30, 1996 Christoph Lameter: Fixup for 1.3.81. Use init_bh
  25.  * instead of direct assignment to kernel arrays.
  26.  *  1.5.5 April 5, 1996 Major device numbers corrected.
  27.  *              Mike McLagan<mike.mclagan@linux.org>: Add setup
  28.  *              variable handling, instead of using the old pcxxconfig.h
  29.  *  1.5.6 April 16, 1996 Christoph Lameter: Pointer cleanup, macro cleanup.
  30.  * Call out devices changed to /dev/cudxx.
  31.  *  1.5.7 July 22, 1996 Martin Mares: CLOCAL fix, pcxe_table clearing.
  32.  * David Nugent: Bug in pcxe_open.
  33.  * Brian J. Murrell: Modem Control fixes, Majors correctly assigned
  34.  *  1.6.1 April 6, 1997 Bernhard Kaindl: fixed virtual memory access for 2.1
  35.  *              i386-kernels and use on other archtitectures, Allowing use
  36.  *              as module, added module parameters, added switch to enable
  37.  *              verbose messages to assist user during card configuration.
  38.  *              Currently only tested on a PC/Xi card, but should work on Xe
  39.  *              and Xeve also.
  40.  *  1.6.2 August, 7, 2000: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  41.  *   get rid of panics, release previously allocated resources
  42.  *  1.6.3 August, 23, 2000: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  43.  *   cleaned up wrt verify_area.
  44.  *              Christoph Lameter: Update documentation, email addresses
  45.  *              and URLs. Remove some obsolete code.
  46.  *
  47.  */
  49. #include <linux/module.h>
  50. #include <linux/mm.h>
  51. #include <linux/ioport.h>
  52. #include <linux/errno.h>
  53. #include <linux/signal.h>
  54. #include <linux/sched.h>
  55. #include <linux/timer.h>
  56. #include <linux/interrupt.h>
  57. #include <linux/tty.h>
  58. #include <linux/tty_flip.h>
  59. #include <linux/major.h>
  60. #include <linux/string.h>
  61. #include <linux/fcntl.h>
  62. #include <linux/ptrace.h>
  63. #include <linux/delay.h>
  64. #include <linux/serial.h>
  65. #include <linux/tty_driver.h>
  66. #include <linux/slab.h>
  67. #include <linux/init.h>
  68. #include <linux/version.h>
  70. #ifndef MODULE
  71. #include <linux/ctype.h> /* We only need it for parsing the "digi="-line */
  72. #endif
  74. #include <asm/system.h>
  75. #include <asm/io.h>
  76. #include <asm/uaccess.h>
  77. #include <asm/bitops.h>
  78. #include <asm/semaphore.h>
  80. #define VERSION  "1.6.3"
  82. #include "digi.h"
  83. #include "fep.h"
  84. #include "pcxx.h"
  85. #include "digi_fep.h"
  86. #include "digi_bios.h"
  88. /*
  89.  * Define one default setting if no digi= config line is used.
  90.  * Default is altpin = disabled, 16 ports, I/O 200h, Memory 0D0000h
  91.  */
  92. static struct board_info boards[MAX_DIGI_BOARDS] = { {
  93. /* Board is enabled       */ ENABLED,
  94. /* Type is auto-detected  */ 0,
  95. /* altping is disabled    */    DISABLED,
  96. /* number of ports = 16   */ 16,
  97. /* io address is 0x200    */ 0x200,
  98. /* card memory at 0xd0000 */ 0xd0000,
  99. /* first minor device no. */ 0
  100. } };
  101.  
  102. static int verbose = 0;
  103. static int debug   = 0;
  105. #ifdef MODULE
  106. /* Variables for insmod */
  107. static int io[]           = {0, 0, 0, 0};
  108. static int membase[]      = {0, 0, 0, 0};
  109. static int memsize[]      = {0, 0, 0, 0};
  110. static int altpin[]       = {0, 0, 0, 0};
  111. static int numports[]     = {0, 0, 0, 0};
  113. # if (LINUX_VERSION_CODE > 0x020111)
  114. MODULE_AUTHOR("Bernhard Kaindl");
  115. MODULE_DESCRIPTION("Digiboard PC/X{i,e,eve} driver");
  116. MODULE_LICENSE("GPL");
  117. MODULE_PARM(verbose,     "i");
  118. MODULE_PARM(debug,       "i");
  119. MODULE_PARM(io,          "1-4i");
  120. MODULE_PARM(membase,     "1-4i");
  121. MODULE_PARM(memsize,     "1-4i");
  122. MODULE_PARM(altpin,      "1-4i");
  123. MODULE_PARM(numports,    "1-4i");
  124. # endif
  126. #endif MODULE
  128. static int numcards = 1;
  129. static int nbdevs = 0;
  130.  
  131. static struct channel    *digi_channels;
  132. static struct tty_struct **pcxe_table;
  133. static struct termios    **pcxe_termios;
  134. static struct termios    **pcxe_termios_locked;
  135.  
  136. int pcxx_ncook=sizeof(pcxx_cook);
  137. int pcxx_nbios=sizeof(pcxx_bios);
  139. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  140. #define pcxxassert(x, msg)  if(!(x)) pcxx_error(__LINE__, msg)
  142. #define FEPTIMEOUT 200000  
  143. #define SERIAL_TYPE_NORMAL 1
  144. #define SERIAL_TYPE_CALLOUT 2
  145. #define PCXE_EVENT_HANGUP   1
  147. struct tty_driver pcxe_driver;
  148. struct tty_driver pcxe_callout;
  149. static int pcxe_refcount;
  151. static struct timer_list pcxx_timer;
  153. DECLARE_TASK_QUEUE(tq_pcxx);
  155. static void pcxxpoll(unsigned long dummy);
  156. static void pcxxdelay(int);
  157. static void fepcmd(struct channel *, int, int, int, int, int);
  158. static void pcxe_put_char(struct tty_struct *, unsigned char);
  159. static void pcxe_flush_chars(struct tty_struct *);
  160. static void pcxx_error(int, char *);
  161. static void pcxe_close(struct tty_struct *, struct file *);
  162. static int pcxe_ioctl(struct tty_struct *, struct file *, unsigned int, unsigned long);
  163. static void pcxe_set_termios(struct tty_struct *, struct termios *);
  164. static int pcxe_write(struct tty_struct *, int, const unsigned char *, int);
  165. static int pcxe_write_room(struct tty_struct *);
  166. static int pcxe_chars_in_buffer(struct tty_struct *);
  167. static void pcxe_flush_buffer(struct tty_struct *);
  168. static void doevent(int);
  169. static void receive_data(struct channel *);
  170. static void pcxxparam(struct tty_struct *, struct channel *ch);
  171. static void do_softint(void *);
  172. static inline void pcxe_sched_event(struct channel *, int);
  173. static void do_pcxe_bh(void);
  174. static void pcxe_start(struct tty_struct *);
  175. static void pcxe_stop(struct tty_struct *);
  176. static void pcxe_throttle(struct tty_struct *);
  177. static void pcxe_unthrottle(struct tty_struct *);
  178. static void digi_send_break(struct channel *ch, int msec);
  179. static void shutdown(struct channel *);
  180. static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
  181. static inline void memwinon(struct board_info *b, unsigned int win);
  182. static inline void memwinoff(struct board_info *b, unsigned int win);
  183. static inline void globalwinon(struct channel *ch);
  184. static inline void rxwinon(struct channel *ch);
  185. static inline void txwinon(struct channel *ch);
  186. static inline void memoff(struct channel *ch);
  187. static inline void assertgwinon(struct channel *ch);
  188. static inline void assertmemoff(struct channel *ch);
  190. #define TZ_BUFSZ 4096
  192. /* function definitions */
  194. /*****************************************************************************/
  196. static void cleanup_board_resources(void)
  197. {
  198. int crd, i;
  199. struct board_info *bd;
  200. struct channel *ch;
  202.         for(crd = 0; crd < numcards; crd++) {
  203.                 bd = &boards[crd];
  204. ch = digi_channels + bd->first_minor;
  206. if (bd->region)
  207. release_region(bd->port, 4);
  209. for(i = 0; i < bd->numports; i++, ch++)
  210. if (ch->tmp_buf)
  211. kfree(ch->tmp_buf);
  212. }
  213. }
  215. /*****************************************************************************/
  217. #ifdef MODULE
  219. /*
  220.  * pcxe_init() is our init_module():
  221.  */
  222. #define pcxe_init init_module
  224. void cleanup_module(void);
  227. /*****************************************************************************/
  229. void cleanup_module()
  230. {
  232. unsigned long flags;
  233. int e1, e2;
  235. printk(KERN_NOTICE "Unloading PC/Xx version %sn", VERSION);
  237. save_flags(flags);
  238. cli();
  239. del_timer_sync(&pcxx_timer);
  240. remove_bh(DIGI_BH);
  242. if ((e1 = tty_unregister_driver(&pcxe_driver)))
  243. printk("SERIAL: failed to unregister serial driver (%d)n", e1);
  244. if ((e2 = tty_unregister_driver(&pcxe_callout)))
  245. printk("SERIAL: failed to unregister callout driver (%d)n",e2);
  247. cleanup_board_resources();
  248. kfree(digi_channels);
  249. kfree(pcxe_termios_locked);
  250. kfree(pcxe_termios);
  251. kfree(pcxe_table);
  252. restore_flags(flags);
  253. }
  254. #endif
  256. static inline struct channel *chan(register struct tty_struct *tty)
  257. {
  258. if (tty) {
  259. register struct channel *ch=(struct channel *)tty->driver_data;
  260. if (ch >= digi_channels && ch < digi_channels+nbdevs) {
  261. if (ch->magic==PCXX_MAGIC)
  262. return ch;
  263. }
  264. }
  265. return NULL;
  266. }
  268. /* These inline routines are to turn board memory on and off */
  269. static inline void memwinon(struct board_info *b, unsigned int win)
  270. {
  271. if(b->type == PCXEVE)
  272. outb_p(FEPWIN|win, b->port+1);
  273. else
  274. outb_p(inb(b->port)|FEPMEM, b->port);
  275. }
  277. static inline void memwinoff(struct board_info *b, unsigned int win)
  278. {
  279. outb_p(inb(b->port)&~FEPMEM, b->port);
  280. if(b->type == PCXEVE)
  281. outb_p(0, b->port + 1);
  282. }
  284. static inline void globalwinon(struct channel *ch)
  285. {
  286. if(ch->board->type == PCXEVE)
  287. outb_p(FEPWIN, ch->board->port+1);
  288. else
  289. outb_p(FEPMEM, ch->board->port);
  290. }
  292. static inline void rxwinon(struct channel *ch)
  293. {
  294. if(ch->rxwin == 0)
  295. outb_p(FEPMEM, ch->board->port);
  296. else 
  297. outb_p(ch->rxwin, ch->board->port+1);
  298. }
  300. static inline void txwinon(struct channel *ch)
  301. {
  302. if(ch->txwin == 0)
  303. outb_p(FEPMEM, ch->board->port);
  304. else
  305. outb_p(ch->txwin, ch->board->port+1);
  306. }
  308. static inline void memoff(struct channel *ch)
  309. {
  310. outb_p(0, ch->board->port);
  311. if(ch->board->type == PCXEVE)
  312. outb_p(0, ch->board->port+1);
  313. }
  315. static inline void assertgwinon(struct channel *ch)
  316. {
  317. if(ch->board->type != PCXEVE)
  318. pcxxassert(inb(ch->board->port) & FEPMEM, "Global memory off");
  319. }
  321. static inline void assertmemoff(struct channel *ch)
  322. {
  323. if(ch->board->type != PCXEVE)
  324. pcxxassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
  325. }
  327. static inline void pcxe_sched_event(struct channel *info, int event)
  328. {
  329. info->event |= 1 << event;
  330. queue_task(&info->tqueue, &tq_pcxx);
  331. mark_bh(DIGI_BH);
  332. }
  334. static void pcxx_error(int line, char *msg)
  335. {
  336. printk("pcxx_error (DigiBoard): line=%d %sn", line, msg);
  337. }
  339. static int pcxx_waitcarrier(struct tty_struct *tty,struct file *filp,struct channel *info)
  340. {
  341. DECLARE_WAITQUEUE(wait, current);
  342. int retval = 0;
  343. int do_clocal = 0;
  345. if (info->asyncflags & ASYNC_CALLOUT_ACTIVE) {
  346. if (info->normal_termios.c_cflag & CLOCAL)
  347. do_clocal = 1;
  348. } else {
  349. if (tty->termios->c_cflag & CLOCAL)
  350. do_clocal = 1;
  351. }
  353. /*
  354.  * Block waiting for the carrier detect and the line to become free
  355.  */
  357. retval = 0;
  358. add_wait_queue(&info->open_wait, &wait);
  359. info->count--;
  360. info->blocked_open++;
  362. for (;;) {
  363. cli();
  364. if ((info->asyncflags & ASYNC_CALLOUT_ACTIVE) == 0) {
  365. globalwinon(info);
  366. info->omodem |= DTR|RTS;
  367. fepcmd(info, SETMODEM, DTR|RTS, 0, 10, 1);
  368. memoff(info);
  369. }
  370. sti();
  371. set_current_state(TASK_INTERRUPTIBLE);
  372. if(tty_hung_up_p(filp) || (info->asyncflags & ASYNC_INITIALIZED) == 0) {
  373. if(info->asyncflags & ASYNC_HUP_NOTIFY)
  374. retval = -EAGAIN;
  375. else
  376. retval = -ERESTARTSYS;
  377. break;
  378. }
  379. if ((info->asyncflags & ASYNC_CALLOUT_ACTIVE) == 0 &&
  380.     (info->asyncflags & ASYNC_CLOSING) == 0 &&
  381. (do_clocal || (info->imodem & info->dcd)))
  382. break;
  383. if(signal_pending(current)) {
  384. retval = -ERESTARTSYS;
  385. break;
  386. }
  387. schedule();
  388. }
  389. current->state = TASK_RUNNING;
  390. remove_wait_queue(&info->open_wait, &wait);
  392. if(!tty_hung_up_p(filp))
  393. info->count++;
  394. info->blocked_open--;
  396. return retval;
  397. }
  400. int pcxe_open(struct tty_struct *tty, struct file * filp)
  401. {
  402. volatile struct board_chan *bc;
  403. struct channel *ch;
  404. unsigned long flags;
  405. int line;
  406. int boardnum;
  407. int retval;
  409. line = MINOR(tty->device) - tty->driver.minor_start;
  411. if(line < 0 || line >= nbdevs) {
  412. printk("line out of range in pcxe_openn");
  413. tty->driver_data = NULL;
  414. return(-ENODEV);
  415. }
  417. for(boardnum=0;boardnum<numcards;boardnum++)
  418. if ((line >= boards[boardnum].first_minor) && 
  419. (line < boards[boardnum].first_minor + boards[boardnum].numports))
  420. break;
  422. if(boardnum >= numcards || boards[boardnum].status == DISABLED ||
  423. (line - boards[boardnum].first_minor) >= boards[boardnum].numports) {
  424. tty->driver_data = NULL;   /* Mark this device as 'down' */
  425. return(-ENODEV);
  426. }
  428. ch = digi_channels+line;
  430. if(ch->brdchan == 0) {
  431. tty->driver_data = NULL;
  432. return(-ENODEV);
  433. }
  435. /* flag the kernel that there is somebody using this guy */
  436. MOD_INC_USE_COUNT;
  437. /*
  438.  * If the device is in the middle of being closed, then block
  439.  * until it's done, and then try again.
  440.  */
  441. if(ch->asyncflags & ASYNC_CLOSING) {
  442. interruptible_sleep_on(&ch->close_wait);
  443. if(ch->asyncflags & ASYNC_HUP_NOTIFY)
  444. return -EAGAIN;
  445. else
  446. return -ERESTARTSYS;
  447. }
  449. save_flags(flags);
  450. cli();
  451. ch->count++;
  452. tty->driver_data = ch;
  453. ch->tty = tty;
  455. if ((ch->asyncflags & ASYNC_INITIALIZED) == 0) {
  456. unsigned int head;
  458. globalwinon(ch);
  459. ch->statusflags = 0;
  460. bc=ch->brdchan;
  461. ch->imodem = bc->mstat;
  462. head = bc->rin;
  463. bc->rout = head;
  464. ch->tty = tty;
  465. pcxxparam(tty,ch);
  466. ch->imodem = bc->mstat;
  467. bc->idata = 1;
  468. ch->omodem = DTR|RTS;
  469. fepcmd(ch, SETMODEM, DTR|RTS, 0, 10, 1);
  470. memoff(ch);
  471. ch->asyncflags |= ASYNC_INITIALIZED;
  472. }
  473. restore_flags(flags);
  475. if(ch->asyncflags & ASYNC_CLOSING) {
  476. interruptible_sleep_on(&ch->close_wait);
  477. if(ch->asyncflags & ASYNC_HUP_NOTIFY)
  478. return -EAGAIN;
  479. else
  480. return -ERESTARTSYS;
  481. }
  482. /*
  483.  * If this is a callout device, then just make sure the normal
  484.  * device isn't being used.
  485.  */
  486. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  487. if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
  488. return -EBUSY;
  489. if (ch->asyncflags & ASYNC_CALLOUT_ACTIVE) {
  490. if ((ch->asyncflags & ASYNC_SESSION_LOCKOUT) &&
  491.      (ch->session != current->session))
  492.     return -EBUSY;
  493. if((ch->asyncflags & ASYNC_PGRP_LOCKOUT) &&
  494.     (ch->pgrp != current->pgrp))
  495.     return -EBUSY;
  496. }
  497. ch->asyncflags |= ASYNC_CALLOUT_ACTIVE;
  498. }
  499. else {
  500. if (filp->f_flags & O_NONBLOCK) {
  501. if(ch->asyncflags & ASYNC_CALLOUT_ACTIVE)
  502. return -EBUSY;
  503. }
  504. else {
  505. /* this has to be set in order for the "block until
  506.  * CD" code to work correctly.  i'm not sure under
  507.  * what circumstances asyncflags should be set to
  508.  * ASYNC_NORMAL_ACTIVE though
  509.  * brian@ilinx.com
  510.  */
  511. ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
  512. if ((retval = pcxx_waitcarrier(tty, filp, ch)) != 0)
  513. return retval;
  514. }
  515. ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
  516. }
  517.  
  518. save_flags(flags);
  519. cli();
  520. if((ch->count == 1) && (ch->asyncflags & ASYNC_SPLIT_TERMIOS)) {
  521. if(tty->driver.subtype == SERIAL_TYPE_NORMAL)
  522. *tty->termios = ch->normal_termios;
  523. else 
  524. *tty->termios = ch->callout_termios;
  525. globalwinon(ch);
  526. pcxxparam(tty,ch);
  527. memoff(ch);
  528. }
  530. ch->session = current->session;
  531. ch->pgrp = current->pgrp;
  532. restore_flags(flags);
  533. return 0;
  534. } 
  536. static void shutdown(struct channel *info)
  537. {
  538. unsigned long flags;
  539. volatile struct board_chan *bc;
  540. struct tty_struct *tty;
  542. if (!(info->asyncflags & ASYNC_INITIALIZED)) 
  543. return;
  545. save_flags(flags);
  546. cli();
  547. globalwinon(info);
  549. bc = info->brdchan;
  550. if(bc)
  551. bc->idata = 0;
  553. tty = info->tty;
  555. /*
  556.  * If we're a modem control device and HUPCL is on, drop RTS & DTR.
  557.  */
  558. if(tty->termios->c_cflag & HUPCL) {
  559. info->omodem &= ~(RTS|DTR);
  560. fepcmd(info, SETMODEM, 0, DTR|RTS, 10, 1);
  561. }
  563. memoff(info);
  564. info->asyncflags &= ~ASYNC_INITIALIZED;
  565. restore_flags(flags);
  566. }
  569. static void pcxe_close(struct tty_struct * tty, struct file * filp)
  570. {
  571. struct channel *info;
  573. if ((info=chan(tty))!=NULL) {
  574. unsigned long flags;
  575. save_flags(flags);
  576. cli();
  578. if(tty_hung_up_p(filp)) {
  579. /* flag that somebody is done with this module */
  580. MOD_DEC_USE_COUNT;
  581. restore_flags(flags);
  582. return;
  583. }
  584. /* this check is in serial.c, it won't hurt to do it here too */
  585. if ((tty->count == 1) && (info->count != 1)) {
  586. /*
  587.  * Uh, oh.  tty->count is 1, which means that the tty
  588.  * structure will be freed.  Info->count should always
  589.  * be one in these conditions.  If it's greater than
  590.  * one, we've got real problems, since it means the
  591.  * serial port won't be shutdown.
  592.  */
  593. printk("pcxe_close: bad serial port count; tty->count is 1, info->count is %dn", info->count);
  594. info->count = 1;
  595. }
  596. if (info->count-- > 1) {
  597. restore_flags(flags);
  598. MOD_DEC_USE_COUNT;
  599. return;
  600. }
  601. if (info->count < 0) {
  602. info->count = 0;
  603. }
  605. info->asyncflags |= ASYNC_CLOSING;
  607. /*
  608. * Save the termios structure, since this port may have
  609. * separate termios for callout and dialin.
  610. */
  611. if(info->asyncflags & ASYNC_NORMAL_ACTIVE)
  612. info->normal_termios = *tty->termios;
  613. if(info->asyncflags & ASYNC_CALLOUT_ACTIVE)
  614. info->callout_termios = *tty->termios;
  615. tty->closing = 1;
  616. if(info->asyncflags & ASYNC_INITIALIZED) {
  617. setup_empty_event(tty,info);
  618. tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
  619. }
  621. if(tty->driver.flush_buffer)
  622. tty->driver.flush_buffer(tty);
  623. if(tty->ldisc.flush_buffer)
  624. tty->ldisc.flush_buffer(tty);
  625. shutdown(info);
  626. tty->closing = 0;
  627. info->event = 0;
  628. info->tty = NULL;
  629. #ifndef MODULE
  630. /* ldiscs[] is not available in a MODULE
  631. ** worth noting that while I'm not sure what this hunk of code is supposed
  632. ** to do, it is not present in the serial.c driver.  Hmmm.  If you know,
  633. ** please send me a note.  brian@ilinx.com
  634. ** Don't know either what this is supposed to do christoph@lameter.com.
  635. */
  636. if(tty->ldisc.num != ldiscs[N_TTY].num) {
  637. if(tty->ldisc.close)
  638. (tty->ldisc.close)(tty);
  639. tty->ldisc = ldiscs[N_TTY];
  640. tty->termios->c_line = N_TTY;
  641. if(tty->ldisc.open)
  642. (tty->ldisc.open)(tty);
  643. }
  644. #endif
  645. if(info->blocked_open) {
  646. if(info->close_delay) {
  647. current->state = TASK_INTERRUPTIBLE;
  648. schedule_timeout(info->close_delay);
  649. }
  650. wake_up_interruptible(&info->open_wait);
  651. }
  652. info->asyncflags &= ~(ASYNC_NORMAL_ACTIVE|
  653.   ASYNC_CALLOUT_ACTIVE|ASYNC_CLOSING);
  654. wake_up_interruptible(&info->close_wait);
  655. MOD_DEC_USE_COUNT;
  656. restore_flags(flags);
  657. }
  658. }
  661. void pcxe_hangup(struct tty_struct *tty)
  662. {
  663. struct channel *ch;
  665. if ((ch=chan(tty))!=NULL) {
  666. unsigned long flags;
  668. save_flags(flags);
  669. cli();
  670. shutdown(ch);
  671. ch->event = 0;
  672. ch->count = 0;
  673. ch->tty = NULL;
  674. ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  675. wake_up_interruptible(&ch->open_wait);
  676. restore_flags(flags);
  677. }
  678. }
  682. static int pcxe_write(struct tty_struct * tty, int from_user, const unsigned char *buf, int count)
  683. {
  684. struct channel *ch;
  685. volatile struct board_chan *bc;
  686. int total, remain, size, stlen;
  687. unsigned int head, tail;
  688. unsigned long flags;
  689. /* printk("Entering pcxe_write()n"); */
  691. if ((ch=chan(tty))==NULL)
  692. return 0;
  694. bc = ch->brdchan;
  695. size = ch->txbufsize;
  697. if (from_user) {
  699. down(&ch->tmp_buf_sem);
  700. save_flags(flags);
  701. cli();
  702. globalwinon(ch);
  703. head = bc->tin & (size - 1);
  704. /* It seems to be necessary to make sure that the value is stable here somehow
  705.    This is a rather odd pice of code here. */
  706. do
  707. {
  708. tail = bc->tout;
  709. } while (tail != bc->tout);
  711. tail &= (size - 1);
  712. stlen = (head >= tail) ? (size - (head - tail) - 1) : (tail - head - 1);
  713. count = MIN(stlen, count);
  714. memoff(ch);
  715. restore_flags(flags);
  717. if (count)
  718. if (copy_from_user(ch->tmp_buf, buf, count))
  719. count = 0;
  721. buf = ch->tmp_buf;
  722. }
  724. /*
  725.  * All data is now local
  726.  */
  728. total = 0;
  729. save_flags(flags);
  730. cli();
  731. globalwinon(ch);
  732. head = bc->tin & (size - 1);
  733. tail = bc->tout;
  734. if (tail != bc->tout)
  735. tail = bc->tout;
  736. tail &= (size - 1);
  737. if (head >= tail) {
  738. remain = size - (head - tail) - 1;
  739. stlen = size - head;
  740. }
  741. else {
  742. remain = tail - head - 1;
  743. stlen = remain;
  744. }
  745. count = MIN(remain, count);
  747. txwinon(ch);
  748. while (count > 0) {
  749. stlen = MIN(count, stlen);
  750. memcpy(ch->txptr + head, buf, stlen);
  751. buf += stlen;
  752. count -= stlen;
  753. total += stlen;
  754. head += stlen;
  755. if (head >= size) {
  756. head = 0;
  757. stlen = tail;
  758. }
  759. }
  760. ch->statusflags |= TXBUSY;
  761. globalwinon(ch);
  762. bc->tin = head;
  763. if ((ch->statusflags & LOWWAIT) == 0) {
  764. ch->statusflags |= LOWWAIT;
  765. bc->ilow = 1;
  766. }
  767. memoff(ch);
  768. restore_flags(flags);
  770. if(from_user)
  771. up(&ch->tmp_buf_sem);
  773. return(total);
  774. }
  777. static void pcxe_put_char(struct tty_struct *tty, unsigned char c)
  778. {
  779. pcxe_write(tty, 0, &c, 1);
  780. return;
  781. }
  784. static int pcxe_write_room(struct tty_struct *tty)
  785. {
  786. struct channel *ch;
  787. int remain;
  789. remain = 0;
  790. if ((ch=chan(tty))!=NULL) {
  791. volatile struct board_chan *bc;
  792. unsigned int head, tail;
  793. unsigned long flags;
  795. save_flags(flags);
  796. cli();
  797. globalwinon(ch);
  799. bc = ch->brdchan;
  800. head = bc->tin & (ch->txbufsize - 1);
  801. tail = bc->tout;
  802. if (tail != bc->tout)
  803. tail = bc->tout;
  804. tail &= (ch->txbufsize - 1);
  806. if((remain = tail - head - 1) < 0 )
  807. remain += ch->txbufsize;
  809. if (remain && (ch->statusflags & LOWWAIT) == 0) {
  810. ch->statusflags |= LOWWAIT;
  811. bc->ilow = 1;
  812. }
  813. memoff(ch);
  814. restore_flags(flags);
  815. }
  817. return remain;
  818. }
  821. static int pcxe_chars_in_buffer(struct tty_struct *tty)
  822. {
  823. int chars;
  824. unsigned int ctail, head, tail;
  825. int remain;
  826. unsigned long flags;
  827. struct channel *ch;
  828. volatile struct board_chan *bc;
  830. if ((ch=chan(tty))==NULL)
  831. return(0);
  833. save_flags(flags);
  834. cli();
  835. globalwinon(ch);
  837. bc = ch->brdchan;
  838. tail = bc->tout;
  839. head = bc->tin;
  840. ctail = ch->mailbox->cout;
  841. if(tail == head && ch->mailbox->cin == ctail && bc->tbusy == 0)
  842. chars = 0;
  843. else {
  844. head = bc->tin & (ch->txbufsize - 1);
  845. tail &= (ch->txbufsize - 1);
  846. if((remain = tail - head - 1) < 0 )
  847. remain += ch->txbufsize;
  849. chars = (int)(ch->txbufsize - remain);
  851. /* 
  852.  * Make it possible to wakeup anything waiting for output
  853.  * in tty_ioctl.c, etc.
  854.  */
  855. if(!(ch->statusflags & EMPTYWAIT))
  856. setup_empty_event(tty,ch);
  857. }
  859. memoff(ch);
  860. restore_flags(flags);
  862. return(chars);
  863. }
  866. static void pcxe_flush_buffer(struct tty_struct *tty)
  867. {
  868. unsigned int tail;
  869. volatile struct board_chan *bc;
  870. struct channel *ch;
  871. unsigned long flags;
  873. if ((ch=chan(tty))==NULL)
  874. return;
  876. save_flags(flags);
  877. cli();
  879. globalwinon(ch);
  880. bc = ch->brdchan;
  881. tail = bc->tout;
  882. fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
  884. memoff(ch);
  885. restore_flags(flags);
  887. wake_up_interruptible(&tty->write_wait);
  888. if((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup)
  889. (tty->ldisc.write_wakeup)(tty);
  890. }
  892. static void pcxe_flush_chars(struct tty_struct *tty)
  893. {
  894. struct channel * ch;
  896. if ((ch=chan(tty))!=NULL) {
  897. unsigned long flags;
  899. save_flags(flags);
  900. cli();
  901. if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
  902. setup_empty_event(tty,ch);
  903. restore_flags(flags);
  904. }
  905. }
  907. #ifndef MODULE
  909. /*
  910.  * Driver setup function when linked into the kernel to optionally parse multible
  911.  * "digi="-lines and initialize the driver at boot time. No probing.
  912.  */
  913. void __init pcxx_setup(char *str, int *ints)
  914. {
  916. struct board_info board;
  917. int               i, j, last;
  918. char              *temp, *t2;
  919. unsigned          len;
  921. numcards=0;
  923. memset(&board, 0, sizeof(board));
  925. for(last=0,i=1;i<=ints[0];i++)
  926. switch(i)
  927. {
  928. case 1:
  929. board.status = ints[i];
  930. last = i;
  931. break;
  933. case 2:
  934. board.type = ints[i];
  935. last = i;
  936. break;
  938. case 3:
  939. board.altpin = ints[i];
  940. last = i;
  941. break;
  943. case 4:
  944. board.numports = ints[i];
  945. last = i;
  946. break;
  948. case 5:
  949. board.port = ints[i];
  950. last = i;
  951. break;
  953. case 6:
  954. board.membase = ints[i];
  955. last = i;
  956. break;
  958. default:
  959. printk("PC/Xx: Too many integer parmsn");
  960. return;
  961. }
  963. while (str && *str) 
  964. {
  965. /* find the next comma or terminator */
  966. temp = str;
  967. while (*temp && (*temp != ','))
  968. temp++;
  970. if (!*temp)
  971. temp = NULL;
  972. else
  973. *temp++ = 0;
  975. i = last + 1;
  977. switch(i)
  978. {
  979. case 1:
  980. len = strlen(str);
  981. if (strncmp("Disable", str, len) == 0) 
  982. board.status = 0;
  983. else
  984. if (strncmp("Enable", str, len) == 0)
  985. board.status = 1;
  986. else
  987. {
  988. printk("PC/Xx: Invalid status %sn", str);
  989. return;
  990. }
  991. last = i;
  992. break;
  994. case 2:
  995. for(j=0;j<PCXX_NUM_TYPES;j++)
  996. if (strcmp(board_desc[j], str) == 0)
  997. break;
  999. if (i<PCXX_NUM_TYPES) 
  1000. board.type = j;
  1001. else
  1002. {
  1003. printk("PC/Xx: Invalid board name: %sn", str);
  1004. return;
  1005. }
  1006. last = i;
  1007. break;
  1009. case 3:
  1010. len = strlen(str);
  1011. if (strncmp("Disable", str, len) == 0) 
  1012. board.altpin = 0;
  1013. else
  1014. if (strncmp("Enable", str, len) == 0)
  1015. board.altpin = 1;
  1016. else
  1017. {
  1018. printk("PC/Xx: Invalid altpin %sn", str);
  1019. return;
  1020. }
  1021. last = i;
  1022. break;
  1024. case 4:
  1025. t2 = str;
  1026. while (isdigit(*t2))
  1027. t2++;
  1029. if (*t2)
  1030. {
  1031. printk("PC/Xx: Invalid port count %sn", str);
  1032. return;
  1033. }
  1035. board.numports = simple_strtoul(str, NULL, 0);
  1036. last = i;
  1037. break;
  1039. case 5:
  1040. t2 = str;
  1041. while (isxdigit(*t2))
  1042. t2++;
  1044. if (*t2)
  1045. {
  1046. printk("PC/Xx: Invalid io port address %sn", str);
  1047. return;
  1048. }
  1050. board.port = simple_strtoul(str, NULL, 16);
  1051. last = i;
  1052. break;
  1054. case 6:
  1055. t2 = str;
  1056. while (isxdigit(*t2))
  1057. t2++;
  1059. if (*t2)
  1060. {
  1061. printk("PC/Xx: Invalid memory base %sn", str);
  1062. return;
  1063. }
  1065. board.membase = simple_strtoul(str, NULL, 16);
  1066. last = i;
  1067. break;
  1069. default:
  1070. printk("PC/Xx: Too many string parmsn");
  1071. return;
  1072. }
  1073. str = temp;
  1074. }
  1076. if (last < 6)  
  1077. {
  1078. printk("PC/Xx: Insufficient parms specifiedn");
  1079. return;
  1080. }
  1081.  
  1082.         /* I should REALLY validate the stuff here */
  1084. memcpy(&boards[numcards],&board, sizeof(board));
  1085. printk("PC/Xx: Added board %i, %s %s %i ports at 0x%4.4X base 0x%6.6Xn", 
  1086. numcards, board_desc[board.type], board_mem[board.type], 
  1087. board.numports, board.port, (unsigned int) board.membase);
  1089. /* keep track of my initial minor number */
  1090.         if (numcards)
  1091. boards[numcards].first_minor = boards[numcards-1].first_minor + boards[numcards-1].numports;
  1092. else
  1093. boards[numcards].first_minor = 0;
  1095. /* yeha!  string parameter was successful! */
  1096. numcards++;
  1097. }
  1098. #endif
  1100. /*
  1101.  * function to initialize the driver with the given parameters, which are either
  1102.  * the default values from this file or the parameters given at boot.
  1103.  */
  1104. int __init pcxe_init(void)
  1105. {
  1106. ulong memory_seg=0, memory_size=0;
  1107. int lowwater, enabled_cards=0, i, crd, shrinkmem=0, topwin = 0xff00L, botwin=0x100L;
  1108. int ret = -ENOMEM;
  1109. unchar *fepos, *memaddr, *bios, v;
  1110. volatile struct global_data *gd;
  1111. volatile struct board_chan *bc;
  1112. struct board_info *bd;
  1113. struct channel *ch;
  1115. printk(KERN_NOTICE "Digiboard PC/X{i,e,eve} driver v%sn", VERSION);
  1117. #ifdef MODULE
  1118. for (i = 0; i < MAX_DIGI_BOARDS; i++) {
  1119. if (io[i]) {
  1120. numcards = 0;
  1121. break;
  1122. }
  1123. }
  1124. if (numcards == 0) {
  1125. int first_minor = 0;
  1127. for (i = 0; i < MAX_DIGI_BOARDS; i++) {
  1128. if (io[i] == 0) {
  1129. boards[i].port    = 0;
  1130. boards[i].status  = DISABLED;
  1131. }
  1132. else {
  1133. boards[i].port         = (ushort)io[i];
  1134. boards[i].status       = ENABLED;
  1135. boards[i].first_minor  = first_minor;
  1136. numcards=i+1;
  1137. }
  1138. if (membase[i])
  1139. boards[i].membase = (ulong)membase[i];
  1140. else
  1141. boards[i].membase = 0xD0000;
  1143. if (memsize[i])
  1144. boards[i].memsize = (ulong)(memsize[i] * 1024);
  1145. else
  1146. boards[i].memsize = 0;
  1148. if (altpin[i])
  1149. boards[i].altpin  = ON;
  1150. else
  1151. boards[i].altpin  = OFF;
  1153. if (numports[i])
  1154. boards[i].numports  = (ushort)numports[i];
  1155. else
  1156. boards[i].numports  = 16;
  1158. boards[i].region = NULL;
  1159. first_minor += boards[i].numports;
  1160. }
  1161. }
  1162. #endif
  1164. if (numcards <= 0)
  1165. {
  1166. printk("PC/Xx: No cards configured, driver not active.n");
  1167. return -EIO;
  1168. }
  1169. #if 1
  1170. if (debug)
  1171.     for (i = 0; i < numcards; i++) {
  1172.     printk("Card %d:status=%d, port=0x%x, membase=0x%lx, memsize=0x%lx, altpin=%d, numports=%d, first_minor=%dn",
  1173.     i+1,
  1174.     boards[i].status,
  1175.     boards[i].port,
  1176.     boards[i].membase,
  1177.     boards[i].memsize,
  1178.     boards[i].altpin,
  1179.     boards[i].numports,
  1180.     boards[i].first_minor);
  1181.     }
  1182. #endif
  1184. for (i=0;i<numcards;i++)
  1185. nbdevs += boards[i].numports;
  1187. if (nbdevs <= 0)
  1188. {
  1189. printk("PC/Xx: No devices activated, driver not active.n");
  1190. return -EIO;
  1191. }
  1193. /*
  1194.  * this turns out to be more memory efficient, as there are no 
  1195.  * unused spaces.
  1196.  */
  1197. digi_channels = kmalloc(sizeof(struct channel) * nbdevs, GFP_KERNEL);
  1198. if (!digi_channels) {
  1199. printk(KERN_ERR "Unable to allocate digi_channel structn");
  1200. return -ENOMEM;
  1201. }
  1202. memset(digi_channels, 0, sizeof(struct channel) * nbdevs);
  1204. pcxe_table =  kmalloc(sizeof(struct tty_struct *) * nbdevs, GFP_KERNEL);
  1205. if (!pcxe_table) {
  1206. printk(KERN_ERR "Unable to allocate pcxe_table structn");
  1207. goto cleanup_digi_channels;
  1208. }
  1209. memset(pcxe_table, 0, sizeof(struct tty_struct *) * nbdevs);
  1211. pcxe_termios = kmalloc(sizeof(struct termios *) * nbdevs, GFP_KERNEL);
  1212. if (!pcxe_termios) {
  1213. printk(KERN_ERR "Unable to allocate pcxe_termios structn");
  1214. goto cleanup_pcxe_table;
  1215. }
  1216. memset(pcxe_termios,0,sizeof(struct termios *)*nbdevs);
  1218. pcxe_termios_locked = kmalloc(sizeof(struct termios *) * nbdevs, GFP_KERNEL);
  1219. if (!pcxe_termios_locked) {
  1220. printk(KERN_ERR "Unable to allocate pcxe_termios_locked structn");
  1221. goto cleanup_pcxe_termios;
  1222. }
  1223. memset(pcxe_termios_locked,0,sizeof(struct termios *)*nbdevs);
  1225. init_bh(DIGI_BH,do_pcxe_bh);
  1227. init_timer(&pcxx_timer);
  1228. pcxx_timer.function = pcxxpoll;
  1230. memset(&pcxe_driver, 0, sizeof(struct tty_driver));
  1231. pcxe_driver.magic = TTY_DRIVER_MAGIC;
  1232. pcxe_driver.name = "ttyD";
  1233. pcxe_driver.major = DIGI_MAJOR; 
  1234. pcxe_driver.minor_start = 0;
  1236. pcxe_driver.num = nbdevs;
  1238. pcxe_driver.type = TTY_DRIVER_TYPE_SERIAL;
  1239. pcxe_driver.subtype = SERIAL_TYPE_NORMAL;
  1240. pcxe_driver.init_termios = tty_std_termios;
  1241. pcxe_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
  1242. pcxe_driver.flags = TTY_DRIVER_REAL_RAW;
  1243. pcxe_driver.refcount = &pcxe_refcount;
  1245. pcxe_driver.table = pcxe_table;
  1246. pcxe_driver.termios = pcxe_termios;
  1247. pcxe_driver.termios_locked = pcxe_termios_locked;
  1249. pcxe_driver.open = pcxe_open;
  1250. pcxe_driver.close = pcxe_close;
  1251. pcxe_driver.write = pcxe_write;
  1252. pcxe_driver.put_char = pcxe_put_char;
  1253. pcxe_driver.flush_chars = pcxe_flush_chars;
  1254. pcxe_driver.write_room = pcxe_write_room;
  1255. pcxe_driver.chars_in_buffer = pcxe_chars_in_buffer;
  1256. pcxe_driver.flush_buffer = pcxe_flush_buffer;
  1257. pcxe_driver.ioctl = pcxe_ioctl;
  1258. pcxe_driver.throttle = pcxe_throttle;
  1259. pcxe_driver.unthrottle = pcxe_unthrottle;
  1260. pcxe_driver.set_termios = pcxe_set_termios;
  1261. pcxe_driver.stop = pcxe_stop;
  1262. pcxe_driver.start = pcxe_start;
  1263. pcxe_driver.hangup = pcxe_hangup;
  1265. pcxe_callout = pcxe_driver;
  1266. pcxe_callout.name = "cud";
  1267. pcxe_callout.major = DIGICU_MAJOR;
  1268. pcxe_callout.subtype = SERIAL_TYPE_CALLOUT;
  1269. pcxe_callout.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  1271. for(crd=0; crd < numcards; crd++) {
  1272. bd = &boards[crd];
  1273. outb(FEPRST, bd->port);
  1274. pcxxdelay(1);
  1276. for(i=0; (inb(bd->port) & FEPMASK) != FEPRST; i++) {
  1277. if(i > 100) {
  1278. printk("PC/Xx: Board not found at port 0x%x! Check switch settings.n",
  1279. bd->port);
  1280. bd->status = DISABLED;
  1281. break;
  1282. }
  1283. #ifdef MODULE
  1284. schedule();
  1285. #endif
  1286. pcxxdelay(10);
  1287. }
  1288. if(bd->status == DISABLED)
  1289. continue;
  1291. v = inb(bd->port);
  1293. if((v & 0x1) == 0x1) {
  1294. if((v & 0x30) == 0) {        /* PC/Xi 64K card */
  1295. memory_seg = 0xf000;
  1296. memory_size = 0x10000;
  1297. } 
  1299. if((v & 0x30) == 0x10) {     /* PC/Xi 128K card */
  1300. memory_seg = 0xe000;
  1301. memory_size = 0x20000;
  1302. }
  1304. if((v & 0x30) == 0x20) {     /* PC/Xi 256K card */
  1305. memory_seg = 0xc000;
  1306. memory_size = 0x40000;
  1307. }
  1309. if((v & 0x30) == 0x30) {     /* PC/Xi 512K card */
  1310. memory_seg = 0x8000;
  1311. memory_size = 0x80000;
  1312. }
  1313. bd->type = PCXI;
  1314. } else {
  1315. if((v & 0x1) == 0x1) {
  1316. bd->status = DISABLED;   /* PC/Xm unsupported card */
  1317. printk("PC/Xx: PC/Xm at 0x%x not supported!!n", bd->port);
  1318. continue;
  1319. } else {
  1320. if(v & 0xC0) {    
  1321. topwin = 0x1f00L;
  1322. outb((((ulong)bd->membase>>8) & 0xe0) | 0x10, bd->port+2);
  1323. outb(((ulong)bd->membase>>16) & 0xff, bd->port+3);
  1324. bd->type = PCXEVE; /* PC/Xe 8K card */
  1325. } else { 
  1326. bd->type = PCXE;    /* PC/Xe 64K card */
  1327. }
  1329. memory_seg = 0xf000;
  1330. memory_size = 0x10000;
  1331. }
  1332. }
  1333. if (verbose)
  1334. printk("Configuring card %d as a %s %ldK card. io=0x%x, mem=%lx-%lxn",
  1335. crd+1, board_desc[bd->type], memory_size/1024,
  1336. bd->port,bd->membase,bd->membase+memory_size-1);
  1338. if (boards[crd].memsize == 0)
  1339. boards[crd].memsize = memory_size;
  1340. else
  1341. if (boards[crd].memsize != memory_size) {
  1342.     printk("PC/Xx: memory size mismatch:supplied=%lx(%ldK) probed=%ld(%ldK)n",
  1343.     boards[crd].memsize, boards[crd].memsize / 1024,
  1344.     memory_size, memory_size / 1024);
  1345.     continue;
  1346. }
  1348. memaddr = (unchar *)phys_to_virt(bd->membase);
  1350. if (verbose)
  1351. printk("Resetting board and testing memory access:");
  1353. outb(FEPRST|FEPMEM, bd->port);
  1355. for(i=0; (inb(bd->port) & FEPMASK) != (FEPRST|FEPMEM); i++) {
  1356. if(i > 1000) {
  1357. printk("nPC/Xx: %s not resetting at port 0x%x! Check switch settings.n",
  1358. board_desc[bd->type], bd->port);
  1359. bd->status = DISABLED;
  1360. break;
  1361. }
  1362. #ifdef MODULE
  1363. schedule();
  1364. #endif
  1365. pcxxdelay(1);
  1366. }
  1367. if(bd->status == DISABLED)
  1368. continue;
  1370. memwinon(bd,0);
  1371. *(ulong *)(memaddr + botwin) = 0xa55a3cc3;
  1372. *(ulong *)(memaddr + topwin) = 0x5aa5c33c;
  1374. if(*(ulong *)(memaddr + botwin) != 0xa55a3cc3 ||
  1375. *(ulong *)(memaddr + topwin) != 0x5aa5c33c) {
  1376. printk("PC/Xx: Failed memory test at %lx for %s at port %x, check switch settings.n",
  1377. bd->membase, board_desc[bd->type], bd->port);
  1378. bd->status = DISABLED;
  1379. continue;
  1380. }
  1381. if (verbose)
  1382. printk(" done.n");
  1384. for(i=0; i < 16; i++) {
  1385. memaddr[MISCGLOBAL+i] = 0;
  1386. }
  1388. if(bd->type == PCXI || bd->type == PCXE) {
  1389. bios = memaddr + BIOSCODE + ((0xf000 - memory_seg) << 4);
  1391. if (verbose)
  1392. printk("Downloading BIOS to 0x%lx:", virt_to_phys(bios));
  1394. memcpy(bios, pcxx_bios, pcxx_nbios);
  1396. if (verbose)
  1397. printk(" done.n");
  1399. outb(FEPMEM, bd->port);
  1401. if (verbose)
  1402. printk("Waiting for BIOS to become ready");
  1404. for(i=1; i <= 30; i++) {
  1405. if(*(ushort *)((ulong)memaddr + MISCGLOBAL) == *(ushort *)"GD" ) {
  1406. goto load_fep;
  1407. }
  1408. if (verbose) {
  1409. printk(".");
  1410. if (i % 50 == 0)
  1411. printk("n");
  1412. }
  1413. #ifdef MODULE
  1414. schedule();
  1415. #endif
  1416. pcxxdelay(50);
  1417. }
  1419. printk("nPC/Xx: BIOS download failed for board at 0x%x(addr=%lx-%lx)!n",
  1420. bd->port, bd->membase, bd->membase+bd->memsize);
  1421. bd->status = DISABLED;
  1422. continue;
  1423. }
  1425. if(bd->type == PCXEVE) {
  1426. bios = memaddr + (BIOSCODE & 0x1fff);
  1427. memwinon(bd,0xff);
  1429. memcpy(bios, pcxx_bios, pcxx_nbios);
  1431. outb(FEPCLR, bd->port);
  1432. memwinon(bd,0);
  1434. for(i=0; i <= 1000; i++) {
  1435. if(*(ushort *)((ulong)memaddr + MISCGLOBAL) == *(ushort *)"GD" ) {
  1436. goto load_fep;
  1437. }
  1438. if (verbose) {
  1439. printk(".");
  1440. if (i % 50 == 0)
  1441. printk("n");
  1442. }
  1443. #ifdef MODULE
  1444. schedule();
  1445. #endif
  1446. pcxxdelay(10);
  1447. }
  1449. printk("nPC/Xx: BIOS download failed on the %s at 0x%x!n",
  1450. board_desc[bd->type], bd->port);
  1451. bd->status = DISABLED;
  1452. continue;
  1453. }
  1455. load_fep:
  1456. fepos = memaddr + FEPCODE;
  1457. if(bd->type == PCXEVE)
  1458. fepos = memaddr + (FEPCODE & 0x1fff);
  1460. if (verbose)
  1461. printk(" ok.nDownloading FEP/OS to 0x%lx:", virt_to_phys(fepos));
  1463. memwinon(bd, (FEPCODE >> 13));
  1464. memcpy(fepos, pcxx_cook, pcxx_ncook);
  1465. memwinon(bd, 0);
  1467. if (verbose)
  1468. printk(" done.n");
  1470. *(ushort *)((ulong)memaddr + MBOX +  0) = 2;
  1471. *(ushort *)((ulong)memaddr + MBOX +  2) = memory_seg + FEPCODESEG;
  1472. *(ushort *)((ulong)memaddr + MBOX +  4) = 0;
  1473. *(ushort *)((ulong)memaddr + MBOX +  6) = FEPCODESEG;
  1474. *(ushort *)((ulong)memaddr + MBOX +  8) = 0;
  1475. *(ushort *)((ulong)memaddr + MBOX + 10) = pcxx_ncook;
  1477. outb(FEPMEM|FEPINT, bd->port);
  1478. outb(FEPMEM, bd->port);
  1480. for(i=0; *(ushort *)((ulong)memaddr + MBOX); i++) {
  1481. if(i > 2000) {
  1482. printk("PC/Xx: Command failed for the %s at 0x%x!n",
  1483. board_desc[bd->type], bd->port);
  1484. bd->status = DISABLED;
  1485. break;
  1486. }
  1487. #ifdef MODULE
  1488. schedule();
  1489. #endif
  1490. pcxxdelay(1);
  1491. }
  1493. if(bd->status == DISABLED)
  1494. continue;
  1496. if (verbose)
  1497. printk("Waiting for FEP/OS to become ready");
  1499. *(ushort *)(memaddr + FEPSTAT) = 0;
  1500. *(ushort *)(memaddr + MBOX + 0) = 1;
  1501. *(ushort *)(memaddr + MBOX + 2) = FEPCODESEG;
  1502. *(ushort *)(memaddr + MBOX + 4) = 0x4L;
  1504. outb(FEPINT, bd->port);
  1505. outb(FEPCLR, bd->port);
  1506. memwinon(bd, 0);
  1508. for(i=1; *(ushort *)((ulong)memaddr + FEPSTAT) != *(ushort *)"OS"; i++) {
  1509. if(i > 1000) {
  1510. printk("nPC/Xx: FEP/OS download failed on the %s at 0x%x!n",
  1511. board_desc[bd->type], bd->port);
  1512. bd->status = DISABLED;
  1513. break;
  1514. }
  1515. if (verbose) {
  1516. printk(".");
  1517. if (i % 50 == 0)
  1518. printk("n%5d",i/50);
  1519. }
  1520. #ifdef MODULE
  1521. schedule();
  1522. #endif
  1523. pcxxdelay(1);
  1524. }
  1525. if(bd->status == DISABLED)
  1526. continue;
  1528. if (verbose)
  1529. printk(" ok.n");
  1531. ch = digi_channels+bd->first_minor;
  1532. pcxxassert(ch < digi_channels+nbdevs, "ch out of range");
  1534. bc = (volatile struct board_chan *)((ulong)memaddr + CHANSTRUCT);
  1535. gd = (volatile struct global_data *)((ulong)memaddr + GLOBAL);
  1537. if((bd->type == PCXEVE) && (*(ushort *)((ulong)memaddr+NPORT) < 3))
  1538. shrinkmem = 1;
  1540. bd->region = request_region(bd->port, 4, "PC/Xx");
  1542. if (!bd->region) {
  1543. printk(KERN_ERR "I/O port 0x%x is already usedn", bd->port);
  1544. ret = -EBUSY;
  1545. goto cleanup_boards;
  1546. }
  1548. for(i=0; i < bd->numports; i++, ch++, bc++) {
  1549. if(((ushort *)((ulong)memaddr + PORTBASE))[i] == 0) {
  1550. ch->brdchan = 0;
  1551. continue;
  1552. }
  1553. ch->brdchan = bc;
  1554. ch->mailbox = gd;
  1555. ch->tqueue.routine = do_softint;
  1556. ch->tqueue.data = ch;
  1557. ch->board = &boards[crd];
  1558. #ifdef DEFAULT_HW_FLOW
  1559. ch->digiext.digi_flags = RTSPACE|CTSPACE;
  1560. #endif
  1561. if(boards[crd].altpin) {
  1562. ch->dsr = CD;
  1563. ch->dcd = DSR;
  1564. ch->digiext.digi_flags |= DIGI_ALTPIN;
  1565. } else { 
  1566. ch->dcd = CD;
  1567. ch->dsr = DSR;
  1568. }
  1570. ch->magic = PCXX_MAGIC;
  1571. ch->boardnum = crd;
  1572. ch->channelnum = i;
  1574. ch->dev = bd->first_minor + i;
  1575. ch->tty = 0;
  1577. if(shrinkmem) {
  1578. fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
  1579. shrinkmem = 0;
  1580. }
  1582. if(bd->type != PCXEVE) {
  1583. ch->txptr = memaddr+((bc->tseg-memory_seg) << 4);
  1584. ch->rxptr = memaddr+((bc->rseg-memory_seg) << 4);
  1585. ch->txwin = ch->rxwin = 0;
  1586. } else {
  1587. ch->txptr = memaddr+(((bc->tseg-memory_seg) << 4) & 0x1fff);
  1588. ch->txwin = FEPWIN | ((bc->tseg-memory_seg) >> 9);
  1589. ch->rxptr = memaddr+(((bc->rseg-memory_seg) << 4) & 0x1fff);
  1590. ch->rxwin = FEPWIN | ((bc->rseg-memory_seg) >>9 );
  1591. }
  1593. ch->txbufsize = bc->tmax + 1;
  1594. ch->rxbufsize = bc->rmax + 1;
  1595. ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
  1596. init_MUTEX(&ch->tmp_buf_sem);
  1598. if (!ch->tmp_buf) {
  1599. printk(KERN_ERR "Unable to allocate memory for temp buffersn");
  1600. goto cleanup_boards;
  1601. }
  1603. lowwater = ch->txbufsize >= 2000 ? 1024 : ch->txbufsize/2;
  1604. fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
  1605. fepcmd(ch, SRXLWATER, ch->rxbufsize/4, 0, 10, 0);
  1606. fepcmd(ch, SRXHWATER, 3 * ch->rxbufsize/4, 0, 10, 0);
  1608. bc->edelay = 100;
  1609. bc->idata = 1;
  1611. ch->startc = bc->startc;
  1612. ch->stopc = bc->stopc;
  1613. ch->startca = bc->startca;
  1614. ch->stopca = bc->stopca;
  1616. ch->fepcflag = 0;
  1617. ch->fepiflag = 0;
  1618. ch->fepoflag = 0;
  1619. ch->fepstartc = 0;
  1620. ch->fepstopc = 0;
  1621. ch->fepstartca = 0;
  1622. ch->fepstopca = 0;
  1624. ch->close_delay = 50;
  1625. ch->count = 0;
  1626. ch->blocked_open = 0;
  1627. ch->callout_termios = pcxe_callout.init_termios;
  1628. ch->normal_termios = pcxe_driver.init_termios;
  1629. init_waitqueue_head(&ch->open_wait);
  1630. init_waitqueue_head(&ch->close_wait);
  1631. ch->asyncflags = 0;
  1632. }
  1634. if (verbose)
  1635.     printk("Card No. %d ready: %s (%s) I/O=0x%x Mem=0x%lx Ports=%dn", 
  1636.     crd+1, board_desc[bd->type], board_mem[bd->type], bd->port, 
  1637.     bd->membase, bd->numports);
  1638. else
  1639.     printk("PC/Xx: %s (%s) I/O=0x%x Mem=0x%lx Ports=%dn", 
  1640.     board_desc[bd->type], board_mem[bd->type], bd->port, 
  1641.     bd->membase, bd->numports);
  1643. memwinoff(bd, 0);
  1644. enabled_cards++;
  1645. }
  1647. if (enabled_cards <= 0) {
  1648. printk(KERN_NOTICE "PC/Xx: No cards enabled, no driver.n");
  1649. ret = -EIO;
  1650. goto cleanup_boards;
  1651. }
  1653. ret = tty_register_driver(&pcxe_driver);
  1654. if(ret) {
  1655. printk(KERN_ERR "Couldn't register PC/Xe drivern");
  1656. goto cleanup_boards;
  1657. }
  1659. ret = tty_register_driver(&pcxe_callout);
  1660. if(ret) {
  1661. printk(KERN_ERR "Couldn't register PC/Xe calloutn");
  1662. goto cleanup_pcxe_driver;
  1663. }
  1665. /*
  1666.  * Start up the poller to check for events on all enabled boards
  1667.  */
  1668. mod_timer(&pcxx_timer, HZ/25);
  1670. if (verbose)
  1671. printk(KERN_NOTICE "PC/Xx: Driver with %d card(s) ready.n", enabled_cards);
  1673. return 0;
  1674. cleanup_pcxe_driver: tty_unregister_driver(&pcxe_driver);
  1675. cleanup_boards: cleanup_board_resources();
  1676. kfree(pcxe_termios_locked);
  1677. cleanup_pcxe_termios: kfree(pcxe_termios);
  1678. cleanup_pcxe_table: kfree(pcxe_table);
  1679. cleanup_digi_channels: kfree(digi_channels);
  1680. return ret;
  1681. }
  1684. static void pcxxpoll(unsigned long dummy)
  1685. {
  1686. unsigned long flags;
  1687. int crd;
  1688. volatile unsigned int head, tail;
  1689. struct channel *ch;
  1690. struct board_info *bd;
  1692. save_flags(flags);
  1693. cli();
  1695. for(crd=0; crd < numcards; crd++) {
  1696. bd = &boards[crd];
  1698. ch = digi_channels+bd->first_minor;
  1700. if(bd->status == DISABLED)
  1701. continue;
  1703. assertmemoff(ch);
  1705. globalwinon(ch);
  1706. head = ch->mailbox->ein;
  1707. tail = ch->mailbox->eout;
  1709. if(head != tail)
  1710. doevent(crd);
  1712. memoff(ch);
  1713. }
  1715. mod_timer(&pcxx_timer, jiffies + HZ/25);
  1716. restore_flags(flags);
  1717. }
  1719. static void doevent(int crd)
  1720. {
  1721. volatile struct board_info *bd;
  1722. static struct tty_struct *tty;
  1723. volatile struct board_chan *bc;
  1724. volatile unchar *eventbuf;
  1725. volatile unsigned int head;
  1726. volatile unsigned int tail;
  1727. struct channel *ch;
  1728. struct channel *chan0;
  1729. int channel, event, mstat, lstat;
  1731. bd = &boards[crd];
  1733. chan0 = digi_channels+bd->first_minor;
  1734. pcxxassert(chan0 < digi_channels+nbdevs, "ch out of range");
  1737. assertgwinon(chan0);
  1739. while ((tail = chan0->mailbox->eout) != (head = chan0->mailbox->ein)) {
  1740. assertgwinon(chan0);
  1741. eventbuf = (volatile unchar *)phys_to_virt(bd->membase + tail + ISTART);
  1742. channel = eventbuf[0];
  1743. event = eventbuf[1];
  1744. mstat = eventbuf[2];
  1745. lstat = eventbuf[3];
  1747. ch=chan0+channel;
  1749. if ((unsigned)channel >= bd->numports || !ch) { 
  1750. printk("physmem=%lx, tail=%x, head=%xn", bd->membase, tail, head);
  1751. printk("doevent(%x) channel %x, event %x, mstat %x, lstat %xn",
  1752. crd, (unsigned)channel, event, (unsigned)mstat, lstat);
  1753. if(channel >= bd->numports)
  1754. ch = chan0;
  1755. bc = ch->brdchan;
  1756. goto next;
  1757. }
  1758. if ((bc = ch->brdchan) == NULL)
  1759. goto next;
  1761. if (event & DATA_IND) {
  1762. receive_data(ch);
  1763. assertgwinon(ch);
  1764. }
  1766. if (event & MODEMCHG_IND) {
  1767. ch->imodem = mstat;
  1768. if (ch->asyncflags & (ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE)) {
  1769. if (ch->asyncflags & ASYNC_CHECK_CD) {
  1770. if (mstat & ch->dcd) {
  1771. wake_up_interruptible(&ch->open_wait);
  1772. } else {
  1773. pcxe_sched_event(ch, PCXE_EVENT_HANGUP);
  1774. }
  1775. }
  1776. }
  1777. }
  1779. tty = ch->tty;
  1781. if (tty) {
  1783. if (event & BREAK_IND) {
  1784. tty->flip.count++;
  1785. *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  1786. *tty->flip.char_buf_ptr++ = 0;
  1787. #if 0
  1788. if (ch->asyncflags & ASYNC_SAK)
  1789. do_SAK(tty);
  1790. #endif
  1791. tty_schedule_flip(tty); 
  1792. }
  1794. if (event & LOWTX_IND) {
  1795. if (ch->statusflags & LOWWAIT) {
  1796. ch->statusflags &= ~LOWWAIT;
  1797. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1798. tty->ldisc.write_wakeup)
  1799. (tty->ldisc.write_wakeup)(tty);
  1800. wake_up_interruptible(&tty->write_wait);
  1801. }
  1802. }
  1804. if (event & EMPTYTX_IND) {
  1805. ch->statusflags &= ~TXBUSY;
  1806. if (ch->statusflags & EMPTYWAIT) {
  1807. ch->statusflags &= ~EMPTYWAIT;
  1808. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1809. tty->ldisc.write_wakeup)
  1810. (tty->ldisc.write_wakeup)(tty);
  1811. wake_up_interruptible(&tty->write_wait);
  1812. }
  1813. }
  1814. }
  1816. next:
  1817. globalwinon(ch);
  1818. if(!bc) printk("bc == NULL in doevent!n");
  1819. else bc->idata = 1;
  1821. chan0->mailbox->eout = (tail+4) & (IMAX-ISTART-4);
  1822. globalwinon(chan0);
  1823. }
  1825. }
  1828. /*
  1829.  * pcxxdelay - delays a specified number of milliseconds
  1830.  */
  1831. static void pcxxdelay(int msec)
  1832. {
  1833. mdelay(msec);
  1834. }
  1837. static void 
  1838. fepcmd(struct channel *ch, int cmd, int word_or_byte, int byte2, int ncmds,
  1839. int bytecmd)
  1840. {
  1841. unchar *memaddr;
  1842. unsigned int head, tail;
  1843. long count;
  1844. int n;
  1846. if(ch->board->status == DISABLED)
  1847. return;
  1849. assertgwinon(ch);
  1851. memaddr = (unchar *)phys_to_virt(ch->board->membase);
  1852. head = ch->mailbox->cin;
  1854. if(head >= (CMAX-CSTART) || (head & 03)) {
  1855. printk("line %d: Out of range, cmd=%x, head=%xn", __LINE__, cmd, head);
  1856. return;
  1857. }
  1859. if(bytecmd) {
  1860. *(unchar *)(memaddr+head+CSTART+0) = cmd;
  1862. *(unchar *)(memaddr+head+CSTART+1) = ch->dev - ch->board->first_minor;
  1864. *(unchar *)(memaddr+head+CSTART+2) = word_or_byte;
  1865. *(unchar *)(memaddr+head+CSTART+3) = byte2;
  1866. } else {
  1867. *(unchar *)(memaddr+head+CSTART+0) = cmd;
  1869. *(unchar *)(memaddr+head+CSTART+1) = ch->dev - ch->board->first_minor;
  1870. *(ushort*)(memaddr+head+CSTART+2) = word_or_byte;
  1871. }
  1873. head = (head+4) & (CMAX-CSTART-4);
  1874. ch->mailbox->cin = head;
  1876. count = FEPTIMEOUT;
  1878. while(1) {
  1879. count--;
  1880. if(count == 0) {
  1881. printk("Fep not responding in fepcmd()n");
  1882. return;
  1883. }
  1885. head = ch->mailbox->cin;
  1886. tail = ch->mailbox->cout;
  1888. n = (head-tail) & (CMAX-CSTART-4);
  1890. if(n <= ncmds * (sizeof(short)*4))
  1891. break;
  1892. /* Seems not to be good here: schedule(); */
  1893. }
  1894. }
  1897. static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
  1898. {
  1899. unsigned res = 0;
  1900. if (cflag & CBAUDEX)
  1901. {
  1902. ch->digiext.digi_flags |= DIGI_FAST;
  1903. res |= FEP_HUPCL;
  1904. /* This gets strange but if we don't do this we will get 78600
  1905.  * instead of 115200. 57600 is mapped to 50 baud yielding 57600 in
  1906.  * FAST mode. 115200 is mapped to 75. We need to map it to 110 to
  1907.  * do 115K
  1908.  */
  1909. if (cflag & B115200) res|=1;
  1910. }
  1911. else ch->digiext.digi_flags &= ~DIGI_FAST;
  1912. res |= cflag & (CBAUD | PARODD | PARENB | CSTOPB | CSIZE | CLOCAL);
  1913. return res;
  1914. }
  1916. static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
  1917. {
  1918. unsigned res = iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK|ISTRIP|IXON|IXANY|IXOFF);
  1920. if(ch->digiext.digi_flags & DIGI_AIXON)
  1921. res |= IAIXON;
  1922. return res;
  1923. }
  1925. static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
  1926. {
  1927. unsigned res = 0;
  1929. if(cflag & CRTSCTS) {
  1930. ch->digiext.digi_flags |= (RTSPACE|CTSPACE);
  1931. res |= (CTS | RTS);
  1932. }
  1933. if(ch->digiext.digi_flags & RTSPACE)
  1934. res |= RTS;
  1935. if(ch->digiext.digi_flags & DTRPACE)
  1936. res |= DTR;
  1937. if(ch->digiext.digi_flags & CTSPACE)
  1938. res |= CTS;
  1939. if(ch->digiext.digi_flags & DSRPACE)
  1940. res |= ch->dsr;
  1941. if(ch->digiext.digi_flags & DCDPACE)
  1942. res |= ch->dcd;
  1944. if (res & RTS)
  1945. ch->digiext.digi_flags |= RTSPACE;
  1946. if (res & CTS)
  1947. ch->digiext.digi_flags |= CTSPACE;
  1949. return res;
  1950. }
  1952. static void pcxxparam(struct tty_struct *tty, struct channel *ch)
  1953. {
  1954. volatile struct board_chan *bc;
  1955. unsigned int head;
  1956. unsigned mval, hflow, cflag, iflag;
  1957. struct termios *ts;
  1959. bc = ch->brdchan;
  1960. assertgwinon(ch);
  1961. ts = tty->termios;
  1963. if((ts->c_cflag & CBAUD) == 0) {
  1964. head = bc->rin;
  1965. bc->rout = head;
  1966. head = bc->tin;
  1967. fepcmd(ch, STOUT, (unsigned) head, 0, 0, 0);
  1968. mval = 0;
  1969. } else {
  1971. cflag = termios2digi_c(ch, ts->c_cflag);
  1973. if(cflag != ch->fepcflag) {
  1974. ch->fepcflag = cflag;
  1975. fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
  1976. }
  1978. if(cflag & CLOCAL)
  1979. ch->asyncflags &= ~ASYNC_CHECK_CD;
  1980. else {
  1981. ch->asyncflags |= ASYNC_CHECK_CD;
  1982. }
  1984. mval = DTR | RTS;
  1985. }
  1987. iflag = termios2digi_i(ch, ts->c_iflag);
  1989. if(iflag != ch->fepiflag) {
  1990. ch->fepiflag = iflag;
  1991. fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
  1992. }
  1994. bc->mint = ch->dcd;
  1995. if((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
  1996. if(ch->digiext.digi_flags & DIGI_FORCEDCD)
  1997. bc->mint = 0;
  1999. ch->imodem = bc->mstat;
  2001. hflow = termios2digi_h(ch, ts->c_cflag);
  2003. if(hflow != ch->hflow) {
  2004. ch->hflow = hflow;
  2005. fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
  2006. }
  2008. /* mval ^= ch->modemfake & (mval ^ ch->modem); */
  2010. if(ch->omodem != mval) {
  2011. ch->omodem = mval;
  2012. fepcmd(ch, SETMODEM, mval, RTS|DTR, 0, 1);
  2013. }
  2015. if(ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc) {
  2016. ch->fepstartc = ch->startc;
  2017. ch->fepstopc = ch->stopc;
  2018. fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
  2019. }
  2021. if(ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca) {
  2022. ch->fepstartca = ch->startca;
  2023. ch->fepstopca = ch->stopca;
  2024. fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
  2025. }
  2026. }
  2029. static void receive_data(struct channel *ch)
  2030. {
  2031. volatile struct board_chan *bc;
  2032. struct tty_struct *tty;
  2033. unsigned int tail, head, wrapmask;
  2034. int n;
  2035. int piece;
  2036. struct termios *ts=0;
  2037. unchar *rptr;
  2038. int rc;
  2039. int wrapgap;
  2041.     globalwinon(ch);
  2043. if (ch->statusflags & RXSTOPPED)
  2044. return;
  2046. tty = ch->tty;
  2047. if(tty)
  2048. ts = tty->termios;
  2050. bc = ch->brdchan;
  2052. if(!bc) {
  2053. printk("bc is NULL in receive_data!n");
  2054. return;
  2055. }
  2057. wrapmask = ch->rxbufsize - 1;
  2059. head = bc->rin;
  2060. head &= wrapmask;
  2061. tail = bc->rout & wrapmask;
  2063. n = (head-tail) & wrapmask;
  2065. if(n == 0)
  2066. return;
  2068. /*
  2069.  * If CREAD bit is off or device not open, set TX tail to head
  2070.  */
  2071. if(!tty || !ts || !(ts->c_cflag & CREAD)) {
  2072. bc->rout = head;
  2073. return;
  2074. }
  2076. if(tty->flip.count == TTY_FLIPBUF_SIZE) {
  2077. /* printk("tty->flip.count = TTY_FLIPBUF_SIZEn"); */
  2078. return;
  2079. }
  2081. if(bc->orun) {
  2082. bc->orun = 0;
  2083. printk("overrun! DigiBoard device minor=%dn",MINOR(tty->device));
  2084. }
  2086. rxwinon(ch);
  2087. rptr = tty->flip.char_buf_ptr;
  2088. rc = tty->flip.count;
  2089. while(n > 0) {
  2090. wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
  2091. piece = (wrapgap < n) ? wrapgap : n;
  2093. /*
  2094.  * Make sure we don't overflow the buffer
  2095.  */
  2097. if ((rc + piece) > TTY_FLIPBUF_SIZE)
  2098. piece = TTY_FLIPBUF_SIZE - rc;
  2100. if (piece == 0)
  2101. break;
  2103. memcpy(rptr, ch->rxptr + tail, piece);
  2104. rptr += piece;
  2105. rc += piece;
  2106. tail = (tail + piece) & wrapmask;
  2107. n -= piece;
  2108. }
  2109. tty->flip.count = rc;
  2110. tty->flip.char_buf_ptr = rptr;
  2111.     globalwinon(ch);
  2112. bc->rout = tail;
  2114. /* Must be called with global data */
  2115. tty_schedule_flip(ch->tty); 
  2116. return;
  2117. }
  2120. static int pcxe_ioctl(struct tty_struct *tty, struct file * file,
  2121.     unsigned int cmd, unsigned long arg)
  2122. {
  2123. struct channel *ch = (struct channel *) tty->driver_data;
  2124. volatile struct board_chan *bc;
  2125. int retval;
  2126. unsigned int mflag, mstat;
  2127. unsigned char startc, stopc;
  2128. unsigned long flags;
  2129. digiflow_t dflow;
  2131. if(ch)
  2132. bc = ch->brdchan;
  2133. else {
  2134. printk("ch is NULL in pcxe_ioctl!n");
  2135. return(-EINVAL);
  2136. }
  2138. save_flags(flags);
  2140. switch(cmd) {
  2141. case TCSBRK: /* SVID version: non-zero arg --> no break */
  2142. retval = tty_check_change(tty);
  2143. if(retval)
  2144. return retval;
  2145. setup_empty_event(tty,ch);
  2146. tty_wait_until_sent(tty, 0);
  2147. if(!arg)
  2148. digi_send_break(ch, HZ/4);    /* 1/4 second */
  2149. return 0;
  2151. case TCSBRKP: /* support for POSIX tcsendbreak() */
  2152. retval = tty_check_change(tty);
  2153. if(retval)
  2154. return retval;
  2155. setup_empty_event(tty,ch);
  2156. tty_wait_until_sent(tty, 0);
  2157. digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
  2158. return 0;
  2160. case TIOCGSOFTCAR:
  2161. return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned int *)arg);
  2163. case TIOCSSOFTCAR:
  2164. {
  2165.     unsigned int value;
  2166.     if (get_user(value, (unsigned int *) arg))
  2167.     return -EFAULT;
  2168.     tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) | (value ? CLOCAL : 0));
  2169. }
  2170. return 0;
  2172. case TIOCMODG:
  2173. case TIOCMGET:
  2174. mflag = 0;
  2176. cli();
  2177. globalwinon(ch);
  2178. mstat = bc->mstat;
  2179. memoff(ch);
  2180. restore_flags(flags);
  2182. if(mstat & DTR)
  2183. mflag |= TIOCM_DTR;
  2184. if(mstat & RTS)
  2185. mflag |= TIOCM_RTS;
  2186. if(mstat & CTS)
  2187. mflag |= TIOCM_CTS;
  2188. if(mstat & ch->dsr)
  2189. mflag |= TIOCM_DSR;
  2190. if(mstat & RI)
  2191. mflag |= TIOCM_RI;
  2192. if(mstat & ch->dcd)
  2193. mflag |= TIOCM_CD;
  2195. if (put_user(mflag, (unsigned int *) arg))
  2196. return -EFAULT;
  2197. break;
  2199. case TIOCMBIS:
  2200. case TIOCMBIC:
  2201. case TIOCMODS:
  2202. case TIOCMSET:
  2203. if (get_user(mstat, (unsigned int *) arg))
  2204. return -EFAULT;
  2206. mflag = 0;
  2207. if(mstat & TIOCM_DTR)
  2208. mflag |= DTR;
  2209. if(mstat & TIOCM_RTS)
  2210. mflag |= RTS;
  2212. switch(cmd) {
  2213. case TIOCMODS:
  2214. case TIOCMSET:
  2215. ch->modemfake = DTR|RTS;
  2216. ch->modem = mflag;
  2217. break;
  2219. case TIOCMBIS:
  2220. ch->modemfake |= mflag;
  2221. ch->modem |= mflag;
  2222. break;
  2224. case TIOCMBIC:
  2225. ch->modemfake &= ~mflag;
  2226. ch->modem &= ~mflag;
  2227. break;
  2228. }
  2230. cli();
  2231. globalwinon(ch);
  2232. pcxxparam(tty,ch);
  2233. memoff(ch);
  2234. restore_flags(flags);
  2235. break;
  2237. case TIOCSDTR:
  2238. cli();
  2239. ch->omodem |= DTR;
  2240. globalwinon(ch);
  2241. fepcmd(ch, SETMODEM, DTR, 0, 10, 1);
  2242. memoff(ch);
  2243. restore_flags(flags);
  2244. break;
  2246. case TIOCCDTR:
  2247. ch->omodem &= ~DTR;
  2248. cli();
  2249. globalwinon(ch);
  2250. fepcmd(ch, SETMODEM, 0, DTR, 10, 1);
  2251. memoff(ch);
  2252. restore_flags(flags);
  2253. break;
  2255. case DIGI_GETA:
  2256. if (copy_to_user((char*)arg, &ch->digiext, sizeof(digi_t)))
  2257. return -EFAULT;
  2258. break;
  2260. case DIGI_SETAW:
  2261. case DIGI_SETAF:
  2262. if(cmd == DIGI_SETAW) {
  2263. setup_empty_event(tty,ch);
  2264. tty_wait_until_sent(tty, 0);
  2265. }
  2266. else {
  2267. if(tty->ldisc.flush_buffer)
  2268. tty->ldisc.flush_buffer(tty);
  2269. }
  2271. /* Fall Thru */
  2273. case DIGI_SETA:
  2274. if (copy_from_user(&ch->digiext, (char*)arg, sizeof(digi_t)))
  2275. return -EFAULT;
  2276. #ifdef DEBUG_IOCTL
  2277. printk("ioctl(DIGI_SETA): flags = %xn", ch->digiext.digi_flags);
  2278. #endif
  2280. if(ch->digiext.digi_flags & DIGI_ALTPIN) {
  2281. ch->dcd = DSR;
  2282. ch->dsr = CD;
  2283. } else {
  2284. ch->dcd = CD;
  2285. ch->dsr = DSR;
  2286. }
  2288. cli();
  2289. globalwinon(ch);
  2290. pcxxparam(tty,ch);
  2291. memoff(ch);
  2292. restore_flags(flags);
  2293. break;
  2295. case DIGI_GETFLOW:
  2296. case DIGI_GETAFLOW:
  2297. cli();
  2298. globalwinon(ch);
  2299. if(cmd == DIGI_GETFLOW) {
  2300. dflow.startc = bc->startc;
  2301. dflow.stopc = bc->stopc;
  2302. } else {
  2303. dflow.startc = bc->startca;
  2304. dflow.stopc = bc->stopca;
  2305. }
  2306. memoff(ch);
  2307. restore_flags(flags);
  2309. if (copy_to_user((char*)arg, &dflow, sizeof(dflow)))
  2310. return -EFAULT;
  2311. break;
  2313. case DIGI_SETAFLOW:
  2314. case DIGI_SETFLOW:
  2315. if(cmd == DIGI_SETFLOW) {
  2316. startc = ch->startc;
  2317. stopc = ch->stopc;
  2318. } else {
  2319. startc = ch->startca;
  2320. stopc = ch->stopca;
  2321. }
  2323. if (copy_from_user(&dflow, (char*)arg, sizeof(dflow)))
  2324. return -EFAULT;
  2326. if(dflow.startc != startc || dflow.stopc != stopc) {
  2327. cli();
  2328. globalwinon(ch);
  2330. if(cmd == DIGI_SETFLOW) {
  2331. ch->fepstartc = ch->startc = dflow.startc;
  2332. ch->fepstopc = ch->stopc = dflow.stopc;
  2333. fepcmd(ch,SONOFFC,ch->fepstartc,ch->fepstopc,0, 1);
  2334. } else {
  2335. ch->fepstartca = ch->startca = dflow.startc;
  2336. ch->fepstopca  = ch->stopca = dflow.stopc;
  2337. fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
  2338. }
  2340. if(ch->statusflags & TXSTOPPED)
  2341. pcxe_start(tty);
  2343. memoff(ch);
  2344. restore_flags(flags);
  2345. }
  2346. break;
  2348. default:
  2349. return -ENOIOCTLCMD;
  2350. }
  2352. return 0;
  2353. }
  2355. static void pcxe_set_termios(struct tty_struct *tty, struct termios *old_termios)
  2356. {
  2357. struct channel *info;
  2359. if ((info=chan(tty))!=NULL) {
  2360. unsigned long flags;
  2361. save_flags(flags);
  2362. cli();
  2363. globalwinon(info);
  2364. pcxxparam(tty,info);
  2365. memoff(info);
  2367. if ((old_termios->c_cflag & CRTSCTS) &&
  2368. ((tty->termios->c_cflag & CRTSCTS) == 0))
  2369. tty->hw_stopped = 0;
  2370. if(!(old_termios->c_cflag & CLOCAL) &&
  2371. (tty->termios->c_cflag & CLOCAL))
  2372. wake_up_interruptible(&info->open_wait);
  2373. restore_flags(flags);
  2374. }
  2375. }
  2378. static void do_pcxe_bh(void)
  2379. {
  2380. run_task_queue(&tq_pcxx);
  2381. }
  2384. static void do_softint(void *private_)
  2385. {
  2386. struct channel *info = (struct channel *) private_;
  2388. if(info && info->magic == PCXX_MAGIC) {
  2389. struct tty_struct *tty = info->tty;
  2390. if (tty && tty->driver_data) {
  2391. if(test_and_clear_bit(PCXE_EVENT_HANGUP, &info->event)) {
  2392. tty_hangup(tty);
  2393. wake_up_interruptible(&info->open_wait);
  2394. info->asyncflags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  2395. }
  2396. }
  2397. }
  2398. }
  2401. static void pcxe_stop(struct tty_struct *tty)
  2402. {
  2403. struct channel *info;
  2405. if ((info=chan(tty))!=NULL) {
  2406. unsigned long flags;
  2407. save_flags(flags); 
  2408. cli();
  2409. if ((info->statusflags & TXSTOPPED) == 0) {
  2410. globalwinon(info);
  2411. fepcmd(info, PAUSETX, 0, 0, 0, 0);
  2412. info->statusflags |= TXSTOPPED;
  2413. memoff(info);
  2414. }
  2415. restore_flags(flags);
  2416. }
  2417. }
  2419. static void pcxe_throttle(struct tty_struct * tty)
  2420. {
  2421. struct channel *info;
  2423. if ((info=chan(tty))!=NULL) {
  2424. unsigned long flags;
  2425. save_flags(flags);
  2426. cli();
  2427. if ((info->statusflags & RXSTOPPED) == 0) {
  2428. globalwinon(info);
  2429. fepcmd(info, PAUSERX, 0, 0, 0, 0);
  2430. info->statusflags |= RXSTOPPED;
  2431. memoff(info);
  2432. }
  2433. restore_flags(flags);
  2434. }
  2435. }
  2437. static void pcxe_unthrottle(struct tty_struct *tty)
  2438. {
  2439. struct channel *info;
  2441. if ((info=chan(tty)) != NULL) {
  2442. unsigned long flags;
  2444. /* Just in case output was resumed because of a change in Digi-flow */
  2445. save_flags(flags);
  2446. cli();
  2447. if(info->statusflags & RXSTOPPED) {
  2448. volatile struct board_chan *bc;
  2449. globalwinon(info);
  2450. bc = info->brdchan;
  2451. fepcmd(info, RESUMERX, 0, 0, 0, 0);
  2452. info->statusflags &= ~RXSTOPPED;
  2453. memoff(info);
  2454. }
  2455. restore_flags(flags);
  2456. }
  2457. }
  2460. static void pcxe_start(struct tty_struct *tty)
  2461. {
  2462. struct channel *info;
  2464. if ((info=chan(tty))!=NULL) {
  2465. unsigned long flags;
  2467. save_flags(flags);
  2468. cli();
  2469. /* Just in case output was resumed because of a change in Digi-flow */
  2470. if(info->statusflags & TXSTOPPED) {
  2471. volatile struct board_chan *bc;
  2472. globalwinon(info);
  2473. bc = info->brdchan;
  2474. if(info->statusflags & LOWWAIT)
  2475. bc->ilow = 1;
  2476. fepcmd(info, RESUMETX, 0, 0, 0, 0);
  2477. info->statusflags &= ~TXSTOPPED;
  2478. memoff(info);
  2479. }
  2480. restore_flags(flags);
  2481. }
  2482. }
  2485. void digi_send_break(struct channel *ch, int msec)
  2486. {
  2487. unsigned long flags;
  2489. save_flags(flags);
  2490. cli();
  2491. globalwinon(ch);
  2493. /* 
  2494.  * Maybe I should send an infinite break here, schedule() for
  2495.  * msec amount of time, and then stop the break.  This way,
  2496.  * the user can't screw up the FEP by causing digi_send_break()
  2497.  * to be called (i.e. via an ioctl()) more than once in msec amount 
  2498.  * of time.  Try this for now...
  2499.  */
  2501. fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
  2502. memoff(ch);
  2504. restore_flags(flags);
  2505. }
  2507. static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
  2508. {
  2509. volatile struct board_chan *bc;
  2510. unsigned long flags;
  2512. save_flags(flags);
  2513. cli();
  2514. globalwinon(ch);
  2515. ch->statusflags |= EMPTYWAIT;
  2516. bc = ch->brdchan;
  2517. bc->iempty = 1;
  2518. memoff(ch);
  2519. restore_flags(flags);
  2520. }