projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] zd1211rw: Add ID for Planex GW-US54Mini
[deliverable/linux.git] / drivers / net / wireless / zd1211rw / zd_usb.c
1 /* zd_usb.c
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 #include <asm/unaligned.h>
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/firmware.h>
23 #include <linux/device.h>
24 #include <linux/errno.h>
25 #include <linux/skbuff.h>
26 #include <linux/usb.h>
27 #include <linux/workqueue.h>
28 #include <net/ieee80211.h>
29
30 #include "zd_def.h"
31 #include "zd_netdev.h"
32 #include "zd_mac.h"
33 #include "zd_usb.h"
34 #include "zd_util.h"
35
36 static struct usb_device_id usb_ids[] = {
37 /* ZD1211 */
38 { USB_DEVICE(0x0ace, 0x1211), .driver_info = DEVICE_ZD1211 },
39 { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211 },
40 { USB_DEVICE(0x126f, 0xa006), .driver_info = DEVICE_ZD1211 },
41 { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
42 { USB_DEVICE(0x0df6, 0x9071), .driver_info = DEVICE_ZD1211 },
43 { USB_DEVICE(0x157e, 0x300b), .driver_info = DEVICE_ZD1211 },
44 { USB_DEVICE(0x079b, 0x004a), .driver_info = DEVICE_ZD1211 },
45 { USB_DEVICE(0x1740, 0x2000), .driver_info = DEVICE_ZD1211 },
46 { USB_DEVICE(0x157e, 0x3204), .driver_info = DEVICE_ZD1211 },
47 { USB_DEVICE(0x0586, 0x3402), .driver_info = DEVICE_ZD1211 },
48 { USB_DEVICE(0x0b3b, 0x5630), .driver_info = DEVICE_ZD1211 },
49 { USB_DEVICE(0x0b05, 0x170c), .driver_info = DEVICE_ZD1211 },
50 { USB_DEVICE(0x1435, 0x0711), .driver_info = DEVICE_ZD1211 },
51 { USB_DEVICE(0x0586, 0x3409), .driver_info = DEVICE_ZD1211 },
52 { USB_DEVICE(0x0b3b, 0x1630), .driver_info = DEVICE_ZD1211 },
53 { USB_DEVICE(0x0586, 0x3401), .driver_info = DEVICE_ZD1211 },
54 { USB_DEVICE(0x14ea, 0xab13), .driver_info = DEVICE_ZD1211 },
55 /* ZD1211B */
56 { USB_DEVICE(0x0ace, 0x1215), .driver_info = DEVICE_ZD1211B },
57 { USB_DEVICE(0x157e, 0x300d), .driver_info = DEVICE_ZD1211B },
58 { USB_DEVICE(0x079b, 0x0062), .driver_info = DEVICE_ZD1211B },
59 { USB_DEVICE(0x1582, 0x6003), .driver_info = DEVICE_ZD1211B },
60 /* "Driverless" devices that need ejecting */
61 { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
62 {}
63 };
64
65 MODULE_LICENSE("GPL");
66 MODULE_DESCRIPTION("USB driver for devices with the ZD1211 chip.");
67 MODULE_AUTHOR("Ulrich Kunitz");
68 MODULE_AUTHOR("Daniel Drake");
69 MODULE_VERSION("1.0");
70 MODULE_DEVICE_TABLE(usb, usb_ids);
71
72 #define FW_ZD1211_PREFIX "zd1211/zd1211_"
73 #define FW_ZD1211B_PREFIX "zd1211/zd1211b_"
74
75 /* register address handling */
76
77 #ifdef DEBUG
78 static int check_addr(struct zd_usb *usb, zd_addr_t addr)
79 {
80 u32 base = ZD_ADDR_BASE(addr);
81 u32 offset = ZD_OFFSET(addr);
82
83 if ((u32)addr & ADDR_ZERO_MASK)
84 goto invalid_address;
85 switch (base) {
86 case USB_BASE:
87 break;
88 case CR_BASE:
89 if (offset > CR_MAX_OFFSET) {
90 dev_dbg(zd_usb_dev(usb),
91 "CR offset %#010x larger than"
92 " CR_MAX_OFFSET %#10x\n",
93 offset, CR_MAX_OFFSET);
94 goto invalid_address;
95 }
96 if (offset & 1) {
97 dev_dbg(zd_usb_dev(usb),
98 "CR offset %#010x is not a multiple of 2\n",
99 offset);
100 goto invalid_address;
101 }
102 break;
103 case E2P_BASE:
104 if (offset > E2P_MAX_OFFSET) {
105 dev_dbg(zd_usb_dev(usb),
106 "E2P offset %#010x larger than"
107 " E2P_MAX_OFFSET %#010x\n",
108 offset, E2P_MAX_OFFSET);
109 goto invalid_address;
110 }
111 break;
112 case FW_BASE:
113 if (!usb->fw_base_offset) {
114 dev_dbg(zd_usb_dev(usb),
115 "ERROR: fw base offset has not been set\n");
116 return -EAGAIN;
117 }
118 if (offset > FW_MAX_OFFSET) {
119 dev_dbg(zd_usb_dev(usb),
120 "FW offset %#10x is larger than"
121 " FW_MAX_OFFSET %#010x\n",
122 offset, FW_MAX_OFFSET);
123 goto invalid_address;
124 }
125 break;
126 default:
127 dev_dbg(zd_usb_dev(usb),
128 "address has unsupported base %#010x\n", addr);
129 goto invalid_address;
130 }
131
132 return 0;
133 invalid_address:
134 dev_dbg(zd_usb_dev(usb),
135 "ERROR: invalid address: %#010x\n", addr);
136 return -EINVAL;
137 }
138 #endif /* DEBUG */
139
140 static u16 usb_addr(struct zd_usb *usb, zd_addr_t addr)
141 {
142 u32 base;
143 u16 offset;
144
145 base = ZD_ADDR_BASE(addr);
146 offset = ZD_OFFSET(addr);
147
148 ZD_ASSERT(check_addr(usb, addr) == 0);
149
150 switch (base) {
151 case CR_BASE:
152 offset += CR_BASE_OFFSET;
153 break;
154 case E2P_BASE:
155 offset += E2P_BASE_OFFSET;
156 break;
157 case FW_BASE:
158 offset += usb->fw_base_offset;
159 break;
160 }
161
162 return offset;
163 }
164
165 /* USB device initialization */
166
167 static int request_fw_file(
168 const struct firmware **fw, const char *name, struct device *device)
169 {
170 int r;
171
172 dev_dbg_f(device, "fw name %s\n", name);
173
174 r = request_firmware(fw, name, device);
175 if (r)
176 dev_err(device,
177 "Could not load firmware file %s. Error number %d\n",
178 name, r);
179 return r;
180 }
181
182 static inline u16 get_bcdDevice(const struct usb_device *udev)
183 {
184 return le16_to_cpu(udev->descriptor.bcdDevice);
185 }
186
187 enum upload_code_flags {
188 REBOOT = 1,
189 };
190
191 /* Ensures that MAX_TRANSFER_SIZE is even. */
192 #define MAX_TRANSFER_SIZE (USB_MAX_TRANSFER_SIZE & ~1)
193
194 static int upload_code(struct usb_device *udev,
195 const u8 *data, size_t size, u16 code_offset, int flags)
196 {
197 u8 *p;
198 int r;
199
200 /* USB request blocks need "kmalloced" buffers.
201 */
202 p = kmalloc(MAX_TRANSFER_SIZE, GFP_KERNEL);
203 if (!p) {
204 dev_err(&udev->dev, "out of memory\n");
205 r = -ENOMEM;
206 goto error;
207 }
208
209 size &= ~1;
210 while (size > 0) {
211 size_t transfer_size = size <= MAX_TRANSFER_SIZE ?
212 size : MAX_TRANSFER_SIZE;
213
214 dev_dbg_f(&udev->dev, "transfer size %zu\n", transfer_size);
215
216 memcpy(p, data, transfer_size);
217 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
218 USB_REQ_FIRMWARE_DOWNLOAD,
219 USB_DIR_OUT | USB_TYPE_VENDOR,
220 code_offset, 0, p, transfer_size, 1000 /* ms */);
221 if (r < 0) {
222 dev_err(&udev->dev,
223 "USB control request for firmware upload"
224 " failed. Error number %d\n", r);
225 goto error;
226 }
227 transfer_size = r & ~1;
228
229 size -= transfer_size;
230 data += transfer_size;
231 code_offset += transfer_size/sizeof(u16);
232 }
233
234 if (flags & REBOOT) {
235 u8 ret;
236
237 r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
238 USB_REQ_FIRMWARE_CONFIRM,
239 USB_DIR_IN | USB_TYPE_VENDOR,
240 0, 0, &ret, sizeof(ret), 5000 /* ms */);
241 if (r != sizeof(ret)) {
242 dev_err(&udev->dev,
243 "control request firmeware confirmation failed."
244 " Return value %d\n", r);
245 if (r >= 0)
246 r = -ENODEV;
247 goto error;
248 }
249 if (ret & 0x80) {
250 dev_err(&udev->dev,
251 "Internal error while downloading."
252 " Firmware confirm return value %#04x\n",
253 (unsigned int)ret);
254 r = -ENODEV;
255 goto error;
256 }
257 dev_dbg_f(&udev->dev, "firmware confirm return value %#04x\n",
258 (unsigned int)ret);
259 }
260
261 r = 0;
262 error:
263 kfree(p);
264 return r;
265 }
266
267 static u16 get_word(const void *data, u16 offset)
268 {
269 const __le16 *p = data;
270 return le16_to_cpu(p[offset]);
271 }
272
273 static char *get_fw_name(char *buffer, size_t size, u8 device_type,
274 const char* postfix)
275 {
276 scnprintf(buffer, size, "%s%s",
277 device_type == DEVICE_ZD1211B ?
278 FW_ZD1211B_PREFIX : FW_ZD1211_PREFIX,
279 postfix);
280 return buffer;
281 }
282
283 static int handle_version_mismatch(struct usb_device *udev, u8 device_type,
284 const struct firmware *ub_fw)
285 {
286 const struct firmware *ur_fw = NULL;
287 int offset;
288 int r = 0;
289 char fw_name[128];
290
291 r = request_fw_file(&ur_fw,
292 get_fw_name(fw_name, sizeof(fw_name), device_type, "ur"),
293 &udev->dev);
294 if (r)
295 goto error;
296
297 r = upload_code(udev, ur_fw->data, ur_fw->size, FW_START_OFFSET,
298 REBOOT);
299 if (r)
300 goto error;
301
302 offset = ((EEPROM_REGS_OFFSET + EEPROM_REGS_SIZE) * sizeof(u16));
303 r = upload_code(udev, ub_fw->data + offset, ub_fw->size - offset,
304 E2P_BASE_OFFSET + EEPROM_REGS_SIZE, REBOOT);
305
306 /* At this point, the vendor driver downloads the whole firmware
307 * image, hacks around with version IDs, and uploads it again,
308 * completely overwriting the boot code. We do not do this here as
309 * it is not required on any tested devices, and it is suspected to
310 * cause problems. */
311 error:
312 release_firmware(ur_fw);
313 return r;
314 }
315
316 static int upload_firmware(struct usb_device *udev, u8 device_type)
317 {
318 int r;
319 u16 fw_bcdDevice;
320 u16 bcdDevice;
321 const struct firmware *ub_fw = NULL;
322 const struct firmware *uph_fw = NULL;
323 char fw_name[128];
324
325 bcdDevice = get_bcdDevice(udev);
326
327 r = request_fw_file(&ub_fw,
328 get_fw_name(fw_name, sizeof(fw_name), device_type, "ub"),
329 &udev->dev);
330 if (r)
331 goto error;
332
333 fw_bcdDevice = get_word(ub_fw->data, EEPROM_REGS_OFFSET);
334
335 if (fw_bcdDevice != bcdDevice) {
336 dev_info(&udev->dev,
337 "firmware version %#06x and device bootcode version "
338 "%#06x differ\n", fw_bcdDevice, bcdDevice);
339 if (bcdDevice <= 0x4313)
340 dev_warn(&udev->dev, "device has old bootcode, please "
341 "report success or failure\n");
342
343 r = handle_version_mismatch(udev, device_type, ub_fw);
344 if (r)
345 goto error;
346 } else {
347 dev_dbg_f(&udev->dev,
348 "firmware device id %#06x is equal to the "
349 "actual device id\n", fw_bcdDevice);
350 }
351
352
353 r = request_fw_file(&uph_fw,
354 get_fw_name(fw_name, sizeof(fw_name), device_type, "uphr"),
355 &udev->dev);
356 if (r)
357 goto error;
358
359 r = upload_code(udev, uph_fw->data, uph_fw->size, FW_START_OFFSET,
360 REBOOT);
361 if (r) {
362 dev_err(&udev->dev,
363 "Could not upload firmware code uph. Error number %d\n",
364 r);
365 }
366
367 /* FALL-THROUGH */
368 error:
369 release_firmware(ub_fw);
370 release_firmware(uph_fw);
371 return r;
372 }
373
374 #define urb_dev(urb) (&(urb)->dev->dev)
375
376 static inline void handle_regs_int(struct urb *urb)
377 {
378 struct zd_usb *usb = urb->context;
379 struct zd_usb_interrupt *intr = &usb->intr;
380 int len;
381
382 ZD_ASSERT(in_interrupt());
383 spin_lock(&intr->lock);
384
385 if (intr->read_regs_enabled) {
386 intr->read_regs.length = len = urb->actual_length;
387
388 if (len > sizeof(intr->read_regs.buffer))
389 len = sizeof(intr->read_regs.buffer);
390 memcpy(intr->read_regs.buffer, urb->transfer_buffer, len);
391 intr->read_regs_enabled = 0;
392 complete(&intr->read_regs.completion);
393 goto out;
394 }
395
396 dev_dbg_f(urb_dev(urb), "regs interrupt ignored\n");
397 out:
398 spin_unlock(&intr->lock);
399 }
400
401 static inline void handle_retry_failed_int(struct urb *urb)
402 {
403 dev_dbg_f(urb_dev(urb), "retry failed interrupt\n");
404 }
405
406
407 static void int_urb_complete(struct urb *urb)
408 {
409 int r;
410 struct usb_int_header *hdr;
411
412 switch (urb->status) {
413 case 0:
414 break;
415 case -ESHUTDOWN:
416 case -EINVAL:
417 case -ENODEV:
418 case -ENOENT:
419 case -ECONNRESET:
420 case -EPIPE:
421 goto kfree;
422 default:
423 goto resubmit;
424 }
425
426 if (urb->actual_length < sizeof(hdr)) {
427 dev_dbg_f(urb_dev(urb), "error: urb %p to small\n", urb);
428 goto resubmit;
429 }
430
431 hdr = urb->transfer_buffer;
432 if (hdr->type != USB_INT_TYPE) {
433 dev_dbg_f(urb_dev(urb), "error: urb %p wrong type\n", urb);
434 goto resubmit;
435 }
436
437 switch (hdr->id) {
438 case USB_INT_ID_REGS:
439 handle_regs_int(urb);
440 break;
441 case USB_INT_ID_RETRY_FAILED:
442 handle_retry_failed_int(urb);
443 break;
444 default:
445 dev_dbg_f(urb_dev(urb), "error: urb %p unknown id %x\n", urb,
446 (unsigned int)hdr->id);
447 goto resubmit;
448 }
449
450 resubmit:
451 r = usb_submit_urb(urb, GFP_ATOMIC);
452 if (r) {
453 dev_dbg_f(urb_dev(urb), "resubmit urb %p\n", urb);
454 goto kfree;
455 }
456 return;
457 kfree:
458 kfree(urb->transfer_buffer);
459 }
460
461 static inline int int_urb_interval(struct usb_device *udev)
462 {
463 switch (udev->speed) {
464 case USB_SPEED_HIGH:
465 return 4;
466 case USB_SPEED_LOW:
467 return 10;
468 case USB_SPEED_FULL:
469 default:
470 return 1;
471 }
472 }
473
474 static inline int usb_int_enabled(struct zd_usb *usb)
475 {
476 unsigned long flags;
477 struct zd_usb_interrupt *intr = &usb->intr;
478 struct urb *urb;
479
480 spin_lock_irqsave(&intr->lock, flags);
481 urb = intr->urb;
482 spin_unlock_irqrestore(&intr->lock, flags);
483 return urb != NULL;
484 }
485
486 int zd_usb_enable_int(struct zd_usb *usb)
487 {
488 int r;
489 struct usb_device *udev;
490 struct zd_usb_interrupt *intr = &usb->intr;
491 void *transfer_buffer = NULL;
492 struct urb *urb;
493
494 dev_dbg_f(zd_usb_dev(usb), "\n");
495
496 urb = usb_alloc_urb(0, GFP_NOFS);
497 if (!urb) {
498 r = -ENOMEM;
499 goto out;
500 }
501
502 ZD_ASSERT(!irqs_disabled());
503 spin_lock_irq(&intr->lock);
504 if (intr->urb) {
505 spin_unlock_irq(&intr->lock);
506 r = 0;
507 goto error_free_urb;
508 }
509 intr->urb = urb;
510 spin_unlock_irq(&intr->lock);
511
512 /* TODO: make it a DMA buffer */
513 r = -ENOMEM;
514 transfer_buffer = kmalloc(USB_MAX_EP_INT_BUFFER, GFP_NOFS);
515 if (!transfer_buffer) {
516 dev_dbg_f(zd_usb_dev(usb),
517 "couldn't allocate transfer_buffer\n");
518 goto error_set_urb_null;
519 }
520
521 udev = zd_usb_to_usbdev(usb);
522 usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),
523 transfer_buffer, USB_MAX_EP_INT_BUFFER,
524 int_urb_complete, usb,
525 intr->interval);
526
527 dev_dbg_f(zd_usb_dev(usb), "submit urb %p\n", intr->urb);
528 r = usb_submit_urb(urb, GFP_NOFS);
529 if (r) {
530 dev_dbg_f(zd_usb_dev(usb),
531 "Couldn't submit urb. Error number %d\n", r);
532 goto error;
533 }
534
535 return 0;
536 error:
537 kfree(transfer_buffer);
538 error_set_urb_null:
539 spin_lock_irq(&intr->lock);
540 intr->urb = NULL;
541 spin_unlock_irq(&intr->lock);
542 error_free_urb:
543 usb_free_urb(urb);
544 out:
545 return r;
546 }
547
548 void zd_usb_disable_int(struct zd_usb *usb)
549 {
550 unsigned long flags;
551 struct zd_usb_interrupt *intr = &usb->intr;
552 struct urb *urb;
553
554 spin_lock_irqsave(&intr->lock, flags);
555 urb = intr->urb;
556 if (!urb) {
557 spin_unlock_irqrestore(&intr->lock, flags);
558 return;
559 }
560 intr->urb = NULL;
561 spin_unlock_irqrestore(&intr->lock, flags);
562
563 usb_kill_urb(urb);
564 dev_dbg_f(zd_usb_dev(usb), "urb %p killed\n", urb);
565 usb_free_urb(urb);
566 }
567
568 static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
569 unsigned int length)
570 {
571 int i;
572 struct zd_mac *mac = zd_usb_to_mac(usb);
573 const struct rx_length_info *length_info;
574
575 if (length < sizeof(struct rx_length_info)) {
576 /* It's not a complete packet anyhow. */
577 return;
578 }
579 length_info = (struct rx_length_info *)
580 (buffer + length - sizeof(struct rx_length_info));
581
582 /* It might be that three frames are merged into a single URB
583 * transaction. We have to check for the length info tag.
584 *
585 * While testing we discovered that length_info might be unaligned,
586 * because if USB transactions are merged, the last packet will not
587 * be padded. Unaligned access might also happen if the length_info
588 * structure is not present.
589 */
590 if (get_unaligned(&length_info->tag) == cpu_to_le16(RX_LENGTH_INFO_TAG))
591 {
592 unsigned int l, k, n;
593 for (i = 0, l = 0;; i++) {
594 k = le16_to_cpu(get_unaligned(&length_info->length[i]));
595 n = l+k;
596 if (n > length)
597 return;
598 zd_mac_rx(mac, buffer+l, k);
599 if (i >= 2)
600 return;
601 l = (n+3) & ~3;
602 }
603 } else {
604 zd_mac_rx(mac, buffer, length);
605 }
606 }
607
608 static void rx_urb_complete(struct urb *urb)
609 {
610 struct zd_usb *usb;
611 struct zd_usb_rx *rx;
612 const u8 *buffer;
613 unsigned int length;
614
615 switch (urb->status) {
616 case 0:
617 break;
618 case -ESHUTDOWN:
619 case -EINVAL:
620 case -ENODEV:
621 case -ENOENT:
622 case -ECONNRESET:
623 case -EPIPE:
624 return;
625 default:
626 dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
627 goto resubmit;
628 }
629
630 buffer = urb->transfer_buffer;
631 length = urb->actual_length;
632 usb = urb->context;
633 rx = &usb->rx;
634
635 if (length%rx->usb_packet_size > rx->usb_packet_size-4) {
636 /* If there is an old first fragment, we don't care. */
637 dev_dbg_f(urb_dev(urb), "*** first fragment ***\n");
638 ZD_ASSERT(length <= ARRAY_SIZE(rx->fragment));
639 spin_lock(&rx->lock);
640 memcpy(rx->fragment, buffer, length);
641 rx->fragment_length = length;
642 spin_unlock(&rx->lock);
643 goto resubmit;
644 }
645
646 spin_lock(&rx->lock);
647 if (rx->fragment_length > 0) {
648 /* We are on a second fragment, we believe */
649 ZD_ASSERT(length + rx->fragment_length <=
650 ARRAY_SIZE(rx->fragment));
651 dev_dbg_f(urb_dev(urb), "*** second fragment ***\n");
652 memcpy(rx->fragment+rx->fragment_length, buffer, length);
653 handle_rx_packet(usb, rx->fragment,
654 rx->fragment_length + length);
655 rx->fragment_length = 0;
656 spin_unlock(&rx->lock);
657 } else {
658 spin_unlock(&rx->lock);
659 handle_rx_packet(usb, buffer, length);
660 }
661
662 resubmit:
663 usb_submit_urb(urb, GFP_ATOMIC);
664 }
665
666 static struct urb *alloc_urb(struct zd_usb *usb)
667 {
668 struct usb_device *udev = zd_usb_to_usbdev(usb);
669 struct urb *urb;
670 void *buffer;
671
672 urb = usb_alloc_urb(0, GFP_NOFS);
673 if (!urb)
674 return NULL;
675 buffer = usb_buffer_alloc(udev, USB_MAX_RX_SIZE, GFP_NOFS,
676 &urb->transfer_dma);
677 if (!buffer) {
678 usb_free_urb(urb);
679 return NULL;
680 }
681
682 usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN),
683 buffer, USB_MAX_RX_SIZE,
684 rx_urb_complete, usb);
685 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
686
687 return urb;
688 }
689
690 static void free_urb(struct urb *urb)
691 {
692 if (!urb)
693 return;
694 usb_buffer_free(urb->dev, urb->transfer_buffer_length,
695 urb->transfer_buffer, urb->transfer_dma);
696 usb_free_urb(urb);
697 }
698
699 int zd_usb_enable_rx(struct zd_usb *usb)
700 {
701 int i, r;
702 struct zd_usb_rx *rx = &usb->rx;
703 struct urb **urbs;
704
705 dev_dbg_f(zd_usb_dev(usb), "\n");
706
707 r = -ENOMEM;
708 urbs = kcalloc(URBS_COUNT, sizeof(struct urb *), GFP_NOFS);
709 if (!urbs)
710 goto error;
711 for (i = 0; i < URBS_COUNT; i++) {
712 urbs[i] = alloc_urb(usb);
713 if (!urbs[i])
714 goto error;
715 }
716
717 ZD_ASSERT(!irqs_disabled());
718 spin_lock_irq(&rx->lock);
719 if (rx->urbs) {
720 spin_unlock_irq(&rx->lock);
721 r = 0;
722 goto error;
723 }
724 rx->urbs = urbs;
725 rx->urbs_count = URBS_COUNT;
726 spin_unlock_irq(&rx->lock);
727
728 for (i = 0; i < URBS_COUNT; i++) {
729 r = usb_submit_urb(urbs[i], GFP_NOFS);
730 if (r)
731 goto error_submit;
732 }
733
734 return 0;
735 error_submit:
736 for (i = 0; i < URBS_COUNT; i++) {
737 usb_kill_urb(urbs[i]);
738 }
739 spin_lock_irq(&rx->lock);
740 rx->urbs = NULL;
741 rx->urbs_count = 0;
742 spin_unlock_irq(&rx->lock);
743 error:
744 if (urbs) {
745 for (i = 0; i < URBS_COUNT; i++)
746 free_urb(urbs[i]);
747 }
748 return r;
749 }
750
751 void zd_usb_disable_rx(struct zd_usb *usb)
752 {
753 int i;
754 unsigned long flags;
755 struct urb **urbs;
756 unsigned int count;
757 struct zd_usb_rx *rx = &usb->rx;
758
759 spin_lock_irqsave(&rx->lock, flags);
760 urbs = rx->urbs;
761 count = rx->urbs_count;
762 spin_unlock_irqrestore(&rx->lock, flags);
763 if (!urbs)
764 return;
765
766 for (i = 0; i < count; i++) {
767 usb_kill_urb(urbs[i]);
768 free_urb(urbs[i]);
769 }
770 kfree(urbs);
771
772 spin_lock_irqsave(&rx->lock, flags);
773 rx->urbs = NULL;
774 rx->urbs_count = 0;
775 spin_unlock_irqrestore(&rx->lock, flags);
776 }
777
778 static void tx_urb_complete(struct urb *urb)
779 {
780 int r;
781
782 switch (urb->status) {
783 case 0:
784 break;
785 case -ESHUTDOWN:
786 case -EINVAL:
787 case -ENODEV:
788 case -ENOENT:
789 case -ECONNRESET:
790 case -EPIPE:
791 dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
792 break;
793 default:
794 dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
795 goto resubmit;
796 }
797 free_urb:
798 usb_buffer_free(urb->dev, urb->transfer_buffer_length,
799 urb->transfer_buffer, urb->transfer_dma);
800 usb_free_urb(urb);
801 return;
802 resubmit:
803 r = usb_submit_urb(urb, GFP_ATOMIC);
804 if (r) {
805 dev_dbg_f(urb_dev(urb), "error resubmit urb %p %d\n", urb, r);
806 goto free_urb;
807 }
808 }
809
810 /* Puts the frame on the USB endpoint. It doesn't wait for
811 * completion. The frame must contain the control set.
812 */
813 int zd_usb_tx(struct zd_usb *usb, const u8 *frame, unsigned int length)
814 {
815 int r;
816 struct usb_device *udev = zd_usb_to_usbdev(usb);
817 struct urb *urb;
818 void *buffer;
819
820 urb = usb_alloc_urb(0, GFP_ATOMIC);
821 if (!urb) {
822 r = -ENOMEM;
823 goto out;
824 }
825
826 buffer = usb_buffer_alloc(zd_usb_to_usbdev(usb), length, GFP_ATOMIC,
827 &urb->transfer_dma);
828 if (!buffer) {
829 r = -ENOMEM;
830 goto error_free_urb;
831 }
832 memcpy(buffer, frame, length);
833
834 usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
835 buffer, length, tx_urb_complete, NULL);
836 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
837
838 r = usb_submit_urb(urb, GFP_ATOMIC);
839 if (r)
840 goto error;
841 return 0;
842 error:
843 usb_buffer_free(zd_usb_to_usbdev(usb), length, buffer,
844 urb->transfer_dma);
845 error_free_urb:
846 usb_free_urb(urb);
847 out:
848 return r;
849 }
850
851 static inline void init_usb_interrupt(struct zd_usb *usb)
852 {
853 struct zd_usb_interrupt *intr = &usb->intr;
854
855 spin_lock_init(&intr->lock);
856 intr->interval = int_urb_interval(zd_usb_to_usbdev(usb));
857 init_completion(&intr->read_regs.completion);
858 intr->read_regs.cr_int_addr = cpu_to_le16(usb_addr(usb, CR_INTERRUPT));
859 }
860
861 static inline void init_usb_rx(struct zd_usb *usb)
862 {
863 struct zd_usb_rx *rx = &usb->rx;
864 spin_lock_init(&rx->lock);
865 if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH) {
866 rx->usb_packet_size = 512;
867 } else {
868 rx->usb_packet_size = 64;
869 }
870 ZD_ASSERT(rx->fragment_length == 0);
871 }
872
873 static inline void init_usb_tx(struct zd_usb *usb)
874 {
875 /* FIXME: at this point we will allocate a fixed number of urb's for
876 * use in a cyclic scheme */
877 }
878
879 void zd_usb_init(struct zd_usb *usb, struct net_device *netdev,
880 struct usb_interface *intf)
881 {
882 memset(usb, 0, sizeof(*usb));
883 usb->intf = usb_get_intf(intf);
884 usb_set_intfdata(usb->intf, netdev);
885 init_usb_interrupt(usb);
886 init_usb_tx(usb);
887 init_usb_rx(usb);
888 }
889
890 int zd_usb_init_hw(struct zd_usb *usb)
891 {
892 int r;
893 struct zd_chip *chip = zd_usb_to_chip(usb);
894
895 ZD_ASSERT(mutex_is_locked(&chip->mutex));
896 r = zd_ioread16_locked(chip, &usb->fw_base_offset,
897 USB_REG((u16)FW_BASE_ADDR_OFFSET));
898 if (r)
899 return r;
900 dev_dbg_f(zd_usb_dev(usb), "fw_base_offset: %#06hx\n",
901 usb->fw_base_offset);
902
903 return 0;
904 }
905
906 void zd_usb_clear(struct zd_usb *usb)
907 {
908 usb_set_intfdata(usb->intf, NULL);
909 usb_put_intf(usb->intf);
910 ZD_MEMCLEAR(usb, sizeof(*usb));
911 /* FIXME: usb_interrupt, usb_tx, usb_rx? */
912 }
913
914 static const char *speed(enum usb_device_speed speed)
915 {
916 switch (speed) {
917 case USB_SPEED_LOW:
918 return "low";
919 case USB_SPEED_FULL:
920 return "full";
921 case USB_SPEED_HIGH:
922 return "high";
923 default:
924 return "unknown speed";
925 }
926 }
927
928 static int scnprint_id(struct usb_device *udev, char *buffer, size_t size)
929 {
930 return scnprintf(buffer, size, "%04hx:%04hx v%04hx %s",
931 le16_to_cpu(udev->descriptor.idVendor),
932 le16_to_cpu(udev->descriptor.idProduct),
933 get_bcdDevice(udev),
934 speed(udev->speed));
935 }
936
937 int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size)
938 {
939 struct usb_device *udev = interface_to_usbdev(usb->intf);
940 return scnprint_id(udev, buffer, size);
941 }
942
943 #ifdef DEBUG
944 static void print_id(struct usb_device *udev)
945 {
946 char buffer[40];
947
948 scnprint_id(udev, buffer, sizeof(buffer));
949 buffer[sizeof(buffer)-1] = 0;
950 dev_dbg_f(&udev->dev, "%s\n", buffer);
951 }
952 #else
953 #define print_id(udev) do { } while (0)
954 #endif
955
956 static int eject_installer(struct usb_interface *intf)
957 {
958 struct usb_device *udev = interface_to_usbdev(intf);
959 struct usb_host_interface *iface_desc = &intf->altsetting[0];
960 struct usb_endpoint_descriptor *endpoint;
961 unsigned char *cmd;
962 u8 bulk_out_ep;
963 int r;
964
965 /* Find bulk out endpoint */
966 endpoint = &iface_desc->endpoint[1].desc;
967 if ((endpoint->bEndpointAddress & USB_TYPE_MASK) == USB_DIR_OUT &&
968 (endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
969 USB_ENDPOINT_XFER_BULK) {
970 bulk_out_ep = endpoint->bEndpointAddress;
971 } else {
972 dev_err(&udev->dev,
973 "zd1211rw: Could not find bulk out endpoint\n");
974 return -ENODEV;
975 }
976
977 cmd = kzalloc(31, GFP_KERNEL);
978 if (cmd == NULL)
979 return -ENODEV;
980
981 /* USB bulk command block */
982 cmd[0] = 0x55; /* bulk command signature */
983 cmd[1] = 0x53; /* bulk command signature */
984 cmd[2] = 0x42; /* bulk command signature */
985 cmd[3] = 0x43; /* bulk command signature */
986 cmd[14] = 6; /* command length */
987
988 cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */
989 cmd[19] = 0x2; /* eject disc */
990
991 dev_info(&udev->dev, "Ejecting virtual installer media...\n");
992 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep),
993 cmd, 31, NULL, 2000);
994 kfree(cmd);
995 if (r)
996 return r;
997
998 /* At this point, the device disconnects and reconnects with the real
999 * ID numbers. */
1000
1001 usb_set_intfdata(intf, NULL);
1002 return 0;
1003 }
1004
1005 static int probe(struct usb_interface *intf, const struct usb_device_id *id)
1006 {
1007 int r;
1008 struct usb_device *udev = interface_to_usbdev(intf);
1009 struct net_device *netdev = NULL;
1010
1011 print_id(udev);
1012
1013 if (id->driver_info & DEVICE_INSTALLER)
1014 return eject_installer(intf);
1015
1016 switch (udev->speed) {
1017 case USB_SPEED_LOW:
1018 case USB_SPEED_FULL:
1019 case USB_SPEED_HIGH:
1020 break;
1021 default:
1022 dev_dbg_f(&intf->dev, "Unknown USB speed\n");
1023 r = -ENODEV;
1024 goto error;
1025 }
1026
1027 netdev = zd_netdev_alloc(intf);
1028 if (netdev == NULL) {
1029 r = -ENOMEM;
1030 goto error;
1031 }
1032
1033 r = upload_firmware(udev, id->driver_info);
1034 if (r) {
1035 dev_err(&intf->dev,
1036 "couldn't load firmware. Error number %d\n", r);
1037 goto error;
1038 }
1039
1040 r = usb_reset_configuration(udev);
1041 if (r) {
1042 dev_dbg_f(&intf->dev,
1043 "couldn't reset configuration. Error number %d\n", r);
1044 goto error;
1045 }
1046
1047 /* At this point the interrupt endpoint is not generally enabled. We
1048 * save the USB bandwidth until the network device is opened. But
1049 * notify that the initialization of the MAC will require the
1050 * interrupts to be temporary enabled.
1051 */
1052 r = zd_mac_init_hw(zd_netdev_mac(netdev), id->driver_info);
1053 if (r) {
1054 dev_dbg_f(&intf->dev,
1055 "couldn't initialize mac. Error number %d\n", r);
1056 goto error;
1057 }
1058
1059 r = register_netdev(netdev);
1060 if (r) {
1061 dev_dbg_f(&intf->dev,
1062 "couldn't register netdev. Error number %d\n", r);
1063 goto error;
1064 }
1065
1066 dev_dbg_f(&intf->dev, "successful\n");
1067 dev_info(&intf->dev,"%s\n", netdev->name);
1068 return 0;
1069 error:
1070 usb_reset_device(interface_to_usbdev(intf));
1071 zd_netdev_free(netdev);
1072 return r;
1073 }
1074
1075 static void disconnect(struct usb_interface *intf)
1076 {
1077 struct net_device *netdev = zd_intf_to_netdev(intf);
1078 struct zd_mac *mac = zd_netdev_mac(netdev);
1079 struct zd_usb *usb = &mac->chip.usb;
1080
1081 /* Either something really bad happened, or we're just dealing with
1082 * a DEVICE_INSTALLER. */
1083 if (netdev == NULL)
1084 return;
1085
1086 dev_dbg_f(zd_usb_dev(usb), "\n");
1087
1088 zd_netdev_disconnect(netdev);
1089
1090 /* Just in case something has gone wrong! */
1091 zd_usb_disable_rx(usb);
1092 zd_usb_disable_int(usb);
1093
1094 /* If the disconnect has been caused by a removal of the
1095 * driver module, the reset allows reloading of the driver. If the
1096 * reset will not be executed here, the upload of the firmware in the
1097 * probe function caused by the reloading of the driver will fail.
1098 */
1099 usb_reset_device(interface_to_usbdev(intf));
1100
1101 zd_netdev_free(netdev);
1102 dev_dbg(&intf->dev, "disconnected\n");
1103 }
1104
1105 static struct usb_driver driver = {
1106 .name = "zd1211rw",
1107 .id_table = usb_ids,
1108 .probe = probe,
1109 .disconnect = disconnect,
1110 };
1111
1112 struct workqueue_struct *zd_workqueue;
1113
1114 static int __init usb_init(void)
1115 {
1116 int r;
1117
1118 pr_debug("usb_init()\n");
1119
1120 zd_workqueue = create_singlethread_workqueue(driver.name);
1121 if (zd_workqueue == NULL) {
1122 printk(KERN_ERR "%s: couldn't create workqueue\n", driver.name);
1123 return -ENOMEM;
1124 }
1125
1126 r = usb_register(&driver);
1127 if (r) {
1128 printk(KERN_ERR "usb_register() failed. Error number %d\n", r);
1129 return r;
1130 }
1131
1132 pr_debug("zd1211rw initialized\n");
1133 return 0;
1134 }
1135
1136 static void __exit usb_exit(void)
1137 {
1138 pr_debug("usb_exit()\n");
1139 usb_deregister(&driver);
1140 destroy_workqueue(zd_workqueue);
1141 }
1142
1143 module_init(usb_init);
1144 module_exit(usb_exit);
1145
1146 static int usb_int_regs_length(unsigned int count)
1147 {
1148 return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
1149 }
1150
1151 static void prepare_read_regs_int(struct zd_usb *usb)
1152 {
1153 struct zd_usb_interrupt *intr = &usb->intr;
1154
1155 spin_lock_irq(&intr->lock);
1156 intr->read_regs_enabled = 1;
1157 INIT_COMPLETION(intr->read_regs.completion);
1158 spin_unlock_irq(&intr->lock);
1159 }
1160
1161 static void disable_read_regs_int(struct zd_usb *usb)
1162 {
1163 struct zd_usb_interrupt *intr = &usb->intr;
1164
1165 spin_lock_irq(&intr->lock);
1166 intr->read_regs_enabled = 0;
1167 spin_unlock_irq(&intr->lock);
1168 }
1169
1170 static int get_results(struct zd_usb *usb, u16 *values,
1171 struct usb_req_read_regs *req, unsigned int count)
1172 {
1173 int r;
1174 int i;
1175 struct zd_usb_interrupt *intr = &usb->intr;
1176 struct read_regs_int *rr = &intr->read_regs;
1177 struct usb_int_regs *regs = (struct usb_int_regs *)rr->buffer;
1178
1179 spin_lock_irq(&intr->lock);
1180
1181 r = -EIO;
1182 /* The created block size seems to be larger than expected.
1183 * However results appear to be correct.
1184 */
1185 if (rr->length < usb_int_regs_length(count)) {
1186 dev_dbg_f(zd_usb_dev(usb),
1187 "error: actual length %d less than expected %d\n",
1188 rr->length, usb_int_regs_length(count));
1189 goto error_unlock;
1190 }
1191 if (rr->length > sizeof(rr->buffer)) {
1192 dev_dbg_f(zd_usb_dev(usb),
1193 "error: actual length %d exceeds buffer size %zu\n",
1194 rr->length, sizeof(rr->buffer));
1195 goto error_unlock;
1196 }
1197
1198 for (i = 0; i < count; i++) {
1199 struct reg_data *rd = &regs->regs[i];
1200 if (rd->addr != req->addr[i]) {
1201 dev_dbg_f(zd_usb_dev(usb),
1202 "rd[%d] addr %#06hx expected %#06hx\n", i,
1203 le16_to_cpu(rd->addr),
1204 le16_to_cpu(req->addr[i]));
1205 goto error_unlock;
1206 }
1207 values[i] = le16_to_cpu(rd->value);
1208 }
1209
1210 r = 0;
1211 error_unlock:
1212 spin_unlock_irq(&intr->lock);
1213 return r;
1214 }
1215
1216 int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
1217 const zd_addr_t *addresses, unsigned int count)
1218 {
1219 int r;
1220 int i, req_len, actual_req_len;
1221 struct usb_device *udev;
1222 struct usb_req_read_regs *req = NULL;
1223 unsigned long timeout;
1224
1225 if (count < 1) {
1226 dev_dbg_f(zd_usb_dev(usb), "error: count is zero\n");
1227 return -EINVAL;
1228 }
1229 if (count > USB_MAX_IOREAD16_COUNT) {
1230 dev_dbg_f(zd_usb_dev(usb),
1231 "error: count %u exceeds possible max %u\n",
1232 count, USB_MAX_IOREAD16_COUNT);
1233 return -EINVAL;
1234 }
1235 if (in_atomic()) {
1236 dev_dbg_f(zd_usb_dev(usb),
1237 "error: io in atomic context not supported\n");
1238 return -EWOULDBLOCK;
1239 }
1240 if (!usb_int_enabled(usb)) {
1241 dev_dbg_f(zd_usb_dev(usb),
1242 "error: usb interrupt not enabled\n");
1243 return -EWOULDBLOCK;
1244 }
1245
1246 req_len = sizeof(struct usb_req_read_regs) + count * sizeof(__le16);
1247 req = kmalloc(req_len, GFP_NOFS);
1248 if (!req)
1249 return -ENOMEM;
1250 req->id = cpu_to_le16(USB_REQ_READ_REGS);
1251 for (i = 0; i < count; i++)
1252 req->addr[i] = cpu_to_le16(usb_addr(usb, addresses[i]));
1253
1254 udev = zd_usb_to_usbdev(usb);
1255 prepare_read_regs_int(usb);
1256 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1257 req, req_len, &actual_req_len, 1000 /* ms */);
1258 if (r) {
1259 dev_dbg_f(zd_usb_dev(usb),
1260 "error in usb_bulk_msg(). Error number %d\n", r);
1261 goto error;
1262 }
1263 if (req_len != actual_req_len) {
1264 dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()\n"
1265 " req_len %d != actual_req_len %d\n",
1266 req_len, actual_req_len);
1267 r = -EIO;
1268 goto error;
1269 }
1270
1271 timeout = wait_for_completion_timeout(&usb->intr.read_regs.completion,
1272 msecs_to_jiffies(1000));
1273 if (!timeout) {
1274 disable_read_regs_int(usb);
1275 dev_dbg_f(zd_usb_dev(usb), "read timed out\n");
1276 r = -ETIMEDOUT;
1277 goto error;
1278 }
1279
1280 r = get_results(usb, values, req, count);
1281 error:
1282 kfree(req);
1283 return r;
1284 }
1285
1286 int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
1287 unsigned int count)
1288 {
1289 int r;
1290 struct usb_device *udev;
1291 struct usb_req_write_regs *req = NULL;
1292 int i, req_len, actual_req_len;
1293
1294 if (count == 0)
1295 return 0;
1296 if (count > USB_MAX_IOWRITE16_COUNT) {
1297 dev_dbg_f(zd_usb_dev(usb),
1298 "error: count %u exceeds possible max %u\n",
1299 count, USB_MAX_IOWRITE16_COUNT);
1300 return -EINVAL;
1301 }
1302 if (in_atomic()) {
1303 dev_dbg_f(zd_usb_dev(usb),
1304 "error: io in atomic context not supported\n");
1305 return -EWOULDBLOCK;
1306 }
1307
1308 req_len = sizeof(struct usb_req_write_regs) +
1309 count * sizeof(struct reg_data);
1310 req = kmalloc(req_len, GFP_NOFS);
1311 if (!req)
1312 return -ENOMEM;
1313
1314 req->id = cpu_to_le16(USB_REQ_WRITE_REGS);
1315 for (i = 0; i < count; i++) {
1316 struct reg_data *rw = &req->reg_writes[i];
1317 rw->addr = cpu_to_le16(usb_addr(usb, ioreqs[i].addr));
1318 rw->value = cpu_to_le16(ioreqs[i].value);
1319 }
1320
1321 udev = zd_usb_to_usbdev(usb);
1322 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1323 req, req_len, &actual_req_len, 1000 /* ms */);
1324 if (r) {
1325 dev_dbg_f(zd_usb_dev(usb),
1326 "error in usb_bulk_msg(). Error number %d\n", r);
1327 goto error;
1328 }
1329 if (req_len != actual_req_len) {
1330 dev_dbg_f(zd_usb_dev(usb),
1331 "error in usb_bulk_msg()"
1332 " req_len %d != actual_req_len %d\n",
1333 req_len, actual_req_len);
1334 r = -EIO;
1335 goto error;
1336 }
1337
1338 /* FALL-THROUGH with r == 0 */
1339 error:
1340 kfree(req);
1341 return r;
1342 }
1343
1344 int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits)
1345 {
1346 int r;
1347 struct usb_device *udev;
1348 struct usb_req_rfwrite *req = NULL;
1349 int i, req_len, actual_req_len;
1350 u16 bit_value_template;
1351
1352 if (in_atomic()) {
1353 dev_dbg_f(zd_usb_dev(usb),
1354 "error: io in atomic context not supported\n");
1355 return -EWOULDBLOCK;
1356 }
1357 if (bits < USB_MIN_RFWRITE_BIT_COUNT) {
1358 dev_dbg_f(zd_usb_dev(usb),
1359 "error: bits %d are smaller than"
1360 " USB_MIN_RFWRITE_BIT_COUNT %d\n",
1361 bits, USB_MIN_RFWRITE_BIT_COUNT);
1362 return -EINVAL;
1363 }
1364 if (bits > USB_MAX_RFWRITE_BIT_COUNT) {
1365 dev_dbg_f(zd_usb_dev(usb),
1366 "error: bits %d exceed USB_MAX_RFWRITE_BIT_COUNT %d\n",
1367 bits, USB_MAX_RFWRITE_BIT_COUNT);
1368 return -EINVAL;
1369 }
1370 #ifdef DEBUG
1371 if (value & (~0UL << bits)) {
1372 dev_dbg_f(zd_usb_dev(usb),
1373 "error: value %#09x has bits >= %d set\n",
1374 value, bits);
1375 return -EINVAL;
1376 }
1377 #endif /* DEBUG */
1378
1379 dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d\n", value, bits);
1380
1381 r = zd_usb_ioread16(usb, &bit_value_template, CR203);
1382 if (r) {
1383 dev_dbg_f(zd_usb_dev(usb),
1384 "error %d: Couldn't read CR203\n", r);
1385 goto out;
1386 }
1387 bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);
1388
1389 req_len = sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16);
1390 req = kmalloc(req_len, GFP_NOFS);
1391 if (!req)
1392 return -ENOMEM;
1393
1394 req->id = cpu_to_le16(USB_REQ_WRITE_RF);
1395 /* 1: 3683a, but not used in ZYDAS driver */
1396 req->value = cpu_to_le16(2);
1397 req->bits = cpu_to_le16(bits);
1398
1399 for (i = 0; i < bits; i++) {
1400 u16 bv = bit_value_template;
1401 if (value & (1 << (bits-1-i)))
1402 bv |= RF_DATA;
1403 req->bit_values[i] = cpu_to_le16(bv);
1404 }
1405
1406 udev = zd_usb_to_usbdev(usb);
1407 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1408 req, req_len, &actual_req_len, 1000 /* ms */);
1409 if (r) {
1410 dev_dbg_f(zd_usb_dev(usb),
1411 "error in usb_bulk_msg(). Error number %d\n", r);
1412 goto out;
1413 }
1414 if (req_len != actual_req_len) {
1415 dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()"
1416 " req_len %d != actual_req_len %d\n",
1417 req_len, actual_req_len);
1418 r = -EIO;
1419 goto out;
1420 }
1421
1422 /* FALL-THROUGH with r == 0 */
1423 out:
1424 kfree(req);
1425 return r;
1426 }
Linux kernel - Deliverables
This page took 0.073633 seconds and 5 git commands to generate.