dtl1_cs.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613
  1. /*
  2. *
  3. * A driver for Nokia Connectivity Card DTL-1 devices
  4. *
  5. * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
  6. *
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation;
  11. *
  12. * Software distributed under the License is distributed on an "AS
  13. * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14. * implied. See the License for the specific language governing
  15. * rights and limitations under the License.
  16. *
  17. * The initial developer of the original code is David A. Hinds
  18. * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
  19. * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
  20. *
  21. */
  22. #include <linux/module.h>
  23. #include <linux/kernel.h>
  24. #include <linux/init.h>
  25. #include <linux/slab.h>
  26. #include <linux/types.h>
  27. #include <linux/delay.h>
  28. #include <linux/errno.h>
  29. #include <linux/ptrace.h>
  30. #include <linux/ioport.h>
  31. #include <linux/spinlock.h>
  32. #include <linux/moduleparam.h>
  33. #include <linux/skbuff.h>
  34. #include <linux/string.h>
  35. #include <linux/serial.h>
  36. #include <linux/serial_reg.h>
  37. #include <linux/bitops.h>
  38. #include <asm/io.h>
  39. #include <pcmcia/cistpl.h>
  40. #include <pcmcia/ciscode.h>
  41. #include <pcmcia/ds.h>
  42. #include <pcmcia/cisreg.h>
  43. #include <net/bluetooth/bluetooth.h>
  44. #include <net/bluetooth/hci_core.h>
  45. /* ======================== Module parameters ======================== */
  46. MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  47. MODULE_DESCRIPTION("Bluetooth driver for Nokia Connectivity Card DTL-1");
  48. MODULE_LICENSE("GPL");
  49. /* ======================== Local structures ======================== */
  50. struct dtl1_info {
  51. struct pcmcia_device *p_dev;
  52. struct hci_dev *hdev;
  53. spinlock_t lock; /* For serializing operations */
  54. unsigned long flowmask; /* HCI flow mask */
  55. int ri_latch;
  56. struct sk_buff_head txq;
  57. unsigned long tx_state;
  58. unsigned long rx_state;
  59. unsigned long rx_count;
  60. struct sk_buff *rx_skb;
  61. };
  62. static int dtl1_config(struct pcmcia_device *link);
  63. /* Transmit states */
  64. #define XMIT_SENDING 1
  65. #define XMIT_WAKEUP 2
  66. #define XMIT_WAITING 8
  67. /* Receiver States */
  68. #define RECV_WAIT_NSH 0
  69. #define RECV_WAIT_DATA 1
  70. struct nsh {
  71. u8 type;
  72. u8 zero;
  73. u16 len;
  74. } __packed; /* Nokia Specific Header */
  75. #define NSHL 4 /* Nokia Specific Header Length */
  76. /* ======================== Interrupt handling ======================== */
  77. static int dtl1_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
  78. {
  79. int actual = 0;
  80. /* Tx FIFO should be empty */
  81. if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
  82. return 0;
  83. /* Fill FIFO with current frame */
  84. while ((fifo_size-- > 0) && (actual < len)) {
  85. /* Transmit next byte */
  86. outb(buf[actual], iobase + UART_TX);
  87. actual++;
  88. }
  89. return actual;
  90. }
  91. static void dtl1_write_wakeup(struct dtl1_info *info)
  92. {
  93. if (!info) {
  94. BT_ERR("Unknown device");
  95. return;
  96. }
  97. if (test_bit(XMIT_WAITING, &(info->tx_state))) {
  98. set_bit(XMIT_WAKEUP, &(info->tx_state));
  99. return;
  100. }
  101. if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
  102. set_bit(XMIT_WAKEUP, &(info->tx_state));
  103. return;
  104. }
  105. do {
  106. unsigned int iobase = info->p_dev->resource[0]->start;
  107. register struct sk_buff *skb;
  108. int len;
  109. clear_bit(XMIT_WAKEUP, &(info->tx_state));
  110. if (!pcmcia_dev_present(info->p_dev))
  111. return;
  112. skb = skb_dequeue(&(info->txq));
  113. if (!skb)
  114. break;
  115. /* Send frame */
  116. len = dtl1_write(iobase, 32, skb->data, skb->len);
  117. if (len == skb->len) {
  118. set_bit(XMIT_WAITING, &(info->tx_state));
  119. kfree_skb(skb);
  120. } else {
  121. skb_pull(skb, len);
  122. skb_queue_head(&(info->txq), skb);
  123. }
  124. info->hdev->stat.byte_tx += len;
  125. } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
  126. clear_bit(XMIT_SENDING, &(info->tx_state));
  127. }
  128. static void dtl1_control(struct dtl1_info *info, struct sk_buff *skb)
  129. {
  130. u8 flowmask = *(u8 *)skb->data;
  131. int i;
  132. printk(KERN_INFO "Bluetooth: Nokia control data =");
  133. for (i = 0; i < skb->len; i++)
  134. printk(" %02x", skb->data[i]);
  135. printk("\n");
  136. /* transition to active state */
  137. if (((info->flowmask & 0x07) == 0) && ((flowmask & 0x07) != 0)) {
  138. clear_bit(XMIT_WAITING, &(info->tx_state));
  139. dtl1_write_wakeup(info);
  140. }
  141. info->flowmask = flowmask;
  142. kfree_skb(skb);
  143. }
  144. static void dtl1_receive(struct dtl1_info *info)
  145. {
  146. unsigned int iobase;
  147. struct nsh *nsh;
  148. int boguscount = 0;
  149. if (!info) {
  150. BT_ERR("Unknown device");
  151. return;
  152. }
  153. iobase = info->p_dev->resource[0]->start;
  154. do {
  155. info->hdev->stat.byte_rx++;
  156. /* Allocate packet */
  157. if (info->rx_skb == NULL) {
  158. info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
  159. if (!info->rx_skb) {
  160. BT_ERR("Can't allocate mem for new packet");
  161. info->rx_state = RECV_WAIT_NSH;
  162. info->rx_count = NSHL;
  163. return;
  164. }
  165. }
  166. *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
  167. nsh = (struct nsh *)info->rx_skb->data;
  168. info->rx_count--;
  169. if (info->rx_count == 0) {
  170. switch (info->rx_state) {
  171. case RECV_WAIT_NSH:
  172. info->rx_state = RECV_WAIT_DATA;
  173. info->rx_count = nsh->len + (nsh->len & 0x0001);
  174. break;
  175. case RECV_WAIT_DATA:
  176. bt_cb(info->rx_skb)->pkt_type = nsh->type;
  177. /* remove PAD byte if it exists */
  178. if (nsh->len & 0x0001) {
  179. info->rx_skb->tail--;
  180. info->rx_skb->len--;
  181. }
  182. /* remove NSH */
  183. skb_pull(info->rx_skb, NSHL);
  184. switch (bt_cb(info->rx_skb)->pkt_type) {
  185. case 0x80:
  186. /* control data for the Nokia Card */
  187. dtl1_control(info, info->rx_skb);
  188. break;
  189. case 0x82:
  190. case 0x83:
  191. case 0x84:
  192. /* send frame to the HCI layer */
  193. bt_cb(info->rx_skb)->pkt_type &= 0x0f;
  194. hci_recv_frame(info->hdev, info->rx_skb);
  195. break;
  196. default:
  197. /* unknown packet */
  198. BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
  199. kfree_skb(info->rx_skb);
  200. break;
  201. }
  202. info->rx_state = RECV_WAIT_NSH;
  203. info->rx_count = NSHL;
  204. info->rx_skb = NULL;
  205. break;
  206. }
  207. }
  208. /* Make sure we don't stay here too long */
  209. if (boguscount++ > 32)
  210. break;
  211. } while (inb(iobase + UART_LSR) & UART_LSR_DR);
  212. }
  213. static irqreturn_t dtl1_interrupt(int irq, void *dev_inst)
  214. {
  215. struct dtl1_info *info = dev_inst;
  216. unsigned int iobase;
  217. unsigned char msr;
  218. int boguscount = 0;
  219. int iir, lsr;
  220. irqreturn_t r = IRQ_NONE;
  221. if (!info || !info->hdev)
  222. /* our irq handler is shared */
  223. return IRQ_NONE;
  224. iobase = info->p_dev->resource[0]->start;
  225. spin_lock(&(info->lock));
  226. iir = inb(iobase + UART_IIR) & UART_IIR_ID;
  227. while (iir) {
  228. r = IRQ_HANDLED;
  229. /* Clear interrupt */
  230. lsr = inb(iobase + UART_LSR);
  231. switch (iir) {
  232. case UART_IIR_RLSI:
  233. BT_ERR("RLSI");
  234. break;
  235. case UART_IIR_RDI:
  236. /* Receive interrupt */
  237. dtl1_receive(info);
  238. break;
  239. case UART_IIR_THRI:
  240. if (lsr & UART_LSR_THRE) {
  241. /* Transmitter ready for data */
  242. dtl1_write_wakeup(info);
  243. }
  244. break;
  245. default:
  246. BT_ERR("Unhandled IIR=%#x", iir);
  247. break;
  248. }
  249. /* Make sure we don't stay here too long */
  250. if (boguscount++ > 100)
  251. break;
  252. iir = inb(iobase + UART_IIR) & UART_IIR_ID;
  253. }
  254. msr = inb(iobase + UART_MSR);
  255. if (info->ri_latch ^ (msr & UART_MSR_RI)) {
  256. info->ri_latch = msr & UART_MSR_RI;
  257. clear_bit(XMIT_WAITING, &(info->tx_state));
  258. dtl1_write_wakeup(info);
  259. r = IRQ_HANDLED;
  260. }
  261. spin_unlock(&(info->lock));
  262. return r;
  263. }
  264. /* ======================== HCI interface ======================== */
  265. static int dtl1_hci_open(struct hci_dev *hdev)
  266. {
  267. return 0;
  268. }
  269. static int dtl1_hci_flush(struct hci_dev *hdev)
  270. {
  271. struct dtl1_info *info = hci_get_drvdata(hdev);
  272. /* Drop TX queue */
  273. skb_queue_purge(&(info->txq));
  274. return 0;
  275. }
  276. static int dtl1_hci_close(struct hci_dev *hdev)
  277. {
  278. dtl1_hci_flush(hdev);
  279. return 0;
  280. }
  281. static int dtl1_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  282. {
  283. struct dtl1_info *info = hci_get_drvdata(hdev);
  284. struct sk_buff *s;
  285. struct nsh nsh;
  286. switch (bt_cb(skb)->pkt_type) {
  287. case HCI_COMMAND_PKT:
  288. hdev->stat.cmd_tx++;
  289. nsh.type = 0x81;
  290. break;
  291. case HCI_ACLDATA_PKT:
  292. hdev->stat.acl_tx++;
  293. nsh.type = 0x82;
  294. break;
  295. case HCI_SCODATA_PKT:
  296. hdev->stat.sco_tx++;
  297. nsh.type = 0x83;
  298. break;
  299. default:
  300. return -EILSEQ;
  301. }
  302. nsh.zero = 0;
  303. nsh.len = skb->len;
  304. s = bt_skb_alloc(NSHL + skb->len + 1, GFP_ATOMIC);
  305. if (!s)
  306. return -ENOMEM;
  307. skb_reserve(s, NSHL);
  308. skb_copy_from_linear_data(skb, skb_put(s, skb->len), skb->len);
  309. if (skb->len & 0x0001)
  310. *skb_put(s, 1) = 0; /* PAD */
  311. /* Prepend skb with Nokia frame header and queue */
  312. memcpy(skb_push(s, NSHL), &nsh, NSHL);
  313. skb_queue_tail(&(info->txq), s);
  314. dtl1_write_wakeup(info);
  315. kfree_skb(skb);
  316. return 0;
  317. }
  318. /* ======================== Card services HCI interaction ======================== */
  319. static int dtl1_open(struct dtl1_info *info)
  320. {
  321. unsigned long flags;
  322. unsigned int iobase = info->p_dev->resource[0]->start;
  323. struct hci_dev *hdev;
  324. spin_lock_init(&(info->lock));
  325. skb_queue_head_init(&(info->txq));
  326. info->rx_state = RECV_WAIT_NSH;
  327. info->rx_count = NSHL;
  328. info->rx_skb = NULL;
  329. set_bit(XMIT_WAITING, &(info->tx_state));
  330. /* Initialize HCI device */
  331. hdev = hci_alloc_dev();
  332. if (!hdev) {
  333. BT_ERR("Can't allocate HCI device");
  334. return -ENOMEM;
  335. }
  336. info->hdev = hdev;
  337. hdev->bus = HCI_PCCARD;
  338. hci_set_drvdata(hdev, info);
  339. SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
  340. hdev->open = dtl1_hci_open;
  341. hdev->close = dtl1_hci_close;
  342. hdev->flush = dtl1_hci_flush;
  343. hdev->send = dtl1_hci_send_frame;
  344. spin_lock_irqsave(&(info->lock), flags);
  345. /* Reset UART */
  346. outb(0, iobase + UART_MCR);
  347. /* Turn off interrupts */
  348. outb(0, iobase + UART_IER);
  349. /* Initialize UART */
  350. outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
  351. outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
  352. info->ri_latch = inb(info->p_dev->resource[0]->start + UART_MSR)
  353. & UART_MSR_RI;
  354. /* Turn on interrupts */
  355. outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
  356. spin_unlock_irqrestore(&(info->lock), flags);
  357. /* Timeout before it is safe to send the first HCI packet */
  358. msleep(2000);
  359. /* Register HCI device */
  360. if (hci_register_dev(hdev) < 0) {
  361. BT_ERR("Can't register HCI device");
  362. info->hdev = NULL;
  363. hci_free_dev(hdev);
  364. return -ENODEV;
  365. }
  366. return 0;
  367. }
  368. static int dtl1_close(struct dtl1_info *info)
  369. {
  370. unsigned long flags;
  371. unsigned int iobase = info->p_dev->resource[0]->start;
  372. struct hci_dev *hdev = info->hdev;
  373. if (!hdev)
  374. return -ENODEV;
  375. dtl1_hci_close(hdev);
  376. spin_lock_irqsave(&(info->lock), flags);
  377. /* Reset UART */
  378. outb(0, iobase + UART_MCR);
  379. /* Turn off interrupts */
  380. outb(0, iobase + UART_IER);
  381. spin_unlock_irqrestore(&(info->lock), flags);
  382. hci_unregister_dev(hdev);
  383. hci_free_dev(hdev);
  384. return 0;
  385. }
  386. static int dtl1_probe(struct pcmcia_device *link)
  387. {
  388. struct dtl1_info *info;
  389. /* Create new info device */
  390. info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
  391. if (!info)
  392. return -ENOMEM;
  393. info->p_dev = link;
  394. link->priv = info;
  395. link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
  396. return dtl1_config(link);
  397. }
  398. static void dtl1_detach(struct pcmcia_device *link)
  399. {
  400. struct dtl1_info *info = link->priv;
  401. dtl1_close(info);
  402. pcmcia_disable_device(link);
  403. }
  404. static int dtl1_confcheck(struct pcmcia_device *p_dev, void *priv_data)
  405. {
  406. if ((p_dev->resource[1]->end) || (p_dev->resource[1]->end < 8))
  407. return -ENODEV;
  408. p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
  409. p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
  410. return pcmcia_request_io(p_dev);
  411. }
  412. static int dtl1_config(struct pcmcia_device *link)
  413. {
  414. struct dtl1_info *info = link->priv;
  415. int ret;
  416. /* Look for a generic full-sized window */
  417. link->resource[0]->end = 8;
  418. ret = pcmcia_loop_config(link, dtl1_confcheck, NULL);
  419. if (ret)
  420. goto failed;
  421. ret = pcmcia_request_irq(link, dtl1_interrupt);
  422. if (ret)
  423. goto failed;
  424. ret = pcmcia_enable_device(link);
  425. if (ret)
  426. goto failed;
  427. ret = dtl1_open(info);
  428. if (ret)
  429. goto failed;
  430. return 0;
  431. failed:
  432. dtl1_detach(link);
  433. return ret;
  434. }
  435. static const struct pcmcia_device_id dtl1_ids[] = {
  436. PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-1", 0xe1bfdd64, 0xe168480d),
  437. PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-4", 0xe1bfdd64, 0x9102bc82),
  438. PCMCIA_DEVICE_PROD_ID12("Socket", "CF", 0xb38bcc2e, 0x44ebf863),
  439. PCMCIA_DEVICE_PROD_ID12("Socket", "CF+ Personal Network Card", 0xb38bcc2e, 0xe732bae3),
  440. PCMCIA_DEVICE_NULL
  441. };
  442. MODULE_DEVICE_TABLE(pcmcia, dtl1_ids);
  443. static struct pcmcia_driver dtl1_driver = {
  444. .owner = THIS_MODULE,
  445. .name = "dtl1_cs",
  446. .probe = dtl1_probe,
  447. .remove = dtl1_detach,
  448. .id_table = dtl1_ids,
  449. };
  450. module_pcmcia_driver(dtl1_driver);