aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/misc
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2008-04-25 15:40:57 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2008-04-25 15:40:57 -0400
commit37b05b17985ecc43a33e2a8cbdaa220115de4703 (patch)
tree8213bf790182711677018ed322a9ccf61470242e /drivers/usb/misc
parentce1d5b23a8d1e19866ab82bdec0dc41fde5273d8 (diff)
parent4953d141dc5db748475001cfbfdcc42e66cf900e (diff)
Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (120 commits) usb: don't update devnum for wusb devices wusb: make ep0_reinit available for modules wusb: devices dont use a set address wusb: teach choose_address() about wireless devices wusb: add link wusb-usb device wusb: add authenticathed bit to usb_dev USB: remove unnecessary type casting of urb->context usb serial: more fixes and groundwork for tty changes USB: replace remaining __FUNCTION__ occurrences USB: usbfs: export the URB_NO_INTERRUPT flag to userspace USB: fix compile problems in ehci-hcd USB: ehci: qh_completions cleanup and bugfix USB: cdc-acm: signedness fix USB: add documentation about callbacks USB: don't explicitly reenable root-hub status interrupts USB: OHCI: turn off RD when remote wakeup is disabled USB: HCDs use the do_remote_wakeup flag USB: g_file_storage: ignore bulk-out data after invalid CBW USB: serial: remove endpoints setting checks from core and header USB: serial: remove unneeded number endpoints settings ...
Diffstat (limited to 'drivers/usb/misc')
-rw-r--r--drivers/usb/misc/Kconfig20
-rw-r--r--drivers/usb/misc/adutux.c120
-rw-r--r--drivers/usb/misc/appledisplay.c6
-rw-r--r--drivers/usb/misc/auerswald.c135
-rw-r--r--drivers/usb/misc/emi26.c30
-rw-r--r--drivers/usb/misc/emi62.c32
-rw-r--r--drivers/usb/misc/ftdi-elan.c2
-rw-r--r--drivers/usb/misc/iowarrior.c10
-rw-r--r--drivers/usb/misc/ldusb.c10
-rw-r--r--drivers/usb/misc/legousbtower.c92
-rw-r--r--drivers/usb/misc/phidgetkit.c6
-rw-r--r--drivers/usb/misc/phidgetmotorcontrol.c2
-rw-r--r--drivers/usb/misc/phidgetservo.c6
-rw-r--r--drivers/usb/misc/usblcd.c8
-rw-r--r--drivers/usb/misc/usbtest.c13
15 files changed, 248 insertions, 244 deletions
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index 9c7eb6144d02..a53db1d4e07a 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -33,8 +33,8 @@ config USB_EMI26
33 module will be called emi26. 33 module will be called emi26.
34 34
35config USB_ADUTUX 35config USB_ADUTUX
36 tristate "ADU devices from Ontrak Control Systems (EXPERIMENTAL)" 36 tristate "ADU devices from Ontrak Control Systems"
37 depends on USB && EXPERIMENTAL 37 depends on USB
38 help 38 help
39 Say Y if you want to use an ADU device from Ontrak Control 39 Say Y if you want to use an ADU device from Ontrak Control
40 Systems. 40 Systems.
@@ -43,8 +43,8 @@ config USB_ADUTUX
43 will be called adutux. 43 will be called adutux.
44 44
45config USB_AUERSWALD 45config USB_AUERSWALD
46 tristate "USB Auerswald ISDN support (EXPERIMENTAL)" 46 tristate "USB Auerswald ISDN support"
47 depends on USB && EXPERIMENTAL 47 depends on USB
48 help 48 help
49 Say Y here if you want to connect an Auerswald USB ISDN Device 49 Say Y here if you want to connect an Auerswald USB ISDN Device
50 to your computer's USB port. 50 to your computer's USB port.
@@ -53,8 +53,8 @@ config USB_AUERSWALD
53 module will be called auerswald. 53 module will be called auerswald.
54 54
55config USB_RIO500 55config USB_RIO500
56 tristate "USB Diamond Rio500 support (EXPERIMENTAL)" 56 tristate "USB Diamond Rio500 support"
57 depends on USB && EXPERIMENTAL 57 depends on USB
58 help 58 help
59 Say Y here if you want to connect a USB Rio500 mp3 player to your 59 Say Y here if you want to connect a USB Rio500 mp3 player to your
60 computer's USB port. Please read <file:Documentation/usb/rio.txt> 60 computer's USB port. Please read <file:Documentation/usb/rio.txt>
@@ -64,8 +64,8 @@ config USB_RIO500
64 module will be called rio500. 64 module will be called rio500.
65 65
66config USB_LEGOTOWER 66config USB_LEGOTOWER
67 tristate "USB Lego Infrared Tower support (EXPERIMENTAL)" 67 tristate "USB Lego Infrared Tower support"
68 depends on USB && EXPERIMENTAL 68 depends on USB
69 help 69 help
70 Say Y here if you want to connect a USB Lego Infrared Tower to your 70 Say Y here if you want to connect a USB Lego Infrared Tower to your
71 computer's USB port. 71 computer's USB port.
@@ -259,8 +259,8 @@ config USB_IOWARRIOR
259 module will be called iowarrior. 259 module will be called iowarrior.
260 260
261config USB_TEST 261config USB_TEST
262 tristate "USB testing driver (DEVELOPMENT)" 262 tristate "USB testing driver"
263 depends on USB && USB_DEVICEFS && EXPERIMENTAL 263 depends on USB && USB_DEVICEFS
264 help 264 help
265 This driver is for testing host controller software. It is used 265 This driver is for testing host controller software. It is used
266 with specialized device firmware for regression and stress testing, 266 with specialized device firmware for regression and stress testing,
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index 5a2c44e4c1f7..965f6eaea6a0 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -147,10 +147,10 @@ static void adu_abort_transfers(struct adu_device *dev)
147{ 147{
148 unsigned long flags; 148 unsigned long flags;
149 149
150 dbg(2," %s : enter", __FUNCTION__); 150 dbg(2," %s : enter", __func__);
151 151
152 if (dev->udev == NULL) { 152 if (dev->udev == NULL) {
153 dbg(1," %s : udev is null", __FUNCTION__); 153 dbg(1," %s : udev is null", __func__);
154 goto exit; 154 goto exit;
155 } 155 }
156 156
@@ -172,12 +172,12 @@ static void adu_abort_transfers(struct adu_device *dev)
172 spin_unlock_irqrestore(&dev->buflock, flags); 172 spin_unlock_irqrestore(&dev->buflock, flags);
173 173
174exit: 174exit:
175 dbg(2," %s : leave", __FUNCTION__); 175 dbg(2," %s : leave", __func__);
176} 176}
177 177
178static void adu_delete(struct adu_device *dev) 178static void adu_delete(struct adu_device *dev)
179{ 179{
180 dbg(2, "%s enter", __FUNCTION__); 180 dbg(2, "%s enter", __func__);
181 181
182 /* free data structures */ 182 /* free data structures */
183 usb_free_urb(dev->interrupt_in_urb); 183 usb_free_urb(dev->interrupt_in_urb);
@@ -188,7 +188,7 @@ static void adu_delete(struct adu_device *dev)
188 kfree(dev->interrupt_out_buffer); 188 kfree(dev->interrupt_out_buffer);
189 kfree(dev); 189 kfree(dev);
190 190
191 dbg(2, "%s : leave", __FUNCTION__); 191 dbg(2, "%s : leave", __func__);
192} 192}
193 193
194static void adu_interrupt_in_callback(struct urb *urb) 194static void adu_interrupt_in_callback(struct urb *urb)
@@ -196,8 +196,8 @@ static void adu_interrupt_in_callback(struct urb *urb)
196 struct adu_device *dev = urb->context; 196 struct adu_device *dev = urb->context;
197 int status = urb->status; 197 int status = urb->status;
198 198
199 dbg(4," %s : enter, status %d", __FUNCTION__, status); 199 dbg(4," %s : enter, status %d", __func__, status);
200 adu_debug_data(5, __FUNCTION__, urb->actual_length, 200 adu_debug_data(5, __func__, urb->actual_length,
201 urb->transfer_buffer); 201 urb->transfer_buffer);
202 202
203 spin_lock(&dev->buflock); 203 spin_lock(&dev->buflock);
@@ -206,7 +206,7 @@ static void adu_interrupt_in_callback(struct urb *urb)
206 if ((status != -ENOENT) && (status != -ECONNRESET) && 206 if ((status != -ENOENT) && (status != -ECONNRESET) &&
207 (status != -ESHUTDOWN)) { 207 (status != -ESHUTDOWN)) {
208 dbg(1," %s : nonzero status received: %d", 208 dbg(1," %s : nonzero status received: %d",
209 __FUNCTION__, status); 209 __func__, status);
210 } 210 }
211 goto exit; 211 goto exit;
212 } 212 }
@@ -220,10 +220,10 @@ static void adu_interrupt_in_callback(struct urb *urb)
220 dev->interrupt_in_buffer, urb->actual_length); 220 dev->interrupt_in_buffer, urb->actual_length);
221 221
222 dev->read_buffer_length += urb->actual_length; 222 dev->read_buffer_length += urb->actual_length;
223 dbg(2," %s reading %d ", __FUNCTION__, 223 dbg(2," %s reading %d ", __func__,
224 urb->actual_length); 224 urb->actual_length);
225 } else { 225 } else {
226 dbg(1," %s : read_buffer overflow", __FUNCTION__); 226 dbg(1," %s : read_buffer overflow", __func__);
227 } 227 }
228 } 228 }
229 229
@@ -232,9 +232,9 @@ exit:
232 spin_unlock(&dev->buflock); 232 spin_unlock(&dev->buflock);
233 /* always wake up so we recover from errors */ 233 /* always wake up so we recover from errors */
234 wake_up_interruptible(&dev->read_wait); 234 wake_up_interruptible(&dev->read_wait);
235 adu_debug_data(5, __FUNCTION__, urb->actual_length, 235 adu_debug_data(5, __func__, urb->actual_length,
236 urb->transfer_buffer); 236 urb->transfer_buffer);
237 dbg(4," %s : leave, status %d", __FUNCTION__, status); 237 dbg(4," %s : leave, status %d", __func__, status);
238} 238}
239 239
240static void adu_interrupt_out_callback(struct urb *urb) 240static void adu_interrupt_out_callback(struct urb *urb)
@@ -242,14 +242,14 @@ static void adu_interrupt_out_callback(struct urb *urb)
242 struct adu_device *dev = urb->context; 242 struct adu_device *dev = urb->context;
243 int status = urb->status; 243 int status = urb->status;
244 244
245 dbg(4," %s : enter, status %d", __FUNCTION__, status); 245 dbg(4," %s : enter, status %d", __func__, status);
246 adu_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer); 246 adu_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
247 247
248 if (status != 0) { 248 if (status != 0) {
249 if ((status != -ENOENT) && 249 if ((status != -ENOENT) &&
250 (status != -ECONNRESET)) { 250 (status != -ECONNRESET)) {
251 dbg(1, " %s :nonzero status received: %d", 251 dbg(1, " %s :nonzero status received: %d",
252 __FUNCTION__, status); 252 __func__, status);
253 } 253 }
254 goto exit; 254 goto exit;
255 } 255 }
@@ -260,9 +260,9 @@ static void adu_interrupt_out_callback(struct urb *urb)
260 spin_unlock(&dev->buflock); 260 spin_unlock(&dev->buflock);
261exit: 261exit:
262 262
263 adu_debug_data(5, __FUNCTION__, urb->actual_length, 263 adu_debug_data(5, __func__, urb->actual_length,
264 urb->transfer_buffer); 264 urb->transfer_buffer);
265 dbg(4," %s : leave, status %d", __FUNCTION__, status); 265 dbg(4," %s : leave, status %d", __func__, status);
266} 266}
267 267
268static int adu_open(struct inode *inode, struct file *file) 268static int adu_open(struct inode *inode, struct file *file)
@@ -272,19 +272,19 @@ static int adu_open(struct inode *inode, struct file *file)
272 int subminor; 272 int subminor;
273 int retval; 273 int retval;
274 274
275 dbg(2,"%s : enter", __FUNCTION__); 275 dbg(2,"%s : enter", __func__);
276 276
277 subminor = iminor(inode); 277 subminor = iminor(inode);
278 278
279 if ((retval = mutex_lock_interruptible(&adutux_mutex))) { 279 if ((retval = mutex_lock_interruptible(&adutux_mutex))) {
280 dbg(2, "%s : mutex lock failed", __FUNCTION__); 280 dbg(2, "%s : mutex lock failed", __func__);
281 goto exit_no_lock; 281 goto exit_no_lock;
282 } 282 }
283 283
284 interface = usb_find_interface(&adu_driver, subminor); 284 interface = usb_find_interface(&adu_driver, subminor);
285 if (!interface) { 285 if (!interface) {
286 err("%s - error, can't find device for minor %d", 286 err("%s - error, can't find device for minor %d",
287 __FUNCTION__, subminor); 287 __func__, subminor);
288 retval = -ENODEV; 288 retval = -ENODEV;
289 goto exit_no_device; 289 goto exit_no_device;
290 } 290 }
@@ -302,7 +302,7 @@ static int adu_open(struct inode *inode, struct file *file)
302 } 302 }
303 303
304 ++dev->open_count; 304 ++dev->open_count;
305 dbg(2,"%s : open count %d", __FUNCTION__, dev->open_count); 305 dbg(2,"%s : open count %d", __func__, dev->open_count);
306 306
307 /* save device in the file's private structure */ 307 /* save device in the file's private structure */
308 file->private_data = dev; 308 file->private_data = dev;
@@ -332,23 +332,23 @@ static int adu_open(struct inode *inode, struct file *file)
332exit_no_device: 332exit_no_device:
333 mutex_unlock(&adutux_mutex); 333 mutex_unlock(&adutux_mutex);
334exit_no_lock: 334exit_no_lock:
335 dbg(2,"%s : leave, return value %d ", __FUNCTION__, retval); 335 dbg(2,"%s : leave, return value %d ", __func__, retval);
336 return retval; 336 return retval;
337} 337}
338 338
339static void adu_release_internal(struct adu_device *dev) 339static void adu_release_internal(struct adu_device *dev)
340{ 340{
341 dbg(2," %s : enter", __FUNCTION__); 341 dbg(2," %s : enter", __func__);
342 342
343 /* decrement our usage count for the device */ 343 /* decrement our usage count for the device */
344 --dev->open_count; 344 --dev->open_count;
345 dbg(2," %s : open count %d", __FUNCTION__, dev->open_count); 345 dbg(2," %s : open count %d", __func__, dev->open_count);
346 if (dev->open_count <= 0) { 346 if (dev->open_count <= 0) {
347 adu_abort_transfers(dev); 347 adu_abort_transfers(dev);
348 dev->open_count = 0; 348 dev->open_count = 0;
349 } 349 }
350 350
351 dbg(2," %s : leave", __FUNCTION__); 351 dbg(2," %s : leave", __func__);
352} 352}
353 353
354static int adu_release(struct inode *inode, struct file *file) 354static int adu_release(struct inode *inode, struct file *file)
@@ -356,17 +356,17 @@ static int adu_release(struct inode *inode, struct file *file)
356 struct adu_device *dev; 356 struct adu_device *dev;
357 int retval = 0; 357 int retval = 0;
358 358
359 dbg(2," %s : enter", __FUNCTION__); 359 dbg(2," %s : enter", __func__);
360 360
361 if (file == NULL) { 361 if (file == NULL) {
362 dbg(1," %s : file is NULL", __FUNCTION__); 362 dbg(1," %s : file is NULL", __func__);
363 retval = -ENODEV; 363 retval = -ENODEV;
364 goto exit; 364 goto exit;
365 } 365 }
366 366
367 dev = file->private_data; 367 dev = file->private_data;
368 if (dev == NULL) { 368 if (dev == NULL) {
369 dbg(1," %s : object is NULL", __FUNCTION__); 369 dbg(1," %s : object is NULL", __func__);
370 retval = -ENODEV; 370 retval = -ENODEV;
371 goto exit; 371 goto exit;
372 } 372 }
@@ -374,7 +374,7 @@ static int adu_release(struct inode *inode, struct file *file)
374 mutex_lock(&adutux_mutex); /* not interruptible */ 374 mutex_lock(&adutux_mutex); /* not interruptible */
375 375
376 if (dev->open_count <= 0) { 376 if (dev->open_count <= 0) {
377 dbg(1," %s : device not opened", __FUNCTION__); 377 dbg(1," %s : device not opened", __func__);
378 retval = -ENODEV; 378 retval = -ENODEV;
379 goto exit; 379 goto exit;
380 } 380 }
@@ -388,7 +388,7 @@ static int adu_release(struct inode *inode, struct file *file)
388 388
389exit: 389exit:
390 mutex_unlock(&adutux_mutex); 390 mutex_unlock(&adutux_mutex);
391 dbg(2," %s : leave, return value %d", __FUNCTION__, retval); 391 dbg(2," %s : leave, return value %d", __func__, retval);
392 return retval; 392 return retval;
393} 393}
394 394
@@ -405,10 +405,10 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
405 unsigned long flags; 405 unsigned long flags;
406 DECLARE_WAITQUEUE(wait, current); 406 DECLARE_WAITQUEUE(wait, current);
407 407
408 dbg(2," %s : enter, count = %Zd, file=%p", __FUNCTION__, count, file); 408 dbg(2," %s : enter, count = %Zd, file=%p", __func__, count, file);
409 409
410 dev = file->private_data; 410 dev = file->private_data;
411 dbg(2," %s : dev=%p", __FUNCTION__, dev); 411 dbg(2," %s : dev=%p", __func__, dev);
412 412
413 if (mutex_lock_interruptible(&dev->mtx)) 413 if (mutex_lock_interruptible(&dev->mtx))
414 return -ERESTARTSYS; 414 return -ERESTARTSYS;
@@ -422,16 +422,16 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
422 422
423 /* verify that some data was requested */ 423 /* verify that some data was requested */
424 if (count == 0) { 424 if (count == 0) {
425 dbg(1," %s : read request of 0 bytes", __FUNCTION__); 425 dbg(1," %s : read request of 0 bytes", __func__);
426 goto exit; 426 goto exit;
427 } 427 }
428 428
429 timeout = COMMAND_TIMEOUT; 429 timeout = COMMAND_TIMEOUT;
430 dbg(2," %s : about to start looping", __FUNCTION__); 430 dbg(2," %s : about to start looping", __func__);
431 while (bytes_to_read) { 431 while (bytes_to_read) {
432 int data_in_secondary = dev->secondary_tail - dev->secondary_head; 432 int data_in_secondary = dev->secondary_tail - dev->secondary_head;
433 dbg(2," %s : while, data_in_secondary=%d, status=%d", 433 dbg(2," %s : while, data_in_secondary=%d, status=%d",
434 __FUNCTION__, data_in_secondary, 434 __func__, data_in_secondary,
435 dev->interrupt_in_urb->status); 435 dev->interrupt_in_urb->status);
436 436
437 if (data_in_secondary) { 437 if (data_in_secondary) {
@@ -456,7 +456,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
456 /* we secure access to the primary */ 456 /* we secure access to the primary */
457 char *tmp; 457 char *tmp;
458 dbg(2," %s : swap, read_buffer_length = %d", 458 dbg(2," %s : swap, read_buffer_length = %d",
459 __FUNCTION__, dev->read_buffer_length); 459 __func__, dev->read_buffer_length);
460 tmp = dev->read_buffer_secondary; 460 tmp = dev->read_buffer_secondary;
461 dev->read_buffer_secondary = dev->read_buffer_primary; 461 dev->read_buffer_secondary = dev->read_buffer_primary;
462 dev->read_buffer_primary = tmp; 462 dev->read_buffer_primary = tmp;
@@ -471,10 +471,10 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
471 if (!dev->read_urb_finished) { 471 if (!dev->read_urb_finished) {
472 /* somebody is doing IO */ 472 /* somebody is doing IO */
473 spin_unlock_irqrestore(&dev->buflock, flags); 473 spin_unlock_irqrestore(&dev->buflock, flags);
474 dbg(2," %s : submitted already", __FUNCTION__); 474 dbg(2," %s : submitted already", __func__);
475 } else { 475 } else {
476 /* we must initiate input */ 476 /* we must initiate input */
477 dbg(2," %s : initiate input", __FUNCTION__); 477 dbg(2," %s : initiate input", __func__);
478 dev->read_urb_finished = 0; 478 dev->read_urb_finished = 0;
479 spin_unlock_irqrestore(&dev->buflock, flags); 479 spin_unlock_irqrestore(&dev->buflock, flags);
480 480
@@ -492,7 +492,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
492 if (retval == -ENOMEM) { 492 if (retval == -ENOMEM) {
493 retval = bytes_read ? bytes_read : -ENOMEM; 493 retval = bytes_read ? bytes_read : -ENOMEM;
494 } 494 }
495 dbg(2," %s : submit failed", __FUNCTION__); 495 dbg(2," %s : submit failed", __func__);
496 goto exit; 496 goto exit;
497 } 497 }
498 } 498 }
@@ -511,13 +511,13 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
511 remove_wait_queue(&dev->read_wait, &wait); 511 remove_wait_queue(&dev->read_wait, &wait);
512 512
513 if (timeout <= 0) { 513 if (timeout <= 0) {
514 dbg(2," %s : timeout", __FUNCTION__); 514 dbg(2," %s : timeout", __func__);
515 retval = bytes_read ? bytes_read : -ETIMEDOUT; 515 retval = bytes_read ? bytes_read : -ETIMEDOUT;
516 goto exit; 516 goto exit;
517 } 517 }
518 518
519 if (signal_pending(current)) { 519 if (signal_pending(current)) {
520 dbg(2," %s : signal pending", __FUNCTION__); 520 dbg(2," %s : signal pending", __func__);
521 retval = bytes_read ? bytes_read : -EINTR; 521 retval = bytes_read ? bytes_read : -EINTR;
522 goto exit; 522 goto exit;
523 } 523 }
@@ -550,7 +550,7 @@ exit:
550 /* unlock the device */ 550 /* unlock the device */
551 mutex_unlock(&dev->mtx); 551 mutex_unlock(&dev->mtx);
552 552
553 dbg(2," %s : leave, return value %d", __FUNCTION__, retval); 553 dbg(2," %s : leave, return value %d", __func__, retval);
554 return retval; 554 return retval;
555} 555}
556 556
@@ -565,7 +565,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
565 unsigned long flags; 565 unsigned long flags;
566 int retval; 566 int retval;
567 567
568 dbg(2," %s : enter, count = %Zd", __FUNCTION__, count); 568 dbg(2," %s : enter, count = %Zd", __func__, count);
569 569
570 dev = file->private_data; 570 dev = file->private_data;
571 571
@@ -582,7 +582,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
582 582
583 /* verify that we actually have some data to write */ 583 /* verify that we actually have some data to write */
584 if (count == 0) { 584 if (count == 0) {
585 dbg(1," %s : write request of 0 bytes", __FUNCTION__); 585 dbg(1," %s : write request of 0 bytes", __func__);
586 goto exit; 586 goto exit;
587 } 587 }
588 588
@@ -595,13 +595,13 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
595 595
596 mutex_unlock(&dev->mtx); 596 mutex_unlock(&dev->mtx);
597 if (signal_pending(current)) { 597 if (signal_pending(current)) {
598 dbg(1," %s : interrupted", __FUNCTION__); 598 dbg(1," %s : interrupted", __func__);
599 set_current_state(TASK_RUNNING); 599 set_current_state(TASK_RUNNING);
600 retval = -EINTR; 600 retval = -EINTR;
601 goto exit_onqueue; 601 goto exit_onqueue;
602 } 602 }
603 if (schedule_timeout(COMMAND_TIMEOUT) == 0) { 603 if (schedule_timeout(COMMAND_TIMEOUT) == 0) {
604 dbg(1, "%s - command timed out.", __FUNCTION__); 604 dbg(1, "%s - command timed out.", __func__);
605 retval = -ETIMEDOUT; 605 retval = -ETIMEDOUT;
606 goto exit_onqueue; 606 goto exit_onqueue;
607 } 607 }
@@ -612,18 +612,18 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
612 goto exit_nolock; 612 goto exit_nolock;
613 } 613 }
614 614
615 dbg(4," %s : in progress, count = %Zd", __FUNCTION__, count); 615 dbg(4," %s : in progress, count = %Zd", __func__, count);
616 } else { 616 } else {
617 spin_unlock_irqrestore(&dev->buflock, flags); 617 spin_unlock_irqrestore(&dev->buflock, flags);
618 set_current_state(TASK_RUNNING); 618 set_current_state(TASK_RUNNING);
619 remove_wait_queue(&dev->write_wait, &waita); 619 remove_wait_queue(&dev->write_wait, &waita);
620 dbg(4," %s : sending, count = %Zd", __FUNCTION__, count); 620 dbg(4," %s : sending, count = %Zd", __func__, count);
621 621
622 /* write the data into interrupt_out_buffer from userspace */ 622 /* write the data into interrupt_out_buffer from userspace */
623 buffer_size = le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize); 623 buffer_size = le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize);
624 bytes_to_write = count > buffer_size ? buffer_size : count; 624 bytes_to_write = count > buffer_size ? buffer_size : count;
625 dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd", 625 dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
626 __FUNCTION__, buffer_size, count, bytes_to_write); 626 __func__, buffer_size, count, bytes_to_write);
627 627
628 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) { 628 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
629 retval = -EFAULT; 629 retval = -EFAULT;
@@ -661,7 +661,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
661exit: 661exit:
662 mutex_unlock(&dev->mtx); 662 mutex_unlock(&dev->mtx);
663exit_nolock: 663exit_nolock:
664 dbg(2," %s : leave, return value %d", __FUNCTION__, retval); 664 dbg(2," %s : leave, return value %d", __func__, retval);
665 return retval; 665 return retval;
666 666
667exit_onqueue: 667exit_onqueue:
@@ -706,7 +706,7 @@ static int adu_probe(struct usb_interface *interface,
706 int out_end_size; 706 int out_end_size;
707 int i; 707 int i;
708 708
709 dbg(2," %s : enter", __FUNCTION__); 709 dbg(2," %s : enter", __func__);
710 710
711 if (udev == NULL) { 711 if (udev == NULL) {
712 dev_err(&interface->dev, "udev is NULL.\n"); 712 dev_err(&interface->dev, "udev is NULL.\n");
@@ -807,7 +807,7 @@ static int adu_probe(struct usb_interface *interface,
807 dev_err(&interface->dev, "Could not retrieve serial number\n"); 807 dev_err(&interface->dev, "Could not retrieve serial number\n");
808 goto error; 808 goto error;
809 } 809 }
810 dbg(2," %s : serial_number=%s", __FUNCTION__, dev->serial_number); 810 dbg(2," %s : serial_number=%s", __func__, dev->serial_number);
811 811
812 /* we can register the device now, as it is ready */ 812 /* we can register the device now, as it is ready */
813 usb_set_intfdata(interface, dev); 813 usb_set_intfdata(interface, dev);
@@ -828,7 +828,7 @@ static int adu_probe(struct usb_interface *interface,
828 udev->descriptor.idProduct, dev->serial_number, 828 udev->descriptor.idProduct, dev->serial_number,
829 (dev->minor - ADU_MINOR_BASE)); 829 (dev->minor - ADU_MINOR_BASE));
830exit: 830exit:
831 dbg(2," %s : leave, return value %p (dev)", __FUNCTION__, dev); 831 dbg(2," %s : leave, return value %p (dev)", __func__, dev);
832 832
833 return retval; 833 return retval;
834 834
@@ -847,7 +847,7 @@ static void adu_disconnect(struct usb_interface *interface)
847 struct adu_device *dev; 847 struct adu_device *dev;
848 int minor; 848 int minor;
849 849
850 dbg(2," %s : enter", __FUNCTION__); 850 dbg(2," %s : enter", __func__);
851 851
852 dev = usb_get_intfdata(interface); 852 dev = usb_get_intfdata(interface);
853 853
@@ -861,7 +861,7 @@ static void adu_disconnect(struct usb_interface *interface)
861 usb_set_intfdata(interface, NULL); 861 usb_set_intfdata(interface, NULL);
862 862
863 /* if the device is not opened, then we clean up right now */ 863 /* if the device is not opened, then we clean up right now */
864 dbg(2," %s : open count %d", __FUNCTION__, dev->open_count); 864 dbg(2," %s : open count %d", __func__, dev->open_count);
865 if (!dev->open_count) 865 if (!dev->open_count)
866 adu_delete(dev); 866 adu_delete(dev);
867 867
@@ -870,7 +870,7 @@ static void adu_disconnect(struct usb_interface *interface)
870 dev_info(&interface->dev, "ADU device adutux%d now disconnected\n", 870 dev_info(&interface->dev, "ADU device adutux%d now disconnected\n",
871 (minor - ADU_MINOR_BASE)); 871 (minor - ADU_MINOR_BASE));
872 872
873 dbg(2," %s : leave", __FUNCTION__); 873 dbg(2," %s : leave", __func__);
874} 874}
875 875
876/* usb specific object needed to register this driver with the usb subsystem */ 876/* usb specific object needed to register this driver with the usb subsystem */
@@ -885,7 +885,7 @@ static int __init adu_init(void)
885{ 885{
886 int result; 886 int result;
887 887
888 dbg(2," %s : enter", __FUNCTION__); 888 dbg(2," %s : enter", __func__);
889 889
890 /* register this driver with the USB subsystem */ 890 /* register this driver with the USB subsystem */
891 result = usb_register(&adu_driver); 891 result = usb_register(&adu_driver);
@@ -899,17 +899,17 @@ static int __init adu_init(void)
899 info("adutux is an experimental driver. Use at your own risk"); 899 info("adutux is an experimental driver. Use at your own risk");
900 900
901exit: 901exit:
902 dbg(2," %s : leave, return value %d", __FUNCTION__, result); 902 dbg(2," %s : leave, return value %d", __func__, result);
903 903
904 return result; 904 return result;
905} 905}
906 906
907static void __exit adu_exit(void) 907static void __exit adu_exit(void)
908{ 908{
909 dbg(2," %s : enter", __FUNCTION__); 909 dbg(2," %s : enter", __func__);
910 /* deregister this driver with the USB subsystem */ 910 /* deregister this driver with the USB subsystem */
911 usb_deregister(&adu_driver); 911 usb_deregister(&adu_driver);
912 dbg(2," %s : leave", __FUNCTION__); 912 dbg(2," %s : leave", __func__);
913} 913}
914 914
915module_init(adu_init); 915module_init(adu_init);
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index a5e4c3545c72..a076c24a312a 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -103,11 +103,11 @@ static void appledisplay_complete(struct urb *urb)
103 case -ESHUTDOWN: 103 case -ESHUTDOWN:
104 /* This urb is terminated, clean up */ 104 /* This urb is terminated, clean up */
105 dbg("%s - urb shuttingdown with status: %d", 105 dbg("%s - urb shuttingdown with status: %d",
106 __FUNCTION__, status); 106 __func__, status);
107 return; 107 return;
108 default: 108 default:
109 dbg("%s - nonzero urb status received: %d", 109 dbg("%s - nonzero urb status received: %d",
110 __FUNCTION__, status); 110 __func__, status);
111 goto exit; 111 goto exit;
112 } 112 }
113 113
@@ -131,7 +131,7 @@ exit:
131 retval = usb_submit_urb(pdata->urb, GFP_ATOMIC); 131 retval = usb_submit_urb(pdata->urb, GFP_ATOMIC);
132 if (retval) { 132 if (retval) {
133 err("%s - usb_submit_urb failed with result %d", 133 err("%s - usb_submit_urb failed with result %d",
134 __FUNCTION__, retval); 134 __func__, retval);
135 } 135 }
136} 136}
137 137
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index df7e1ecc810a..093938697426 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -31,6 +31,7 @@
31#include <linux/init.h> 31#include <linux/init.h>
32#include <linux/wait.h> 32#include <linux/wait.h>
33#include <linux/usb.h> 33#include <linux/usb.h>
34#include <linux/mutex.h>
34 35
35/*-------------------------------------------------------------------*/ 36/*-------------------------------------------------------------------*/
36/* Debug support */ 37/* Debug support */
@@ -232,7 +233,7 @@ typedef struct auerscon
232/* USB device context */ 233/* USB device context */
233typedef struct 234typedef struct
234{ 235{
235 struct semaphore mutex; /* protection in user context */ 236 struct mutex mutex; /* protection in user context */
236 char name[20]; /* name of the /dev/usb entry */ 237 char name[20]; /* name of the /dev/usb entry */
237 unsigned int dtindex; /* index in the device table */ 238 unsigned int dtindex; /* index in the device table */
238 struct usb_device * usbdev; /* USB device handle */ 239 struct usb_device * usbdev; /* USB device handle */
@@ -253,12 +254,12 @@ typedef struct
253/* character device context */ 254/* character device context */
254typedef struct 255typedef struct
255{ 256{
256 struct semaphore mutex; /* protection in user context */ 257 struct mutex mutex; /* protection in user context */
257 pauerswald_t auerdev; /* context pointer of assigned device */ 258 pauerswald_t auerdev; /* context pointer of assigned device */
258 auerbufctl_t bufctl; /* controls the buffer chain */ 259 auerbufctl_t bufctl; /* controls the buffer chain */
259 auerscon_t scontext; /* service context */ 260 auerscon_t scontext; /* service context */
260 wait_queue_head_t readwait; /* for synchronous reading */ 261 wait_queue_head_t readwait; /* for synchronous reading */
261 struct semaphore readmutex; /* protection against multiple reads */ 262 struct mutex readmutex; /* protection against multiple reads */
262 pauerbuf_t readbuf; /* buffer held for partial reading */ 263 pauerbuf_t readbuf; /* buffer held for partial reading */
263 unsigned int readoffset; /* current offset in readbuf */ 264 unsigned int readoffset; /* current offset in readbuf */
264 unsigned int removed; /* is != 0 if device is removed */ 265 unsigned int removed; /* is != 0 if device is removed */
@@ -283,7 +284,7 @@ static void auerchain_complete (struct urb * urb)
283 int result; 284 int result;
284 285
285 /* get pointer to element and to chain */ 286 /* get pointer to element and to chain */
286 pauerchainelement_t acep = (pauerchainelement_t) urb->context; 287 pauerchainelement_t acep = urb->context;
287 pauerchain_t acp = acep->chain; 288 pauerchain_t acp = acep->chain;
288 289
289 /* restore original entries in urb */ 290 /* restore original entries in urb */
@@ -593,7 +594,7 @@ ac_fail:/* free the elements */
593/* completion handler for synchronous chained URBs */ 594/* completion handler for synchronous chained URBs */
594static void auerchain_blocking_completion (struct urb *urb) 595static void auerchain_blocking_completion (struct urb *urb)
595{ 596{
596 pauerchain_chs_t pchs = (pauerchain_chs_t)urb->context; 597 pauerchain_chs_t pchs = urb->context;
597 pchs->done = 1; 598 pchs->done = 1;
598 wmb(); 599 wmb();
599 wake_up (&pchs->wqh); 600 wake_up (&pchs->wqh);
@@ -846,7 +847,7 @@ static int auerswald_status_retry (int status)
846/* Completion of asynchronous write block */ 847/* Completion of asynchronous write block */
847static void auerchar_ctrlwrite_complete (struct urb * urb) 848static void auerchar_ctrlwrite_complete (struct urb * urb)
848{ 849{
849 pauerbuf_t bp = (pauerbuf_t) urb->context; 850 pauerbuf_t bp = urb->context;
850 pauerswald_t cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl))); 851 pauerswald_t cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
851 dbg ("auerchar_ctrlwrite_complete called"); 852 dbg ("auerchar_ctrlwrite_complete called");
852 853
@@ -859,7 +860,7 @@ static void auerchar_ctrlwrite_complete (struct urb * urb)
859/* Completion handler for dummy retry packet */ 860/* Completion handler for dummy retry packet */
860static void auerswald_ctrlread_wretcomplete (struct urb * urb) 861static void auerswald_ctrlread_wretcomplete (struct urb * urb)
861{ 862{
862 pauerbuf_t bp = (pauerbuf_t) urb->context; 863 pauerbuf_t bp = urb->context;
863 pauerswald_t cp; 864 pauerswald_t cp;
864 int ret; 865 int ret;
865 int status = urb->status; 866 int status = urb->status;
@@ -903,7 +904,7 @@ static void auerswald_ctrlread_complete (struct urb * urb)
903 unsigned int serviceid; 904 unsigned int serviceid;
904 pauerswald_t cp; 905 pauerswald_t cp;
905 pauerscon_t scp; 906 pauerscon_t scp;
906 pauerbuf_t bp = (pauerbuf_t) urb->context; 907 pauerbuf_t bp = urb->context;
907 int status = urb->status; 908 int status = urb->status;
908 int ret; 909 int ret;
909 910
@@ -980,9 +981,9 @@ static void auerswald_int_complete (struct urb * urb)
980 int ret; 981 int ret;
981 int status = urb->status; 982 int status = urb->status;
982 pauerbuf_t bp = NULL; 983 pauerbuf_t bp = NULL;
983 pauerswald_t cp = (pauerswald_t) urb->context; 984 pauerswald_t cp = urb->context;
984 985
985 dbg ("%s called", __FUNCTION__); 986 dbg ("%s called", __func__);
986 987
987 switch (status) { 988 switch (status) {
988 case 0: 989 case 0:
@@ -992,10 +993,10 @@ static void auerswald_int_complete (struct urb * urb)
992 case -ENOENT: 993 case -ENOENT:
993 case -ESHUTDOWN: 994 case -ESHUTDOWN:
994 /* this urb is terminated, clean up */ 995 /* this urb is terminated, clean up */
995 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status); 996 dbg("%s - urb shutting down with status: %d", __func__, status);
996 return; 997 return;
997 default: 998 default:
998 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status); 999 dbg("%s - nonzero urb status received: %d", __func__, status);
999 goto exit; 1000 goto exit;
1000 } 1001 }
1001 1002
@@ -1080,7 +1081,7 @@ exit:
1080 ret = usb_submit_urb (urb, GFP_ATOMIC); 1081 ret = usb_submit_urb (urb, GFP_ATOMIC);
1081 if (ret) 1082 if (ret)
1082 err ("%s - usb_submit_urb failed with result %d", 1083 err ("%s - usb_submit_urb failed with result %d",
1083 __FUNCTION__, ret); 1084 __func__, ret);
1084} 1085}
1085 1086
1086/* int memory deallocation 1087/* int memory deallocation
@@ -1376,7 +1377,7 @@ static int auerchar_open (struct inode *inode, struct file *file)
1376 if (cp == NULL) { 1377 if (cp == NULL) {
1377 return -ENODEV; 1378 return -ENODEV;
1378 } 1379 }
1379 if (down_interruptible (&cp->mutex)) { 1380 if (mutex_lock_interruptible(&cp->mutex)) {
1380 return -ERESTARTSYS; 1381 return -ERESTARTSYS;
1381 } 1382 }
1382 1383
@@ -1389,8 +1390,8 @@ static int auerchar_open (struct inode *inode, struct file *file)
1389 } 1390 }
1390 1391
1391 /* Initialize device descriptor */ 1392 /* Initialize device descriptor */
1392 init_MUTEX( &ccp->mutex); 1393 mutex_init(&ccp->mutex);
1393 init_MUTEX( &ccp->readmutex); 1394 mutex_init(&ccp->readmutex);
1394 auerbuf_init (&ccp->bufctl); 1395 auerbuf_init (&ccp->bufctl);
1395 ccp->scontext.id = AUH_UNASSIGNED; 1396 ccp->scontext.id = AUH_UNASSIGNED;
1396 ccp->scontext.dispatch = auerchar_ctrlread_dispatch; 1397 ccp->scontext.dispatch = auerchar_ctrlread_dispatch;
@@ -1405,7 +1406,7 @@ static int auerchar_open (struct inode *inode, struct file *file)
1405 cp->open_count++; 1406 cp->open_count++;
1406 ccp->auerdev = cp; 1407 ccp->auerdev = cp;
1407 dbg("open %s as /dev/%s", cp->dev_desc, cp->name); 1408 dbg("open %s as /dev/%s", cp->dev_desc, cp->name);
1408 up (&cp->mutex); 1409 mutex_unlock(&cp->mutex);
1409 1410
1410 /* file IO stuff */ 1411 /* file IO stuff */
1411 file->f_pos = 0; 1412 file->f_pos = 0;
@@ -1413,7 +1414,7 @@ static int auerchar_open (struct inode *inode, struct file *file)
1413 return nonseekable_open(inode, file); 1414 return nonseekable_open(inode, file);
1414 1415
1415 /* Error exit */ 1416 /* Error exit */
1416ofail: up (&cp->mutex); 1417ofail: mutex_unlock(&cp->mutex);
1417 auerchar_delete (ccp); 1418 auerchar_delete (ccp);
1418 return ret; 1419 return ret;
1419} 1420}
@@ -1432,23 +1433,23 @@ static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int
1432 dbg ("ioctl"); 1433 dbg ("ioctl");
1433 1434
1434 /* get the mutexes */ 1435 /* get the mutexes */
1435 if (down_interruptible (&ccp->mutex)) { 1436 if (mutex_lock_interruptible(&ccp->mutex)) {
1436 return -ERESTARTSYS; 1437 return -ERESTARTSYS;
1437 } 1438 }
1438 cp = ccp->auerdev; 1439 cp = ccp->auerdev;
1439 if (!cp) { 1440 if (!cp) {
1440 up (&ccp->mutex); 1441 mutex_unlock(&ccp->mutex);
1441 return -ENODEV; 1442 return -ENODEV;
1442 } 1443 }
1443 if (down_interruptible (&cp->mutex)) { 1444 if (mutex_lock_interruptible(&cp->mutex)) {
1444 up(&ccp->mutex); 1445 mutex_unlock(&ccp->mutex);
1445 return -ERESTARTSYS; 1446 return -ERESTARTSYS;
1446 } 1447 }
1447 1448
1448 /* Check for removal */ 1449 /* Check for removal */
1449 if (!cp->usbdev) { 1450 if (!cp->usbdev) {
1450 up(&cp->mutex); 1451 mutex_unlock(&cp->mutex);
1451 up(&ccp->mutex); 1452 mutex_unlock(&ccp->mutex);
1452 return -ENODEV; 1453 return -ENODEV;
1453 } 1454 }
1454 1455
@@ -1550,8 +1551,8 @@ static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int
1550 break; 1551 break;
1551 } 1552 }
1552 /* release the mutexes */ 1553 /* release the mutexes */
1553 up(&cp->mutex); 1554 mutex_unlock(&cp->mutex);
1554 up(&ccp->mutex); 1555 mutex_unlock(&ccp->mutex);
1555 return ret; 1556 return ret;
1556} 1557}
1557 1558
@@ -1574,18 +1575,18 @@ static ssize_t auerchar_read (struct file *file, char __user *buf, size_t count,
1574 return 0; 1575 return 0;
1575 1576
1576 /* get the mutex */ 1577 /* get the mutex */
1577 if (down_interruptible (&ccp->mutex)) 1578 if (mutex_lock_interruptible(&ccp->mutex))
1578 return -ERESTARTSYS; 1579 return -ERESTARTSYS;
1579 1580
1580 /* Can we expect to read something? */ 1581 /* Can we expect to read something? */
1581 if (ccp->scontext.id == AUH_UNASSIGNED) { 1582 if (ccp->scontext.id == AUH_UNASSIGNED) {
1582 up (&ccp->mutex); 1583 mutex_unlock(&ccp->mutex);
1583 return -EIO; 1584 return -EIO;
1584 } 1585 }
1585 1586
1586 /* only one reader per device allowed */ 1587 /* only one reader per device allowed */
1587 if (down_interruptible (&ccp->readmutex)) { 1588 if (mutex_lock_interruptible(&ccp->readmutex)) {
1588 up (&ccp->mutex); 1589 mutex_unlock(&ccp->mutex);
1589 return -ERESTARTSYS; 1590 return -ERESTARTSYS;
1590 } 1591 }
1591 1592
@@ -1602,8 +1603,8 @@ doreadbuf:
1602 if (count) { 1603 if (count) {
1603 if (copy_to_user (buf, bp->bufp+ccp->readoffset, count)) { 1604 if (copy_to_user (buf, bp->bufp+ccp->readoffset, count)) {
1604 dbg ("auerswald_read: copy_to_user failed"); 1605 dbg ("auerswald_read: copy_to_user failed");
1605 up (&ccp->readmutex); 1606 mutex_unlock(&ccp->readmutex);
1606 up (&ccp->mutex); 1607 mutex_unlock(&ccp->mutex);
1607 return -EFAULT; 1608 return -EFAULT;
1608 } 1609 }
1609 } 1610 }
@@ -1617,8 +1618,8 @@ doreadbuf:
1617 } 1618 }
1618 /* return with number of bytes read */ 1619 /* return with number of bytes read */
1619 if (count) { 1620 if (count) {
1620 up (&ccp->readmutex); 1621 mutex_unlock(&ccp->readmutex);
1621 up (&ccp->mutex); 1622 mutex_unlock(&ccp->mutex);
1622 return count; 1623 return count;
1623 } 1624 }
1624 } 1625 }
@@ -1654,29 +1655,29 @@ doreadlist:
1654 dbg ("No read buffer available, returning -EAGAIN"); 1655 dbg ("No read buffer available, returning -EAGAIN");
1655 set_current_state (TASK_RUNNING); 1656 set_current_state (TASK_RUNNING);
1656 remove_wait_queue (&ccp->readwait, &wait); 1657 remove_wait_queue (&ccp->readwait, &wait);
1657 up (&ccp->readmutex); 1658 mutex_unlock(&ccp->readmutex);
1658 up (&ccp->mutex); 1659 mutex_unlock(&ccp->mutex);
1659 return -EAGAIN; /* nonblocking, no data available */ 1660 return -EAGAIN; /* nonblocking, no data available */
1660 } 1661 }
1661 1662
1662 /* yes, we should wait! */ 1663 /* yes, we should wait! */
1663 up (&ccp->mutex); /* allow other operations while we wait */ 1664 mutex_unlock(&ccp->mutex); /* allow other operations while we wait */
1664 schedule(); 1665 schedule();
1665 remove_wait_queue (&ccp->readwait, &wait); 1666 remove_wait_queue (&ccp->readwait, &wait);
1666 if (signal_pending (current)) { 1667 if (signal_pending (current)) {
1667 /* waked up by a signal */ 1668 /* waked up by a signal */
1668 up (&ccp->readmutex); 1669 mutex_unlock(&ccp->readmutex);
1669 return -ERESTARTSYS; 1670 return -ERESTARTSYS;
1670 } 1671 }
1671 1672
1672 /* Anything left to read? */ 1673 /* Anything left to read? */
1673 if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) { 1674 if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) {
1674 up (&ccp->readmutex); 1675 mutex_unlock(&ccp->readmutex);
1675 return -EIO; 1676 return -EIO;
1676 } 1677 }
1677 1678
1678 if (down_interruptible (&ccp->mutex)) { 1679 if (mutex_lock_interruptible(&ccp->mutex)) {
1679 up (&ccp->readmutex); 1680 mutex_unlock(&ccp->readmutex);
1680 return -ERESTARTSYS; 1681 return -ERESTARTSYS;
1681 } 1682 }
1682 1683
@@ -1707,27 +1708,27 @@ static ssize_t auerchar_write (struct file *file, const char __user *buf, size_t
1707 1708
1708write_again: 1709write_again:
1709 /* get the mutex */ 1710 /* get the mutex */
1710 if (down_interruptible (&ccp->mutex)) 1711 if (mutex_lock_interruptible(&ccp->mutex))
1711 return -ERESTARTSYS; 1712 return -ERESTARTSYS;
1712 1713
1713 /* Can we expect to write something? */ 1714 /* Can we expect to write something? */
1714 if (ccp->scontext.id == AUH_UNASSIGNED) { 1715 if (ccp->scontext.id == AUH_UNASSIGNED) {
1715 up (&ccp->mutex); 1716 mutex_unlock(&ccp->mutex);
1716 return -EIO; 1717 return -EIO;
1717 } 1718 }
1718 1719
1719 cp = ccp->auerdev; 1720 cp = ccp->auerdev;
1720 if (!cp) { 1721 if (!cp) {
1721 up (&ccp->mutex); 1722 mutex_unlock(&ccp->mutex);
1722 return -ERESTARTSYS; 1723 return -ERESTARTSYS;
1723 } 1724 }
1724 if (down_interruptible (&cp->mutex)) { 1725 if (mutex_lock_interruptible(&cp->mutex)) {
1725 up (&ccp->mutex); 1726 mutex_unlock(&ccp->mutex);
1726 return -ERESTARTSYS; 1727 return -ERESTARTSYS;
1727 } 1728 }
1728 if (!cp->usbdev) { 1729 if (!cp->usbdev) {
1729 up (&cp->mutex); 1730 mutex_unlock(&cp->mutex);
1730 up (&ccp->mutex); 1731 mutex_unlock(&ccp->mutex);
1731 return -EIO; 1732 return -EIO;
1732 } 1733 }
1733 /* Prepare for sleep */ 1734 /* Prepare for sleep */
@@ -1750,8 +1751,8 @@ write_again:
1750 1751
1751 /* are there any buffers left? */ 1752 /* are there any buffers left? */
1752 if (!bp) { 1753 if (!bp) {
1753 up (&cp->mutex); 1754 mutex_unlock(&cp->mutex);
1754 up (&ccp->mutex); 1755 mutex_unlock(&ccp->mutex);
1755 1756
1756 /* NONBLOCK: don't wait */ 1757 /* NONBLOCK: don't wait */
1757 if (file->f_flags & O_NONBLOCK) { 1758 if (file->f_flags & O_NONBLOCK) {
@@ -1783,8 +1784,8 @@ write_again:
1783 auerbuf_releasebuf (bp); 1784 auerbuf_releasebuf (bp);
1784 /* Wake up all processes waiting for a buffer */ 1785 /* Wake up all processes waiting for a buffer */
1785 wake_up (&cp->bufferwait); 1786 wake_up (&cp->bufferwait);
1786 up (&cp->mutex); 1787 mutex_unlock(&cp->mutex);
1787 up (&ccp->mutex); 1788 mutex_unlock(&ccp->mutex);
1788 return -EFAULT; 1789 return -EFAULT;
1789 } 1790 }
1790 1791
@@ -1803,18 +1804,18 @@ write_again:
1803 auerchar_ctrlwrite_complete, bp); 1804 auerchar_ctrlwrite_complete, bp);
1804 /* up we go */ 1805 /* up we go */
1805 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp); 1806 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1806 up (&cp->mutex); 1807 mutex_unlock(&cp->mutex);
1807 if (ret) { 1808 if (ret) {
1808 dbg ("auerchar_write: nonzero result of auerchain_submit_urb %d", ret); 1809 dbg ("auerchar_write: nonzero result of auerchain_submit_urb %d", ret);
1809 auerbuf_releasebuf (bp); 1810 auerbuf_releasebuf (bp);
1810 /* Wake up all processes waiting for a buffer */ 1811 /* Wake up all processes waiting for a buffer */
1811 wake_up (&cp->bufferwait); 1812 wake_up (&cp->bufferwait);
1812 up (&ccp->mutex); 1813 mutex_unlock(&ccp->mutex);
1813 return -EIO; 1814 return -EIO;
1814 } 1815 }
1815 else { 1816 else {
1816 dbg ("auerchar_write: Write OK"); 1817 dbg ("auerchar_write: Write OK");
1817 up (&ccp->mutex); 1818 mutex_unlock(&ccp->mutex);
1818 return len; 1819 return len;
1819 } 1820 }
1820} 1821}
@@ -1827,24 +1828,24 @@ static int auerchar_release (struct inode *inode, struct file *file)
1827 pauerswald_t cp; 1828 pauerswald_t cp;
1828 dbg("release"); 1829 dbg("release");
1829 1830
1830 down(&ccp->mutex); 1831 mutex_lock(&ccp->mutex);
1831 cp = ccp->auerdev; 1832 cp = ccp->auerdev;
1832 if (cp) { 1833 if (cp) {
1833 down(&cp->mutex); 1834 mutex_lock(&cp->mutex);
1834 /* remove an open service */ 1835 /* remove an open service */
1835 auerswald_removeservice (cp, &ccp->scontext); 1836 auerswald_removeservice (cp, &ccp->scontext);
1836 /* detach from device */ 1837 /* detach from device */
1837 if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) { 1838 if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) {
1838 /* usb device waits for removal */ 1839 /* usb device waits for removal */
1839 up (&cp->mutex); 1840 mutex_unlock(&cp->mutex);
1840 auerswald_delete (cp); 1841 auerswald_delete (cp);
1841 } else { 1842 } else {
1842 up (&cp->mutex); 1843 mutex_unlock(&cp->mutex);
1843 } 1844 }
1844 cp = NULL; 1845 cp = NULL;
1845 ccp->auerdev = NULL; 1846 ccp->auerdev = NULL;
1846 } 1847 }
1847 up (&ccp->mutex); 1848 mutex_unlock(&ccp->mutex);
1848 auerchar_delete (ccp); 1849 auerchar_delete (ccp);
1849 1850
1850 return 0; 1851 return 0;
@@ -1917,7 +1918,7 @@ static int auerswald_probe (struct usb_interface *intf,
1917 } 1918 }
1918 1919
1919 /* Initialize device descriptor */ 1920 /* Initialize device descriptor */
1920 init_MUTEX (&cp->mutex); 1921 mutex_init(&cp->mutex);
1921 cp->usbdev = usbdev; 1922 cp->usbdev = usbdev;
1922 auerchain_init (&cp->controlchain); 1923 auerchain_init (&cp->controlchain);
1923 auerbuf_init (&cp->bufctl); 1924 auerbuf_init (&cp->bufctl);
@@ -2042,7 +2043,7 @@ static void auerswald_disconnect (struct usb_interface *intf)
2042 /* give back our USB minor number */ 2043 /* give back our USB minor number */
2043 usb_deregister_dev(intf, &auerswald_class); 2044 usb_deregister_dev(intf, &auerswald_class);
2044 2045
2045 down (&cp->mutex); 2046 mutex_lock(&cp->mutex);
2046 info ("device /dev/%s now disconnecting", cp->name); 2047 info ("device /dev/%s now disconnecting", cp->name);
2047 2048
2048 /* Stop the interrupt endpoint */ 2049 /* Stop the interrupt endpoint */
@@ -2057,16 +2058,18 @@ static void auerswald_disconnect (struct usb_interface *intf)
2057 2058
2058 if (cp->open_count == 0) { 2059 if (cp->open_count == 0) {
2059 /* nobody is using this device. So we can clean up now */ 2060 /* nobody is using this device. So we can clean up now */
2060 up (&cp->mutex);/* up() is possible here because no other task 2061 mutex_unlock(&cp->mutex);
2061 can open the device (see above). I don't want 2062 /* mutex_unlock() is possible here because no other task
2062 to kfree() a locked mutex. */ 2063 can open the device (see above). I don't want
2064 to kfree() a locked mutex. */
2065
2063 auerswald_delete (cp); 2066 auerswald_delete (cp);
2064 } else { 2067 } else {
2065 /* device is used. Remove the pointer to the 2068 /* device is used. Remove the pointer to the
2066 usb device (it's not valid any more). The last 2069 usb device (it's not valid any more). The last
2067 release() will do the clean up */ 2070 release() will do the clean up */
2068 cp->usbdev = NULL; 2071 cp->usbdev = NULL;
2069 up (&cp->mutex); 2072 mutex_unlock(&cp->mutex);
2070 /* Terminate waiting writers */ 2073 /* Terminate waiting writers */
2071 wake_up (&cp->bufferwait); 2074 wake_up (&cp->bufferwait);
2072 /* Inform all waiting readers */ 2075 /* Inform all waiting readers */
diff --git a/drivers/usb/misc/emi26.c b/drivers/usb/misc/emi26.c
index 4a09b87bdd28..4b9dc81b8453 100644
--- a/drivers/usb/misc/emi26.c
+++ b/drivers/usb/misc/emi26.c
@@ -70,8 +70,8 @@ static int emi26_writememory (struct usb_device *dev, int address, unsigned char
70static int emi26_set_reset (struct usb_device *dev, unsigned char reset_bit) 70static int emi26_set_reset (struct usb_device *dev, unsigned char reset_bit)
71{ 71{
72 int response; 72 int response;
73 info("%s - %d", __FUNCTION__, reset_bit); 73 info("%s - %d", __func__, reset_bit);
74 /* printk(KERN_DEBUG "%s - %d", __FUNCTION__, reset_bit); */ 74 /* printk(KERN_DEBUG "%s - %d", __func__, reset_bit); */
75 response = emi26_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0); 75 response = emi26_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
76 if (response < 0) { 76 if (response < 0) {
77 err("emi26: set_reset (%d) failed", reset_bit); 77 err("emi26: set_reset (%d) failed", reset_bit);
@@ -91,7 +91,7 @@ static int emi26_load_firmware (struct usb_device *dev)
91 91
92 buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL); 92 buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
93 if (!buf) { 93 if (!buf) {
94 err( "%s - error loading firmware: error = %d", __FUNCTION__, -ENOMEM); 94 err( "%s - error loading firmware: error = %d", __func__, -ENOMEM);
95 err = -ENOMEM; 95 err = -ENOMEM;
96 goto wraperr; 96 goto wraperr;
97 } 97 }
@@ -99,7 +99,7 @@ static int emi26_load_firmware (struct usb_device *dev)
99 /* Assert reset (stop the CPU in the EMI) */ 99 /* Assert reset (stop the CPU in the EMI) */
100 err = emi26_set_reset(dev,1); 100 err = emi26_set_reset(dev,1);
101 if (err < 0) { 101 if (err < 0) {
102 err( "%s - error loading firmware: error = %d", __FUNCTION__, err); 102 err( "%s - error loading firmware: error = %d", __func__, err);
103 goto wraperr; 103 goto wraperr;
104 } 104 }
105 105
@@ -107,7 +107,7 @@ static int emi26_load_firmware (struct usb_device *dev)
107 for (i=0; g_Loader[i].type == 0; i++) { 107 for (i=0; g_Loader[i].type == 0; i++) {
108 err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL); 108 err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL);
109 if (err < 0) { 109 if (err < 0) {
110 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 110 err("%s - error loading firmware: error = %d", __func__, err);
111 goto wraperr; 111 goto wraperr;
112 } 112 }
113 } 113 }
@@ -115,7 +115,7 @@ static int emi26_load_firmware (struct usb_device *dev)
115 /* De-assert reset (let the CPU run) */ 115 /* De-assert reset (let the CPU run) */
116 err = emi26_set_reset(dev,0); 116 err = emi26_set_reset(dev,0);
117 if (err < 0) { 117 if (err < 0) {
118 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 118 err("%s - error loading firmware: error = %d", __func__, err);
119 goto wraperr; 119 goto wraperr;
120 } 120 }
121 msleep(250); /* let device settle */ 121 msleep(250); /* let device settle */
@@ -135,7 +135,7 @@ static int emi26_load_firmware (struct usb_device *dev)
135 } 135 }
136 err = emi26_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA); 136 err = emi26_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
137 if (err < 0) { 137 if (err < 0) {
138 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 138 err("%s - error loading firmware: error = %d", __func__, err);
139 goto wraperr; 139 goto wraperr;
140 } 140 }
141 } while (i > 0); 141 } while (i > 0);
@@ -143,7 +143,7 @@ static int emi26_load_firmware (struct usb_device *dev)
143 /* Assert reset (stop the CPU in the EMI) */ 143 /* Assert reset (stop the CPU in the EMI) */
144 err = emi26_set_reset(dev,1); 144 err = emi26_set_reset(dev,1);
145 if (err < 0) { 145 if (err < 0) {
146 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 146 err("%s - error loading firmware: error = %d", __func__, err);
147 goto wraperr; 147 goto wraperr;
148 } 148 }
149 149
@@ -151,7 +151,7 @@ static int emi26_load_firmware (struct usb_device *dev)
151 for (i=0; g_Loader[i].type == 0; i++) { 151 for (i=0; g_Loader[i].type == 0; i++) {
152 err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL); 152 err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL);
153 if (err < 0) { 153 if (err < 0) {
154 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 154 err("%s - error loading firmware: error = %d", __func__, err);
155 goto wraperr; 155 goto wraperr;
156 } 156 }
157 } 157 }
@@ -160,7 +160,7 @@ static int emi26_load_firmware (struct usb_device *dev)
160 /* De-assert reset (let the CPU run) */ 160 /* De-assert reset (let the CPU run) */
161 err = emi26_set_reset(dev,0); 161 err = emi26_set_reset(dev,0);
162 if (err < 0) { 162 if (err < 0) {
163 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 163 err("%s - error loading firmware: error = %d", __func__, err);
164 goto wraperr; 164 goto wraperr;
165 } 165 }
166 166
@@ -169,7 +169,7 @@ static int emi26_load_firmware (struct usb_device *dev)
169 if (!INTERNAL_RAM(g_Firmware[i].address)) { 169 if (!INTERNAL_RAM(g_Firmware[i].address)) {
170 err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_EXTERNAL); 170 err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_EXTERNAL);
171 if (err < 0) { 171 if (err < 0) {
172 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 172 err("%s - error loading firmware: error = %d", __func__, err);
173 goto wraperr; 173 goto wraperr;
174 } 174 }
175 } 175 }
@@ -178,7 +178,7 @@ static int emi26_load_firmware (struct usb_device *dev)
178 /* Assert reset (stop the CPU in the EMI) */ 178 /* Assert reset (stop the CPU in the EMI) */
179 err = emi26_set_reset(dev,1); 179 err = emi26_set_reset(dev,1);
180 if (err < 0) { 180 if (err < 0) {
181 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 181 err("%s - error loading firmware: error = %d", __func__, err);
182 goto wraperr; 182 goto wraperr;
183 } 183 }
184 184
@@ -186,7 +186,7 @@ static int emi26_load_firmware (struct usb_device *dev)
186 if (INTERNAL_RAM(g_Firmware[i].address)) { 186 if (INTERNAL_RAM(g_Firmware[i].address)) {
187 err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_INTERNAL); 187 err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_INTERNAL);
188 if (err < 0) { 188 if (err < 0) {
189 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 189 err("%s - error loading firmware: error = %d", __func__, err);
190 goto wraperr; 190 goto wraperr;
191 } 191 }
192 } 192 }
@@ -195,7 +195,7 @@ static int emi26_load_firmware (struct usb_device *dev)
195 /* De-assert reset (let the CPU run) */ 195 /* De-assert reset (let the CPU run) */
196 err = emi26_set_reset(dev,0); 196 err = emi26_set_reset(dev,0);
197 if (err < 0) { 197 if (err < 0) {
198 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 198 err("%s - error loading firmware: error = %d", __func__, err);
199 goto wraperr; 199 goto wraperr;
200 } 200 }
201 msleep(250); /* let device settle */ 201 msleep(250); /* let device settle */
@@ -221,7 +221,7 @@ static int emi26_probe(struct usb_interface *intf, const struct usb_device_id *i
221{ 221{
222 struct usb_device *dev = interface_to_usbdev(intf); 222 struct usb_device *dev = interface_to_usbdev(intf);
223 223
224 info("%s start", __FUNCTION__); 224 info("%s start", __func__);
225 225
226 emi26_load_firmware(dev); 226 emi26_load_firmware(dev);
227 227
diff --git a/drivers/usb/misc/emi62.c b/drivers/usb/misc/emi62.c
index d1362415922c..1a2b79ac5e10 100644
--- a/drivers/usb/misc/emi62.c
+++ b/drivers/usb/misc/emi62.c
@@ -78,7 +78,7 @@ static int emi62_writememory (struct usb_device *dev, int address, unsigned char
78static int emi62_set_reset (struct usb_device *dev, unsigned char reset_bit) 78static int emi62_set_reset (struct usb_device *dev, unsigned char reset_bit)
79{ 79{
80 int response; 80 int response;
81 info("%s - %d", __FUNCTION__, reset_bit); 81 info("%s - %d", __func__, reset_bit);
82 82
83 response = emi62_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0); 83 response = emi62_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
84 if (response < 0) { 84 if (response < 0) {
@@ -100,7 +100,7 @@ static int emi62_load_firmware (struct usb_device *dev)
100 dev_dbg(&dev->dev, "load_firmware\n"); 100 dev_dbg(&dev->dev, "load_firmware\n");
101 buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL); 101 buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
102 if (!buf) { 102 if (!buf) {
103 err( "%s - error loading firmware: error = %d", __FUNCTION__, -ENOMEM); 103 err( "%s - error loading firmware: error = %d", __func__, -ENOMEM);
104 err = -ENOMEM; 104 err = -ENOMEM;
105 goto wraperr; 105 goto wraperr;
106 } 106 }
@@ -108,7 +108,7 @@ static int emi62_load_firmware (struct usb_device *dev)
108 /* Assert reset (stop the CPU in the EMI) */ 108 /* Assert reset (stop the CPU in the EMI) */
109 err = emi62_set_reset(dev,1); 109 err = emi62_set_reset(dev,1);
110 if (err < 0) { 110 if (err < 0) {
111 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 111 err("%s - error loading firmware: error = %d", __func__, err);
112 goto wraperr; 112 goto wraperr;
113 } 113 }
114 114
@@ -116,7 +116,7 @@ static int emi62_load_firmware (struct usb_device *dev)
116 for (i=0; g_emi62_loader[i].type == 0; i++) { 116 for (i=0; g_emi62_loader[i].type == 0; i++) {
117 err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL); 117 err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL);
118 if (err < 0) { 118 if (err < 0) {
119 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 119 err("%s - error loading firmware: error = %d", __func__, err);
120 goto wraperr; 120 goto wraperr;
121 } 121 }
122 } 122 }
@@ -124,7 +124,7 @@ static int emi62_load_firmware (struct usb_device *dev)
124 /* De-assert reset (let the CPU run) */ 124 /* De-assert reset (let the CPU run) */
125 err = emi62_set_reset(dev,0); 125 err = emi62_set_reset(dev,0);
126 if (err < 0) { 126 if (err < 0) {
127 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 127 err("%s - error loading firmware: error = %d", __func__, err);
128 goto wraperr; 128 goto wraperr;
129 } 129 }
130 msleep(250); /* let device settle */ 130 msleep(250); /* let device settle */
@@ -144,7 +144,7 @@ static int emi62_load_firmware (struct usb_device *dev)
144 } 144 }
145 err = emi62_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA); 145 err = emi62_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
146 if (err < 0) { 146 if (err < 0) {
147 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 147 err("%s - error loading firmware: error = %d", __func__, err);
148 goto wraperr; 148 goto wraperr;
149 } 149 }
150 } while (i > 0); 150 } while (i > 0);
@@ -152,7 +152,7 @@ static int emi62_load_firmware (struct usb_device *dev)
152 /* Assert reset (stop the CPU in the EMI) */ 152 /* Assert reset (stop the CPU in the EMI) */
153 err = emi62_set_reset(dev,1); 153 err = emi62_set_reset(dev,1);
154 if (err < 0) { 154 if (err < 0) {
155 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 155 err("%s - error loading firmware: error = %d", __func__, err);
156 goto wraperr; 156 goto wraperr;
157 } 157 }
158 158
@@ -160,7 +160,7 @@ static int emi62_load_firmware (struct usb_device *dev)
160 for (i=0; g_emi62_loader[i].type == 0; i++) { 160 for (i=0; g_emi62_loader[i].type == 0; i++) {
161 err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL); 161 err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL);
162 if (err < 0) { 162 if (err < 0) {
163 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 163 err("%s - error loading firmware: error = %d", __func__, err);
164 goto wraperr; 164 goto wraperr;
165 } 165 }
166 } 166 }
@@ -168,7 +168,7 @@ static int emi62_load_firmware (struct usb_device *dev)
168 /* De-assert reset (let the CPU run) */ 168 /* De-assert reset (let the CPU run) */
169 err = emi62_set_reset(dev,0); 169 err = emi62_set_reset(dev,0);
170 if (err < 0) { 170 if (err < 0) {
171 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 171 err("%s - error loading firmware: error = %d", __func__, err);
172 goto wraperr; 172 goto wraperr;
173 } 173 }
174 msleep(250); /* let device settle */ 174 msleep(250); /* let device settle */
@@ -181,7 +181,7 @@ static int emi62_load_firmware (struct usb_device *dev)
181 if (!INTERNAL_RAM(g_HexSpdifFw62[i].address)) { 181 if (!INTERNAL_RAM(g_HexSpdifFw62[i].address)) {
182 err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_EXTERNAL); 182 err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_EXTERNAL);
183 if (err < 0) { 183 if (err < 0) {
184 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 184 err("%s - error loading firmware: error = %d", __func__, err);
185 goto wraperr; 185 goto wraperr;
186 } 186 }
187 } 187 }
@@ -191,7 +191,7 @@ static int emi62_load_firmware (struct usb_device *dev)
191 if (!INTERNAL_RAM(g_HexMidiFw62[i].address)) { 191 if (!INTERNAL_RAM(g_HexMidiFw62[i].address)) {
192 err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_EXTERNAL); 192 err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_EXTERNAL);
193 if (err < 0) { 193 if (err < 0) {
194 err("%s - error loading firmware: error = %d\n", __FUNCTION__, err); 194 err("%s - error loading firmware: error = %d\n", __func__, err);
195 goto wraperr; 195 goto wraperr;
196 return err; 196 return err;
197 } 197 }
@@ -201,7 +201,7 @@ static int emi62_load_firmware (struct usb_device *dev)
201 /* Assert reset (stop the CPU in the EMI) */ 201 /* Assert reset (stop the CPU in the EMI) */
202 err = emi62_set_reset(dev,1); 202 err = emi62_set_reset(dev,1);
203 if (err < 0) { 203 if (err < 0) {
204 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 204 err("%s - error loading firmware: error = %d", __func__, err);
205 goto wraperr; 205 goto wraperr;
206 } 206 }
207 207
@@ -211,7 +211,7 @@ static int emi62_load_firmware (struct usb_device *dev)
211 if (INTERNAL_RAM(g_HexSpdifFw62[i].address)) { 211 if (INTERNAL_RAM(g_HexSpdifFw62[i].address)) {
212 err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_INTERNAL); 212 err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_INTERNAL);
213 if (err < 0) { 213 if (err < 0) {
214 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 214 err("%s - error loading firmware: error = %d", __func__, err);
215 goto wraperr; 215 goto wraperr;
216 } 216 }
217 } 217 }
@@ -221,7 +221,7 @@ static int emi62_load_firmware (struct usb_device *dev)
221 if (INTERNAL_RAM(g_HexMidiFw62[i].address)) { 221 if (INTERNAL_RAM(g_HexMidiFw62[i].address)) {
222 err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_INTERNAL); 222 err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_INTERNAL);
223 if (err < 0) { 223 if (err < 0) {
224 err("%s - error loading firmware: error = %d\n", __FUNCTION__, err); 224 err("%s - error loading firmware: error = %d\n", __func__, err);
225 goto wraperr; 225 goto wraperr;
226 } 226 }
227 } 227 }
@@ -231,7 +231,7 @@ static int emi62_load_firmware (struct usb_device *dev)
231 /* De-assert reset (let the CPU run) */ 231 /* De-assert reset (let the CPU run) */
232 err = emi62_set_reset(dev,0); 232 err = emi62_set_reset(dev,0);
233 if (err < 0) { 233 if (err < 0) {
234 err("%s - error loading firmware: error = %d", __FUNCTION__, err); 234 err("%s - error loading firmware: error = %d", __func__, err);
235 goto wraperr; 235 goto wraperr;
236 } 236 }
237 msleep(250); /* let device settle */ 237 msleep(250); /* let device settle */
@@ -260,7 +260,7 @@ static int emi62_probe(struct usb_interface *intf, const struct usb_device_id *i
260 struct usb_device *dev = interface_to_usbdev(intf); 260 struct usb_device *dev = interface_to_usbdev(intf);
261 dev_dbg(&intf->dev, "emi62_probe\n"); 261 dev_dbg(&intf->dev, "emi62_probe\n");
262 262
263 info("%s start", __FUNCTION__); 263 info("%s start", __func__);
264 264
265 emi62_load_firmware(dev); 265 emi62_load_firmware(dev);
266 266
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index 148b7fe639b2..ec88b3bfee46 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -746,7 +746,7 @@ static ssize_t ftdi_elan_read(struct file *file, char __user *buffer,
746 746
747static void ftdi_elan_write_bulk_callback(struct urb *urb) 747static void ftdi_elan_write_bulk_callback(struct urb *urb)
748{ 748{
749 struct usb_ftdi *ftdi = (struct usb_ftdi *)urb->context; 749 struct usb_ftdi *ftdi = urb->context;
750 int status = urb->status; 750 int status = urb->status;
751 751
752 if (status && !(status == -ENOENT || status == -ECONNRESET || 752 if (status && !(status == -ENOENT || status == -ECONNRESET ||
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 801070502cc1..1cb54a28347f 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -154,7 +154,7 @@ MODULE_DEVICE_TABLE(usb, iowarrior_ids);
154 */ 154 */
155static void iowarrior_callback(struct urb *urb) 155static void iowarrior_callback(struct urb *urb)
156{ 156{
157 struct iowarrior *dev = (struct iowarrior *)urb->context; 157 struct iowarrior *dev = urb->context;
158 int intr_idx; 158 int intr_idx;
159 int read_idx; 159 int read_idx;
160 int aux_idx; 160 int aux_idx;
@@ -218,7 +218,7 @@ exit:
218 retval = usb_submit_urb(urb, GFP_ATOMIC); 218 retval = usb_submit_urb(urb, GFP_ATOMIC);
219 if (retval) 219 if (retval)
220 dev_err(&dev->interface->dev, "%s - usb_submit_urb failed with result %d\n", 220 dev_err(&dev->interface->dev, "%s - usb_submit_urb failed with result %d\n",
221 __FUNCTION__, retval); 221 __func__, retval);
222 222
223} 223}
224 224
@@ -230,7 +230,7 @@ static void iowarrior_write_callback(struct urb *urb)
230 struct iowarrior *dev; 230 struct iowarrior *dev;
231 int status = urb->status; 231 int status = urb->status;
232 232
233 dev = (struct iowarrior *)urb->context; 233 dev = urb->context;
234 /* sync/async unlink faults aren't errors */ 234 /* sync/async unlink faults aren't errors */
235 if (status && 235 if (status &&
236 !(status == -ENOENT || 236 !(status == -ENOENT ||
@@ -453,7 +453,7 @@ static ssize_t iowarrior_write(struct file *file,
453 default: 453 default:
454 /* what do we have here ? An unsupported Product-ID ? */ 454 /* what do we have here ? An unsupported Product-ID ? */
455 dev_err(&dev->interface->dev, "%s - not supported for product=0x%x\n", 455 dev_err(&dev->interface->dev, "%s - not supported for product=0x%x\n",
456 __FUNCTION__, dev->product_id); 456 __func__, dev->product_id);
457 retval = -EFAULT; 457 retval = -EFAULT;
458 goto exit; 458 goto exit;
459 break; 459 break;
@@ -604,7 +604,7 @@ static int iowarrior_open(struct inode *inode, struct file *file)
604 604
605 interface = usb_find_interface(&iowarrior_driver, subminor); 605 interface = usb_find_interface(&iowarrior_driver, subminor);
606 if (!interface) { 606 if (!interface) {
607 err("%s - error, can't find device for minor %d", __FUNCTION__, 607 err("%s - error, can't find device for minor %d", __func__,
608 subminor); 608 subminor);
609 return -ENODEV; 609 return -ENODEV;
610 } 610 }
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index c730d20eec66..11580e81e2c6 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -231,7 +231,7 @@ static void ld_usb_interrupt_in_callback(struct urb *urb)
231 goto exit; 231 goto exit;
232 } else { 232 } else {
233 dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n", 233 dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n",
234 __FUNCTION__, status); 234 __func__, status);
235 spin_lock(&dev->rbsl); 235 spin_lock(&dev->rbsl);
236 goto resubmit; /* maybe we can recover */ 236 goto resubmit; /* maybe we can recover */
237 } 237 }
@@ -247,7 +247,7 @@ static void ld_usb_interrupt_in_callback(struct urb *urb)
247 memcpy(actual_buffer+1, dev->interrupt_in_buffer, urb->actual_length); 247 memcpy(actual_buffer+1, dev->interrupt_in_buffer, urb->actual_length);
248 dev->ring_head = next_ring_head; 248 dev->ring_head = next_ring_head;
249 dbg_info(&dev->intf->dev, "%s: received %d bytes\n", 249 dbg_info(&dev->intf->dev, "%s: received %d bytes\n",
250 __FUNCTION__, urb->actual_length); 250 __func__, urb->actual_length);
251 } else { 251 } else {
252 dev_warn(&dev->intf->dev, 252 dev_warn(&dev->intf->dev,
253 "Ring buffer overflow, %d bytes dropped\n", 253 "Ring buffer overflow, %d bytes dropped\n",
@@ -286,7 +286,7 @@ static void ld_usb_interrupt_out_callback(struct urb *urb)
286 status == -ESHUTDOWN)) 286 status == -ESHUTDOWN))
287 dbg_info(&dev->intf->dev, 287 dbg_info(&dev->intf->dev,
288 "%s - nonzero write interrupt status received: %d\n", 288 "%s - nonzero write interrupt status received: %d\n",
289 __FUNCTION__, status); 289 __func__, status);
290 290
291 dev->interrupt_out_busy = 0; 291 dev->interrupt_out_busy = 0;
292 wake_up_interruptible(&dev->write_wait); 292 wake_up_interruptible(&dev->write_wait);
@@ -309,7 +309,7 @@ static int ld_usb_open(struct inode *inode, struct file *file)
309 309
310 if (!interface) { 310 if (!interface) {
311 err("%s - error, can't find device for minor %d\n", 311 err("%s - error, can't find device for minor %d\n",
312 __FUNCTION__, subminor); 312 __func__, subminor);
313 return -ENODEV; 313 return -ENODEV;
314 } 314 }
315 315
@@ -556,7 +556,7 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
556 bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size); 556 bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size);
557 if (bytes_to_write < count) 557 if (bytes_to_write < count)
558 dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write); 558 dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write);
559 dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __FUNCTION__, count, bytes_to_write); 559 dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __func__, count, bytes_to_write);
560 560
561 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) { 561 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
562 retval = -EFAULT; 562 retval = -EFAULT;
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 6664043f4645..9370326a5940 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -31,7 +31,7 @@
31 * - imported into lejos project 31 * - imported into lejos project
32 * - changed wake_up to wake_up_interruptible 32 * - changed wake_up to wake_up_interruptible
33 * - changed to use lego0 rather than tower0 33 * - changed to use lego0 rather than tower0
34 * - changed dbg() to use __func__ rather than deprecated __FUNCTION__ 34 * - changed dbg() to use __func__ rather than deprecated __func__
35 * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au) 35 * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
36 * - changed read and write to write everything or 36 * - changed read and write to write everything or
37 * timeout (from a patch by Chris Riesen and Brett Thaeler driver) 37 * timeout (from a patch by Chris Riesen and Brett Thaeler driver)
@@ -49,7 +49,7 @@
49 * - added poll 49 * - added poll
50 * - forbid seeking 50 * - forbid seeking
51 * - added nonblocking I/O 51 * - added nonblocking I/O
52 * - changed back __func__ to __FUNCTION__ 52 * - changed back __func__ to __func__
53 * - read and log tower firmware version 53 * - read and log tower firmware version
54 * - reset tower on probe, avoids failure of first write 54 * - reset tower on probe, avoids failure of first write
55 * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net> 55 * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
@@ -309,7 +309,7 @@ static inline void lego_usb_tower_debug_data (int level, const char *function, i
309 */ 309 */
310static inline void tower_delete (struct lego_usb_tower *dev) 310static inline void tower_delete (struct lego_usb_tower *dev)
311{ 311{
312 dbg(2, "%s: enter", __FUNCTION__); 312 dbg(2, "%s: enter", __func__);
313 313
314 tower_abort_transfers (dev); 314 tower_abort_transfers (dev);
315 315
@@ -321,7 +321,7 @@ static inline void tower_delete (struct lego_usb_tower *dev)
321 kfree (dev->interrupt_out_buffer); 321 kfree (dev->interrupt_out_buffer);
322 kfree (dev); 322 kfree (dev);
323 323
324 dbg(2, "%s: leave", __FUNCTION__); 324 dbg(2, "%s: leave", __func__);
325} 325}
326 326
327 327
@@ -337,7 +337,7 @@ static int tower_open (struct inode *inode, struct file *file)
337 struct tower_reset_reply reset_reply; 337 struct tower_reset_reply reset_reply;
338 int result; 338 int result;
339 339
340 dbg(2, "%s: enter", __FUNCTION__); 340 dbg(2, "%s: enter", __func__);
341 341
342 nonseekable_open(inode, file); 342 nonseekable_open(inode, file);
343 subminor = iminor(inode); 343 subminor = iminor(inode);
@@ -346,7 +346,7 @@ static int tower_open (struct inode *inode, struct file *file)
346 346
347 if (!interface) { 347 if (!interface) {
348 err ("%s - error, can't find device for minor %d", 348 err ("%s - error, can't find device for minor %d",
349 __FUNCTION__, subminor); 349 __func__, subminor);
350 retval = -ENODEV; 350 retval = -ENODEV;
351 goto exit; 351 goto exit;
352 } 352 }
@@ -424,7 +424,7 @@ unlock_exit:
424 mutex_unlock(&dev->lock); 424 mutex_unlock(&dev->lock);
425 425
426exit: 426exit:
427 dbg(2, "%s: leave, return value %d ", __FUNCTION__, retval); 427 dbg(2, "%s: leave, return value %d ", __func__, retval);
428 428
429 return retval; 429 return retval;
430} 430}
@@ -437,12 +437,12 @@ static int tower_release (struct inode *inode, struct file *file)
437 struct lego_usb_tower *dev; 437 struct lego_usb_tower *dev;
438 int retval = 0; 438 int retval = 0;
439 439
440 dbg(2, "%s: enter", __FUNCTION__); 440 dbg(2, "%s: enter", __func__);
441 441
442 dev = (struct lego_usb_tower *)file->private_data; 442 dev = (struct lego_usb_tower *)file->private_data;
443 443
444 if (dev == NULL) { 444 if (dev == NULL) {
445 dbg(1, "%s: object is NULL", __FUNCTION__); 445 dbg(1, "%s: object is NULL", __func__);
446 retval = -ENODEV; 446 retval = -ENODEV;
447 goto exit_nolock; 447 goto exit_nolock;
448 } 448 }
@@ -454,7 +454,7 @@ static int tower_release (struct inode *inode, struct file *file)
454 } 454 }
455 455
456 if (dev->open_count != 1) { 456 if (dev->open_count != 1) {
457 dbg(1, "%s: device not opened exactly once", __FUNCTION__); 457 dbg(1, "%s: device not opened exactly once", __func__);
458 retval = -ENODEV; 458 retval = -ENODEV;
459 goto unlock_exit; 459 goto unlock_exit;
460 } 460 }
@@ -480,7 +480,7 @@ unlock_exit:
480exit: 480exit:
481 mutex_unlock(&open_disc_mutex); 481 mutex_unlock(&open_disc_mutex);
482exit_nolock: 482exit_nolock:
483 dbg(2, "%s: leave, return value %d", __FUNCTION__, retval); 483 dbg(2, "%s: leave, return value %d", __func__, retval);
484 return retval; 484 return retval;
485} 485}
486 486
@@ -491,10 +491,10 @@ exit_nolock:
491 */ 491 */
492static void tower_abort_transfers (struct lego_usb_tower *dev) 492static void tower_abort_transfers (struct lego_usb_tower *dev)
493{ 493{
494 dbg(2, "%s: enter", __FUNCTION__); 494 dbg(2, "%s: enter", __func__);
495 495
496 if (dev == NULL) { 496 if (dev == NULL) {
497 dbg(1, "%s: dev is null", __FUNCTION__); 497 dbg(1, "%s: dev is null", __func__);
498 goto exit; 498 goto exit;
499 } 499 }
500 500
@@ -509,7 +509,7 @@ static void tower_abort_transfers (struct lego_usb_tower *dev)
509 usb_kill_urb(dev->interrupt_out_urb); 509 usb_kill_urb(dev->interrupt_out_urb);
510 510
511exit: 511exit:
512 dbg(2, "%s: leave", __FUNCTION__); 512 dbg(2, "%s: leave", __func__);
513} 513}
514 514
515 515
@@ -542,7 +542,7 @@ static unsigned int tower_poll (struct file *file, poll_table *wait)
542 struct lego_usb_tower *dev; 542 struct lego_usb_tower *dev;
543 unsigned int mask = 0; 543 unsigned int mask = 0;
544 544
545 dbg(2, "%s: enter", __FUNCTION__); 545 dbg(2, "%s: enter", __func__);
546 546
547 dev = file->private_data; 547 dev = file->private_data;
548 548
@@ -557,7 +557,7 @@ static unsigned int tower_poll (struct file *file, poll_table *wait)
557 mask |= POLLOUT | POLLWRNORM; 557 mask |= POLLOUT | POLLWRNORM;
558 } 558 }
559 559
560 dbg(2, "%s: leave, mask = %d", __FUNCTION__, mask); 560 dbg(2, "%s: leave, mask = %d", __func__, mask);
561 561
562 return mask; 562 return mask;
563} 563}
@@ -583,7 +583,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
583 int retval = 0; 583 int retval = 0;
584 unsigned long timeout = 0; 584 unsigned long timeout = 0;
585 585
586 dbg(2, "%s: enter, count = %Zd", __FUNCTION__, count); 586 dbg(2, "%s: enter, count = %Zd", __func__, count);
587 587
588 dev = (struct lego_usb_tower *)file->private_data; 588 dev = (struct lego_usb_tower *)file->private_data;
589 589
@@ -602,7 +602,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
602 602
603 /* verify that we actually have some data to read */ 603 /* verify that we actually have some data to read */
604 if (count == 0) { 604 if (count == 0) {
605 dbg(1, "%s: read request of 0 bytes", __FUNCTION__); 605 dbg(1, "%s: read request of 0 bytes", __func__);
606 goto unlock_exit; 606 goto unlock_exit;
607 } 607 }
608 608
@@ -658,7 +658,7 @@ unlock_exit:
658 mutex_unlock(&dev->lock); 658 mutex_unlock(&dev->lock);
659 659
660exit: 660exit:
661 dbg(2, "%s: leave, return value %d", __FUNCTION__, retval); 661 dbg(2, "%s: leave, return value %d", __func__, retval);
662 return retval; 662 return retval;
663} 663}
664 664
@@ -672,7 +672,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
672 size_t bytes_to_write; 672 size_t bytes_to_write;
673 int retval = 0; 673 int retval = 0;
674 674
675 dbg(2, "%s: enter, count = %Zd", __FUNCTION__, count); 675 dbg(2, "%s: enter, count = %Zd", __func__, count);
676 676
677 dev = (struct lego_usb_tower *)file->private_data; 677 dev = (struct lego_usb_tower *)file->private_data;
678 678
@@ -691,7 +691,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
691 691
692 /* verify that we actually have some data to write */ 692 /* verify that we actually have some data to write */
693 if (count == 0) { 693 if (count == 0) {
694 dbg(1, "%s: write request of 0 bytes", __FUNCTION__); 694 dbg(1, "%s: write request of 0 bytes", __func__);
695 goto unlock_exit; 695 goto unlock_exit;
696 } 696 }
697 697
@@ -709,7 +709,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
709 709
710 /* write the data into interrupt_out_buffer from userspace */ 710 /* write the data into interrupt_out_buffer from userspace */
711 bytes_to_write = min_t(int, count, write_buffer_size); 711 bytes_to_write = min_t(int, count, write_buffer_size);
712 dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __FUNCTION__, count, bytes_to_write); 712 dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __func__, count, bytes_to_write);
713 713
714 if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) { 714 if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
715 retval = -EFAULT; 715 retval = -EFAULT;
@@ -742,7 +742,7 @@ unlock_exit:
742 mutex_unlock(&dev->lock); 742 mutex_unlock(&dev->lock);
743 743
744exit: 744exit:
745 dbg(2, "%s: leave, return value %d", __FUNCTION__, retval); 745 dbg(2, "%s: leave, return value %d", __func__, retval);
746 746
747 return retval; 747 return retval;
748} 748}
@@ -753,13 +753,13 @@ exit:
753 */ 753 */
754static void tower_interrupt_in_callback (struct urb *urb) 754static void tower_interrupt_in_callback (struct urb *urb)
755{ 755{
756 struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context; 756 struct lego_usb_tower *dev = urb->context;
757 int status = urb->status; 757 int status = urb->status;
758 int retval; 758 int retval;
759 759
760 dbg(4, "%s: enter, status %d", __FUNCTION__, status); 760 dbg(4, "%s: enter, status %d", __func__, status);
761 761
762 lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer); 762 lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
763 763
764 if (status) { 764 if (status) {
765 if (status == -ENOENT || 765 if (status == -ENOENT ||
@@ -767,7 +767,7 @@ static void tower_interrupt_in_callback (struct urb *urb)
767 status == -ESHUTDOWN) { 767 status == -ESHUTDOWN) {
768 goto exit; 768 goto exit;
769 } else { 769 } else {
770 dbg(1, "%s: nonzero status received: %d", __FUNCTION__, status); 770 dbg(1, "%s: nonzero status received: %d", __func__, status);
771 goto resubmit; /* maybe we can recover */ 771 goto resubmit; /* maybe we can recover */
772 } 772 }
773 } 773 }
@@ -780,9 +780,9 @@ static void tower_interrupt_in_callback (struct urb *urb)
780 urb->actual_length); 780 urb->actual_length);
781 dev->read_buffer_length += urb->actual_length; 781 dev->read_buffer_length += urb->actual_length;
782 dev->read_last_arrival = jiffies; 782 dev->read_last_arrival = jiffies;
783 dbg(3, "%s: received %d bytes", __FUNCTION__, urb->actual_length); 783 dbg(3, "%s: received %d bytes", __func__, urb->actual_length);
784 } else { 784 } else {
785 printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __FUNCTION__, urb->actual_length); 785 printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __func__, urb->actual_length);
786 } 786 }
787 spin_unlock (&dev->read_buffer_lock); 787 spin_unlock (&dev->read_buffer_lock);
788 } 788 }
@@ -792,7 +792,7 @@ resubmit:
792 if (dev->interrupt_in_running && dev->udev) { 792 if (dev->interrupt_in_running && dev->udev) {
793 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC); 793 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
794 if (retval) { 794 if (retval) {
795 err("%s: usb_submit_urb failed (%d)", __FUNCTION__, retval); 795 err("%s: usb_submit_urb failed (%d)", __func__, retval);
796 } 796 }
797 } 797 }
798 798
@@ -800,8 +800,8 @@ exit:
800 dev->interrupt_in_done = 1; 800 dev->interrupt_in_done = 1;
801 wake_up_interruptible (&dev->read_wait); 801 wake_up_interruptible (&dev->read_wait);
802 802
803 lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer); 803 lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
804 dbg(4, "%s: leave, status %d", __FUNCTION__, status); 804 dbg(4, "%s: leave, status %d", __func__, status);
805} 805}
806 806
807 807
@@ -810,25 +810,25 @@ exit:
810 */ 810 */
811static void tower_interrupt_out_callback (struct urb *urb) 811static void tower_interrupt_out_callback (struct urb *urb)
812{ 812{
813 struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context; 813 struct lego_usb_tower *dev = urb->context;
814 int status = urb->status; 814 int status = urb->status;
815 815
816 dbg(4, "%s: enter, status %d", __FUNCTION__, status); 816 dbg(4, "%s: enter, status %d", __func__, status);
817 lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer); 817 lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
818 818
819 /* sync/async unlink faults aren't errors */ 819 /* sync/async unlink faults aren't errors */
820 if (status && !(status == -ENOENT || 820 if (status && !(status == -ENOENT ||
821 status == -ECONNRESET || 821 status == -ECONNRESET ||
822 status == -ESHUTDOWN)) { 822 status == -ESHUTDOWN)) {
823 dbg(1, "%s - nonzero write bulk status received: %d", 823 dbg(1, "%s - nonzero write bulk status received: %d",
824 __FUNCTION__, status); 824 __func__, status);
825 } 825 }
826 826
827 dev->interrupt_out_busy = 0; 827 dev->interrupt_out_busy = 0;
828 wake_up_interruptible(&dev->write_wait); 828 wake_up_interruptible(&dev->write_wait);
829 829
830 lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer); 830 lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
831 dbg(4, "%s: leave, status %d", __FUNCTION__, status); 831 dbg(4, "%s: leave, status %d", __func__, status);
832} 832}
833 833
834 834
@@ -849,7 +849,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
849 int retval = -ENOMEM; 849 int retval = -ENOMEM;
850 int result; 850 int result;
851 851
852 dbg(2, "%s: enter", __FUNCTION__); 852 dbg(2, "%s: enter", __func__);
853 853
854 if (udev == NULL) { 854 if (udev == NULL) {
855 info ("udev is NULL."); 855 info ("udev is NULL.");
@@ -978,7 +978,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
978 978
979 979
980exit: 980exit:
981 dbg(2, "%s: leave, return value 0x%.8lx (dev)", __FUNCTION__, (long) dev); 981 dbg(2, "%s: leave, return value 0x%.8lx (dev)", __func__, (long) dev);
982 982
983 return retval; 983 return retval;
984 984
@@ -998,7 +998,7 @@ static void tower_disconnect (struct usb_interface *interface)
998 struct lego_usb_tower *dev; 998 struct lego_usb_tower *dev;
999 int minor; 999 int minor;
1000 1000
1001 dbg(2, "%s: enter", __FUNCTION__); 1001 dbg(2, "%s: enter", __func__);
1002 1002
1003 dev = usb_get_intfdata (interface); 1003 dev = usb_get_intfdata (interface);
1004 mutex_lock(&open_disc_mutex); 1004 mutex_lock(&open_disc_mutex);
@@ -1023,7 +1023,7 @@ static void tower_disconnect (struct usb_interface *interface)
1023 1023
1024 info("LEGO USB Tower #%d now disconnected", (minor - LEGO_USB_TOWER_MINOR_BASE)); 1024 info("LEGO USB Tower #%d now disconnected", (minor - LEGO_USB_TOWER_MINOR_BASE));
1025 1025
1026 dbg(2, "%s: leave", __FUNCTION__); 1026 dbg(2, "%s: leave", __func__);
1027} 1027}
1028 1028
1029 1029
@@ -1036,7 +1036,7 @@ static int __init lego_usb_tower_init(void)
1036 int result; 1036 int result;
1037 int retval = 0; 1037 int retval = 0;
1038 1038
1039 dbg(2, "%s: enter", __FUNCTION__); 1039 dbg(2, "%s: enter", __func__);
1040 1040
1041 /* register this driver with the USB subsystem */ 1041 /* register this driver with the USB subsystem */
1042 result = usb_register(&tower_driver); 1042 result = usb_register(&tower_driver);
@@ -1049,7 +1049,7 @@ static int __init lego_usb_tower_init(void)
1049 info(DRIVER_DESC " " DRIVER_VERSION); 1049 info(DRIVER_DESC " " DRIVER_VERSION);
1050 1050
1051exit: 1051exit:
1052 dbg(2, "%s: leave, return value %d", __FUNCTION__, retval); 1052 dbg(2, "%s: leave, return value %d", __func__, retval);
1053 1053
1054 return retval; 1054 return retval;
1055} 1055}
@@ -1060,12 +1060,12 @@ exit:
1060 */ 1060 */
1061static void __exit lego_usb_tower_exit(void) 1061static void __exit lego_usb_tower_exit(void)
1062{ 1062{
1063 dbg(2, "%s: enter", __FUNCTION__); 1063 dbg(2, "%s: enter", __func__);
1064 1064
1065 /* deregister this driver with the USB subsystem */ 1065 /* deregister this driver with the USB subsystem */
1066 usb_deregister (&tower_driver); 1066 usb_deregister (&tower_driver);
1067 1067
1068 dbg(2, "%s: leave", __FUNCTION__); 1068 dbg(2, "%s: leave", __func__);
1069} 1069}
1070 1070
1071module_init (lego_usb_tower_init); 1071module_init (lego_usb_tower_init);
diff --git a/drivers/usb/misc/phidgetkit.c b/drivers/usb/misc/phidgetkit.c
index aa9bcceabe74..24230c638b8e 100644
--- a/drivers/usb/misc/phidgetkit.c
+++ b/drivers/usb/misc/phidgetkit.c
@@ -113,7 +113,7 @@ static int set_outputs(struct interfacekit *kit)
113 113
114 buffer = kzalloc(4, GFP_KERNEL); 114 buffer = kzalloc(4, GFP_KERNEL);
115 if (!buffer) { 115 if (!buffer) {
116 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__); 116 dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
117 return -ENOMEM; 117 return -ENOMEM;
118 } 118 }
119 buffer[0] = (u8)kit->outputs; 119 buffer[0] = (u8)kit->outputs;
@@ -146,7 +146,7 @@ static int change_string(struct interfacekit *kit, const char *display, unsigned
146 buffer = kmalloc(8, GFP_KERNEL); 146 buffer = kmalloc(8, GFP_KERNEL);
147 form_buffer = kmalloc(30, GFP_KERNEL); 147 form_buffer = kmalloc(30, GFP_KERNEL);
148 if ((!buffer) || (!form_buffer)) { 148 if ((!buffer) || (!form_buffer)) {
149 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__); 149 dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
150 goto exit; 150 goto exit;
151 } 151 }
152 152
@@ -216,7 +216,7 @@ static ssize_t set_backlight(struct device *dev, struct device_attribute *attr,
216 216
217 buffer = kzalloc(8, GFP_KERNEL); 217 buffer = kzalloc(8, GFP_KERNEL);
218 if (!buffer) { 218 if (!buffer) {
219 dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__); 219 dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
220 goto exit; 220 goto exit;
221 } 221 }
222 222
diff --git a/drivers/usb/misc/phidgetmotorcontrol.c b/drivers/usb/misc/phidgetmotorcontrol.c
index 2ad09b1f4848..f0113c17cc5a 100644
--- a/drivers/usb/misc/phidgetmotorcontrol.c
+++ b/drivers/usb/misc/phidgetmotorcontrol.c
@@ -61,7 +61,7 @@ static int set_motor(struct motorcontrol *mc, int motor)
61 61
62 buffer = kzalloc(8, GFP_KERNEL); 62 buffer = kzalloc(8, GFP_KERNEL);
63 if (!buffer) { 63 if (!buffer) {
64 dev_err(&mc->intf->dev, "%s - out of memory\n", __FUNCTION__); 64 dev_err(&mc->intf->dev, "%s - out of memory\n", __func__);
65 return -ENOMEM; 65 return -ENOMEM;
66 } 66 }
67 67
diff --git a/drivers/usb/misc/phidgetservo.c b/drivers/usb/misc/phidgetservo.c
index 0d9de2f73930..7d590c09434a 100644
--- a/drivers/usb/misc/phidgetservo.c
+++ b/drivers/usb/misc/phidgetservo.c
@@ -89,7 +89,7 @@ change_position_v30(struct phidget_servo *servo, int servo_no, int degrees,
89 buffer = kmalloc(6, GFP_KERNEL); 89 buffer = kmalloc(6, GFP_KERNEL);
90 if (!buffer) { 90 if (!buffer) {
91 dev_err(&servo->udev->dev, "%s - out of memory\n", 91 dev_err(&servo->udev->dev, "%s - out of memory\n",
92 __FUNCTION__); 92 __func__);
93 return -ENOMEM; 93 return -ENOMEM;
94 } 94 }
95 95
@@ -162,7 +162,7 @@ change_position_v20(struct phidget_servo *servo, int servo_no, int degrees,
162 buffer = kmalloc(2, GFP_KERNEL); 162 buffer = kmalloc(2, GFP_KERNEL);
163 if (!buffer) { 163 if (!buffer) {
164 dev_err(&servo->udev->dev, "%s - out of memory\n", 164 dev_err(&servo->udev->dev, "%s - out of memory\n",
165 __FUNCTION__); 165 __func__);
166 return -ENOMEM; 166 return -ENOMEM;
167 } 167 }
168 168
@@ -259,7 +259,7 @@ servo_probe(struct usb_interface *interface, const struct usb_device_id *id)
259 259
260 dev = kzalloc(sizeof (struct phidget_servo), GFP_KERNEL); 260 dev = kzalloc(sizeof (struct phidget_servo), GFP_KERNEL);
261 if (dev == NULL) { 261 if (dev == NULL) {
262 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__); 262 dev_err(&interface->dev, "%s - out of memory\n", __func__);
263 rc = -ENOMEM; 263 rc = -ENOMEM;
264 goto out; 264 goto out;
265 } 265 }
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 20777d01db62..7f7021ee4189 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -78,7 +78,7 @@ static int lcd_open(struct inode *inode, struct file *file)
78 interface = usb_find_interface(&lcd_driver, subminor); 78 interface = usb_find_interface(&lcd_driver, subminor);
79 if (!interface) { 79 if (!interface) {
80 err ("USBLCD: %s - error, can't find device for minor %d", 80 err ("USBLCD: %s - error, can't find device for minor %d",
81 __FUNCTION__, subminor); 81 __func__, subminor);
82 return -ENODEV; 82 return -ENODEV;
83 } 83 }
84 84
@@ -185,7 +185,7 @@ static void lcd_write_bulk_callback(struct urb *urb)
185 struct usb_lcd *dev; 185 struct usb_lcd *dev;
186 int status = urb->status; 186 int status = urb->status;
187 187
188 dev = (struct usb_lcd *)urb->context; 188 dev = urb->context;
189 189
190 /* sync/async unlink faults aren't errors */ 190 /* sync/async unlink faults aren't errors */
191 if (status && 191 if (status &&
@@ -193,7 +193,7 @@ static void lcd_write_bulk_callback(struct urb *urb)
193 status == -ECONNRESET || 193 status == -ECONNRESET ||
194 status == -ESHUTDOWN)) { 194 status == -ESHUTDOWN)) {
195 dbg("USBLCD: %s - nonzero write bulk status received: %d", 195 dbg("USBLCD: %s - nonzero write bulk status received: %d",
196 __FUNCTION__, status); 196 __func__, status);
197 } 197 }
198 198
199 /* free up our allocated buffer */ 199 /* free up our allocated buffer */
@@ -248,7 +248,7 @@ static ssize_t lcd_write(struct file *file, const char __user * user_buffer, siz
248 /* send the data out the bulk port */ 248 /* send the data out the bulk port */
249 retval = usb_submit_urb(urb, GFP_KERNEL); 249 retval = usb_submit_urb(urb, GFP_KERNEL);
250 if (retval) { 250 if (retval) {
251 err("USBLCD: %s - failed submitting write urb, error %d", __FUNCTION__, retval); 251 err("USBLCD: %s - failed submitting write urb, error %d", __func__, retval);
252 goto error_unanchor; 252 goto error_unanchor;
253 } 253 }
254 254
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index b6b5b2affad1..a51983854ca0 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -201,7 +201,7 @@ found:
201 201
202static void simple_callback (struct urb *urb) 202static void simple_callback (struct urb *urb)
203{ 203{
204 complete ((struct completion *) urb->context); 204 complete(urb->context);
205} 205}
206 206
207static struct urb *simple_alloc_urb ( 207static struct urb *simple_alloc_urb (
@@ -1046,7 +1046,7 @@ static void unlink1_callback (struct urb *urb)
1046 status = usb_submit_urb (urb, GFP_ATOMIC); 1046 status = usb_submit_urb (urb, GFP_ATOMIC);
1047 if (status) { 1047 if (status) {
1048 urb->status = status; 1048 urb->status = status;
1049 complete ((struct completion *) urb->context); 1049 complete(urb->context);
1050 } 1050 }
1051} 1051}
1052 1052
@@ -1136,7 +1136,7 @@ static int verify_not_halted (int ep, struct urb *urb)
1136 dbg ("ep %02x bogus status: %04x != 0", ep, status); 1136 dbg ("ep %02x bogus status: %04x != 0", ep, status);
1137 return -EINVAL; 1137 return -EINVAL;
1138 } 1138 }
1139 retval = simple_io (urb, 1, 0, 0, __FUNCTION__); 1139 retval = simple_io (urb, 1, 0, 0, __func__);
1140 if (retval != 0) 1140 if (retval != 0)
1141 return -EINVAL; 1141 return -EINVAL;
1142 return 0; 1142 return 0;
@@ -1158,7 +1158,7 @@ static int verify_halted (int ep, struct urb *urb)
1158 dbg ("ep %02x bogus status: %04x != 1", ep, status); 1158 dbg ("ep %02x bogus status: %04x != 1", ep, status);
1159 return -EINVAL; 1159 return -EINVAL;
1160 } 1160 }
1161 retval = simple_io (urb, 1, 0, -EPIPE, __FUNCTION__); 1161 retval = simple_io (urb, 1, 0, -EPIPE, __func__);
1162 if (retval != -EPIPE) 1162 if (retval != -EPIPE)
1163 return -EINVAL; 1163 return -EINVAL;
1164 retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted"); 1164 retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted");
@@ -1404,7 +1404,7 @@ static struct urb *iso_alloc_urb (
1404 return NULL; 1404 return NULL;
1405 maxp = 0x7ff & le16_to_cpu(desc->wMaxPacketSize); 1405 maxp = 0x7ff & le16_to_cpu(desc->wMaxPacketSize);
1406 maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11)); 1406 maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11));
1407 packets = (bytes + maxp - 1) / maxp; 1407 packets = DIV_ROUND_UP(bytes, maxp);
1408 1408
1409 urb = usb_alloc_urb (packets, GFP_KERNEL); 1409 urb = usb_alloc_urb (packets, GFP_KERNEL);
1410 if (!urb) 1410 if (!urb)
@@ -1564,7 +1564,8 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
1564 if (mutex_lock_interruptible(&dev->lock)) 1564 if (mutex_lock_interruptible(&dev->lock))
1565 return -ERESTARTSYS; 1565 return -ERESTARTSYS;
1566 1566
1567 if (intf->dev.power.power_state.event != PM_EVENT_ON) { 1567 /* FIXME: What if a system sleep starts while a test is running? */
1568 if (!intf->is_active) {
1568 mutex_unlock(&dev->lock); 1569 mutex_unlock(&dev->lock);
1569 return -EHOSTUNREACH; 1570 return -EHOSTUNREACH;
1570 } 1571 }
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-24 00:40:19 -0400