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