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

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

嵌入式Linux

开发平台：

Unix_Linux

keyspan.c：源码内容
  1. /*
  2.   Keyspan USB to Serial Converter driver
  3.  
  4.   (C) Copyright (C) 2000-2001
  5.       Hugh Blemings <hugh@misc.nu>
  6.    
  7.   This program is free software; you can redistribute it and/or modify
  8.   it under the terms of the GNU General Public License as published by
  9.   the Free Software Foundation; either version 2 of the License, or
  10.   (at your option) any later version.
  12.   See http://misc.nu/hugh/keyspan.html for more information.
  13.   
  14.   Code in this driver inspired by and in a number of places taken
  15.   from Brian Warner's original Keyspan-PDA driver.
  17.   This driver has been put together with the support of Innosys, Inc.
  18.   and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
  19.   Thanks Guys :)
  20.   
  21.   Thanks to Paulus for miscellaneous tidy ups, some largish chunks
  22.   of much nicer and/or completely new code and (perhaps most uniquely)
  23.   having the patience to sit down and explain why and where he'd changed
  24.   stuff. 
  25.   
  26.   Tip 'o the hat to IBM (and previously Linuxcare :) for supporting 
  27.   staff in their work on open source projects.
  29.   Change History
  31.     Mon Oct  8 14:29:00 EST 2001 hugh
  32.       Fixed bug that prevented mulitport devices operating correctly
  33.       if they weren't the first unit attached.
  35.     Sat Oct  6 12:31:21 EST 2001 hugh
  36.       Added support for USA-28XA and -28XB, misc cleanups, break support
  37.       for usa26 based models thanks to David Gibson.
  39.     Thu May 31 11:56:42 PDT 2001 gkh
  40.       switched from using spinlock to a semaphore
  41.    
  42.     (04/08/2001) gb
  43. Identify version on module load.
  44.    
  45.     (11/01/2000) Adam J. Richter
  46. usb_device_id table support.
  47.    
  48.     Tue Oct 10 23:15:33 EST 2000 Hugh
  49.       Merged Paul's changes with my USA-49W mods.  Work in progress
  50.       still...
  51.   
  52.     Wed Jul 19 14:00:42 EST 2000 gkh
  53.       Added module_init and module_exit functions to handle the fact that
  54.       this driver is a loadable module now.
  55.  
  56.     Tue Jul 18 16:14:52 EST 2000 Hugh
  57.       Basic character input/output for USA-19 now mostly works,
  58.       fixed at 9600 baud for the moment.
  60.     Sat Jul  8 11:11:48 EST 2000 Hugh
  61.       First public release - nothing works except the firmware upload.
  62.       Tested on PPC and x86 architectures, seems to behave...
  63. */
  66. #include <linux/config.h>
  67. #include <linux/kernel.h>
  68. #include <linux/sched.h>
  69. #include <linux/signal.h>
  70. #include <linux/errno.h>
  71. #include <linux/poll.h>
  72. #include <linux/init.h>
  73. #include <linux/slab.h>
  74. #include <linux/fcntl.h>
  75. #include <linux/tty.h>
  76. #include <linux/tty_driver.h>
  77. #include <linux/tty_flip.h>
  78. #include <linux/module.h>
  79. #include <linux/spinlock.h>
  80. #include <linux/usb.h>
  82. #ifdef CONFIG_USB_SERIAL_DEBUG
  83. static int debug = 1;
  84. #define DEBUG
  85. #else
  86. static int debug;
  87. #undef DEBUG
  88. #endif
  90. #include <linux/usb.h>
  92. #include "usb-serial.h"
  93. #include "keyspan.h"
  95. /*
  96.  * Version Information
  97.  */
  98. #define DRIVER_VERSION "v1.1.1"
  99. #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
  100. #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
  102. #define INSTAT_BUFLEN 32
  103. #define GLOCONT_BUFLEN 64
  105. /* Per device and per port private data */
  106. struct keyspan_serial_private {
  107. /* number of active ports */
  108. atomic_t active_count;
  110. const keyspan_device_details *device_details;
  112. urb_t *instat_urb;
  113. char instat_buf[INSTAT_BUFLEN];
  115. /* XXX this one probably will need a lock */
  116. urb_t *glocont_urb;
  117. char glocont_buf[GLOCONT_BUFLEN];
  118. };
  120. struct keyspan_port_private {
  121. /* Keep track of which input & output endpoints to use */
  122. int in_flip;
  123. int out_flip;
  125. /* Keep duplicate of device details in each port
  126.    structure as well - simplifies some of the
  127.    callback functions etc. */
  128. const keyspan_device_details *device_details;
  130. /* Input endpoints and buffer for this port */
  131. urb_t *in_urbs[2];
  132. char in_buffer[2][64];
  133. /* Output endpoints and buffer for this port */
  134. urb_t *out_urbs[2];
  135. char out_buffer[2][64];
  137. /* Input ack endpoint */
  138. urb_t *inack_urb;
  139. char inack_buffer[1];
  141. /* Output control endpoint */
  142. urb_t *outcont_urb;
  143. char outcont_buffer[64];
  145. /* Settings for the port */
  146. int baud;
  147. int old_baud;
  148. unsigned int cflag;
  149. enum {flow_none, flow_cts, flow_xon} flow_control;
  150. int rts_state; /* Handshaking pins (outputs) */
  151. int dtr_state;
  152. int cts_state; /* Handshaking pins (inputs) */
  153. int dsr_state;
  154. int dcd_state;
  155. int ri_state;
  156. int break_on;
  158. unsigned long tx_start_time[2];
  159. int resend_cont; /* need to resend control packet */
  160. };
  163. /* Include Keyspan message headers.  All current Keyspan Adapters
  164.    make use of one of three message formats which are referred
  165.    to as USA-26, USA-28 and USA-49 by Keyspan and within this driver. */
  166. #include "keyspan_usa26msg.h"
  167. #include "keyspan_usa28msg.h"
  168. #include "keyspan_usa49msg.h"
  170. /* If you don't get debugging output, uncomment the following
  171.    two lines to enable cheat. */
  172. #if 0
  173.   #undef  dbg 
  174.   #define dbg printk 
  175. #endif
  178. /* Functions used by new usb-serial code. */
  179. static int __init keyspan_init (void)
  180. {
  181. usb_serial_register (&keyspan_usa18x_pre_device);
  182. usb_serial_register (&keyspan_usa19_pre_device);
  183. usb_serial_register (&keyspan_usa19w_pre_device);
  184. usb_serial_register (&keyspan_usa28_pre_device);
  185. usb_serial_register (&keyspan_usa28x_pre_device);
  186. usb_serial_register (&keyspan_usa28xa_pre_device);
  187. usb_serial_register (&keyspan_usa28xb_pre_device);
  188. usb_serial_register (&keyspan_usa49w_pre_device);
  190. usb_serial_register (&keyspan_usa18x_device);
  191. usb_serial_register (&keyspan_usa19_device);
  192. usb_serial_register (&keyspan_usa19w_device);
  193. usb_serial_register (&keyspan_usa28_device);
  194. usb_serial_register (&keyspan_usa28x_device);
  195. usb_serial_register (&keyspan_usa28xa_device);
  196. /* We don't need a separate entry for the usa28xb as it appears as a 28x anyway */
  197. usb_serial_register (&keyspan_usa49w_device);
  199. info(DRIVER_VERSION ":" DRIVER_DESC);
  201. return 0;
  202. }
  204. static void __exit keyspan_exit (void)
  205. {
  206. usb_serial_deregister (&keyspan_usa18x_pre_device);
  207. usb_serial_deregister (&keyspan_usa19_pre_device);
  208. usb_serial_deregister (&keyspan_usa19w_pre_device);
  209. usb_serial_deregister (&keyspan_usa28_pre_device);
  210. usb_serial_deregister (&keyspan_usa28x_pre_device);
  211. usb_serial_deregister (&keyspan_usa28xa_pre_device);
  212. usb_serial_deregister (&keyspan_usa28xb_pre_device);
  213. usb_serial_deregister (&keyspan_usa49w_pre_device);
  215. usb_serial_deregister (&keyspan_usa18x_device);
  216. usb_serial_deregister (&keyspan_usa19_device);
  217. usb_serial_deregister (&keyspan_usa19w_device);
  218. usb_serial_deregister (&keyspan_usa28_device);
  219. usb_serial_deregister (&keyspan_usa28x_device);
  220. usb_serial_deregister (&keyspan_usa28xa_device);
  221. /* We don't need a separate entry for the usa28xb as it appears as a 28x anyway */
  222. usb_serial_deregister (&keyspan_usa49w_device);
  223. }
  225. module_init(keyspan_init);
  226. module_exit(keyspan_exit);
  228. static void keyspan_rx_throttle (struct usb_serial_port *port)
  229. {
  230. dbg("keyspan_rx_throttle port %dn", port->number);
  231. }
  234. static void keyspan_rx_unthrottle (struct usb_serial_port *port)
  235. {
  236. dbg("keyspan_rx_unthrottle port %dn", port->number);
  237. }
  240. static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
  241. {
  242. struct keyspan_port_private  *p_priv;
  244.   dbg("keyspan_break_ctln");
  246. p_priv = (struct keyspan_port_private *)port->private;
  248. if (break_state == -1)
  249. p_priv->break_on = 1;
  250. else
  251. p_priv->break_on = 0;
  253. keyspan_send_setup(port, 0);
  254. }
  257. static void keyspan_set_termios (struct usb_serial_port *port, 
  258.      struct termios *old_termios)
  259. {
  260. int baud_rate;
  261. struct keyspan_port_private  *p_priv;
  262. const keyspan_device_details *d_details;
  263. unsigned int  cflag;
  265. dbg(__FUNCTION__ ".n"); 
  267. p_priv = (struct keyspan_port_private *)(port->private);
  268. d_details = p_priv->device_details;
  269. cflag = port->tty->termios->c_cflag;
  271. /* Baud rate calculation takes baud rate as an integer
  272.    so other rates can be generated if desired. */
  273. baud_rate = tty_get_baud_rate(port->tty);
  274. /* If no match or invalid, don't change */
  275. if (baud_rate >= 0
  276.     && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
  277. NULL, NULL, NULL) == KEYSPAN_BAUD_RATE_OK) {
  278. /* FIXME - more to do here to ensure rate changes cleanly */
  279. p_priv->baud = baud_rate;
  280. }
  282. /* set CTS/RTS handshake etc. */
  283. p_priv->cflag = cflag;
  284. p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
  286. keyspan_send_setup(port, 0);
  287. }
  289. static int keyspan_ioctl(struct usb_serial_port *port, struct file *file,
  290.      unsigned int cmd, unsigned long arg)
  291. {
  292. unsigned int value, set;
  293. struct keyspan_port_private  *p_priv;
  295. p_priv = (struct keyspan_port_private *)(port->private);
  297. switch (cmd) {
  298. case TIOCMGET:
  299. value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
  300. ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
  301. ((p_priv->cts_state) ? TIOCM_CTS : 0) |
  302. ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
  303. ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
  304. ((p_priv->ri_state) ? TIOCM_RNG : 0); 
  306. if (put_user(value, (unsigned int *) arg))
  307. return -EFAULT;
  308. return 0;
  310. case TIOCMSET:
  311. if (get_user(value, (unsigned int *) arg))
  312. return -EFAULT;
  313. p_priv->rts_state = ((value & TIOCM_RTS) ? 1 : 0);
  314. p_priv->dtr_state = ((value & TIOCM_DTR) ? 1 : 0);
  315. keyspan_send_setup(port, 0);
  316. return 0;
  318. case TIOCMBIS:
  319. case TIOCMBIC:
  320. if (get_user(value, (unsigned int *) arg))
  321. return -EFAULT;
  322. set = (cmd == TIOCMBIS);
  323. if (value & TIOCM_RTS)
  324. p_priv->rts_state = set;
  325. if (value & TIOCM_DTR)
  326. p_priv->dtr_state = set;
  327. keyspan_send_setup(port, 0);
  328. return 0;
  329. }
  331. return -ENOIOCTLCMD;
  332. }
  334. /* Write function is generic for the three protocols used
  335.    with only a minor change for usa49 required */
  336. static int keyspan_write(struct usb_serial_port *port, int from_user, 
  337.  const unsigned char *buf, int count)
  338. {
  339. struct keyspan_port_private  *p_priv;
  340. const keyspan_device_details *d_details;
  341. int flip;
  342. int  left, todo;
  343. urb_t  *this_urb;
  344. int  err;
  346. p_priv = (struct keyspan_port_private *)(port->private);
  347. d_details = p_priv->device_details;
  349. #if 0
  350. dbg(__FUNCTION__ " for port %d (%d chars [%x]), flip=%dn",
  351.     port->number, count, buf[0], p_priv->out_flip);
  352. #endif
  354. for (left = count; left > 0; left -= todo) {
  355. todo = left;
  356. if (todo > 63)
  357. todo = 63;
  359. flip = p_priv->out_flip;
  361. /* Check we have a valid urb/endpoint before we use it... */
  362. if ((this_urb = p_priv->out_urbs[flip]) == 0) {
  363. /* no bulk out, so return 0 bytes written */
  364. dbg(__FUNCTION__ " no output urb :(n");
  365. return count;
  366. }
  368. dbg(__FUNCTION__ " endpoint %dn", usb_pipeendpoint(this_urb->pipe));
  370. if (this_urb->status == -EINPROGRESS) {
  371. if (this_urb->transfer_flags & USB_ASYNC_UNLINK)
  372. break;
  373. if (jiffies - p_priv->tx_start_time[flip] < 10 * HZ)
  374. break;
  375. this_urb->transfer_flags |= USB_ASYNC_UNLINK;
  376. usb_unlink_urb(this_urb);
  377. break;
  378. }
  380. /* First byte in buffer is "last flag" - unused so
  381.    for now so set to zero */
  382. ((char *)this_urb->transfer_buffer)[0] = 0;
  384. if (from_user) {
  385. if (copy_from_user(this_urb->transfer_buffer + 1, buf, todo))
  386. return -EFAULT;
  387. } else {
  388. memcpy (this_urb->transfer_buffer + 1, buf, todo);
  389. }
  390. buf += todo;
  392. /* send the data out the bulk port */
  393. this_urb->transfer_buffer_length = todo + 1;
  395. this_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
  396. this_urb->dev = port->serial->dev;
  397. if ((err = usb_submit_urb(this_urb)) != 0) {
  398. dbg("usb_submit_urb(write bulk) failed (%d)n", err);
  399. }
  400. p_priv->tx_start_time[flip] = jiffies;
  402. /* Flip for next time if usa26 or usa28 interface
  403.    (not used on usa49) */
  404. p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
  405. }
  407. return count - left;
  408. }
  410. static void usa26_indat_callback(struct urb *urb)
  411. {
  412. int i, err;
  413. int endpoint;
  414. struct usb_serial_port *port;
  415. struct tty_struct *tty;
  416. unsigned char  *data = urb->transfer_buffer;
  418. dbg ("%sn", __FUNCTION__); 
  420. endpoint = usb_pipeendpoint(urb->pipe);
  422. if (urb->status) {
  423. dbg(__FUNCTION__ "nonzero status: %x on endpoint %d.n",
  424.        urb->status, endpoint);
  425. return;
  426. }
  428. port = (struct usb_serial_port *) urb->context;
  429. tty = port->tty;
  430. if (urb->actual_length) {
  431. if (data[0] == 0) {
  432. /* no error on any byte */
  433. for (i = 1; i < urb->actual_length ; ++i) {
  434. tty_insert_flip_char(tty, data[i], 0);
  435. }
  436. } else {
  437. /* some bytes had errors, every byte has status */
  438. for (i = 0; i + 1 < urb->actual_length; i += 2) {
  439. int stat = data[i], flag = 0;
  440. if (stat & RXERROR_OVERRUN)
  441. flag |= TTY_OVERRUN;
  442. if (stat & RXERROR_FRAMING)
  443. flag |= TTY_FRAME;
  444. if (stat & RXERROR_PARITY)
  445. flag |= TTY_PARITY;
  446. /* XXX should handle break (0x10) */
  447. tty_insert_flip_char(tty, data[i+1], flag);
  448. }
  449. }
  450. tty_flip_buffer_push(tty);
  451. }
  453. /* Resubmit urb so we continue receiving */
  454. urb->dev = port->serial->dev;
  455. if ((err = usb_submit_urb(urb)) != 0) {
  456. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n", err);
  457. }
  458. return;
  459. }
  461. /* Outdat handling is common for usa26, usa28 and usa49 messages */
  462. static void usa2x_outdat_callback(struct urb *urb)
  463. {
  464. struct usb_serial_port *port;
  465. struct keyspan_port_private *p_priv;
  467. port = (struct usb_serial_port *) urb->context;
  468. p_priv = (struct keyspan_port_private *)(port->private);
  469. dbg (__FUNCTION__ " urb %dn", urb == p_priv->out_urbs[1]); 
  471. if (port->active) {
  472. queue_task(&port->tqueue, &tq_immediate);
  473. mark_bh(IMMEDIATE_BH);
  474. }
  475. }
  477. static void usa26_inack_callback(struct urb *urb)
  478. {
  479. dbg ("%sn", __FUNCTION__); 
  481. }
  483. static void usa26_outcont_callback(struct urb *urb)
  484. {
  485. struct usb_serial_port *port;
  486. struct keyspan_port_private *p_priv;
  488. port = (struct usb_serial_port *) urb->context;
  489. p_priv = (struct keyspan_port_private *)(port->private);
  491. if (p_priv->resend_cont) {
  492. dbg (__FUNCTION__ " sending setupn"); 
  493. keyspan_usa26_send_setup(port->serial, port, 0);
  494. }
  495. }
  497. static void usa26_instat_callback(struct urb *urb)
  498. {
  499. unsigned char  *data = urb->transfer_buffer;
  500. keyspan_usa26_portStatusMessage *msg;
  501. struct usb_serial *serial;
  502. struct usb_serial_port *port;
  503. struct keyspan_port_private   *p_priv;
  504. int old_dcd_state, err;
  506. serial = (struct usb_serial *) urb->context;
  508. if (urb->status) {
  509. dbg(__FUNCTION__ " nonzero status: %xn", urb->status);
  510. return;
  511. }
  512. if (urb->actual_length != 9) {
  513. dbg(__FUNCTION__ " %d byte report??n", urb->actual_length);
  514. goto exit;
  515. }
  517. msg = (keyspan_usa26_portStatusMessage *)data;
  519. #if 0
  520. dbg(__FUNCTION__ " port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %dn",
  521.     msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff,
  522.     msg->_txXoff, msg->rxEnabled, msg->controlResponse);
  523. #endif
  525. /* Now do something useful with the data */
  528. /* Check port number from message and retrieve private data */
  529. if (msg->port >= serial->num_ports) {
  530. dbg ("Unexpected port number %dn", msg->port);
  531. goto exit;
  532. }
  533. port = &serial->port[msg->port];
  534. p_priv = (struct keyspan_port_private *)(port->private);
  536. /* Update handshaking pin state information */
  537. old_dcd_state = p_priv->dcd_state;
  538. p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
  539. p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
  540. p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
  541. p_priv->ri_state = ((msg->ri) ? 1 : 0);
  543. if (port->tty && !C_CLOCAL(port->tty)
  544.     && old_dcd_state != p_priv->dcd_state) {
  545. if (old_dcd_state)
  546. tty_hangup(port->tty);
  547. /*  else */
  548. /* wake_up_interruptible(&p_priv->open_wait); */
  549. }
  551. exit:
  552. /* Resubmit urb so we continue receiving */
  553. urb->dev = serial->dev;
  554. if ((err = usb_submit_urb(urb)) != 0) {
  555. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n", err);
  556. }
  557. }
  559. static void usa26_glocont_callback(struct urb *urb)
  560. {
  561. dbg ("%sn", __FUNCTION__);
  563. }
  566. static void     usa28_indat_callback(struct urb *urb)
  567. {
  568. int                     i, err;
  569. struct usb_serial_port  *port;
  570. struct tty_struct       *tty;
  571. unsigned char           *data;
  572. struct keyspan_port_private             *p_priv;
  574. dbg ("%sn", __FUNCTION__);
  576. port = (struct usb_serial_port *) urb->context;
  577. p_priv = (struct keyspan_port_private *)(port->private);
  578. data = urb->transfer_buffer;
  580. if (urb != p_priv->in_urbs[p_priv->in_flip])
  581. return;
  583. do {
  584. if (urb->status) {
  585. dbg(__FUNCTION__ "nonzero status: %x on endpoint
  586. %d.n",
  587.     urb->status, usb_pipeendpoint(urb->pipe));
  588. return;
  589. }
  591. port = (struct usb_serial_port *) urb->context;
  592. p_priv = (struct keyspan_port_private *)(port->private);
  593. data = urb->transfer_buffer;
  595. tty = port->tty;
  596. if (urb->actual_length) {
  597. for (i = 0; i < urb->actual_length ; ++i) {
  598. tty_insert_flip_char(tty, data[i], 0);
  599. }
  600. tty_flip_buffer_push(tty);
  601. }
  603. /* Resubmit urb so we continue receiving */
  604. urb->dev = port->serial->dev;
  605. if ((err = usb_submit_urb(urb)) != 0) {
  606. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n",
  607. err);
  608. }
  609. p_priv->in_flip ^= 1;
  611. urb = p_priv->in_urbs[p_priv->in_flip];
  612. } while (urb->status != -EINPROGRESS);
  613. }
  615. static void usa28_inack_callback(struct urb *urb)
  616. {
  617. dbg ("%sn", __FUNCTION__);
  618. }
  620. static void usa28_outcont_callback(struct urb *urb)
  621. {
  622. struct usb_serial_port *port;
  623. struct keyspan_port_private *p_priv;
  625. port = (struct usb_serial_port *) urb->context;
  626. p_priv = (struct keyspan_port_private *)(port->private);
  628. if (p_priv->resend_cont) {
  629. dbg (__FUNCTION__ " sending setupn");
  630. keyspan_usa28_send_setup(port->serial, port, 0);
  631. }
  632. }
  634. static void usa28_instat_callback(struct urb *urb)
  635. {
  636. int err;
  637. unsigned char  *data = urb->transfer_buffer;
  638. keyspan_usa28_portStatusMessage *msg;
  639. struct usb_serial *serial;
  640. struct usb_serial_port *port;
  641. struct keyspan_port_private   *p_priv;
  642. int old_dcd_state;
  644. serial = (struct usb_serial *) urb->context;
  646. if (urb->status) {
  647. dbg(__FUNCTION__ " nonzero status: %xn", urb->status);
  648. return;
  649. }
  651. if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
  652. dbg(__FUNCTION__ " bad length %dn", urb->actual_length);
  653. goto exit;
  654. }
  656. /*dbg(__FUNCTION__ " %x %x %x %x %x %x %x %x %x %x %x %xn",
  657.     data[0], data[1], data[2], data[3], data[4], data[5],
  658.     data[6], data[7], data[8], data[9], data[10], data[11]);*/
  660. /* Now do something useful with the data */
  661. msg = (keyspan_usa28_portStatusMessage *)data;
  664. /* Check port number from message and retrieve private data */
  665. if (msg->port >= serial->num_ports) {
  666. dbg ("Unexpected port number %dn", msg->port);
  667. goto exit;
  668. }
  669. port = &serial->port[msg->port];
  670. p_priv = (struct keyspan_port_private *)(port->private);
  672. /* Update handshaking pin state information */
  673. old_dcd_state = p_priv->dcd_state;
  674. p_priv->cts_state = ((msg->cts) ? 1 : 0);
  675. p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
  676. p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
  677. p_priv->ri_state = ((msg->ri) ? 1 : 0);
  679. if (port->tty && !C_CLOCAL(port->tty)
  680.     && old_dcd_state != p_priv->dcd_state) {
  681. if (old_dcd_state)
  682. tty_hangup(port->tty);
  683. /*  else */
  684. /* wake_up_interruptible(&p_priv->open_wait); */
  685. }
  687. exit:
  688. /* Resubmit urb so we continue receiving */
  689. urb->dev = serial->dev;
  690. if ((err = usb_submit_urb(urb)) != 0) {
  691. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n", err);
  692. }
  693. }
  695. static void usa28_glocont_callback(struct urb *urb)
  696. {
  697. dbg ("%sn", __FUNCTION__);
  698. }
  701. static void usa49_glocont_callback(struct urb *urb)
  702. {
  703. struct usb_serial *serial;
  704. struct usb_serial_port *port;
  705. struct keyspan_port_private *p_priv;
  706. int i;
  708. dbg ("%sn", __FUNCTION__);
  710. serial = (struct usb_serial *) urb->context;
  711. for (i = 0; i < serial->num_ports; ++i) {
  712. port = &serial->port[i];
  713. p_priv = (struct keyspan_port_private *)(port->private);
  715. if (p_priv->resend_cont) {
  716. dbg (__FUNCTION__ " sending setupn"); 
  717. keyspan_usa49_send_setup(serial, port, 0);
  718. break;
  719. }
  720. }
  721. }
  723. /* This is actually called glostat in the Keyspan
  724.    doco */
  725. static void usa49_instat_callback(struct urb *urb)
  726. {
  727. int err;
  728. unsigned char  *data = urb->transfer_buffer;
  729. keyspan_usa49_portStatusMessage *msg;
  730. struct usb_serial *serial;
  731. struct usb_serial_port *port;
  732. struct keyspan_port_private   *p_priv;
  733. int old_dcd_state;
  735. dbg ("%sn", __FUNCTION__);
  737. serial = (struct usb_serial *) urb->context;
  739. if (urb->status) {
  740. dbg(__FUNCTION__ " nonzero status: %xn", urb->status);
  741. return;
  742. }
  744. if (urb->actual_length != sizeof(struct keyspan_usa49_portStatusMessage)) {
  745. dbg(__FUNCTION__ " bad length %dn", urb->actual_length);
  746. goto exit;
  747. }
  749. /*dbg(__FUNCTION__ " %x %x %x %x %x %x %x %x %x %x %xn",
  750.     data[0], data[1], data[2], data[3], data[4], data[5],
  751.     data[6], data[7], data[8], data[9], data[10]);*/
  753. /* Now do something useful with the data */
  754. msg = (keyspan_usa49_portStatusMessage *)data;
  756. /* Check port number from message and retrieve private data */
  757. if (msg->portNumber >= serial->num_ports) {
  758. dbg ("Unexpected port number %dn", msg->portNumber);
  759. goto exit;
  760. }
  761. port = &serial->port[msg->portNumber];
  762. p_priv = (struct keyspan_port_private *)(port->private);
  764. /* Update handshaking pin state information */
  765. old_dcd_state = p_priv->dcd_state;
  766. p_priv->cts_state = ((msg->cts) ? 1 : 0);
  767. p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
  768. p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
  769. p_priv->ri_state = ((msg->ri) ? 1 : 0);
  771. if (port->tty && !C_CLOCAL(port->tty)
  772.     && old_dcd_state != p_priv->dcd_state) {
  773. if (old_dcd_state)
  774. tty_hangup(port->tty);
  775. /*  else */
  776. /* wake_up_interruptible(&p_priv->open_wait); */
  777. }
  779. exit:
  780. /* Resubmit urb so we continue receiving */
  781. urb->dev = serial->dev;
  783. if ((err = usb_submit_urb(urb)) != 0) {
  784. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n", err);
  785. }
  786. }
  788. static void usa49_inack_callback(struct urb *urb)
  789. {
  790. dbg ("%sn", __FUNCTION__);
  791. }
  793. static void usa49_indat_callback(struct urb *urb)
  794. {
  795. int i, err;
  796. int endpoint;
  797. struct usb_serial_port *port;
  798. struct tty_struct *tty;
  799. unsigned char  *data = urb->transfer_buffer;
  801. dbg ("%sn", __FUNCTION__);
  803. endpoint = usb_pipeendpoint(urb->pipe);
  805. if (urb->status) {
  806. dbg(__FUNCTION__ "nonzero status: %x on endpoint %d.n",
  807.        urb->status, endpoint);
  808. return;
  809. }
  811. port = (struct usb_serial_port *) urb->context;
  812. tty = port->tty;
  813. if (urb->actual_length) {
  814. if (data[0] == 0) {
  815. /* no error on any byte */
  816. for (i = 1; i < urb->actual_length ; ++i) {
  817. tty_insert_flip_char(tty, data[i], 0);
  818. }
  819. } else {
  820. /* some bytes had errors, every byte has status */
  821. for (i = 0; i + 1 < urb->actual_length; i += 2) {
  822. int stat = data[i], flag = 0;
  823. if (stat & RXERROR_OVERRUN)
  824. flag |= TTY_OVERRUN;
  825. if (stat & RXERROR_FRAMING)
  826. flag |= TTY_FRAME;
  827. if (stat & RXERROR_PARITY)
  828. flag |= TTY_PARITY;
  829. /* XXX should handle break (0x10) */
  830. tty_insert_flip_char(tty, data[i+1], flag);
  831. }
  832. }
  833. tty_flip_buffer_push(tty);
  834. }
  836. /* Resubmit urb so we continue receiving */
  837. urb->dev = port->serial->dev;
  838. if ((err = usb_submit_urb(urb)) != 0) {
  839. dbg(__FUNCTION__ "resubmit read urb failed. (%d)n", err);
  840. }
  841. }
  843. /* not used, usa-49 doesn't have per-port control endpoints */
  844. static void usa49_outcont_callback(struct urb *urb)
  845. {
  846. dbg ("%sn", __FUNCTION__);
  847. }
  851. static int keyspan_write_room (struct usb_serial_port *port)
  852. {
  853. dbg("keyspan_write_room calledn");
  854. return (32);
  856. }
  859. static int keyspan_chars_in_buffer (struct usb_serial_port *port)
  860. {
  861. return (0);
  862. }
  865. static int keyspan_open (struct usb_serial_port *port, struct file *filp)
  866. {
  867. struct keyspan_port_private  *p_priv;
  868. struct keyspan_serial_private  *s_priv;
  869. struct usb_serial  *serial = port->serial;
  870. const keyspan_device_details *d_details;
  871. int i, already_active, err;
  872. urb_t *urb;
  874. s_priv = (struct keyspan_serial_private *)(serial->private);
  875. p_priv = (struct keyspan_port_private *)(port->private);
  876. d_details = s_priv->device_details;
  878. dbg("keyspan_open called for port%d.n", port->number); 
  880. MOD_INC_USE_COUNT;
  882. down (&port->sem);
  883. ++port->open_count;
  884. already_active = port->active;
  885. port->active = 1;
  886. up (&port->sem);
  888. if (already_active)
  889. return 0;
  891. p_priv = (struct keyspan_port_private *)(port->private);
  893. /* Set some sane defaults */
  894. p_priv->rts_state = 1;
  895. p_priv->dtr_state = 1;
  897. /* Start reading from endpoints */
  898. for (i = 0; i < 2; i++) {
  899. if ((urb = p_priv->in_urbs[i]) == NULL)
  900. continue;
  901. urb->dev = serial->dev;
  902. if ((err = usb_submit_urb(urb)) != 0) {
  903. dbg(__FUNCTION__ " submit urb %d failed (%d)n", i, err);
  904. }
  905. }
  907. keyspan_set_termios(port, NULL);
  909. return (0);
  910. }
  912. static inline void stop_urb(urb_t *urb)
  913. {
  914. if (urb && urb->status == -EINPROGRESS) {
  915. urb->transfer_flags &= ~USB_ASYNC_UNLINK;
  916. usb_unlink_urb(urb);
  917. }
  918. }
  920. static void keyspan_close(struct usb_serial_port *port, struct file *filp)
  921. {
  922. int i;
  923. struct usb_serial *serial;
  924. struct keyspan_serial_private  *s_priv;
  925. struct keyspan_port_private  *p_priv;
  927. serial = get_usb_serial (port, __FUNCTION__);
  928. if (!serial)
  929. return;
  931. dbg("keyspan_close calledn");
  932. s_priv = (struct keyspan_serial_private *)(serial->private);
  933. p_priv = (struct keyspan_port_private *)(port->private);
  935. p_priv->rts_state = 0;
  936. p_priv->dtr_state = 0;
  938. if (serial->dev)
  939. keyspan_send_setup(port, 1);
  941. /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
  942. dbg("close - urb in progressn");
  943. }*/
  945. p_priv->out_flip = 0;
  946. p_priv->in_flip = 0;
  948. down (&port->sem);
  950. if (--port->open_count <= 0) {
  951. if (port->active) {
  952. if (serial->dev) {
  953. /* Stop reading/writing urbs */
  954. stop_urb(p_priv->inack_urb);
  955. stop_urb(p_priv->outcont_urb);
  956. for (i = 0; i < 2; i++) {
  957. stop_urb(p_priv->in_urbs[i]);
  958. stop_urb(p_priv->out_urbs[i]);
  959. }
  960. }
  961. }
  962. port->active = 0;
  963. port->open_count = 0;
  964. port->tty = 0;
  965. }
  966. up (&port->sem);
  968. MOD_DEC_USE_COUNT;
  969. }
  972. /* download the firmware to a pre-renumeration device */
  973. static int keyspan_fake_startup (struct usb_serial *serial)
  974. {
  975. int  response;
  976. const struct ezusb_hex_record  *record;
  977. char *fw_name;
  979. dbg("Keyspan startup version %04x product %04xn",
  980.     serial->dev->descriptor.bcdDevice,
  981.     serial->dev->descriptor.idProduct); 
  983. if ((serial->dev->descriptor.bcdDevice & 0x8000) != 0x8000) {
  984. dbg("Firmware already loaded.  Quitting.n");
  985. return(1);
  986. }
  988. /* Select firmware image on the basis of idProduct */
  989. switch (serial->dev->descriptor.idProduct) {
  990. case keyspan_usa28_pre_product_id:
  991. record = &keyspan_usa28_firmware[0];
  992. fw_name = "USA28";
  993. break;
  995. case keyspan_usa28x_pre_product_id:
  996. record = &keyspan_usa28x_firmware[0];
  997. fw_name = "USA28X";
  998. break;
  1000. case keyspan_usa28xa_pre_product_id:
  1001. record = &keyspan_usa28xa_firmware[0];
  1002. fw_name = "USA28XA";
  1003. break;
  1005. case keyspan_usa28xb_pre_product_id:
  1006. record = &keyspan_usa28xb_firmware[0];
  1007. fw_name = "USA28XB";
  1008. break;
  1010. case keyspan_usa19_pre_product_id:
  1011. record = &keyspan_usa19_firmware[0];
  1012. fw_name = "USA19";
  1013. break;
  1014.      
  1015. case keyspan_usa18x_pre_product_id:
  1016. record = &keyspan_usa18x_firmware[0];
  1017. fw_name = "USA18X";
  1018. break;
  1019.      
  1020. case keyspan_usa19w_pre_product_id:
  1021. record = &keyspan_usa19w_firmware[0];
  1022. fw_name = "USA19W";
  1023. break;
  1025. case keyspan_usa49w_pre_product_id:
  1026. record = &keyspan_usa49w_firmware[0];
  1027. fw_name = "USA49W";
  1028. break;
  1030. default:
  1031. record = NULL;
  1032. fw_name = "Unknown";
  1033. break;
  1034. }
  1036. if (record == NULL) {
  1037. err("Required keyspan firmware image (%s) unavailable.", fw_name);
  1038. return(1);
  1039. }
  1041. dbg("Uploading Keyspan %s firmware.n", fw_name);
  1043. /* download the firmware image */
  1044. response = ezusb_set_reset(serial, 1);
  1046. while(record->address != 0xffff) {
  1047. response = ezusb_writememory(serial, record->address,
  1048.      (unsigned char *)record->data,
  1049.      record->data_size, 0xa0);
  1050. if (response < 0) {
  1051. err("ezusb_writememory failed for Keyspan"
  1052.     "firmware (%d %04X %p %d)",
  1053.     response, 
  1054.     record->address, record->data, record->data_size);
  1055. break;
  1056. }
  1057. record++;
  1058. }
  1059. /* bring device out of reset. Renumeration will occur in a
  1060.    moment and the new device will bind to the real driver */
  1061. response = ezusb_set_reset(serial, 0);
  1063. /* we don't want this device to have a driver assigned to it. */
  1064. return (1);
  1065. }
  1067. /* Helper functions used by keyspan_setup_urbs */
  1068. static urb_t *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
  1069. int dir, void *ctx, char *buf, int len,
  1070. void (*callback)(urb_t *))
  1071. {
  1072. urb_t *urb;
  1074. if (endpoint == -1)
  1075. return NULL; /* endpoint not needed */
  1077. dbg (__FUNCTION__ " alloc for endpoint %d.n", endpoint);
  1078. urb = usb_alloc_urb(0); /* No ISO */
  1079. if (urb == NULL) {
  1080. dbg (__FUNCTION__ " alloc for endpoint %d failed.n", endpoint);
  1081. return NULL;
  1082. }
  1084. /* Fill URB using supplied data. */
  1085. FILL_BULK_URB(urb, serial->dev,
  1086.       usb_sndbulkpipe(serial->dev, endpoint) | dir,
  1087.       buf, len, callback, ctx);
  1089. return urb;
  1090. }
  1092. static struct callbacks {
  1093. void (*instat_callback)(urb_t *);
  1094. void (*glocont_callback)(urb_t *);
  1095. void (*indat_callback)(urb_t *);
  1096. void (*outdat_callback)(urb_t *);
  1097. void (*inack_callback)(urb_t *);
  1098. void (*outcont_callback)(urb_t *);
  1099. } keyspan_callbacks[] = {
  1100. {
  1101. /* msg_usa26 callbacks */
  1102. instat_callback: usa26_instat_callback,
  1103. glocont_callback: usa26_glocont_callback,
  1104. indat_callback: usa26_indat_callback,
  1105. outdat_callback: usa2x_outdat_callback,
  1106. inack_callback: usa26_inack_callback,
  1107. outcont_callback: usa26_outcont_callback,
  1108. }, {
  1109. /* msg_usa28 callbacks */
  1110. instat_callback: usa28_instat_callback,
  1111. glocont_callback: usa28_glocont_callback,
  1112. indat_callback: usa28_indat_callback,
  1113. outdat_callback: usa2x_outdat_callback,
  1114. inack_callback: usa28_inack_callback,
  1115. outcont_callback: usa28_outcont_callback,
  1116. }, {
  1117. /* msg_usa49 callbacks */
  1118. instat_callback: usa49_instat_callback,
  1119. glocont_callback: usa49_glocont_callback,
  1120. indat_callback: usa49_indat_callback,
  1121. outdat_callback: usa2x_outdat_callback,
  1122. inack_callback: usa49_inack_callback,
  1123. outcont_callback: usa49_outcont_callback,
  1124. }
  1125. };
  1127. /* Generic setup urbs function that uses
  1128.    data in device_details */
  1129. static void keyspan_setup_urbs(struct usb_serial *serial)
  1130. {
  1131. int i, j;
  1132. struct keyspan_serial_private  *s_priv;
  1133. const keyspan_device_details *d_details;
  1134. struct usb_serial_port *port;
  1135. struct keyspan_port_private *p_priv;
  1136. struct callbacks *cback;
  1137. int endp;
  1139. dbg ("%sn", __FUNCTION__);
  1141. s_priv = (struct keyspan_serial_private *)(serial->private);
  1142. d_details = s_priv->device_details;
  1144. /* Setup values for the various callback routines */
  1145. cback = &keyspan_callbacks[d_details->msg_format];
  1147. /* Allocate and set up urbs for each one that is in use, 
  1148.    starting with instat endpoints */
  1149. s_priv->instat_urb = keyspan_setup_urb
  1150. (serial, d_details->instat_endpoint, USB_DIR_IN,
  1151.  serial, s_priv->instat_buf, INSTAT_BUFLEN,
  1152.  cback->instat_callback);
  1154. s_priv->glocont_urb = keyspan_setup_urb
  1155. (serial, d_details->glocont_endpoint, USB_DIR_OUT,
  1156.  serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
  1157.  cback->glocont_callback);
  1159. /* Setup endpoints for each port specific thing */
  1160. for (i = 0; i < d_details->num_ports; i ++) {
  1161. port = &serial->port[i];
  1162. p_priv = (struct keyspan_port_private *)(port->private);
  1164. /* Do indat endpoints first, once for each flip */
  1165. endp = d_details->indat_endpoints[i];
  1166. for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) {
  1167. p_priv->in_urbs[j] = keyspan_setup_urb
  1168. (serial, endp, USB_DIR_IN, port,
  1169.  p_priv->in_buffer[j], 64,
  1170.  cback->indat_callback);
  1171. }
  1172. for (; j < 2; ++j)
  1173. p_priv->in_urbs[j] = NULL;
  1175. /* outdat endpoints also have flip */
  1176. endp = d_details->outdat_endpoints[i];
  1177. for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) {
  1178. p_priv->out_urbs[j] = keyspan_setup_urb
  1179. (serial, endp, USB_DIR_OUT, port,
  1180.  p_priv->out_buffer[j], 64,
  1181.  cback->outdat_callback);
  1182. }
  1183. for (; j < 2; ++j)
  1184. p_priv->out_urbs[j] = NULL;
  1186. /* inack endpoint */
  1187. p_priv->inack_urb = keyspan_setup_urb
  1188. (serial, d_details->inack_endpoints[i], USB_DIR_IN,
  1189.  port, p_priv->inack_buffer, 1, cback->inack_callback);
  1191. /* outcont endpoint */
  1192. p_priv->outcont_urb = keyspan_setup_urb
  1193. (serial, d_details->outcont_endpoints[i], USB_DIR_OUT,
  1194.  port, p_priv->outcont_buffer, 64,
  1195.  cback->outcont_callback);
  1196. }
  1198. }
  1200. /* usa19 function doesn't require prescaler */
  1201. static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk,
  1202.    u8 *rate_hi, u8 *rate_low, u8 *prescaler)
  1203. {
  1204. u32  b16, /* baud rate times 16 (actual rate used internally) */
  1205. div, /* divisor */
  1206. cnt; /* inverse of divisor (programmed into 8051) */
  1209. /* prevent divide by zero...  */
  1210. if( (b16 = (baud_rate * 16L)) == 0) {
  1211. return (KEYSPAN_INVALID_BAUD_RATE);
  1212. }
  1214. /* Any "standard" rate over 57k6 is marginal on the USA-19
  1215.    as we run out of divisor resolution. */
  1216. if (baud_rate > 57600) {
  1217. return (KEYSPAN_INVALID_BAUD_RATE);
  1218. }
  1220. /* calculate the divisor and the counter (its inverse) */
  1221. if( (div = (baudclk / b16)) == 0) {
  1222. return (KEYSPAN_INVALID_BAUD_RATE);
  1223. }
  1224. else {
  1225. cnt = 0 - div;
  1226. }
  1228. if(div > 0xffff) {
  1229. return (KEYSPAN_INVALID_BAUD_RATE);
  1230. }
  1232. /* return the counter values if non-null */
  1233. if (rate_low) {
  1234. *rate_low = (u8) (cnt & 0xff);
  1235. }
  1236. if (rate_hi) {
  1237. *rate_hi = (u8) ((cnt >> 8) & 0xff);
  1238. }
  1239. if (rate_low && rate_hi) {
  1240. dbg (__FUNCTION__ " %d %02x %02x.", baud_rate, *rate_hi, *rate_low);
  1241. }
  1243. return (KEYSPAN_BAUD_RATE_OK);
  1244. }
  1246. static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk,
  1247.     u8 *rate_hi, u8 *rate_low, u8 *prescaler)
  1248. {
  1249. u32  b16, /* baud rate times 16 (actual rate used internally) */
  1250. clk, /* clock with 13/8 prescaler */
  1251. div, /* divisor using 13/8 prescaler */
  1252. res, /* resulting baud rate using 13/8 prescaler */
  1253. diff, /* error using 13/8 prescaler */
  1254. smallest_diff;
  1255. u8 best_prescaler;
  1256. int i;
  1258. dbg (__FUNCTION__ " %d.n", baud_rate);
  1260. /* prevent divide by zero */
  1261. if( (b16 = baud_rate * 16L) == 0) {
  1262. return (KEYSPAN_INVALID_BAUD_RATE);
  1263. }
  1265. /* Calculate prescaler by trying them all and looking
  1266.    for best fit */
  1268. /* start with largest possible difference */
  1269. smallest_diff = 0xffffffff;
  1271. /* 0 is an invalid prescaler, used as a flag */
  1272. best_prescaler = 0;
  1274. for(i = 8; i <= 0xff; ++i)
  1275. {
  1276. clk = (baudclk * 8) / (u32) i;
  1278. if( (div = clk / b16) == 0) {
  1279. continue;
  1280. }
  1282. res = clk / div;
  1283. diff= (res > b16) ? (res-b16) : (b16-res);
  1285. if(diff < smallest_diff)
  1286. {
  1287. best_prescaler = i;
  1288. smallest_diff = diff;
  1289. }
  1290. }
  1292. if(best_prescaler == 0) {
  1293. return (KEYSPAN_INVALID_BAUD_RATE);
  1294. }
  1296. clk = (baudclk * 8) / (u32) best_prescaler;
  1297. div = clk / b16;
  1299. /* return the divisor and prescaler if non-null */
  1300. if (rate_low) {
  1301. *rate_low = (u8) (div & 0xff);
  1302. }
  1303. if (rate_hi) {
  1304. *rate_hi = (u8) ((div >> 8) & 0xff);
  1305. }
  1306. if (prescaler) {
  1307. *prescaler = best_prescaler;
  1308. /*  dbg(__FUNCTION__ " %d %d", *prescaler, div); */
  1309. }
  1310. return (KEYSPAN_BAUD_RATE_OK);
  1311. }
  1313. static int keyspan_usa26_send_setup(struct usb_serial *serial,
  1314.     struct usb_serial_port *port,
  1315.     int reset_port)
  1316. {
  1317. struct keyspan_usa26_portControlMessage msg;
  1318. struct keyspan_serial_private  *s_priv;
  1319. struct keyspan_port_private  *p_priv;
  1320. const  keyspan_device_details *d_details;
  1321. int  outcont_urb;
  1322. urb_t *this_urb;
  1323. int err;
  1325. dbg ("%s reset=%dn", __FUNCTION__, reset_port); 
  1327. s_priv = (struct keyspan_serial_private *)(serial->private);
  1328. p_priv = (struct keyspan_port_private *)(port->private);
  1329. d_details = s_priv->device_details;
  1331. outcont_urb = d_details->outcont_endpoints[port->number];
  1332. this_urb = p_priv->outcont_urb;
  1334. dbg(__FUNCTION__ " endpoint %dn", usb_pipeendpoint(this_urb->pipe));
  1336. /* Make sure we have an urb then send the message */
  1337. if (this_urb == NULL) {
  1338. dbg(__FUNCTION__ " oops no urb.n");
  1339. return -1;
  1340. }
  1342. p_priv->resend_cont = 1;
  1343. if (this_urb->status == -EINPROGRESS) {
  1344. /*  dbg (__FUNCTION__ " already writing"); */
  1345. return(-1);
  1346. }
  1348. memset(&msg, 0, sizeof (struct keyspan_usa26_portControlMessage));
  1350. /* Only set baud rate if it's changed */
  1351. if (p_priv->old_baud != p_priv->baud) {
  1352. p_priv->old_baud = p_priv->baud;
  1353. msg.setClocking = 0xff;
  1354. if (d_details->calculate_baud_rate
  1355.     (p_priv->baud, d_details->baudclk, &msg.baudHi,
  1356.      &msg.baudLo, &msg.prescaler) == KEYSPAN_INVALID_BAUD_RATE ) {
  1357. dbg(__FUNCTION__ "Invalid baud rate %d requested, using 9600.n",
  1358.     p_priv->baud);
  1359. msg.baudLo = 0;
  1360. msg.baudHi = 125; /* Values for 9600 baud */
  1361. msg.prescaler = 10;
  1362. }
  1363. msg.setPrescaler = 0xff;
  1364. }
  1366. msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
  1367. switch (p_priv->cflag & CSIZE) {
  1368. case CS5:
  1369. msg.lcr |= USA_DATABITS_5;
  1370. break;
  1371. case CS6:
  1372. msg.lcr |= USA_DATABITS_6;
  1373. break;
  1374. case CS7:
  1375. msg.lcr |= USA_DATABITS_7;
  1376. break;
  1377. case CS8:
  1378. msg.lcr |= USA_DATABITS_8;
  1379. break;
  1380. }
  1381. if (p_priv->cflag & PARENB) {
  1382. /* note USA_PARITY_NONE == 0 */
  1383. msg.lcr |= (p_priv->cflag & PARODD)?
  1384. USA_PARITY_ODD: USA_PARITY_EVEN;
  1385. }
  1386. msg.setLcr = 0xff;
  1388. msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
  1389. msg.xonFlowControl = 0;
  1390. msg.setFlowControl = 0xff;
  1392. msg.forwardingLength = 1;
  1393. msg.xonChar = 17;
  1394. msg.xoffChar = 19;
  1396. if (reset_port) {
  1397. msg._txOn = 0;
  1398. msg._txOff = 1;
  1399. msg.txFlush = 0;
  1400. msg.txBreak = 0;
  1401. msg.rxOn = 0;
  1402. msg.rxOff = 1;
  1403. msg.rxFlush = 1;
  1404. msg.rxForward = 0;
  1405. msg.returnStatus = 0;
  1406. msg.resetDataToggle = 0xff;
  1407. }
  1408. else {
  1409. msg._txOn = (! p_priv->break_on);
  1410. msg._txOff = 0;
  1411. msg.txFlush = 0;
  1412. msg.txBreak = (p_priv->break_on);
  1413. msg.rxOn = 1;
  1414. msg.rxOff = 0;
  1415. msg.rxFlush = 0;
  1416. msg.rxForward = 0;
  1417. msg.returnStatus = 0;
  1418. msg.resetDataToggle = 0x0;
  1419. }
  1421. /* Do handshaking outputs */
  1422. msg.setTxTriState_setRts = 0xff;
  1423. msg.txTriState_rts = p_priv->rts_state;
  1425. msg.setHskoa_setDtr = 0xff;
  1426. msg.hskoa_dtr = p_priv->dtr_state;
  1428. p_priv->resend_cont = 0;
  1429. memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
  1431. /* send the data out the device on control endpoint */
  1432. this_urb->transfer_buffer_length = sizeof(msg);
  1434. this_urb->dev = serial->dev;
  1435. if ((err = usb_submit_urb(this_urb)) != 0) {
  1436. dbg(__FUNCTION__ " usb_submit_urb(setup) failed (%d)n", err);
  1437. }
  1438. #if 0
  1439. else {
  1440. dbg(__FUNCTION__ " usb_submit_urb(%d) OK %d bytes (end %d)",
  1441.     outcont_urb, this_urb->transfer_buffer_length,
  1442.     usb_pipeendpoint(this_urb->pipe));
  1443. }
  1444. #endif
  1446. return (0);
  1447. }
  1449. static int keyspan_usa28_send_setup(struct usb_serial *serial,
  1450.     struct usb_serial_port *port,
  1451.     int reset_port)
  1452. {
  1453. struct keyspan_usa28_portControlMessage msg;
  1454. struct keyspan_serial_private   *s_priv;
  1455. struct keyspan_port_private  *p_priv;
  1456. const  keyspan_device_details *d_details;
  1457. urb_t *this_urb;
  1458. int err;
  1460. s_priv = (struct keyspan_serial_private *)(serial->private);
  1461. p_priv = (struct keyspan_port_private *)(port->private);
  1462. d_details = s_priv->device_details;
  1464. /* only do something if we have a bulk out endpoint */
  1465. if ((this_urb = p_priv->outcont_urb) == NULL) {
  1466. dbg(__FUNCTION__ " oops no urb.n");
  1467. return -1;
  1468. }
  1470. p_priv->resend_cont = 1;
  1471. if (this_urb->status == -EINPROGRESS) {
  1472. dbg (__FUNCTION__ " already writingn");
  1473. return(-1);
  1474. }
  1476. memset(&msg, 0, sizeof (struct keyspan_usa28_portControlMessage));
  1478. msg.setBaudRate = 1;
  1479. if (keyspan_usa19_calc_baud(p_priv->baud, d_details->baudclk,
  1480. &msg.baudHi, &msg.baudLo, NULL) == KEYSPAN_INVALID_BAUD_RATE ) {
  1481. dbg(__FUNCTION__ "Invalid baud rate requested %d.", p_priv->baud);
  1482. msg.baudLo = 0xff;
  1483. msg.baudHi = 0xb2; /* Values for 9600 baud */
  1484. }
  1486. /* If parity is enabled, we must calculate it ourselves. */
  1487. msg.parity = 0; /* XXX for now */
  1489. msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
  1490. msg.xonFlowControl = 0;
  1492. /* Do handshaking outputs, DTR is inverted relative to RTS */
  1493. msg.rts = p_priv->rts_state;
  1494. msg.dtr = p_priv->dtr_state;
  1496. msg.forwardingLength = 1;
  1497. msg.forwardMs = 10;
  1498. msg.breakThreshold = 45;
  1499. msg.xonChar = 17;
  1500. msg.xoffChar = 19;
  1502. msg._txOn = 1;
  1503. msg._txOff = 0;
  1504. msg.txFlush = 0;
  1505. msg.txForceXoff = 0;
  1506. msg.txBreak = 0;
  1507. msg.rxOn = 1;
  1508. msg.rxOff = 0;
  1509. msg.rxFlush = 0;
  1510. msg.rxForward = 0;
  1511. /*msg.returnStatus = 1;
  1512. msg.resetDataToggle = 0xff;*/
  1514. p_priv->resend_cont = 0;
  1515. memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
  1517. /* send the data out the device on control endpoint */
  1518. this_urb->transfer_buffer_length = sizeof(msg);
  1520. this_urb->dev = serial->dev;
  1521. if ((err = usb_submit_urb(this_urb)) != 0) {
  1522. dbg(__FUNCTION__ " usb_submit_urb(setup) failedn");
  1523. }
  1524. #if 0
  1525. else {
  1526. dbg(__FUNCTION__ " usb_submit_urb(setup) OK %d bytes",
  1527.     this_urb->transfer_buffer_length);
  1528. }
  1529. #endif
  1531. return (0);
  1532. }
  1534. static int keyspan_usa49_send_setup(struct usb_serial *serial,
  1535.     struct usb_serial_port *port,
  1536.     int reset_port)
  1537. {
  1538. struct keyspan_usa49_portControlMessage msg;
  1539. struct keyspan_serial_private  *s_priv;
  1540. struct keyspan_port_private  *p_priv;
  1541. const  keyspan_device_details *d_details;
  1542. int  glocont_urb;
  1543. urb_t  *this_urb;
  1544. int  err;
  1545. int device_port;
  1547. dbg ("%sn", __FUNCTION__);
  1549. s_priv = (struct keyspan_serial_private *)(serial->private);
  1550. p_priv = (struct keyspan_port_private *)(port->private);
  1551. d_details = s_priv->device_details;
  1553. glocont_urb = d_details->glocont_endpoint;
  1554. this_urb = s_priv->glocont_urb;
  1556. /* Work out which port within the device is being setup */
  1557. device_port = port->number - port->serial->minor;
  1559. dbg(__FUNCTION__ " endpoint %d port %d (%d)n", usb_pipeendpoint(this_urb->pipe), port->number, device_port);
  1561. /* Make sure we have an urb then send the message */
  1562. if (this_urb == NULL) {
  1563. dbg(__FUNCTION__ " oops no urb for port %d.n", port->number);
  1564. return -1;
  1565. }
  1567. p_priv->resend_cont = 1;
  1568. if (this_urb->status == -EINPROGRESS) {
  1569. /*  dbg (__FUNCTION__ " already writing"); */
  1570. return(-1);
  1571. }
  1573. memset(&msg, 0, sizeof (struct keyspan_usa49_portControlMessage));
  1575. /*msg.portNumber = port->number;*/
  1576. msg.portNumber = device_port;
  1578. /* Only set baud rate if it's changed */
  1579. if (p_priv->old_baud != p_priv->baud) {
  1580. p_priv->old_baud = p_priv->baud;
  1581. msg.setClocking = 0xff;
  1582. if (d_details->calculate_baud_rate
  1583.     (p_priv->baud, d_details->baudclk, &msg.baudHi,
  1584.      &msg.baudLo, &msg.prescaler) == KEYSPAN_INVALID_BAUD_RATE ) {
  1585. dbg(__FUNCTION__ "Invalid baud rate %d requested, using 9600.n",
  1586.     p_priv->baud);
  1587. msg.baudLo = 0;
  1588. msg.baudHi = 125; /* Values for 9600 baud */
  1589. msg.prescaler = 10;
  1590. }
  1591. //msg.setPrescaler = 0xff;
  1592. }
  1594. msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
  1595. switch (p_priv->cflag & CSIZE) {
  1596. case CS5:
  1597. msg.lcr |= USA_DATABITS_5;
  1598. break;
  1599. case CS6:
  1600. msg.lcr |= USA_DATABITS_6;
  1601. break;
  1602. case CS7:
  1603. msg.lcr |= USA_DATABITS_7;
  1604. break;
  1605. case CS8:
  1606. msg.lcr |= USA_DATABITS_8;
  1607. break;
  1608. }
  1609. if (p_priv->cflag & PARENB) {
  1610. /* note USA_PARITY_NONE == 0 */
  1611. msg.lcr |= (p_priv->cflag & PARODD)?
  1612. USA_PARITY_ODD: USA_PARITY_EVEN;
  1613. }
  1614. msg.setLcr = 0xff;
  1616. msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
  1617. msg.xonFlowControl = 0;
  1618. msg.setFlowControl = 0xff;
  1620. msg.forwardingLength = 1;
  1621. msg.xonChar = 17;
  1622. msg.xoffChar = 19;
  1624. msg._txOn = 1;
  1625. msg._txOff = 0;
  1626. msg.txFlush = 0;
  1627. msg.txBreak = 0;
  1628. msg.rxOn = 1;
  1629. msg.rxOff = 0;
  1630. msg.rxFlush = 0;
  1631. msg.rxForward = 0;
  1632. msg.enablePort = 0xff;
  1633. msg.disablePort = 0;
  1635. /* Do handshaking outputs */
  1636. msg.setRts = 0xff;
  1637. msg.rts = p_priv->rts_state;
  1639. msg.setDtr = 0xff;
  1640. msg.dtr = p_priv->dtr_state;
  1642. p_priv->resend_cont = 0;
  1643. memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
  1645. /* send the data out the device on control endpoint */
  1646. this_urb->transfer_buffer_length = sizeof(msg);
  1648. this_urb->dev = serial->dev;
  1649. if ((err = usb_submit_urb(this_urb)) != 0) {
  1650. dbg(__FUNCTION__ " usb_submit_urb(setup) failed (%d)n", err);
  1651. }
  1652. #if 0
  1653. else {
  1654. dbg(__FUNCTION__ " usb_submit_urb(%d) OK %d bytes (end %d)",
  1655.     outcont_urb, this_urb->transfer_buffer_length,
  1656.     usb_pipeendpoint(this_urb->pipe));
  1657. }
  1658. #endif
  1660. return (0);
  1661. }
  1663. static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
  1664. {
  1665. struct usb_serial *serial = port->serial;
  1666. struct keyspan_serial_private  *s_priv;
  1667. const keyspan_device_details *d_details;
  1669. s_priv = (struct keyspan_serial_private *)(serial->private);
  1670. d_details = s_priv->device_details;
  1672. switch (d_details->msg_format) {
  1673. case msg_usa26:
  1674. keyspan_usa26_send_setup(serial, port, reset_port);
  1675. break;
  1676. case msg_usa28:
  1677. keyspan_usa28_send_setup(serial, port, reset_port);
  1678. break;
  1679. case msg_usa49:
  1680. keyspan_usa49_send_setup(serial, port, reset_port);
  1681. break;
  1682. }
  1683. }
  1685. /* Gets called by the "real" driver (ie once firmware is loaded
  1686.    and renumeration has taken place. */
  1687. static int keyspan_startup (struct usb_serial *serial)
  1688. {
  1689. int i, err;
  1690. struct usb_serial_port *port;
  1691. struct keyspan_serial_private  *s_priv;
  1692. struct keyspan_port_private *p_priv;
  1693. const keyspan_device_details *d_details;
  1695. dbg("keyspan_startup called.n");
  1697. for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
  1698. if (d_details->product_id == serial->dev->descriptor.idProduct)
  1699. break;
  1700. if (d_details == NULL) {
  1701. printk(KERN_ERR __FUNCTION__ ": unknown product id %xn",
  1702.        serial->dev->descriptor.idProduct);
  1703. return 1;
  1704. }
  1706. /* Setup private data for serial driver */
  1707. serial->private = kmalloc(sizeof(struct keyspan_serial_private),
  1708.   GFP_KERNEL);
  1709. if (!serial->private) {
  1710. dbg(__FUNCTION__ "kmalloc for keyspan_serial_private failed.n");
  1711. return (1);
  1712. }
  1713. memset(serial->private, 0, sizeof(struct keyspan_serial_private));
  1715. s_priv = (struct keyspan_serial_private *)(serial->private);
  1716. s_priv->device_details = d_details;
  1718. /* Now setup per port private data */
  1719. for (i = 0; i < serial->num_ports; i++) {
  1720. port = &serial->port[i];
  1721. port->private = kmalloc(sizeof(struct keyspan_port_private),
  1722. GFP_KERNEL);
  1723. if (!port->private) {
  1724. dbg(__FUNCTION__ "kmalloc for keyspan_port_private (%d) failed!.n", i);
  1725. return (1);
  1726. }
  1727. memset(port->private, 0, sizeof(struct keyspan_port_private));
  1728. p_priv = (struct keyspan_port_private *)(port->private);
  1729. p_priv->device_details = d_details;
  1730. }
  1732. keyspan_setup_urbs(serial);
  1734. s_priv->instat_urb->dev = serial->dev;
  1735. if ((err = usb_submit_urb(s_priv->instat_urb)) != 0) {
  1736. dbg(__FUNCTION__ " submit instat urb failed %dn", err);
  1737. }
  1739. return (0);
  1740. }
  1742. static void keyspan_shutdown (struct usb_serial *serial)
  1743. {
  1744. int i, j;
  1745. struct usb_serial_port *port;
  1746. struct keyspan_serial_private  *s_priv;
  1747. struct keyspan_port_private *p_priv;
  1749. dbg("keyspan_shutdown calledn");
  1751. s_priv = (struct keyspan_serial_private *)(serial->private);
  1753. /* Stop reading/writing urbs */
  1754. stop_urb(s_priv->instat_urb);
  1755. stop_urb(s_priv->glocont_urb);
  1756. for (i = 0; i < serial->num_ports; ++i) {
  1757. port = &serial->port[i];
  1758. p_priv = (struct keyspan_port_private *)(port->private);
  1759. stop_urb(p_priv->inack_urb);
  1760. stop_urb(p_priv->outcont_urb);
  1761. for (j = 0; j < 2; j++) {
  1762. stop_urb(p_priv->in_urbs[j]);
  1763. stop_urb(p_priv->out_urbs[j]);
  1764. }
  1765. }
  1767. /* Now free them */
  1768. if (s_priv->instat_urb)
  1769. usb_free_urb(s_priv->instat_urb);
  1770. if (s_priv->glocont_urb)
  1771. usb_free_urb(s_priv->glocont_urb);
  1772. for (i = 0; i < serial->num_ports; ++i) {
  1773. port = &serial->port[i];
  1774. p_priv = (struct keyspan_port_private *)(port->private);
  1775. if (p_priv->inack_urb)
  1776. usb_free_urb(p_priv->inack_urb);
  1777. if (p_priv->outcont_urb)
  1778. usb_free_urb(p_priv->outcont_urb);
  1779. for (j = 0; j < 2; j++) {
  1780. if (p_priv->in_urbs[j])
  1781. usb_free_urb(p_priv->in_urbs[j]);
  1782. if (p_priv->out_urbs[j])
  1783. usb_free_urb(p_priv->out_urbs[j]);
  1784. }
  1785. }
  1787. /*  dbg("Freeing serial->private."); */
  1788. kfree(serial->private);
  1790. /*  dbg("Freeing port->private."); */
  1791. /* Now free per port private data */
  1792. for (i = 0; i < serial->num_ports; i++) {
  1793. port = &serial->port[i];
  1794. while (port->open_count > 0) {
  1795. --port->open_count;
  1796. MOD_DEC_USE_COUNT;
  1797. }
  1798. kfree(port->private);
  1799. }
  1800. }
  1802. MODULE_AUTHOR( DRIVER_AUTHOR );
  1803. MODULE_DESCRIPTION( DRIVER_DESC );
  1804. MODULE_LICENSE("GPL");
  1806. MODULE_PARM(debug, "i");
  1807. MODULE_PARM_DESC(debug, "Debug enabled or not");