USB: serial: keyspan_pda: clean up comments and whitespace

 * driver

 */

#include <linux/kernel.h>

#include <linux/errno.h>

#include <linux/slab.h>

	dev_dbg(&port->dev, "%s\n", __func__);

	/* ask the device to tell us when the tx buffer becomes

	   sufficiently empty */

	/*

	 * Ask the device to tell us when the tx buffer becomes

	 * sufficiently empty.

	 */

	result = usb_control_msg(serial->dev,

				 usb_sndctrlpipe(serial->dev, 0),

				 7, /* request_unthrottle */

			keyspan_pda_write_start(port);

			/* queue up a wakeup at scheduler time */

			usb_serial_port_softint(port);

			break;

		default:

			__func__, retval);

}

static void keyspan_pda_rx_throttle(struct tty_struct *tty)

{

	/* stop receiving characters. We just turn off the URB request, and

	   let chars pile up in the device. If we're doing hardware

	   flowcontrol, the device will signal the other end when its buffer

	   fills up. If we're doing XON/XOFF, this would be a good time to

	   send an XOFF, although it might make sense to foist that off

	   upon the device too. */

	struct usb_serial_port *port = tty->driver_data;

	/*

	 * Stop receiving characters. We just turn off the URB request, and

	 * let chars pile up in the device. If we're doing hardware

	 * flowcontrol, the device will signal the other end when its buffer

	 * fills up. If we're doing XON/XOFF, this would be a good time to

	 * send an XOFF, although it might make sense to foist that off upon

	 * the device too.

	 */

	usb_kill_urb(port->interrupt_in_urb);

}

static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)

{

	struct usb_serial_port *port = tty->driver_data;

	/* just restart the receive interrupt URB */

	/* just restart the receive interrupt URB */

	if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))

		dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");

}

static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)

{

	int rc;

		baud = 9600;

	}

	/* rather than figure out how to sleep while waiting for this

	   to complete, I just use the "legacy" API. */

	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),

			     0, /* set baud */

			     USB_TYPE_VENDOR

			     2000); /* timeout */

	if (rc < 0)

		return 0;

	return baud;

}

static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)

{

	struct usb_serial_port *port = tty->driver_data;

		value = 1; /* start break */

	else

		value = 0; /* clear break */

	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),

			4, /* set break */

			USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,

	if (result < 0)

		dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",

			__func__, result);

	/* there is something funky about this.. the TCSBRK that 'cu' performs

	   ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4

	   seconds apart, but it feels like the break sent isn't as long as it

	   is on /dev/ttyS0 */

}

static void keyspan_pda_set_termios(struct tty_struct *tty,

		struct usb_serial_port *port, struct ktermios *old_termios)

{

	struct usb_serial *serial = port->serial;

	speed_t speed;

	/* cflag specifies lots of stuff: number of stop bits, parity, number

	   of data bits, baud. What can the device actually handle?:

	   CSTOPB (1 stop bit or 2)

	   PARENB (parity)

	   CSIZE (5bit .. 8bit)

	   There is minimal hw support for parity (a PSW bit seems to hold the

	   parity of whatever is in the accumulator). The UART either deals

	   with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,

	   1 special, stop). So, with firmware changes, we could do:

	   8N1: 10 bit

	   8N2: 11 bit, extra bit always (mark?)

	   8[EOMS]1: 11 bit, extra bit is parity

	   7[EOMS]1: 10 bit, b0/b7 is parity

	   7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)

	   HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS

	   bit.

	   For now, just do baud. */

	/*

	 * cflag specifies lots of stuff: number of stop bits, parity, number

	 * of data bits, baud. What can the device actually handle?:

	 * CSTOPB (1 stop bit or 2)

	 * PARENB (parity)

	 * CSIZE (5bit .. 8bit)

	 * There is minimal hw support for parity (a PSW bit seems to hold the

	 * parity of whatever is in the accumulator). The UART either deals

	 * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,

	 * 1 special, stop). So, with firmware changes, we could do:

	 * 8N1: 10 bit

	 * 8N2: 11 bit, extra bit always (mark?)

	 * 8[EOMS]1: 11 bit, extra bit is parity

	 * 7[EOMS]1: 10 bit, b0/b7 is parity

	 * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)

	 *

	 * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS

	 * bit.

	 *

	 * For now, just do baud.

	 */

	speed = tty_get_baud_rate(tty);

	speed = keyspan_pda_setbaud(serial, speed);

		/* It hasn't changed so.. */

		speed = tty_termios_baud_rate(old_termios);

	}

	/* Only speed can change so copy the old h/w parameters

	   then encode the new speed */

	/*

	 * Only speed can change so copy the old h/w parameters then encode

	 * the new speed.

	 */

	tty_termios_copy_hw(&tty->termios, old_termios);

	tty_encode_baud_rate(tty, speed, speed);

}

/* modem control pins: DTR and RTS are outputs and can be controlled.

   DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be

   read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */

/*

 * Modem control pins: DTR and RTS are outputs and can be controlled.

 * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be

 * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused.

 */

static int keyspan_pda_get_modem_info(struct usb_serial *serial,

				      unsigned char *value)

{

	return rc;

}

static int keyspan_pda_set_modem_info(struct usb_serial *serial,

				      unsigned char value)

{

	 * unthrottle work is scheduled).

	 */

	/* we might block because of:

	   the TX urb is in-flight (wait until it completes)

	   the device is full (wait until it says there is room)

	/*

	 * We might block because of:

	 * the TX urb is in-flight (wait until it completes)

	 * the device is full (wait until it says there is room)

	 */

	spin_lock_irqsave(&port->lock, flags);

	keyspan_pda_write_start(port);

	/* queue up a wakeup at scheduler time */

	usb_serial_port_softint(port);

}

	priv->tx_room = rc;

	spin_unlock_irq(&port->lock);

	/*Start reading from the device*/

	rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);

	if (rc) {

		dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);

		return -ENOENT;

	}

	/* after downloading firmware Renumeration will occur in a

	  moment and the new device will bind to the real driver */

	/*

	 * After downloading firmware renumeration will occur in a moment and

	 * the new device will bind to the real driver.

	 */

	/* we want this device to fail to have a driver assigned to it. */

	/* We want this device to fail to have a driver assigned to it. */

	return 1;

}