iuu_phoenix.c 30 KB

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