* Re: Regarding USB-Serial Device driver
[not found] ` <20100819061525.M24093@admin-gateway.ncra.tifr.res.in>
@ 2010-08-19 7:38 ` Marek Vasut
2010-08-19 14:18 ` Greg KH
0 siblings, 1 reply; 14+ messages in thread
From: Marek Vasut @ 2010-08-19 7:38 UTC (permalink / raw)
To: Raju Rameshwar Uprade
Cc: Greg KH, linux-usb, linux-kernel, maxinbjohn, orest.bond, vijaykumar
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)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-19 7:38 ` Regarding USB-Serial Device driver Marek Vasut
@ 2010-08-19 14:18 ` Greg KH
2010-08-20 3:42 ` Raju Rameshwar Uprade
0 siblings, 1 reply; 14+ messages in thread
From: Greg KH @ 2010-08-19 14:18 UTC (permalink / raw)
To: Marek Vasut
Cc: Raju Rameshwar Uprade, linux-usb, linux-kernel, maxinbjohn,
orest.bond, vijaykumar
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
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-19 14:18 ` Greg KH
@ 2010-08-20 3:42 ` Raju Rameshwar Uprade
2010-08-20 3:56 ` Greg KH
0 siblings, 1 reply; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-08-20 3:42 UTC (permalink / raw)
To: Greg KH, Marek Vasut
Cc: Raju Rameshwar Uprade, linux-usb, linux-kernel, maxinbjohn,
orest.bond, vijaykumar
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)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-20 3:42 ` Raju Rameshwar Uprade
@ 2010-08-20 3:56 ` Greg KH
2010-08-20 6:56 ` Raju Rameshwar Uprade
0 siblings, 1 reply; 14+ messages in thread
From: Greg KH @ 2010-08-20 3:56 UTC (permalink / raw)
To: Raju Rameshwar Uprade
Cc: Marek Vasut, linux-usb, linux-kernel, maxinbjohn, orest.bond, vijaykumar
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
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-20 3:56 ` Greg KH
@ 2010-08-20 6:56 ` Raju Rameshwar Uprade
2010-08-20 15:39 ` Greg KH
0 siblings, 1 reply; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-08-20 6:56 UTC (permalink / raw)
To: Greg KH, Oliver Neukum; +Cc: linux-usb, linux-kernel
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
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-20 6:56 ` Raju Rameshwar Uprade
@ 2010-08-20 15:39 ` Greg KH
[not found] ` <AANLkTin8AiOj4CST5Dr_icnY4MugG1mhgP7=c1jgcJcA@mail.gmail.com>
0 siblings, 1 reply; 14+ messages in thread
From: Greg KH @ 2010-08-20 15:39 UTC (permalink / raw)
To: Raju Rameshwar Uprade; +Cc: Oliver Neukum, linux-usb, linux-kernel
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
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
[not found] ` <AANLkTin8AiOj4CST5Dr_icnY4MugG1mhgP7=c1jgcJcA@mail.gmail.com>
@ 2010-08-31 4:05 ` Greg KH
0 siblings, 0 replies; 14+ messages in thread
From: Greg KH @ 2010-08-31 4:05 UTC (permalink / raw)
To: raj uprade; +Cc: Raju Rameshwar Uprade, Oliver Neukum, linux-usb, linux-kernel
On Thu, Aug 26, 2010 at 03:20:06PM +0530, raj uprade wrote:
> Hi Greg,
>
> >
> >
> > > Again, please use a more modern kernel version, and then, please show
> > the exact diff (in 'diff -u' format) that you made.
> >
> > Below is the diff -u of changes made in pl2303.c
>
> --- /home/teleset/Zip_file/linux-2.6.26/drivers/usb/serial/pl2303.c
> 2010-07-29 15:13:47.000000000 +0530
> +++ /home/teleset/Desktop/pl2303.c 2010-08-26 15:11:04.000000000 +0530
> @@ -469,12 +469,25 @@
> if (!count)
> return count;
>
> + 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);
>
> + mdelay(5);
> + spin_lock_irqsave(&priv->lock, flags);
> + priv->line_control = 0;
> + control = priv->line_control;
> + spin_unlock_irqrestore(&priv->lock, flags);
> + set_control_lines(port->serial->dev,control);
> +
> return count;
> }
I don't even recall what you were trying to do here, sorry. Please
include more context in your emails, we get a lot of them.
Also, what function was this change made in?
I don't think such a quick line control change is going to do what you
think it does as there are delays on the device side for sending the
data out through the uart that don't sync right up with the usb host
side here. So it might be very easy to get out of order things
happening.
You need to make sure the data is really out the port before changing
any control lines. Can't you do this properly from userspace with no
kernel changes?
thanks,
greg k-h
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-serial device driver
2010-09-08 6:17 ` Greg KH
@ 2010-09-08 8:51 ` Raju Rameshwar Uprade
0 siblings, 0 replies; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-09-08 8:51 UTC (permalink / raw)
To: Greg KH, Raju Rameshwar Uprade; +Cc: linux-kernel, linux-usb
[-- Attachment #1: Type: text/plain, Size: 2737 bytes --]
> Good.
thanks for appreciation.
> Something wrote it to the driver, did you try it with "debug=1" on the
> modprobe line to see what the driver thinks is happening?
Ya I tried with debug=1 on the modprobe line.
> > f6e80c00 4108452201 C Bo:7:003:2 0 1 >
> > f6e80900 4108453203 C Ii:7:003:1 0:1 10 = a1200000 00000200 0000
same status bytes I am also getting.
One thing I would like to ask why it is coming on Ii (Isochronous endpoint)?
> This was some status bytes coming back, are you sure you got the line
> settings correct?
>
> Your example .c file showed no line settings being set, so you have no
> idea what baud rate you are sending at, or what the flow control is, or
> anything else like that. Please be sure to set that up properly to
> verify that you really are getting the data out to the device properly.
>
Line settings,baud rate, flow control are implemented in mcmdriver.c ( UART driver)
which is attached for your ref.
I am trying to implement functionality of mcmdriver.c in pl2303.c, so that using USB
port I can communicated with various MCM devices connected via RS-485 interface card.
On oscilloscope I have verified that the data is out properly to the device.
output of usbmon :
eebcd000 2366447340 S Co:7:005:0 s 21 22 0003 0000 0000 0
eebcd000 2366449228 C Co:7:005:0 0 0
ee9e1500 2366449269 S Bo:7:005:2 -115 6 = 02110000 0100
ee9e1500 2366450226 C Bo:7:005:2 0 6 >
eebcd700 2366455282 S Co:7:005:0 s 21 22 0000 0000 0000 0
eebcd700 2366456225 C Co:7:005:0 0 0
ef7ebc80 2366456274 S Co:7:005:0 s 21 22 0003 0000 0000 0
ef7ebc80 2366457225 C Co:7:005:0 0 0
ee9e1980 2366458228 C Ii:7:005:1 0:1 10 = a1200000 00000200 1000
ee9e1980 2366458247 S Ii:7:005:1 -115:1 10 <
ee9e1500 2366458358 S Bo:7:005:2 -115 1 = 09
ee9e1500 2366459225 C Bo:7:005:2 0 1 >
eebcdb80 2366459368 S Co:7:005:0 s 21 22 0000 0000 0000 0
ee9e1980 2366460227 C Ii:7:005:1 0:1 10 = a1200000 00000200 0000
ee9e1980 2366460252 S Ii:7:005:1 -115:1 10 <
eebcdb80 2366460256 C Co:7:005:0 0 0
eebcdb80 2366460327 S Co:7:005:0 s 21 22 0003 0000 0000 0
eebcdb80 2366461226 C Co:7:005:0 0 0
ee9e1500 2366461279 S Bo:7:005:2 -115 11 = 00010000 00000000 0000e4
ee9e1500 2366462223 C Bo:7:005:2 0 11 >
eebcdb80 2366472294 S Co:7:005:0 s 21 22 0000 0000 0000 0
eebcdb80 2366474225 C Co:7:005:0 0 0
output of usbmon tell that data going out properly, but it's going in chunks,Ideally It
should go out in one chunk.I think I have to take care of RTS line. UART drivers works
in that way,RTS is enabled for complete data out ,then it is disabled so that we can get
device response.
kindly tell me how and where I can write RTS line enable and disable code in pl2303.c,
so that it can work as mcmdriver.c
Thanks,
Raj.
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: mcmdriver.c --]
[-- Type: text/x-csrc; name="mcmdriver.c", Size: 10674 bytes --]
/*************************************************************************
* mcmdriver.c
* Linux kernel module, Serial port driver for MCM communications :
* through RS485 with 9 bit protocol
* requires RS232 / RS485 converter, associated Makefile
*
* under root in a console out of X:
* to install:
* make
* insmod mcmdriver.ko SerialPortNb=1 (or 2)
* mknod /dev/mcmdriver c ... (nbs answered from previous command)
* to uninstall: rmmod mcmdriver , rm -f /dev/mcmdriver
* to check: lsmod
* to test: ./mcmtest.o (compiled from mcmtest.c program)
*
* 20/09/05: modif write9(), no more trans MCM error.
* 01/03/06: modif for Kernel 2.6
* 16/09/2008: modif for FC9 (kernel version 2.6.25.11),it's not working fully but now I m able to get data from the device, there is some bytes lose,have to go thru the code & do the things...
* 23/09/2008: Now the device driver is working fine.I used twisted pair cable instead of single line wire,twisted pair cable reduced the noise level.
**************************************************************************/
//#define __KERNEL__ needed?
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/wait.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
//#include <linux/tqueue.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/serial.h> //for BASE_BAUD
#include <linux/serial_reg.h> //for UART reg
#include <asm/io.h> // or sys/io.h for outb inb
//#include <unistd.h>
MODULE_LICENSE("Dual BSD/GPL");
uint inportb(int port);
void outportb(int port, char value);
void setbit(int port, char bits);
void clrbit(int port, char bits);
char cksum(char *buff);
void ckbaud(void);
void init_baud(unsigned long baud);
static int write9(const char *buff_wr);
irqreturn_t irq_handler(int irq, void *dev_id);
void hw_init(void);
/******************************************************************
* serial write and read functions with MCM
* reading via interruption
******************************************************************/
static char buf_ptr0[200];
static int siz; //must be char for device_read() return value
static int SerialPortNb=0, SerialPortAddr, IRQNb;
DECLARE_WAIT_QUEUE_HEAD(WaitQ);
module_param(SerialPortNb, int, S_IRUGO);
#define UART_IER_DISABLE 0x00 /*disable interrupts, is missing from serial-reg.h*/
#define UART_FCR_DISABLE_FIFO 0x00 /*disable fifo*/
#define UART_FIFO_SETUP (UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT | UART_FCR_TRIGGER_1)
#define LCR_ADDR (UART_LCR_WLEN8 | UART_LCR_PARITY | UART_LCR_SPAR)
#define LCR_DATA (UART_LCR_WLEN8 | UART_LCR_PARITY | UART_LCR_SPAR | UART_LCR_EPAR)
/*------------ Macros -----------------------------------------------*/
uint inportb(int port) {return (uint)(inb(SerialPortAddr + port));}
void outportb(int port, char value) {outb(value, SerialPortAddr + port);}
void setbit(int port, char bits) {outportb(port, (inportb(port) | bits));}
void clrbit(int port, char bits) {outportb(port, inportb(port) & ~bits);}
/*---------- CheckSum function----------------------------------------*/
/*char cksum(char *buff)
{
char length, i, cs = 0;
if (siz < 3) return 1;
length = *(buff) + (*(buff+1)<<8);
for(i=0; i<length; i++)
{cs += *(buff+i);}
// printk(KERN_ALERT "cs %d\n", cs);
return cs;
}*/
/*---------- Baud init function--------------------------------------*/
void init_baud(unsigned long baud)
{
unsigned long divisor;
divisor = BASE_BAUD / baud;
printk(KERN_ALERT " I m in BAUD Init function\n");
printk(KERN_ALERT "divisor = %ld\n",divisor);
setbit(UART_LCR,UART_LCR_DLAB);
outportb(UART_DLL,(divisor & 0xff));
outportb(UART_DLM,((divisor >> 8) & 0xff));
clrbit(UART_LCR,UART_LCR_DLAB);
};
/*------------ write function----------------------------------------*/
int write9(const char *buff_wr)
{
int length, i;
// printk(KERN_ALERT "I M IN WRITE9");
length = *(buff_wr+1) + ((*(buff_wr+2))<<8);
setbit(UART_MCR, UART_MCR_RTS); // tx_on
//while (!(inportb(UART_MCR) & UART_MCR_RTS)) {;}
outportb(UART_LCR,LCR_ADDR); // addr parity
//while (!(inportb(UART_LCR) & LCR_ADDR)) {;}
while (!(inportb(UART_LSR) & UART_LSR_THRE)) {;}
outportb(UART_TX, *buff_wr);
while (!(inportb(UART_LSR) & UART_LSR_TEMT)) {;}
outportb(UART_LCR, LCR_DATA); // data parity
//while (!(inportb(UART_LCR) & LCR_DATA)) {;}
for (i=1; i<(length+1); i++) {
while (!(inportb(UART_LSR) & UART_LSR_THRE)) {;}
outportb(UART_TX, *(buff_wr+i));
}
while (!(inportb(UART_LSR) & UART_LSR_TEMT)) {;}
clrbit(UART_MCR, UART_MCR_RTS); // tx_off
//while ((inportb(UART_MCR) & UART_MCR_RTS)) {;}
siz = 0;
/* printk(KERN_ALERT "\nier %.2x\n", inportb(UART_IER));
printk(KERN_ALERT "iir %.2x\n", inportb(UART_IIR));
printk(KERN_ALERT "fcr %.2x\n", inportb(UART_FCR)); */
return 1;
}
/*------------ IRQ handler function-----------------------------------*/
irqreturn_t irq_handler(int irq, void *dev_id)
{
volatile int lsr=0, packsiz=0;
printk(KERN_ALERT "IRQ detected\n");
while(inportb(UART_IIR) & 0x04) {
lsr = inportb(UART_LSR);
if (lsr & 0x02)
{
buf_ptr0[siz] = inportb(UART_RX);
printk(KERN_ALERT "%x ", buf_ptr0[siz]);
} //Overrun
else if (lsr & 0x08)
{
buf_ptr0[siz] = inportb(UART_RX);
printk(KERN_ALERT "Framming Error \n");
printk(KERN_ALERT "%x ", buf_ptr0[siz]);
} //Framing Error
else {
buf_ptr0[siz] = inportb(UART_RX);siz++;
printk(KERN_ALERT "%x ", buf_ptr0[siz-1]);
}
}
if (siz>3) {
packsiz = (*(buf_ptr0+1)+(*(buf_ptr0+2)<<8)+1);
if (siz > 200) {printk(KERN_ALERT "siz error, packet reset\n"); siz = 0;}
else if (siz == packsiz)
wake_up_interruptible(&WaitQ);
}
return IRQ_HANDLED;
}
/*----------- hardware initialisation----------------------------------*/
void hw_init(void)
{
printk(KERN_ALERT "I m in Hw-Init");
outportb(UART_MCR, 0x00);
outportb(UART_IER, UART_IER_DISABLE);
outportb(UART_FCR, UART_FCR_DISABLE_FIFO);
outportb(UART_FCR, UART_FIFO_SETUP);
printk(KERN_ALERT "fcrsetup %.2x\n", UART_FIFO_SETUP);
printk(KERN_ALERT "fcr %.2x\n", inportb(UART_FCR));
outportb(UART_LCR, 0x00);
setbit(UART_MCR, UART_MCR_OUT2 | UART_MCR_RTS); //interrupt enabled
setbit(UART_IER, UART_IER_RDI | UART_IER_THRI| UART_IER_MSI ); // interrupt rx on
// while (!(inportb(UART_IER) & UART_IER_RDI)) {;}
while ((inportb(UART_IIR) & 0x01)==0) {
inportb(UART_LSR);
inportb(UART_MSR);
inportb(UART_RX);
}
init_baud(9600);
}
/******************************************************************
* Module functions for /dev/char driver
* redefines open, write, read and close (release)
******************************************************************/
static dev_t DevNb;
static struct cdev *CharDev; // struct for the internal representation of char devices in the kernel.
static int device_release(struct inode *inode, struct file *file)
{
//release_region(SerialPortNb, 1);
free_irq(IRQNb, NULL);
//MOD_DEC_USE_COUNT;
return 0;
}
static int device_open(struct inode *inode, struct file *file)
{
//if (request_region(SerialPortNb, 1, "mcmdriver") == NULL)
//{printk(KERN_ALERT "Requesting Port failed\n"); return -1;}
// if(request_irq(IRQNb, irq_handler, SA_INTERRUPT, "serial9", NULL))
// {printk(KERN_ALERT "irq request error\n"); return -1;}
printk(KERN_ALERT " I m in device_open function");
if(request_irq(IRQNb, irq_handler, IRQF_DISABLED, "serial9", NULL))
printk(KERN_ALERT " I m in device_open function");
// if(request_irq(IRQNb, irq_handler,IRQF_SHARED , "serial9", NULL))
hw_init();
//MOD_INC_USE_COUNT;
siz = 0;
return 0;
}
static ssize_t device_write(struct file *filp, const char __user *buffer, size_t length, loff_t *offset)
{
write9(buffer);
return 1;
}
/*blocking read with timeout*/
static ssize_t device_read(struct file *filp, char __user *buffer, size_t length, loff_t *offset)
{
int err;//, i;
if (siz < 3)
wait_event_interruptible_timeout(WaitQ, 0,150); // &WaitQ or WaitQ?, 1 or 0?
// wait_event_interruptible(WaitQ,0);
//for (i=0;i<siz;i++) printk(KERN_ALERT "%x ", (unsigned char)buf_ptr0[i]);
//printk(KERN_ALERT "\n");
/*if (cksum(buf_ptr0+1) && (siz > 3)) siz = -1;
else
err = */ copy_to_user(buffer, buf_ptr0, siz);
mdelay(50);
/* Hardware limitation: the driver cannot write 2 times successively in a too short period.
Delay necessary for rewriting just after, optimized for a write & read loop (just 1 printk),
with Set Anl Mask Cmd (the longest) and in a console outside X.
Delay placed here, CS/siz problems if placed before writing ?*/
return siz;
}
static struct file_operations fops = {
.owner = THIS_MODULE,
.open = device_open,
.release = device_release,
.read = device_read,
.write = device_write,
};
static int __init device_init(void)
{
int err;
err = alloc_chrdev_region(&DevNb, 0, 1, "mcmdriver");
if (err < 0)
{printk(KERN_ALERT "Allocating DevNb failed with %d\n", err); return err;}
CharDev = cdev_alloc();
cdev_init(CharDev, &fops);
CharDev->owner = THIS_MODULE;
CharDev->ops = &fops;
err = cdev_add(CharDev, DevNb, 1);
if (err)
{printk(KERN_ALERT "Registering CharDev failed with %d\n", err); return err;}
if (SerialPortNb == 1)
{SerialPortAddr = 0x3f8; IRQNb = 4;}
/* if (SerialPortNb == 1 )
{SerialPortAddr = 0xfe00; IRQNb = 16;} */
/** Changes did for USB to Serial for MCM communication, but lock the computer.......*****/
/**** if (SerialPortNb == 0)
{SerialPortAddr = 0x000; IRQNb = 0;} ***/
else if (SerialPortNb == 2)
{SerialPortAddr = 0x2f8; IRQNb = 3;}
printk(KERN_ALERT "Serial Port %d selected (address %x)\n", SerialPortNb, SerialPortAddr);
printk(KERN_ALERT "Create dev file with 'mknod /dev/mcmdriver c %d %d'.\n", MAJOR(DevNb), MINOR(DevNb));
return 0;
}
static void __exit device_exit(void)
{
cdev_del(CharDev);
unregister_chrdev_region(DevNb, 1);
}
module_init(device_init);
module_exit(device_exit);
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-serial device driver
2010-09-08 3:41 ` Raju Rameshwar Uprade
@ 2010-09-08 6:17 ` Greg KH
2010-09-08 8:51 ` Raju Rameshwar Uprade
0 siblings, 1 reply; 14+ messages in thread
From: Greg KH @ 2010-09-08 6:17 UTC (permalink / raw)
To: Raju Rameshwar Uprade; +Cc: linux-usb, linux-kernel
On Wed, Sep 08, 2010 at 09:11:19AM +0530, Raju Rameshwar Uprade wrote:
> Greg,
> I am really sorry, that superfluous data was due to user space program.I have
> modified that.Now I am able to send correct data to the device. 5e and 40 is also going
> out.I don't know from where it is coming.
> But I am not getting the response.
>
> output of usbmon :
>
> ee9e1680 4108443204 C Co:7:003:0 0 0
> f6e80c00 4108443237 S Bo:7:003:2 -115 9 = 05080000 00000000 f8 // correct data bytes
Good.
> f6e80c00 4108444202 C Bo:7:003:2 0 9 >
> ee9e1680 4108448251 S Co:7:003:0 s 21 22 0000 0000 0000 0
> ee9e1680 4108449202 C Co:7:003:0 0 0
> f6e80700 4108450204 C Bi:7:003:3 0 1 = 00
> ee9e1680 4108450546 S Co:7:003:0 s 21 22 0003 0000 0000 0
> f6e80900 4108451204 C Ii:7:003:1 0:1 10 = a1200000 00000200 0400
> f6e80900 4108451223 S Ii:7:003:1 -115:1 10 <
> ee9e1680 4108451227 C Co:7:003:0 0 0
> f6e80c00 4108451252 S Bo:7:003:2 -115 1 = 5e // don't know from where it is going out
Something wrote it to the driver, did you try it with "debug=1" on the
modprobe line to see what the driver thinks is happening?
> f6e80c00 4108452201 C Bo:7:003:2 0 1 >
> f6e80900 4108453203 C Ii:7:003:1 0:1 10 = a1200000 00000200 0000
This was some status bytes coming back, are you sure you got the line
settings correct?
Your example .c file showed no line settings being set, so you have no
idea what baud rate you are sending at, or what the flow control is, or
anything else like that. Please be sure to set that up properly to
verify that you really are getting the data out to the device properly.
thanks,
greg k-h
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-serial device driver
[not found] ` <20100907114913.M69542@admin-gateway.ncra.tifr.res.in>
@ 2010-09-08 3:41 ` Raju Rameshwar Uprade
2010-09-08 6:17 ` Greg KH
0 siblings, 1 reply; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-09-08 3:41 UTC (permalink / raw)
To: Greg KH; +Cc: linux-usb, linux-kernel
> Wierd. If you enable debugging in the driver:
> modprobe pl2303 debug=1
> do you also see the kernel log showing extra data going out to the host?
>
> What is your userspace program doing? Are you sure you are only writing
> 6 bytes? The bulk out should only be writing the actual data in the
> buffer, not any more than that.
>
> Do you have an example userspace code that we can use to test with?
>
> thanks,
>
> greg k-h
Greg,
I am really sorry, that superfluous data was due to user space program.I have
modified that.Now I am able to send correct data to the device. 5e and 40 is also going
out.I don't know from where it is coming.
But I am not getting the response.
output of usbmon :
ee9e1680 4108443204 C Co:7:003:0 0 0
f6e80c00 4108443237 S Bo:7:003:2 -115 9 = 05080000 00000000 f8 // correct data bytes
f6e80c00 4108444202 C Bo:7:003:2 0 9 >
ee9e1680 4108448251 S Co:7:003:0 s 21 22 0000 0000 0000 0
ee9e1680 4108449202 C Co:7:003:0 0 0
f6e80700 4108450204 C Bi:7:003:3 0 1 = 00
ee9e1680 4108450546 S Co:7:003:0 s 21 22 0003 0000 0000 0
f6e80900 4108451204 C Ii:7:003:1 0:1 10 = a1200000 00000200 0400
f6e80900 4108451223 S Ii:7:003:1 -115:1 10 <
ee9e1680 4108451227 C Co:7:003:0 0 0
f6e80c00 4108451252 S Bo:7:003:2 -115 1 = 5e // don't know from where it is going out
f6e80c00 4108452201 C Bo:7:003:2 0 1 >
f6e80900 4108453203 C Ii:7:003:1 0:1 10 = a1200000 00000200 0000
f6e80900 4108453221 S Ii:7:003:1 -115:1 10 <
ee9e1680 4108456262 S Co:7:003:0 s 21 22 0000 0000 0000 0
ee9e1680 4108457202 C Co:7:003:0 0 0
ee9e1680 4108457225 S Co:7:003:0 s 21 22 0003 0000 0000 0
ee9e1680 4108458201 C Co:7:003:0 0 0
f6e80c00 4108458228 S Bo:7:003:2 -115 1 = 40 // don't know from where it is going out
f6e80c00 4108459201 C Bo:7:003:2 0 1 >
ee9e1680 4108463235 S Co:7:003:0 s 21 22 0000 0000 0000 0
ee9e1680 4108464204 C Co:7:003:0 0 0
Regards,
Raj.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-serial device driver
2010-09-07 6:14 Regarding USB-serial device driver Raju Rameshwar Uprade
@ 2010-09-07 6:59 ` Greg KH
[not found] ` <20100907114913.M69542@admin-gateway.ncra.tifr.res.in>
0 siblings, 1 reply; 14+ messages in thread
From: Greg KH @ 2010-09-07 6:59 UTC (permalink / raw)
To: Raju Rameshwar Uprade; +Cc: linux-usb, linux-kernel
On Tue, Sep 07, 2010 at 11:44:50AM +0530, Raju Rameshwar Uprade wrote:
>
> Hi Greg,
> I have a UART device driver which is used to control some MCM ( Monitor
> & control module ) devices with address like 2,3,5,10,14 & 0 thru serial port using
> RS-485 interface card.
>
> Now I want to control these devices thru usb-serial adaptor card.When I plug the
> usb-to-serial device.It's shows me the terminal ttyUSB0.
>
> I tried sending data thru it , but in between some junk data is also going out ....
>
> output of usbmon :
>
> ee26be80 3612838323 S Co:7:002:0 s 40 01 0008 0000 0000 0
> ee26be80 3612839660 C Co:7:002:0 0 0
> ee26be80 3612839716 S Co:7:002:0 s 40 01 0009 0000 0000 0
> ee26be80 3612840660 C Co:7:002:0 0 0
> ee26be80 3612840700 S Ci:7:002:0 s a1 21 0000 0000 0007 7 <
> ee26be80 3612841661 C Ci:7:002:0 0 7 = 80250000 000008
> ee26be80 3612841710 S Co:7:002:0 s 21 20 0000 0000 0007 7 = 80250000 000008
> ee26be80 3612842659 C Co:7:002:0 0 7 >
> ee26be80 3612842672 S Co:7:002:0 s 21 22 0003 0000 0000 0
> ee26be80 3612843657 C Co:7:002:0 0 0
> ee2b3800 3612843712 S Ci:7:002:0 s a1 21 0000 0000 0007 7 <
> ee2b3800 3612844658 C Ci:7:002:0 0 7 = 80250000 000008
> ee2b3800 3612844668 S Co:7:002:0 s 40 01 0000 0000 0000 0
> ee2b3800 3612845660 C Co:7:002:0 0 0
> ee0eaf80 3612845669 S Bi:7:002:3 -115 256 <
> ee0ead00 3612845674 S Ii:7:002:1 -115:1 10 <
> ee2b3800 3612845679 S Co:7:002:0 s 21 22 0003 0000 0000 0
> ee2b3800 3612846657 C Co:7:002:0 0 0
> ee0ea680 3618022849 S Bo:7:002:2 -115 100 = 00080000 00000000 f8000000 00000000 00000000
> 00000000 00000000 00000000
> ee0ea680 3618024532 C Bo:7:002:2 0 100 >
>
>
> Ideally data which should go out is : 0080000000f8.( device address is 0 and check sum
> is f8 ).
Wierd. If you enable debugging in the driver:
modprobe pl2303 debug=1
do you also see the kernel log showing extra data going out to the host?
What is your userspace program doing? Are you sure you are only writing
6 bytes? The bulk out should only be writing the actual data in the
buffer, not any more than that.
Do you have an example userspace code that we can use to test with?
thanks,
greg k-h
^ permalink raw reply [flat|nested] 14+ messages in thread
* Regarding USB-serial device driver
@ 2010-09-07 6:14 Raju Rameshwar Uprade
2010-09-07 6:59 ` Greg KH
0 siblings, 1 reply; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-09-07 6:14 UTC (permalink / raw)
To: Greg KH; +Cc: linux-usb, linux-kernel
Hi Greg,
I have a UART device driver which is used to control some MCM ( Monitor
& control module ) devices with address like 2,3,5,10,14 & 0 thru serial port using
RS-485 interface card.
Now I want to control these devices thru usb-serial adaptor card.When I plug the
usb-to-serial device.It's shows me the terminal ttyUSB0.
I tried sending data thru it , but in between some junk data is also going out ....
output of usbmon :
ee26be80 3612838323 S Co:7:002:0 s 40 01 0008 0000 0000 0
ee26be80 3612839660 C Co:7:002:0 0 0
ee26be80 3612839716 S Co:7:002:0 s 40 01 0009 0000 0000 0
ee26be80 3612840660 C Co:7:002:0 0 0
ee26be80 3612840700 S Ci:7:002:0 s a1 21 0000 0000 0007 7 <
ee26be80 3612841661 C Ci:7:002:0 0 7 = 80250000 000008
ee26be80 3612841710 S Co:7:002:0 s 21 20 0000 0000 0007 7 = 80250000 000008
ee26be80 3612842659 C Co:7:002:0 0 7 >
ee26be80 3612842672 S Co:7:002:0 s 21 22 0003 0000 0000 0
ee26be80 3612843657 C Co:7:002:0 0 0
ee2b3800 3612843712 S Ci:7:002:0 s a1 21 0000 0000 0007 7 <
ee2b3800 3612844658 C Ci:7:002:0 0 7 = 80250000 000008
ee2b3800 3612844668 S Co:7:002:0 s 40 01 0000 0000 0000 0
ee2b3800 3612845660 C Co:7:002:0 0 0
ee0eaf80 3612845669 S Bi:7:002:3 -115 256 <
ee0ead00 3612845674 S Ii:7:002:1 -115:1 10 <
ee2b3800 3612845679 S Co:7:002:0 s 21 22 0003 0000 0000 0
ee2b3800 3612846657 C Co:7:002:0 0 0
ee0ea680 3618022849 S Bo:7:002:2 -115 100 = 00080000 00000000 f8000000 00000000 00000000
00000000 00000000 00000000
ee0ea680 3618024532 C Bo:7:002:2 0 100 >
Ideally data which should go out is : 0080000000f8.( device address is 0 and check sum
is f8 ).
In my previous emails, you told me to use current kernel version..so I am now using
2.6.35 kernel version.
kindly help me.
Thanks-
Raj.
--
Open WebMail Project (http://openwebmail.org)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: Regarding USB-Serial Device driver
2010-08-19 6:28 Regarding USB-Serial Device driver Raju Rameshwar Uprade
@ 2010-08-19 13:09 ` Oliver Neukum
0 siblings, 0 replies; 14+ messages in thread
From: Oliver Neukum @ 2010-08-19 13:09 UTC (permalink / raw)
To: Raju Rameshwar Uprade; +Cc: LKML, linux-usb
Am Donnerstag, 19. August 2010, 08:28:57 schrieb Raju Rameshwar Uprade:
> Dear All,
> 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.
Could you please send this as a unified diff?
And take the USB list into cc? Do you see this superfluous
data also with usbmon?
Regards
Oliver
^ permalink raw reply [flat|nested] 14+ messages in thread
* Regarding USB-Serial Device driver
@ 2010-08-19 6:28 Raju Rameshwar Uprade
2010-08-19 13:09 ` Oliver Neukum
0 siblings, 1 reply; 14+ messages in thread
From: Raju Rameshwar Uprade @ 2010-08-19 6:28 UTC (permalink / raw)
To: LKML
[-- Attachment #1: Type: TEXT/PLAIN, Size: 43857 bytes --]
Dear All,
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.
/* 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
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2010-09-08 8:51 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <20100819055329.M29689@admin-gateway.ncra.tifr.res.in>
[not found] ` <20100819061525.M24093@admin-gateway.ncra.tifr.res.in>
2010-08-19 7:38 ` Regarding USB-Serial Device driver Marek Vasut
2010-08-19 14:18 ` Greg KH
2010-08-20 3:42 ` Raju Rameshwar Uprade
2010-08-20 3:56 ` Greg KH
2010-08-20 6:56 ` Raju Rameshwar Uprade
2010-08-20 15:39 ` Greg KH
[not found] ` <AANLkTin8AiOj4CST5Dr_icnY4MugG1mhgP7=c1jgcJcA@mail.gmail.com>
2010-08-31 4:05 ` Greg KH
2010-09-07 6:14 Regarding USB-serial device driver Raju Rameshwar Uprade
2010-09-07 6:59 ` Greg KH
[not found] ` <20100907114913.M69542@admin-gateway.ncra.tifr.res.in>
2010-09-08 3:41 ` Raju Rameshwar Uprade
2010-09-08 6:17 ` Greg KH
2010-09-08 8:51 ` Raju Rameshwar Uprade
-- strict thread matches above, loose matches on Subject: below --
2010-08-19 6:28 Regarding USB-Serial Device driver Raju Rameshwar Uprade
2010-08-19 13:09 ` Oliver Neukum
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.