2 * atusb.c - Driver for the ATUSB IEEE 802.15.4 dongle
4 * Written 2013 by Werner Almesberger <werner@almesberger.net>
6 * Copyright (c) 2015 - 2016 Stefan Schmidt <stefan@datenfreihafen.org>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation, version 2
12 * Based on at86rf230.c and spi_atusb.c.
14 * Copyright (C) 2009 Siemens AG
15 * Written by: Dmitry Eremin-Solenikov <dmitry.baryshkov@siemens.com>
18 * Copyright (c) 2011 Richard Sharpe <realrichardsharpe@gmail.com>
19 * Copyright (c) 2011 Stefan Schmidt <stefan@datenfreihafen.org>
20 * Copyright (c) 2011 Werner Almesberger <werner@almesberger.net>
22 * USB initialization is
23 * Copyright (c) 2013 Alexander Aring <alex.aring@gmail.com>
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/jiffies.h>
30 #include <linux/usb.h>
31 #include <linux/skbuff.h>
33 #include <net/cfg802154.h>
34 #include <net/mac802154.h>
36 #include "at86rf230.h"
39 #define ATUSB_JEDEC_ATMEL 0x1f /* JEDEC manufacturer ID */
41 #define ATUSB_NUM_RX_URBS 4 /* allow for a bit of local latency */
42 #define ATUSB_ALLOC_DELAY_MS 100 /* delay after failed allocation */
43 #define ATUSB_TX_TIMEOUT_MS 200 /* on the air timeout */
46 struct ieee802154_hw
*hw
;
47 struct usb_device
*usb_dev
;
48 int shutdown
; /* non-zero if shutting down */
49 int err
; /* set by first error */
52 struct delayed_work work
; /* memory allocations */
53 struct usb_anchor idle_urbs
; /* URBs waiting to be submitted */
54 struct usb_anchor rx_urbs
; /* URBs waiting for reception */
57 struct usb_ctrlrequest tx_dr
;
59 struct sk_buff
*tx_skb
;
60 uint8_t tx_ack_seq
; /* current TX ACK sequence number */
63 /* ----- USB commands without data ----------------------------------------- */
65 /* To reduce the number of error checks in the code, we record the first error
66 * in atusb->err and reject all subsequent requests until the error is cleared.
69 static int atusb_control_msg(struct atusb
*atusb
, unsigned int pipe
,
70 __u8 request
, __u8 requesttype
,
71 __u16 value
, __u16 index
,
72 void *data
, __u16 size
, int timeout
)
74 struct usb_device
*usb_dev
= atusb
->usb_dev
;
80 ret
= usb_control_msg(usb_dev
, pipe
, request
, requesttype
,
81 value
, index
, data
, size
, timeout
);
84 dev_err(&usb_dev
->dev
,
85 "atusb_control_msg: req 0x%02x val 0x%x idx 0x%x, error %d\n",
86 request
, value
, index
, ret
);
91 static int atusb_command(struct atusb
*atusb
, uint8_t cmd
, uint8_t arg
)
93 struct usb_device
*usb_dev
= atusb
->usb_dev
;
95 dev_dbg(&usb_dev
->dev
, "atusb_command: cmd = 0x%x\n", cmd
);
96 return atusb_control_msg(atusb
, usb_sndctrlpipe(usb_dev
, 0),
97 cmd
, ATUSB_REQ_TO_DEV
, arg
, 0, NULL
, 0, 1000);
100 static int atusb_write_reg(struct atusb
*atusb
, uint8_t reg
, uint8_t value
)
102 struct usb_device
*usb_dev
= atusb
->usb_dev
;
104 dev_dbg(&usb_dev
->dev
, "atusb_write_reg: 0x%02x <- 0x%02x\n",
106 return atusb_control_msg(atusb
, usb_sndctrlpipe(usb_dev
, 0),
107 ATUSB_REG_WRITE
, ATUSB_REQ_TO_DEV
,
108 value
, reg
, NULL
, 0, 1000);
111 static int atusb_read_reg(struct atusb
*atusb
, uint8_t reg
)
113 struct usb_device
*usb_dev
= atusb
->usb_dev
;
117 dev_dbg(&usb_dev
->dev
, "atusb: reg = 0x%x\n", reg
);
118 ret
= atusb_control_msg(atusb
, usb_rcvctrlpipe(usb_dev
, 0),
119 ATUSB_REG_READ
, ATUSB_REQ_FROM_DEV
,
120 0, reg
, &value
, 1, 1000);
121 return ret
>= 0 ? value
: ret
;
124 static int atusb_write_subreg(struct atusb
*atusb
, uint8_t reg
, uint8_t mask
,
125 uint8_t shift
, uint8_t value
)
127 struct usb_device
*usb_dev
= atusb
->usb_dev
;
131 dev_dbg(&usb_dev
->dev
, "atusb_write_subreg: 0x%02x <- 0x%02x\n",
134 orig
= atusb_read_reg(atusb
, reg
);
136 /* Write the value only into that part of the register which is allowed
137 * by the mask. All other bits stay as before.
140 tmp
|= (value
<< shift
) & mask
;
143 ret
= atusb_write_reg(atusb
, reg
, tmp
);
148 static int atusb_get_and_clear_error(struct atusb
*atusb
)
150 int err
= atusb
->err
;
156 /* ----- skb allocation ---------------------------------------------------- */
159 #define MAX_RX_XFER (1 + MAX_PSDU + 2 + 1) /* PHR+PSDU+CRC+LQI */
161 #define SKB_ATUSB(skb) (*(struct atusb **)(skb)->cb)
163 static void atusb_in(struct urb
*urb
);
165 static int atusb_submit_rx_urb(struct atusb
*atusb
, struct urb
*urb
)
167 struct usb_device
*usb_dev
= atusb
->usb_dev
;
168 struct sk_buff
*skb
= urb
->context
;
172 skb
= alloc_skb(MAX_RX_XFER
, GFP_KERNEL
);
174 dev_warn_ratelimited(&usb_dev
->dev
,
175 "atusb_in: can't allocate skb\n");
178 skb_put(skb
, MAX_RX_XFER
);
179 SKB_ATUSB(skb
) = atusb
;
182 usb_fill_bulk_urb(urb
, usb_dev
, usb_rcvbulkpipe(usb_dev
, 1),
183 skb
->data
, MAX_RX_XFER
, atusb_in
, skb
);
184 usb_anchor_urb(urb
, &atusb
->rx_urbs
);
186 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
188 usb_unanchor_urb(urb
);
195 static void atusb_work_urbs(struct work_struct
*work
)
197 struct atusb
*atusb
=
198 container_of(to_delayed_work(work
), struct atusb
, work
);
199 struct usb_device
*usb_dev
= atusb
->usb_dev
;
207 urb
= usb_get_from_anchor(&atusb
->idle_urbs
);
210 ret
= atusb_submit_rx_urb(atusb
, urb
);
213 usb_anchor_urb(urb
, &atusb
->idle_urbs
);
214 dev_warn_ratelimited(&usb_dev
->dev
,
215 "atusb_in: can't allocate/submit URB (%d)\n", ret
);
216 schedule_delayed_work(&atusb
->work
,
217 msecs_to_jiffies(ATUSB_ALLOC_DELAY_MS
) + 1);
220 /* ----- Asynchronous USB -------------------------------------------------- */
222 static void atusb_tx_done(struct atusb
*atusb
, uint8_t seq
)
224 struct usb_device
*usb_dev
= atusb
->usb_dev
;
225 uint8_t expect
= atusb
->tx_ack_seq
;
227 dev_dbg(&usb_dev
->dev
, "atusb_tx_done (0x%02x/0x%02x)\n", seq
, expect
);
229 /* TODO check for ifs handling in firmware */
230 ieee802154_xmit_complete(atusb
->hw
, atusb
->tx_skb
, false);
232 /* TODO I experience this case when atusb has a tx complete
233 * irq before probing, we should fix the firmware it's an
234 * unlikely case now that seq == expect is then true, but can
235 * happen and fail with a tx_skb = NULL;
237 ieee802154_wake_queue(atusb
->hw
);
239 dev_kfree_skb_irq(atusb
->tx_skb
);
243 static void atusb_in_good(struct urb
*urb
)
245 struct usb_device
*usb_dev
= urb
->dev
;
246 struct sk_buff
*skb
= urb
->context
;
247 struct atusb
*atusb
= SKB_ATUSB(skb
);
250 if (!urb
->actual_length
) {
251 dev_dbg(&usb_dev
->dev
, "atusb_in: zero-sized URB ?\n");
257 if (urb
->actual_length
== 1) {
258 atusb_tx_done(atusb
, len
);
262 if (len
+ 1 > urb
->actual_length
- 1) {
263 dev_dbg(&usb_dev
->dev
, "atusb_in: frame len %d+1 > URB %u-1\n",
264 len
, urb
->actual_length
);
268 if (!ieee802154_is_valid_psdu_len(len
)) {
269 dev_dbg(&usb_dev
->dev
, "atusb_in: frame corrupted\n");
273 lqi
= skb
->data
[len
+ 1];
274 dev_dbg(&usb_dev
->dev
, "atusb_in: rx len %d lqi 0x%02x\n", len
, lqi
);
275 skb_pull(skb
, 1); /* remove PHR */
276 skb_trim(skb
, len
); /* get payload only */
277 ieee802154_rx_irqsafe(atusb
->hw
, skb
, lqi
);
278 urb
->context
= NULL
; /* skb is gone */
281 static void atusb_in(struct urb
*urb
)
283 struct usb_device
*usb_dev
= urb
->dev
;
284 struct sk_buff
*skb
= urb
->context
;
285 struct atusb
*atusb
= SKB_ATUSB(skb
);
287 dev_dbg(&usb_dev
->dev
, "atusb_in: status %d len %d\n",
288 urb
->status
, urb
->actual_length
);
290 if (urb
->status
== -ENOENT
) { /* being killed */
295 dev_dbg(&usb_dev
->dev
, "atusb_in: URB error %d\n", urb
->status
);
300 usb_anchor_urb(urb
, &atusb
->idle_urbs
);
301 if (!atusb
->shutdown
)
302 schedule_delayed_work(&atusb
->work
, 0);
305 /* ----- URB allocation/deallocation --------------------------------------- */
307 static void atusb_free_urbs(struct atusb
*atusb
)
312 urb
= usb_get_from_anchor(&atusb
->idle_urbs
);
315 kfree_skb(urb
->context
);
320 static int atusb_alloc_urbs(struct atusb
*atusb
, int n
)
325 urb
= usb_alloc_urb(0, GFP_KERNEL
);
327 atusb_free_urbs(atusb
);
330 usb_anchor_urb(urb
, &atusb
->idle_urbs
);
336 /* ----- IEEE 802.15.4 interface operations -------------------------------- */
338 static void atusb_xmit_complete(struct urb
*urb
)
340 dev_dbg(&urb
->dev
->dev
, "atusb_xmit urb completed");
343 static int atusb_xmit(struct ieee802154_hw
*hw
, struct sk_buff
*skb
)
345 struct atusb
*atusb
= hw
->priv
;
346 struct usb_device
*usb_dev
= atusb
->usb_dev
;
349 dev_dbg(&usb_dev
->dev
, "atusb_xmit (%d)\n", skb
->len
);
352 atusb
->tx_dr
.wIndex
= cpu_to_le16(atusb
->tx_ack_seq
);
353 atusb
->tx_dr
.wLength
= cpu_to_le16(skb
->len
);
355 usb_fill_control_urb(atusb
->tx_urb
, usb_dev
,
356 usb_sndctrlpipe(usb_dev
, 0),
357 (unsigned char *)&atusb
->tx_dr
, skb
->data
,
358 skb
->len
, atusb_xmit_complete
, NULL
);
359 ret
= usb_submit_urb(atusb
->tx_urb
, GFP_ATOMIC
);
360 dev_dbg(&usb_dev
->dev
, "atusb_xmit done (%d)\n", ret
);
364 static int atusb_channel(struct ieee802154_hw
*hw
, u8 page
, u8 channel
)
366 struct atusb
*atusb
= hw
->priv
;
369 /* This implicitly sets the CCA (Clear Channel Assessment) mode to 0,
370 * "Mode 3a, Carrier sense OR energy above threshold".
371 * We should probably make this configurable. @@@
373 ret
= atusb_write_reg(atusb
, RG_PHY_CC_CCA
, channel
);
376 msleep(1); /* @@@ ugly synchronization */
380 static int atusb_ed(struct ieee802154_hw
*hw
, u8
*level
)
387 static int atusb_set_hw_addr_filt(struct ieee802154_hw
*hw
,
388 struct ieee802154_hw_addr_filt
*filt
,
389 unsigned long changed
)
391 struct atusb
*atusb
= hw
->priv
;
392 struct device
*dev
= &atusb
->usb_dev
->dev
;
394 if (changed
& IEEE802154_AFILT_SADDR_CHANGED
) {
395 u16 addr
= le16_to_cpu(filt
->short_addr
);
397 dev_vdbg(dev
, "atusb_set_hw_addr_filt called for saddr\n");
398 atusb_write_reg(atusb
, RG_SHORT_ADDR_0
, addr
);
399 atusb_write_reg(atusb
, RG_SHORT_ADDR_1
, addr
>> 8);
402 if (changed
& IEEE802154_AFILT_PANID_CHANGED
) {
403 u16 pan
= le16_to_cpu(filt
->pan_id
);
405 dev_vdbg(dev
, "atusb_set_hw_addr_filt called for pan id\n");
406 atusb_write_reg(atusb
, RG_PAN_ID_0
, pan
);
407 atusb_write_reg(atusb
, RG_PAN_ID_1
, pan
>> 8);
410 if (changed
& IEEE802154_AFILT_IEEEADDR_CHANGED
) {
411 u8 i
, addr
[IEEE802154_EXTENDED_ADDR_LEN
];
413 memcpy(addr
, &filt
->ieee_addr
, IEEE802154_EXTENDED_ADDR_LEN
);
414 dev_vdbg(dev
, "atusb_set_hw_addr_filt called for IEEE addr\n");
415 for (i
= 0; i
< 8; i
++)
416 atusb_write_reg(atusb
, RG_IEEE_ADDR_0
+ i
, addr
[i
]);
419 if (changed
& IEEE802154_AFILT_PANC_CHANGED
) {
421 "atusb_set_hw_addr_filt called for panc change\n");
423 atusb_write_subreg(atusb
, SR_AACK_I_AM_COORD
, 1);
425 atusb_write_subreg(atusb
, SR_AACK_I_AM_COORD
, 0);
428 return atusb_get_and_clear_error(atusb
);
431 static int atusb_start(struct ieee802154_hw
*hw
)
433 struct atusb
*atusb
= hw
->priv
;
434 struct usb_device
*usb_dev
= atusb
->usb_dev
;
437 dev_dbg(&usb_dev
->dev
, "atusb_start\n");
438 schedule_delayed_work(&atusb
->work
, 0);
439 atusb_command(atusb
, ATUSB_RX_MODE
, 1);
440 ret
= atusb_get_and_clear_error(atusb
);
442 usb_kill_anchored_urbs(&atusb
->idle_urbs
);
446 static void atusb_stop(struct ieee802154_hw
*hw
)
448 struct atusb
*atusb
= hw
->priv
;
449 struct usb_device
*usb_dev
= atusb
->usb_dev
;
451 dev_dbg(&usb_dev
->dev
, "atusb_stop\n");
452 usb_kill_anchored_urbs(&atusb
->idle_urbs
);
453 atusb_command(atusb
, ATUSB_RX_MODE
, 0);
454 atusb_get_and_clear_error(atusb
);
457 #define ATUSB_MAX_TX_POWERS 0xF
458 static const s32 atusb_powers
[ATUSB_MAX_TX_POWERS
+ 1] = {
459 300, 280, 230, 180, 130, 70, 0, -100, -200, -300, -400, -500, -700,
464 atusb_set_txpower(struct ieee802154_hw
*hw
, s32 mbm
)
466 struct atusb
*atusb
= hw
->priv
;
469 for (i
= 0; i
< hw
->phy
->supported
.tx_powers_size
; i
++) {
470 if (hw
->phy
->supported
.tx_powers
[i
] == mbm
)
471 return atusb_write_subreg(atusb
, SR_TX_PWR_23X
, i
);
477 #define ATUSB_MAX_ED_LEVELS 0xF
478 static const s32 atusb_ed_levels
[ATUSB_MAX_ED_LEVELS
+ 1] = {
479 -9100, -8900, -8700, -8500, -8300, -8100, -7900, -7700, -7500, -7300,
480 -7100, -6900, -6700, -6500, -6300, -6100,
484 atusb_set_cca_mode(struct ieee802154_hw
*hw
, const struct wpan_phy_cca
*cca
)
486 struct atusb
*atusb
= hw
->priv
;
489 /* mapping 802.15.4 to driver spec */
491 case NL802154_CCA_ENERGY
:
494 case NL802154_CCA_CARRIER
:
497 case NL802154_CCA_ENERGY_CARRIER
:
499 case NL802154_CCA_OPT_ENERGY_CARRIER_AND
:
502 case NL802154_CCA_OPT_ENERGY_CARRIER_OR
:
513 return atusb_write_subreg(atusb
, SR_CCA_MODE
, val
);
517 atusb_set_cca_ed_level(struct ieee802154_hw
*hw
, s32 mbm
)
519 struct atusb
*atusb
= hw
->priv
;
522 for (i
= 0; i
< hw
->phy
->supported
.cca_ed_levels_size
; i
++) {
523 if (hw
->phy
->supported
.cca_ed_levels
[i
] == mbm
)
524 return atusb_write_subreg(atusb
, SR_CCA_ED_THRES
, i
);
531 atusb_set_csma_params(struct ieee802154_hw
*hw
, u8 min_be
, u8 max_be
, u8 retries
)
533 struct atusb
*atusb
= hw
->priv
;
536 ret
= atusb_write_subreg(atusb
, SR_MIN_BE
, min_be
);
540 ret
= atusb_write_subreg(atusb
, SR_MAX_BE
, max_be
);
544 return atusb_write_subreg(atusb
, SR_MAX_CSMA_RETRIES
, retries
);
548 atusb_set_promiscuous_mode(struct ieee802154_hw
*hw
, const bool on
)
550 struct atusb
*atusb
= hw
->priv
;
554 ret
= atusb_write_subreg(atusb
, SR_AACK_DIS_ACK
, 1);
558 ret
= atusb_write_subreg(atusb
, SR_AACK_PROM_MODE
, 1);
562 ret
= atusb_write_subreg(atusb
, SR_AACK_PROM_MODE
, 0);
566 ret
= atusb_write_subreg(atusb
, SR_AACK_DIS_ACK
, 0);
574 static struct ieee802154_ops atusb_ops
= {
575 .owner
= THIS_MODULE
,
576 .xmit_async
= atusb_xmit
,
578 .set_channel
= atusb_channel
,
579 .start
= atusb_start
,
581 .set_hw_addr_filt
= atusb_set_hw_addr_filt
,
582 .set_txpower
= atusb_set_txpower
,
583 .set_cca_mode
= atusb_set_cca_mode
,
584 .set_cca_ed_level
= atusb_set_cca_ed_level
,
585 .set_csma_params
= atusb_set_csma_params
,
586 .set_promiscuous_mode
= atusb_set_promiscuous_mode
,
589 /* ----- Firmware and chip version information ----------------------------- */
591 static int atusb_get_and_show_revision(struct atusb
*atusb
)
593 struct usb_device
*usb_dev
= atusb
->usb_dev
;
594 unsigned char buffer
[3];
597 /* Get a couple of the ATMega Firmware values */
598 ret
= atusb_control_msg(atusb
, usb_rcvctrlpipe(usb_dev
, 0),
599 ATUSB_ID
, ATUSB_REQ_FROM_DEV
, 0, 0,
602 dev_info(&usb_dev
->dev
,
603 "Firmware: major: %u, minor: %u, hardware type: %u\n",
604 buffer
[0], buffer
[1], buffer
[2]);
605 if (buffer
[0] == 0 && buffer
[1] < 2) {
606 dev_info(&usb_dev
->dev
,
607 "Firmware version (%u.%u) is predates our first public release.",
608 buffer
[0], buffer
[1]);
609 dev_info(&usb_dev
->dev
, "Please update to version 0.2 or newer");
615 static int atusb_get_and_show_build(struct atusb
*atusb
)
617 struct usb_device
*usb_dev
= atusb
->usb_dev
;
618 char build
[ATUSB_BUILD_SIZE
+ 1];
621 ret
= atusb_control_msg(atusb
, usb_rcvctrlpipe(usb_dev
, 0),
622 ATUSB_BUILD
, ATUSB_REQ_FROM_DEV
, 0, 0,
623 build
, ATUSB_BUILD_SIZE
, 1000);
626 dev_info(&usb_dev
->dev
, "Firmware: build %s\n", build
);
632 static int atusb_get_and_show_chip(struct atusb
*atusb
)
634 struct usb_device
*usb_dev
= atusb
->usb_dev
;
635 uint8_t man_id_0
, man_id_1
, part_num
, version_num
;
638 man_id_0
= atusb_read_reg(atusb
, RG_MAN_ID_0
);
639 man_id_1
= atusb_read_reg(atusb
, RG_MAN_ID_1
);
640 part_num
= atusb_read_reg(atusb
, RG_PART_NUM
);
641 version_num
= atusb_read_reg(atusb
, RG_VERSION_NUM
);
646 if ((man_id_1
<< 8 | man_id_0
) != ATUSB_JEDEC_ATMEL
) {
647 dev_err(&usb_dev
->dev
,
648 "non-Atmel transceiver xxxx%02x%02x\n",
661 dev_err(&usb_dev
->dev
,
662 "unexpected transceiver, part 0x%02x version 0x%02x\n",
663 part_num
, version_num
);
667 dev_info(&usb_dev
->dev
, "ATUSB: %s version %d\n", chip
, version_num
);
672 atusb
->err
= -ENODEV
;
676 /* ----- Setup ------------------------------------------------------------- */
678 static int atusb_probe(struct usb_interface
*interface
,
679 const struct usb_device_id
*id
)
681 struct usb_device
*usb_dev
= interface_to_usbdev(interface
);
682 struct ieee802154_hw
*hw
;
683 struct atusb
*atusb
= NULL
;
686 hw
= ieee802154_alloc_hw(sizeof(struct atusb
), &atusb_ops
);
692 atusb
->usb_dev
= usb_get_dev(usb_dev
);
693 usb_set_intfdata(interface
, atusb
);
697 INIT_DELAYED_WORK(&atusb
->work
, atusb_work_urbs
);
698 init_usb_anchor(&atusb
->idle_urbs
);
699 init_usb_anchor(&atusb
->rx_urbs
);
701 if (atusb_alloc_urbs(atusb
, ATUSB_NUM_RX_URBS
))
704 atusb
->tx_dr
.bRequestType
= ATUSB_REQ_TO_DEV
;
705 atusb
->tx_dr
.bRequest
= ATUSB_TX
;
706 atusb
->tx_dr
.wValue
= cpu_to_le16(0);
708 atusb
->tx_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
712 hw
->parent
= &usb_dev
->dev
;
713 hw
->flags
= IEEE802154_HW_TX_OMIT_CKSUM
| IEEE802154_HW_AFILT
|
714 IEEE802154_HW_PROMISCUOUS
| IEEE802154_HW_CSMA_PARAMS
;
716 hw
->phy
->flags
= WPAN_PHY_FLAG_TXPOWER
| WPAN_PHY_FLAG_CCA_ED_LEVEL
|
717 WPAN_PHY_FLAG_CCA_MODE
;
719 hw
->phy
->supported
.cca_modes
= BIT(NL802154_CCA_ENERGY
) |
720 BIT(NL802154_CCA_CARRIER
) | BIT(NL802154_CCA_ENERGY_CARRIER
);
721 hw
->phy
->supported
.cca_opts
= BIT(NL802154_CCA_OPT_ENERGY_CARRIER_AND
) |
722 BIT(NL802154_CCA_OPT_ENERGY_CARRIER_OR
);
724 hw
->phy
->supported
.cca_ed_levels
= atusb_ed_levels
;
725 hw
->phy
->supported
.cca_ed_levels_size
= ARRAY_SIZE(atusb_ed_levels
);
727 hw
->phy
->cca
.mode
= NL802154_CCA_ENERGY
;
729 hw
->phy
->current_page
= 0;
730 hw
->phy
->current_channel
= 11; /* reset default */
731 hw
->phy
->supported
.channels
[0] = 0x7FFF800;
732 hw
->phy
->supported
.tx_powers
= atusb_powers
;
733 hw
->phy
->supported
.tx_powers_size
= ARRAY_SIZE(atusb_powers
);
734 hw
->phy
->transmit_power
= hw
->phy
->supported
.tx_powers
[0];
735 ieee802154_random_extended_addr(&hw
->phy
->perm_extended_addr
);
736 hw
->phy
->cca_ed_level
= hw
->phy
->supported
.cca_ed_levels
[7];
738 atusb_command(atusb
, ATUSB_RF_RESET
, 0);
739 atusb_get_and_show_chip(atusb
);
740 atusb_get_and_show_revision(atusb
);
741 atusb_get_and_show_build(atusb
);
742 ret
= atusb_get_and_clear_error(atusb
);
744 dev_err(&atusb
->usb_dev
->dev
,
745 "%s: initialization failed, error = %d\n",
750 ret
= ieee802154_register_hw(hw
);
754 /* If we just powered on, we're now in P_ON and need to enter TRX_OFF
755 * explicitly. Any resets after that will send us straight to TRX_OFF,
756 * making the command below redundant.
758 atusb_write_reg(atusb
, RG_TRX_STATE
, STATE_FORCE_TRX_OFF
);
759 msleep(1); /* reset => TRX_OFF, tTR13 = 37 us */
762 /* Calculating the maximum time available to empty the frame buffer
765 * According to [1], the inter-frame gap is
766 * R * 20 * 16 us + 128 us
767 * where R is a random number from 0 to 7. Furthermore, we have 20 bit
768 * times (80 us at 250 kbps) of SHR of the next frame before the
769 * transceiver begins storing data in the frame buffer.
771 * This yields a minimum time of 208 us between the last data of a
772 * frame and the first data of the next frame. This time is further
773 * reduced by interrupt latency in the atusb firmware.
775 * atusb currently needs about 500 us to retrieve a maximum-sized
776 * frame. We therefore have to allow reception of a new frame to begin
777 * while we retrieve the previous frame.
779 * [1] "JN-AN-1035 Calculating data rates in an IEEE 802.15.4-based
780 * network", Jennic 2006.
781 * http://www.jennic.com/download_file.php?supportFile=JN-AN-1035%20Calculating%20802-15-4%20Data%20Rates-1v0.pdf
784 atusb_write_subreg(atusb
, SR_RX_SAFE_MODE
, 1);
786 atusb_write_reg(atusb
, RG_IRQ_MASK
, 0xff);
788 ret
= atusb_get_and_clear_error(atusb
);
792 dev_err(&atusb
->usb_dev
->dev
,
793 "%s: setup failed, error = %d\n",
796 ieee802154_unregister_hw(hw
);
798 atusb_free_urbs(atusb
);
799 usb_kill_urb(atusb
->tx_urb
);
800 usb_free_urb(atusb
->tx_urb
);
801 usb_put_dev(usb_dev
);
802 ieee802154_free_hw(hw
);
806 static void atusb_disconnect(struct usb_interface
*interface
)
808 struct atusb
*atusb
= usb_get_intfdata(interface
);
810 dev_dbg(&atusb
->usb_dev
->dev
, "atusb_disconnect\n");
813 cancel_delayed_work_sync(&atusb
->work
);
815 usb_kill_anchored_urbs(&atusb
->rx_urbs
);
816 atusb_free_urbs(atusb
);
817 usb_kill_urb(atusb
->tx_urb
);
818 usb_free_urb(atusb
->tx_urb
);
820 ieee802154_unregister_hw(atusb
->hw
);
822 ieee802154_free_hw(atusb
->hw
);
824 usb_set_intfdata(interface
, NULL
);
825 usb_put_dev(atusb
->usb_dev
);
827 pr_debug("atusb_disconnect done\n");
830 /* The devices we work with */
831 static const struct usb_device_id atusb_device_table
[] = {
833 .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
|
834 USB_DEVICE_ID_MATCH_INT_INFO
,
835 .idVendor
= ATUSB_VENDOR_ID
,
836 .idProduct
= ATUSB_PRODUCT_ID
,
837 .bInterfaceClass
= USB_CLASS_VENDOR_SPEC
839 /* end with null element */
842 MODULE_DEVICE_TABLE(usb
, atusb_device_table
);
844 static struct usb_driver atusb_driver
= {
846 .probe
= atusb_probe
,
847 .disconnect
= atusb_disconnect
,
848 .id_table
= atusb_device_table
,
850 module_usb_driver(atusb_driver
);
852 MODULE_AUTHOR("Alexander Aring <alex.aring@gmail.com>");
853 MODULE_AUTHOR("Richard Sharpe <realrichardsharpe@gmail.com>");
854 MODULE_AUTHOR("Stefan Schmidt <stefan@datenfreihafen.org>");
855 MODULE_AUTHOR("Werner Almesberger <werner@almesberger.net>");
856 MODULE_DESCRIPTION("ATUSB IEEE 802.15.4 Driver");
857 MODULE_LICENSE("GPL");