Dne Čt 19. srpna 2010 08:17:30 Raju Rameshwar Uprade napsal(a):
> Dear Sir,
> I am trying to write a Pl2303_mcm.c usb-serial device driver which
> will be able to talk to several devices using RS-485 interface card.I have
> modified the standard pl2303.c by which I am able to enable/disable the
> RTS line.
> I am sending 10 bytes of data to the device, data is going out but instead
> of 10 bytes, device driver is sending a large amount of data as seen on
> Lecroy waverunner oscilloscope. Here I am sending the modified file.
Hi, I have no idea why I'm CCed in this, but anyway.
1) could you please update the driver to a more recent kernel (we are 10 kernel
versions further now)
2) could you please send a diff instead of a whole file? (git diff <file1>
<file2> > diff.diff ... see man git-diff)
Cheers
>
> /* Prolific PL2303 USB to serial adaptor driver which will be able to
> communicate with MCM.....for kernel version 2.6.25.14
> Implementing mcmdriver in pl2303.c */
>
> #include <linux/kernel.h>
> #include <linux/errno.h>
> #include <linux/init.h>
> #include <linux/slab.h>
> #include <linux/tty.h>
> #include <linux/tty_driver.h>
> #include <linux/tty_flip.h>
> #include <linux/serial.h>
> #include <linux/module.h>
> #include <linux/moduleparam.h>
> #include <linux/spinlock.h>
> #include <asm/uaccess.h>
> #include <linux/usb.h>
> #include <linux/usb/serial.h>
> #include <linux/delay.h>
> #define PL2303_VENDOR_ID 0x067b
> #define PL2303_PRODUCT_ID 0x2303
> /*
> * Version Information
> */
> #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
>
> static int debug;
> #define PL2303_CLOSING_WAIT (30*HZ)
>
> /* Original
>
> #define PL2303_BUF_SIZE 1024
> #define PL2303_TMP_BUF_SIZE 1024 */
>
> #define PL2303_BUF_SIZE 100
> #define PL2303_TMP_BUF_SIZE 100
>
> struct pl2303_buf {
> unsigned int buf_size;
> char *buf_buf;
> char *buf_get;
> char *buf_put;
> };
>
> static struct usb_device_id id_table [] = {
> { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
> { } /* Terminating entry */
> };
>
> MODULE_DEVICE_TABLE(usb, id_table);
>
> static struct usb_driver pl2303_mcm_driver = {
> .name = "pl2303_mcm",
> .probe = usb_serial_probe,
> .disconnect = usb_serial_disconnect,
> .id_table = id_table,
> .suspend = usb_serial_suspend,
> .resume = usb_serial_resume,
> .no_dynamic_id = 1,
> .supports_autosuspend = 1,
> };
>
> #define SET_LINE_REQUEST_TYPE 0x21
> #define SET_LINE_REQUEST 0x20
>
> #define SET_CONTROL_REQUEST_TYPE 0x21
> #define SET_CONTROL_REQUEST 0x22
> #define CONTROL_DTR 0x01
> #define CONTROL_RTS 0x02
>
> #define BREAK_REQUEST_TYPE 0x21
> #define BREAK_REQUEST 0x23
> #define BREAK_ON 0xffff
> #define BREAK_OFF 0x0000
>
> #define GET_LINE_REQUEST_TYPE 0xa1
> #define GET_LINE_REQUEST 0x21
>
> #define VENDOR_WRITE_REQUEST_TYPE 0x40
> #define VENDOR_WRITE_REQUEST 0x01
>
> #define VENDOR_READ_REQUEST_TYPE 0xc0
> #define VENDOR_READ_REQUEST 0x01
>
> #define UART_STATE 0x08
> #define UART_STATE_TRANSIENT_MASK 0x74
> #define UART_DCD 0x01
> #define UART_DSR 0x02
> #define UART_BREAK_ERROR 0x04
> #define UART_RING 0x08
> #define UART_FRAME_ERROR 0x10
> #define UART_PARITY_ERROR 0x20
> #define UART_OVERRUN_ERROR 0x40
> #define UART_CTS 0x80
>
> enum pl2303_type {
> type_0, /* don't know the difference between type 0 and */
> type_1, /* type 1, until someone from prolific tells us... */
> HX, /* HX version of the pl2303 chip */
> };
>
> struct pl2303_private {
> spinlock_t lock; /* spin lock
*/
> struct pl2303_buf *buf;
> int write_urb_in_use;
> wait_queue_head_t delta_msr_wait;
> u8 line_control; /* used as MCR
(
> modem control register */
> u8 line_status; /* used as MSR
> (modem status register ) */
> u8 termios_initialized;
> enum pl2303_type type;
> };
>
> /*
> * pl2303_buf_alloc
> *
> * Allocate a circular buffer and all associated memory.
> */
> static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
> {
> struct pl2303_buf *pb;
>
> if (size == 0)
> return NULL;
>
> pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
> if (pb == NULL)
> return NULL;
>
> pb->buf_buf = kmalloc(size, GFP_KERNEL);
> if (pb->buf_buf == NULL) {
> kfree(pb);
> return NULL;
> }
>
> pb->buf_size = size;
> pb->buf_get = pb->buf_put = pb->buf_buf;
>
> return pb;
> }
>
> /*
> * pl2303_buf_free
> *
> * Free the buffer and all associated memory.
> */
> static void pl2303_buf_free(struct pl2303_buf *pb)
> {
> if (pb) {
> kfree(pb->buf_buf);
> kfree(pb);
> }
> }
>
> /*
> * pl2303_buf_clear
> *
> * Clear out all data in the circular buffer.
> */
> static void pl2303_buf_clear(struct pl2303_buf *pb)
> {
> if (pb != NULL)
> pb->buf_get = pb->buf_put;
> /* equivalent to a get of all data available */
> }
>
> /*
> * pl2303_buf_data_avail
> *
> * Return the number of bytes of data available in the circular
> * buffer.
> */
> static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
> {
> if (pb == NULL)
> return 0;
>
> return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
> }
>
> /*
> * pl2303_buf_space_avail
> *
> * Return the number of bytes of space available in the circular
> * buffer.
> */
> static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
> {
> if (pb == NULL)
> return 0;
>
> return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
> }
>
> /*
> * pl2303_buf_put
> *
> * Copy data from a user buffer and put it into the circular buffer.
>
> * Restrict to the amount of space available.
> *
> * Return the number of bytes copied.
> */
> static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char
> *buf,unsigned int count)
> {
> unsigned int len;
>
> if (pb == NULL)
> return 0;
>
> len = pl2303_buf_space_avail(pb);
> if (count > len) // if count is greater
> than len count = len;
>
> if (count == 0)
> return 0;
>
> len = pb->buf_buf + pb->buf_size - pb->buf_put;
> if (count > len)
> {
> // memcpy - copy memory area
> // void *memcpy(void *dest, const void *src, size_t n);
>
> memcpy(pb->buf_put, buf, len);
> memcpy(pb->buf_buf, buf+len, count - len);
> pb->buf_put = pb->buf_buf + count - len;
> }
> else
> {
> memcpy(pb->buf_put, buf, count);
> if (count < len)
> pb->buf_put += count;
> else /* count == len */
> pb->buf_put = pb->buf_buf;
> }
>
> return count;
> }
>
> /*
> * pl2303_buf_get
> *
> * Get data from the circular buffer and copy to the given buffer.
> * Restrict to the amount of data available.
> *
> * Return the number of bytes copied.
> */
> static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
> unsigned int count) {
> unsigned int len;
>
> if (pb == NULL)
> return 0;
>
> len = pl2303_buf_data_avail(pb);
> if (count > len)
> count = len;
>
> if (count == 0)
> return 0;
>
> len = pb->buf_buf + pb->buf_size - pb->buf_get;
> if (count > len) {
>
> // memcpy - copy memory area
> // void *memcpy(void *dest, const void *src, size_t n);
>
> memcpy(buf, pb->buf_get, len);
> memcpy(buf+len, pb->buf_buf, count - len);
> pb->buf_get = pb->buf_buf + count - len;
> } else {
> memcpy(buf, pb->buf_get, count);
> if (count < len)
> pb->buf_get += count;
> else /* count == len */
> pb->buf_get = pb->buf_buf;
> }
>
> return count;
> }
>
> static int pl2303_vendor_read(__u16 value, __u16 index,
> struct usb_serial *serial, unsigned char *buf)
> {
> int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
> VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
> value, index, buf, 1, 100);
> dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
> VENDOR_READ_REQUEST, value, index, res, buf[0]);
> return res;
> }
>
> static int pl2303_vendor_write(__u16 value, __u16 index,
> struct usb_serial *serial)
> {
> int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
> VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
> value, index, NULL, 0, 100);
> dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
> VENDOR_WRITE_REQUEST, value, index, res);
> return res;
> }
>
> static int pl2303_startup(struct usb_serial *serial)
> {
> struct pl2303_private *priv;
> enum pl2303_type type = type_0;
> unsigned char *buf;
> int i;
>
> buf = kmalloc(10, GFP_KERNEL);
> if (buf == NULL)
> return -ENOMEM;
>
> if (serial->dev->descriptor.bDeviceClass == 0x02)
> type = type_0;
> else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
> type = HX;
> else if (serial->dev->descriptor.bDeviceClass == 0x00)
> type = type_1;
> else if (serial->dev->descriptor.bDeviceClass == 0xFF)
> type = type_1;
> dbg("device type: %d", type);
>
> for (i = 0; i < serial->num_ports; ++i) {
> priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
> if (!priv)
> goto cleanup;
> spin_lock_init(&priv->lock);
> priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
> if (priv->buf == NULL) {
> kfree(priv);
> goto cleanup;
> }
> init_waitqueue_head(&priv->delta_msr_wait);
> priv->type = type;
> usb_set_serial_port_data(serial->port[i], priv);
> }
>
> pl2303_vendor_read(0x8484, 0, serial, buf);
> pl2303_vendor_write(0x0404, 0, serial);
> pl2303_vendor_read(0x8484, 0, serial, buf);
> pl2303_vendor_read(0x8383, 0, serial, buf);
> pl2303_vendor_read(0x8484, 0, serial, buf);
> pl2303_vendor_write(0x0404, 1, serial);
> pl2303_vendor_read(0x8484, 0, serial, buf);
> pl2303_vendor_read(0x8383, 0, serial, buf);
> pl2303_vendor_write(0, 1, serial);
> pl2303_vendor_write(1, 0, serial);
> if (type == HX)
> pl2303_vendor_write(2, 0x44, serial);
> else
> pl2303_vendor_write(2, 0x24, serial);
>
> kfree(buf);
> return 0;
>
> cleanup:
> kfree(buf);
> for (--i; i>=0; --i) {
> priv = usb_get_serial_port_data(serial->port[i]);
> pl2303_buf_free(priv->buf);
> kfree(priv);
> usb_set_serial_port_data(serial->port[i], NULL);
> }
> return -ENOMEM;
> }
>
> static int set_control_lines(struct usb_device *dev, u8 value)
> {
> int retval;
>
> retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
> SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE, value, 0, NULL, 0, 100);
> dbg("%s - value = %d, retval = %d", __func__, value, retval);
> return retval;
> }
>
> // struct usb_serial_port include the struct urb which has a variable named
> write_urb .....
>
> static void pl2303_send(struct usb_serial_port *port)
> {
> int count, result;
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 control;
> // int on = 1;
> dbg("%s - port %d", __func__, port->number);
>
> spin_lock_irqsave(&priv->lock, flags);
>
> if (priv->write_urb_in_use)
> {
> spin_unlock_irqrestore(&priv->lock, flags);
> return;
> }
>
> // transfer_buffer This identifies the buffer to (or from) which the I/O
> request will be performed (unless URB_NO_TRANSFER_DMA_MAP is set). This
> buffer must be suitable for DMA;
> // ALLOCATE IT WITH KMALLOC OR EQUIVALENT. For transfers to ``in''
> endpoints, contents of this buffer will be modified. This buffer is used
> for the data stage of control transfers.
> // bulk_out_size : the size of the bulk_out_buffer, in bytes
>
> count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
> port->bulk_out_size);
>
> if (count == 0)
> {
> spin_unlock_irqrestore(&priv->lock, flags);
> return;
> }
>
> priv->write_urb_in_use = 1;
>
> spin_unlock_irqrestore(&priv->lock, flags);
>
> /* spin_lock_irqsave(&priv->lock, flags);
> if (on)
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> else
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control); */
>
> usb_serial_debug_data(debug, &port->dev, __func__,
> count,port->write_urb->transfer_buffer);
>
> // port->write_urb->transfer_buffer_length = count;
> port->write_urb->transfer_buffer_length = count; // this value
> matters a lot .....
> port->write_urb->dev = port->serial->dev;
> result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
>
> // Following Code hangs the PC
> /* mdelay(10);
> spin_lock_irqsave(&priv->lock,flags);
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control); */
> if (result)
> {
> dev_err(&port->dev, "%s - failed submitting write urb,""
error
> %d\n", __func__, result);
> priv->write_urb_in_use = 0;
> // TODO: reschedule pl2303_send
> }
>
> usb_serial_port_softint(port);
>
> /* spin_lock_irqsave(&priv->lock,flags);
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control); */
> }
>
> static int pl2303_write(struct usb_serial_port *port, const unsigned char
> *buf,int count) {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 control;
> dbg("%s - port %d, %d bytes", __func__, port->number, count);
>
> if (!count)
> return count;
>
> // Following code is included so that We can enable the RTS line to
> high before data transmission
> // Tried writing a for loop here to loop the RTS line
> enable/disable , but that also didn't work...
>
> spin_lock_irqsave(&priv->lock, flags);
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control);
>
> spin_lock_irqsave(&priv->lock, flags);
> count = pl2303_buf_put(priv->buf, buf, count);
> spin_unlock_irqrestore(&priv->lock, flags);
>
> pl2303_send(port); // If I comment
> this , driver dosen't work
>
> // Following code is included so that We can disable the RTS line to
low
> after data transmission..
> // mdelay plays an Important role here....
> mdelay(5);
> spin_lock_irqsave(&priv->lock, flags);
> // priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); // this
> doesn't work here... priv->line_control = 0; // this work here.....
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev,control);
>
> return count; // count is also very IMP b'coz it affect the
> device driver's behaviour.....
> }
>
> // Write_room---> The function that indicates how much of
> the buffer is free. static int pl2303_write_room(struct usb_serial_port
> *port)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> int room = 0;
> unsigned long flags;
>
> dbg("%s - port %d", __func__, port->number);
>
> spin_lock_irqsave(&priv->lock, flags);
> room = pl2303_buf_space_avail(priv->buf);
> spin_unlock_irqrestore(&priv->lock, flags);
>
> dbg("%s - returns %d", __func__, room);
> return room;
> }
>
> // chars_in_buffer------> The function that indicates how much of the
> buffer is full of data.
> static int pl2303_chars_in_buffer(struct usb_serial_port *port)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> int chars = 0;
> unsigned long flags;
>
> dbg("%s - port %d", __func__, port->number);
>
> spin_lock_irqsave(&priv->lock, flags);
> chars = pl2303_buf_data_avail(priv->buf);
> spin_unlock_irqrestore(&priv->lock, flags);
>
> dbg("%s - returns %d", __func__, chars);
> return chars;
> }
>
> static void pl2303_set_termios(struct usb_serial_port *port,struct ktermios
> *old_termios) {
> struct usb_serial *serial = port->serial;
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> unsigned int cflag;
> unsigned char *buf;
> int baud;
> int i;
> u8 control;
>
> dbg("%s - port %d", __func__, port->number);
>
> //printk(KERN_ALERT "I M in Set Termios\n");
>
> spin_lock_irqsave(&priv->lock, flags);
> if (!priv->termios_initialized) {
> *(port->tty->termios) = tty_std_termios;
>
> /* HUPCL----> Lower modem control lines after last process closes the
> device (hang up). CLOCAL----> Ignore modem control lines.
> CLOCAL------> Ignore modem control lines.
> CREAD---------> Enable receiver. */
>
> port->tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
> CLOCAL; port->tty->termios->c_ispeed = 9600;
> port->tty->termios->c_ospeed = 9600;
> priv->termios_initialized = 1;
> }
> spin_unlock_irqrestore(&priv->lock, flags);
>
> /* The PL2303 is reported to lose bytes if you change
> serial settings even to the same values as before. Thus
> we actually need to filter in this specific case */
>
> if (!tty_termios_hw_change(port->tty->termios, old_termios))
> return;
>
> cflag = port->tty->termios->c_cflag;
>
> buf = kzalloc(7, GFP_KERNEL);
> if (!buf) {
> dev_err(&port->dev, "%s - out of memory.\n", __func__);
> /* Report back no change occurred */
> *port->tty->termios = *old_termios;
> return;
> }
>
> i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
> GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
> 0, 0, buf, 7, 100);
> dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
> buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
>
> if (cflag & CSIZE) {
> switch (cflag & CSIZE) {
> case CS5: buf[6] = 5; break;
> case CS6: buf[6] = 6; break;
> case CS7: buf[6] = 7; break;
> default:
> case CS8: buf[6] = 8; break;
> }
> dbg("%s - data bits = %d", __func__, buf[6]);
> }
>
> baud = tty_get_baud_rate(port->tty);;
> dbg("%s - baud = %d", __func__, baud);
> if (baud) {
> buf[0] = baud & 0xff;
> buf[1] = (baud >> 8) & 0xff;
> buf[2] = (baud >> 16) & 0xff;
> buf[3] = (baud >> 24) & 0xff;
> }
>
> /* For reference buf[4]=0 is 1 stop bits */
> /* For reference buf[4]=1 is 1.5 stop bits */
> /* For reference buf[4]=2 is 2 stop bits */
> if (cflag & CSTOPB) {
> buf[4] = 2;
> dbg("%s - stop bits = 2", __func__);
> } else {
> buf[4] = 0;
> dbg("%s - stop bits = 1", __func__);
> }
>
> if (cflag & PARENB) {
> /* For reference buf[5]=0 is none parity */
> /* For reference buf[5]=1 is odd parity */
> /* For reference buf[5]=2 is even parity */
> /* For reference buf[5]=3 is mark parity */
> /* For reference buf[5]=4 is space parity */
> if (cflag & PARODD) {
> buf[5] = 1;
> dbg("%s - parity = odd", __func__);
> } else {
> buf[5] = 2;
> dbg("%s - parity = even", __func__);
> }
> } else {
> buf[5] = 0;
> dbg("%s - parity = none", __func__);
> }
>
> i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
> SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
> 0, 0, buf, 7, 100);
> dbg("0x21:0x20:0:0 %d", i);
>
> /* change control lines if we are switching to or from B0 */
> spin_lock_irqsave(&priv->lock, flags);
> control = priv->line_control;
>
> /* The zero baud rate, B0, is used to terminate the connection. If B0 is
> specified, the modem control lines shall no longer be asserted. Normally,
> this will disconnect the line */
>
> if ((cflag & CBAUD) == B0)
>
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> else
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> if (control != priv->line_control) {
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(serial->dev, control);
> } else {
> spin_unlock_irqrestore(&priv->lock, flags);
> }
>
> buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
>
> i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
> GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
> 0, 0, buf, 7, 100);
> dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
> buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
>
> if (cflag & CRTSCTS) {
> if (priv->type == HX)
> pl2303_vendor_write(0x0, 0x61, serial);
> else
> pl2303_vendor_write(0x0, 0x41, serial);
> } else {
> pl2303_vendor_write(0x0, 0x0, serial);
> }
>
> /* FIXME: Need to read back resulting baud rate */
> if (baud)
> tty_encode_baud_rate(port->tty, baud, baud);
>
> kfree(buf);
> }
>
> /*************
> static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 control;
>
> spin_lock_irqsave(&priv->lock, flags);
> // Change DTR and RTS
> if (on)
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> else
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control);
> }
> *************/
> static void pl2303_close(struct usb_serial_port *port, struct file *filp)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> unsigned int c_cflag;
> int bps;
> long timeout;
> wait_queue_t wait;
>
> dbg("%s - port %d", __func__, port->number);
> // Tried to comment from here upto
> schedule_timeout_interruptible(timeout); ..but it doesn't make any
> diffrence...5/8/10
> //wait for data to drain from the buffer
> spin_lock_irqsave(&priv->lock, flags);
> timeout = PL2303_CLOSING_WAIT;
> init_waitqueue_entry(&wait, current);
> add_wait_queue(&port->tty->write_wait, &wait);
> for (;;) {
> set_current_state(TASK_INTERRUPTIBLE);
> if (pl2303_buf_data_avail(priv->buf) == 0 ||
> timeout == 0 || signal_pending(current) ||
> port->serial->disconnected)
> break;
> spin_unlock_irqrestore(&priv->lock, flags);
> timeout = schedule_timeout(timeout);
> spin_lock_irqsave(&priv->lock, flags);
> }
> set_current_state(TASK_RUNNING);
> remove_wait_queue(&port->tty->write_wait, &wait);
> // clear out any remaining data in the buffer
> pl2303_buf_clear(priv->buf);
> spin_unlock_irqrestore(&priv->lock, flags);
>
> // wait for characters to drain from the device (this is long enough for
> the entire 256 byte pl2303 hardware buffer to drain with no flow
> // control for data rates of 1200 bps or more, for lower rates we should
> really know how much data is in the buffer to compute a delay
> // that is not unnecessarily long)
> bps = tty_get_baud_rate(port->tty);
> // if bps is greater than 1200
> if (bps > 1200)
> timeout = max((HZ*2560)/bps,HZ/10);
> else
> timeout = 2*HZ;
> schedule_timeout_interruptible(timeout);
>
> /* shutdown our urbs */
> dbg("%s - shutting down urbs", __func__);
> usb_kill_urb(port->write_urb);
> usb_kill_urb(port->read_urb);
> usb_kill_urb(port->interrupt_in_urb);
>
> if (port->tty) {
> c_cflag = port->tty->termios->c_cflag;
> if (c_cflag & HUPCL) {
> /* drop DTR and RTS */
> spin_lock_irqsave(&priv->lock, flags);
> priv->line_control = 0;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, 0);
> }
> }
> }
>
> static int pl2303_open(struct usb_serial_port *port, struct file *filp)
> {
> struct ktermios tmp_termios;
> struct usb_serial *serial = port->serial;
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> int result;
> int on =1;
> // trying to implemet RTS/DTR line settings -------> Raj date
> 14.07.2010
>
> u8 control;
> unsigned long flags;
> dbg("%s - port %d", __func__, port->number);
>
> if (priv->type != HX) {
> usb_clear_halt(serial->dev, port->write_urb->pipe);
> usb_clear_halt(serial->dev, port->read_urb->pipe);
> } else {
> // reset upstream data pipes
> pl2303_vendor_write(8, 0, serial);
> pl2303_vendor_write(9, 0, serial);
> }
>
> /* Setup termios */
> if (port->tty) {
> pl2303_set_termios(port, &tmp_termios);
> }
>
> //FIXME: need to assert RTS and DTR if CRTSCTS off
> // CRTSCTS -----> Hardware flow control settings......
> // code written for RTS line setting
> // Change DTR and RTS
> // if on =1 ------------> LED glows
> // if on = 0 -------------> LED doesn't glow
> //printk(KERN_ALERT "I M just before RTS\n");
> spin_lock_irqsave(&priv->lock, flags);
> if (on)
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> else
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control);
> // printk(KERN_ALERT "I M just before RTS\n"); */
>
> /* *********************** Code written as per Shri RBS
> guidlines....... Date 26/07/2010 ************/
>
> /* spin_lock_irqsave(&priv->lock,flags);
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control);
> mdelay(50);
> spin_lock_irqsave(&priv->lock,flags);
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control); */
>
> dbg("%s - submitting read urb", __func__);
> port->read_urb->dev = serial->dev;
> result = usb_submit_urb(port->read_urb, GFP_KERNEL);
> if (result) {
> dev_err(&port->dev, "%s - failed submitting read urb,"" error
%d\n",
> __func__, result); pl2303_close(port, NULL);
> return -EPROTO;
> }
>
> dbg("%s - submitting interrupt urb", __func__);
> port->interrupt_in_urb->dev = serial->dev;
> result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
> if (result) {
> dev_err(&port->dev, "%s - failed submitting interrupt urb,""
error %d\n",
> __func__, result);
> pl2303_close(port, NULL);
> return -EPROTO;
> }
>
> // Following code snippet is able to disable RTS line......need to
> find out where 2 place this code....( Date 27/7/2010 )
> // printk(KERN_ALERT "I M just before Mdelay\n");
> /* mdelay(10);
> spin_lock_irqsave(&priv->lock,flags);
> priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control); */
> return 0;
> }
>
> static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
> unsigned int set, unsigned int clear)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 control;
>
> if (!usb_get_intfdata(port->serial->interface))
> return -ENODEV;
>
> spin_lock_irqsave(&priv->lock, flags);
>
> if (set & TIOCM_RTS)
> priv->line_control |= CONTROL_RTS; /* mcr ( priv->
line_control =
> 1 */ if (set & TIOCM_DTR)
> priv->line_control |= CONTROL_DTR; /* mcr ( priv->
line_control =
> 1 */ if (clear & TIOCM_RTS)
> priv->line_control &= ~CONTROL_RTS; /* mcr ( priv->
line_control = 0
> */ if (clear & TIOCM_DTR)
> priv->line_control &= ~CONTROL_DTR; /* mcr ( priv->
line_control = 0
> */
>
> control = priv->line_control;
>
> spin_unlock_irqrestore(&priv->lock, flags);
>
> return set_control_lines(port->serial->dev, control);
> }
>
> static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> unsigned int mcr;
> unsigned int status;
> unsigned int result;
>
> dbg("%s (%d)", __func__, port->number);
>
> if (!usb_get_intfdata(port->serial->interface))
> return -ENODEV;
>
> spin_lock_irqsave(&priv->lock, flags);
> mcr = priv->line_control; /* Modem control register
> */ status = priv->line_status; /* Modem status register
> */ spin_unlock_irqrestore(&priv->lock, flags);
>
> result = ((mcr & CONTROL_DTR)? TIOCM_DTR : 0) /* DTR is set */
>
> | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0) /* RTS is
set */
> | ((status & UART_CTS) ? TIOCM_CTS : 0) /* CTS is
set */
> | ((status & UART_DSR) ? TIOCM_DSR : 0) /* DSR is
set */
> | ((status & UART_RING) ? TIOCM_RI : 0) /*
RING INDICATOR is
> | set */ ((status & UART_DCD) ? TIOCM_CD : 0); /*
CARRIER
> | DETECT is set */
>
> dbg("%s - result = %x", __func__, result);
>
> return result;
> }
>
> /*******
> static int pl2303_carrier_raised(struct usb_serial_port *port)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> if (priv->line_status & UART_DCD)
> return 1;
> return 0;
> }
> *********/
>
> /* TIOCMIWAIT ------>Waits for MSR change. The user asks for this ioctl in
> the unusual circumstances that it wants to sleep within the kernel until
> something happens to the MSR register of
the
> tty device.
> The arg parameter contains the type of event that the user is waiting for.
> This is commonly used to wait until a status line changes, signaling that
> more data is ready to be sent to the device.
> Be careful when implementing this ioctl, and do not use the
> interruptible_sleep_on call, as it is unsafe (there are lots of nasty race
> conditions involved with it). Instead, a wait_queue should be used to
> avoid these problems. */
>
> static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> unsigned int prevstatus;
> unsigned int status;
> unsigned int changed;
>
> spin_lock_irqsave(&priv->lock, flags);
> prevstatus = priv->line_status;
> spin_unlock_irqrestore(&priv->lock, flags);
>
> while (1) {
> interruptible_sleep_on(&priv->delta_msr_wait);
> /* see if a signal did it */
> if (signal_pending(current))
> return -ERESTARTSYS;
>
> spin_lock_irqsave(&priv->lock, flags);
> status = priv->line_status;
> spin_unlock_irqrestore(&priv->lock, flags);
>
> changed=prevstatus^status;
>
> if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
> ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
> ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
> ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
> return 0;
> }
> prevstatus = status;
> }
> /* NOTREACHED */
> return 0;
> }
>
> static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
> unsigned int cmd, unsigned long arg)
> {
> dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
>
> switch (cmd) {
> case TIOCMIWAIT: /* Waits for the MSR register change */
> dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
> return wait_modem_info(port, arg);
>
> default:
> dbg("%s not supported = 0x%04x", __func__, cmd);
> break;
> }
>
> return -ENOIOCTLCMD;
> }
>
> static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
> {
> struct usb_serial *serial = port->serial;
> u16 state;
> int result;
>
> dbg("%s - port %d", __func__, port->number);
>
> if (break_state == 0)
> state = BREAK_OFF;
> else
> state = BREAK_ON;
> dbg("%s - turning break %s", __func__, state==BREAK_OFF ? "off" : "on");
>
> result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
> BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 0, NULL, 0, 100);
> if (result)
> dbg("%s - error sending break = %d", __func__, result);
> }
>
> static void pl2303_shutdown(struct usb_serial *serial)
> {
> int i;
> struct pl2303_private *priv;
>
> dbg("%s", __func__);
>
> for (i = 0; i < serial->num_ports; ++i) {
> priv = usb_get_serial_port_data(serial->port[i]);
> if (priv) {
> pl2303_buf_free(priv->buf);
> kfree(priv);
> usb_set_serial_port_data(serial->port[i], NULL);
> }
> }
> }
>
> /* Somewhere in the tty driver’s code that recognizes that the MSR
> register changes, the following line must be called for this code to work
> properly:
> wake_up_interruptible(&tp->wait); */
>
> static void pl2303_update_line_status(struct usb_serial_port *port,
> unsigned char *data, unsigned int actual_length)
> {
>
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 status_idx = UART_STATE;
> u8 length = UART_STATE + 1;
> u16 idv, idp;
>
> idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
> idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
>
> /* Save off the uart status for others to look at */
> spin_lock_irqsave(&priv->lock, flags);
> priv->line_status = data[status_idx];
> spin_unlock_irqrestore(&priv->lock, flags);
> wake_up_interruptible(&priv->delta_msr_wait);
> }
>
> /* urb Callback Function Pointers
>
> The read_int_callback, read_bulk_callback and write_bulk_callback function
> pointers are all used by the USB serial core to set up the initial
> callbacks for these kinds of USB endpoints. If the driver does not specify
> the read or write bulk callback functions, the generic callbacks are used.
> There is no generic read interrupt callback function, so if your device
> has an interrupt endpoint, you must provide this callback.
>
> The operation of the generic read bulk callback adds the data received by
> the USB urb to the port's tty buffer, to be sent to user space when read()
> is called. It then resubmits the urb to the device. If your device does
> not need to interpret the data received in any way, I recommend using this
> function instead of writing a new one. The generic bulk write callback is
> much smaller and only wakes up the tty layer (in case it was sleeping,
> waiting for data to be transmitted to the device).
> */
>
> static void pl2303_read_int_callback(struct urb *urb)
> {
> struct usb_serial_port *port = urb->context;
> unsigned char *data = urb->transfer_buffer;
> unsigned int actual_length = urb->actual_length;
> int status = urb->status;
> int retval;
>
> dbg("%s (%d)", __func__, port->number);
>
> switch (status) {
> case 0:
> /* success */
> break;
> case -ECONNRESET:
> case -ENOENT:
> case -ESHUTDOWN:
> /* this urb is terminated, clean up */
> dbg("%s - urb shutting down with status: %d", __func__,
> status);
> return;
> default:
> dbg("%s - nonzero urb status received: %d", __func__,status);
> goto exit;
> }
>
> usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
> urb->transfer_buffer);
>
> pl2303_update_line_status(port, data, actual_length); // data == 0 PC
get
> hanged.
>
> exit:
> retval = usb_submit_urb(urb, GFP_ATOMIC);
> if (retval)
> dev_err(&urb->dev->dev,"%s - usb_submit_urb failed with result
> %d\n",__func__, retval); }
>
> static void pl2303_read_bulk_callback(struct urb *urb)
> {
> struct usb_serial_port *port = urb->context;
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> struct tty_struct *tty;
> unsigned char *data = urb->transfer_buffer;
> unsigned long flags;
> int i;
> int result;
> int status = urb->status;
> u8 line_status;
> // u8 control;
> char tty_flag;
>
> dbg("%s - port %d", __func__, port->number);
>
> if (status)
> {
> dbg("%s - urb status = %d", __func__, status);
> if (!port->open_count)
> {
> dbg("%s - port is closed, exiting.", __func__);
> return;
> }
> if (status == -EPROTO)
> {
> /* PL2303 mysteriously fails with -EPROTO reschedule
the read */
> dbg("%s - caught -EPROTO, resubmitting the urb",
> __func__);
> urb->dev = port->serial->dev;
> result = usb_submit_urb(urb, GFP_ATOMIC);
> if (result)
> dev_err(&urb->dev->dev, "%s - failed" "
resubmitting read urb, error
> %d\n",__func__, result);
> return;
> }
>
> dbg("%s - unable to handle the error, exiting.",
> __func__); return;
> }
>
> usb_serial_debug_data(debug, &port->dev, __func__,urb->actual_length,
> data);
>
> /* get tty_flag from status */
> tty_flag = TTY_NORMAL;
> spin_lock_irqsave(&priv->lock, flags);
> line_status = priv->line_status;
> priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
> spin_unlock_irqrestore(&priv->lock, flags);
> wake_up_interruptible(&priv->delta_msr_wait);
>
> /* break takes precedence over parity, */
> /* which takes precedence over framing errors */
> if (line_status & UART_BREAK_ERROR )
> tty_flag = TTY_BREAK;
> else if (line_status & UART_PARITY_ERROR)
> tty_flag = TTY_PARITY;
> else if (line_status & UART_FRAME_ERROR)
> tty_flag = TTY_FRAME;
> dbg("%s - tty_flag = %d", __func__, tty_flag);
>
> tty = port->tty;
> if (tty && urb->actual_length) {
> tty_buffer_request_room(tty, urb->actual_length + 1);
> /* overrun is special, not associated with a char */
> if (line_status & UART_OVERRUN_ERROR)
> tty_insert_flip_char(tty, 0, TTY_OVERRUN);
> for (i = 0; i < urb->actual_length; ++i)
> tty_insert_flip_char(tty, data[i], tty_flag);
> tty_flip_buffer_push(tty);
> }
>
> /* Schedule the next read _if_ we are still open */
> /* if (port->open_count)
> {
> urb->dev = port->serial->dev;
> result = usb_submit_urb(urb, GFP_ATOMIC);
> if (result)
> dev_err(&urb->dev->dev, "%s - failed resubmitting"
> " read urb, error %d\n", __func__, result);
> } */
> // mdelay(5);
> return;
> }
>
> // Implementation of pl2303_write_bulk_callback merely reports if the urb
> was completed successfully or not and then returns.
>
> static void pl2303_write_bulk_callback(struct urb *urb)
> {
> struct usb_serial_port *port = urb->context;
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> int result;
> int status = urb->status;
>
> dbg("%s - port %d", __func__, port->number);
>
> switch (status)
> {
> case 0:
> /* success */
> break;
> case -ECONNRESET:
> case -ENOENT:
> case -ESHUTDOWN:
> /* this urb is terminated, clean up */
> dbg("%s - urb shutting down with status: %d",
__func__, status);
> priv->write_urb_in_use = 0;
> return;
>
> default:
> /* error in the urb, so we have to resubmit it */
> dbg("%s - Overflow in write", __func__);
> dbg("%s - nonzero write bulk status received: %d",
__func__,status);
>
> // Original is this
> /* port->write_urb->transfer_buffer_length = 1;
> port->write_urb->dev = port->serial->dev; */
>
> // I m trying date 2/08/2010
> port->write_urb->transfer_buffer_length = 1;
> port->write_urb->dev = port->serial->dev;
> result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
>
> //Below sentence Hangs the PC....We need 2 restart the PC.
> // result = usb_submit_urb(0, GFP_ATOMIC);
> if (result)
> dev_err(&urb->dev->dev, "%s - failed resubmitting
write"" urb, error
> %d\n", __func__, result);
> else
> return;
> }
>
> priv->write_urb_in_use = 0;
>
> /* send any buffered data */
> pl2303_send(port);
> }
>
> /* All of the device info needed for the PL2303 SIO serial converter */
> static struct usb_serial_driver pl2303_mcm_device = {
> .driver = {
> .owner = THIS_MODULE,
> .name = "pl2303_mcm",
> },
> .id_table = id_table,
> .usb_driver = &pl2303_mcm_driver,
> .num_ports = 1,
> .open = pl2303_open,
> .close = pl2303_close,
> .write = pl2303_write,
> .ioctl = pl2303_ioctl,
> .break_ctl = pl2303_break_ctl,
> .set_termios = pl2303_set_termios,
> .tiocmget = pl2303_tiocmget,
> .tiocmset = pl2303_tiocmset,
> .read_bulk_callback = pl2303_read_bulk_callback,
> .read_int_callback = pl2303_read_int_callback,
> .write_bulk_callback = pl2303_write_bulk_callback,
//
> tried commenting write_bulk_callback bt nothing was going out....
> .write_room = pl2303_write_room,
> .chars_in_buffer = pl2303_chars_in_buffer,
> .attach = pl2303_startup,
> .shutdown = pl2303_shutdown,
> };
>
> static int __init pl2303_init(void)
> {
> int retval;
>
> retval = usb_serial_register(&pl2303_mcm_device);
> if (retval)
> goto failed_usb_serial_register;
> retval = usb_register(&pl2303_mcm_driver);
> if (retval)
> goto failed_usb_register;
> info(DRIVER_DESC);
> return 0;
> failed_usb_register:
> usb_serial_deregister(&pl2303_mcm_device);
> failed_usb_serial_register:
> return retval;
> }
>
> static void __exit pl2303_exit(void)
> {
> usb_deregister(&pl2303_mcm_driver);
> usb_serial_deregister(&pl2303_mcm_device);
> }
>
> module_init(pl2303_init);
> module_exit(pl2303_exit);
>
> MODULE_DESCRIPTION(DRIVER_DESC);
> MODULE_LICENSE("GPL");
>
> module_param(debug, bool, S_IRUGO | S_IWUSR);
> MODULE_PARM_DESC(debug, "Debug enabled or not");
>
> kindly Help me sir.
>
> Thanks & Regards,
> Raju
> ------- End of Forwarded Message -------
>
>
> --
> Open WebMail Project (http://openwebmail.org)
On Thu, Aug 19, 2010 at 09:38:44AM +0200, Marek Vasut wrote:
> Dne ??t 19. srpna 2010 08:17:30 Raju Rameshwar Uprade napsal(a):
> > Dear Sir,
> > I am trying to write a Pl2303_mcm.c usb-serial device driver which
> > will be able to talk to several devices using RS-485 interface card.I have
> > modified the standard pl2303.c by which I am able to enable/disable the
> > RTS line.
> > I am sending 10 bytes of data to the device, data is going out but instead
> > of 10 bytes, device driver is sending a large amount of data as seen on
> > Lecroy waverunner oscilloscope. Here I am sending the modified file.
>
> Hi, I have no idea why I'm CCed in this, but anyway.
>
> 1) could you please update the driver to a more recent kernel (we are 10 kernel
> versions further now)
> 2) could you please send a diff instead of a whole file? (git diff <file1>
> <file2> > diff.diff ... see man git-diff)
Yes, Raju, please see the file, Documentation/SubmittingPatches for how
to do this properly.
Also, does your updated driver work properly for you? It would be good
to have proper RTS support in the pl2303 driver, but I thought that the
driver already supported this?
thanks,
greg k-h
Hello Greg,
No the driver is not working properly for me.I have connected RS-485
interface card to the USB-Serial adaptor through which I am controlling six MCM card(
Control & Monitor unit). When I send command to MCM 2 , command also goes to MCM 10 & 0.
When I checked on the oscilloscope, I found out that instead of going some ten bytes,
large number of bytes are going out.
Current kernel version have that RTS support, but for 2.6.25 it doesn't have.
I am having confusion that form where so many bytes are going out.
If you can help me out,I would be very thankful to you.
Thanks,
Raju.
On Thu, 19 Aug 2010 07:18:12 -0700, Greg KH wrote
> On Thu, Aug 19, 2010 at 09:38:44AM +0200, Marek Vasut wrote:
> > Dne ??t 19. srpna 2010 08:17:30 Raju Rameshwar Uprade napsal(a):
> > > Dear Sir,
> > > I am trying to write a Pl2303_mcm.c usb-serial device driver which
> > > will be able to talk to several devices using RS-485 interface card.I have
> > > modified the standard pl2303.c by which I am able to enable/disable the
> > > RTS line.
> > > I am sending 10 bytes of data to the device, data is going out but instead
> > > of 10 bytes, device driver is sending a large amount of data as seen on
> > > Lecroy waverunner oscilloscope. Here I am sending the modified file.
> >
> > Hi, I have no idea why I'm CCed in this, but anyway.
> >
> > 1) could you please update the driver to a more recent kernel (we are 10 kernel
> > versions further now)
> > 2) could you please send a diff instead of a whole file? (git diff <file1>
> > <file2> > diff.diff ... see man git-diff)
>
> Yes, Raju, please see the file, Documentation/SubmittingPatches for how
> to do this properly.
>
> Also, does your updated driver work properly for you? It would be good
> to have proper RTS support in the pl2303 driver, but I thought that the
> driver already supported this?
>
> thanks,
>
> greg k-h
--
Open WebMail Project (http://openwebmail.org)
A: No.
Q: Should I include quotations after my reply?
http://daringfireball.net/2007/07/on_top
On Fri, Aug 20, 2010 at 09:12:56AM +0530, Raju Rameshwar Uprade wrote:
> Hello Greg,
>
> No the driver is not working properly for me.I have connected RS-485
> interface card to the USB-Serial adaptor through which I am controlling six MCM card(
> Control & Monitor unit). When I send command to MCM 2 , command also goes to MCM 10 & 0.
> When I checked on the oscilloscope, I found out that instead of going some ten bytes,
> large number of bytes are going out.
Is the data going to the usb device properly? You can use usbmon to see
this.
> Current kernel version have that RTS support, but for 2.6.25 it doesn't have.
2.6.25 is many years old and not supported by any community member.
Please use something more recent like 2.6.35.
> I am having confusion that form where so many bytes are going out.
> If you can help me out,I would be very thankful to you.
I don't know the changes you made, can you please show them in diff
format?
thanks,
greg k-h
Greg,
Sorry for including quotations in my email.
Oliver,
I see the superfluous data with usbmon also.
I have changed the pl2303_write(), according to my need.I enabled the RTS line before
the data transmission and after a delay of 5ms ,disabled the RTS lines for my MCM device
to respond.
static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,int count)
> {
> struct pl2303_private *priv = usb_get_serial_port_data(port);
> unsigned long flags;
> u8 control;
> dbg("%s - port %d, %d bytes", __func__, port->number, count);
>
> if (!count)
> return count;
>
> // Following code is included so that We can enable the RTS line to high before
data transmission
> // Tried writing a for loop here to loop the RTS line enable/disable , but
that also didn't work...
>
> spin_lock_irqsave(&priv->lock, flags);
> priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev, control);
>
> spin_lock_irqsave(&priv->lock, flags);
> count = pl2303_buf_put(priv->buf, buf, count);
> spin_unlock_irqrestore(&priv->lock, flags);
>
> pl2303_send(port); // If I comment this , driver
dosen't work
>
> // Following code is included so that We can disable the RTS line to low after data
transmission..
> // mdelay plays an Important role here....
> mdelay(5);
> spin_lock_irqsave(&priv->lock, flags);
> // priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); // this doesn't work
here...
> priv->line_control = 0; // this work here.....
> control = priv->line_control;
> spin_unlock_irqrestore(&priv->lock, flags);
> set_control_lines(port->serial->dev,control);
>
> return count; // count is also very IMP b'coz it affect the device
driver's behaviour.....
> }
Thanks,
Raju
On Fri, Aug 20, 2010 at 12:26:22PM +0530, Raju Rameshwar Uprade wrote:
> Greg,
> Sorry for including quotations in my email.
No, that's not the point. Please don't top-post, that's the problem.
> Oliver,
> I see the superfluous data with usbmon also.
Then your driver is at fault :)
> I have changed the pl2303_write(), according to my need.I enabled the RTS line before
> the data transmission and after a delay of 5ms ,disabled the RTS lines for my MCM device
> to respond.
Again, please use a more modern kernel version, and then, please show
the exact diff (in 'diff -u' format) that you made.
thanks,
greg k-h