xref: /openbmc/linux/drivers/usb/serial/iuu_phoenix.c (revision b159eecc)
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 = IUU_UART_RX;
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 	for (i = 0; i < 2; i++) {
542 		status = bulk_immediate(port, &rxcmd, 1);
543 		if (status != IUU_OPERATION_OK) {
544 			dev_dbg(dev, "%s - uart_flush_write error\n", __func__);
545 			return status;
546 		}
547 
548 		status = read_immediate(port, &priv->len, 1);
549 		if (status != IUU_OPERATION_OK) {
550 			dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
551 			return status;
552 		}
553 
554 		if (priv->len > 0) {
555 			dev_dbg(dev, "%s - uart_flush datalen is : %i\n", __func__, priv->len);
556 			status = read_immediate(port, priv->buf, priv->len);
557 			if (status != IUU_OPERATION_OK) {
558 				dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
559 				return status;
560 			}
561 		}
562 	}
563 	dev_dbg(dev, "%s - uart_flush_read OK!\n", __func__);
564 	iuu_led(port, 0, 0xF000, 0, 0xFF);
565 	return status;
566 }
567 
568 static void read_buf_callback(struct urb *urb)
569 {
570 	struct usb_serial_port *port = urb->context;
571 	unsigned char *data = urb->transfer_buffer;
572 	int status = urb->status;
573 
574 	if (status) {
575 		if (status == -EPROTO) {
576 			/* reschedule needed */
577 		}
578 		return;
579 	}
580 
581 	dev_dbg(&port->dev, "%s - %i chars to write\n", __func__, urb->actual_length);
582 
583 	if (urb->actual_length) {
584 		tty_insert_flip_string(&port->port, data, urb->actual_length);
585 		tty_flip_buffer_push(&port->port);
586 	}
587 	iuu_led_activity_on(urb);
588 }
589 
590 static int iuu_bulk_write(struct usb_serial_port *port)
591 {
592 	struct iuu_private *priv = usb_get_serial_port_data(port);
593 	unsigned long flags;
594 	int result;
595 	int buf_len;
596 	char *buf_ptr = port->write_urb->transfer_buffer;
597 
598 	spin_lock_irqsave(&priv->lock, flags);
599 	*buf_ptr++ = IUU_UART_ESC;
600 	*buf_ptr++ = IUU_UART_TX;
601 	*buf_ptr++ = priv->writelen;
602 
603 	memcpy(buf_ptr, priv->writebuf, priv->writelen);
604 	buf_len = priv->writelen;
605 	priv->writelen = 0;
606 	spin_unlock_irqrestore(&priv->lock, flags);
607 	dev_dbg(&port->dev, "%s - writing %i chars : %*ph\n", __func__,
608 		buf_len, buf_len, buf_ptr);
609 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
610 			  usb_sndbulkpipe(port->serial->dev,
611 					  port->bulk_out_endpointAddress),
612 			  port->write_urb->transfer_buffer, buf_len + 3,
613 			  iuu_rxcmd, port);
614 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
615 	usb_serial_port_softint(port);
616 	return result;
617 }
618 
619 static int iuu_read_buf(struct usb_serial_port *port, int len)
620 {
621 	int result;
622 
623 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
624 			  usb_rcvbulkpipe(port->serial->dev,
625 					  port->bulk_in_endpointAddress),
626 			  port->read_urb->transfer_buffer, len,
627 			  read_buf_callback, port);
628 	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
629 	return result;
630 }
631 
632 static void iuu_uart_read_callback(struct urb *urb)
633 {
634 	struct usb_serial_port *port = urb->context;
635 	struct iuu_private *priv = usb_get_serial_port_data(port);
636 	unsigned long flags;
637 	int status = urb->status;
638 	int error = 0;
639 	int len = 0;
640 	unsigned char *data = urb->transfer_buffer;
641 	priv->poll++;
642 
643 	if (status) {
644 		dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
645 		/* error stop all */
646 		return;
647 	}
648 
649 	if (urb->actual_length == 1)
650 		len = (int) data[0];
651 
652 	if (urb->actual_length > 1) {
653 		dev_dbg(&port->dev, "%s - urb->actual_length = %i\n", __func__,
654 		    urb->actual_length);
655 		error = 1;
656 		return;
657 	}
658 	/* if len > 0 call readbuf */
659 
660 	if (len > 0 && error == 0) {
661 		dev_dbg(&port->dev, "%s - call read buf - len to read is %i\n",
662 			__func__, len);
663 		status = iuu_read_buf(port, len);
664 		return;
665 	}
666 	/* need to update status  ? */
667 	if (priv->poll > 99) {
668 		status = iuu_status(port);
669 		priv->poll = 0;
670 		return;
671 	}
672 
673 	/* reset waiting ? */
674 
675 	if (priv->reset == 1) {
676 		status = iuu_reset(port, 0xC);
677 		return;
678 	}
679 	/* Writebuf is waiting */
680 	spin_lock_irqsave(&priv->lock, flags);
681 	if (priv->writelen > 0) {
682 		spin_unlock_irqrestore(&priv->lock, flags);
683 		status = iuu_bulk_write(port);
684 		return;
685 	}
686 	spin_unlock_irqrestore(&priv->lock, flags);
687 	/* if nothing to write call again rxcmd */
688 	dev_dbg(&port->dev, "%s - rxcmd recall\n", __func__);
689 	iuu_led_activity_off(urb);
690 }
691 
692 static int iuu_uart_write(struct tty_struct *tty, struct usb_serial_port *port,
693 			  const u8 *buf, int count)
694 {
695 	struct iuu_private *priv = usb_get_serial_port_data(port);
696 	unsigned long flags;
697 
698 	spin_lock_irqsave(&priv->lock, flags);
699 
700 	count = min(count, 256 - priv->writelen);
701 	if (count == 0)
702 		goto out;
703 
704 	/* fill the buffer */
705 	memcpy(priv->writebuf + priv->writelen, buf, count);
706 	priv->writelen += count;
707 out:
708 	spin_unlock_irqrestore(&priv->lock, flags);
709 
710 	return count;
711 }
712 
713 static void read_rxcmd_callback(struct urb *urb)
714 {
715 	struct usb_serial_port *port = urb->context;
716 	int result;
717 	int status = urb->status;
718 
719 	if (status) {
720 		/* error stop all */
721 		return;
722 	}
723 
724 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
725 			  usb_rcvbulkpipe(port->serial->dev,
726 					  port->bulk_in_endpointAddress),
727 			  port->read_urb->transfer_buffer, 256,
728 			  iuu_uart_read_callback, port);
729 	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
730 	dev_dbg(&port->dev, "%s - submit result = %d\n", __func__, result);
731 }
732 
733 static int iuu_uart_on(struct usb_serial_port *port)
734 {
735 	int status;
736 	u8 *buf;
737 
738 	buf = kmalloc(4, GFP_KERNEL);
739 
740 	if (!buf)
741 		return -ENOMEM;
742 
743 	buf[0] = IUU_UART_ENABLE;
744 	buf[1] = (u8) ((IUU_BAUD_9600 >> 8) & 0x00FF);
745 	buf[2] = (u8) (0x00FF & IUU_BAUD_9600);
746 	buf[3] = (u8) (0x0F0 & IUU_ONE_STOP_BIT) | (0x07 & IUU_PARITY_EVEN);
747 
748 	status = bulk_immediate(port, buf, 4);
749 	if (status != IUU_OPERATION_OK) {
750 		dev_dbg(&port->dev, "%s - uart_on error\n", __func__);
751 		goto uart_enable_failed;
752 	}
753 	/*  iuu_reset() the card after iuu_uart_on() */
754 	status = iuu_uart_flush(port);
755 	if (status != IUU_OPERATION_OK)
756 		dev_dbg(&port->dev, "%s - uart_flush error\n", __func__);
757 uart_enable_failed:
758 	kfree(buf);
759 	return status;
760 }
761 
762 /*  Disables the IUU UART (a.k.a. the Phoenix voiderface) */
763 static int iuu_uart_off(struct usb_serial_port *port)
764 {
765 	int status;
766 	u8 *buf;
767 	buf = kmalloc(1, GFP_KERNEL);
768 	if (!buf)
769 		return -ENOMEM;
770 	buf[0] = IUU_UART_DISABLE;
771 
772 	status = bulk_immediate(port, buf, 1);
773 	if (status != IUU_OPERATION_OK)
774 		dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
775 
776 	kfree(buf);
777 	return status;
778 }
779 
780 static int iuu_uart_baud(struct usb_serial_port *port, u32 baud_base,
781 			 u32 *actual, u8 parity)
782 {
783 	int status;
784 	u32 baud;
785 	u8 *dataout;
786 	u8 DataCount = 0;
787 	u8 T1Frekvens = 0;
788 	u8 T1reload = 0;
789 	unsigned int T1FrekvensHZ = 0;
790 
791 	dev_dbg(&port->dev, "%s - enter baud_base=%d\n", __func__, baud_base);
792 	dataout = kmalloc(5, GFP_KERNEL);
793 
794 	if (!dataout)
795 		return -ENOMEM;
796 	/*baud = (((priv->clk / 35) * baud_base) / 100000); */
797 	baud = baud_base;
798 
799 	if (baud < 1200 || baud > 230400) {
800 		kfree(dataout);
801 		return IUU_INVALID_PARAMETER;
802 	}
803 	if (baud > 977) {
804 		T1Frekvens = 3;
805 		T1FrekvensHZ = 500000;
806 	}
807 
808 	if (baud > 3906) {
809 		T1Frekvens = 2;
810 		T1FrekvensHZ = 2000000;
811 	}
812 
813 	if (baud > 11718) {
814 		T1Frekvens = 1;
815 		T1FrekvensHZ = 6000000;
816 	}
817 
818 	if (baud > 46875) {
819 		T1Frekvens = 0;
820 		T1FrekvensHZ = 24000000;
821 	}
822 
823 	T1reload = 256 - (u8) (T1FrekvensHZ / (baud * 2));
824 
825 	/*  magic number here:  ENTER_FIRMWARE_UPDATE; */
826 	dataout[DataCount++] = IUU_UART_ESC;
827 	/*  magic number here:  CHANGE_BAUD; */
828 	dataout[DataCount++] = IUU_UART_CHANGE;
829 	dataout[DataCount++] = T1Frekvens;
830 	dataout[DataCount++] = T1reload;
831 
832 	*actual = (T1FrekvensHZ / (256 - T1reload)) / 2;
833 
834 	switch (parity & 0x0F) {
835 	case IUU_PARITY_NONE:
836 		dataout[DataCount++] = 0x00;
837 		break;
838 	case IUU_PARITY_EVEN:
839 		dataout[DataCount++] = 0x01;
840 		break;
841 	case IUU_PARITY_ODD:
842 		dataout[DataCount++] = 0x02;
843 		break;
844 	case IUU_PARITY_MARK:
845 		dataout[DataCount++] = 0x03;
846 		break;
847 	case IUU_PARITY_SPACE:
848 		dataout[DataCount++] = 0x04;
849 		break;
850 	default:
851 		kfree(dataout);
852 		return IUU_INVALID_PARAMETER;
853 		break;
854 	}
855 
856 	switch (parity & 0xF0) {
857 	case IUU_ONE_STOP_BIT:
858 		dataout[DataCount - 1] |= IUU_ONE_STOP_BIT;
859 		break;
860 
861 	case IUU_TWO_STOP_BITS:
862 		dataout[DataCount - 1] |= IUU_TWO_STOP_BITS;
863 		break;
864 	default:
865 		kfree(dataout);
866 		return IUU_INVALID_PARAMETER;
867 		break;
868 	}
869 
870 	status = bulk_immediate(port, dataout, DataCount);
871 	if (status != IUU_OPERATION_OK)
872 		dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
873 	kfree(dataout);
874 	return status;
875 }
876 
877 static void iuu_set_termios(struct tty_struct *tty,
878 		struct usb_serial_port *port, struct ktermios *old_termios)
879 {
880 	const u32 supported_mask = CMSPAR|PARENB|PARODD;
881 	struct iuu_private *priv = usb_get_serial_port_data(port);
882 	unsigned int cflag = tty->termios.c_cflag;
883 	int status;
884 	u32 actual;
885 	u32 parity;
886 	int csize = CS7;
887 	int baud;
888 	u32 newval = cflag & supported_mask;
889 
890 	/* Just use the ospeed. ispeed should be the same. */
891 	baud = tty->termios.c_ospeed;
892 
893 	dev_dbg(&port->dev, "%s - enter c_ospeed or baud=%d\n", __func__, baud);
894 
895 	/* compute the parity parameter */
896 	parity = 0;
897 	if (cflag & CMSPAR) {	/* Using mark space */
898 		if (cflag & PARODD)
899 			parity |= IUU_PARITY_SPACE;
900 		else
901 			parity |= IUU_PARITY_MARK;
902 	} else if (!(cflag & PARENB)) {
903 		parity |= IUU_PARITY_NONE;
904 		csize = CS8;
905 	} else if (cflag & PARODD)
906 		parity |= IUU_PARITY_ODD;
907 	else
908 		parity |= IUU_PARITY_EVEN;
909 
910 	parity |= (cflag & CSTOPB ? IUU_TWO_STOP_BITS : IUU_ONE_STOP_BIT);
911 
912 	/* set it */
913 	status = iuu_uart_baud(port,
914 			baud * priv->boost / 100,
915 			&actual, parity);
916 
917 	/* set the termios value to the real one, so the user now what has
918 	 * changed. We support few fields so its easies to copy the old hw
919 	 * settings back over and then adjust them
920 	 */
921 	if (old_termios)
922 		tty_termios_copy_hw(&tty->termios, old_termios);
923 	if (status != 0)	/* Set failed - return old bits */
924 		return;
925 	/* Re-encode speed, parity and csize */
926 	tty_encode_baud_rate(tty, baud, baud);
927 	tty->termios.c_cflag &= ~(supported_mask|CSIZE);
928 	tty->termios.c_cflag |= newval | csize;
929 }
930 
931 static void iuu_close(struct usb_serial_port *port)
932 {
933 	/* iuu_led (port,255,0,0,0); */
934 
935 	iuu_uart_off(port);
936 
937 	usb_kill_urb(port->write_urb);
938 	usb_kill_urb(port->read_urb);
939 
940 	iuu_led(port, 0, 0, 0xF000, 0xFF);
941 }
942 
943 static void iuu_init_termios(struct tty_struct *tty)
944 {
945 	tty->termios.c_cflag = B9600 | CS8 | CSTOPB | CREAD | PARENB | CLOCAL;
946 	tty->termios.c_ispeed = 9600;
947 	tty->termios.c_ospeed = 9600;
948 	tty->termios.c_lflag = 0;
949 	tty->termios.c_oflag = 0;
950 	tty->termios.c_iflag = 0;
951 }
952 
953 static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
954 {
955 	struct usb_serial *serial = port->serial;
956 	struct device *dev = &port->dev;
957 	int result;
958 	int baud;
959 	u32 actual;
960 	struct iuu_private *priv = usb_get_serial_port_data(port);
961 
962 	baud = tty->termios.c_ospeed;
963 
964 	dev_dbg(dev, "%s - baud %d\n", __func__, baud);
965 	usb_clear_halt(serial->dev, port->write_urb->pipe);
966 	usb_clear_halt(serial->dev, port->read_urb->pipe);
967 
968 	priv->poll = 0;
969 
970 #define SOUP(a, b, c, d)  do { \
971 	result = usb_control_msg(port->serial->dev,	\
972 				usb_sndctrlpipe(port->serial->dev, 0),	\
973 				b, a, c, d, NULL, 0, 1000); \
974 	dev_dbg(dev, "0x%x:0x%x:0x%x:0x%x  %d\n", a, b, c, d, result); } while (0)
975 
976 	/*  This is not UART related but IUU USB driver related or something */
977 	/*  like that. Basically no IUU will accept any commands from the USB */
978 	/*  host unless it has received the following message */
979 	/* sprintf(buf ,"%c%c%c%c",0x03,0x02,0x02,0x0); */
980 
981 	SOUP(0x03, 0x02, 0x02, 0x0);
982 
983 	iuu_led(port, 0xF000, 0xF000, 0, 0xFF);
984 	iuu_uart_on(port);
985 	if (boost < 100)
986 		boost = 100;
987 	priv->boost = boost;
988 	switch (clockmode) {
989 	case 2:		/*  3.680 Mhz */
990 		priv->clk = IUU_CLK_3680000;
991 		iuu_clk(port, IUU_CLK_3680000 * boost / 100);
992 		result =
993 		    iuu_uart_baud(port, baud * boost / 100, &actual,
994 				  IUU_PARITY_EVEN);
995 		break;
996 	case 3:		/*  6.00 Mhz */
997 		iuu_clk(port, IUU_CLK_6000000 * boost / 100);
998 		priv->clk = IUU_CLK_6000000;
999 		/* Ratio of 6000000 to 3500000 for baud 9600 */
1000 		result =
1001 		    iuu_uart_baud(port, 16457 * boost / 100, &actual,
1002 				  IUU_PARITY_EVEN);
1003 		break;
1004 	default:		/*  3.579 Mhz */
1005 		iuu_clk(port, IUU_CLK_3579000 * boost / 100);
1006 		priv->clk = IUU_CLK_3579000;
1007 		result =
1008 		    iuu_uart_baud(port, baud * boost / 100, &actual,
1009 				  IUU_PARITY_EVEN);
1010 	}
1011 
1012 	/* set the cardin cardout signals */
1013 	switch (cdmode) {
1014 	case 0:
1015 		iuu_cardin = 0;
1016 		iuu_cardout = 0;
1017 		break;
1018 	case 1:
1019 		iuu_cardin = TIOCM_CD;
1020 		iuu_cardout =  0;
1021 		break;
1022 	case 2:
1023 		iuu_cardin = 0;
1024 		iuu_cardout = TIOCM_CD;
1025 		break;
1026 	case 3:
1027 		iuu_cardin = TIOCM_DSR;
1028 		iuu_cardout = 0;
1029 		break;
1030 	case 4:
1031 		iuu_cardin = 0;
1032 		iuu_cardout = TIOCM_DSR;
1033 		break;
1034 	case 5:
1035 		iuu_cardin = TIOCM_CTS;
1036 		iuu_cardout = 0;
1037 		break;
1038 	case 6:
1039 		iuu_cardin = 0;
1040 		iuu_cardout = TIOCM_CTS;
1041 		break;
1042 	case 7:
1043 		iuu_cardin = TIOCM_RNG;
1044 		iuu_cardout = 0;
1045 		break;
1046 	case 8:
1047 		iuu_cardin = 0;
1048 		iuu_cardout = TIOCM_RNG;
1049 	}
1050 
1051 	iuu_uart_flush(port);
1052 
1053 	dev_dbg(dev, "%s - initialization done\n", __func__);
1054 
1055 	memset(port->write_urb->transfer_buffer, IUU_UART_RX, 1);
1056 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1057 			  usb_sndbulkpipe(port->serial->dev,
1058 					  port->bulk_out_endpointAddress),
1059 			  port->write_urb->transfer_buffer, 1,
1060 			  read_rxcmd_callback, port);
1061 	result = usb_submit_urb(port->write_urb, GFP_KERNEL);
1062 	if (result) {
1063 		dev_err(dev, "%s - failed submitting read urb, error %d\n", __func__, result);
1064 		iuu_close(port);
1065 	} else {
1066 		dev_dbg(dev, "%s - rxcmd OK\n", __func__);
1067 	}
1068 
1069 	return result;
1070 }
1071 
1072 /* how to change VCC */
1073 static int iuu_vcc_set(struct usb_serial_port *port, unsigned int vcc)
1074 {
1075 	int status;
1076 	u8 *buf;
1077 
1078 	buf = kmalloc(5, GFP_KERNEL);
1079 	if (!buf)
1080 		return -ENOMEM;
1081 
1082 	buf[0] = IUU_SET_VCC;
1083 	buf[1] = vcc & 0xFF;
1084 	buf[2] = (vcc >> 8) & 0xFF;
1085 	buf[3] = (vcc >> 16) & 0xFF;
1086 	buf[4] = (vcc >> 24) & 0xFF;
1087 
1088 	status = bulk_immediate(port, buf, 5);
1089 	kfree(buf);
1090 
1091 	if (status != IUU_OPERATION_OK)
1092 		dev_dbg(&port->dev, "%s - vcc error status = %2x\n", __func__, status);
1093 	else
1094 		dev_dbg(&port->dev, "%s - vcc OK !\n", __func__);
1095 
1096 	return status;
1097 }
1098 
1099 /*
1100  * Sysfs Attributes
1101  */
1102 
1103 static ssize_t vcc_mode_show(struct device *dev,
1104 	struct device_attribute *attr, char *buf)
1105 {
1106 	struct usb_serial_port *port = to_usb_serial_port(dev);
1107 	struct iuu_private *priv = usb_get_serial_port_data(port);
1108 
1109 	return sprintf(buf, "%d\n", priv->vcc);
1110 }
1111 
1112 static ssize_t vcc_mode_store(struct device *dev,
1113 	struct device_attribute *attr, const char *buf, size_t count)
1114 {
1115 	struct usb_serial_port *port = to_usb_serial_port(dev);
1116 	struct iuu_private *priv = usb_get_serial_port_data(port);
1117 	unsigned long v;
1118 
1119 	if (kstrtoul(buf, 10, &v)) {
1120 		dev_err(dev, "%s - vcc_mode: %s is not a unsigned long\n",
1121 				__func__, buf);
1122 		goto fail_store_vcc_mode;
1123 	}
1124 
1125 	dev_dbg(dev, "%s: setting vcc_mode = %ld\n", __func__, v);
1126 
1127 	if ((v != 3) && (v != 5)) {
1128 		dev_err(dev, "%s - vcc_mode %ld is invalid\n", __func__, v);
1129 	} else {
1130 		iuu_vcc_set(port, v);
1131 		priv->vcc = v;
1132 	}
1133 fail_store_vcc_mode:
1134 	return count;
1135 }
1136 static DEVICE_ATTR_RW(vcc_mode);
1137 
1138 static int iuu_create_sysfs_attrs(struct usb_serial_port *port)
1139 {
1140 	return device_create_file(&port->dev, &dev_attr_vcc_mode);
1141 }
1142 
1143 static int iuu_remove_sysfs_attrs(struct usb_serial_port *port)
1144 {
1145 	device_remove_file(&port->dev, &dev_attr_vcc_mode);
1146 	return 0;
1147 }
1148 
1149 /*
1150  * End Sysfs Attributes
1151  */
1152 
1153 static struct usb_serial_driver iuu_device = {
1154 	.driver = {
1155 		   .owner = THIS_MODULE,
1156 		   .name = "iuu_phoenix",
1157 		   },
1158 	.id_table = id_table,
1159 	.num_ports = 1,
1160 	.num_bulk_in = 1,
1161 	.num_bulk_out = 1,
1162 	.bulk_in_size = 512,
1163 	.bulk_out_size = 512,
1164 	.open = iuu_open,
1165 	.close = iuu_close,
1166 	.write = iuu_uart_write,
1167 	.read_bulk_callback = iuu_uart_read_callback,
1168 	.tiocmget = iuu_tiocmget,
1169 	.tiocmset = iuu_tiocmset,
1170 	.set_termios = iuu_set_termios,
1171 	.init_termios = iuu_init_termios,
1172 	.port_probe = iuu_port_probe,
1173 	.port_remove = iuu_port_remove,
1174 };
1175 
1176 static struct usb_serial_driver * const serial_drivers[] = {
1177 	&iuu_device, NULL
1178 };
1179 
1180 module_usb_serial_driver(serial_drivers, id_table);
1181 
1182 MODULE_AUTHOR("Alain Degreffe eczema@ecze.com");
1183 
1184 MODULE_DESCRIPTION(DRIVER_DESC);
1185 MODULE_LICENSE("GPL");
1186 
1187 module_param(xmas, bool, S_IRUGO | S_IWUSR);
1188 MODULE_PARM_DESC(xmas, "Xmas colors enabled or not");
1189 
1190 module_param(boost, int, S_IRUGO | S_IWUSR);
1191 MODULE_PARM_DESC(boost, "Card overclock boost (in percent 100-500)");
1192 
1193 module_param(clockmode, int, S_IRUGO | S_IWUSR);
1194 MODULE_PARM_DESC(clockmode, "Card clock mode (1=3.579 MHz, 2=3.680 MHz, "
1195 		"3=6 Mhz)");
1196 
1197 module_param(cdmode, int, S_IRUGO | S_IWUSR);
1198 MODULE_PARM_DESC(cdmode, "Card detect mode (0=none, 1=CD, 2=!CD, 3=DSR, "
1199 		 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING)");
1200 
1201 module_param(vcc_default, int, S_IRUGO | S_IWUSR);
1202 MODULE_PARM_DESC(vcc_default, "Set default VCC (either 3 for 3.3V or 5 "
1203 		"for 5V). Default to 5.");
1204