2 * carl9170user - userspace testing utility for ar9170 devices
6 * Copyright 2009, 2010 Christian Lamparter <chunkeey@googlemail.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
39 #define ADD_DEV(_vid, _pid, _vs, _ps) { \
52 ADD_DEV(0x0cf3, 0x9170, "Atheros", "9170"),
53 ADD_DEV(0x0cf3, 0x1001, "Atheros", "TG121N"),
54 ADD_DEV(0x0cf3, 0x1002, "TP-Link", "TL-WN821N v2"),
55 ADD_DEV(0xcace, 0x0300, "Cace", "Airpcap NX"),
56 ADD_DEV(0x07d1, 0x3c10, "D-Link", "DWA 160 A1"),
57 ADD_DEV(0x07d1, 0x3a09, "D-Link", "DWA 160 A2"),
58 ADD_DEV(0x0846, 0x9010, "Netgear", "WNDA3100"),
59 ADD_DEV(0x0846, 0x9001, "Netgear", "WN111 v2"),
60 ADD_DEV(0x0ace, 0x1221, "Zydas", "ZD1221"),
61 ADD_DEV(0x0586, 0x3417, "ZyXEL", "NWD271N"),
62 ADD_DEV(0x0cde, 0x0023, "Z-Com", "UB81 BG"),
63 ADD_DEV(0x0cde, 0x0026, "Z-Com", "UB82 ABG"),
64 ADD_DEV(0x0cde, 0x0027, "Sphairon", "Homelink 1202"),
65 ADD_DEV(0x083a, 0xf522, "Arcadyan", "WN7512"),
66 ADD_DEV(0x2019, 0x5304, "Planex", "GWUS300"),
67 ADD_DEV(0x04bb, 0x093f, "IO-Data", "WNGDNUS2"),
68 ADD_DEV(0x057C, 0x8401, "AVM", "FRITZ!WLAN USB Stick N"),
69 ADD_DEV(0x057C, 0x8402, "AVM", "FRITZ!WLAN USB Stick N 2.4"),
72 static libusb_context *usb_ctx;
73 static LIST_HEAD(active_dev_list);
75 static int carlusb_event_thread(void *_ar)
77 struct carlusb *ar = (void *)_ar;
78 dbg("event thread active and polling.\n");
80 while (!ar->stop_event_polling)
81 libusb_handle_events(ar->ctx);
83 dbg("==> event thread desixed.\n");
87 static int carlusb_is_ar9170(struct libusb_device_descriptor *desc)
91 for (i = 0; i < ARRAY_SIZE(dev_list); i++) {
92 if ((desc->idVendor == dev_list[i].idVendor) &&
93 (desc->idProduct == dev_list[i].idProduct)) {
94 dbg("== found device \"%s %s\" [0x%04x:0x%04x]\n",
95 dev_list[i].vendor_name, dev_list[i].product_name,
96 desc->idVendor, desc->idProduct);
105 static bool carlusb_is_dev(struct carlusb *iter,
106 struct libusb_device *dev)
108 libusb_device *list_dev;
113 list_dev = libusb_get_device(iter->dev);
115 if (libusb_get_bus_number(list_dev) == libusb_get_bus_number(dev) &&
116 libusb_get_device_address(list_dev) == libusb_get_device_address(dev))
122 int carlusb_show_devinfo(struct carlusb *ar)
124 struct libusb_device_descriptor desc;
128 dev = libusb_get_device(ar->dev);
130 err = libusb_get_device_descriptor(dev, &desc);
134 info("USB Device Information:\n");
135 info("\tUSB VendorID:%.4x(%s), ProductID:%.4x(%s)\n",
136 dev_list[ar->idx].idVendor, dev_list[ar->idx].vendor_name,
137 dev_list[ar->idx].idProduct, dev_list[ar->idx].product_name);
138 info("\tBus:%d Address:%d\n", libusb_get_bus_number(dev),
139 libusb_get_device_address(dev));
144 static int carlusb_get_dev(struct carlusb *ar, bool reset)
146 struct carlusb *iter;
147 libusb_device_handle *dev;
148 libusb_device **list;
149 int ret, err, i, idx = -1;
151 ret = libusb_get_device_list(usb_ctx, &list);
153 err("usb device enum failed (%d)\n", ret);
157 for (i = 0; i < ret; i++) {
158 struct libusb_device_descriptor desc;
160 memset(&desc, 0, sizeof(desc));
161 err = libusb_get_device_descriptor(list[i], &desc);
165 idx = carlusb_is_ar9170(&desc);
169 list_for_each_entry(iter, &active_dev_list, dev_list) {
170 if (carlusb_is_dev(iter, list[i])) {
179 err = libusb_open(list[i], &dev);
181 err("failed to open device (%d)\n", err);
185 err = libusb_kernel_driver_active(dev, 0);
190 err("failed to aquire exculusive access (%d).\n", err);
195 err = libusb_reset_device(dev);
197 err("failed to reset device (%d)\n", err);
202 err = libusb_claim_interface(dev, 0);
204 dbg(">device is now under our control.\n");
207 err("failed to claim device (%d)\n", err);
219 list_add_tail(&ar->dev_list, &active_dev_list);
225 libusb_free_device_list(list, 1);
229 static void carlusb_tx_cb(struct carlusb *ar,
232 if (ar->common.tx_cb)
233 ar->common.tx_cb(&ar->common, frame);
235 ar->common.tx_octets += frame->len;
237 carlu_free_frame(&ar->common, frame);
240 static void carlusb_zap_queues(struct carlusb *ar)
244 BUG_ON(SDL_mutexP(ar->tx_queue_lock) != 0);
245 while (!list_empty(&ar->tx_queue)) {
246 frame = list_first_entry(&ar->tx_queue, struct frame, dcb.list);
247 list_del(&frame->dcb.list);
248 carlusb_tx_cb(ar, frame);
250 SDL_mutexV(ar->tx_queue_lock);
253 static void carlusb_free_driver(struct carlusb *ar)
256 if (ar->event_pipe[0] > -1)
257 close(ar->event_pipe[0]);
259 if (ar->event_pipe[1] > -1)
260 close(ar->event_pipe[1]);
262 carlusb_zap_queues(ar);
263 carlfw_release(ar->common.fw);
264 ar->common.fw = NULL;
267 libusb_release_interface(ar->dev, 0);
268 libusb_close(ar->dev);
271 carlu_free_driver(&ar->common);
275 static int carlusb_init(struct carlusb *ar)
277 init_list_head(&ar->tx_queue);
278 ar->tx_queue_lock = SDL_CreateMutex();
279 ar->event_pipe[0] = ar->event_pipe[1] = -1;
284 static struct carlusb *carlusb_open(void)
289 tmp = carlu_alloc_driver(sizeof(*tmp));
293 err = carlusb_init(tmp);
297 err = carlusb_get_dev(tmp, true);
304 carlusb_free_driver(tmp);
308 static void carlusb_cancel_rings(struct carlusb *ar)
312 for (i = 0; i < ARRAY_SIZE(ar->rx_ring); i++)
313 libusb_cancel_transfer(ar->rx_ring[i]);
315 libusb_cancel_transfer(ar->rx_interrupt);
318 static void carlusb_free_rings(struct carlusb *ar)
322 for (i = 0; i < ARRAY_SIZE(ar->rx_ring); i++)
323 libusb_free_transfer(ar->rx_ring[i]);
325 libusb_free_transfer(ar->rx_interrupt);
328 static void carlusb_destroy(struct carlusb *ar)
330 int event_thread_status;
332 dbg("==>release device.\n");
334 ar->stop_event_polling = true;
336 carlusb_cancel_rings(ar);
338 SDL_WaitThread(ar->event_thread, &event_thread_status);
340 carlusb_free_rings(ar);
341 list_del(&ar->dev_list);
344 static void carlusb_tx_bulk_cb(struct libusb_transfer *transfer);
346 static void carlusb_tx_pending(struct carlusb *ar)
349 struct libusb_transfer *urb;
352 BUG_ON(SDL_mutexP(ar->tx_queue_lock) != 0);
353 if (ar->tx_queue_len >= (AR9170_TX_MAX_ACTIVE_URBS) ||
354 list_empty(&ar->tx_queue))
359 urb = libusb_alloc_transfer(0);
363 frame = list_first_entry(&ar->tx_queue, struct frame, dcb.list);
364 list_del(&frame->dcb.list);
366 if (ar->common.tx_stream) {
367 struct ar9170_stream *tx_stream;
369 tx_stream = frame_push(frame, sizeof(*tx_stream));
370 tx_stream->length = cpu_to_le16(frame->len);
371 tx_stream->tag = cpu_to_le16(0x697e);
374 libusb_fill_bulk_transfer(urb, ar->dev, AR9170_EP_TX, (unsigned char *)
375 frame->data, frame->len, carlusb_tx_bulk_cb, (void *)frame, 0);
377 /* FIXME: ZERO_PACKET support! */
378 urb->flags |= LIBUSB_TRANSFER_FREE_TRANSFER;
379 /* urb->flags |= LIBUSB_TRANSFER_ZERO_PACKET; */
380 frame->dev = (void *) ar;
383 err = libusb_submit_transfer(urb);
385 err("->usb bulk tx submit failed (%d).\n", err);
386 libusb_free_transfer(urb);
390 SDL_mutexV(ar->tx_queue_lock);
394 void carlusb_tx(struct carlu *_ar, struct frame *frame)
396 struct carlusb *ar = (void *)_ar;
398 BUG_ON(SDL_mutexP(ar->tx_queue_lock) != 0);
400 list_add_tail(&frame->dcb.list, &ar->tx_queue);
401 SDL_mutexV(ar->tx_queue_lock);
403 carlusb_tx_pending(ar);
406 static void carlusb_tx_bulk_cb(struct libusb_transfer *transfer)
408 struct frame *frame = (void *) transfer->user_data;
409 struct carlusb *ar = (void *) frame->dev;
411 BUG_ON(SDL_mutexP(ar->tx_queue_lock) != 0);
413 SDL_mutexV(ar->tx_queue_lock);
415 if (ar->common.tx_stream)
416 frame_pull(frame, 4);
418 carlusb_tx_cb(ar, frame);
419 carlusb_tx_pending(ar);
422 static void carlusb_rx_interrupt_cb(struct libusb_transfer *transfer)
424 struct carlusb *ar = (void *) transfer->user_data;
427 switch (transfer->status) {
428 case LIBUSB_TRANSFER_COMPLETED:
429 carlu_handle_command(&ar->common, transfer->buffer, transfer->actual_length);
432 case LIBUSB_TRANSFER_CANCELLED:
436 err("==>rx_irq urb died (%d)\n", transfer->status);
440 err = libusb_submit_transfer(transfer);
442 err("==>rx_irq urb resubmit failed (%d)\n", err);
445 static void carlusb_rx_bulk_cb(struct libusb_transfer *transfer)
447 struct frame *frame = (void *) transfer->user_data;
448 struct carlusb *ar = (void *) frame->dev;
451 switch (transfer->status) {
452 case LIBUSB_TRANSFER_COMPLETED:
453 frame_put(frame, transfer->actual_length);
455 carlu_rx(&ar->common, frame);
457 frame_trim(frame, 0);
460 case LIBUSB_TRANSFER_CANCELLED:
464 err("==>rx_bulk urb died (%d)\n", transfer->status);
468 err = libusb_submit_transfer(transfer);
470 err("->rx_bulk urb resubmit failed (%d)\n", err);
473 static int carlusb_initialize_rxirq(struct carlusb *ar)
477 ar->rx_interrupt = libusb_alloc_transfer(0);
478 if (ar->rx_interrupt == NULL) {
479 err("==>cannot alloc rx interrupt urb\n");
483 libusb_fill_interrupt_transfer(ar->rx_interrupt, ar->dev, AR9170_EP_IRQ,
484 (unsigned char *)&ar->irq_buf, sizeof(ar->irq_buf),
485 carlusb_rx_interrupt_cb, (void *) ar, 0);
487 err = libusb_submit_transfer(ar->rx_interrupt);
489 err("==>failed to submit rx interrupt (%d)\n", err);
493 dbg("rx interrupt is now operational.\n");
497 static int carlusb_initialize_rxrings(struct carlusb *ar)
503 for (i = 0; i < ARRAY_SIZE(ar->rx_ring); i++) {
504 tmp = frame_alloc(ar->rx_max);
508 tmp->dev = (void *) ar;
510 ar->rx_ring[i] = libusb_alloc_transfer(0);
511 if (ar->rx_ring[i] == NULL) {
516 libusb_fill_bulk_transfer(ar->rx_ring[i], ar->dev,
517 AR9170_EP_RX, (unsigned char *)tmp->data,
518 ar->rx_max, carlusb_rx_bulk_cb, (void *)tmp, 0);
520 err = libusb_submit_transfer(ar->rx_ring[i]);
522 err("==>failed to submit rx buld urb (%d)\n", err);
527 dbg("rx ring is now ready to receive.\n");
531 static int carlusb_load_firmware(struct carlusb *ar)
535 dbg("loading firmware...\n");
537 ar->common.fw = carlfw_load(CARL9170_FIRMWARE_FILE);
538 if (IS_ERR_OR_NULL(ar->common.fw))
539 return PTR_ERR(ar->common.fw);
541 ret = carlu_fw_check(&ar->common);
545 ret = carlusb_fw_check(ar);
552 static int carlusb_upload_firmware(struct carlusb *ar, bool boot)
554 uint32_t addr = 0x200000;
559 dbg("initiating firmware image upload procedure.\n");
561 buf = carlfw_get_fw(ar->common.fw, &len);
562 if (IS_ERR_OR_NULL(buf))
565 ret = carlu_fw_check(&ar->common);
569 ret = carlusb_fw_check(ar);
573 if (ar->miniboot_size) {
574 dbg("Miniboot firmware size:%d\n", ar->miniboot_size);
575 len -= ar->miniboot_size;
576 buf += ar->miniboot_size;
580 int blocklen = len > 4096 ? 4096 : len;
582 ret = libusb_control_transfer(ar->dev, 0x40, 0x30, addr >> 8, 0, buf, blocklen, 1000);
583 if (ret != blocklen && ret != LIBUSB_ERROR_TIMEOUT) {
584 err("==>firmware upload failed (%d)\n", ret);
585 return -EXIT_FAILURE;
588 dbg("uploaded %d bytes to start address 0x%04x.\n", blocklen, addr);
596 ret = libusb_control_transfer(ar->dev, 0x40, 0x31, 0, 0, NULL, 0, 5000);
598 err("unable to boot firmware (%d)\n", ret);
599 return -EXIT_FAILURE;
602 /* give the firmware some time to reset & reboot */
606 * since the device did a full usb reset,
607 * we have to get a new "dev".
609 libusb_release_interface(ar->dev, 0);
610 libusb_close(ar->dev);
612 list_del(&ar->dev_list);
614 ret = carlusb_get_dev(ar, false);
620 int carlusb_cmd(struct carlu *_ar, uint8_t oid,
621 uint8_t *cmd, size_t clen,
622 uint8_t *rsp, size_t rlen)
624 struct carlusb *ar = (void *)_ar;
627 if (clen > (CARL9170_MAX_CMD_LEN - 4)) {
628 err("|-> OID:0x%.2x has too much payload (%d octs)\n", oid, (int)clen);
632 ret = SDL_mutexP(ar->common.resp_lock);
634 err("failed to acquire resp_lock.\n");
635 print_hex_dump_bytes(ERROR, "CMD:", ar->cmd_buf, clen);
639 ar->cmd_buf[0] = clen;
640 ar->cmd_buf[1] = oid;
641 /* buf[2] & buf[3] are padding */
642 if (clen && cmd != (uint8_t *)(&ar->cmd_buf[4]))
643 memcpy(&ar->cmd_buf[4], cmd, clen);
645 ar->common.resp_buf = (uint8_t *)rsp;
646 ar->common.resp_len = rlen;
648 ret = libusb_interrupt_transfer(ar->dev, AR9170_EP_CMD, ar->cmd_buf, clen + 4, &send, 32);
650 err("OID:0x%.2x failed due to (%d) (%d).\n", oid, ret, send);
651 print_hex_dump_bytes(ERROR, "CMD:", ar->cmd_buf, clen);
652 SDL_mutexV(ar->common.resp_lock);
656 ret = SDL_CondWaitTimeout(ar->common.resp_pend, ar->common.resp_lock, 100);
658 err("|-> OID:0x%.2x timed out %d.\n", oid, ret);
659 ar->common.resp_buf = NULL;
660 ar->common.resp_len = 0;
664 SDL_mutexV(ar->common.resp_lock);
668 struct carlu *carlusb_probe(void)
677 ret = carlusb_show_devinfo(ar);
681 ret = carlusb_load_firmware(ar);
685 ret = pipe(ar->event_pipe);
689 ar->stop_event_polling = false;
690 ar->event_thread = SDL_CreateThread(carlusb_event_thread, ar);
692 ret = carlusb_load_firmware(ar);
696 ret = carlusb_upload_firmware(ar, true);
700 ret = carlusb_initialize_rxirq(ar);
704 ret = carlusb_initialize_rxrings(ar);
708 ret = carlu_cmd_echo(&ar->common, 0x44110dee);
710 err("echo test failed...\n");
714 info("firmware is active and running.\n");
716 carlu_fw_info(&ar->common);
724 carlusb_free_driver(ar);
725 err("usb device rendezvous failed (%d).\n", ret);
730 void carlusb_close(struct carlu *_ar)
732 struct carlusb *ar = (void *) _ar;
734 carlu_cmd_reboot(_ar);
737 carlusb_free_driver(ar);
740 int carlusb_print_known_devices(void)
746 info("==> dumping known device list <==\n");
747 for (i = 0; i < ARRAY_SIZE(dev_list); i++) {
748 info("Vendor:\"%-9s\" Product:\"%-26s\" => USBID:[0x%04x:0x%04x]\n",
749 dev_list[i].vendor_name, dev_list[i].product_name,
750 dev_list[i].idVendor, dev_list[i].idProduct);
752 info("==> end of device list <==\n");
761 ret = libusb_init(&usb_ctx);
763 err("failed to initialize usb subsystem (%d)\n", ret);
767 /* like a silent chatterbox! */
768 libusb_set_debug(usb_ctx, 2);
775 libusb_exit(usb_ctx);