Attachment #151236 for bug #219152

Lines 290-296 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here

(-)a/drivers/usb/serial/cypress_m8.c (-15 / +22 lines)
290	{	290	{
291	int new_baudrate = 0, retval = 0, tries = 0;	291	int new_baudrate = 0, retval = 0, tries = 0;
292	struct cypress_private *priv;	292	struct cypress_private *priv;
293	__u8 feature_buffer[8];	293	__u8 feature_buffer[5];
294	unsigned long flags;	294	unsigned long flags;
295		295
296	dbg("%s", __FUNCTION__);	296	dbg("%s", __FUNCTION__);
Lines 353-359 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here
353	}	353	}
354	dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);	354	dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);
355		355
356	memset(feature_buffer, 0, 8);	356	memset(feature_buffer, 0, sizeof(feature_buffer));
357	/* fill the feature_buffer with new configuration */	357	/* fill the feature_buffer with new configuration */
358	((u_int32_t )feature_buffer) = new_baudrate;	358	((u_int32_t )feature_buffer) = new_baudrate;
359		359
Lines 370-385 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here
370	feature_buffer[2], feature_buffer[3], feature_buffer[4]);	370	feature_buffer[2], feature_buffer[3], feature_buffer[4]);
371		371
372	do {	372	do {
373	retval = usb_control_msg (port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),	373	retval = usb_control_msg(port->serial->dev,
374	HID_REQ_SET_REPORT, USB_DIR_OUT \| USB_RECIP_INTERFACE \| USB_TYPE_CLASS,	374	usb_sndctrlpipe(port->serial->dev, 0),
375	0x0300, 0, feature_buffer, 8, 500);	375	HID_REQ_SET_REPORT,
		376	USB_DIR_OUT \| USB_RECIP_INTERFACE \| USB_TYPE_CLASS,
		377	0x0300, 0, feature_buffer,
		378	sizeof(feature_buffer), 500);
376		379
377	if (tries++ >= 3)	380	if (tries++ >= 3)
378	break;	381	break;
379		382
380	} while (retval != 8 && retval != -ENODEV);	383	} while (retval != sizeof(feature_buffer) &&
		384	retval != -ENODEV);
381		385
382	if (retval != 8) {	386	if (retval != sizeof(feature_buffer)) {
383	err("%s - failed sending serial line settings - %d", __FUNCTION__, retval);	387	err("%s - failed sending serial line settings - %d", __FUNCTION__, retval);
384	cypress_set_dead(port);	388	cypress_set_dead(port);
385	} else {	389	} else {
Lines 393-411 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here
393	case CYPRESS_GET_CONFIG:	397	case CYPRESS_GET_CONFIG:
394	dbg("%s - retreiving serial line settings", __FUNCTION__);	398	dbg("%s - retreiving serial line settings", __FUNCTION__);
395	/* set initial values in feature buffer */	399	/* set initial values in feature buffer */
396	memset(feature_buffer, 0, 8);	400	memset(feature_buffer, 0, sizeof(feature_buffer));
397		401
398	do {	402	do {
399	retval = usb_control_msg (port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),	403	retval = usb_control_msg(port->serial->dev,
400	HID_REQ_GET_REPORT, USB_DIR_IN \| USB_RECIP_INTERFACE \| USB_TYPE_CLASS,	404	usb_rcvctrlpipe(port->serial->dev, 0),
401	0x0300, 0, feature_buffer, 8, 500);	405	HID_REQ_GET_REPORT,
402		406	USB_DIR_IN \| USB_RECIP_INTERFACE \| USB_TYPE_CLASS,
		407	0x0300, 0, feature_buffer,
		408	sizeof(feature_buffer), 500);
		409
403	if (tries++ >= 3)	410	if (tries++ >= 3)
404	break;	411	break;
405		412
406	} while (retval != 5 && retval != -ENODEV);	413	} while (retval != sizeof(feature_buffer) &&
		414	retval != -ENODEV);
407		415
408	if (retval != 5) {	416	if (retval != sizeof(feature_buffer)) {
409	err("%s - failed to retrieve serial line settings - %d", __FUNCTION__, retval);	417	err("%s - failed to retrieve serial line settings - %d", __FUNCTION__, retval);
410	cypress_set_dead(port);	418	cypress_set_dead(port);
411	return retval;	419	return retval;
412	--

Lines 122-127 static struct usb_driver cypress_driver = { Link Here

(-)a/drivers/usb/serial/cypress_m8.c (-46 / +66 lines)
122	.no_dynamic_id = 1,	122	.no_dynamic_id = 1,
123	};	123	};
124		124
		125	enum packet_format {
		126	packet_format_1, /* b0:status, b1:payload count */
		127	packet_format_2 /* b0[7:3]:status, b0[2:0]:payload count */
		128	};
		129
125	struct cypress_private {	130	struct cypress_private {
126	spinlock_t lock; /* private lock */	131	spinlock_t lock; /* private lock */
127	int chiptype; /* identifier of device, for quirks/etc */	132	int chiptype; /* identifier of device, for quirks/etc */
Lines 139-144 struct cypress_private { Link Here
139	__u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */	144	__u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */
140	__u8 current_config; /* stores the current configuration byte */	145	__u8 current_config; /* stores the current configuration byte */
141	__u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */	146	__u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */
		147	enum packet_format pkt_fmt; /* format to use for packet send / receive */
142	int baud_rate; /* stores current baud rate in integer form */	148	int baud_rate; /* stores current baud rate in integer form */
143	int cbr_mask; /* stores current baud rate in masked form */	149	int cbr_mask; /* stores current baud rate in masked form */
144	int isthrottled; /* if throttled, discard reads */	150	int isthrottled; /* if throttled, discard reads */
Lines 532-537 static int generic_startup (struct usb_serial *serial) Link Here
532	priv->termios_initialized = 0;	538	priv->termios_initialized = 0;
533	priv->rx_flags = 0;	539	priv->rx_flags = 0;
534	priv->cbr_mask = B300;	540	priv->cbr_mask = B300;
		541	/* Default packet format setting is determined by packet size.
		542	Anything with a size larger then 9 must have a separate
		543	count field since the 3 bit count field is otherwise too
		544	small. Otherwise we can use the slightly more compact
		545	format. This is in accordance with the cypress_m8 serial
		546	converter app note. */
		547	if (port->interrupt_out_size > 9) {
		548	priv->pkt_fmt = packet_format_1;
		549	} else {
		550	priv->pkt_fmt = packet_format_2;
		551	}
535	if (interval > 0) {	552	if (interval > 0) {
536	priv->write_urb_interval = interval;	553	priv->write_urb_interval = interval;
537	priv->read_urb_interval = interval;	554	priv->read_urb_interval = interval;
Lines 564-569 static int cypress_earthmate_startup (struct usb_serial *serial) Link Here
564		581
565	priv = usb_get_serial_port_data(serial->port[0]);	582	priv = usb_get_serial_port_data(serial->port[0]);
566	priv->chiptype = CT_EARTHMATE;	583	priv->chiptype = CT_EARTHMATE;
		584	/* All Earthmate devices use the separated-count packet
		585	format! Idiotic. */
		586	priv->pkt_fmt = packet_format_1;
567		587
568	return 0;	588	return 0;
569	} /* cypress_earthmate_startup */	589	} /* cypress_earthmate_startup */
Lines 811-831 static void cypress_send(struct usb_serial_port *port) Link Here
811	memset(port->interrupt_out_urb->transfer_buffer, 0, port->interrupt_out_size);	831	memset(port->interrupt_out_urb->transfer_buffer, 0, port->interrupt_out_size);
812		832
813	spin_lock_irqsave(&priv->lock, flags);	833	spin_lock_irqsave(&priv->lock, flags);
814	switch (port->interrupt_out_size) {	834	switch (priv->pkt_fmt) {
815	case 32:	835	default:
816	/* this is for the CY7C64013... */	836	case packet_format_1:
817	offset = 2;	837	/* this is for the CY7C64013... */
818	port->interrupt_out_buffer[0] = priv->line_control;	838	offset = 2;
819	break;	839	port->interrupt_out_buffer[0] = priv->line_control;
820	case 8:	840	break;
821	/* this is for the CY7C63743... */	841	case packet_format_2:
822	offset = 1;	842	/* this is for the CY7C63743... */
823	port->interrupt_out_buffer[0] = priv->line_control;	843	offset = 1;
824	break;	844	port->interrupt_out_buffer[0] = priv->line_control;
825	default:	845	break;
826	dbg("%s - wrong packet size", __FUNCTION__);
827	spin_unlock_irqrestore(&priv->lock, flags);
828	return;
829	}	846	}
830		847
831	if (priv->line_control & CONTROL_RESET)	848	if (priv->line_control & CONTROL_RESET)
Lines 846-857 static void cypress_send(struct usb_serial_port *port) Link Here
846	return;	863	return;
847	}	864	}
848		865
849	switch (port->interrupt_out_size) {	866	switch (priv->pkt_fmt) {
850	case 32:	867	default:
851	port->interrupt_out_buffer[1] = count;	868	case packet_format_1:
852	break;	869	port->interrupt_out_buffer[1] = count;
853	case 8:	870	break;
854	port->interrupt_out_buffer[0] \|= count;	871	case packet_format_2:
		872	port->interrupt_out_buffer[0] \|= count;
855	}	873	}
856		874
857	dbg("%s - count is %d", __FUNCTION__, count);	875	dbg("%s - count is %d", __FUNCTION__, count);
Lines 864-871 send: Link Here
864	if (priv->cmd_ctrl)	882	if (priv->cmd_ctrl)
865	actual_size = 1;	883	actual_size = 1;
866	else	884	else
867	actual_size = count + (port->interrupt_out_size == 32 ? 2 : 1);	885	actual_size = count +
868		886	(priv->pkt_fmt == packet_format_1 ? 2 : 1);
		887
869	usb_serial_debug_data(debug, &port->dev, __FUNCTION__, port->interrupt_out_size,	888	usb_serial_debug_data(debug, &port->dev, __FUNCTION__, port->interrupt_out_size,
870	port->interrupt_out_urb->transfer_buffer);	889	port->interrupt_out_urb->transfer_buffer);
871		890
Lines 1331-1360 static void cypress_read_int_callback(struct urb *urb) Link Here
1331	}	1350	}
1332		1351
1333	spin_lock_irqsave(&priv->lock, flags);	1352	spin_lock_irqsave(&priv->lock, flags);
1334	switch(urb->actual_length) {	1353	result = urb->actual_length;
1335	case 32:	1354	switch (priv->pkt_fmt) {
1336	/* This is for the CY7C64013... */	1355	default:
1337	priv->current_status = data[0] & 0xF8;	1356	case packet_format_1:
1338	bytes = data[1] + 2;	1357	/* This is for the CY7C64013... */
1339	i = 2;	1358	priv->current_status = data[0] & 0xF8;
1340	if (bytes > 2)	1359	bytes = data[1] + 2;
1341	havedata = 1;	1360	i = 2;
1342	break;	1361	if (bytes > 2)
1343	case 8:	1362	havedata = 1;
1344	/* This is for the CY7C63743... */	1363	break;
1345	priv->current_status = data[0] & 0xF8;	1364	case packet_format_2:
1346	bytes = (data[0] & 0x07) + 1;	1365	/* This is for the CY7C63743... */
1347	i = 1;	1366	priv->current_status = data[0] & 0xF8;
1348	if (bytes > 1)	1367	bytes = (data[0] & 0x07) + 1;
1349	havedata = 1;	1368	i = 1;
1350	break;	1369	if (bytes > 1)
1351	default:	1370	havedata = 1;
1352	dbg("%s - wrong packet size - received %d bytes",	1371	break;
1353	__FUNCTION__, urb->actual_length);
1354	spin_unlock_irqrestore(&priv->lock, flags);
1355	goto continue_read;
1356	}	1372	}
1357	spin_unlock_irqrestore(&priv->lock, flags);	1373	spin_unlock_irqrestore(&priv->lock, flags);
		1374	if (result < bytes) {
		1375	dbg("%s - wrong packet size - received %d bytes but packet "
		1376	"said %d bytes", __func__, result, bytes);
		1377	goto continue_read;
		1378	}
1358		1379
1359	usb_serial_debug_data (debug, &port->dev, __FUNCTION__,	1380	usb_serial_debug_data (debug, &port->dev, __FUNCTION__,
1360	urb->actual_length, data);	1381	urb->actual_length, data);
1361	--

Lines 145-150 struct cypress_private { Link Here

(-)a/drivers/usb/serial/cypress_m8.c (-3 / +19 lines)
145	__u8 current_config; /* stores the current configuration byte */	145	__u8 current_config; /* stores the current configuration byte */
146	__u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */	146	__u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */
147	enum packet_format pkt_fmt; /* format to use for packet send / receive */	147	enum packet_format pkt_fmt; /* format to use for packet send / receive */
		148	int get_cfg_unsafe; /* If true, the CYPRESS_GET_CONFIG is unsafe */
148	int baud_rate; /* stores current baud rate in integer form */	149	int baud_rate; /* stores current baud rate in integer form */
149	int cbr_mask; /* stores current baud rate in masked form */	150	int cbr_mask; /* stores current baud rate in masked form */
150	int isthrottled; /* if throttled, discard reads */	151	int isthrottled; /* if throttled, discard reads */
Lines 401-406 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here
401	}	402	}
402	break;	403	break;
403	case CYPRESS_GET_CONFIG:	404	case CYPRESS_GET_CONFIG:
		405	if (priv->get_cfg_unsafe) {
		406	/* Not implemented for this device,
		407	and if we try to do it we're likely
		408	to crash the hardware. */
		409	return -ENOTTY;
		410	}
404	dbg("%s - retreiving serial line settings", __FUNCTION__);	411	dbg("%s - retreiving serial line settings", __FUNCTION__);
405	/* set initial values in feature buffer */	412	/* set initial values in feature buffer */
406	memset(feature_buffer, 0, sizeof(feature_buffer));	413	memset(feature_buffer, 0, sizeof(feature_buffer));
Lines 570-589 static int generic_startup (struct usb_serial *serial) Link Here
570	static int cypress_earthmate_startup (struct usb_serial *serial)	577	static int cypress_earthmate_startup (struct usb_serial *serial)
571	{	578	{
572	struct cypress_private *priv;	579	struct cypress_private *priv;
		580	struct usb_serial_port *port = serial->port[0];
573		581
574	dbg("%s", __FUNCTION__);	582	dbg("%s", __FUNCTION__);
575		583
576	if (generic_startup(serial)) {	584	if (generic_startup(serial)) {
577	dbg("%s - Failed setting up port %d", __FUNCTION__,	585	dbg("%s - Failed setting up port %d", __FUNCTION__,
578	serial->port[0]->number);	586	port->number);
579	return 1;	587	return 1;
580	}	588	}
581		589
582	priv = usb_get_serial_port_data(serial->port[0]);	590	priv = usb_get_serial_port_data(port);
583	priv->chiptype = CT_EARTHMATE;	591	priv->chiptype = CT_EARTHMATE;
584	/* All Earthmate devices use the separated-count packet	592	/* All Earthmate devices use the separated-count packet
585	format! Idiotic. */	593	format! Idiotic. */
586	priv->pkt_fmt = packet_format_1;	594	priv->pkt_fmt = packet_format_1;
		595	if (serial->dev->descriptor.idProduct != PRODUCT_ID_EARTHMATEUSB) {
		596	/* The old original USB Earthmate seemed able to
		597	handle GET_CONFIG requests; everything they've
		598	produced since that time crashes if this command is
		599	attempted :-( */
		600	dbg("%s - Marking this device as unsafe for GET_CONFIG "
		601	"commands", __func__);
		602	priv->get_cfg_unsafe = !0;
		603	}
587		604
588	return 0;	605	return 0;
589	} /* cypress_earthmate_startup */	606	} /* cypress_earthmate_startup */
590	--





	spin_lock_irqsave(&priv->lock, flags);
	/* check to see if status has changed */
	if (priv->current_status != priv->prev_status) {
		priv->diff_status |= priv->current_status ^
			priv->prev_status;
		wake_up_interruptible(&priv->delta_msr_wait);
		priv->prev_status = priv->current_status;
			priv->prev_status = priv->current_status;
		}
	}
	spin_unlock_irqrestore(&priv->lock, flags);

--




 *****************************************************************************/


static int analyze_baud_rate(struct usb_serial_port *port, unsigned baud_mask)
{
	int new_rate;
	struct cypress_private *priv;
	priv = usb_get_serial_port_data(port);

	/*
	 * The general purpose firmware for the Cypress M8 allows for
	 * a maximum speed of 57600bps (I have no idea whether DeLorme
	 * chose to use the general purpose firmware or not), if you
	 * need to modify this speed setting for your own project
	 * please add your own chiptype and modify the code likewise.
	 * The Cypress HID->COM device will work successfully up to
	 * 115200bps (but the actual throughput is around 3kBps).
	 */
	new_rate = mask_to_rate(baud_mask);
	if (new_rate < 0) {
		dbg("%s - failed setting baud rate, untranslatable speed",
		    __func__);
		return -1;
	}
	if (port->serial->dev->speed == USB_SPEED_LOW) {
		/*
		 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
		 * Cypress app note that describes this mechanism
		 * states the the low-speed part can't handle more
		 * than 800 bytes/sec, in which case 4800 baud is the
		 * safest speed for a part like that.
		 */
		if (new_rate > 4800) {
			dbg("%s - failed setting baud rate, device incapable "
			    "speed %d", __func__, new_rate);
			return -1;
		}
	}
	switch (priv->chiptype) {
	case CT_EARTHMATE:
		if (new_rate <= 600) {
			/* 300 and 600 baud rates are supported under
			 * the generic firmware, but are not used with
			 * NMEA and SiRF protocols */
			dbg("%s - failed setting baud rate, unsupported speed "
			    "of %d on Earthmate GPS", __func__, new_rate);
			return -1;
		}
		break;
	default:
		break;
	}
	return new_rate;
}


/* This function can either set or retrieve the current serial line settings */
static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_mask, int data_bits, int stop_bits,
				   int parity_enable, int parity_type, int reset, int cypress_request_type)


	switch(cypress_request_type) {
		case CYPRESS_SET_CONFIG:
			new_baudrate = priv->baud_rate;
			/*
			 * The general purpose firmware for the Cypress M8 allows for a maximum speed
 			 * of 57600bps (I have no idea whether DeLorme chose to use the general purpose
			 * firmware or not), if you need to modify this speed setting for your own
			 * project please add your own chiptype and modify the code likewise.  The
			 * Cypress HID->COM device will work successfully up to 115200bps (but the
			 * actual throughput is around 3kBps).
			 */
			if (baud_mask != priv->cbr_mask) {
				dbg("%s - baud rate is changing", __FUNCTION__);
				retval = analyze_baud_rate(port, baud_mask);
				if (retval >=  0) {
					new_baudrate = retval;
					dbg("%s - New baud rate set to %d",
					    __func__, new_baudrate);
						err("%s - failed setting baud rate, unsupported speed",
						    __FUNCTION__);
						new_baudrate = priv->baud_rate;
					} else if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
						err("%s - failed setting baud rate, unsupported speed",
						    __FUNCTION__);
						new_baudrate = priv->baud_rate;
					}
				} else if (priv->chiptype == CT_CYPHIDCOM) {
					if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
						err("%s - failed setting baud rate, unsupported speed",
						    __FUNCTION__);
						new_baudrate = priv->baud_rate;
					}
				} else if (priv->chiptype == CT_CA42V2) {
					if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
						err("%s - failed setting baud rate, unsupported speed",
						    __FUNCTION__);
						new_baudrate = priv->baud_rate;
					}
				} else if (priv->chiptype == CT_GENERIC) {
					if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
						err("%s - failed setting baud rate, unsupported speed",
						    __FUNCTION__);
						new_baudrate = priv->baud_rate;
					}
				} else {
					info("%s - please define your chiptype", __FUNCTION__);
					new_baudrate = priv->baud_rate;
				}
			} else {  /* baud rate not changing, keep the old */
				new_baudrate = priv->baud_rate;
			}
			dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);
			

Return to bug 219152

Lines 1399-1411 static void cypress_read_int_callback(struct urb *urb) Link Here

(-)a/drivers/usb/serial/cypress_m8.c (-8 / +5 lines)
1399		1399
1400	spin_lock_irqsave(&priv->lock, flags);	1400	spin_lock_irqsave(&priv->lock, flags);
1401	/* check to see if status has changed */	1401	/* check to see if status has changed */
1402	if (priv != NULL) {	1402	if (priv->current_status != priv->prev_status) {
1403	if (priv->current_status != priv->prev_status) {	1403	priv->diff_status \|= priv->current_status ^
1404	priv->diff_status \|= priv->current_status ^	1404	priv->prev_status;
1405	priv->prev_status;	1405	wake_up_interruptible(&priv->delta_msr_wait);
1406	wake_up_interruptible(&priv->delta_msr_wait);	1406	priv->prev_status = priv->current_status;
1407	priv->prev_status = priv->current_status;
1408	}
1409	}	1407	}
1410	spin_unlock_irqrestore(&priv->lock, flags);	1408	spin_unlock_irqrestore(&priv->lock, flags);
1411		1409
1412	--

Lines 291-296 static struct usb_serial_driver cypress_ca42v2_device = { Link Here

(-)a/drivers/usb/serial/cypress_m8.c (-45 / +59 lines)
291	*****************************************************************************/	291	*****************************************************************************/
292		292
293		293
		294	static int analyze_baud_rate(struct usb_serial_port *port, unsigned baud_mask)
		295	{
		296	int new_rate;
		297	struct cypress_private *priv;
		298	priv = usb_get_serial_port_data(port);
		299
		300	/*
		301	* The general purpose firmware for the Cypress M8 allows for
		302	* a maximum speed of 57600bps (I have no idea whether DeLorme
		303	* chose to use the general purpose firmware or not), if you
		304	* need to modify this speed setting for your own project
		305	* please add your own chiptype and modify the code likewise.
		306	* The Cypress HID->COM device will work successfully up to
		307	* 115200bps (but the actual throughput is around 3kBps).
		308	*/
		309	new_rate = mask_to_rate(baud_mask);
		310	if (new_rate < 0) {
		311	dbg("%s - failed setting baud rate, untranslatable speed",
		312	__func__);
		313	return -1;
		314	}
		315	if (port->serial->dev->speed == USB_SPEED_LOW) {
		316	/*
		317	* Mike Isely <isely@pobox.com> 2-Feb-2008: The
		318	* Cypress app note that describes this mechanism
		319	* states the the low-speed part can't handle more
		320	* than 800 bytes/sec, in which case 4800 baud is the
		321	* safest speed for a part like that.
		322	*/
		323	if (new_rate > 4800) {
		324	dbg("%s - failed setting baud rate, device incapable "
		325	"speed %d", __func__, new_rate);
		326	return -1;
		327	}
		328	}
		329	switch (priv->chiptype) {
		330	case CT_EARTHMATE:
		331	if (new_rate <= 600) {
		332	/* 300 and 600 baud rates are supported under
		333	* the generic firmware, but are not used with
		334	* NMEA and SiRF protocols */
		335	dbg("%s - failed setting baud rate, unsupported speed "
		336	"of %d on Earthmate GPS", __func__, new_rate);
		337	return -1;
		338	}
		339	break;
		340	default:
		341	break;
		342	}
		343	return new_rate;
		344	}
		345
		346
294	/* This function can either set or retrieve the current serial line settings */	347	/* This function can either set or retrieve the current serial line settings */
295	static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_mask, int data_bits, int stop_bits,	348	static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_mask, int data_bits, int stop_bits,
296	int parity_enable, int parity_type, int reset, int cypress_request_type)	349	int parity_enable, int parity_type, int reset, int cypress_request_type)
Lines 309-362 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m Link Here
309		362
310	switch(cypress_request_type) {	363	switch(cypress_request_type) {
311	case CYPRESS_SET_CONFIG:	364	case CYPRESS_SET_CONFIG:
312		365	new_baudrate = priv->baud_rate;
313	/*
314	* The general purpose firmware for the Cypress M8 allows for a maximum speed
315	* of 57600bps (I have no idea whether DeLorme chose to use the general purpose
316	* firmware or not), if you need to modify this speed setting for your own
317	* project please add your own chiptype and modify the code likewise. The
318	* Cypress HID->COM device will work successfully up to 115200bps (but the
319	* actual throughput is around 3kBps).
320	*/
321	if (baud_mask != priv->cbr_mask) {	366	if (baud_mask != priv->cbr_mask) {
322	dbg("%s - baud rate is changing", __FUNCTION__);	367	dbg("%s - baud rate is changing", __FUNCTION__);
323	if ( priv->chiptype == CT_EARTHMATE ) {	368	retval = analyze_baud_rate(port, baud_mask);
324	/* 300 and 600 baud rates are supported under the generic firmware,	369	if (retval >= 0) {
325	* but are not used with NMEA and SiRF protocols */	370	new_baudrate = retval;
326		371	dbg("%s - New baud rate set to %d",
327	if ( (baud_mask == B300) \|\| (baud_mask == B600) ) {	372	__func__, new_baudrate);
328	err("%s - failed setting baud rate, unsupported speed",
329	__FUNCTION__);
330	new_baudrate = priv->baud_rate;
331	} else if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
332	err("%s - failed setting baud rate, unsupported speed",
333	__FUNCTION__);
334	new_baudrate = priv->baud_rate;
335	}
336	} else if (priv->chiptype == CT_CYPHIDCOM) {
337	if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
338	err("%s - failed setting baud rate, unsupported speed",
339	__FUNCTION__);
340	new_baudrate = priv->baud_rate;
341	}
342	} else if (priv->chiptype == CT_CA42V2) {
343	if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
344	err("%s - failed setting baud rate, unsupported speed",
345	__FUNCTION__);
346	new_baudrate = priv->baud_rate;
347	}
348	} else if (priv->chiptype == CT_GENERIC) {
349	if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
350	err("%s - failed setting baud rate, unsupported speed",
351	__FUNCTION__);
352	new_baudrate = priv->baud_rate;
353	}
354	} else {
355	info("%s - please define your chiptype", __FUNCTION__);
356	new_baudrate = priv->baud_rate;
357	}	373	}
358	} else { /* baud rate not changing, keep the old */
359	new_baudrate = priv->baud_rate;
360	}	374	}
361	dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);	375	dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);
362		376