Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Clean ups from Moschip version and a few ioctl implementations by:
0004  *  Paul B Schroeder <pschroeder "at" uplogix "dot" com>
0005  *
0006  * Originally based on drivers/usb/serial/io_edgeport.c which is:
0007  *      Copyright (C) 2000 Inside Out Networks, All rights reserved.
0008  *      Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
0009  *
0010  */
0011 
0012 #include <linux/kernel.h>
0013 #include <linux/errno.h>
0014 #include <linux/slab.h>
0015 #include <linux/tty.h>
0016 #include <linux/tty_driver.h>
0017 #include <linux/tty_flip.h>
0018 #include <linux/module.h>
0019 #include <linux/serial.h>
0020 #include <linux/usb.h>
0021 #include <linux/usb/serial.h>
0022 #include <linux/uaccess.h>
0023 
0024 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver"
0025 
0026 /*
0027  * 16C50 UART register defines
0028  */
0029 
0030 #define LCR_BITS_5             0x00 /* 5 bits/char */
0031 #define LCR_BITS_6             0x01 /* 6 bits/char */
0032 #define LCR_BITS_7             0x02 /* 7 bits/char */
0033 #define LCR_BITS_8             0x03 /* 8 bits/char */
0034 #define LCR_BITS_MASK          0x03 /* Mask for bits/char field */
0035 
0036 #define LCR_STOP_1             0x00 /* 1 stop bit */
0037 #define LCR_STOP_1_5           0x04 /* 1.5 stop bits (if 5   bits/char) */
0038 #define LCR_STOP_2             0x04 /* 2 stop bits   (if 6-8 bits/char) */
0039 #define LCR_STOP_MASK          0x04 /* Mask for stop bits field */
0040 
0041 #define LCR_PAR_NONE           0x00 /* No parity */
0042 #define LCR_PAR_ODD            0x08 /* Odd parity */
0043 #define LCR_PAR_EVEN           0x18 /* Even parity */
0044 #define LCR_PAR_MARK           0x28 /* Force parity bit to 1 */
0045 #define LCR_PAR_SPACE          0x38 /* Force parity bit to 0 */
0046 #define LCR_PAR_MASK           0x38 /* Mask for parity field */
0047 
0048 #define LCR_SET_BREAK          0x40 /* Set Break condition */
0049 #define LCR_DL_ENABLE          0x80 /* Enable access to divisor latch */
0050 
0051 #define MCR_DTR                0x01 /* Assert DTR */
0052 #define MCR_RTS                0x02 /* Assert RTS */
0053 #define MCR_OUT1               0x04 /* Loopback only: Sets state of RI */
0054 #define MCR_MASTER_IE          0x08 /* Enable interrupt outputs */
0055 #define MCR_LOOPBACK           0x10 /* Set internal (digital) loopback mode */
0056 #define MCR_XON_ANY            0x20 /* Enable any char to exit XOFF mode */
0057 
0058 #define MOS7840_MSR_CTS        0x10 /* Current state of CTS */
0059 #define MOS7840_MSR_DSR        0x20 /* Current state of DSR */
0060 #define MOS7840_MSR_RI         0x40 /* Current state of RI */
0061 #define MOS7840_MSR_CD         0x80 /* Current state of CD */
0062 
0063 /*
0064  * Defines used for sending commands to port
0065  */
0066 
0067 #define MOS_WDR_TIMEOUT     5000    /* default urb timeout */
0068 
0069 #define MOS_PORT1       0x0200
0070 #define MOS_PORT2       0x0300
0071 #define MOS_VENREG      0x0000
0072 #define MOS_MAX_PORT    0x02
0073 #define MOS_WRITE       0x0E
0074 #define MOS_READ        0x0D
0075 
0076 /* Requests */
0077 #define MCS_RD_RTYPE    0xC0
0078 #define MCS_WR_RTYPE    0x40
0079 #define MCS_RDREQ       0x0D
0080 #define MCS_WRREQ       0x0E
0081 #define MCS_CTRL_TIMEOUT        500
0082 #define VENDOR_READ_LENGTH      (0x01)
0083 
0084 #define MAX_NAME_LEN    64
0085 
0086 #define ZLP_REG1  0x3A      /* Zero_Flag_Reg1    58 */
0087 #define ZLP_REG5  0x3E      /* Zero_Flag_Reg5    62 */
0088 
0089 /* For higher baud Rates use TIOCEXBAUD */
0090 #define TIOCEXBAUD     0x5462
0091 
0092 /*
0093  * Vendor id and device id defines
0094  *
0095  * NOTE: Do not add new defines, add entries directly to the id_table instead.
0096  */
0097 #define USB_VENDOR_ID_BANDB              0x0856
0098 #define BANDB_DEVICE_ID_USO9ML2_2        0xAC22
0099 #define BANDB_DEVICE_ID_USO9ML2_2P       0xBC00
0100 #define BANDB_DEVICE_ID_USO9ML2_4        0xAC24
0101 #define BANDB_DEVICE_ID_USO9ML2_4P       0xBC01
0102 #define BANDB_DEVICE_ID_US9ML2_2         0xAC29
0103 #define BANDB_DEVICE_ID_US9ML2_4         0xAC30
0104 #define BANDB_DEVICE_ID_USPTL4_2         0xAC31
0105 #define BANDB_DEVICE_ID_USPTL4_4         0xAC32
0106 #define BANDB_DEVICE_ID_USOPTL4_2        0xAC42
0107 #define BANDB_DEVICE_ID_USOPTL4_2P       0xBC02
0108 #define BANDB_DEVICE_ID_USOPTL4_4        0xAC44
0109 #define BANDB_DEVICE_ID_USOPTL4_4P       0xBC03
0110 
0111 /* Interrupt Routine Defines    */
0112 
0113 #define SERIAL_IIR_RLS      0x06
0114 #define SERIAL_IIR_MS       0x00
0115 
0116 /*
0117  *  Emulation of the bit mask on the LINE STATUS REGISTER.
0118  */
0119 #define SERIAL_LSR_DR       0x0001
0120 #define SERIAL_LSR_OE       0x0002
0121 #define SERIAL_LSR_PE       0x0004
0122 #define SERIAL_LSR_FE       0x0008
0123 #define SERIAL_LSR_BI       0x0010
0124 
0125 #define MOS_MSR_DELTA_CTS   0x10
0126 #define MOS_MSR_DELTA_DSR   0x20
0127 #define MOS_MSR_DELTA_RI    0x40
0128 #define MOS_MSR_DELTA_CD    0x80
0129 
0130 /* Serial Port register Address */
0131 #define INTERRUPT_ENABLE_REGISTER  ((__u16)(0x01))
0132 #define FIFO_CONTROL_REGISTER      ((__u16)(0x02))
0133 #define LINE_CONTROL_REGISTER      ((__u16)(0x03))
0134 #define MODEM_CONTROL_REGISTER     ((__u16)(0x04))
0135 #define LINE_STATUS_REGISTER       ((__u16)(0x05))
0136 #define MODEM_STATUS_REGISTER      ((__u16)(0x06))
0137 #define SCRATCH_PAD_REGISTER       ((__u16)(0x07))
0138 #define DIVISOR_LATCH_LSB          ((__u16)(0x00))
0139 #define DIVISOR_LATCH_MSB          ((__u16)(0x01))
0140 
0141 #define CLK_MULTI_REGISTER         ((__u16)(0x02))
0142 #define CLK_START_VALUE_REGISTER   ((__u16)(0x03))
0143 #define GPIO_REGISTER              ((__u16)(0x07))
0144 
0145 #define SERIAL_LCR_DLAB            ((__u16)(0x0080))
0146 
0147 /*
0148  * URB POOL related defines
0149  */
0150 #define NUM_URBS                        16  /* URB Count */
0151 #define URB_TRANSFER_BUFFER_SIZE        32  /* URB Size  */
0152 
0153 /* LED on/off milliseconds*/
0154 #define LED_ON_MS   500
0155 #define LED_OFF_MS  500
0156 
0157 enum mos7840_flag {
0158     MOS7840_FLAG_LED_BUSY,
0159 };
0160 
0161 #define MCS_PORT_MASK   GENMASK(2, 0)
0162 #define MCS_PORTS(nr)   ((nr) & MCS_PORT_MASK)
0163 #define MCS_LED     BIT(3)
0164 
0165 #define MCS_DEVICE(vid, pid, flags) \
0166         USB_DEVICE((vid), (pid)), .driver_info = (flags)
0167 
0168 static const struct usb_device_id id_table[] = {
0169     { MCS_DEVICE(0x0557, 0x2011, MCS_PORTS(4)) },   /* ATEN UC2324 */
0170     { MCS_DEVICE(0x0557, 0x7820, MCS_PORTS(2)) },   /* ATEN UC2322 */
0171     { MCS_DEVICE(0x110a, 0x2210, MCS_PORTS(2)) },   /* Moxa UPort 2210 */
0172     { MCS_DEVICE(0x9710, 0x7810, MCS_PORTS(1) | MCS_LED) }, /* ASIX MCS7810 */
0173     { MCS_DEVICE(0x9710, 0x7820, MCS_PORTS(2)) },   /* MosChip MCS7820 */
0174     { MCS_DEVICE(0x9710, 0x7840, MCS_PORTS(4)) },   /* MosChip MCS7840 */
0175     { MCS_DEVICE(0x9710, 0x7843, MCS_PORTS(3)) },   /* ASIX MCS7840 3 port */
0176     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2) },
0177     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P) },
0178     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4) },
0179     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P) },
0180     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2) },
0181     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4) },
0182     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2) },
0183     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4) },
0184     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2) },
0185     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P) },
0186     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4) },
0187     { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P) },
0188     {}          /* terminating entry */
0189 };
0190 MODULE_DEVICE_TABLE(usb, id_table);
0191 
0192 /* This structure holds all of the local port information */
0193 
0194 struct moschip_port {
0195     int port_num;       /*Actual port number in the device(1,2,etc) */
0196     struct urb *read_urb;   /* read URB for this port */
0197     __u8 shadowLCR;     /* last LCR value received */
0198     __u8 shadowMCR;     /* last MCR value received */
0199     struct usb_serial_port *port;   /* loop back to the owner of this object */
0200 
0201     /* Offsets */
0202     __u8 SpRegOffset;
0203     __u8 ControlRegOffset;
0204     __u8 DcrRegOffset;
0205 
0206     spinlock_t pool_lock;
0207     struct urb *write_urb_pool[NUM_URBS];
0208     char busy[NUM_URBS];
0209     bool read_urb_busy;
0210 
0211     /* For device(s) with LED indicator */
0212     bool has_led;
0213     struct timer_list led_timer1;   /* Timer for LED on */
0214     struct timer_list led_timer2;   /* Timer for LED off */
0215     struct urb *led_urb;
0216     struct usb_ctrlrequest *led_dr;
0217 
0218     unsigned long flags;
0219 };
0220 
0221 /*
0222  * mos7840_set_reg_sync
0223  *  To set the Control register by calling usb_fill_control_urb function
0224  *  by passing usb_sndctrlpipe function as parameter.
0225  */
0226 
0227 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
0228                 __u16 val)
0229 {
0230     struct usb_device *dev = port->serial->dev;
0231     val = val & 0x00ff;
0232     dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val);
0233 
0234     return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
0235                    MCS_WR_RTYPE, val, reg, NULL, 0,
0236                    MOS_WDR_TIMEOUT);
0237 }
0238 
0239 /*
0240  * mos7840_get_reg_sync
0241  *  To set the Uart register by calling usb_fill_control_urb function by
0242  *  passing usb_rcvctrlpipe function as parameter.
0243  */
0244 
0245 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
0246                 __u16 *val)
0247 {
0248     struct usb_device *dev = port->serial->dev;
0249     int ret = 0;
0250     u8 *buf;
0251 
0252     buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
0253     if (!buf)
0254         return -ENOMEM;
0255 
0256     ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
0257                   MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
0258                   MOS_WDR_TIMEOUT);
0259     if (ret < VENDOR_READ_LENGTH) {
0260         if (ret >= 0)
0261             ret = -EIO;
0262         goto out;
0263     }
0264 
0265     *val = buf[0];
0266     dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val);
0267 out:
0268     kfree(buf);
0269     return ret;
0270 }
0271 
0272 /*
0273  * mos7840_set_uart_reg
0274  *  To set the Uart register by calling usb_fill_control_urb function by
0275  *  passing usb_sndctrlpipe function as parameter.
0276  */
0277 
0278 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
0279                 __u16 val)
0280 {
0281 
0282     struct usb_device *dev = port->serial->dev;
0283     val = val & 0x00ff;
0284     /* For the UART control registers, the application number need
0285        to be Or'ed */
0286     if (port->serial->num_ports == 2 && port->port_number != 0)
0287         val |= ((__u16)port->port_number + 2) << 8;
0288     else
0289         val |= ((__u16)port->port_number + 1) << 8;
0290     dev_dbg(&port->dev, "%s application number is %x\n", __func__, val);
0291     return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
0292                    MCS_WR_RTYPE, val, reg, NULL, 0,
0293                    MOS_WDR_TIMEOUT);
0294 
0295 }
0296 
0297 /*
0298  * mos7840_get_uart_reg
0299  *  To set the Control register by calling usb_fill_control_urb function
0300  *  by passing usb_rcvctrlpipe function as parameter.
0301  */
0302 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
0303                 __u16 *val)
0304 {
0305     struct usb_device *dev = port->serial->dev;
0306     int ret = 0;
0307     __u16 Wval;
0308     u8 *buf;
0309 
0310     buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
0311     if (!buf)
0312         return -ENOMEM;
0313 
0314     /* Wval  is same as application number */
0315     if (port->serial->num_ports == 2 && port->port_number != 0)
0316         Wval = ((__u16)port->port_number + 2) << 8;
0317     else
0318         Wval = ((__u16)port->port_number + 1) << 8;
0319     dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval);
0320     ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
0321                   MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
0322                   MOS_WDR_TIMEOUT);
0323     if (ret < VENDOR_READ_LENGTH) {
0324         if (ret >= 0)
0325             ret = -EIO;
0326         goto out;
0327     }
0328     *val = buf[0];
0329 out:
0330     kfree(buf);
0331     return ret;
0332 }
0333 
0334 static void mos7840_dump_serial_port(struct usb_serial_port *port,
0335                      struct moschip_port *mos7840_port)
0336 {
0337 
0338     dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset);
0339     dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset);
0340     dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset);
0341 
0342 }
0343 
0344 /************************************************************************/
0345 /************************************************************************/
0346 /*            U S B  C A L L B A C K   F U N C T I O N S                */
0347 /*            U S B  C A L L B A C K   F U N C T I O N S                */
0348 /************************************************************************/
0349 /************************************************************************/
0350 
0351 static void mos7840_set_led_callback(struct urb *urb)
0352 {
0353     switch (urb->status) {
0354     case 0:
0355         /* Success */
0356         break;
0357     case -ECONNRESET:
0358     case -ENOENT:
0359     case -ESHUTDOWN:
0360         /* This urb is terminated, clean up */
0361         dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
0362             __func__, urb->status);
0363         break;
0364     default:
0365         dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
0366             __func__, urb->status);
0367     }
0368 }
0369 
0370 static void mos7840_set_led_async(struct moschip_port *mcs, __u16 wval,
0371                 __u16 reg)
0372 {
0373     struct usb_device *dev = mcs->port->serial->dev;
0374     struct usb_ctrlrequest *dr = mcs->led_dr;
0375 
0376     dr->bRequestType = MCS_WR_RTYPE;
0377     dr->bRequest = MCS_WRREQ;
0378     dr->wValue = cpu_to_le16(wval);
0379     dr->wIndex = cpu_to_le16(reg);
0380     dr->wLength = cpu_to_le16(0);
0381 
0382     usb_fill_control_urb(mcs->led_urb, dev, usb_sndctrlpipe(dev, 0),
0383         (unsigned char *)dr, NULL, 0, mos7840_set_led_callback, NULL);
0384 
0385     usb_submit_urb(mcs->led_urb, GFP_ATOMIC);
0386 }
0387 
0388 static void mos7840_set_led_sync(struct usb_serial_port *port, __u16 reg,
0389                 __u16 val)
0390 {
0391     struct usb_device *dev = port->serial->dev;
0392 
0393     usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, MCS_WR_RTYPE,
0394             val, reg, NULL, 0, MOS_WDR_TIMEOUT);
0395 }
0396 
0397 static void mos7840_led_off(struct timer_list *t)
0398 {
0399     struct moschip_port *mcs = from_timer(mcs, t, led_timer1);
0400 
0401     /* Turn off LED */
0402     mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER);
0403     mod_timer(&mcs->led_timer2,
0404                 jiffies + msecs_to_jiffies(LED_OFF_MS));
0405 }
0406 
0407 static void mos7840_led_flag_off(struct timer_list *t)
0408 {
0409     struct moschip_port *mcs = from_timer(mcs, t, led_timer2);
0410 
0411     clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags);
0412 }
0413 
0414 static void mos7840_led_activity(struct usb_serial_port *port)
0415 {
0416     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0417 
0418     if (test_and_set_bit_lock(MOS7840_FLAG_LED_BUSY, &mos7840_port->flags))
0419         return;
0420 
0421     mos7840_set_led_async(mos7840_port, 0x0301, MODEM_CONTROL_REGISTER);
0422     mod_timer(&mos7840_port->led_timer1,
0423                 jiffies + msecs_to_jiffies(LED_ON_MS));
0424 }
0425 
0426 /*****************************************************************************
0427  * mos7840_bulk_in_callback
0428  *  this is the callback function for when we have received data on the
0429  *  bulk in endpoint.
0430  *****************************************************************************/
0431 
0432 static void mos7840_bulk_in_callback(struct urb *urb)
0433 {
0434     struct moschip_port *mos7840_port = urb->context;
0435     struct usb_serial_port *port = mos7840_port->port;
0436     int retval;
0437     unsigned char *data;
0438     int status = urb->status;
0439 
0440     if (status) {
0441         dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
0442         mos7840_port->read_urb_busy = false;
0443         return;
0444     }
0445 
0446     data = urb->transfer_buffer;
0447     usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
0448 
0449     if (urb->actual_length) {
0450         struct tty_port *tport = &mos7840_port->port->port;
0451         tty_insert_flip_string(tport, data, urb->actual_length);
0452         tty_flip_buffer_push(tport);
0453         port->icount.rx += urb->actual_length;
0454         dev_dbg(&port->dev, "icount.rx is %d:\n", port->icount.rx);
0455     }
0456 
0457     if (mos7840_port->has_led)
0458         mos7840_led_activity(port);
0459 
0460     mos7840_port->read_urb_busy = true;
0461     retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
0462 
0463     if (retval) {
0464         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
0465         mos7840_port->read_urb_busy = false;
0466     }
0467 }
0468 
0469 /*****************************************************************************
0470  * mos7840_bulk_out_data_callback
0471  *  this is the callback function for when we have finished sending
0472  *  serial data on the bulk out endpoint.
0473  *****************************************************************************/
0474 
0475 static void mos7840_bulk_out_data_callback(struct urb *urb)
0476 {
0477     struct moschip_port *mos7840_port = urb->context;
0478     struct usb_serial_port *port = mos7840_port->port;
0479     int status = urb->status;
0480     unsigned long flags;
0481     int i;
0482 
0483     spin_lock_irqsave(&mos7840_port->pool_lock, flags);
0484     for (i = 0; i < NUM_URBS; i++) {
0485         if (urb == mos7840_port->write_urb_pool[i]) {
0486             mos7840_port->busy[i] = 0;
0487             break;
0488         }
0489     }
0490     spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
0491 
0492     if (status) {
0493         dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status);
0494         return;
0495     }
0496 
0497     tty_port_tty_wakeup(&port->port);
0498 
0499 }
0500 
0501 /************************************************************************/
0502 /*       D R I V E R  T T Y  I N T E R F A C E  F U N C T I O N S       */
0503 /************************************************************************/
0504 
0505 /*****************************************************************************
0506  * mos7840_open
0507  *  this function is called by the tty driver when a port is opened
0508  *  If successful, we return 0
0509  *  Otherwise we return a negative error number.
0510  *****************************************************************************/
0511 
0512 static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
0513 {
0514     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0515     struct usb_serial *serial = port->serial;
0516     int response;
0517     int j;
0518     struct urb *urb;
0519     __u16 Data;
0520     int status;
0521 
0522     usb_clear_halt(serial->dev, port->write_urb->pipe);
0523     usb_clear_halt(serial->dev, port->read_urb->pipe);
0524 
0525     /* Initialising the write urb pool */
0526     for (j = 0; j < NUM_URBS; ++j) {
0527         urb = usb_alloc_urb(0, GFP_KERNEL);
0528         mos7840_port->write_urb_pool[j] = urb;
0529         if (!urb)
0530             continue;
0531 
0532         urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
0533                                 GFP_KERNEL);
0534         if (!urb->transfer_buffer) {
0535             usb_free_urb(urb);
0536             mos7840_port->write_urb_pool[j] = NULL;
0537             continue;
0538         }
0539     }
0540 
0541 /*****************************************************************************
0542  * Initialize MCS7840 -- Write Init values to corresponding Registers
0543  *
0544  * Register Index
0545  * 1 : IER
0546  * 2 : FCR
0547  * 3 : LCR
0548  * 4 : MCR
0549  *
0550  * 0x08 : SP1/2 Control Reg
0551  *****************************************************************************/
0552 
0553     /* NEED to check the following Block */
0554 
0555     Data = 0x0;
0556     status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
0557     if (status < 0) {
0558         dev_dbg(&port->dev, "Reading Spreg failed\n");
0559         goto err;
0560     }
0561     Data |= 0x80;
0562     status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
0563     if (status < 0) {
0564         dev_dbg(&port->dev, "writing Spreg failed\n");
0565         goto err;
0566     }
0567 
0568     Data &= ~0x80;
0569     status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
0570     if (status < 0) {
0571         dev_dbg(&port->dev, "writing Spreg failed\n");
0572         goto err;
0573     }
0574     /* End of block to be checked */
0575 
0576     Data = 0x0;
0577     status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
0578                                     &Data);
0579     if (status < 0) {
0580         dev_dbg(&port->dev, "Reading Controlreg failed\n");
0581         goto err;
0582     }
0583     Data |= 0x08;       /* Driver done bit */
0584     Data |= 0x20;       /* rx_disable */
0585     status = mos7840_set_reg_sync(port,
0586                 mos7840_port->ControlRegOffset, Data);
0587     if (status < 0) {
0588         dev_dbg(&port->dev, "writing Controlreg failed\n");
0589         goto err;
0590     }
0591     /* do register settings here */
0592     /* Set all regs to the device default values. */
0593     /***********************************
0594      * First Disable all interrupts.
0595      ***********************************/
0596     Data = 0x00;
0597     status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
0598     if (status < 0) {
0599         dev_dbg(&port->dev, "disabling interrupts failed\n");
0600         goto err;
0601     }
0602     /* Set FIFO_CONTROL_REGISTER to the default value */
0603     Data = 0x00;
0604     status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
0605     if (status < 0) {
0606         dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
0607         goto err;
0608     }
0609 
0610     Data = 0xcf;
0611     status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
0612     if (status < 0) {
0613         dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
0614         goto err;
0615     }
0616 
0617     Data = 0x03;
0618     status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
0619     mos7840_port->shadowLCR = Data;
0620 
0621     Data = 0x0b;
0622     status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
0623     mos7840_port->shadowMCR = Data;
0624 
0625     Data = 0x00;
0626     status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
0627     mos7840_port->shadowLCR = Data;
0628 
0629     Data |= SERIAL_LCR_DLAB;    /* data latch enable in LCR 0x80 */
0630     status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
0631 
0632     Data = 0x0c;
0633     status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
0634 
0635     Data = 0x0;
0636     status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
0637 
0638     Data = 0x00;
0639     status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
0640 
0641     Data = Data & ~SERIAL_LCR_DLAB;
0642     status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
0643     mos7840_port->shadowLCR = Data;
0644 
0645     /* clearing Bulkin and Bulkout Fifo */
0646     Data = 0x0;
0647     status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
0648 
0649     Data = Data | 0x0c;
0650     status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
0651 
0652     Data = Data & ~0x0c;
0653     status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
0654     /* Finally enable all interrupts */
0655     Data = 0x0c;
0656     status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
0657 
0658     /* clearing rx_disable */
0659     Data = 0x0;
0660     status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
0661                                     &Data);
0662     Data = Data & ~0x20;
0663     status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
0664                                     Data);
0665 
0666     /* rx_negate */
0667     Data = 0x0;
0668     status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
0669                                     &Data);
0670     Data = Data | 0x10;
0671     status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
0672                                     Data);
0673 
0674     dev_dbg(&port->dev, "port number is %d\n", port->port_number);
0675     dev_dbg(&port->dev, "minor number is %d\n", port->minor);
0676     dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
0677     dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
0678     dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
0679     dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num);
0680     mos7840_port->read_urb = port->read_urb;
0681 
0682     /* set up our bulk in urb */
0683     if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
0684         usb_fill_bulk_urb(mos7840_port->read_urb,
0685             serial->dev,
0686             usb_rcvbulkpipe(serial->dev,
0687                 (port->bulk_in_endpointAddress) + 2),
0688             port->bulk_in_buffer,
0689             mos7840_port->read_urb->transfer_buffer_length,
0690             mos7840_bulk_in_callback, mos7840_port);
0691     } else {
0692         usb_fill_bulk_urb(mos7840_port->read_urb,
0693             serial->dev,
0694             usb_rcvbulkpipe(serial->dev,
0695                 port->bulk_in_endpointAddress),
0696             port->bulk_in_buffer,
0697             mos7840_port->read_urb->transfer_buffer_length,
0698             mos7840_bulk_in_callback, mos7840_port);
0699     }
0700 
0701     dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress);
0702     mos7840_port->read_urb_busy = true;
0703     response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
0704     if (response) {
0705         dev_err(&port->dev, "%s - Error %d submitting control urb\n",
0706             __func__, response);
0707         mos7840_port->read_urb_busy = false;
0708     }
0709 
0710     /* initialize our port settings */
0711     /* Must set to enable ints! */
0712     mos7840_port->shadowMCR = MCR_MASTER_IE;
0713 
0714     return 0;
0715 err:
0716     for (j = 0; j < NUM_URBS; ++j) {
0717         urb = mos7840_port->write_urb_pool[j];
0718         if (!urb)
0719             continue;
0720         kfree(urb->transfer_buffer);
0721         usb_free_urb(urb);
0722     }
0723     return status;
0724 }
0725 
0726 /*****************************************************************************
0727  * mos7840_chars_in_buffer
0728  *  this function is called by the tty driver when it wants to know how many
0729  *  bytes of data we currently have outstanding in the port (data that has
0730  *  been written, but hasn't made it out the port yet)
0731  *****************************************************************************/
0732 
0733 static unsigned int mos7840_chars_in_buffer(struct tty_struct *tty)
0734 {
0735     struct usb_serial_port *port = tty->driver_data;
0736     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0737     int i;
0738     unsigned int chars = 0;
0739     unsigned long flags;
0740 
0741     spin_lock_irqsave(&mos7840_port->pool_lock, flags);
0742     for (i = 0; i < NUM_URBS; ++i) {
0743         if (mos7840_port->busy[i]) {
0744             struct urb *urb = mos7840_port->write_urb_pool[i];
0745             chars += urb->transfer_buffer_length;
0746         }
0747     }
0748     spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
0749     dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
0750     return chars;
0751 
0752 }
0753 
0754 /*****************************************************************************
0755  * mos7840_close
0756  *  this function is called by the tty driver when a port is closed
0757  *****************************************************************************/
0758 
0759 static void mos7840_close(struct usb_serial_port *port)
0760 {
0761     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0762     int j;
0763     __u16 Data;
0764 
0765     for (j = 0; j < NUM_URBS; ++j)
0766         usb_kill_urb(mos7840_port->write_urb_pool[j]);
0767 
0768     /* Freeing Write URBs */
0769     for (j = 0; j < NUM_URBS; ++j) {
0770         if (mos7840_port->write_urb_pool[j]) {
0771             kfree(mos7840_port->write_urb_pool[j]->transfer_buffer);
0772             usb_free_urb(mos7840_port->write_urb_pool[j]);
0773         }
0774     }
0775 
0776     usb_kill_urb(mos7840_port->read_urb);
0777     mos7840_port->read_urb_busy = false;
0778 
0779     Data = 0x0;
0780     mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
0781 
0782     Data = 0x00;
0783     mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
0784 }
0785 
0786 /*****************************************************************************
0787  * mos7840_break
0788  *  this function sends a break to the port
0789  *****************************************************************************/
0790 static void mos7840_break(struct tty_struct *tty, int break_state)
0791 {
0792     struct usb_serial_port *port = tty->driver_data;
0793     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0794     unsigned char data;
0795 
0796     if (break_state == -1)
0797         data = mos7840_port->shadowLCR | LCR_SET_BREAK;
0798     else
0799         data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
0800 
0801     /* FIXME: no locking on shadowLCR anywhere in driver */
0802     mos7840_port->shadowLCR = data;
0803     dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
0804     mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
0805                  mos7840_port->shadowLCR);
0806 }
0807 
0808 /*****************************************************************************
0809  * mos7840_write_room
0810  *  this function is called by the tty driver when it wants to know how many
0811  *  bytes of data we can accept for a specific port.
0812  *****************************************************************************/
0813 
0814 static unsigned int mos7840_write_room(struct tty_struct *tty)
0815 {
0816     struct usb_serial_port *port = tty->driver_data;
0817     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0818     int i;
0819     unsigned int room = 0;
0820     unsigned long flags;
0821 
0822     spin_lock_irqsave(&mos7840_port->pool_lock, flags);
0823     for (i = 0; i < NUM_URBS; ++i) {
0824         if (!mos7840_port->busy[i])
0825             room += URB_TRANSFER_BUFFER_SIZE;
0826     }
0827     spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
0828 
0829     room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
0830     dev_dbg(&mos7840_port->port->dev, "%s - returns %u\n", __func__, room);
0831     return room;
0832 
0833 }
0834 
0835 /*****************************************************************************
0836  * mos7840_write
0837  *  this function is called by the tty driver when data should be written to
0838  *  the port.
0839  *  If successful, we return the number of bytes written, otherwise we
0840  *      return a negative error number.
0841  *****************************************************************************/
0842 
0843 static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
0844              const unsigned char *data, int count)
0845 {
0846     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0847     struct usb_serial *serial = port->serial;
0848     int status;
0849     int i;
0850     int bytes_sent = 0;
0851     int transfer_size;
0852     unsigned long flags;
0853     struct urb *urb;
0854     /* __u16 Data; */
0855     const unsigned char *current_position = data;
0856 
0857     /* try to find a free urb in the list */
0858     urb = NULL;
0859 
0860     spin_lock_irqsave(&mos7840_port->pool_lock, flags);
0861     for (i = 0; i < NUM_URBS; ++i) {
0862         if (!mos7840_port->busy[i]) {
0863             mos7840_port->busy[i] = 1;
0864             urb = mos7840_port->write_urb_pool[i];
0865             dev_dbg(&port->dev, "URB:%d\n", i);
0866             break;
0867         }
0868     }
0869     spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
0870 
0871     if (urb == NULL) {
0872         dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
0873         goto exit;
0874     }
0875 
0876     if (urb->transfer_buffer == NULL) {
0877         urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
0878                            GFP_ATOMIC);
0879         if (!urb->transfer_buffer) {
0880             bytes_sent = -ENOMEM;
0881             goto exit;
0882         }
0883     }
0884     transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
0885 
0886     memcpy(urb->transfer_buffer, current_position, transfer_size);
0887 
0888     /* fill urb with data and submit  */
0889     if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
0890         usb_fill_bulk_urb(urb,
0891             serial->dev,
0892             usb_sndbulkpipe(serial->dev,
0893                 (port->bulk_out_endpointAddress) + 2),
0894             urb->transfer_buffer,
0895             transfer_size,
0896             mos7840_bulk_out_data_callback, mos7840_port);
0897     } else {
0898         usb_fill_bulk_urb(urb,
0899             serial->dev,
0900             usb_sndbulkpipe(serial->dev,
0901                 port->bulk_out_endpointAddress),
0902             urb->transfer_buffer,
0903             transfer_size,
0904             mos7840_bulk_out_data_callback, mos7840_port);
0905     }
0906 
0907     dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
0908 
0909     if (mos7840_port->has_led)
0910         mos7840_led_activity(port);
0911 
0912     /* send it down the pipe */
0913     status = usb_submit_urb(urb, GFP_ATOMIC);
0914 
0915     if (status) {
0916         mos7840_port->busy[i] = 0;
0917         dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
0918             "with status = %d\n", __func__, status);
0919         bytes_sent = status;
0920         goto exit;
0921     }
0922     bytes_sent = transfer_size;
0923     port->icount.tx += transfer_size;
0924     dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx);
0925 exit:
0926     return bytes_sent;
0927 
0928 }
0929 
0930 /*****************************************************************************
0931  * mos7840_throttle
0932  *  this function is called by the tty driver when it wants to stop the data
0933  *  being read from the port.
0934  *****************************************************************************/
0935 
0936 static void mos7840_throttle(struct tty_struct *tty)
0937 {
0938     struct usb_serial_port *port = tty->driver_data;
0939     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0940     int status;
0941 
0942     /* if we are implementing XON/XOFF, send the stop character */
0943     if (I_IXOFF(tty)) {
0944         unsigned char stop_char = STOP_CHAR(tty);
0945         status = mos7840_write(tty, port, &stop_char, 1);
0946         if (status <= 0)
0947             return;
0948     }
0949     /* if we are implementing RTS/CTS, toggle that line */
0950     if (C_CRTSCTS(tty)) {
0951         mos7840_port->shadowMCR &= ~MCR_RTS;
0952         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
0953                      mos7840_port->shadowMCR);
0954         if (status < 0)
0955             return;
0956     }
0957 }
0958 
0959 /*****************************************************************************
0960  * mos7840_unthrottle
0961  *  this function is called by the tty driver when it wants to resume
0962  *  the data being read from the port (called after mos7840_throttle is
0963  *  called)
0964  *****************************************************************************/
0965 static void mos7840_unthrottle(struct tty_struct *tty)
0966 {
0967     struct usb_serial_port *port = tty->driver_data;
0968     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
0969     int status;
0970 
0971     /* if we are implementing XON/XOFF, send the start character */
0972     if (I_IXOFF(tty)) {
0973         unsigned char start_char = START_CHAR(tty);
0974         status = mos7840_write(tty, port, &start_char, 1);
0975         if (status <= 0)
0976             return;
0977     }
0978 
0979     /* if we are implementing RTS/CTS, toggle that line */
0980     if (C_CRTSCTS(tty)) {
0981         mos7840_port->shadowMCR |= MCR_RTS;
0982         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
0983                      mos7840_port->shadowMCR);
0984         if (status < 0)
0985             return;
0986     }
0987 }
0988 
0989 static int mos7840_tiocmget(struct tty_struct *tty)
0990 {
0991     struct usb_serial_port *port = tty->driver_data;
0992     unsigned int result;
0993     __u16 msr;
0994     __u16 mcr;
0995     int status;
0996 
0997     status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
0998     if (status < 0)
0999         return -EIO;
1000     status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
1001     if (status < 0)
1002         return -EIO;
1003     result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1004         | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1005         | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1006         | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1007         | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1008         | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1009         | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1010 
1011     dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1012 
1013     return result;
1014 }
1015 
1016 static int mos7840_tiocmset(struct tty_struct *tty,
1017                 unsigned int set, unsigned int clear)
1018 {
1019     struct usb_serial_port *port = tty->driver_data;
1020     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1021     unsigned int mcr;
1022     int status;
1023 
1024     /* FIXME: What locks the port registers ? */
1025     mcr = mos7840_port->shadowMCR;
1026     if (clear & TIOCM_RTS)
1027         mcr &= ~MCR_RTS;
1028     if (clear & TIOCM_DTR)
1029         mcr &= ~MCR_DTR;
1030     if (clear & TIOCM_LOOP)
1031         mcr &= ~MCR_LOOPBACK;
1032 
1033     if (set & TIOCM_RTS)
1034         mcr |= MCR_RTS;
1035     if (set & TIOCM_DTR)
1036         mcr |= MCR_DTR;
1037     if (set & TIOCM_LOOP)
1038         mcr |= MCR_LOOPBACK;
1039 
1040     mos7840_port->shadowMCR = mcr;
1041 
1042     status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1043     if (status < 0) {
1044         dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
1045         return status;
1046     }
1047 
1048     return 0;
1049 }
1050 
1051 /*****************************************************************************
1052  * mos7840_calc_baud_rate_divisor
1053  *  this function calculates the proper baud rate divisor for the specified
1054  *  baud rate.
1055  *****************************************************************************/
1056 static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
1057                       int baudRate, int *divisor,
1058                       __u16 *clk_sel_val)
1059 {
1060     dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
1061 
1062     if (baudRate <= 115200) {
1063         *divisor = 115200 / baudRate;
1064         *clk_sel_val = 0x0;
1065     }
1066     if ((baudRate > 115200) && (baudRate <= 230400)) {
1067         *divisor = 230400 / baudRate;
1068         *clk_sel_val = 0x10;
1069     } else if ((baudRate > 230400) && (baudRate <= 403200)) {
1070         *divisor = 403200 / baudRate;
1071         *clk_sel_val = 0x20;
1072     } else if ((baudRate > 403200) && (baudRate <= 460800)) {
1073         *divisor = 460800 / baudRate;
1074         *clk_sel_val = 0x30;
1075     } else if ((baudRate > 460800) && (baudRate <= 806400)) {
1076         *divisor = 806400 / baudRate;
1077         *clk_sel_val = 0x40;
1078     } else if ((baudRate > 806400) && (baudRate <= 921600)) {
1079         *divisor = 921600 / baudRate;
1080         *clk_sel_val = 0x50;
1081     } else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1082         *divisor = 1572864 / baudRate;
1083         *clk_sel_val = 0x60;
1084     } else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1085         *divisor = 3145728 / baudRate;
1086         *clk_sel_val = 0x70;
1087     }
1088     return 0;
1089 }
1090 
1091 /*****************************************************************************
1092  * mos7840_send_cmd_write_baud_rate
1093  *  this function sends the proper command to change the baud rate of the
1094  *  specified port.
1095  *****************************************************************************/
1096 
1097 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1098                         int baudRate)
1099 {
1100     struct usb_serial_port *port = mos7840_port->port;
1101     int divisor = 0;
1102     int status;
1103     __u16 Data;
1104     __u16 clk_sel_val;
1105 
1106     dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate);
1107     /* reset clk_uart_sel in spregOffset */
1108     if (baudRate > 115200) {
1109 #ifdef HW_flow_control
1110         /* NOTE: need to see the pther register to modify */
1111         /* setting h/w flow control bit to 1 */
1112         Data = 0x2b;
1113         mos7840_port->shadowMCR = Data;
1114         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1115                                     Data);
1116         if (status < 0) {
1117             dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1118             return -1;
1119         }
1120 #endif
1121 
1122     } else {
1123 #ifdef HW_flow_control
1124         /* setting h/w flow control bit to 0 */
1125         Data = 0xb;
1126         mos7840_port->shadowMCR = Data;
1127         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1128                                     Data);
1129         if (status < 0) {
1130             dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1131             return -1;
1132         }
1133 #endif
1134 
1135     }
1136 
1137     if (1) {        /* baudRate <= 115200) */
1138         clk_sel_val = 0x0;
1139         Data = 0x0;
1140         status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
1141                            &clk_sel_val);
1142         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1143                                  &Data);
1144         if (status < 0) {
1145             dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
1146             return -1;
1147         }
1148         Data = (Data & 0x8f) | clk_sel_val;
1149         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1150                                 Data);
1151         if (status < 0) {
1152             dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1153             return -1;
1154         }
1155         /* Calculate the Divisor */
1156 
1157         if (status) {
1158             dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1159             return status;
1160         }
1161         /* Enable access to divisor latch */
1162         Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1163         mos7840_port->shadowLCR = Data;
1164         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1165 
1166         /* Write the divisor */
1167         Data = (unsigned char)(divisor & 0xff);
1168         dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
1169         mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1170 
1171         Data = (unsigned char)((divisor & 0xff00) >> 8);
1172         dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
1173         mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1174 
1175         /* Disable access to divisor latch */
1176         Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1177         mos7840_port->shadowLCR = Data;
1178         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1179 
1180     }
1181     return status;
1182 }
1183 
1184 /*****************************************************************************
1185  * mos7840_change_port_settings
1186  *  This routine is called to set the UART on the device to match
1187  *      the specified new settings.
1188  *****************************************************************************/
1189 
1190 static void mos7840_change_port_settings(struct tty_struct *tty,
1191     struct moschip_port *mos7840_port, struct ktermios *old_termios)
1192 {
1193     struct usb_serial_port *port = mos7840_port->port;
1194     int baud;
1195     unsigned cflag;
1196     __u8 lData;
1197     __u8 lParity;
1198     __u8 lStop;
1199     int status;
1200     __u16 Data;
1201 
1202     lData = LCR_BITS_8;
1203     lStop = LCR_STOP_1;
1204     lParity = LCR_PAR_NONE;
1205 
1206     cflag = tty->termios.c_cflag;
1207 
1208     /* Change the number of bits */
1209     switch (cflag & CSIZE) {
1210     case CS5:
1211         lData = LCR_BITS_5;
1212         break;
1213 
1214     case CS6:
1215         lData = LCR_BITS_6;
1216         break;
1217 
1218     case CS7:
1219         lData = LCR_BITS_7;
1220         break;
1221 
1222     default:
1223     case CS8:
1224         lData = LCR_BITS_8;
1225         break;
1226     }
1227 
1228     /* Change the Parity bit */
1229     if (cflag & PARENB) {
1230         if (cflag & PARODD) {
1231             lParity = LCR_PAR_ODD;
1232             dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1233         } else {
1234             lParity = LCR_PAR_EVEN;
1235             dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1236         }
1237 
1238     } else {
1239         dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1240     }
1241 
1242     if (cflag & CMSPAR)
1243         lParity = lParity | 0x20;
1244 
1245     /* Change the Stop bit */
1246     if (cflag & CSTOPB) {
1247         lStop = LCR_STOP_2;
1248         dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1249     } else {
1250         lStop = LCR_STOP_1;
1251         dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1252     }
1253 
1254     /* Update the LCR with the correct value */
1255     mos7840_port->shadowLCR &=
1256         ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1257     mos7840_port->shadowLCR |= (lData | lParity | lStop);
1258 
1259     dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
1260         mos7840_port->shadowLCR);
1261     /* Disable Interrupts */
1262     Data = 0x00;
1263     mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1264 
1265     Data = 0x00;
1266     mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1267 
1268     Data = 0xcf;
1269     mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1270 
1271     /* Send the updated LCR value to the mos7840 */
1272     Data = mos7840_port->shadowLCR;
1273 
1274     mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1275 
1276     Data = 0x00b;
1277     mos7840_port->shadowMCR = Data;
1278     mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1279     Data = 0x00b;
1280     mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1281 
1282     /* set up the MCR register and send it to the mos7840 */
1283 
1284     mos7840_port->shadowMCR = MCR_MASTER_IE;
1285     if (cflag & CBAUD)
1286         mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
1287 
1288     if (cflag & CRTSCTS)
1289         mos7840_port->shadowMCR |= (MCR_XON_ANY);
1290     else
1291         mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
1292 
1293     Data = mos7840_port->shadowMCR;
1294     mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1295 
1296     /* Determine divisor based on baud rate */
1297     baud = tty_get_baud_rate(tty);
1298 
1299     if (!baud) {
1300         /* pick a default, any default... */
1301         dev_dbg(&port->dev, "%s", "Picked default baud...\n");
1302         baud = 9600;
1303     }
1304 
1305     dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1306     status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
1307 
1308     /* Enable Interrupts */
1309     Data = 0x0c;
1310     mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1311 
1312     if (!mos7840_port->read_urb_busy) {
1313         mos7840_port->read_urb_busy = true;
1314         status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1315         if (status) {
1316             dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1317                 status);
1318             mos7840_port->read_urb_busy = false;
1319         }
1320     }
1321     dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
1322         mos7840_port->shadowLCR);
1323 }
1324 
1325 /*****************************************************************************
1326  * mos7840_set_termios
1327  *  this function is called by the tty driver when it wants to change
1328  *  the termios structure
1329  *****************************************************************************/
1330 
1331 static void mos7840_set_termios(struct tty_struct *tty,
1332                 struct usb_serial_port *port,
1333                 struct ktermios *old_termios)
1334 {
1335     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1336     int status;
1337 
1338     /* change the port settings to the new ones specified */
1339 
1340     mos7840_change_port_settings(tty, mos7840_port, old_termios);
1341 
1342     if (!mos7840_port->read_urb_busy) {
1343         mos7840_port->read_urb_busy = true;
1344         status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1345         if (status) {
1346             dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1347                 status);
1348             mos7840_port->read_urb_busy = false;
1349         }
1350     }
1351 }
1352 
1353 /*****************************************************************************
1354  * mos7840_get_lsr_info - get line status register info
1355  *
1356  * Purpose: Let user call ioctl() to get info when the UART physically
1357  *      is emptied.  On bus types like RS485, the transmitter must
1358  *      release the bus after transmitting. This must be done when
1359  *      the transmit shift register is empty, not be done when the
1360  *      transmit holding register is empty.  This functionality
1361  *      allows an RS485 driver to be written in user space.
1362  *****************************************************************************/
1363 
1364 static int mos7840_get_lsr_info(struct tty_struct *tty,
1365                 unsigned int __user *value)
1366 {
1367     int count;
1368     unsigned int result = 0;
1369 
1370     count = mos7840_chars_in_buffer(tty);
1371     if (count == 0)
1372         result = TIOCSER_TEMT;
1373 
1374     if (copy_to_user(value, &result, sizeof(int)))
1375         return -EFAULT;
1376     return 0;
1377 }
1378 
1379 /*****************************************************************************
1380  * SerialIoctl
1381  *  this function handles any ioctl calls to the driver
1382  *****************************************************************************/
1383 
1384 static int mos7840_ioctl(struct tty_struct *tty,
1385              unsigned int cmd, unsigned long arg)
1386 {
1387     struct usb_serial_port *port = tty->driver_data;
1388     void __user *argp = (void __user *)arg;
1389 
1390     switch (cmd) {
1391         /* return number of bytes available */
1392 
1393     case TIOCSERGETLSR:
1394         dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
1395         return mos7840_get_lsr_info(tty, argp);
1396 
1397     default:
1398         break;
1399     }
1400     return -ENOIOCTLCMD;
1401 }
1402 
1403 /*
1404  * Check if GPO (pin 42) is connected to GPI (pin 33) as recommended by ASIX
1405  * for MCS7810 by bit-banging a 16-bit word.
1406  *
1407  * Note that GPO is really RTS of the third port so this will toggle RTS of
1408  * port two or three on two- and four-port devices.
1409  */
1410 static int mos7810_check(struct usb_serial *serial)
1411 {
1412     int i, pass_count = 0;
1413     u8 *buf;
1414     __u16 data = 0, mcr_data = 0;
1415     __u16 test_pattern = 0x55AA;
1416     int res;
1417 
1418     buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1419     if (!buf)
1420         return 0;   /* failed to identify 7810 */
1421 
1422     /* Store MCR setting */
1423     res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1424         MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER,
1425         buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1426     if (res == VENDOR_READ_LENGTH)
1427         mcr_data = *buf;
1428 
1429     for (i = 0; i < 16; i++) {
1430         /* Send the 1-bit test pattern out to MCS7810 test pin */
1431         usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1432             MCS_WRREQ, MCS_WR_RTYPE,
1433             (0x0300 | (((test_pattern >> i) & 0x0001) << 1)),
1434             MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT);
1435 
1436         /* Read the test pattern back */
1437         res = usb_control_msg(serial->dev,
1438                 usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ,
1439                 MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1440                 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1441         if (res == VENDOR_READ_LENGTH)
1442             data = *buf;
1443 
1444         /* If this is a MCS7810 device, both test patterns must match */
1445         if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001)
1446             break;
1447 
1448         pass_count++;
1449     }
1450 
1451     /* Restore MCR setting */
1452     usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ,
1453         MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL,
1454         0, MOS_WDR_TIMEOUT);
1455 
1456     kfree(buf);
1457 
1458     if (pass_count == 16)
1459         return 1;
1460 
1461     return 0;
1462 }
1463 
1464 static int mos7840_probe(struct usb_serial *serial,
1465                 const struct usb_device_id *id)
1466 {
1467     unsigned long device_flags = id->driver_info;
1468     u8 *buf;
1469 
1470     /* Skip device-type detection if we already have device flags. */
1471     if (device_flags)
1472         goto out;
1473 
1474     buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1475     if (!buf)
1476         return -ENOMEM;
1477 
1478     usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1479             MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1480             VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1481 
1482     /* For a MCS7840 device GPIO0 must be set to 1 */
1483     if (buf[0] & 0x01)
1484         device_flags = MCS_PORTS(4);
1485     else if (mos7810_check(serial))
1486         device_flags = MCS_PORTS(1) | MCS_LED;
1487     else
1488         device_flags = MCS_PORTS(2);
1489 
1490     kfree(buf);
1491 out:
1492     usb_set_serial_data(serial, (void *)device_flags);
1493 
1494     return 0;
1495 }
1496 
1497 static int mos7840_calc_num_ports(struct usb_serial *serial,
1498                     struct usb_serial_endpoints *epds)
1499 {
1500     unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1501     int num_ports = MCS_PORTS(device_flags);
1502 
1503     if (num_ports == 0 || num_ports > 4)
1504         return -ENODEV;
1505 
1506     if (epds->num_bulk_in < num_ports || epds->num_bulk_out < num_ports) {
1507         dev_err(&serial->interface->dev, "missing endpoints\n");
1508         return -ENODEV;
1509     }
1510 
1511     return num_ports;
1512 }
1513 
1514 static int mos7840_attach(struct usb_serial *serial)
1515 {
1516     struct device *dev = &serial->interface->dev;
1517     int status;
1518     u16 val;
1519 
1520     /* Zero Length flag enable */
1521     val = 0x0f;
1522     status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, val);
1523     if (status < 0)
1524         dev_dbg(dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
1525     else
1526         dev_dbg(dev, "ZLP_REG5 Writing success status%d\n", status);
1527 
1528     return status;
1529 }
1530 
1531 static int mos7840_port_probe(struct usb_serial_port *port)
1532 {
1533     struct usb_serial *serial = port->serial;
1534     unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1535     struct moschip_port *mos7840_port;
1536     int status;
1537     int pnum;
1538     __u16 Data;
1539 
1540     /* we set up the pointers to the endpoints in the mos7840_open *
1541      * function, as the structures aren't created yet.             */
1542 
1543     pnum = port->port_number;
1544 
1545     dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
1546     mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
1547     if (!mos7840_port)
1548         return -ENOMEM;
1549 
1550     /* Initialize all port interrupt end point to port 0 int
1551      * endpoint. Our device has only one interrupt end point
1552      * common to all port */
1553 
1554     mos7840_port->port = port;
1555     spin_lock_init(&mos7840_port->pool_lock);
1556 
1557     /* minor is not initialised until later by
1558      * usb-serial.c:get_free_serial() and cannot therefore be used
1559      * to index device instances */
1560     mos7840_port->port_num = pnum + 1;
1561     dev_dbg(&port->dev, "port->minor = %d\n", port->minor);
1562     dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
1563 
1564     if (mos7840_port->port_num == 1) {
1565         mos7840_port->SpRegOffset = 0x0;
1566         mos7840_port->ControlRegOffset = 0x1;
1567         mos7840_port->DcrRegOffset = 0x4;
1568     } else {
1569         u8 phy_num = mos7840_port->port_num;
1570 
1571         /* Port 2 in the 2-port case uses registers of port 3 */
1572         if (serial->num_ports == 2)
1573             phy_num = 3;
1574 
1575         mos7840_port->SpRegOffset = 0x8 + 2 * (phy_num - 2);
1576         mos7840_port->ControlRegOffset = 0x9 + 2 * (phy_num - 2);
1577         mos7840_port->DcrRegOffset = 0x16 + 3 * (phy_num - 2);
1578     }
1579     mos7840_dump_serial_port(port, mos7840_port);
1580     usb_set_serial_port_data(port, mos7840_port);
1581 
1582     /* enable rx_disable bit in control register */
1583     status = mos7840_get_reg_sync(port,
1584             mos7840_port->ControlRegOffset, &Data);
1585     if (status < 0) {
1586         dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status);
1587         goto error;
1588     } else
1589         dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
1590     Data |= 0x08;   /* setting driver done bit */
1591     Data |= 0x04;   /* sp1_bit to have cts change reflect in
1592                modem status reg */
1593 
1594     /* Data |= 0x20; //rx_disable bit */
1595     status = mos7840_set_reg_sync(port,
1596             mos7840_port->ControlRegOffset, Data);
1597     if (status < 0) {
1598         dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
1599         goto error;
1600     } else
1601         dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
1602 
1603     /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
1604        and 0x24 in DCR3 */
1605     Data = 0x01;
1606     status = mos7840_set_reg_sync(port,
1607             (__u16) (mos7840_port->DcrRegOffset + 0), Data);
1608     if (status < 0) {
1609         dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status);
1610         goto error;
1611     } else
1612         dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status);
1613 
1614     Data = 0x05;
1615     status = mos7840_set_reg_sync(port,
1616             (__u16) (mos7840_port->DcrRegOffset + 1), Data);
1617     if (status < 0) {
1618         dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status);
1619         goto error;
1620     } else
1621         dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status);
1622 
1623     Data = 0x24;
1624     status = mos7840_set_reg_sync(port,
1625             (__u16) (mos7840_port->DcrRegOffset + 2), Data);
1626     if (status < 0) {
1627         dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status);
1628         goto error;
1629     } else
1630         dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status);
1631 
1632     /* write values in clkstart0x0 and clkmulti 0x20 */
1633     Data = 0x0;
1634     status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data);
1635     if (status < 0) {
1636         dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
1637         goto error;
1638     } else
1639         dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
1640 
1641     Data = 0x20;
1642     status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data);
1643     if (status < 0) {
1644         dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
1645         goto error;
1646     } else
1647         dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
1648 
1649     /* write value 0x0 to scratchpad register */
1650     Data = 0x00;
1651     status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data);
1652     if (status < 0) {
1653         dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
1654         goto error;
1655     } else
1656         dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
1657 
1658     /* Zero Length flag register */
1659     if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) {
1660         Data = 0xff;
1661         status = mos7840_set_reg_sync(port,
1662                 (__u16) (ZLP_REG1 +
1663                     ((__u16)mos7840_port->port_num)), Data);
1664         dev_dbg(&port->dev, "ZLIP offset %x\n",
1665                 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
1666         if (status < 0) {
1667             dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status);
1668             goto error;
1669         } else
1670             dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status);
1671     } else {
1672         Data = 0xff;
1673         status = mos7840_set_reg_sync(port,
1674                 (__u16) (ZLP_REG1 +
1675                     ((__u16)mos7840_port->port_num) - 0x1), Data);
1676         dev_dbg(&port->dev, "ZLIP offset %x\n",
1677                 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
1678         if (status < 0) {
1679             dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status);
1680             goto error;
1681         } else
1682             dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status);
1683 
1684     }
1685 
1686     mos7840_port->has_led = device_flags & MCS_LED;
1687 
1688     /* Initialize LED timers */
1689     if (mos7840_port->has_led) {
1690         mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
1691         mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr),
1692                                 GFP_KERNEL);
1693         if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
1694             status = -ENOMEM;
1695             goto error;
1696         }
1697 
1698         timer_setup(&mos7840_port->led_timer1, mos7840_led_off, 0);
1699         mos7840_port->led_timer1.expires =
1700             jiffies + msecs_to_jiffies(LED_ON_MS);
1701         timer_setup(&mos7840_port->led_timer2, mos7840_led_flag_off,
1702                 0);
1703         mos7840_port->led_timer2.expires =
1704             jiffies + msecs_to_jiffies(LED_OFF_MS);
1705 
1706         /* Turn off LED */
1707         mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1708     }
1709 
1710     return 0;
1711 error:
1712     kfree(mos7840_port->led_dr);
1713     usb_free_urb(mos7840_port->led_urb);
1714     kfree(mos7840_port);
1715 
1716     return status;
1717 }
1718 
1719 static void mos7840_port_remove(struct usb_serial_port *port)
1720 {
1721     struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1722 
1723     if (mos7840_port->has_led) {
1724         /* Turn off LED */
1725         mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1726 
1727         del_timer_sync(&mos7840_port->led_timer1);
1728         del_timer_sync(&mos7840_port->led_timer2);
1729 
1730         usb_kill_urb(mos7840_port->led_urb);
1731         usb_free_urb(mos7840_port->led_urb);
1732         kfree(mos7840_port->led_dr);
1733     }
1734 
1735     kfree(mos7840_port);
1736 }
1737 
1738 static struct usb_serial_driver moschip7840_4port_device = {
1739     .driver = {
1740            .owner = THIS_MODULE,
1741            .name = "mos7840",
1742            },
1743     .description = DRIVER_DESC,
1744     .id_table = id_table,
1745     .num_interrupt_in = 1,
1746     .open = mos7840_open,
1747     .close = mos7840_close,
1748     .write = mos7840_write,
1749     .write_room = mos7840_write_room,
1750     .chars_in_buffer = mos7840_chars_in_buffer,
1751     .throttle = mos7840_throttle,
1752     .unthrottle = mos7840_unthrottle,
1753     .calc_num_ports = mos7840_calc_num_ports,
1754     .probe = mos7840_probe,
1755     .attach = mos7840_attach,
1756     .ioctl = mos7840_ioctl,
1757     .set_termios = mos7840_set_termios,
1758     .break_ctl = mos7840_break,
1759     .tiocmget = mos7840_tiocmget,
1760     .tiocmset = mos7840_tiocmset,
1761     .get_icount = usb_serial_generic_get_icount,
1762     .port_probe = mos7840_port_probe,
1763     .port_remove = mos7840_port_remove,
1764     .read_bulk_callback = mos7840_bulk_in_callback,
1765 };
1766 
1767 static struct usb_serial_driver * const serial_drivers[] = {
1768     &moschip7840_4port_device, NULL
1769 };
1770 
1771 module_usb_serial_driver(serial_drivers, id_table);
1772 
1773 MODULE_DESCRIPTION(DRIVER_DESC);
1774 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!