xref: /linux/drivers/usb/serial/iuu_phoenix.c (revision 26fbb4c8c7c3ee9a4c3b4de555a8587b5a19154e)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Infinity Unlimited USB Phoenix driver
4  *
5  * Copyright (C) 2010 James Courtier-Dutton (James@superbug.co.uk)
6 
7  * Copyright (C) 2007 Alain Degreffe (eczema@ecze.com)
8  *
9  * Original code taken from iuutool (Copyright (C) 2006 Juan Carlos Borrás)
10  *
11  *  And tested with help of WB Electronics
12  */
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/tty.h>
17 #include <linux/tty_driver.h>
18 #include <linux/tty_flip.h>
19 #include <linux/serial.h>
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/spinlock.h>
23 #include <linux/uaccess.h>
24 #include <linux/usb.h>
25 #include <linux/usb/serial.h>
26 #include "iuu_phoenix.h"
27 #include <linux/random.h>
28 
29 #define DRIVER_DESC "Infinity USB Unlimited Phoenix driver"
30 
31 static const struct usb_device_id id_table[] = {
32 	{USB_DEVICE(IUU_USB_VENDOR_ID, IUU_USB_PRODUCT_ID)},
33 	{}			/* Terminating entry */
34 };
35 MODULE_DEVICE_TABLE(usb, id_table);
36 
37 /* turbo parameter */
38 static int boost = 100;
39 static int clockmode = 1;
40 static int cdmode = 1;
41 static int iuu_cardin;
42 static int iuu_cardout;
43 static bool xmas;
44 static int vcc_default = 5;
45 
46 static int iuu_create_sysfs_attrs(struct usb_serial_port *port);
47 static int iuu_remove_sysfs_attrs(struct usb_serial_port *port);
48 static void read_rxcmd_callback(struct urb *urb);
49 
50 struct iuu_private {
51 	spinlock_t lock;	/* store irq state */
52 	u8 line_status;
53 	int tiostatus;		/* store IUART SIGNAL for tiocmget call */
54 	u8 reset;		/* if 1 reset is needed */
55 	int poll;		/* number of poll */
56 	u8 *writebuf;		/* buffer for writing to device */
57 	int writelen;		/* num of byte to write to device */
58 	u8 *buf;		/* used for initialize speed */
59 	u8 len;
60 	int vcc;		/* vcc (either 3 or 5 V) */
61 	u32 boost;
62 	u32 clk;
63 };
64 
65 static int iuu_port_probe(struct usb_serial_port *port)
66 {
67 	struct iuu_private *priv;
68 	int ret;
69 
70 	priv = kzalloc(sizeof(struct iuu_private), GFP_KERNEL);
71 	if (!priv)
72 		return -ENOMEM;
73 
74 	priv->buf = kzalloc(256, GFP_KERNEL);
75 	if (!priv->buf) {
76 		kfree(priv);
77 		return -ENOMEM;
78 	}
79 
80 	priv->writebuf = kzalloc(256, GFP_KERNEL);
81 	if (!priv->writebuf) {
82 		kfree(priv->buf);
83 		kfree(priv);
84 		return -ENOMEM;
85 	}
86 
87 	priv->vcc = vcc_default;
88 	spin_lock_init(&priv->lock);
89 
90 	usb_set_serial_port_data(port, priv);
91 
92 	ret = iuu_create_sysfs_attrs(port);
93 	if (ret) {
94 		kfree(priv->writebuf);
95 		kfree(priv->buf);
96 		kfree(priv);
97 		return ret;
98 	}
99 
100 	return 0;
101 }
102 
103 static int iuu_port_remove(struct usb_serial_port *port)
104 {
105 	struct iuu_private *priv = usb_get_serial_port_data(port);
106 
107 	iuu_remove_sysfs_attrs(port);
108 	kfree(priv->writebuf);
109 	kfree(priv->buf);
110 	kfree(priv);
111 
112 	return 0;
113 }
114 
115 static int iuu_tiocmset(struct tty_struct *tty,
116 			unsigned int set, unsigned int clear)
117 {
118 	struct usb_serial_port *port = tty->driver_data;
119 	struct iuu_private *priv = usb_get_serial_port_data(port);
120 	unsigned long flags;
121 
122 	/* FIXME: locking on tiomstatus */
123 	dev_dbg(&port->dev, "%s msg : SET = 0x%04x, CLEAR = 0x%04x\n",
124 		__func__, set, clear);
125 
126 	spin_lock_irqsave(&priv->lock, flags);
127 
128 	if ((set & TIOCM_RTS) && !(priv->tiostatus == TIOCM_RTS)) {
129 		dev_dbg(&port->dev, "%s TIOCMSET RESET called !!!\n", __func__);
130 		priv->reset = 1;
131 	}
132 	if (set & TIOCM_RTS)
133 		priv->tiostatus = TIOCM_RTS;
134 
135 	spin_unlock_irqrestore(&priv->lock, flags);
136 	return 0;
137 }
138 
139 /* This is used to provide a carrier detect mechanism
140  * When a card is present, the response is 0x00
141  * When no card , the reader respond with TIOCM_CD
142  * This is known as CD autodetect mechanism
143  */
144 static int iuu_tiocmget(struct tty_struct *tty)
145 {
146 	struct usb_serial_port *port = tty->driver_data;
147 	struct iuu_private *priv = usb_get_serial_port_data(port);
148 	unsigned long flags;
149 	int rc;
150 
151 	spin_lock_irqsave(&priv->lock, flags);
152 	rc = priv->tiostatus;
153 	spin_unlock_irqrestore(&priv->lock, flags);
154 
155 	return rc;
156 }
157 
158 static void iuu_rxcmd(struct urb *urb)
159 {
160 	struct usb_serial_port *port = urb->context;
161 	int status = urb->status;
162 
163 	if (status) {
164 		dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
165 		/* error stop all */
166 		return;
167 	}
168 
169 
170 	memset(port->write_urb->transfer_buffer, IUU_UART_RX, 1);
171 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
172 			  usb_sndbulkpipe(port->serial->dev,
173 					  port->bulk_out_endpointAddress),
174 			  port->write_urb->transfer_buffer, 1,
175 			  read_rxcmd_callback, port);
176 	usb_submit_urb(port->write_urb, GFP_ATOMIC);
177 }
178 
179 static int iuu_reset(struct usb_serial_port *port, u8 wt)
180 {
181 	struct iuu_private *priv = usb_get_serial_port_data(port);
182 	int result;
183 	char *buf_ptr = port->write_urb->transfer_buffer;
184 
185 	/* Prepare the reset sequence */
186 
187 	*buf_ptr++ = IUU_RST_SET;
188 	*buf_ptr++ = IUU_DELAY_MS;
189 	*buf_ptr++ = wt;
190 	*buf_ptr = IUU_RST_CLEAR;
191 
192 	/* send the sequence */
193 
194 	usb_fill_bulk_urb(port->write_urb,
195 			  port->serial->dev,
196 			  usb_sndbulkpipe(port->serial->dev,
197 					  port->bulk_out_endpointAddress),
198 			  port->write_urb->transfer_buffer, 4, iuu_rxcmd, port);
199 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
200 	priv->reset = 0;
201 	return result;
202 }
203 
204 /* Status Function
205  * Return value is
206  * 0x00 = no card
207  * 0x01 = smartcard
208  * 0x02 = sim card
209  */
210 static void iuu_update_status_callback(struct urb *urb)
211 {
212 	struct usb_serial_port *port = urb->context;
213 	struct iuu_private *priv = usb_get_serial_port_data(port);
214 	u8 *st;
215 	int status = urb->status;
216 
217 	if (status) {
218 		dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
219 		/* error stop all */
220 		return;
221 	}
222 
223 	st = urb->transfer_buffer;
224 	dev_dbg(&port->dev, "%s - enter\n", __func__);
225 	if (urb->actual_length == 1) {
226 		switch (st[0]) {
227 		case 0x1:
228 			priv->tiostatus = iuu_cardout;
229 			break;
230 		case 0x0:
231 			priv->tiostatus = iuu_cardin;
232 			break;
233 		default:
234 			priv->tiostatus = iuu_cardin;
235 		}
236 	}
237 	iuu_rxcmd(urb);
238 }
239 
240 static void iuu_status_callback(struct urb *urb)
241 {
242 	struct usb_serial_port *port = urb->context;
243 	int status = urb->status;
244 
245 	dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
246 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
247 			  usb_rcvbulkpipe(port->serial->dev,
248 					  port->bulk_in_endpointAddress),
249 			  port->read_urb->transfer_buffer, 256,
250 			  iuu_update_status_callback, port);
251 	usb_submit_urb(port->read_urb, GFP_ATOMIC);
252 }
253 
254 static int iuu_status(struct usb_serial_port *port)
255 {
256 	int result;
257 
258 	memset(port->write_urb->transfer_buffer, IUU_GET_STATE_REGISTER, 1);
259 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
260 			  usb_sndbulkpipe(port->serial->dev,
261 					  port->bulk_out_endpointAddress),
262 			  port->write_urb->transfer_buffer, 1,
263 			  iuu_status_callback, port);
264 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
265 	return result;
266 
267 }
268 
269 static int bulk_immediate(struct usb_serial_port *port, u8 *buf, u8 count)
270 {
271 	int status;
272 	struct usb_serial *serial = port->serial;
273 	int actual = 0;
274 
275 	/* send the data out the bulk port */
276 
277 	status =
278 	    usb_bulk_msg(serial->dev,
279 			 usb_sndbulkpipe(serial->dev,
280 					 port->bulk_out_endpointAddress), buf,
281 			 count, &actual, 1000);
282 
283 	if (status != IUU_OPERATION_OK)
284 		dev_dbg(&port->dev, "%s - error = %2x\n", __func__, status);
285 	else
286 		dev_dbg(&port->dev, "%s - write OK !\n", __func__);
287 	return status;
288 }
289 
290 static int read_immediate(struct usb_serial_port *port, u8 *buf, u8 count)
291 {
292 	int status;
293 	struct usb_serial *serial = port->serial;
294 	int actual = 0;
295 
296 	/* send the data out the bulk port */
297 	status =
298 	    usb_bulk_msg(serial->dev,
299 			 usb_rcvbulkpipe(serial->dev,
300 					 port->bulk_in_endpointAddress), buf,
301 			 count, &actual, 1000);
302 
303 	if (status != IUU_OPERATION_OK)
304 		dev_dbg(&port->dev, "%s - error = %2x\n", __func__, status);
305 	else
306 		dev_dbg(&port->dev, "%s - read OK !\n", __func__);
307 	return status;
308 }
309 
310 static int iuu_led(struct usb_serial_port *port, unsigned int R,
311 		   unsigned int G, unsigned int B, u8 f)
312 {
313 	int status;
314 	u8 *buf;
315 	buf = kmalloc(8, GFP_KERNEL);
316 	if (!buf)
317 		return -ENOMEM;
318 
319 	buf[0] = IUU_SET_LED;
320 	buf[1] = R & 0xFF;
321 	buf[2] = (R >> 8) & 0xFF;
322 	buf[3] = G & 0xFF;
323 	buf[4] = (G >> 8) & 0xFF;
324 	buf[5] = B & 0xFF;
325 	buf[6] = (B >> 8) & 0xFF;
326 	buf[7] = f;
327 	status = bulk_immediate(port, buf, 8);
328 	kfree(buf);
329 	if (status != IUU_OPERATION_OK)
330 		dev_dbg(&port->dev, "%s - led error status = %2x\n", __func__, status);
331 	else
332 		dev_dbg(&port->dev, "%s - led OK !\n", __func__);
333 	return IUU_OPERATION_OK;
334 }
335 
336 static void iuu_rgbf_fill_buffer(u8 *buf, u8 r1, u8 r2, u8 g1, u8 g2, u8 b1,
337 				 u8 b2, u8 freq)
338 {
339 	*buf++ = IUU_SET_LED;
340 	*buf++ = r1;
341 	*buf++ = r2;
342 	*buf++ = g1;
343 	*buf++ = g2;
344 	*buf++ = b1;
345 	*buf++ = b2;
346 	*buf = freq;
347 }
348 
349 static void iuu_led_activity_on(struct urb *urb)
350 {
351 	struct usb_serial_port *port = urb->context;
352 	char *buf_ptr = port->write_urb->transfer_buffer;
353 
354 	if (xmas) {
355 		buf_ptr[0] = IUU_SET_LED;
356 		get_random_bytes(buf_ptr + 1, 6);
357 		buf_ptr[7] = 1;
358 	} else {
359 		iuu_rgbf_fill_buffer(buf_ptr, 255, 255, 0, 0, 0, 0, 255);
360 	}
361 
362 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
363 			  usb_sndbulkpipe(port->serial->dev,
364 					  port->bulk_out_endpointAddress),
365 			  port->write_urb->transfer_buffer, 8 ,
366 			  iuu_rxcmd, port);
367 	usb_submit_urb(port->write_urb, GFP_ATOMIC);
368 }
369 
370 static void iuu_led_activity_off(struct urb *urb)
371 {
372 	struct usb_serial_port *port = urb->context;
373 	char *buf_ptr = port->write_urb->transfer_buffer;
374 
375 	if (xmas) {
376 		iuu_rxcmd(urb);
377 		return;
378 	}
379 
380 	iuu_rgbf_fill_buffer(buf_ptr, 0, 0, 255, 255, 0, 0, 255);
381 
382 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
383 			  usb_sndbulkpipe(port->serial->dev,
384 					  port->bulk_out_endpointAddress),
385 			  port->write_urb->transfer_buffer, 8 ,
386 			  iuu_rxcmd, port);
387 	usb_submit_urb(port->write_urb, GFP_ATOMIC);
388 }
389 
390 
391 
392 static int iuu_clk(struct usb_serial_port *port, int dwFrq)
393 {
394 	int status;
395 	struct iuu_private *priv = usb_get_serial_port_data(port);
396 	int Count = 0;
397 	u8 FrqGenAdr = 0x69;
398 	u8 DIV = 0;		/* 8bit */
399 	u8 XDRV = 0;		/* 8bit */
400 	u8 PUMP = 0;		/* 3bit */
401 	u8 PBmsb = 0;		/* 2bit */
402 	u8 PBlsb = 0;		/* 8bit */
403 	u8 PO = 0;		/* 1bit */
404 	u8 Q = 0;		/* 7bit */
405 	/* 24bit = 3bytes */
406 	unsigned int P = 0;
407 	unsigned int P2 = 0;
408 	int frq = (int)dwFrq;
409 
410 	if (frq == 0) {
411 		priv->buf[Count++] = IUU_UART_WRITE_I2C;
412 		priv->buf[Count++] = FrqGenAdr << 1;
413 		priv->buf[Count++] = 0x09;
414 		priv->buf[Count++] = 0x00;
415 
416 		status = bulk_immediate(port, (u8 *) priv->buf, Count);
417 		if (status != 0) {
418 			dev_dbg(&port->dev, "%s - write error\n", __func__);
419 			return status;
420 		}
421 	} else if (frq == 3579000) {
422 		DIV = 100;
423 		P = 1193;
424 		Q = 40;
425 		XDRV = 0;
426 	} else if (frq == 3680000) {
427 		DIV = 105;
428 		P = 161;
429 		Q = 5;
430 		XDRV = 0;
431 	} else if (frq == 6000000) {
432 		DIV = 66;
433 		P = 66;
434 		Q = 2;
435 		XDRV = 0x28;
436 	} else {
437 		unsigned int result = 0;
438 		unsigned int tmp = 0;
439 		unsigned int check;
440 		unsigned int check2;
441 		char found = 0x00;
442 		unsigned int lQ = 2;
443 		unsigned int lP = 2055;
444 		unsigned int lDiv = 4;
445 
446 		for (lQ = 2; lQ <= 47 && !found; lQ++)
447 			for (lP = 2055; lP >= 8 && !found; lP--)
448 				for (lDiv = 4; lDiv <= 127 && !found; lDiv++) {
449 					tmp = (12000000 / lDiv) * (lP / lQ);
450 					if (abs((int)(tmp - frq)) <
451 					    abs((int)(frq - result))) {
452 						check2 = (12000000 / lQ);
453 						if (check2 < 250000)
454 							continue;
455 						check = (12000000 / lQ) * lP;
456 						if (check > 400000000)
457 							continue;
458 						if (check < 100000000)
459 							continue;
460 						if (lDiv < 4 || lDiv > 127)
461 							continue;
462 						result = tmp;
463 						P = lP;
464 						DIV = lDiv;
465 						Q = lQ;
466 						if (result == frq)
467 							found = 0x01;
468 					}
469 				}
470 	}
471 	P2 = ((P - PO) / 2) - 4;
472 	PUMP = 0x04;
473 	PBmsb = (P2 >> 8 & 0x03);
474 	PBlsb = P2 & 0xFF;
475 	PO = (P >> 10) & 0x01;
476 	Q = Q - 2;
477 
478 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/* 0x4C */
479 	priv->buf[Count++] = FrqGenAdr << 1;
480 	priv->buf[Count++] = 0x09;
481 	priv->buf[Count++] = 0x20;	/* Adr = 0x09 */
482 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/* 0x4C */
483 	priv->buf[Count++] = FrqGenAdr << 1;
484 	priv->buf[Count++] = 0x0C;
485 	priv->buf[Count++] = DIV;	/* Adr = 0x0C */
486 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/* 0x4C */
487 	priv->buf[Count++] = FrqGenAdr << 1;
488 	priv->buf[Count++] = 0x12;
489 	priv->buf[Count++] = XDRV;	/* Adr = 0x12 */
490 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
491 	priv->buf[Count++] = FrqGenAdr << 1;
492 	priv->buf[Count++] = 0x13;
493 	priv->buf[Count++] = 0x6B;	/* Adr = 0x13 */
494 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
495 	priv->buf[Count++] = FrqGenAdr << 1;
496 	priv->buf[Count++] = 0x40;
497 	priv->buf[Count++] = (0xC0 | ((PUMP & 0x07) << 2)) |
498 			     (PBmsb & 0x03);	/* Adr = 0x40 */
499 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
500 	priv->buf[Count++] = FrqGenAdr << 1;
501 	priv->buf[Count++] = 0x41;
502 	priv->buf[Count++] = PBlsb;	/* Adr = 0x41 */
503 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
504 	priv->buf[Count++] = FrqGenAdr << 1;
505 	priv->buf[Count++] = 0x42;
506 	priv->buf[Count++] = Q | (((PO & 0x01) << 7));	/* Adr = 0x42 */
507 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
508 	priv->buf[Count++] = FrqGenAdr << 1;
509 	priv->buf[Count++] = 0x44;
510 	priv->buf[Count++] = (char)0xFF;	/* Adr = 0x44 */
511 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
512 	priv->buf[Count++] = FrqGenAdr << 1;
513 	priv->buf[Count++] = 0x45;
514 	priv->buf[Count++] = (char)0xFE;	/* Adr = 0x45 */
515 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
516 	priv->buf[Count++] = FrqGenAdr << 1;
517 	priv->buf[Count++] = 0x46;
518 	priv->buf[Count++] = 0x7F;	/* Adr = 0x46 */
519 	priv->buf[Count++] = IUU_UART_WRITE_I2C;	/*  0x4C */
520 	priv->buf[Count++] = FrqGenAdr << 1;
521 	priv->buf[Count++] = 0x47;
522 	priv->buf[Count++] = (char)0x84;	/* Adr = 0x47 */
523 
524 	status = bulk_immediate(port, (u8 *) priv->buf, Count);
525 	if (status != IUU_OPERATION_OK)
526 		dev_dbg(&port->dev, "%s - write error\n", __func__);
527 	return status;
528 }
529 
530 static int iuu_uart_flush(struct usb_serial_port *port)
531 {
532 	struct device *dev = &port->dev;
533 	int i;
534 	int status;
535 	u8 *rxcmd;
536 	struct iuu_private *priv = usb_get_serial_port_data(port);
537 
538 	if (iuu_led(port, 0xF000, 0, 0, 0xFF) < 0)
539 		return -EIO;
540 
541 	rxcmd = kmalloc(1, GFP_KERNEL);
542 	if (!rxcmd)
543 		return -ENOMEM;
544 
545 	rxcmd[0] = IUU_UART_RX;
546 
547 	for (i = 0; i < 2; i++) {
548 		status = bulk_immediate(port, rxcmd, 1);
549 		if (status != IUU_OPERATION_OK) {
550 			dev_dbg(dev, "%s - uart_flush_write error\n", __func__);
551 			goto out_free;
552 		}
553 
554 		status = read_immediate(port, &priv->len, 1);
555 		if (status != IUU_OPERATION_OK) {
556 			dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
557 			goto out_free;
558 		}
559 
560 		if (priv->len > 0) {
561 			dev_dbg(dev, "%s - uart_flush datalen is : %i\n", __func__, priv->len);
562 			status = read_immediate(port, priv->buf, priv->len);
563 			if (status != IUU_OPERATION_OK) {
564 				dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
565 				goto out_free;
566 			}
567 		}
568 	}
569 	dev_dbg(dev, "%s - uart_flush_read OK!\n", __func__);
570 	iuu_led(port, 0, 0xF000, 0, 0xFF);
571 
572 out_free:
573 	kfree(rxcmd);
574 
575 	return status;
576 }
577 
578 static void read_buf_callback(struct urb *urb)
579 {
580 	struct usb_serial_port *port = urb->context;
581 	unsigned char *data = urb->transfer_buffer;
582 	int status = urb->status;
583 
584 	if (status) {
585 		if (status == -EPROTO) {
586 			/* reschedule needed */
587 		}
588 		return;
589 	}
590 
591 	dev_dbg(&port->dev, "%s - %i chars to write\n", __func__, urb->actual_length);
592 
593 	if (urb->actual_length) {
594 		tty_insert_flip_string(&port->port, data, urb->actual_length);
595 		tty_flip_buffer_push(&port->port);
596 	}
597 	iuu_led_activity_on(urb);
598 }
599 
600 static int iuu_bulk_write(struct usb_serial_port *port)
601 {
602 	struct iuu_private *priv = usb_get_serial_port_data(port);
603 	unsigned long flags;
604 	int result;
605 	int buf_len;
606 	char *buf_ptr = port->write_urb->transfer_buffer;
607 
608 	spin_lock_irqsave(&priv->lock, flags);
609 	*buf_ptr++ = IUU_UART_ESC;
610 	*buf_ptr++ = IUU_UART_TX;
611 	*buf_ptr++ = priv->writelen;
612 
613 	memcpy(buf_ptr, priv->writebuf, priv->writelen);
614 	buf_len = priv->writelen;
615 	priv->writelen = 0;
616 	spin_unlock_irqrestore(&priv->lock, flags);
617 	dev_dbg(&port->dev, "%s - writing %i chars : %*ph\n", __func__,
618 		buf_len, buf_len, buf_ptr);
619 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
620 			  usb_sndbulkpipe(port->serial->dev,
621 					  port->bulk_out_endpointAddress),
622 			  port->write_urb->transfer_buffer, buf_len + 3,
623 			  iuu_rxcmd, port);
624 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
625 	usb_serial_port_softint(port);
626 	return result;
627 }
628 
629 static int iuu_read_buf(struct usb_serial_port *port, int len)
630 {
631 	int result;
632 
633 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
634 			  usb_rcvbulkpipe(port->serial->dev,
635 					  port->bulk_in_endpointAddress),
636 			  port->read_urb->transfer_buffer, len,
637 			  read_buf_callback, port);
638 	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
639 	return result;
640 }
641 
642 static void iuu_uart_read_callback(struct urb *urb)
643 {
644 	struct usb_serial_port *port = urb->context;
645 	struct iuu_private *priv = usb_get_serial_port_data(port);
646 	unsigned long flags;
647 	int status = urb->status;
648 	int error = 0;
649 	int len = 0;
650 	unsigned char *data = urb->transfer_buffer;
651 	priv->poll++;
652 
653 	if (status) {
654 		dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
655 		/* error stop all */
656 		return;
657 	}
658 
659 	if (urb->actual_length == 1)
660 		len = (int) data[0];
661 
662 	if (urb->actual_length > 1) {
663 		dev_dbg(&port->dev, "%s - urb->actual_length = %i\n", __func__,
664 		    urb->actual_length);
665 		error = 1;
666 		return;
667 	}
668 	/* if len > 0 call readbuf */
669 
670 	if (len > 0 && error == 0) {
671 		dev_dbg(&port->dev, "%s - call read buf - len to read is %i\n",
672 			__func__, len);
673 		status = iuu_read_buf(port, len);
674 		return;
675 	}
676 	/* need to update status  ? */
677 	if (priv->poll > 99) {
678 		status = iuu_status(port);
679 		priv->poll = 0;
680 		return;
681 	}
682 
683 	/* reset waiting ? */
684 
685 	if (priv->reset == 1) {
686 		status = iuu_reset(port, 0xC);
687 		return;
688 	}
689 	/* Writebuf is waiting */
690 	spin_lock_irqsave(&priv->lock, flags);
691 	if (priv->writelen > 0) {
692 		spin_unlock_irqrestore(&priv->lock, flags);
693 		status = iuu_bulk_write(port);
694 		return;
695 	}
696 	spin_unlock_irqrestore(&priv->lock, flags);
697 	/* if nothing to write call again rxcmd */
698 	dev_dbg(&port->dev, "%s - rxcmd recall\n", __func__);
699 	iuu_led_activity_off(urb);
700 }
701 
702 static int iuu_uart_write(struct tty_struct *tty, struct usb_serial_port *port,
703 			  const u8 *buf, int count)
704 {
705 	struct iuu_private *priv = usb_get_serial_port_data(port);
706 	unsigned long flags;
707 
708 	spin_lock_irqsave(&priv->lock, flags);
709 
710 	count = min(count, 256 - priv->writelen);
711 	if (count == 0)
712 		goto out;
713 
714 	/* fill the buffer */
715 	memcpy(priv->writebuf + priv->writelen, buf, count);
716 	priv->writelen += count;
717 out:
718 	spin_unlock_irqrestore(&priv->lock, flags);
719 
720 	return count;
721 }
722 
723 static void read_rxcmd_callback(struct urb *urb)
724 {
725 	struct usb_serial_port *port = urb->context;
726 	int result;
727 	int status = urb->status;
728 
729 	if (status) {
730 		/* error stop all */
731 		return;
732 	}
733 
734 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
735 			  usb_rcvbulkpipe(port->serial->dev,
736 					  port->bulk_in_endpointAddress),
737 			  port->read_urb->transfer_buffer, 256,
738 			  iuu_uart_read_callback, port);
739 	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
740 	dev_dbg(&port->dev, "%s - submit result = %d\n", __func__, result);
741 }
742 
743 static int iuu_uart_on(struct usb_serial_port *port)
744 {
745 	int status;
746 	u8 *buf;
747 
748 	buf = kmalloc(4, GFP_KERNEL);
749 
750 	if (!buf)
751 		return -ENOMEM;
752 
753 	buf[0] = IUU_UART_ENABLE;
754 	buf[1] = (u8) ((IUU_BAUD_9600 >> 8) & 0x00FF);
755 	buf[2] = (u8) (0x00FF & IUU_BAUD_9600);
756 	buf[3] = (u8) (0x0F0 & IUU_ONE_STOP_BIT) | (0x07 & IUU_PARITY_EVEN);
757 
758 	status = bulk_immediate(port, buf, 4);
759 	if (status != IUU_OPERATION_OK) {
760 		dev_dbg(&port->dev, "%s - uart_on error\n", __func__);
761 		goto uart_enable_failed;
762 	}
763 	/*  iuu_reset() the card after iuu_uart_on() */
764 	status = iuu_uart_flush(port);
765 	if (status != IUU_OPERATION_OK)
766 		dev_dbg(&port->dev, "%s - uart_flush error\n", __func__);
767 uart_enable_failed:
768 	kfree(buf);
769 	return status;
770 }
771 
772 /*  Disables the IUU UART (a.k.a. the Phoenix voiderface) */
773 static int iuu_uart_off(struct usb_serial_port *port)
774 {
775 	int status;
776 	u8 *buf;
777 	buf = kmalloc(1, GFP_KERNEL);
778 	if (!buf)
779 		return -ENOMEM;
780 	buf[0] = IUU_UART_DISABLE;
781 
782 	status = bulk_immediate(port, buf, 1);
783 	if (status != IUU_OPERATION_OK)
784 		dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
785 
786 	kfree(buf);
787 	return status;
788 }
789 
790 static int iuu_uart_baud(struct usb_serial_port *port, u32 baud_base,
791 			 u32 *actual, u8 parity)
792 {
793 	int status;
794 	u32 baud;
795 	u8 *dataout;
796 	u8 DataCount = 0;
797 	u8 T1Frekvens = 0;
798 	u8 T1reload = 0;
799 	unsigned int T1FrekvensHZ = 0;
800 
801 	dev_dbg(&port->dev, "%s - enter baud_base=%d\n", __func__, baud_base);
802 	dataout = kmalloc(5, GFP_KERNEL);
803 
804 	if (!dataout)
805 		return -ENOMEM;
806 	/*baud = (((priv->clk / 35) * baud_base) / 100000); */
807 	baud = baud_base;
808 
809 	if (baud < 1200 || baud > 230400) {
810 		kfree(dataout);
811 		return IUU_INVALID_PARAMETER;
812 	}
813 	if (baud > 977) {
814 		T1Frekvens = 3;
815 		T1FrekvensHZ = 500000;
816 	}
817 
818 	if (baud > 3906) {
819 		T1Frekvens = 2;
820 		T1FrekvensHZ = 2000000;
821 	}
822 
823 	if (baud > 11718) {
824 		T1Frekvens = 1;
825 		T1FrekvensHZ = 6000000;
826 	}
827 
828 	if (baud > 46875) {
829 		T1Frekvens = 0;
830 		T1FrekvensHZ = 24000000;
831 	}
832 
833 	T1reload = 256 - (u8) (T1FrekvensHZ / (baud * 2));
834 
835 	/*  magic number here:  ENTER_FIRMWARE_UPDATE; */
836 	dataout[DataCount++] = IUU_UART_ESC;
837 	/*  magic number here:  CHANGE_BAUD; */
838 	dataout[DataCount++] = IUU_UART_CHANGE;
839 	dataout[DataCount++] = T1Frekvens;
840 	dataout[DataCount++] = T1reload;
841 
842 	*actual = (T1FrekvensHZ / (256 - T1reload)) / 2;
843 
844 	switch (parity & 0x0F) {
845 	case IUU_PARITY_NONE:
846 		dataout[DataCount++] = 0x00;
847 		break;
848 	case IUU_PARITY_EVEN:
849 		dataout[DataCount++] = 0x01;
850 		break;
851 	case IUU_PARITY_ODD:
852 		dataout[DataCount++] = 0x02;
853 		break;
854 	case IUU_PARITY_MARK:
855 		dataout[DataCount++] = 0x03;
856 		break;
857 	case IUU_PARITY_SPACE:
858 		dataout[DataCount++] = 0x04;
859 		break;
860 	default:
861 		kfree(dataout);
862 		return IUU_INVALID_PARAMETER;
863 	}
864 
865 	switch (parity & 0xF0) {
866 	case IUU_ONE_STOP_BIT:
867 		dataout[DataCount - 1] |= IUU_ONE_STOP_BIT;
868 		break;
869 
870 	case IUU_TWO_STOP_BITS:
871 		dataout[DataCount - 1] |= IUU_TWO_STOP_BITS;
872 		break;
873 	default:
874 		kfree(dataout);
875 		return IUU_INVALID_PARAMETER;
876 	}
877 
878 	status = bulk_immediate(port, dataout, DataCount);
879 	if (status != IUU_OPERATION_OK)
880 		dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
881 	kfree(dataout);
882 	return status;
883 }
884 
885 static void iuu_set_termios(struct tty_struct *tty,
886 		struct usb_serial_port *port, struct ktermios *old_termios)
887 {
888 	const u32 supported_mask = CMSPAR|PARENB|PARODD;
889 	struct iuu_private *priv = usb_get_serial_port_data(port);
890 	unsigned int cflag = tty->termios.c_cflag;
891 	int status;
892 	u32 actual;
893 	u32 parity;
894 	int csize = CS7;
895 	int baud;
896 	u32 newval = cflag & supported_mask;
897 
898 	/* Just use the ospeed. ispeed should be the same. */
899 	baud = tty->termios.c_ospeed;
900 
901 	dev_dbg(&port->dev, "%s - enter c_ospeed or baud=%d\n", __func__, baud);
902 
903 	/* compute the parity parameter */
904 	parity = 0;
905 	if (cflag & CMSPAR) {	/* Using mark space */
906 		if (cflag & PARODD)
907 			parity |= IUU_PARITY_SPACE;
908 		else
909 			parity |= IUU_PARITY_MARK;
910 	} else if (!(cflag & PARENB)) {
911 		parity |= IUU_PARITY_NONE;
912 		csize = CS8;
913 	} else if (cflag & PARODD)
914 		parity |= IUU_PARITY_ODD;
915 	else
916 		parity |= IUU_PARITY_EVEN;
917 
918 	parity |= (cflag & CSTOPB ? IUU_TWO_STOP_BITS : IUU_ONE_STOP_BIT);
919 
920 	/* set it */
921 	status = iuu_uart_baud(port,
922 			baud * priv->boost / 100,
923 			&actual, parity);
924 
925 	/* set the termios value to the real one, so the user now what has
926 	 * changed. We support few fields so its easies to copy the old hw
927 	 * settings back over and then adjust them
928 	 */
929 	if (old_termios)
930 		tty_termios_copy_hw(&tty->termios, old_termios);
931 	if (status != 0)	/* Set failed - return old bits */
932 		return;
933 	/* Re-encode speed, parity and csize */
934 	tty_encode_baud_rate(tty, baud, baud);
935 	tty->termios.c_cflag &= ~(supported_mask|CSIZE);
936 	tty->termios.c_cflag |= newval | csize;
937 }
938 
939 static void iuu_close(struct usb_serial_port *port)
940 {
941 	/* iuu_led (port,255,0,0,0); */
942 
943 	iuu_uart_off(port);
944 
945 	usb_kill_urb(port->write_urb);
946 	usb_kill_urb(port->read_urb);
947 
948 	iuu_led(port, 0, 0, 0xF000, 0xFF);
949 }
950 
951 static void iuu_init_termios(struct tty_struct *tty)
952 {
953 	tty->termios.c_cflag = B9600 | CS8 | CSTOPB | CREAD | PARENB | CLOCAL;
954 	tty->termios.c_ispeed = 9600;
955 	tty->termios.c_ospeed = 9600;
956 	tty->termios.c_lflag = 0;
957 	tty->termios.c_oflag = 0;
958 	tty->termios.c_iflag = 0;
959 }
960 
961 static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
962 {
963 	struct usb_serial *serial = port->serial;
964 	struct device *dev = &port->dev;
965 	int result;
966 	int baud;
967 	u32 actual;
968 	struct iuu_private *priv = usb_get_serial_port_data(port);
969 
970 	baud = tty->termios.c_ospeed;
971 
972 	dev_dbg(dev, "%s - baud %d\n", __func__, baud);
973 	usb_clear_halt(serial->dev, port->write_urb->pipe);
974 	usb_clear_halt(serial->dev, port->read_urb->pipe);
975 
976 	priv->poll = 0;
977 
978 #define SOUP(a, b, c, d)  do { \
979 	result = usb_control_msg(port->serial->dev,	\
980 				usb_sndctrlpipe(port->serial->dev, 0),	\
981 				b, a, c, d, NULL, 0, 1000); \
982 	dev_dbg(dev, "0x%x:0x%x:0x%x:0x%x  %d\n", a, b, c, d, result); } while (0)
983 
984 	/*  This is not UART related but IUU USB driver related or something */
985 	/*  like that. Basically no IUU will accept any commands from the USB */
986 	/*  host unless it has received the following message */
987 	/* sprintf(buf ,"%c%c%c%c",0x03,0x02,0x02,0x0); */
988 
989 	SOUP(0x03, 0x02, 0x02, 0x0);
990 
991 	iuu_led(port, 0xF000, 0xF000, 0, 0xFF);
992 	iuu_uart_on(port);
993 	if (boost < 100)
994 		boost = 100;
995 	priv->boost = boost;
996 	switch (clockmode) {
997 	case 2:		/*  3.680 Mhz */
998 		priv->clk = IUU_CLK_3680000;
999 		iuu_clk(port, IUU_CLK_3680000 * boost / 100);
1000 		result =
1001 		    iuu_uart_baud(port, baud * boost / 100, &actual,
1002 				  IUU_PARITY_EVEN);
1003 		break;
1004 	case 3:		/*  6.00 Mhz */
1005 		iuu_clk(port, IUU_CLK_6000000 * boost / 100);
1006 		priv->clk = IUU_CLK_6000000;
1007 		/* Ratio of 6000000 to 3500000 for baud 9600 */
1008 		result =
1009 		    iuu_uart_baud(port, 16457 * boost / 100, &actual,
1010 				  IUU_PARITY_EVEN);
1011 		break;
1012 	default:		/*  3.579 Mhz */
1013 		iuu_clk(port, IUU_CLK_3579000 * boost / 100);
1014 		priv->clk = IUU_CLK_3579000;
1015 		result =
1016 		    iuu_uart_baud(port, baud * boost / 100, &actual,
1017 				  IUU_PARITY_EVEN);
1018 	}
1019 
1020 	/* set the cardin cardout signals */
1021 	switch (cdmode) {
1022 	case 0:
1023 		iuu_cardin = 0;
1024 		iuu_cardout = 0;
1025 		break;
1026 	case 1:
1027 		iuu_cardin = TIOCM_CD;
1028 		iuu_cardout =  0;
1029 		break;
1030 	case 2:
1031 		iuu_cardin = 0;
1032 		iuu_cardout = TIOCM_CD;
1033 		break;
1034 	case 3:
1035 		iuu_cardin = TIOCM_DSR;
1036 		iuu_cardout = 0;
1037 		break;
1038 	case 4:
1039 		iuu_cardin = 0;
1040 		iuu_cardout = TIOCM_DSR;
1041 		break;
1042 	case 5:
1043 		iuu_cardin = TIOCM_CTS;
1044 		iuu_cardout = 0;
1045 		break;
1046 	case 6:
1047 		iuu_cardin = 0;
1048 		iuu_cardout = TIOCM_CTS;
1049 		break;
1050 	case 7:
1051 		iuu_cardin = TIOCM_RNG;
1052 		iuu_cardout = 0;
1053 		break;
1054 	case 8:
1055 		iuu_cardin = 0;
1056 		iuu_cardout = TIOCM_RNG;
1057 	}
1058 
1059 	iuu_uart_flush(port);
1060 
1061 	dev_dbg(dev, "%s - initialization done\n", __func__);
1062 
1063 	memset(port->write_urb->transfer_buffer, IUU_UART_RX, 1);
1064 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1065 			  usb_sndbulkpipe(port->serial->dev,
1066 					  port->bulk_out_endpointAddress),
1067 			  port->write_urb->transfer_buffer, 1,
1068 			  read_rxcmd_callback, port);
1069 	result = usb_submit_urb(port->write_urb, GFP_KERNEL);
1070 	if (result) {
1071 		dev_err(dev, "%s - failed submitting read urb, error %d\n", __func__, result);
1072 		iuu_close(port);
1073 	} else {
1074 		dev_dbg(dev, "%s - rxcmd OK\n", __func__);
1075 	}
1076 
1077 	return result;
1078 }
1079 
1080 /* how to change VCC */
1081 static int iuu_vcc_set(struct usb_serial_port *port, unsigned int vcc)
1082 {
1083 	int status;
1084 	u8 *buf;
1085 
1086 	buf = kmalloc(5, GFP_KERNEL);
1087 	if (!buf)
1088 		return -ENOMEM;
1089 
1090 	buf[0] = IUU_SET_VCC;
1091 	buf[1] = vcc & 0xFF;
1092 	buf[2] = (vcc >> 8) & 0xFF;
1093 	buf[3] = (vcc >> 16) & 0xFF;
1094 	buf[4] = (vcc >> 24) & 0xFF;
1095 
1096 	status = bulk_immediate(port, buf, 5);
1097 	kfree(buf);
1098 
1099 	if (status != IUU_OPERATION_OK)
1100 		dev_dbg(&port->dev, "%s - vcc error status = %2x\n", __func__, status);
1101 	else
1102 		dev_dbg(&port->dev, "%s - vcc OK !\n", __func__);
1103 
1104 	return status;
1105 }
1106 
1107 /*
1108  * Sysfs Attributes
1109  */
1110 
1111 static ssize_t vcc_mode_show(struct device *dev,
1112 	struct device_attribute *attr, char *buf)
1113 {
1114 	struct usb_serial_port *port = to_usb_serial_port(dev);
1115 	struct iuu_private *priv = usb_get_serial_port_data(port);
1116 
1117 	return sprintf(buf, "%d\n", priv->vcc);
1118 }
1119 
1120 static ssize_t vcc_mode_store(struct device *dev,
1121 	struct device_attribute *attr, const char *buf, size_t count)
1122 {
1123 	struct usb_serial_port *port = to_usb_serial_port(dev);
1124 	struct iuu_private *priv = usb_get_serial_port_data(port);
1125 	unsigned long v;
1126 
1127 	if (kstrtoul(buf, 10, &v)) {
1128 		dev_err(dev, "%s - vcc_mode: %s is not a unsigned long\n",
1129 				__func__, buf);
1130 		goto fail_store_vcc_mode;
1131 	}
1132 
1133 	dev_dbg(dev, "%s: setting vcc_mode = %ld\n", __func__, v);
1134 
1135 	if ((v != 3) && (v != 5)) {
1136 		dev_err(dev, "%s - vcc_mode %ld is invalid\n", __func__, v);
1137 	} else {
1138 		iuu_vcc_set(port, v);
1139 		priv->vcc = v;
1140 	}
1141 fail_store_vcc_mode:
1142 	return count;
1143 }
1144 static DEVICE_ATTR_RW(vcc_mode);
1145 
1146 static int iuu_create_sysfs_attrs(struct usb_serial_port *port)
1147 {
1148 	return device_create_file(&port->dev, &dev_attr_vcc_mode);
1149 }
1150 
1151 static int iuu_remove_sysfs_attrs(struct usb_serial_port *port)
1152 {
1153 	device_remove_file(&port->dev, &dev_attr_vcc_mode);
1154 	return 0;
1155 }
1156 
1157 /*
1158  * End Sysfs Attributes
1159  */
1160 
1161 static struct usb_serial_driver iuu_device = {
1162 	.driver = {
1163 		   .owner = THIS_MODULE,
1164 		   .name = "iuu_phoenix",
1165 		   },
1166 	.id_table = id_table,
1167 	.num_ports = 1,
1168 	.num_bulk_in = 1,
1169 	.num_bulk_out = 1,
1170 	.bulk_in_size = 512,
1171 	.bulk_out_size = 512,
1172 	.open = iuu_open,
1173 	.close = iuu_close,
1174 	.write = iuu_uart_write,
1175 	.read_bulk_callback = iuu_uart_read_callback,
1176 	.tiocmget = iuu_tiocmget,
1177 	.tiocmset = iuu_tiocmset,
1178 	.set_termios = iuu_set_termios,
1179 	.init_termios = iuu_init_termios,
1180 	.port_probe = iuu_port_probe,
1181 	.port_remove = iuu_port_remove,
1182 };
1183 
1184 static struct usb_serial_driver * const serial_drivers[] = {
1185 	&iuu_device, NULL
1186 };
1187 
1188 module_usb_serial_driver(serial_drivers, id_table);
1189 
1190 MODULE_AUTHOR("Alain Degreffe eczema@ecze.com");
1191 
1192 MODULE_DESCRIPTION(DRIVER_DESC);
1193 MODULE_LICENSE("GPL");
1194 
1195 module_param(xmas, bool, S_IRUGO | S_IWUSR);
1196 MODULE_PARM_DESC(xmas, "Xmas colors enabled or not");
1197 
1198 module_param(boost, int, S_IRUGO | S_IWUSR);
1199 MODULE_PARM_DESC(boost, "Card overclock boost (in percent 100-500)");
1200 
1201 module_param(clockmode, int, S_IRUGO | S_IWUSR);
1202 MODULE_PARM_DESC(clockmode, "Card clock mode (1=3.579 MHz, 2=3.680 MHz, "
1203 		"3=6 Mhz)");
1204 
1205 module_param(cdmode, int, S_IRUGO | S_IWUSR);
1206 MODULE_PARM_DESC(cdmode, "Card detect mode (0=none, 1=CD, 2=!CD, 3=DSR, "
1207 		 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING)");
1208 
1209 module_param(vcc_default, int, S_IRUGO | S_IWUSR);
1210 MODULE_PARM_DESC(vcc_default, "Set default VCC (either 3 for 3.3V or 5 "
1211 		"for 5V). Default to 5.");
1212