forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-02-19 1c055e55a242a33e574e48be530e06770a210dcd 
 kernel/drivers/usb/misc/legousbtower.c
....@@ -157,19 +157,19 @@
157157 #define LEGO_USB_TOWER_REQUEST_GET_VERSION	0xFD
158158 
159159 struct tower_reset_reply {
160
-	__le16 size;		/* little-endian */
160
+	__le16 size;
161161 	__u8 err_code;
162162 	__u8 spare;
163
-} __attribute__ ((packed));
163
+};
164164 
165165 struct tower_get_version_reply {
166
-	__le16 size;		/* little-endian */
166
+	__le16 size;
167167 	__u8 err_code;
168168 	__u8 spare;
169169 	__u8 major;
170170 	__u8 minor;
171
-	__le16 build_no;		/* little-endian */
172
-} __attribute__ ((packed));
171
+	__le16 build_no;
172
+};
173173 
174174 
175175 /* table of devices that work with this driver */
....@@ -178,7 +178,7 @@
178178 	{ }					/* Terminating entry */
179179 };
180180 
181
-MODULE_DEVICE_TABLE (usb, tower_table);
181
+MODULE_DEVICE_TABLE(usb, tower_table);
182182 
183183 #define LEGO_USB_TOWER_MINOR_BASE	160
184184 
....@@ -186,13 +186,13 @@
186186 /* Structure to hold all of our device specific stuff */
187187 struct lego_usb_tower {
188188 	struct mutex		lock;		/* locks this structure */
189
-	struct usb_device*	udev;		/* save off the usb device pointer */
189
+	struct usb_device	*udev;		/* save off the usb device pointer */
190190 	unsigned char		minor;		/* the starting minor number for this device */
191191 
192192 	int			open_count;	/* number of times this port has been opened */
193193 	unsigned long		disconnected:1;
194194 
195
-	char*			read_buffer;
195
+	char			*read_buffer;
196196 	size_t			read_buffer_length; /* this much came in */
197197 	size_t			read_packet_length; /* this much will be returned on read */
198198 	spinlock_t		read_buffer_lock;
....@@ -202,16 +202,15 @@
202202 	wait_queue_head_t	read_wait;
203203 	wait_queue_head_t	write_wait;
204204 
205
-	char*			interrupt_in_buffer;
206
-	struct usb_endpoint_descriptor* interrupt_in_endpoint;
207
-	struct urb*		interrupt_in_urb;
205
+	char			*interrupt_in_buffer;
206
+	struct usb_endpoint_descriptor *interrupt_in_endpoint;
207
+	struct urb		*interrupt_in_urb;
208208 	int			interrupt_in_interval;
209
-	int			interrupt_in_running;
210209 	int			interrupt_in_done;
211210 
212
-	char*			interrupt_out_buffer;
213
-	struct usb_endpoint_descriptor* interrupt_out_endpoint;
214
-	struct urb*		interrupt_out_urb;
211
+	char			*interrupt_out_buffer;
212
+	struct usb_endpoint_descriptor *interrupt_out_endpoint;
213
+	struct urb		*interrupt_out_urb;
215214 	int			interrupt_out_interval;
216215 	int			interrupt_out_busy;
217216 
....@@ -219,21 +218,20 @@
219218 
220219 
221220 /* local function prototypes */
222
-static ssize_t tower_read	(struct file *file, char __user *buffer, size_t count, loff_t *ppos);
223
-static ssize_t tower_write	(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
224
-static inline void tower_delete (struct lego_usb_tower *dev);
225
-static int tower_open		(struct inode *inode, struct file *file);
226
-static int tower_release	(struct inode *inode, struct file *file);
227
-static __poll_t tower_poll	(struct file *file, poll_table *wait);
228
-static loff_t tower_llseek	(struct file *file, loff_t off, int whence);
221
+static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos);
222
+static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
223
+static inline void tower_delete(struct lego_usb_tower *dev);
224
+static int tower_open(struct inode *inode, struct file *file);
225
+static int tower_release(struct inode *inode, struct file *file);
226
+static __poll_t tower_poll(struct file *file, poll_table *wait);
227
+static loff_t tower_llseek(struct file *file, loff_t off, int whence);
229228 
230
-static void tower_abort_transfers (struct lego_usb_tower *dev);
231
-static void tower_check_for_read_packet (struct lego_usb_tower *dev);
232
-static void tower_interrupt_in_callback (struct urb *urb);
233
-static void tower_interrupt_out_callback (struct urb *urb);
229
+static void tower_check_for_read_packet(struct lego_usb_tower *dev);
230
+static void tower_interrupt_in_callback(struct urb *urb);
231
+static void tower_interrupt_out_callback(struct urb *urb);
234232 
235
-static int  tower_probe	(struct usb_interface *interface, const struct usb_device_id *id);
236
-static void tower_disconnect	(struct usb_interface *interface);
233
+static int  tower_probe(struct usb_interface *interface, const struct usb_device_id *id);
234
+static void tower_disconnect(struct usb_interface *interface);
237235 
238236 
239237 /* file operations needed when we register this driver */
....@@ -273,7 +271,7 @@
273271 };
274272 
275273 
276
-/**
274
+/*
277275  *	lego_usb_tower_debug_data
278276  */
279277 static inline void lego_usb_tower_debug_data(struct device *dev,
....@@ -285,46 +283,38 @@
285283 }
286284 
287285 
288
-/**
286
+/*
289287  *	tower_delete
290288  */
291
-static inline void tower_delete (struct lego_usb_tower *dev)
289
+static inline void tower_delete(struct lego_usb_tower *dev)
292290 {
293291 	/* free data structures */
294292 	usb_free_urb(dev->interrupt_in_urb);
295293 	usb_free_urb(dev->interrupt_out_urb);
296
-	kfree (dev->read_buffer);
297
-	kfree (dev->interrupt_in_buffer);
298
-	kfree (dev->interrupt_out_buffer);
294
+	kfree(dev->read_buffer);
295
+	kfree(dev->interrupt_in_buffer);
296
+	kfree(dev->interrupt_out_buffer);
299297 	usb_put_dev(dev->udev);
300
-	kfree (dev);
298
+	kfree(dev);
301299 }
302300 
303301 
304
-/**
302
+/*
305303  *	tower_open
306304  */
307
-static int tower_open (struct inode *inode, struct file *file)
305
+static int tower_open(struct inode *inode, struct file *file)
308306 {
309307 	struct lego_usb_tower *dev = NULL;
310308 	int subminor;
311309 	int retval = 0;
312310 	struct usb_interface *interface;
313
-	struct tower_reset_reply *reset_reply;
311
+	struct tower_reset_reply reset_reply;
314312 	int result;
315
-
316
-	reset_reply = kmalloc(sizeof(*reset_reply), GFP_KERNEL);
317
-
318
-	if (!reset_reply) {
319
-		retval = -ENOMEM;
320
-		goto exit;
321
-	}
322313 
323314 	nonseekable_open(inode, file);
324315 	subminor = iminor(inode);
325316 
326
-	interface = usb_find_interface (&tower_driver, subminor);
327
-
317
+	interface = usb_find_interface(&tower_driver, subminor);
328318 	if (!interface) {
329319 		pr_err("error, can't find device for minor %d\n", subminor);
330320 		retval = -ENODEV;
....@@ -351,15 +341,12 @@
351341 	}
352342 
353343 	/* reset the tower */
354
-	result = usb_control_msg (dev->udev,
355
-				  usb_rcvctrlpipe(dev->udev, 0),
356
-				  LEGO_USB_TOWER_REQUEST_RESET,
357
-				  USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
358
-				  0,
359
-				  0,
360
-				  reset_reply,
361
-				  sizeof(*reset_reply),
362
-				  1000);
344
+	result = usb_control_msg_recv(dev->udev, 0,
345
+				      LEGO_USB_TOWER_REQUEST_RESET,
346
+				      USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
347
+				      0, 0,
348
+				      &reset_reply, sizeof(reset_reply), 1000,
349
+				      GFP_KERNEL);
363350 	if (result < 0) {
364351 		dev_err(&dev->udev->dev,
365352 			"LEGO USB Tower reset control request failed\n");
....@@ -370,24 +357,22 @@
370357 	/* initialize in direction */
371358 	dev->read_buffer_length = 0;
372359 	dev->read_packet_length = 0;
373
-	usb_fill_int_urb (dev->interrupt_in_urb,
374
-			  dev->udev,
375
-			  usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
376
-			  dev->interrupt_in_buffer,
377
-			  usb_endpoint_maxp(dev->interrupt_in_endpoint),
378
-			  tower_interrupt_in_callback,
379
-			  dev,
380
-			  dev->interrupt_in_interval);
360
+	usb_fill_int_urb(dev->interrupt_in_urb,
361
+			 dev->udev,
362
+			 usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
363
+			 dev->interrupt_in_buffer,
364
+			 usb_endpoint_maxp(dev->interrupt_in_endpoint),
365
+			 tower_interrupt_in_callback,
366
+			 dev,
367
+			 dev->interrupt_in_interval);
381368 
382
-	dev->interrupt_in_running = 1;
383369 	dev->interrupt_in_done = 0;
384370 	mb();
385371 
386
-	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);
372
+	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
387373 	if (retval) {
388374 		dev_err(&dev->udev->dev,
389375 			"Couldn't submit interrupt_in_urb %d\n", retval);
390
-		dev->interrupt_in_running = 0;
391376 		goto unlock_exit;
392377 	}
393378 
....@@ -400,20 +385,18 @@
400385 	mutex_unlock(&dev->lock);
401386 
402387 exit:
403
-	kfree(reset_reply);
404388 	return retval;
405389 }
406390 
407
-/**
391
+/*
408392  *	tower_release
409393  */
410
-static int tower_release (struct inode *inode, struct file *file)
394
+static int tower_release(struct inode *inode, struct file *file)
411395 {
412396 	struct lego_usb_tower *dev;
413397 	int retval = 0;
414398 
415399 	dev = file->private_data;
416
-
417400 	if (dev == NULL) {
418401 		retval = -ENODEV;
419402 		goto exit;
....@@ -421,57 +404,33 @@
421404 
422405 	mutex_lock(&dev->lock);
423406 
424
-	if (dev->open_count != 1) {
425
-		dev_dbg(&dev->udev->dev, "%s: device not opened exactly once\n",
426
-			__func__);
427
-		retval = -ENODEV;
428
-		goto unlock_exit;
429
-	}
430
-
431407 	if (dev->disconnected) {
432408 		/* the device was unplugged before the file was released */
433409 
434410 		/* unlock here as tower_delete frees dev */
435411 		mutex_unlock(&dev->lock);
436
-		tower_delete (dev);
412
+		tower_delete(dev);
437413 		goto exit;
438414 	}
439415 
440416 	/* wait until write transfer is finished */
441417 	if (dev->interrupt_out_busy) {
442
-		wait_event_interruptible_timeout (dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);
418
+		wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy,
419
+						 2 * HZ);
443420 	}
444
-	tower_abort_transfers (dev);
421
+
422
+	/* shutdown transfers */
423
+	usb_kill_urb(dev->interrupt_in_urb);
424
+	usb_kill_urb(dev->interrupt_out_urb);
425
+
445426 	dev->open_count = 0;
446427 
447
-unlock_exit:
448428 	mutex_unlock(&dev->lock);
449429 exit:
450430 	return retval;
451431 }
452432 
453
-
454
-/**
455
- *	tower_abort_transfers
456
- *      aborts transfers and frees associated data structures
457
- */
458
-static void tower_abort_transfers (struct lego_usb_tower *dev)
459
-{
460
-	if (dev == NULL)
461
-		return;
462
-
463
-	/* shutdown transfer */
464
-	if (dev->interrupt_in_running) {
465
-		dev->interrupt_in_running = 0;
466
-		mb();
467
-		usb_kill_urb(dev->interrupt_in_urb);
468
-	}
469
-	if (dev->interrupt_out_busy)
470
-		usb_kill_urb(dev->interrupt_out_urb);
471
-}
472
-
473
-
474
-/**
433
+/*
475434  *	tower_check_for_read_packet
476435  *
477436  *      To get correct semantics for signals and non-blocking I/O
....@@ -479,23 +438,23 @@
479438  *      until it has been there unchanged for at least
480439  *      dev->packet_timeout_jiffies, or until the buffer is full.
481440  */
482
-static void tower_check_for_read_packet (struct lego_usb_tower *dev)
441
+static void tower_check_for_read_packet(struct lego_usb_tower *dev)
483442 {
484
-	spin_lock_irq (&dev->read_buffer_lock);
443
+	spin_lock_irq(&dev->read_buffer_lock);
485444 	if (!packet_timeout
486445 	    || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)
487446 	    || dev->read_buffer_length == read_buffer_size) {
488447 		dev->read_packet_length = dev->read_buffer_length;
489448 	}
490449 	dev->interrupt_in_done = 0;
491
-	spin_unlock_irq (&dev->read_buffer_lock);
450
+	spin_unlock_irq(&dev->read_buffer_lock);
492451 }
493452 
494453 
495
-/**
454
+/*
496455  *	tower_poll
497456  */
498
-static __poll_t tower_poll (struct file *file, poll_table *wait)
457
+static __poll_t tower_poll(struct file *file, poll_table *wait)
499458 {
500459 	struct lego_usb_tower *dev;
501460 	__poll_t mask = 0;
....@@ -509,30 +468,28 @@
509468 	poll_wait(file, &dev->write_wait, wait);
510469 
511470 	tower_check_for_read_packet(dev);
512
-	if (dev->read_packet_length > 0) {
471
+	if (dev->read_packet_length > 0)
513472 		mask |= EPOLLIN | EPOLLRDNORM;
514
-	}
515
-	if (!dev->interrupt_out_busy) {
473
+	if (!dev->interrupt_out_busy)
516474 		mask |= EPOLLOUT | EPOLLWRNORM;
517
-	}
518475 
519476 	return mask;
520477 }
521478 
522479 
523
-/**
480
+/*
524481  *	tower_llseek
525482  */
526
-static loff_t tower_llseek (struct file *file, loff_t off, int whence)
483
+static loff_t tower_llseek(struct file *file, loff_t off, int whence)
527484 {
528485 	return -ESPIPE;		/* unseekable */
529486 }
530487 
531488 
532
-/**
489
+/*
533490  *	tower_read
534491  */
535
-static ssize_t tower_read (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
492
+static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
536493 {
537494 	struct lego_usb_tower *dev;
538495 	size_t bytes_to_read;
....@@ -551,7 +508,6 @@
551508 	/* verify that the device wasn't unplugged */
552509 	if (dev->disconnected) {
553510 		retval = -ENODEV;
554
-		pr_err("No device or device unplugged %d\n", retval);
555511 		goto unlock_exit;
556512 	}
557513 
....@@ -561,21 +517,19 @@
561517 		goto unlock_exit;
562518 	}
563519 
564
-	if (read_timeout) {
520
+	if (read_timeout)
565521 		timeout = jiffies + msecs_to_jiffies(read_timeout);
566
-	}
567522 
568523 	/* wait for data */
569
-	tower_check_for_read_packet (dev);
524
+	tower_check_for_read_packet(dev);
570525 	while (dev->read_packet_length == 0) {
571526 		if (file->f_flags & O_NONBLOCK) {
572527 			retval = -EAGAIN;
573528 			goto unlock_exit;
574529 		}
575530 		retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
576
-		if (retval < 0) {
531
+		if (retval < 0)
577532 			goto unlock_exit;
578
-		}
579533 
580534 		/* reset read timeout during read or write activity */
581535 		if (read_timeout
....@@ -583,28 +537,27 @@
583537 			timeout = jiffies + msecs_to_jiffies(read_timeout);
584538 		}
585539 		/* check for read timeout */
586
-		if (read_timeout && time_after (jiffies, timeout)) {
540
+		if (read_timeout && time_after(jiffies, timeout)) {
587541 			retval = -ETIMEDOUT;
588542 			goto unlock_exit;
589543 		}
590
-		tower_check_for_read_packet (dev);
544
+		tower_check_for_read_packet(dev);
591545 	}
592546 
593547 	/* copy the data from read_buffer into userspace */
594548 	bytes_to_read = min(count, dev->read_packet_length);
595549 
596
-	if (copy_to_user (buffer, dev->read_buffer, bytes_to_read)) {
550
+	if (copy_to_user(buffer, dev->read_buffer, bytes_to_read)) {
597551 		retval = -EFAULT;
598552 		goto unlock_exit;
599553 	}
600554 
601
-	spin_lock_irq (&dev->read_buffer_lock);
555
+	spin_lock_irq(&dev->read_buffer_lock);
602556 	dev->read_buffer_length -= bytes_to_read;
603557 	dev->read_packet_length -= bytes_to_read;
604
-	for (i=0; i<dev->read_buffer_length; i++) {
558
+	for (i = 0; i < dev->read_buffer_length; i++)
605559 		dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
606
-	}
607
-	spin_unlock_irq (&dev->read_buffer_lock);
560
+	spin_unlock_irq(&dev->read_buffer_lock);
608561 
609562 	retval = bytes_to_read;
610563 
....@@ -617,10 +570,10 @@
617570 }
618571 
619572 
620
-/**
573
+/*
621574  *	tower_write
622575  */
623
-static ssize_t tower_write (struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
576
+static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
624577 {
625578 	struct lego_usb_tower *dev;
626579 	size_t bytes_to_write;
....@@ -637,7 +590,6 @@
637590 	/* verify that the device wasn't unplugged */
638591 	if (dev->disconnected) {
639592 		retval = -ENODEV;
640
-		pr_err("No device or device unplugged %d\n", retval);
641593 		goto unlock_exit;
642594 	}
643595 
....@@ -653,10 +605,10 @@
653605 			retval = -EAGAIN;
654606 			goto unlock_exit;
655607 		}
656
-		retval = wait_event_interruptible (dev->write_wait, !dev->interrupt_out_busy);
657
-		if (retval) {
608
+		retval = wait_event_interruptible(dev->write_wait,
609
+						  !dev->interrupt_out_busy);
610
+		if (retval)
658611 			goto unlock_exit;
659
-		}
660612 	}
661613 
662614 	/* write the data into interrupt_out_buffer from userspace */
....@@ -664,7 +616,7 @@
664616 	dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n",
665617 		__func__, count, bytes_to_write);
666618 
667
-	if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
619
+	if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
668620 		retval = -EFAULT;
669621 		goto unlock_exit;
670622 	}
....@@ -682,7 +634,7 @@
682634 	dev->interrupt_out_busy = 1;
683635 	wmb();
684636 
685
-	retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
637
+	retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
686638 	if (retval) {
687639 		dev->interrupt_out_busy = 0;
688640 		dev_err(&dev->udev->dev,
....@@ -700,10 +652,10 @@
700652 }
701653 
702654 
703
-/**
655
+/*
704656  *	tower_interrupt_in_callback
705657  */
706
-static void tower_interrupt_in_callback (struct urb *urb)
658
+static void tower_interrupt_in_callback(struct urb *urb)
707659 {
708660 	struct lego_usb_tower *dev = urb->context;
709661 	int status = urb->status;
....@@ -729,9 +681,9 @@
729681 	if (urb->actual_length > 0) {
730682 		spin_lock_irqsave(&dev->read_buffer_lock, flags);
731683 		if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {
732
-			memcpy (dev->read_buffer + dev->read_buffer_length,
733
-				dev->interrupt_in_buffer,
734
-				urb->actual_length);
684
+			memcpy(dev->read_buffer + dev->read_buffer_length,
685
+			       dev->interrupt_in_buffer,
686
+			       urb->actual_length);
735687 			dev->read_buffer_length += urb->actual_length;
736688 			dev->read_last_arrival = jiffies;
737689 			dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",
....@@ -744,25 +696,21 @@
744696 	}
745697 
746698 resubmit:
747
-	/* resubmit if we're still running */
748
-	if (dev->interrupt_in_running) {
749
-		retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
750
-		if (retval)
751
-			dev_err(&dev->udev->dev,
752
-				"%s: usb_submit_urb failed (%d)\n",
753
-				__func__, retval);
699
+	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
700
+	if (retval) {
701
+		dev_err(&dev->udev->dev, "%s: usb_submit_urb failed (%d)\n",
702
+			__func__, retval);
754703 	}
755
-
756704 exit:
757705 	dev->interrupt_in_done = 1;
758
-	wake_up_interruptible (&dev->read_wait);
706
+	wake_up_interruptible(&dev->read_wait);
759707 }
760708 
761709 
762
-/**
710
+/*
763711  *	tower_interrupt_out_callback
764712  */
765
-static void tower_interrupt_out_callback (struct urb *urb)
713
+static void tower_interrupt_out_callback(struct urb *urb)
766714 {
767715 	struct lego_usb_tower *dev = urb->context;
768716 	int status = urb->status;
....@@ -784,54 +732,33 @@
784732 }
785733 
786734 
787
-/**
735
+/*
788736  *	tower_probe
789737  *
790738  *	Called by the usb core when a new device is connected that it thinks
791739  *	this driver might be interested in.
792740  */
793
-static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id)
741
+static int tower_probe(struct usb_interface *interface, const struct usb_device_id *id)
794742 {
795743 	struct device *idev = &interface->dev;
796744 	struct usb_device *udev = interface_to_usbdev(interface);
797
-	struct lego_usb_tower *dev = NULL;
798
-	struct tower_get_version_reply *get_version_reply = NULL;
745
+	struct lego_usb_tower *dev;
746
+	struct tower_get_version_reply get_version_reply;
799747 	int retval = -ENOMEM;
800748 	int result;
801749 
802750 	/* allocate memory for our device state and initialize it */
803
-
804
-	dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
805
-
751
+	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
806752 	if (!dev)
807753 		goto exit;
808754 
809755 	mutex_init(&dev->lock);
810
-
811756 	dev->udev = usb_get_dev(udev);
812
-	dev->open_count = 0;
813
-	dev->disconnected = 0;
814
-
815
-	dev->read_buffer = NULL;
816
-	dev->read_buffer_length = 0;
817
-	dev->read_packet_length = 0;
818
-	spin_lock_init (&dev->read_buffer_lock);
757
+	spin_lock_init(&dev->read_buffer_lock);
819758 	dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);
820759 	dev->read_last_arrival = jiffies;
821
-
822
-	init_waitqueue_head (&dev->read_wait);
823
-	init_waitqueue_head (&dev->write_wait);
824
-
825
-	dev->interrupt_in_buffer = NULL;
826
-	dev->interrupt_in_endpoint = NULL;
827
-	dev->interrupt_in_urb = NULL;
828
-	dev->interrupt_in_running = 0;
829
-	dev->interrupt_in_done = 0;
830
-
831
-	dev->interrupt_out_buffer = NULL;
832
-	dev->interrupt_out_endpoint = NULL;
833
-	dev->interrupt_out_urb = NULL;
834
-	dev->interrupt_out_busy = 0;
760
+	init_waitqueue_head(&dev->read_wait);
761
+	init_waitqueue_head(&dev->write_wait);
835762 
836763 	result = usb_find_common_endpoints_reverse(interface->cur_altsetting,
837764 			NULL, NULL,
....@@ -843,16 +770,16 @@
843770 		goto error;
844771 	}
845772 
846
-	dev->read_buffer = kmalloc (read_buffer_size, GFP_KERNEL);
773
+	dev->read_buffer = kmalloc(read_buffer_size, GFP_KERNEL);
847774 	if (!dev->read_buffer)
848775 		goto error;
849
-	dev->interrupt_in_buffer = kmalloc (usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
776
+	dev->interrupt_in_buffer = kmalloc(usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
850777 	if (!dev->interrupt_in_buffer)
851778 		goto error;
852779 	dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
853780 	if (!dev->interrupt_in_urb)
854781 		goto error;
855
-	dev->interrupt_out_buffer = kmalloc (write_buffer_size, GFP_KERNEL);
782
+	dev->interrupt_out_buffer = kmalloc(write_buffer_size, GFP_KERNEL);
856783 	if (!dev->interrupt_out_buffer)
857784 		goto error;
858785 	dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
....@@ -861,41 +788,30 @@
861788 	dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
862789 	dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
863790 
864
-	get_version_reply = kmalloc(sizeof(*get_version_reply), GFP_KERNEL);
865
-
866
-	if (!get_version_reply) {
867
-		retval = -ENOMEM;
868
-		goto error;
869
-	}
870
-
871791 	/* get the firmware version and log it */
872
-	result = usb_control_msg (udev,
873
-				  usb_rcvctrlpipe(udev, 0),
874
-				  LEGO_USB_TOWER_REQUEST_GET_VERSION,
875
-				  USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
876
-				  0,
877
-				  0,
878
-				  get_version_reply,
879
-				  sizeof(*get_version_reply),
880
-				  1000);
881
-	if (result != sizeof(*get_version_reply)) {
882
-		if (result >= 0)
883
-			result = -EIO;
792
+	result = usb_control_msg_recv(udev, 0,
793
+				      LEGO_USB_TOWER_REQUEST_GET_VERSION,
794
+				      USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
795
+				      0,
796
+				      0,
797
+				      &get_version_reply,
798
+				      sizeof(get_version_reply),
799
+				      1000, GFP_KERNEL);
800
+	if (result) {
884801 		dev_err(idev, "get version request failed: %d\n", result);
885802 		retval = result;
886803 		goto error;
887804 	}
888805 	dev_info(&interface->dev,
889806 		 "LEGO USB Tower firmware version is %d.%d build %d\n",
890
-		 get_version_reply->major,
891
-		 get_version_reply->minor,
892
-		 le16_to_cpu(get_version_reply->build_no));
807
+		 get_version_reply.major,
808
+		 get_version_reply.minor,
809
+		 le16_to_cpu(get_version_reply.build_no));
893810 
894811 	/* we can register the device now, as it is ready */
895
-	usb_set_intfdata (interface, dev);
812
+	usb_set_intfdata(interface, dev);
896813 
897
-	retval = usb_register_dev (interface, &tower_class);
898
-
814
+	retval = usb_register_dev(interface, &tower_class);
899815 	if (retval) {
900816 		/* something prevented us from registering this driver */
901817 		dev_err(idev, "Not able to get a minor for this device.\n");
....@@ -909,32 +825,30 @@
909825 		 USB_MAJOR, dev->minor);
910826 
911827 exit:
912
-	kfree(get_version_reply);
913828 	return retval;
914829 
915830 error:
916
-	kfree(get_version_reply);
917831 	tower_delete(dev);
918832 	return retval;
919833 }
920834 
921835 
922
-/**
836
+/*
923837  *	tower_disconnect
924838  *
925839  *	Called by the usb core when the device is removed from the system.
926840  */
927
-static void tower_disconnect (struct usb_interface *interface)
841
+static void tower_disconnect(struct usb_interface *interface)
928842 {
929843 	struct lego_usb_tower *dev;
930844 	int minor;
931845 
932
-	dev = usb_get_intfdata (interface);
846
+	dev = usb_get_intfdata(interface);
933847 
934848 	minor = dev->minor;
935849 
936850 	/* give back our minor and prevent further open() */
937
-	usb_deregister_dev (interface, &tower_class);
851
+	usb_deregister_dev(interface, &tower_class);
938852 
939853 	/* stop I/O */
940854 	usb_poison_urb(dev->interrupt_in_urb);
....@@ -945,7 +859,7 @@
945859 	/* if the device is not opened, then we clean up right now */
946860 	if (!dev->open_count) {
947861 		mutex_unlock(&dev->lock);
948
-		tower_delete (dev);
862
+		tower_delete(dev);
949863 	} else {
950864 		dev->disconnected = 1;
951865 		/* wake up pollers */
....@@ -962,6 +876,4 @@
962876 
963877 MODULE_AUTHOR(DRIVER_AUTHOR);
964878 MODULE_DESCRIPTION(DRIVER_DESC);
965
-#ifdef MODULE_LICENSE
966879 MODULE_LICENSE("GPL");
967
-#endif