bluecard_cs.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908
  1. /*
  2. *
  3. * Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)
  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/sched.h>
  28. #include <linux/delay.h>
  29. #include <linux/timer.h>
  30. #include <linux/errno.h>
  31. #include <linux/ptrace.h>
  32. #include <linux/ioport.h>
  33. #include <linux/spinlock.h>
  34. #include <linux/moduleparam.h>
  35. #include <linux/wait.h>
  36. #include <linux/skbuff.h>
  37. #include <linux/io.h>
  38. #include <pcmcia/cistpl.h>
  39. #include <pcmcia/ciscode.h>
  40. #include <pcmcia/ds.h>
  41. #include <pcmcia/cisreg.h>
  42. #include <net/bluetooth/bluetooth.h>
  43. #include <net/bluetooth/hci_core.h>
  44. /* ======================== Module parameters ======================== */
  45. MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  46. MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)");
  47. MODULE_LICENSE("GPL");
  48. /* ======================== Local structures ======================== */
  49. struct bluecard_info {
  50. struct pcmcia_device *p_dev;
  51. struct hci_dev *hdev;
  52. spinlock_t lock; /* For serializing operations */
  53. struct timer_list timer; /* For LED control */
  54. struct sk_buff_head txq;
  55. unsigned long tx_state;
  56. unsigned long rx_state;
  57. unsigned long rx_count;
  58. struct sk_buff *rx_skb;
  59. unsigned char ctrl_reg;
  60. unsigned long hw_state; /* Status of the hardware and LED control */
  61. };
  62. static int bluecard_config(struct pcmcia_device *link);
  63. static void bluecard_release(struct pcmcia_device *link);
  64. static void bluecard_detach(struct pcmcia_device *p_dev);
  65. /* Default baud rate: 57600, 115200, 230400 or 460800 */
  66. #define DEFAULT_BAUD_RATE 230400
  67. /* Hardware states */
  68. #define CARD_READY 1
  69. #define CARD_ACTIVITY 2
  70. #define CARD_HAS_PCCARD_ID 4
  71. #define CARD_HAS_POWER_LED 5
  72. #define CARD_HAS_ACTIVITY_LED 6
  73. /* Transmit states */
  74. #define XMIT_SENDING 1
  75. #define XMIT_WAKEUP 2
  76. #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */
  77. #define XMIT_BUF_ONE_READY 6
  78. #define XMIT_BUF_TWO_READY 7
  79. #define XMIT_SENDING_READY 8
  80. /* Receiver states */
  81. #define RECV_WAIT_PACKET_TYPE 0
  82. #define RECV_WAIT_EVENT_HEADER 1
  83. #define RECV_WAIT_ACL_HEADER 2
  84. #define RECV_WAIT_SCO_HEADER 3
  85. #define RECV_WAIT_DATA 4
  86. /* Special packet types */
  87. #define PKT_BAUD_RATE_57600 0x80
  88. #define PKT_BAUD_RATE_115200 0x81
  89. #define PKT_BAUD_RATE_230400 0x82
  90. #define PKT_BAUD_RATE_460800 0x83
  91. /* These are the register offsets */
  92. #define REG_COMMAND 0x20
  93. #define REG_INTERRUPT 0x21
  94. #define REG_CONTROL 0x22
  95. #define REG_RX_CONTROL 0x24
  96. #define REG_CARD_RESET 0x30
  97. #define REG_LED_CTRL 0x30
  98. /* REG_COMMAND */
  99. #define REG_COMMAND_TX_BUF_ONE 0x01
  100. #define REG_COMMAND_TX_BUF_TWO 0x02
  101. #define REG_COMMAND_RX_BUF_ONE 0x04
  102. #define REG_COMMAND_RX_BUF_TWO 0x08
  103. #define REG_COMMAND_RX_WIN_ONE 0x00
  104. #define REG_COMMAND_RX_WIN_TWO 0x10
  105. /* REG_CONTROL */
  106. #define REG_CONTROL_BAUD_RATE_57600 0x00
  107. #define REG_CONTROL_BAUD_RATE_115200 0x01
  108. #define REG_CONTROL_BAUD_RATE_230400 0x02
  109. #define REG_CONTROL_BAUD_RATE_460800 0x03
  110. #define REG_CONTROL_RTS 0x04
  111. #define REG_CONTROL_BT_ON 0x08
  112. #define REG_CONTROL_BT_RESET 0x10
  113. #define REG_CONTROL_BT_RES_PU 0x20
  114. #define REG_CONTROL_INTERRUPT 0x40
  115. #define REG_CONTROL_CARD_RESET 0x80
  116. /* REG_RX_CONTROL */
  117. #define RTS_LEVEL_SHIFT_BITS 0x02
  118. /* ======================== LED handling routines ======================== */
  119. static void bluecard_activity_led_timeout(struct timer_list *t)
  120. {
  121. struct bluecard_info *info = from_timer(info, t, timer);
  122. unsigned int iobase = info->p_dev->resource[0]->start;
  123. if (test_bit(CARD_ACTIVITY, &(info->hw_state))) {
  124. /* leave LED in inactive state for HZ/10 for blink effect */
  125. clear_bit(CARD_ACTIVITY, &(info->hw_state));
  126. mod_timer(&(info->timer), jiffies + HZ / 10);
  127. }
  128. /* Disable activity LED, enable power LED */
  129. outb(0x08 | 0x20, iobase + 0x30);
  130. }
  131. static void bluecard_enable_activity_led(struct bluecard_info *info)
  132. {
  133. unsigned int iobase = info->p_dev->resource[0]->start;
  134. /* don't disturb running blink timer */
  135. if (timer_pending(&(info->timer)))
  136. return;
  137. set_bit(CARD_ACTIVITY, &(info->hw_state));
  138. if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
  139. /* Enable activity LED, keep power LED enabled */
  140. outb(0x18 | 0x60, iobase + 0x30);
  141. } else {
  142. /* Disable power LED */
  143. outb(0x00, iobase + 0x30);
  144. }
  145. /* Stop the LED after HZ/10 */
  146. mod_timer(&(info->timer), jiffies + HZ / 10);
  147. }
  148. /* ======================== Interrupt handling ======================== */
  149. static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)
  150. {
  151. int i, actual;
  152. actual = (len > 15) ? 15 : len;
  153. outb_p(actual, iobase + offset);
  154. for (i = 0; i < actual; i++)
  155. outb_p(buf[i], iobase + offset + i + 1);
  156. return actual;
  157. }
  158. static void bluecard_write_wakeup(struct bluecard_info *info)
  159. {
  160. if (!info) {
  161. BT_ERR("Unknown device");
  162. return;
  163. }
  164. if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))
  165. return;
  166. if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
  167. set_bit(XMIT_WAKEUP, &(info->tx_state));
  168. return;
  169. }
  170. do {
  171. unsigned int iobase = info->p_dev->resource[0]->start;
  172. unsigned int offset;
  173. unsigned char command;
  174. unsigned long ready_bit;
  175. register struct sk_buff *skb;
  176. int len;
  177. clear_bit(XMIT_WAKEUP, &(info->tx_state));
  178. if (!pcmcia_dev_present(info->p_dev))
  179. return;
  180. if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {
  181. if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))
  182. break;
  183. offset = 0x10;
  184. command = REG_COMMAND_TX_BUF_TWO;
  185. ready_bit = XMIT_BUF_TWO_READY;
  186. } else {
  187. if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))
  188. break;
  189. offset = 0x00;
  190. command = REG_COMMAND_TX_BUF_ONE;
  191. ready_bit = XMIT_BUF_ONE_READY;
  192. }
  193. skb = skb_dequeue(&(info->txq));
  194. if (!skb)
  195. break;
  196. if (hci_skb_pkt_type(skb) & 0x80) {
  197. /* Disable RTS */
  198. info->ctrl_reg |= REG_CONTROL_RTS;
  199. outb(info->ctrl_reg, iobase + REG_CONTROL);
  200. }
  201. /* Activate LED */
  202. bluecard_enable_activity_led(info);
  203. /* Send frame */
  204. len = bluecard_write(iobase, offset, skb->data, skb->len);
  205. /* Tell the FPGA to send the data */
  206. outb_p(command, iobase + REG_COMMAND);
  207. /* Mark the buffer as dirty */
  208. clear_bit(ready_bit, &(info->tx_state));
  209. if (hci_skb_pkt_type(skb) & 0x80) {
  210. DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
  211. DEFINE_WAIT(wait);
  212. unsigned char baud_reg;
  213. switch (hci_skb_pkt_type(skb)) {
  214. case PKT_BAUD_RATE_460800:
  215. baud_reg = REG_CONTROL_BAUD_RATE_460800;
  216. break;
  217. case PKT_BAUD_RATE_230400:
  218. baud_reg = REG_CONTROL_BAUD_RATE_230400;
  219. break;
  220. case PKT_BAUD_RATE_115200:
  221. baud_reg = REG_CONTROL_BAUD_RATE_115200;
  222. break;
  223. case PKT_BAUD_RATE_57600:
  224. default:
  225. baud_reg = REG_CONTROL_BAUD_RATE_57600;
  226. break;
  227. }
  228. /* Wait until the command reaches the baseband */
  229. mdelay(100);
  230. /* Set baud on baseband */
  231. info->ctrl_reg &= ~0x03;
  232. info->ctrl_reg |= baud_reg;
  233. outb(info->ctrl_reg, iobase + REG_CONTROL);
  234. /* Enable RTS */
  235. info->ctrl_reg &= ~REG_CONTROL_RTS;
  236. outb(info->ctrl_reg, iobase + REG_CONTROL);
  237. /* Wait before the next HCI packet can be send */
  238. mdelay(1000);
  239. }
  240. if (len == skb->len) {
  241. kfree_skb(skb);
  242. } else {
  243. skb_pull(skb, len);
  244. skb_queue_head(&(info->txq), skb);
  245. }
  246. info->hdev->stat.byte_tx += len;
  247. /* Change buffer */
  248. change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));
  249. } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
  250. clear_bit(XMIT_SENDING, &(info->tx_state));
  251. }
  252. static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)
  253. {
  254. int i, n, len;
  255. outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);
  256. len = inb(iobase + offset);
  257. n = 0;
  258. i = 1;
  259. while (n < len) {
  260. if (i == 16) {
  261. outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);
  262. i = 0;
  263. }
  264. buf[n] = inb(iobase + offset + i);
  265. n++;
  266. i++;
  267. }
  268. return len;
  269. }
  270. static void bluecard_receive(struct bluecard_info *info,
  271. unsigned int offset)
  272. {
  273. unsigned int iobase;
  274. unsigned char buf[31];
  275. int i, len;
  276. if (!info) {
  277. BT_ERR("Unknown device");
  278. return;
  279. }
  280. iobase = info->p_dev->resource[0]->start;
  281. if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))
  282. bluecard_enable_activity_led(info);
  283. len = bluecard_read(iobase, offset, buf, sizeof(buf));
  284. for (i = 0; i < len; i++) {
  285. /* Allocate packet */
  286. if (!info->rx_skb) {
  287. info->rx_state = RECV_WAIT_PACKET_TYPE;
  288. info->rx_count = 0;
  289. info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
  290. if (!info->rx_skb) {
  291. BT_ERR("Can't allocate mem for new packet");
  292. return;
  293. }
  294. }
  295. if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
  296. hci_skb_pkt_type(info->rx_skb) = buf[i];
  297. switch (hci_skb_pkt_type(info->rx_skb)) {
  298. case 0x00:
  299. /* init packet */
  300. if (offset != 0x00) {
  301. set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
  302. set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
  303. set_bit(XMIT_SENDING_READY, &(info->tx_state));
  304. bluecard_write_wakeup(info);
  305. }
  306. kfree_skb(info->rx_skb);
  307. info->rx_skb = NULL;
  308. break;
  309. case HCI_EVENT_PKT:
  310. info->rx_state = RECV_WAIT_EVENT_HEADER;
  311. info->rx_count = HCI_EVENT_HDR_SIZE;
  312. break;
  313. case HCI_ACLDATA_PKT:
  314. info->rx_state = RECV_WAIT_ACL_HEADER;
  315. info->rx_count = HCI_ACL_HDR_SIZE;
  316. break;
  317. case HCI_SCODATA_PKT:
  318. info->rx_state = RECV_WAIT_SCO_HEADER;
  319. info->rx_count = HCI_SCO_HDR_SIZE;
  320. break;
  321. default:
  322. /* unknown packet */
  323. BT_ERR("Unknown HCI packet with type 0x%02x received",
  324. hci_skb_pkt_type(info->rx_skb));
  325. info->hdev->stat.err_rx++;
  326. kfree_skb(info->rx_skb);
  327. info->rx_skb = NULL;
  328. break;
  329. }
  330. } else {
  331. skb_put_u8(info->rx_skb, buf[i]);
  332. info->rx_count--;
  333. if (info->rx_count == 0) {
  334. int dlen;
  335. struct hci_event_hdr *eh;
  336. struct hci_acl_hdr *ah;
  337. struct hci_sco_hdr *sh;
  338. switch (info->rx_state) {
  339. case RECV_WAIT_EVENT_HEADER:
  340. eh = hci_event_hdr(info->rx_skb);
  341. info->rx_state = RECV_WAIT_DATA;
  342. info->rx_count = eh->plen;
  343. break;
  344. case RECV_WAIT_ACL_HEADER:
  345. ah = hci_acl_hdr(info->rx_skb);
  346. dlen = __le16_to_cpu(ah->dlen);
  347. info->rx_state = RECV_WAIT_DATA;
  348. info->rx_count = dlen;
  349. break;
  350. case RECV_WAIT_SCO_HEADER:
  351. sh = hci_sco_hdr(info->rx_skb);
  352. info->rx_state = RECV_WAIT_DATA;
  353. info->rx_count = sh->dlen;
  354. break;
  355. case RECV_WAIT_DATA:
  356. hci_recv_frame(info->hdev, info->rx_skb);
  357. info->rx_skb = NULL;
  358. break;
  359. }
  360. }
  361. }
  362. }
  363. info->hdev->stat.byte_rx += len;
  364. }
  365. static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)
  366. {
  367. struct bluecard_info *info = dev_inst;
  368. unsigned int iobase;
  369. unsigned char reg;
  370. if (!info || !info->hdev)
  371. /* our irq handler is shared */
  372. return IRQ_NONE;
  373. if (!test_bit(CARD_READY, &(info->hw_state)))
  374. return IRQ_HANDLED;
  375. iobase = info->p_dev->resource[0]->start;
  376. spin_lock(&(info->lock));
  377. /* Disable interrupt */
  378. info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;
  379. outb(info->ctrl_reg, iobase + REG_CONTROL);
  380. reg = inb(iobase + REG_INTERRUPT);
  381. if ((reg != 0x00) && (reg != 0xff)) {
  382. if (reg & 0x04) {
  383. bluecard_receive(info, 0x00);
  384. outb(0x04, iobase + REG_INTERRUPT);
  385. outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
  386. }
  387. if (reg & 0x08) {
  388. bluecard_receive(info, 0x10);
  389. outb(0x08, iobase + REG_INTERRUPT);
  390. outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
  391. }
  392. if (reg & 0x01) {
  393. set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
  394. outb(0x01, iobase + REG_INTERRUPT);
  395. bluecard_write_wakeup(info);
  396. }
  397. if (reg & 0x02) {
  398. set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
  399. outb(0x02, iobase + REG_INTERRUPT);
  400. bluecard_write_wakeup(info);
  401. }
  402. }
  403. /* Enable interrupt */
  404. info->ctrl_reg |= REG_CONTROL_INTERRUPT;
  405. outb(info->ctrl_reg, iobase + REG_CONTROL);
  406. spin_unlock(&(info->lock));
  407. return IRQ_HANDLED;
  408. }
  409. /* ======================== Device specific HCI commands ======================== */
  410. static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)
  411. {
  412. struct bluecard_info *info = hci_get_drvdata(hdev);
  413. struct sk_buff *skb;
  414. /* Ericsson baud rate command */
  415. unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };
  416. skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_KERNEL);
  417. if (!skb) {
  418. BT_ERR("Can't allocate mem for new packet");
  419. return -1;
  420. }
  421. switch (baud) {
  422. case 460800:
  423. cmd[4] = 0x00;
  424. hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800;
  425. break;
  426. case 230400:
  427. cmd[4] = 0x01;
  428. hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400;
  429. break;
  430. case 115200:
  431. cmd[4] = 0x02;
  432. hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200;
  433. break;
  434. case 57600:
  435. default:
  436. cmd[4] = 0x03;
  437. hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600;
  438. break;
  439. }
  440. skb_put_data(skb, cmd, sizeof(cmd));
  441. skb_queue_tail(&(info->txq), skb);
  442. bluecard_write_wakeup(info);
  443. return 0;
  444. }
  445. /* ======================== HCI interface ======================== */
  446. static int bluecard_hci_flush(struct hci_dev *hdev)
  447. {
  448. struct bluecard_info *info = hci_get_drvdata(hdev);
  449. /* Drop TX queue */
  450. skb_queue_purge(&(info->txq));
  451. return 0;
  452. }
  453. static int bluecard_hci_open(struct hci_dev *hdev)
  454. {
  455. struct bluecard_info *info = hci_get_drvdata(hdev);
  456. unsigned int iobase = info->p_dev->resource[0]->start;
  457. if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
  458. bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);
  459. /* Enable power LED */
  460. outb(0x08 | 0x20, iobase + 0x30);
  461. return 0;
  462. }
  463. static int bluecard_hci_close(struct hci_dev *hdev)
  464. {
  465. struct bluecard_info *info = hci_get_drvdata(hdev);
  466. unsigned int iobase = info->p_dev->resource[0]->start;
  467. bluecard_hci_flush(hdev);
  468. /* Stop LED timer */
  469. del_timer_sync(&(info->timer));
  470. /* Disable power LED */
  471. outb(0x00, iobase + 0x30);
  472. return 0;
  473. }
  474. static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  475. {
  476. struct bluecard_info *info = hci_get_drvdata(hdev);
  477. switch (hci_skb_pkt_type(skb)) {
  478. case HCI_COMMAND_PKT:
  479. hdev->stat.cmd_tx++;
  480. break;
  481. case HCI_ACLDATA_PKT:
  482. hdev->stat.acl_tx++;
  483. break;
  484. case HCI_SCODATA_PKT:
  485. hdev->stat.sco_tx++;
  486. break;
  487. }
  488. /* Prepend skb with frame type */
  489. memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
  490. skb_queue_tail(&(info->txq), skb);
  491. bluecard_write_wakeup(info);
  492. return 0;
  493. }
  494. /* ======================== Card services HCI interaction ======================== */
  495. static int bluecard_open(struct bluecard_info *info)
  496. {
  497. unsigned int iobase = info->p_dev->resource[0]->start;
  498. struct hci_dev *hdev;
  499. unsigned char id;
  500. spin_lock_init(&(info->lock));
  501. timer_setup(&info->timer, bluecard_activity_led_timeout, 0);
  502. skb_queue_head_init(&(info->txq));
  503. info->rx_state = RECV_WAIT_PACKET_TYPE;
  504. info->rx_count = 0;
  505. info->rx_skb = NULL;
  506. /* Initialize HCI device */
  507. hdev = hci_alloc_dev();
  508. if (!hdev) {
  509. BT_ERR("Can't allocate HCI device");
  510. return -ENOMEM;
  511. }
  512. info->hdev = hdev;
  513. hdev->bus = HCI_PCCARD;
  514. hci_set_drvdata(hdev, info);
  515. SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
  516. hdev->open = bluecard_hci_open;
  517. hdev->close = bluecard_hci_close;
  518. hdev->flush = bluecard_hci_flush;
  519. hdev->send = bluecard_hci_send_frame;
  520. id = inb(iobase + 0x30);
  521. if ((id & 0x0f) == 0x02)
  522. set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));
  523. if (id & 0x10)
  524. set_bit(CARD_HAS_POWER_LED, &(info->hw_state));
  525. if (id & 0x20)
  526. set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));
  527. /* Reset card */
  528. info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
  529. outb(info->ctrl_reg, iobase + REG_CONTROL);
  530. /* Turn FPGA off */
  531. outb(0x80, iobase + 0x30);
  532. /* Wait some time */
  533. msleep(10);
  534. /* Turn FPGA on */
  535. outb(0x00, iobase + 0x30);
  536. /* Activate card */
  537. info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;
  538. outb(info->ctrl_reg, iobase + REG_CONTROL);
  539. /* Enable interrupt */
  540. outb(0xff, iobase + REG_INTERRUPT);
  541. info->ctrl_reg |= REG_CONTROL_INTERRUPT;
  542. outb(info->ctrl_reg, iobase + REG_CONTROL);
  543. if ((id & 0x0f) == 0x03) {
  544. /* Disable RTS */
  545. info->ctrl_reg |= REG_CONTROL_RTS;
  546. outb(info->ctrl_reg, iobase + REG_CONTROL);
  547. /* Set baud rate */
  548. info->ctrl_reg |= 0x03;
  549. outb(info->ctrl_reg, iobase + REG_CONTROL);
  550. /* Enable RTS */
  551. info->ctrl_reg &= ~REG_CONTROL_RTS;
  552. outb(info->ctrl_reg, iobase + REG_CONTROL);
  553. set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
  554. set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
  555. set_bit(XMIT_SENDING_READY, &(info->tx_state));
  556. }
  557. /* Start the RX buffers */
  558. outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
  559. outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
  560. /* Signal that the hardware is ready */
  561. set_bit(CARD_READY, &(info->hw_state));
  562. /* Drop TX queue */
  563. skb_queue_purge(&(info->txq));
  564. /* Control the point at which RTS is enabled */
  565. outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);
  566. /* Timeout before it is safe to send the first HCI packet */
  567. msleep(1250);
  568. /* Register HCI device */
  569. if (hci_register_dev(hdev) < 0) {
  570. BT_ERR("Can't register HCI device");
  571. info->hdev = NULL;
  572. hci_free_dev(hdev);
  573. return -ENODEV;
  574. }
  575. return 0;
  576. }
  577. static int bluecard_close(struct bluecard_info *info)
  578. {
  579. unsigned int iobase = info->p_dev->resource[0]->start;
  580. struct hci_dev *hdev = info->hdev;
  581. if (!hdev)
  582. return -ENODEV;
  583. bluecard_hci_close(hdev);
  584. clear_bit(CARD_READY, &(info->hw_state));
  585. /* Reset card */
  586. info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
  587. outb(info->ctrl_reg, iobase + REG_CONTROL);
  588. /* Turn FPGA off */
  589. outb(0x80, iobase + 0x30);
  590. hci_unregister_dev(hdev);
  591. hci_free_dev(hdev);
  592. return 0;
  593. }
  594. static int bluecard_probe(struct pcmcia_device *link)
  595. {
  596. struct bluecard_info *info;
  597. /* Create new info device */
  598. info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
  599. if (!info)
  600. return -ENOMEM;
  601. info->p_dev = link;
  602. link->priv = info;
  603. link->config_flags |= CONF_ENABLE_IRQ;
  604. return bluecard_config(link);
  605. }
  606. static void bluecard_detach(struct pcmcia_device *link)
  607. {
  608. bluecard_release(link);
  609. }
  610. static int bluecard_config(struct pcmcia_device *link)
  611. {
  612. struct bluecard_info *info = link->priv;
  613. int i, n;
  614. link->config_index = 0x20;
  615. link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
  616. link->resource[0]->end = 64;
  617. link->io_lines = 6;
  618. for (n = 0; n < 0x400; n += 0x40) {
  619. link->resource[0]->start = n ^ 0x300;
  620. i = pcmcia_request_io(link);
  621. if (i == 0)
  622. break;
  623. }
  624. if (i != 0)
  625. goto failed;
  626. i = pcmcia_request_irq(link, bluecard_interrupt);
  627. if (i != 0)
  628. goto failed;
  629. i = pcmcia_enable_device(link);
  630. if (i != 0)
  631. goto failed;
  632. if (bluecard_open(info) != 0)
  633. goto failed;
  634. return 0;
  635. failed:
  636. bluecard_release(link);
  637. return -ENODEV;
  638. }
  639. static void bluecard_release(struct pcmcia_device *link)
  640. {
  641. struct bluecard_info *info = link->priv;
  642. bluecard_close(info);
  643. del_timer_sync(&(info->timer));
  644. pcmcia_disable_device(link);
  645. }
  646. static const struct pcmcia_device_id bluecard_ids[] = {
  647. PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),
  648. PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),
  649. PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),
  650. PCMCIA_DEVICE_NULL
  651. };
  652. MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
  653. static struct pcmcia_driver bluecard_driver = {
  654. .owner = THIS_MODULE,
  655. .name = "bluecard_cs",
  656. .probe = bluecard_probe,
  657. .remove = bluecard_detach,
  658. .id_table = bluecard_ids,
  659. };
  660. module_pcmcia_driver(bluecard_driver);