1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * atusb.c - Driver for the ATUSB IEEE 802.15.4 dongle |
4 | * |
5 | * Written 2013 by Werner Almesberger <werner@almesberger.net> |
6 | * |
7 | * Copyright (c) 2015 - 2016 Stefan Schmidt <stefan@datenfreihafen.org> |
8 | * |
9 | * Based on at86rf230.c and spi_atusb.c. |
10 | * at86rf230.c is |
11 | * Copyright (C) 2009 Siemens AG |
12 | * Written by: Dmitry Eremin-Solenikov <dmitry.baryshkov@siemens.com> |
13 | * |
14 | * spi_atusb.c is |
15 | * Copyright (c) 2011 Richard Sharpe <realrichardsharpe@gmail.com> |
16 | * Copyright (c) 2011 Stefan Schmidt <stefan@datenfreihafen.org> |
17 | * Copyright (c) 2011 Werner Almesberger <werner@almesberger.net> |
18 | * |
19 | * USB initialization is |
20 | * Copyright (c) 2013 Alexander Aring <alex.aring@gmail.com> |
21 | * |
22 | * Busware HUL support is |
23 | * Copyright (c) 2017 Josef Filzmaier <j.filzmaier@gmx.at> |
24 | */ |
25 | |
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> |
32 | |
33 | #include <net/cfg802154.h> |
34 | #include <net/mac802154.h> |
35 | |
36 | #include "at86rf230.h" |
37 | #include "atusb.h" |
38 | |
39 | #define ATUSB_JEDEC_ATMEL 0x1f /* JEDEC manufacturer ID */ |
40 | |
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 */ |
44 | |
45 | struct atusb { |
46 | struct ieee802154_hw *hw; |
47 | struct usb_device *usb_dev; |
48 | struct atusb_chip_data *data; |
49 | int shutdown; /* non-zero if shutting down */ |
50 | int err; /* set by first error */ |
51 | |
52 | /* RX variables */ |
53 | struct delayed_work work; /* memory allocations */ |
54 | struct usb_anchor idle_urbs; /* URBs waiting to be submitted */ |
55 | struct usb_anchor rx_urbs; /* URBs waiting for reception */ |
56 | |
57 | /* TX variables */ |
58 | struct usb_ctrlrequest tx_dr; |
59 | struct urb *tx_urb; |
60 | struct sk_buff *tx_skb; |
61 | u8 tx_ack_seq; /* current TX ACK sequence number */ |
62 | |
63 | /* Firmware variable */ |
64 | unsigned char fw_ver_maj; /* Firmware major version number */ |
65 | unsigned char fw_ver_min; /* Firmware minor version number */ |
66 | unsigned char fw_hw_type; /* Firmware hardware type */ |
67 | }; |
68 | |
69 | struct atusb_chip_data { |
70 | u16 t_channel_switch; |
71 | int ; |
72 | |
73 | int (*set_channel)(struct ieee802154_hw*, u8, u8); |
74 | int (*set_txpower)(struct ieee802154_hw*, s32); |
75 | }; |
76 | |
77 | static int atusb_write_subreg(struct atusb *atusb, u8 reg, u8 mask, |
78 | u8 shift, u8 value) |
79 | { |
80 | struct usb_device *usb_dev = atusb->usb_dev; |
81 | u8 orig, tmp; |
82 | int ret = 0; |
83 | |
84 | dev_dbg(&usb_dev->dev, "%s: 0x%02x <- 0x%02x\n" , __func__, reg, value); |
85 | |
86 | ret = usb_control_msg_recv(dev: usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
87 | value: 0, index: reg, data: &orig, size: 1, timeout: 1000, GFP_KERNEL); |
88 | if (ret < 0) |
89 | return ret; |
90 | |
91 | /* Write the value only into that part of the register which is allowed |
92 | * by the mask. All other bits stay as before. |
93 | */ |
94 | tmp = orig & ~mask; |
95 | tmp |= (value << shift) & mask; |
96 | |
97 | if (tmp != orig) |
98 | ret = usb_control_msg_send(dev: usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
99 | value: tmp, index: reg, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
100 | |
101 | return ret; |
102 | } |
103 | |
104 | static int atusb_read_subreg(struct atusb *lp, |
105 | unsigned int addr, unsigned int mask, |
106 | unsigned int shift) |
107 | { |
108 | int reg, ret; |
109 | |
110 | ret = usb_control_msg_recv(dev: lp->usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
111 | value: 0, index: addr, data: ®, size: 1, timeout: 1000, GFP_KERNEL); |
112 | if (ret < 0) |
113 | return ret; |
114 | |
115 | reg = (reg & mask) >> shift; |
116 | |
117 | return reg; |
118 | } |
119 | |
120 | static int atusb_get_and_clear_error(struct atusb *atusb) |
121 | { |
122 | int err = atusb->err; |
123 | |
124 | atusb->err = 0; |
125 | return err; |
126 | } |
127 | |
128 | /* ----- skb allocation ---------------------------------------------------- */ |
129 | |
130 | #define MAX_PSDU 127 |
131 | #define MAX_RX_XFER (1 + MAX_PSDU + 2 + 1) /* PHR+PSDU+CRC+LQI */ |
132 | |
133 | #define SKB_ATUSB(skb) (*(struct atusb **)(skb)->cb) |
134 | |
135 | static void atusb_in(struct urb *urb); |
136 | |
137 | static int atusb_submit_rx_urb(struct atusb *atusb, struct urb *urb) |
138 | { |
139 | struct usb_device *usb_dev = atusb->usb_dev; |
140 | struct sk_buff *skb = urb->context; |
141 | int ret; |
142 | |
143 | if (!skb) { |
144 | skb = alloc_skb(MAX_RX_XFER, GFP_KERNEL); |
145 | if (!skb) { |
146 | dev_warn_ratelimited(&usb_dev->dev, |
147 | "atusb_in: can't allocate skb\n" ); |
148 | return -ENOMEM; |
149 | } |
150 | skb_put(skb, MAX_RX_XFER); |
151 | SKB_ATUSB(skb) = atusb; |
152 | } |
153 | |
154 | usb_fill_bulk_urb(urb, dev: usb_dev, usb_rcvbulkpipe(usb_dev, 1), |
155 | transfer_buffer: skb->data, MAX_RX_XFER, complete_fn: atusb_in, context: skb); |
156 | usb_anchor_urb(urb, anchor: &atusb->rx_urbs); |
157 | |
158 | ret = usb_submit_urb(urb, GFP_KERNEL); |
159 | if (ret) { |
160 | usb_unanchor_urb(urb); |
161 | kfree_skb(skb); |
162 | urb->context = NULL; |
163 | } |
164 | return ret; |
165 | } |
166 | |
167 | static void atusb_work_urbs(struct work_struct *work) |
168 | { |
169 | struct atusb *atusb = |
170 | container_of(to_delayed_work(work), struct atusb, work); |
171 | struct usb_device *usb_dev = atusb->usb_dev; |
172 | struct urb *urb; |
173 | int ret; |
174 | |
175 | if (atusb->shutdown) |
176 | return; |
177 | |
178 | do { |
179 | urb = usb_get_from_anchor(anchor: &atusb->idle_urbs); |
180 | if (!urb) |
181 | return; |
182 | ret = atusb_submit_rx_urb(atusb, urb); |
183 | } while (!ret); |
184 | |
185 | usb_anchor_urb(urb, anchor: &atusb->idle_urbs); |
186 | dev_warn_ratelimited(&usb_dev->dev, |
187 | "atusb_in: can't allocate/submit URB (%d)\n" , ret); |
188 | schedule_delayed_work(dwork: &atusb->work, |
189 | delay: msecs_to_jiffies(ATUSB_ALLOC_DELAY_MS) + 1); |
190 | } |
191 | |
192 | /* ----- Asynchronous USB -------------------------------------------------- */ |
193 | |
194 | static void atusb_tx_done(struct atusb *atusb, u8 seq, int reason) |
195 | { |
196 | struct usb_device *usb_dev = atusb->usb_dev; |
197 | u8 expect = atusb->tx_ack_seq; |
198 | |
199 | dev_dbg(&usb_dev->dev, "%s (0x%02x/0x%02x)\n" , __func__, seq, expect); |
200 | if (seq == expect) { |
201 | /* TODO check for ifs handling in firmware */ |
202 | if (reason == IEEE802154_SUCCESS) |
203 | ieee802154_xmit_complete(hw: atusb->hw, skb: atusb->tx_skb, ifs_handling: false); |
204 | else |
205 | ieee802154_xmit_error(hw: atusb->hw, skb: atusb->tx_skb, reason); |
206 | } else { |
207 | /* TODO I experience this case when atusb has a tx complete |
208 | * irq before probing, we should fix the firmware it's an |
209 | * unlikely case now that seq == expect is then true, but can |
210 | * happen and fail with a tx_skb = NULL; |
211 | */ |
212 | ieee802154_xmit_hw_error(hw: atusb->hw, skb: atusb->tx_skb); |
213 | } |
214 | } |
215 | |
216 | static void atusb_in_good(struct urb *urb) |
217 | { |
218 | struct usb_device *usb_dev = urb->dev; |
219 | struct sk_buff *skb = urb->context; |
220 | struct atusb *atusb = SKB_ATUSB(skb); |
221 | int result = IEEE802154_SUCCESS; |
222 | u8 len, lqi, trac; |
223 | |
224 | if (!urb->actual_length) { |
225 | dev_dbg(&usb_dev->dev, "atusb_in: zero-sized URB ?\n" ); |
226 | return; |
227 | } |
228 | |
229 | len = *skb->data; |
230 | |
231 | switch (urb->actual_length) { |
232 | case 2: |
233 | trac = TRAC_MASK(*(skb->data + 1)); |
234 | switch (trac) { |
235 | case TRAC_SUCCESS: |
236 | case TRAC_SUCCESS_DATA_PENDING: |
237 | /* already IEEE802154_SUCCESS */ |
238 | break; |
239 | case TRAC_CHANNEL_ACCESS_FAILURE: |
240 | result = IEEE802154_CHANNEL_ACCESS_FAILURE; |
241 | break; |
242 | case TRAC_NO_ACK: |
243 | result = IEEE802154_NO_ACK; |
244 | break; |
245 | default: |
246 | result = IEEE802154_SYSTEM_ERROR; |
247 | } |
248 | |
249 | fallthrough; |
250 | case 1: |
251 | atusb_tx_done(atusb, seq: len, reason: result); |
252 | return; |
253 | } |
254 | |
255 | if (len + 1 > urb->actual_length - 1) { |
256 | dev_dbg(&usb_dev->dev, "atusb_in: frame len %d+1 > URB %u-1\n" , |
257 | len, urb->actual_length); |
258 | return; |
259 | } |
260 | |
261 | if (!ieee802154_is_valid_psdu_len(len)) { |
262 | dev_dbg(&usb_dev->dev, "atusb_in: frame corrupted\n" ); |
263 | return; |
264 | } |
265 | |
266 | lqi = skb->data[len + 1]; |
267 | dev_dbg(&usb_dev->dev, "atusb_in: rx len %d lqi 0x%02x\n" , len, lqi); |
268 | skb_pull(skb, len: 1); /* remove PHR */ |
269 | skb_trim(skb, len); /* get payload only */ |
270 | ieee802154_rx_irqsafe(hw: atusb->hw, skb, lqi); |
271 | urb->context = NULL; /* skb is gone */ |
272 | } |
273 | |
274 | static void atusb_in(struct urb *urb) |
275 | { |
276 | struct usb_device *usb_dev = urb->dev; |
277 | struct sk_buff *skb = urb->context; |
278 | struct atusb *atusb = SKB_ATUSB(skb); |
279 | |
280 | dev_dbg(&usb_dev->dev, "%s: status %d len %d\n" , __func__, |
281 | urb->status, urb->actual_length); |
282 | if (urb->status) { |
283 | if (urb->status == -ENOENT) { /* being killed */ |
284 | kfree_skb(skb); |
285 | urb->context = NULL; |
286 | return; |
287 | } |
288 | dev_dbg(&usb_dev->dev, "%s: URB error %d\n" , __func__, urb->status); |
289 | } else { |
290 | atusb_in_good(urb); |
291 | } |
292 | |
293 | usb_anchor_urb(urb, anchor: &atusb->idle_urbs); |
294 | if (!atusb->shutdown) |
295 | schedule_delayed_work(dwork: &atusb->work, delay: 0); |
296 | } |
297 | |
298 | /* ----- URB allocation/deallocation --------------------------------------- */ |
299 | |
300 | static void atusb_free_urbs(struct atusb *atusb) |
301 | { |
302 | struct urb *urb; |
303 | |
304 | while (1) { |
305 | urb = usb_get_from_anchor(anchor: &atusb->idle_urbs); |
306 | if (!urb) |
307 | break; |
308 | kfree_skb(skb: urb->context); |
309 | usb_free_urb(urb); |
310 | } |
311 | } |
312 | |
313 | static int atusb_alloc_urbs(struct atusb *atusb, int n) |
314 | { |
315 | struct urb *urb; |
316 | |
317 | while (n) { |
318 | urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
319 | if (!urb) { |
320 | atusb_free_urbs(atusb); |
321 | return -ENOMEM; |
322 | } |
323 | usb_anchor_urb(urb, anchor: &atusb->idle_urbs); |
324 | usb_free_urb(urb); |
325 | n--; |
326 | } |
327 | return 0; |
328 | } |
329 | |
330 | /* ----- IEEE 802.15.4 interface operations -------------------------------- */ |
331 | |
332 | static void atusb_xmit_complete(struct urb *urb) |
333 | { |
334 | dev_dbg(&urb->dev->dev, "atusb_xmit urb completed" ); |
335 | } |
336 | |
337 | static int atusb_xmit(struct ieee802154_hw *hw, struct sk_buff *skb) |
338 | { |
339 | struct atusb *atusb = hw->priv; |
340 | struct usb_device *usb_dev = atusb->usb_dev; |
341 | int ret; |
342 | |
343 | dev_dbg(&usb_dev->dev, "%s (%d)\n" , __func__, skb->len); |
344 | atusb->tx_skb = skb; |
345 | atusb->tx_ack_seq++; |
346 | atusb->tx_dr.wIndex = cpu_to_le16(atusb->tx_ack_seq); |
347 | atusb->tx_dr.wLength = cpu_to_le16(skb->len); |
348 | |
349 | usb_fill_control_urb(urb: atusb->tx_urb, dev: usb_dev, |
350 | usb_sndctrlpipe(usb_dev, 0), |
351 | setup_packet: (unsigned char *)&atusb->tx_dr, transfer_buffer: skb->data, |
352 | buffer_length: skb->len, complete_fn: atusb_xmit_complete, NULL); |
353 | ret = usb_submit_urb(urb: atusb->tx_urb, GFP_ATOMIC); |
354 | dev_dbg(&usb_dev->dev, "%s done (%d)\n" , __func__, ret); |
355 | return ret; |
356 | } |
357 | |
358 | static int atusb_ed(struct ieee802154_hw *hw, u8 *level) |
359 | { |
360 | WARN_ON(!level); |
361 | *level = 0xbe; |
362 | return 0; |
363 | } |
364 | |
365 | static int atusb_set_hw_addr_filt(struct ieee802154_hw *hw, |
366 | struct ieee802154_hw_addr_filt *filt, |
367 | unsigned long changed) |
368 | { |
369 | struct atusb *atusb = hw->priv; |
370 | struct device *dev = &atusb->usb_dev->dev; |
371 | |
372 | if (changed & IEEE802154_AFILT_SADDR_CHANGED) { |
373 | u16 addr = le16_to_cpu(filt->short_addr); |
374 | |
375 | dev_vdbg(dev, "%s called for saddr\n" , __func__); |
376 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
377 | value: addr, RG_SHORT_ADDR_0, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
378 | |
379 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
380 | value: addr >> 8, RG_SHORT_ADDR_1, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
381 | } |
382 | |
383 | if (changed & IEEE802154_AFILT_PANID_CHANGED) { |
384 | u16 pan = le16_to_cpu(filt->pan_id); |
385 | |
386 | dev_vdbg(dev, "%s called for pan id\n" , __func__); |
387 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
388 | value: pan, RG_PAN_ID_0, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
389 | |
390 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
391 | value: pan >> 8, RG_PAN_ID_1, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
392 | } |
393 | |
394 | if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) { |
395 | u8 i, addr[IEEE802154_EXTENDED_ADDR_LEN]; |
396 | |
397 | memcpy(addr, &filt->ieee_addr, IEEE802154_EXTENDED_ADDR_LEN); |
398 | dev_vdbg(dev, "%s called for IEEE addr\n" , __func__); |
399 | for (i = 0; i < 8; i++) |
400 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
401 | value: addr[i], RG_IEEE_ADDR_0 + i, NULL, size: 0, |
402 | timeout: 1000, GFP_KERNEL); |
403 | } |
404 | |
405 | if (changed & IEEE802154_AFILT_PANC_CHANGED) { |
406 | dev_vdbg(dev, "%s called for panc change\n" , __func__); |
407 | if (filt->pan_coord) |
408 | atusb_write_subreg(atusb, SR_AACK_I_AM_COORD, value: 1); |
409 | else |
410 | atusb_write_subreg(atusb, SR_AACK_I_AM_COORD, value: 0); |
411 | } |
412 | |
413 | return atusb_get_and_clear_error(atusb); |
414 | } |
415 | |
416 | static int atusb_start(struct ieee802154_hw *hw) |
417 | { |
418 | struct atusb *atusb = hw->priv; |
419 | struct usb_device *usb_dev = atusb->usb_dev; |
420 | int ret; |
421 | |
422 | dev_dbg(&usb_dev->dev, "%s\n" , __func__); |
423 | schedule_delayed_work(dwork: &atusb->work, delay: 0); |
424 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_RX_MODE, ATUSB_REQ_TO_DEV, value: 1, index: 0, |
425 | NULL, size: 0, timeout: 1000, GFP_KERNEL); |
426 | ret = atusb_get_and_clear_error(atusb); |
427 | if (ret < 0) |
428 | usb_kill_anchored_urbs(anchor: &atusb->idle_urbs); |
429 | return ret; |
430 | } |
431 | |
432 | static void atusb_stop(struct ieee802154_hw *hw) |
433 | { |
434 | struct atusb *atusb = hw->priv; |
435 | struct usb_device *usb_dev = atusb->usb_dev; |
436 | |
437 | dev_dbg(&usb_dev->dev, "%s\n" , __func__); |
438 | usb_kill_anchored_urbs(anchor: &atusb->idle_urbs); |
439 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_RX_MODE, ATUSB_REQ_TO_DEV, value: 0, index: 0, |
440 | NULL, size: 0, timeout: 1000, GFP_KERNEL); |
441 | atusb_get_and_clear_error(atusb); |
442 | } |
443 | |
444 | #define ATUSB_MAX_TX_POWERS 0xF |
445 | static const s32 atusb_powers[ATUSB_MAX_TX_POWERS + 1] = { |
446 | 300, 280, 230, 180, 130, 70, 0, -100, -200, -300, -400, -500, -700, |
447 | -900, -1200, -1700, |
448 | }; |
449 | |
450 | static int |
451 | atusb_txpower(struct ieee802154_hw *hw, s32 mbm) |
452 | { |
453 | struct atusb *atusb = hw->priv; |
454 | |
455 | if (atusb->data) |
456 | return atusb->data->set_txpower(hw, mbm); |
457 | else |
458 | return -ENOTSUPP; |
459 | } |
460 | |
461 | static int |
462 | atusb_set_txpower(struct ieee802154_hw *hw, s32 mbm) |
463 | { |
464 | struct atusb *atusb = hw->priv; |
465 | u32 i; |
466 | |
467 | for (i = 0; i < hw->phy->supported.tx_powers_size; i++) { |
468 | if (hw->phy->supported.tx_powers[i] == mbm) |
469 | return atusb_write_subreg(atusb, SR_TX_PWR_23X, value: i); |
470 | } |
471 | |
472 | return -EINVAL; |
473 | } |
474 | |
475 | static int |
476 | hulusb_set_txpower(struct ieee802154_hw *hw, s32 mbm) |
477 | { |
478 | u32 i; |
479 | |
480 | for (i = 0; i < hw->phy->supported.tx_powers_size; i++) { |
481 | if (hw->phy->supported.tx_powers[i] == mbm) |
482 | return atusb_write_subreg(atusb: hw->priv, SR_TX_PWR_212, value: i); |
483 | } |
484 | |
485 | return -EINVAL; |
486 | } |
487 | |
488 | #define ATUSB_MAX_ED_LEVELS 0xF |
489 | static const s32 atusb_ed_levels[ATUSB_MAX_ED_LEVELS + 1] = { |
490 | -9100, -8900, -8700, -8500, -8300, -8100, -7900, -7700, -7500, -7300, |
491 | -7100, -6900, -6700, -6500, -6300, -6100, |
492 | }; |
493 | |
494 | #define AT86RF212_MAX_TX_POWERS 0x1F |
495 | static const s32 at86rf212_powers[AT86RF212_MAX_TX_POWERS + 1] = { |
496 | 500, 400, 300, 200, 100, 0, -100, -200, -300, -400, -500, -600, -700, |
497 | -800, -900, -1000, -1100, -1200, -1300, -1400, -1500, -1600, -1700, |
498 | -1800, -1900, -2000, -2100, -2200, -2300, -2400, -2500, -2600, |
499 | }; |
500 | |
501 | #define AT86RF2XX_MAX_ED_LEVELS 0xF |
502 | static const s32 at86rf212_ed_levels_100[AT86RF2XX_MAX_ED_LEVELS + 1] = { |
503 | -10000, -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200, |
504 | -8000, -7800, -7600, -7400, -7200, -7000, |
505 | }; |
506 | |
507 | static const s32 at86rf212_ed_levels_98[AT86RF2XX_MAX_ED_LEVELS + 1] = { |
508 | -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200, -8000, |
509 | -7800, -7600, -7400, -7200, -7000, -6800, |
510 | }; |
511 | |
512 | static int |
513 | atusb_set_cca_mode(struct ieee802154_hw *hw, const struct wpan_phy_cca *cca) |
514 | { |
515 | struct atusb *atusb = hw->priv; |
516 | u8 val; |
517 | |
518 | /* mapping 802.15.4 to driver spec */ |
519 | switch (cca->mode) { |
520 | case NL802154_CCA_ENERGY: |
521 | val = 1; |
522 | break; |
523 | case NL802154_CCA_CARRIER: |
524 | val = 2; |
525 | break; |
526 | case NL802154_CCA_ENERGY_CARRIER: |
527 | switch (cca->opt) { |
528 | case NL802154_CCA_OPT_ENERGY_CARRIER_AND: |
529 | val = 3; |
530 | break; |
531 | case NL802154_CCA_OPT_ENERGY_CARRIER_OR: |
532 | val = 0; |
533 | break; |
534 | default: |
535 | return -EINVAL; |
536 | } |
537 | break; |
538 | default: |
539 | return -EINVAL; |
540 | } |
541 | |
542 | return atusb_write_subreg(atusb, SR_CCA_MODE, value: val); |
543 | } |
544 | |
545 | static int hulusb_set_cca_ed_level(struct atusb *lp, int ) |
546 | { |
547 | int cca_ed_thres; |
548 | |
549 | cca_ed_thres = atusb_read_subreg(lp, SR_CCA_ED_THRES); |
550 | if (cca_ed_thres < 0) |
551 | return cca_ed_thres; |
552 | |
553 | switch (rssi_base_val) { |
554 | case -98: |
555 | lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_98; |
556 | lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_98); |
557 | lp->hw->phy->cca_ed_level = at86rf212_ed_levels_98[cca_ed_thres]; |
558 | break; |
559 | case -100: |
560 | lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100; |
561 | lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100); |
562 | lp->hw->phy->cca_ed_level = at86rf212_ed_levels_100[cca_ed_thres]; |
563 | break; |
564 | default: |
565 | WARN_ON(1); |
566 | } |
567 | |
568 | return 0; |
569 | } |
570 | |
571 | static int |
572 | atusb_set_cca_ed_level(struct ieee802154_hw *hw, s32 mbm) |
573 | { |
574 | struct atusb *atusb = hw->priv; |
575 | u32 i; |
576 | |
577 | for (i = 0; i < hw->phy->supported.cca_ed_levels_size; i++) { |
578 | if (hw->phy->supported.cca_ed_levels[i] == mbm) |
579 | return atusb_write_subreg(atusb, SR_CCA_ED_THRES, value: i); |
580 | } |
581 | |
582 | return -EINVAL; |
583 | } |
584 | |
585 | static int atusb_channel(struct ieee802154_hw *hw, u8 page, u8 channel) |
586 | { |
587 | struct atusb *atusb = hw->priv; |
588 | int ret = -ENOTSUPP; |
589 | |
590 | if (atusb->data) { |
591 | ret = atusb->data->set_channel(hw, page, channel); |
592 | /* @@@ ugly synchronization */ |
593 | msleep(msecs: atusb->data->t_channel_switch); |
594 | } |
595 | |
596 | return ret; |
597 | } |
598 | |
599 | static int atusb_set_channel(struct ieee802154_hw *hw, u8 page, u8 channel) |
600 | { |
601 | struct atusb *atusb = hw->priv; |
602 | int ret; |
603 | |
604 | ret = atusb_write_subreg(atusb, SR_CHANNEL, value: channel); |
605 | if (ret < 0) |
606 | return ret; |
607 | return 0; |
608 | } |
609 | |
610 | static int hulusb_set_channel(struct ieee802154_hw *hw, u8 page, u8 channel) |
611 | { |
612 | int rc; |
613 | int ; |
614 | |
615 | struct atusb *lp = hw->priv; |
616 | |
617 | if (channel == 0) |
618 | rc = atusb_write_subreg(atusb: lp, SR_SUB_MODE, value: 0); |
619 | else |
620 | rc = atusb_write_subreg(atusb: lp, SR_SUB_MODE, value: 1); |
621 | if (rc < 0) |
622 | return rc; |
623 | |
624 | if (page == 0) { |
625 | rc = atusb_write_subreg(atusb: lp, SR_BPSK_QPSK, value: 0); |
626 | rssi_base_val = -100; |
627 | } else { |
628 | rc = atusb_write_subreg(atusb: lp, SR_BPSK_QPSK, value: 1); |
629 | rssi_base_val = -98; |
630 | } |
631 | if (rc < 0) |
632 | return rc; |
633 | |
634 | rc = hulusb_set_cca_ed_level(lp, rssi_base_val); |
635 | if (rc < 0) |
636 | return rc; |
637 | |
638 | return atusb_write_subreg(atusb: lp, SR_CHANNEL, value: channel); |
639 | } |
640 | |
641 | static int |
642 | atusb_set_csma_params(struct ieee802154_hw *hw, u8 min_be, u8 max_be, u8 retries) |
643 | { |
644 | struct atusb *atusb = hw->priv; |
645 | int ret; |
646 | |
647 | ret = atusb_write_subreg(atusb, SR_MIN_BE, value: min_be); |
648 | if (ret) |
649 | return ret; |
650 | |
651 | ret = atusb_write_subreg(atusb, SR_MAX_BE, value: max_be); |
652 | if (ret) |
653 | return ret; |
654 | |
655 | return atusb_write_subreg(atusb, SR_MAX_CSMA_RETRIES, value: retries); |
656 | } |
657 | |
658 | static int |
659 | hulusb_set_lbt(struct ieee802154_hw *hw, bool on) |
660 | { |
661 | struct atusb *atusb = hw->priv; |
662 | |
663 | return atusb_write_subreg(atusb, SR_CSMA_LBT_MODE, value: on); |
664 | } |
665 | |
666 | static int |
667 | atusb_set_frame_retries(struct ieee802154_hw *hw, s8 retries) |
668 | { |
669 | struct atusb *atusb = hw->priv; |
670 | |
671 | return atusb_write_subreg(atusb, SR_MAX_FRAME_RETRIES, value: retries); |
672 | } |
673 | |
674 | static int |
675 | atusb_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on) |
676 | { |
677 | struct atusb *atusb = hw->priv; |
678 | int ret; |
679 | |
680 | if (on) { |
681 | ret = atusb_write_subreg(atusb, SR_AACK_DIS_ACK, value: 1); |
682 | if (ret < 0) |
683 | return ret; |
684 | |
685 | ret = atusb_write_subreg(atusb, SR_AACK_PROM_MODE, value: 1); |
686 | if (ret < 0) |
687 | return ret; |
688 | } else { |
689 | ret = atusb_write_subreg(atusb, SR_AACK_PROM_MODE, value: 0); |
690 | if (ret < 0) |
691 | return ret; |
692 | |
693 | ret = atusb_write_subreg(atusb, SR_AACK_DIS_ACK, value: 0); |
694 | if (ret < 0) |
695 | return ret; |
696 | } |
697 | |
698 | return 0; |
699 | } |
700 | |
701 | static struct atusb_chip_data atusb_chip_data = { |
702 | .t_channel_switch = 1, |
703 | .rssi_base_val = -91, |
704 | .set_txpower = atusb_set_txpower, |
705 | .set_channel = atusb_set_channel, |
706 | }; |
707 | |
708 | static struct atusb_chip_data hulusb_chip_data = { |
709 | .t_channel_switch = 11, |
710 | .rssi_base_val = -100, |
711 | .set_txpower = hulusb_set_txpower, |
712 | .set_channel = hulusb_set_channel, |
713 | }; |
714 | |
715 | static const struct ieee802154_ops atusb_ops = { |
716 | .owner = THIS_MODULE, |
717 | .xmit_async = atusb_xmit, |
718 | .ed = atusb_ed, |
719 | .set_channel = atusb_channel, |
720 | .start = atusb_start, |
721 | .stop = atusb_stop, |
722 | .set_hw_addr_filt = atusb_set_hw_addr_filt, |
723 | .set_txpower = atusb_txpower, |
724 | .set_lbt = hulusb_set_lbt, |
725 | .set_cca_mode = atusb_set_cca_mode, |
726 | .set_cca_ed_level = atusb_set_cca_ed_level, |
727 | .set_csma_params = atusb_set_csma_params, |
728 | .set_frame_retries = atusb_set_frame_retries, |
729 | .set_promiscuous_mode = atusb_set_promiscuous_mode, |
730 | }; |
731 | |
732 | /* ----- Firmware and chip version information ----------------------------- */ |
733 | |
734 | static int atusb_get_and_show_revision(struct atusb *atusb) |
735 | { |
736 | struct usb_device *usb_dev = atusb->usb_dev; |
737 | char *hw_name; |
738 | unsigned char buffer[3]; |
739 | int ret; |
740 | |
741 | /* Get a couple of the ATMega Firmware values */ |
742 | ret = usb_control_msg_recv(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_ID, ATUSB_REQ_FROM_DEV, value: 0, index: 0, |
743 | data: buffer, size: 3, timeout: 1000, GFP_KERNEL); |
744 | if (!ret) { |
745 | atusb->fw_ver_maj = buffer[0]; |
746 | atusb->fw_ver_min = buffer[1]; |
747 | atusb->fw_hw_type = buffer[2]; |
748 | |
749 | switch (atusb->fw_hw_type) { |
750 | case ATUSB_HW_TYPE_100813: |
751 | case ATUSB_HW_TYPE_101216: |
752 | case ATUSB_HW_TYPE_110131: |
753 | hw_name = "ATUSB" ; |
754 | atusb->data = &atusb_chip_data; |
755 | break; |
756 | case ATUSB_HW_TYPE_RZUSB: |
757 | hw_name = "RZUSB" ; |
758 | atusb->data = &atusb_chip_data; |
759 | break; |
760 | case ATUSB_HW_TYPE_HULUSB: |
761 | hw_name = "HULUSB" ; |
762 | atusb->data = &hulusb_chip_data; |
763 | break; |
764 | default: |
765 | hw_name = "UNKNOWN" ; |
766 | atusb->err = -ENOTSUPP; |
767 | ret = -ENOTSUPP; |
768 | break; |
769 | } |
770 | |
771 | dev_info(&usb_dev->dev, |
772 | "Firmware: major: %u, minor: %u, hardware type: %s (%d)\n" , |
773 | atusb->fw_ver_maj, atusb->fw_ver_min, hw_name, |
774 | atusb->fw_hw_type); |
775 | } |
776 | if (atusb->fw_ver_maj == 0 && atusb->fw_ver_min < 2) { |
777 | dev_info(&usb_dev->dev, |
778 | "Firmware version (%u.%u) predates our first public release." , |
779 | atusb->fw_ver_maj, atusb->fw_ver_min); |
780 | dev_info(&usb_dev->dev, "Please update to version 0.2 or newer" ); |
781 | } |
782 | |
783 | return ret; |
784 | } |
785 | |
786 | static int atusb_get_and_show_build(struct atusb *atusb) |
787 | { |
788 | struct usb_device *usb_dev = atusb->usb_dev; |
789 | char *build; |
790 | int ret; |
791 | |
792 | build = kmalloc(ATUSB_BUILD_SIZE + 1, GFP_KERNEL); |
793 | if (!build) |
794 | return -ENOMEM; |
795 | |
796 | ret = usb_control_msg(dev: atusb->usb_dev, usb_rcvctrlpipe(usb_dev, 0), request: ATUSB_BUILD, |
797 | ATUSB_REQ_FROM_DEV, value: 0, index: 0, data: build, ATUSB_BUILD_SIZE, timeout: 1000); |
798 | if (ret >= 0) { |
799 | build[ret] = 0; |
800 | dev_info(&usb_dev->dev, "Firmware: build %s\n" , build); |
801 | } |
802 | |
803 | kfree(objp: build); |
804 | return ret; |
805 | } |
806 | |
807 | static int atusb_get_and_conf_chip(struct atusb *atusb) |
808 | { |
809 | struct usb_device *usb_dev = atusb->usb_dev; |
810 | u8 man_id_0, man_id_1, part_num, version_num; |
811 | const char *chip; |
812 | struct ieee802154_hw *hw = atusb->hw; |
813 | int ret; |
814 | |
815 | ret = usb_control_msg_recv(dev: usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
816 | value: 0, RG_MAN_ID_0, data: &man_id_0, size: 1, timeout: 1000, GFP_KERNEL); |
817 | if (ret < 0) |
818 | return ret; |
819 | |
820 | ret = usb_control_msg_recv(dev: usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
821 | value: 0, RG_MAN_ID_1, data: &man_id_1, size: 1, timeout: 1000, GFP_KERNEL); |
822 | if (ret < 0) |
823 | return ret; |
824 | |
825 | ret = usb_control_msg_recv(dev: usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
826 | value: 0, RG_PART_NUM, data: &part_num, size: 1, timeout: 1000, GFP_KERNEL); |
827 | if (ret < 0) |
828 | return ret; |
829 | |
830 | ret = usb_control_msg_recv(dev: usb_dev, endpoint: 0, request: ATUSB_REG_READ, ATUSB_REQ_FROM_DEV, |
831 | value: 0, RG_VERSION_NUM, data: &version_num, size: 1, timeout: 1000, GFP_KERNEL); |
832 | if (ret < 0) |
833 | return ret; |
834 | |
835 | hw->flags = IEEE802154_HW_TX_OMIT_CKSUM | IEEE802154_HW_AFILT | |
836 | IEEE802154_HW_PROMISCUOUS | IEEE802154_HW_CSMA_PARAMS; |
837 | |
838 | hw->phy->flags = WPAN_PHY_FLAG_TXPOWER | WPAN_PHY_FLAG_CCA_ED_LEVEL | |
839 | WPAN_PHY_FLAG_CCA_MODE; |
840 | |
841 | hw->phy->supported.cca_modes = BIT(NL802154_CCA_ENERGY) | |
842 | BIT(NL802154_CCA_CARRIER) | |
843 | BIT(NL802154_CCA_ENERGY_CARRIER); |
844 | hw->phy->supported.cca_opts = BIT(NL802154_CCA_OPT_ENERGY_CARRIER_AND) | |
845 | BIT(NL802154_CCA_OPT_ENERGY_CARRIER_OR); |
846 | |
847 | hw->phy->cca.mode = NL802154_CCA_ENERGY; |
848 | |
849 | hw->phy->current_page = 0; |
850 | |
851 | if ((man_id_1 << 8 | man_id_0) != ATUSB_JEDEC_ATMEL) { |
852 | dev_err(&usb_dev->dev, |
853 | "non-Atmel transceiver xxxx%02x%02x\n" , |
854 | man_id_1, man_id_0); |
855 | goto fail; |
856 | } |
857 | |
858 | switch (part_num) { |
859 | case 2: |
860 | chip = "AT86RF230" ; |
861 | atusb->hw->phy->supported.channels[0] = 0x7FFF800; |
862 | atusb->hw->phy->current_channel = 11; /* reset default */ |
863 | atusb->hw->phy->supported.tx_powers = atusb_powers; |
864 | atusb->hw->phy->supported.tx_powers_size = ARRAY_SIZE(atusb_powers); |
865 | hw->phy->supported.cca_ed_levels = atusb_ed_levels; |
866 | hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(atusb_ed_levels); |
867 | break; |
868 | case 3: |
869 | chip = "AT86RF231" ; |
870 | atusb->hw->phy->supported.channels[0] = 0x7FFF800; |
871 | atusb->hw->phy->current_channel = 11; /* reset default */ |
872 | atusb->hw->phy->supported.tx_powers = atusb_powers; |
873 | atusb->hw->phy->supported.tx_powers_size = ARRAY_SIZE(atusb_powers); |
874 | hw->phy->supported.cca_ed_levels = atusb_ed_levels; |
875 | hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(atusb_ed_levels); |
876 | break; |
877 | case 7: |
878 | chip = "AT86RF212" ; |
879 | atusb->hw->flags |= IEEE802154_HW_LBT; |
880 | atusb->hw->phy->supported.channels[0] = 0x00007FF; |
881 | atusb->hw->phy->supported.channels[2] = 0x00007FF; |
882 | atusb->hw->phy->current_channel = 5; |
883 | atusb->hw->phy->supported.lbt = NL802154_SUPPORTED_BOOL_BOTH; |
884 | atusb->hw->phy->supported.tx_powers = at86rf212_powers; |
885 | atusb->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf212_powers); |
886 | atusb->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100; |
887 | atusb->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100); |
888 | break; |
889 | default: |
890 | dev_err(&usb_dev->dev, |
891 | "unexpected transceiver, part 0x%02x version 0x%02x\n" , |
892 | part_num, version_num); |
893 | goto fail; |
894 | } |
895 | |
896 | hw->phy->transmit_power = hw->phy->supported.tx_powers[0]; |
897 | hw->phy->cca_ed_level = hw->phy->supported.cca_ed_levels[7]; |
898 | |
899 | dev_info(&usb_dev->dev, "ATUSB: %s version %d\n" , chip, version_num); |
900 | |
901 | return 0; |
902 | |
903 | fail: |
904 | atusb->err = -ENODEV; |
905 | return -ENODEV; |
906 | } |
907 | |
908 | static int atusb_set_extended_addr(struct atusb *atusb) |
909 | { |
910 | struct usb_device *usb_dev = atusb->usb_dev; |
911 | unsigned char buffer[IEEE802154_EXTENDED_ADDR_LEN]; |
912 | __le64 extended_addr; |
913 | u64 addr; |
914 | int ret; |
915 | |
916 | /* Firmware versions before 0.3 do not support the EUI64_READ command. |
917 | * Just use a random address and be done. |
918 | */ |
919 | if (atusb->fw_ver_maj == 0 && atusb->fw_ver_min < 3) { |
920 | ieee802154_random_extended_addr(addr: &atusb->hw->phy->perm_extended_addr); |
921 | return 0; |
922 | } |
923 | |
924 | /* Firmware is new enough so we fetch the address from EEPROM */ |
925 | ret = usb_control_msg_recv(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_EUI64_READ, ATUSB_REQ_FROM_DEV, value: 0, index: 0, |
926 | data: buffer, IEEE802154_EXTENDED_ADDR_LEN, timeout: 1000, GFP_KERNEL); |
927 | if (ret < 0) { |
928 | dev_err(&usb_dev->dev, "failed to fetch extended address, random address set\n" ); |
929 | ieee802154_random_extended_addr(addr: &atusb->hw->phy->perm_extended_addr); |
930 | return ret; |
931 | } |
932 | |
933 | memcpy(&extended_addr, buffer, IEEE802154_EXTENDED_ADDR_LEN); |
934 | /* Check if read address is not empty and the unicast bit is set correctly */ |
935 | if (!ieee802154_is_valid_extended_unicast_addr(addr: extended_addr)) { |
936 | dev_info(&usb_dev->dev, "no permanent extended address found, random address set\n" ); |
937 | ieee802154_random_extended_addr(addr: &atusb->hw->phy->perm_extended_addr); |
938 | } else { |
939 | atusb->hw->phy->perm_extended_addr = extended_addr; |
940 | addr = swab64((__force u64)atusb->hw->phy->perm_extended_addr); |
941 | dev_info(&usb_dev->dev, "Read permanent extended address %8phC from device\n" , |
942 | &addr); |
943 | } |
944 | |
945 | return ret; |
946 | } |
947 | |
948 | /* ----- Setup ------------------------------------------------------------- */ |
949 | |
950 | static int atusb_probe(struct usb_interface *interface, |
951 | const struct usb_device_id *id) |
952 | { |
953 | struct usb_device *usb_dev = interface_to_usbdev(interface); |
954 | struct ieee802154_hw *hw; |
955 | struct atusb *atusb = NULL; |
956 | int ret = -ENOMEM; |
957 | |
958 | hw = ieee802154_alloc_hw(priv_data_len: sizeof(struct atusb), ops: &atusb_ops); |
959 | if (!hw) |
960 | return -ENOMEM; |
961 | |
962 | atusb = hw->priv; |
963 | atusb->hw = hw; |
964 | atusb->usb_dev = usb_get_dev(dev: usb_dev); |
965 | usb_set_intfdata(intf: interface, data: atusb); |
966 | |
967 | atusb->shutdown = 0; |
968 | atusb->err = 0; |
969 | INIT_DELAYED_WORK(&atusb->work, atusb_work_urbs); |
970 | init_usb_anchor(anchor: &atusb->idle_urbs); |
971 | init_usb_anchor(anchor: &atusb->rx_urbs); |
972 | |
973 | if (atusb_alloc_urbs(atusb, ATUSB_NUM_RX_URBS)) |
974 | goto fail; |
975 | |
976 | atusb->tx_dr.bRequestType = ATUSB_REQ_TO_DEV; |
977 | atusb->tx_dr.bRequest = ATUSB_TX; |
978 | atusb->tx_dr.wValue = cpu_to_le16(0); |
979 | |
980 | atusb->tx_urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
981 | if (!atusb->tx_urb) |
982 | goto fail; |
983 | |
984 | hw->parent = &usb_dev->dev; |
985 | |
986 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_RF_RESET, ATUSB_REQ_TO_DEV, value: 0, index: 0, |
987 | NULL, size: 0, timeout: 1000, GFP_KERNEL); |
988 | atusb_get_and_conf_chip(atusb); |
989 | atusb_get_and_show_revision(atusb); |
990 | atusb_get_and_show_build(atusb); |
991 | atusb_set_extended_addr(atusb); |
992 | |
993 | if ((atusb->fw_ver_maj == 0 && atusb->fw_ver_min >= 3) || atusb->fw_ver_maj > 0) |
994 | hw->flags |= IEEE802154_HW_FRAME_RETRIES; |
995 | |
996 | ret = atusb_get_and_clear_error(atusb); |
997 | if (ret) { |
998 | dev_err(&atusb->usb_dev->dev, |
999 | "%s: initialization failed, error = %d\n" , |
1000 | __func__, ret); |
1001 | goto fail; |
1002 | } |
1003 | |
1004 | ret = ieee802154_register_hw(hw); |
1005 | if (ret) |
1006 | goto fail; |
1007 | |
1008 | /* If we just powered on, we're now in P_ON and need to enter TRX_OFF |
1009 | * explicitly. Any resets after that will send us straight to TRX_OFF, |
1010 | * making the command below redundant. |
1011 | */ |
1012 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
1013 | STATE_FORCE_TRX_OFF, RG_TRX_STATE, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
1014 | |
1015 | msleep(msecs: 1); /* reset => TRX_OFF, tTR13 = 37 us */ |
1016 | |
1017 | #if 0 |
1018 | /* Calculating the maximum time available to empty the frame buffer |
1019 | * on reception: |
1020 | * |
1021 | * According to [1], the inter-frame gap is |
1022 | * R * 20 * 16 us + 128 us |
1023 | * where R is a random number from 0 to 7. Furthermore, we have 20 bit |
1024 | * times (80 us at 250 kbps) of SHR of the next frame before the |
1025 | * transceiver begins storing data in the frame buffer. |
1026 | * |
1027 | * This yields a minimum time of 208 us between the last data of a |
1028 | * frame and the first data of the next frame. This time is further |
1029 | * reduced by interrupt latency in the atusb firmware. |
1030 | * |
1031 | * atusb currently needs about 500 us to retrieve a maximum-sized |
1032 | * frame. We therefore have to allow reception of a new frame to begin |
1033 | * while we retrieve the previous frame. |
1034 | * |
1035 | * [1] "JN-AN-1035 Calculating data rates in an IEEE 802.15.4-based |
1036 | * network", Jennic 2006. |
1037 | * http://www.jennic.com/download_file.php?supportFile=JN-AN-1035%20Calculating%20802-15-4%20Data%20Rates-1v0.pdf |
1038 | */ |
1039 | |
1040 | atusb_write_subreg(atusb, SR_RX_SAFE_MODE, 1); |
1041 | #endif |
1042 | usb_control_msg_send(dev: atusb->usb_dev, endpoint: 0, request: ATUSB_REG_WRITE, ATUSB_REQ_TO_DEV, |
1043 | value: 0xff, RG_IRQ_MASK, NULL, size: 0, timeout: 1000, GFP_KERNEL); |
1044 | |
1045 | ret = atusb_get_and_clear_error(atusb); |
1046 | if (!ret) |
1047 | return 0; |
1048 | |
1049 | dev_err(&atusb->usb_dev->dev, |
1050 | "%s: setup failed, error = %d\n" , |
1051 | __func__, ret); |
1052 | |
1053 | ieee802154_unregister_hw(hw); |
1054 | fail: |
1055 | atusb_free_urbs(atusb); |
1056 | usb_kill_urb(urb: atusb->tx_urb); |
1057 | usb_free_urb(urb: atusb->tx_urb); |
1058 | usb_put_dev(dev: usb_dev); |
1059 | ieee802154_free_hw(hw); |
1060 | return ret; |
1061 | } |
1062 | |
1063 | static void atusb_disconnect(struct usb_interface *interface) |
1064 | { |
1065 | struct atusb *atusb = usb_get_intfdata(intf: interface); |
1066 | |
1067 | dev_dbg(&atusb->usb_dev->dev, "%s\n" , __func__); |
1068 | |
1069 | atusb->shutdown = 1; |
1070 | cancel_delayed_work_sync(dwork: &atusb->work); |
1071 | |
1072 | usb_kill_anchored_urbs(anchor: &atusb->rx_urbs); |
1073 | atusb_free_urbs(atusb); |
1074 | usb_kill_urb(urb: atusb->tx_urb); |
1075 | usb_free_urb(urb: atusb->tx_urb); |
1076 | |
1077 | ieee802154_unregister_hw(hw: atusb->hw); |
1078 | |
1079 | usb_put_dev(dev: atusb->usb_dev); |
1080 | |
1081 | ieee802154_free_hw(hw: atusb->hw); |
1082 | |
1083 | usb_set_intfdata(intf: interface, NULL); |
1084 | |
1085 | pr_debug("%s done\n" , __func__); |
1086 | } |
1087 | |
1088 | /* The devices we work with */ |
1089 | static const struct usb_device_id atusb_device_table[] = { |
1090 | { |
1091 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | |
1092 | USB_DEVICE_ID_MATCH_INT_INFO, |
1093 | .idVendor = ATUSB_VENDOR_ID, |
1094 | .idProduct = ATUSB_PRODUCT_ID, |
1095 | .bInterfaceClass = USB_CLASS_VENDOR_SPEC |
1096 | }, |
1097 | /* end with null element */ |
1098 | {} |
1099 | }; |
1100 | MODULE_DEVICE_TABLE(usb, atusb_device_table); |
1101 | |
1102 | static struct usb_driver atusb_driver = { |
1103 | .name = "atusb" , |
1104 | .probe = atusb_probe, |
1105 | .disconnect = atusb_disconnect, |
1106 | .id_table = atusb_device_table, |
1107 | }; |
1108 | module_usb_driver(atusb_driver); |
1109 | |
1110 | MODULE_AUTHOR("Alexander Aring <alex.aring@gmail.com>" ); |
1111 | MODULE_AUTHOR("Richard Sharpe <realrichardsharpe@gmail.com>" ); |
1112 | MODULE_AUTHOR("Stefan Schmidt <stefan@datenfreihafen.org>" ); |
1113 | MODULE_AUTHOR("Werner Almesberger <werner@almesberger.net>" ); |
1114 | MODULE_AUTHOR("Josef Filzmaier <j.filzmaier@gmx.at>" ); |
1115 | MODULE_DESCRIPTION("ATUSB IEEE 802.15.4 Driver" ); |
1116 | MODULE_LICENSE("GPL" ); |
1117 | |