aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2009-05-07 05:17:13 -0400
committerIngo Molnar <mingo@elte.hu>2009-05-07 05:17:34 -0400
commit44347d947f628060b92449702071bfe1d31dfb75 (patch)
treec6ed74610d5b3295df4296659f80f5feb94b28cc /drivers/staging
parentd94fc523f3c35bd8013f04827e94756cbc0212f4 (diff)
parent413f81eba35d6ede9289b0c8a920c013a84fac71 (diff)
Merge branch 'linus' into tracing/core
Merge reason: tracing/core was on a .30-rc1 base and was missing out on on a handful of tracing fixes present in .30-rc5-almost. Signed-off-by: Ingo Molnar <mingo@elte.hu>
Diffstat (limited to 'drivers/staging')
-rw-r--r--drivers/staging/android/binder.c201
-rw-r--r--drivers/staging/at76_usb/at76_usb.c20
-rw-r--r--drivers/staging/b3dfg/b3dfg.c2
-rw-r--r--drivers/staging/epl/VirtualEthernetLinux.c17
-rw-r--r--drivers/staging/et131x/et131x_netdev.c23
-rw-r--r--drivers/staging/go7007/go7007-driver.c26
-rw-r--r--drivers/staging/go7007/go7007-i2c.c83
-rw-r--r--drivers/staging/go7007/go7007-priv.h1
-rw-r--r--drivers/staging/go7007/go7007-usb.c14
-rw-r--r--drivers/staging/go7007/s2250-board.c71
-rw-r--r--drivers/staging/go7007/wis-i2c.h9
-rw-r--r--drivers/staging/go7007/wis-ov7640.c56
-rw-r--r--drivers/staging/go7007/wis-saa7113.c60
-rw-r--r--drivers/staging/go7007/wis-saa7115.c60
-rw-r--r--drivers/staging/go7007/wis-sony-tuner.c62
-rw-r--r--drivers/staging/go7007/wis-tw2804.c57
-rw-r--r--drivers/staging/go7007/wis-tw9903.c60
-rw-r--r--drivers/staging/go7007/wis-uda1342.c52
-rw-r--r--drivers/staging/line6/audio.c9
-rw-r--r--drivers/staging/otus/usbdrv.c47
-rw-r--r--drivers/staging/otus/zdusb.c3
-rw-r--r--drivers/staging/otus/zdusb.h4
-rw-r--r--drivers/staging/pohmelfs/config.c61
-rw-r--r--drivers/staging/pohmelfs/dir.c24
-rw-r--r--drivers/staging/pohmelfs/inode.c137
-rw-r--r--drivers/staging/pohmelfs/lock.c3
-rw-r--r--drivers/staging/pohmelfs/net.c72
-rw-r--r--drivers/staging/pohmelfs/netfs.h21
-rw-r--r--drivers/staging/pohmelfs/trans.c33
-rw-r--r--drivers/staging/rt2860/rt_main_dev.c25
-rw-r--r--drivers/staging/rt2870/rt2870.h1
-rw-r--r--drivers/staging/rt2870/rt_main_dev.c28
-rw-r--r--drivers/staging/rt3070/rt_main_dev.c29
-rw-r--r--drivers/staging/slicoss/README31
-rw-r--r--drivers/staging/slicoss/slicoss.c25
-rw-r--r--drivers/staging/stlc45xx/Kconfig2
-rw-r--r--drivers/staging/sxg/sxg.c127
-rw-r--r--drivers/staging/uc2322/aten2011.c28
-rw-r--r--drivers/staging/wlan-ng/p80211netdev.c20
39 files changed, 820 insertions, 784 deletions
diff --git a/drivers/staging/android/binder.c b/drivers/staging/android/binder.c
index 79e90fed27d3..299d29d1dadb 100644
--- a/drivers/staging/android/binder.c
+++ b/drivers/staging/android/binder.c
@@ -41,6 +41,8 @@ static int binder_last_id;
41static struct proc_dir_entry *binder_proc_dir_entry_root; 41static struct proc_dir_entry *binder_proc_dir_entry_root;
42static struct proc_dir_entry *binder_proc_dir_entry_proc; 42static struct proc_dir_entry *binder_proc_dir_entry_proc;
43static struct hlist_head binder_dead_nodes; 43static struct hlist_head binder_dead_nodes;
44static HLIST_HEAD(binder_deferred_list);
45static DEFINE_MUTEX(binder_deferred_lock);
44 46
45static int binder_read_proc_proc( 47static int binder_read_proc_proc(
46 char *page, char **start, off_t off, int count, int *eof, void *data); 48 char *page, char **start, off_t off, int count, int *eof, void *data);
@@ -54,11 +56,7 @@ static int binder_read_proc_proc(
54#define SZ_4M 0x400000 56#define SZ_4M 0x400000
55#endif 57#endif
56 58
57#ifndef __i386__
58#define FORBIDDEN_MMAP_FLAGS (VM_WRITE | VM_EXEC)
59#else
60#define FORBIDDEN_MMAP_FLAGS (VM_WRITE) 59#define FORBIDDEN_MMAP_FLAGS (VM_WRITE)
61#endif
62 60
63#define BINDER_SMALL_BUF_SIZE (PAGE_SIZE * 64) 61#define BINDER_SMALL_BUF_SIZE (PAGE_SIZE * 64)
64 62
@@ -236,6 +234,12 @@ struct binder_buffer {
236 uint8_t data[0]; 234 uint8_t data[0];
237}; 235};
238 236
237enum {
238 BINDER_DEFERRED_PUT_FILES = 0x01,
239 BINDER_DEFERRED_FLUSH = 0x02,
240 BINDER_DEFERRED_RELEASE = 0x04,
241};
242
239struct binder_proc { 243struct binder_proc {
240 struct hlist_node proc_node; 244 struct hlist_node proc_node;
241 struct rb_root threads; 245 struct rb_root threads;
@@ -245,8 +249,11 @@ struct binder_proc {
245 int pid; 249 int pid;
246 struct vm_area_struct *vma; 250 struct vm_area_struct *vma;
247 struct task_struct *tsk; 251 struct task_struct *tsk;
252 struct files_struct *files;
253 struct hlist_node deferred_work_node;
254 int deferred_work;
248 void *buffer; 255 void *buffer;
249 size_t user_buffer_offset; 256 ptrdiff_t user_buffer_offset;
250 257
251 struct list_head buffers; 258 struct list_head buffers;
252 struct rb_root free_buffers; 259 struct rb_root free_buffers;
@@ -310,12 +317,14 @@ struct binder_transaction {
310 uid_t sender_euid; 317 uid_t sender_euid;
311}; 318};
312 319
320static void binder_defer_work(struct binder_proc *proc, int defer);
321
313/* 322/*
314 * copied from get_unused_fd_flags 323 * copied from get_unused_fd_flags
315 */ 324 */
316int task_get_unused_fd_flags(struct task_struct *tsk, int flags) 325int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
317{ 326{
318 struct files_struct *files = get_files_struct(tsk); 327 struct files_struct *files = proc->files;
319 int fd, error; 328 int fd, error;
320 struct fdtable *fdt; 329 struct fdtable *fdt;
321 unsigned long rlim_cur; 330 unsigned long rlim_cur;
@@ -337,9 +346,9 @@ repeat:
337 * will limit the total number of files that can be opened. 346 * will limit the total number of files that can be opened.
338 */ 347 */
339 rlim_cur = 0; 348 rlim_cur = 0;
340 if (lock_task_sighand(tsk, &irqs)) { 349 if (lock_task_sighand(proc->tsk, &irqs)) {
341 rlim_cur = tsk->signal->rlim[RLIMIT_NOFILE].rlim_cur; 350 rlim_cur = proc->tsk->signal->rlim[RLIMIT_NOFILE].rlim_cur;
342 unlock_task_sighand(tsk, &irqs); 351 unlock_task_sighand(proc->tsk, &irqs);
343 } 352 }
344 if (fd >= rlim_cur) 353 if (fd >= rlim_cur)
345 goto out; 354 goto out;
@@ -375,7 +384,6 @@ repeat:
375 384
376out: 385out:
377 spin_unlock(&files->file_lock); 386 spin_unlock(&files->file_lock);
378 put_files_struct(files);
379 return error; 387 return error;
380} 388}
381 389
@@ -383,9 +391,9 @@ out:
383 * copied from fd_install 391 * copied from fd_install
384 */ 392 */
385static void task_fd_install( 393static void task_fd_install(
386 struct task_struct *tsk, unsigned int fd, struct file *file) 394 struct binder_proc *proc, unsigned int fd, struct file *file)
387{ 395{
388 struct files_struct *files = get_files_struct(tsk); 396 struct files_struct *files = proc->files;
389 struct fdtable *fdt; 397 struct fdtable *fdt;
390 398
391 if (files == NULL) 399 if (files == NULL)
@@ -396,7 +404,6 @@ static void task_fd_install(
396 BUG_ON(fdt->fd[fd] != NULL); 404 BUG_ON(fdt->fd[fd] != NULL);
397 rcu_assign_pointer(fdt->fd[fd], file); 405 rcu_assign_pointer(fdt->fd[fd], file);
398 spin_unlock(&files->file_lock); 406 spin_unlock(&files->file_lock);
399 put_files_struct(files);
400} 407}
401 408
402/* 409/*
@@ -413,10 +420,10 @@ static void __put_unused_fd(struct files_struct *files, unsigned int fd)
413/* 420/*
414 * copied from sys_close 421 * copied from sys_close
415 */ 422 */
416static long task_close_fd(struct task_struct *tsk, unsigned int fd) 423static long task_close_fd(struct binder_proc *proc, unsigned int fd)
417{ 424{
418 struct file *filp; 425 struct file *filp;
419 struct files_struct *files = get_files_struct(tsk); 426 struct files_struct *files = proc->files;
420 struct fdtable *fdt; 427 struct fdtable *fdt;
421 int retval; 428 int retval;
422 429
@@ -443,12 +450,10 @@ static long task_close_fd(struct task_struct *tsk, unsigned int fd)
443 retval == -ERESTART_RESTARTBLOCK)) 450 retval == -ERESTART_RESTARTBLOCK))
444 retval = -EINTR; 451 retval = -EINTR;
445 452
446 put_files_struct(files);
447 return retval; 453 return retval;
448 454
449out_unlock: 455out_unlock:
450 spin_unlock(&files->file_lock); 456 spin_unlock(&files->file_lock);
451 put_files_struct(files);
452 return -EBADF; 457 return -EBADF;
453} 458}
454 459
@@ -618,7 +623,8 @@ static int binder_update_page_range(struct binder_proc *proc, int allocate,
618 proc->pid, page_addr); 623 proc->pid, page_addr);
619 goto err_map_kernel_failed; 624 goto err_map_kernel_failed;
620 } 625 }
621 user_page_addr = (size_t)page_addr + proc->user_buffer_offset; 626 user_page_addr =
627 (uintptr_t)page_addr + proc->user_buffer_offset;
622 ret = vm_insert_page(vma, user_page_addr, page[0]); 628 ret = vm_insert_page(vma, user_page_addr, page[0]);
623 if (ret) { 629 if (ret) {
624 printk(KERN_ERR "binder: %d: binder_alloc_buf failed " 630 printk(KERN_ERR "binder: %d: binder_alloc_buf failed "
@@ -639,7 +645,7 @@ free_range:
639 page_addr -= PAGE_SIZE) { 645 page_addr -= PAGE_SIZE) {
640 page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE]; 646 page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];
641 if (vma) 647 if (vma)
642 zap_page_range(vma, (size_t)page_addr + 648 zap_page_range(vma, (uintptr_t)page_addr +
643 proc->user_buffer_offset, PAGE_SIZE, NULL); 649 proc->user_buffer_offset, PAGE_SIZE, NULL);
644err_vm_insert_page_failed: 650err_vm_insert_page_failed:
645 unmap_kernel_range((unsigned long)page_addr, PAGE_SIZE); 651 unmap_kernel_range((unsigned long)page_addr, PAGE_SIZE);
@@ -720,18 +726,19 @@ static struct binder_buffer *binder_alloc_buf(struct binder_proc *proc,
720 "er %p size %zd\n", proc->pid, size, buffer, buffer_size); 726 "er %p size %zd\n", proc->pid, size, buffer, buffer_size);
721 727
722 has_page_addr = 728 has_page_addr =
723 (void *)(((size_t)buffer->data + buffer_size) & PAGE_MASK); 729 (void *)(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK);
724 if (n == NULL) { 730 if (n == NULL) {
725 if (size + sizeof(struct binder_buffer) + 4 >= buffer_size) 731 if (size + sizeof(struct binder_buffer) + 4 >= buffer_size)
726 buffer_size = size; /* no room for other buffers */ 732 buffer_size = size; /* no room for other buffers */
727 else 733 else
728 buffer_size = size + sizeof(struct binder_buffer); 734 buffer_size = size + sizeof(struct binder_buffer);
729 } 735 }
730 end_page_addr = (void *)PAGE_ALIGN((size_t)buffer->data + buffer_size); 736 end_page_addr =
737 (void *)PAGE_ALIGN((uintptr_t)buffer->data + buffer_size);
731 if (end_page_addr > has_page_addr) 738 if (end_page_addr > has_page_addr)
732 end_page_addr = has_page_addr; 739 end_page_addr = has_page_addr;
733 if (binder_update_page_range(proc, 1, 740 if (binder_update_page_range(proc, 1,
734 (void *)PAGE_ALIGN((size_t)buffer->data), end_page_addr, NULL)) 741 (void *)PAGE_ALIGN((uintptr_t)buffer->data), end_page_addr, NULL))
735 return NULL; 742 return NULL;
736 743
737 rb_erase(best_fit, &proc->free_buffers); 744 rb_erase(best_fit, &proc->free_buffers);
@@ -762,12 +769,12 @@ static struct binder_buffer *binder_alloc_buf(struct binder_proc *proc,
762 769
763static void *buffer_start_page(struct binder_buffer *buffer) 770static void *buffer_start_page(struct binder_buffer *buffer)
764{ 771{
765 return (void *)((size_t)buffer & PAGE_MASK); 772 return (void *)((uintptr_t)buffer & PAGE_MASK);
766} 773}
767 774
768static void *buffer_end_page(struct binder_buffer *buffer) 775static void *buffer_end_page(struct binder_buffer *buffer)
769{ 776{
770 return (void *)(((size_t)(buffer + 1) - 1) & PAGE_MASK); 777 return (void *)(((uintptr_t)(buffer + 1) - 1) & PAGE_MASK);
771} 778}
772 779
773static void binder_delete_free_buffer( 780static void binder_delete_free_buffer(
@@ -845,8 +852,8 @@ static void binder_free_buf(
845 } 852 }
846 853
847 binder_update_page_range(proc, 0, 854 binder_update_page_range(proc, 0,
848 (void *)PAGE_ALIGN((size_t)buffer->data), 855 (void *)PAGE_ALIGN((uintptr_t)buffer->data),
849 (void *)(((size_t)buffer->data + buffer_size) & PAGE_MASK), 856 (void *)(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK),
850 NULL); 857 NULL);
851 rb_erase(&buffer->rb_node, &proc->allocated_buffers); 858 rb_erase(&buffer->rb_node, &proc->allocated_buffers);
852 buffer->free = 1; 859 buffer->free = 1;
@@ -1345,6 +1352,17 @@ binder_transaction(struct binder_proc *proc, struct binder_thread *thread,
1345 if (!(tr->flags & TF_ONE_WAY) && thread->transaction_stack) { 1352 if (!(tr->flags & TF_ONE_WAY) && thread->transaction_stack) {
1346 struct binder_transaction *tmp; 1353 struct binder_transaction *tmp;
1347 tmp = thread->transaction_stack; 1354 tmp = thread->transaction_stack;
1355 if (tmp->to_thread != thread) {
1356 binder_user_error("binder: %d:%d got new "
1357 "transaction with bad transaction stack"
1358 ", transaction %d has target %d:%d\n",
1359 proc->pid, thread->pid, tmp->debug_id,
1360 tmp->to_proc ? tmp->to_proc->pid : 0,
1361 tmp->to_thread ?
1362 tmp->to_thread->pid : 0);
1363 return_error = BR_FAILED_REPLY;
1364 goto err_bad_call_stack;
1365 }
1348 while (tmp) { 1366 while (tmp) {
1349 if (tmp->from && tmp->from->proc == target_proc) 1367 if (tmp->from && tmp->from->proc == target_proc)
1350 target_thread = tmp->from; 1368 target_thread = tmp->from;
@@ -1434,10 +1452,19 @@ binder_transaction(struct binder_proc *proc, struct binder_thread *thread,
1434 return_error = BR_FAILED_REPLY; 1452 return_error = BR_FAILED_REPLY;
1435 goto err_copy_data_failed; 1453 goto err_copy_data_failed;
1436 } 1454 }
1455 if (!IS_ALIGNED(tr->offsets_size, sizeof(size_t))) {
1456 binder_user_error("binder: %d:%d got transaction with "
1457 "invalid offsets size, %zd\n",
1458 proc->pid, thread->pid, tr->offsets_size);
1459 return_error = BR_FAILED_REPLY;
1460 goto err_bad_offset;
1461 }
1437 off_end = (void *)offp + tr->offsets_size; 1462 off_end = (void *)offp + tr->offsets_size;
1438 for (; offp < off_end; offp++) { 1463 for (; offp < off_end; offp++) {
1439 struct flat_binder_object *fp; 1464 struct flat_binder_object *fp;
1440 if (*offp > t->buffer->data_size - sizeof(*fp)) { 1465 if (*offp > t->buffer->data_size - sizeof(*fp) ||
1466 t->buffer->data_size < sizeof(*fp) ||
1467 !IS_ALIGNED(*offp, sizeof(void *))) {
1441 binder_user_error("binder: %d:%d got transaction with " 1468 binder_user_error("binder: %d:%d got transaction with "
1442 "invalid offset, %zd\n", 1469 "invalid offset, %zd\n",
1443 proc->pid, thread->pid, *offp); 1470 proc->pid, thread->pid, *offp);
@@ -1544,13 +1571,13 @@ binder_transaction(struct binder_proc *proc, struct binder_thread *thread,
1544 return_error = BR_FAILED_REPLY; 1571 return_error = BR_FAILED_REPLY;
1545 goto err_fget_failed; 1572 goto err_fget_failed;
1546 } 1573 }
1547 target_fd = task_get_unused_fd_flags(target_proc->tsk, O_CLOEXEC); 1574 target_fd = task_get_unused_fd_flags(target_proc, O_CLOEXEC);
1548 if (target_fd < 0) { 1575 if (target_fd < 0) {
1549 fput(file); 1576 fput(file);
1550 return_error = BR_FAILED_REPLY; 1577 return_error = BR_FAILED_REPLY;
1551 goto err_get_unused_fd_failed; 1578 goto err_get_unused_fd_failed;
1552 } 1579 }
1553 task_fd_install(target_proc->tsk, target_fd, file); 1580 task_fd_install(target_proc, target_fd, file);
1554 if (binder_debug_mask & BINDER_DEBUG_TRANSACTION) 1581 if (binder_debug_mask & BINDER_DEBUG_TRANSACTION)
1555 printk(KERN_INFO " fd %ld -> %d\n", fp->handle, target_fd); 1582 printk(KERN_INFO " fd %ld -> %d\n", fp->handle, target_fd);
1556 /* TODO: fput? */ 1583 /* TODO: fput? */
@@ -1655,7 +1682,9 @@ binder_transaction_buffer_release(struct binder_proc *proc, struct binder_buffer
1655 off_end = (void *)offp + buffer->offsets_size; 1682 off_end = (void *)offp + buffer->offsets_size;
1656 for (; offp < off_end; offp++) { 1683 for (; offp < off_end; offp++) {
1657 struct flat_binder_object *fp; 1684 struct flat_binder_object *fp;
1658 if (*offp > buffer->data_size - sizeof(*fp)) { 1685 if (*offp > buffer->data_size - sizeof(*fp) ||
1686 buffer->data_size < sizeof(*fp) ||
1687 !IS_ALIGNED(*offp, sizeof(void *))) {
1659 printk(KERN_ERR "binder: transaction release %d bad" 1688 printk(KERN_ERR "binder: transaction release %d bad"
1660 "offset %zd, size %zd\n", debug_id, *offp, buffer->data_size); 1689 "offset %zd, size %zd\n", debug_id, *offp, buffer->data_size);
1661 continue; 1690 continue;
@@ -1691,7 +1720,7 @@ binder_transaction_buffer_release(struct binder_proc *proc, struct binder_buffer
1691 if (binder_debug_mask & BINDER_DEBUG_TRANSACTION) 1720 if (binder_debug_mask & BINDER_DEBUG_TRANSACTION)
1692 printk(KERN_INFO " fd %ld\n", fp->handle); 1721 printk(KERN_INFO " fd %ld\n", fp->handle);
1693 if (failed_at) 1722 if (failed_at)
1694 task_close_fd(proc->tsk, fp->handle); 1723 task_close_fd(proc, fp->handle);
1695 break; 1724 break;
1696 1725
1697 default: 1726 default:
@@ -2340,7 +2369,7 @@ retry:
2340 2369
2341 tr.data_size = t->buffer->data_size; 2370 tr.data_size = t->buffer->data_size;
2342 tr.offsets_size = t->buffer->offsets_size; 2371 tr.offsets_size = t->buffer->offsets_size;
2343 tr.data.ptr.buffer = (void *)((void *)t->buffer->data + proc->user_buffer_offset); 2372 tr.data.ptr.buffer = (void *)t->buffer->data + proc->user_buffer_offset;
2344 tr.data.ptr.offsets = tr.data.ptr.buffer + ALIGN(t->buffer->data_size, sizeof(void *)); 2373 tr.data.ptr.offsets = tr.data.ptr.buffer + ALIGN(t->buffer->data_size, sizeof(void *));
2345 2374
2346 if (put_user(cmd, (uint32_t __user *)ptr)) 2375 if (put_user(cmd, (uint32_t __user *)ptr))
@@ -2656,6 +2685,7 @@ static void binder_vma_open(struct vm_area_struct *vma)
2656 (unsigned long)pgprot_val(vma->vm_page_prot)); 2685 (unsigned long)pgprot_val(vma->vm_page_prot));
2657 dump_stack(); 2686 dump_stack();
2658} 2687}
2688
2659static void binder_vma_close(struct vm_area_struct *vma) 2689static void binder_vma_close(struct vm_area_struct *vma)
2660{ 2690{
2661 struct binder_proc *proc = vma->vm_private_data; 2691 struct binder_proc *proc = vma->vm_private_data;
@@ -2666,6 +2696,7 @@ static void binder_vma_close(struct vm_area_struct *vma)
2666 (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags, 2696 (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags,
2667 (unsigned long)pgprot_val(vma->vm_page_prot)); 2697 (unsigned long)pgprot_val(vma->vm_page_prot));
2668 proc->vma = NULL; 2698 proc->vma = NULL;
2699 binder_defer_work(proc, BINDER_DEFERRED_PUT_FILES);
2669} 2700}
2670 2701
2671static struct vm_operations_struct binder_vm_ops = { 2702static struct vm_operations_struct binder_vm_ops = {
@@ -2698,6 +2729,12 @@ static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
2698 } 2729 }
2699 vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE; 2730 vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE;
2700 2731
2732 if (proc->buffer) {
2733 ret = -EBUSY;
2734 failure_string = "already mapped";
2735 goto err_already_mapped;
2736 }
2737
2701 area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP); 2738 area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP);
2702 if (area == NULL) { 2739 if (area == NULL) {
2703 ret = -ENOMEM; 2740 ret = -ENOMEM;
@@ -2705,7 +2742,7 @@ static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
2705 goto err_get_vm_area_failed; 2742 goto err_get_vm_area_failed;
2706 } 2743 }
2707 proc->buffer = area->addr; 2744 proc->buffer = area->addr;
2708 proc->user_buffer_offset = vma->vm_start - (size_t)proc->buffer; 2745 proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;
2709 2746
2710#ifdef CONFIG_CPU_CACHE_VIPT 2747#ifdef CONFIG_CPU_CACHE_VIPT
2711 if (cache_is_vipt_aliasing()) { 2748 if (cache_is_vipt_aliasing()) {
@@ -2738,6 +2775,7 @@ static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
2738 binder_insert_free_buffer(proc, buffer); 2775 binder_insert_free_buffer(proc, buffer);
2739 proc->free_async_space = proc->buffer_size / 2; 2776 proc->free_async_space = proc->buffer_size / 2;
2740 barrier(); 2777 barrier();
2778 proc->files = get_files_struct(current);
2741 proc->vma = vma; 2779 proc->vma = vma;
2742 2780
2743 /*printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/ 2781 /*printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/
@@ -2745,10 +2783,12 @@ static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
2745 2783
2746err_alloc_small_buf_failed: 2784err_alloc_small_buf_failed:
2747 kfree(proc->pages); 2785 kfree(proc->pages);
2786 proc->pages = NULL;
2748err_alloc_pages_failed: 2787err_alloc_pages_failed:
2749 vfree(proc->buffer); 2788 vfree(proc->buffer);
2789 proc->buffer = NULL;
2750err_get_vm_area_failed: 2790err_get_vm_area_failed:
2751 mutex_unlock(&binder_lock); 2791err_already_mapped:
2752err_bad_arg: 2792err_bad_arg:
2753 printk(KERN_ERR "binder_mmap: %d %lx-%lx %s failed %d\n", proc->pid, vma->vm_start, vma->vm_end, failure_string, ret); 2793 printk(KERN_ERR "binder_mmap: %d %lx-%lx %s failed %d\n", proc->pid, vma->vm_start, vma->vm_end, failure_string, ret);
2754 return ret; 2794 return ret;
@@ -2780,6 +2820,7 @@ static int binder_open(struct inode *nodp, struct file *filp)
2780 if (binder_proc_dir_entry_proc) { 2820 if (binder_proc_dir_entry_proc) {
2781 char strbuf[11]; 2821 char strbuf[11];
2782 snprintf(strbuf, sizeof(strbuf), "%u", proc->pid); 2822 snprintf(strbuf, sizeof(strbuf), "%u", proc->pid);
2823 remove_proc_entry(strbuf, binder_proc_dir_entry_proc);
2783 create_proc_read_entry(strbuf, S_IRUGO, binder_proc_dir_entry_proc, binder_read_proc_proc, proc); 2824 create_proc_read_entry(strbuf, S_IRUGO, binder_proc_dir_entry_proc, binder_read_proc_proc, proc);
2784 } 2825 }
2785 2826
@@ -2788,11 +2829,17 @@ static int binder_open(struct inode *nodp, struct file *filp)
2788 2829
2789static int binder_flush(struct file *filp, fl_owner_t id) 2830static int binder_flush(struct file *filp, fl_owner_t id)
2790{ 2831{
2791 struct rb_node *n;
2792 struct binder_proc *proc = filp->private_data; 2832 struct binder_proc *proc = filp->private_data;
2793 int wake_count = 0;
2794 2833
2795 mutex_lock(&binder_lock); 2834 binder_defer_work(proc, BINDER_DEFERRED_FLUSH);
2835
2836 return 0;
2837}
2838
2839static void binder_deferred_flush(struct binder_proc *proc)
2840{
2841 struct rb_node *n;
2842 int wake_count = 0;
2796 for (n = rb_first(&proc->threads); n != NULL; n = rb_next(n)) { 2843 for (n = rb_first(&proc->threads); n != NULL; n = rb_next(n)) {
2797 struct binder_thread *thread = rb_entry(n, struct binder_thread, rb_node); 2844 struct binder_thread *thread = rb_entry(n, struct binder_thread, rb_node);
2798 thread->looper |= BINDER_LOOPER_STATE_NEED_RETURN; 2845 thread->looper |= BINDER_LOOPER_STATE_NEED_RETURN;
@@ -2802,28 +2849,35 @@ static int binder_flush(struct file *filp, fl_owner_t id)
2802 } 2849 }
2803 } 2850 }
2804 wake_up_interruptible_all(&proc->wait); 2851 wake_up_interruptible_all(&proc->wait);
2805 mutex_unlock(&binder_lock);
2806 2852
2807 if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE) 2853 if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)
2808 printk(KERN_INFO "binder_flush: %d woke %d threads\n", proc->pid, wake_count); 2854 printk(KERN_INFO "binder_flush: %d woke %d threads\n", proc->pid, wake_count);
2809
2810 return 0;
2811} 2855}
2812 2856
2813static int binder_release(struct inode *nodp, struct file *filp) 2857static int binder_release(struct inode *nodp, struct file *filp)
2814{ 2858{
2815 struct hlist_node *pos;
2816 struct binder_transaction *t;
2817 struct rb_node *n;
2818 struct binder_proc *proc = filp->private_data; 2859 struct binder_proc *proc = filp->private_data;
2819 int threads, nodes, incoming_refs, outgoing_refs, buffers, active_transactions, page_count;
2820
2821 if (binder_proc_dir_entry_proc) { 2860 if (binder_proc_dir_entry_proc) {
2822 char strbuf[11]; 2861 char strbuf[11];
2823 snprintf(strbuf, sizeof(strbuf), "%u", proc->pid); 2862 snprintf(strbuf, sizeof(strbuf), "%u", proc->pid);
2824 remove_proc_entry(strbuf, binder_proc_dir_entry_proc); 2863 remove_proc_entry(strbuf, binder_proc_dir_entry_proc);
2825 } 2864 }
2826 mutex_lock(&binder_lock); 2865
2866 binder_defer_work(proc, BINDER_DEFERRED_RELEASE);
2867
2868 return 0;
2869}
2870
2871static void binder_deferred_release(struct binder_proc *proc)
2872{
2873 struct hlist_node *pos;
2874 struct binder_transaction *t;
2875 struct rb_node *n;
2876 int threads, nodes, incoming_refs, outgoing_refs, buffers, active_transactions, page_count;
2877
2878 BUG_ON(proc->vma);
2879 BUG_ON(proc->files);
2880
2827 hlist_del(&proc->proc_node); 2881 hlist_del(&proc->proc_node);
2828 if (binder_context_mgr_node && binder_context_mgr_node->proc == proc) { 2882 if (binder_context_mgr_node && binder_context_mgr_node->proc == proc) {
2829 if (binder_debug_mask & BINDER_DEBUG_DEAD_BINDER) 2883 if (binder_debug_mask & BINDER_DEBUG_DEAD_BINDER)
@@ -2897,7 +2951,6 @@ static int binder_release(struct inode *nodp, struct file *filp)
2897 } 2951 }
2898 2952
2899 binder_stats.obj_deleted[BINDER_STAT_PROC]++; 2953 binder_stats.obj_deleted[BINDER_STAT_PROC]++;
2900 mutex_unlock(&binder_lock);
2901 2954
2902 page_count = 0; 2955 page_count = 0;
2903 if (proc->pages) { 2956 if (proc->pages) {
@@ -2921,7 +2974,57 @@ static int binder_release(struct inode *nodp, struct file *filp)
2921 proc->pid, threads, nodes, incoming_refs, outgoing_refs, active_transactions, buffers, page_count); 2974 proc->pid, threads, nodes, incoming_refs, outgoing_refs, active_transactions, buffers, page_count);
2922 2975
2923 kfree(proc); 2976 kfree(proc);
2924 return 0; 2977}
2978
2979static void binder_deferred_func(struct work_struct *work)
2980{
2981 struct binder_proc *proc;
2982 struct files_struct *files;
2983
2984 int defer;
2985 do {
2986 mutex_lock(&binder_lock);
2987 mutex_lock(&binder_deferred_lock);
2988 if (!hlist_empty(&binder_deferred_list)) {
2989 proc = hlist_entry(binder_deferred_list.first,
2990 struct binder_proc, deferred_work_node);
2991 hlist_del_init(&proc->deferred_work_node);
2992 defer = proc->deferred_work;
2993 proc->deferred_work = 0;
2994 } else {
2995 proc = NULL;
2996 defer = 0;
2997 }
2998 mutex_unlock(&binder_deferred_lock);
2999
3000 files = NULL;
3001 if (defer & BINDER_DEFERRED_PUT_FILES)
3002 if ((files = proc->files))
3003 proc->files = NULL;
3004
3005 if (defer & BINDER_DEFERRED_FLUSH)
3006 binder_deferred_flush(proc);
3007
3008 if (defer & BINDER_DEFERRED_RELEASE)
3009 binder_deferred_release(proc); /* frees proc */
3010
3011 mutex_unlock(&binder_lock);
3012 if (files)
3013 put_files_struct(files);
3014 } while (proc);
3015}
3016static DECLARE_WORK(binder_deferred_work, binder_deferred_func);
3017
3018static void binder_defer_work(struct binder_proc *proc, int defer)
3019{
3020 mutex_lock(&binder_deferred_lock);
3021 proc->deferred_work |= defer;
3022 if (hlist_unhashed(&proc->deferred_work_node)) {
3023 hlist_add_head(&proc->deferred_work_node,
3024 &binder_deferred_list);
3025 schedule_work(&binder_deferred_work);
3026 }
3027 mutex_unlock(&binder_deferred_lock);
2925} 3028}
2926 3029
2927static char *print_binder_transaction(char *buf, char *end, const char *prefix, struct binder_transaction *t) 3030static char *print_binder_transaction(char *buf, char *end, const char *prefix, struct binder_transaction *t)
diff --git a/drivers/staging/at76_usb/at76_usb.c b/drivers/staging/at76_usb/at76_usb.c
index 6f6e36a3bd9f..c8af9a868d62 100644
--- a/drivers/staging/at76_usb/at76_usb.c
+++ b/drivers/staging/at76_usb/at76_usb.c
@@ -5259,6 +5259,18 @@ static int at76_alloc_urbs(struct at76_priv *priv,
5259 return 0; 5259 return 0;
5260} 5260}
5261 5261
5262static const struct net_device_ops at76_netdev_ops = {
5263 .ndo_open = at76_open,
5264 .ndo_stop = at76_stop,
5265 .ndo_get_stats = at76_get_stats,
5266 .ndo_start_xmit = at76_tx,
5267 .ndo_tx_timeout = at76_tx_timeout,
5268 .ndo_set_multicast_list = at76_set_multicast,
5269 .ndo_set_mac_address = at76_set_mac_address,
5270 .ndo_validate_addr = eth_validate_addr,
5271 .ndo_change_mtu = eth_change_mtu,
5272};
5273
5262/* Register network device and initialize the hardware */ 5274/* Register network device and initialize the hardware */
5263static int at76_init_new_device(struct at76_priv *priv, 5275static int at76_init_new_device(struct at76_priv *priv,
5264 struct usb_interface *interface) 5276 struct usb_interface *interface)
@@ -5303,21 +5315,15 @@ static int at76_init_new_device(struct at76_priv *priv,
5303 priv->scan_mode = SCAN_TYPE_ACTIVE; 5315 priv->scan_mode = SCAN_TYPE_ACTIVE;
5304 5316
5305 netdev->flags &= ~IFF_MULTICAST; /* not yet or never */ 5317 netdev->flags &= ~IFF_MULTICAST; /* not yet or never */
5306 netdev->open = at76_open; 5318 netdev->netdev_ops = &at76_netdev_ops;
5307 netdev->stop = at76_stop;
5308 netdev->get_stats = at76_get_stats;
5309 netdev->ethtool_ops = &at76_ethtool_ops; 5319 netdev->ethtool_ops = &at76_ethtool_ops;
5310 5320
5311 /* Add pointers to enable iwspy support. */ 5321 /* Add pointers to enable iwspy support. */
5312 priv->wireless_data.spy_data = &priv->spy_data; 5322 priv->wireless_data.spy_data = &priv->spy_data;
5313 netdev->wireless_data = &priv->wireless_data; 5323 netdev->wireless_data = &priv->wireless_data;
5314 5324
5315 netdev->hard_start_xmit = at76_tx;
5316 netdev->tx_timeout = at76_tx_timeout;
5317 netdev->watchdog_timeo = 2 * HZ; 5325 netdev->watchdog_timeo = 2 * HZ;
5318 netdev->wireless_handlers = &at76_handler_def; 5326 netdev->wireless_handlers = &at76_handler_def;
5319 netdev->set_multicast_list = at76_set_multicast;
5320 netdev->set_mac_address = at76_set_mac_address;
5321 dev_alloc_name(netdev, "wlan%d"); 5327 dev_alloc_name(netdev, "wlan%d");
5322 5328
5323 ret = register_netdev(priv->netdev); 5329 ret = register_netdev(priv->netdev);
diff --git a/drivers/staging/b3dfg/b3dfg.c b/drivers/staging/b3dfg/b3dfg.c
index 0348072b3ab5..75ebe338c6f2 100644
--- a/drivers/staging/b3dfg/b3dfg.c
+++ b/drivers/staging/b3dfg/b3dfg.c
@@ -1000,7 +1000,7 @@ static int __devinit b3dfg_probe(struct pci_dev *pdev,
1000 1000
1001 pci_set_master(pdev); 1001 pci_set_master(pdev);
1002 1002
1003 r = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 1003 r = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1004 if (r) { 1004 if (r) {
1005 dev_err(&pdev->dev, "no usable DMA configuration\n"); 1005 dev_err(&pdev->dev, "no usable DMA configuration\n");
1006 goto err_free_res; 1006 goto err_free_res;
diff --git a/drivers/staging/epl/VirtualEthernetLinux.c b/drivers/staging/epl/VirtualEthernetLinux.c
index 21206c4d22ff..077724a556cc 100644
--- a/drivers/staging/epl/VirtualEthernetLinux.c
+++ b/drivers/staging/epl/VirtualEthernetLinux.c
@@ -284,6 +284,17 @@ static tEplKernel VEthRecvFrame(tEplFrameInfo * pFrameInfo_p)
284 return Ret; 284 return Ret;
285} 285}
286 286
287static const struct net_device_ops epl_netdev_ops = {
288 .ndo_open = VEthOpen,
289 .ndo_stop = VEthClose,
290 .ndo_get_stats = VEthGetStats,
291 .ndo_start_xmit = VEthXmit,
292 .ndo_tx_timeout = VEthTimeout,
293 .ndo_change_mtu = eth_change_mtu,
294 .ndo_set_mac_address = eth_mac_addr,
295 .ndo_validate_addr = eth_validate_addr,
296};
297
287tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p) 298tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p)
288{ 299{
289 tEplKernel Ret = kEplSuccessful; 300 tEplKernel Ret = kEplSuccessful;
@@ -299,11 +310,7 @@ tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p)
299 goto Exit; 310 goto Exit;
300 } 311 }
301 312
302 pVEthNetDevice_g->open = VEthOpen; 313 pVEthNetDevice_g->netdev_ops = &epl_netdev_ops;
303 pVEthNetDevice_g->stop = VEthClose;
304 pVEthNetDevice_g->get_stats = VEthGetStats;
305 pVEthNetDevice_g->hard_start_xmit = VEthXmit;
306 pVEthNetDevice_g->tx_timeout = VEthTimeout;
307 pVEthNetDevice_g->watchdog_timeo = EPL_VETH_TX_TIMEOUT; 314 pVEthNetDevice_g->watchdog_timeo = EPL_VETH_TX_TIMEOUT;
308 pVEthNetDevice_g->destructor = free_netdev; 315 pVEthNetDevice_g->destructor = free_netdev;
309 316
diff --git a/drivers/staging/et131x/et131x_netdev.c b/drivers/staging/et131x/et131x_netdev.c
index de65972ff362..951c73d5db20 100644
--- a/drivers/staging/et131x/et131x_netdev.c
+++ b/drivers/staging/et131x/et131x_netdev.c
@@ -112,6 +112,19 @@ void et131x_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
112void et131x_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid); 112void et131x_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
113void et131x_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid); 113void et131x_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
114 114
115static const struct net_device_ops et131x_netdev_ops = {
116 .ndo_open = et131x_open,
117 .ndo_stop = et131x_close,
118 .ndo_start_xmit = et131x_tx,
119 .ndo_set_multicast_list = et131x_multicast,
120 .ndo_tx_timeout = et131x_tx_timeout,
121 .ndo_change_mtu = et131x_change_mtu,
122 .ndo_set_mac_address = et131x_set_mac_addr,
123 .ndo_validate_addr = eth_validate_addr,
124 .ndo_get_stats = et131x_stats,
125 .ndo_do_ioctl = et131x_ioctl,
126};
127
115/** 128/**
116 * et131x_device_alloc 129 * et131x_device_alloc
117 * 130 *
@@ -142,16 +155,8 @@ struct net_device *et131x_device_alloc(void)
142 */ 155 */
143 //netdev->init = &et131x_init; 156 //netdev->init = &et131x_init;
144 //netdev->set_config = &et131x_config; 157 //netdev->set_config = &et131x_config;
145 netdev->get_stats = &et131x_stats;
146 netdev->open = &et131x_open;
147 netdev->stop = &et131x_close;
148 netdev->do_ioctl = &et131x_ioctl;
149 netdev->set_multicast_list = &et131x_multicast;
150 netdev->hard_start_xmit = &et131x_tx;
151 netdev->tx_timeout = &et131x_tx_timeout;
152 netdev->watchdog_timeo = ET131X_TX_TIMEOUT; 158 netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
153 netdev->change_mtu = &et131x_change_mtu; 159 netdev->netdev_ops = &et131x_netdev_ops;
154 netdev->set_mac_address = &et131x_set_mac_addr;
155 160
156 //netdev->ethtool_ops = &et131x_ethtool_ops; 161 //netdev->ethtool_ops = &et131x_ethtool_ops;
157 162
diff --git a/drivers/staging/go7007/go7007-driver.c b/drivers/staging/go7007/go7007-driver.c
index 58bfc8d81b3b..77b1e769ac92 100644
--- a/drivers/staging/go7007/go7007-driver.c
+++ b/drivers/staging/go7007/go7007-driver.c
@@ -191,8 +191,10 @@ int go7007_reset_encoder(struct go7007 *go)
191/* 191/*
192 * Attempt to instantiate an I2C client by ID, probably loading a module. 192 * Attempt to instantiate an I2C client by ID, probably loading a module.
193 */ 193 */
194static int init_i2c_module(struct i2c_adapter *adapter, int id, int addr) 194static int init_i2c_module(struct i2c_adapter *adapter, const char *type,
195 int id, int addr)
195{ 196{
197 struct i2c_board_info info;
196 char *modname; 198 char *modname;
197 199
198 switch (id) { 200 switch (id) {
@@ -226,7 +228,11 @@ static int init_i2c_module(struct i2c_adapter *adapter, int id, int addr)
226 } 228 }
227 if (modname != NULL) 229 if (modname != NULL)
228 request_module(modname); 230 request_module(modname);
229 if (wis_i2c_probe_device(adapter, id, addr) == 1) 231
232 memset(&info, 0, sizeof(struct i2c_board_info));
233 info.addr = addr;
234 strlcpy(info.type, type, I2C_NAME_SIZE);
235 if (!i2c_new_device(adapter, &info))
230 return 0; 236 return 0;
231 if (modname != NULL) 237 if (modname != NULL)
232 printk(KERN_INFO 238 printk(KERN_INFO
@@ -266,23 +272,9 @@ int go7007_register_encoder(struct go7007 *go)
266 if (go->i2c_adapter_online) { 272 if (go->i2c_adapter_online) {
267 for (i = 0; i < go->board_info->num_i2c_devs; ++i) 273 for (i = 0; i < go->board_info->num_i2c_devs; ++i)
268 init_i2c_module(&go->i2c_adapter, 274 init_i2c_module(&go->i2c_adapter,
275 go->board_info->i2c_devs[i].type,
269 go->board_info->i2c_devs[i].id, 276 go->board_info->i2c_devs[i].id,
270 go->board_info->i2c_devs[i].addr); 277 go->board_info->i2c_devs[i].addr);
271#ifdef TUNER_SET_TYPE_ADDR
272 if (go->tuner_type >= 0) {
273 struct tuner_setup tun_setup = {
274 .mode_mask = T_ANALOG_TV,
275 .addr = ADDR_UNSET,
276 .type = go->tuner_type
277 };
278 i2c_clients_command(&go->i2c_adapter,
279 TUNER_SET_TYPE_ADDR, &tun_setup);
280 }
281#else
282 if (go->tuner_type >= 0)
283 i2c_clients_command(&go->i2c_adapter,
284 TUNER_SET_TYPE, &go->tuner_type);
285#endif
286 if (go->board_id == GO7007_BOARDID_ADLINK_MPG24) 278 if (go->board_id == GO7007_BOARDID_ADLINK_MPG24)
287 i2c_clients_command(&go->i2c_adapter, 279 i2c_clients_command(&go->i2c_adapter,
288 DECODER_SET_CHANNEL, &go->channel_number); 280 DECODER_SET_CHANNEL, &go->channel_number);
diff --git a/drivers/staging/go7007/go7007-i2c.c b/drivers/staging/go7007/go7007-i2c.c
index cd55b76eabc7..c82867fdd28d 100644
--- a/drivers/staging/go7007/go7007-i2c.c
+++ b/drivers/staging/go7007/go7007-i2c.c
@@ -31,87 +31,6 @@
31#include "go7007-priv.h" 31#include "go7007-priv.h"
32#include "wis-i2c.h" 32#include "wis-i2c.h"
33 33
34/************** Registration interface for I2C client drivers **************/
35
36/* Since there's no way to auto-probe the I2C devices connected to the I2C
37 * bus on the go7007, we have this silly little registration system that
38 * client drivers can use to register their I2C driver ID and their
39 * detect_client function (the one that's normally passed to i2c_probe).
40 *
41 * When a new go7007 device is connected, we can look up in a board info
42 * table by the USB or PCI vendor/product/revision ID to determine
43 * which I2C client module to load. The client driver module will register
44 * itself here, and then we can call the registered detect_client function
45 * to force-load a new client at the address listed in the board info table.
46 *
47 * Really the I2C subsystem should have a way to force-load I2C client
48 * drivers when we have a priori knowledge of what's on the bus, especially
49 * since the existing I2C auto-probe mechanism is so hokey, but we'll use
50 * our own mechanism for the time being. */
51
52struct wis_i2c_client_driver {
53 unsigned int id;
54 found_proc found_proc;
55 struct list_head list;
56};
57
58static LIST_HEAD(i2c_client_drivers);
59static DECLARE_MUTEX(i2c_client_driver_list_lock);
60
61/* Client drivers register here by their I2C driver ID */
62int wis_i2c_add_driver(unsigned int id, found_proc found_proc)
63{
64 struct wis_i2c_client_driver *driver;
65
66 driver = kmalloc(sizeof(struct wis_i2c_client_driver), GFP_KERNEL);
67 if (driver == NULL)
68 return -ENOMEM;
69 driver->id = id;
70 driver->found_proc = found_proc;
71
72 down(&i2c_client_driver_list_lock);
73 list_add_tail(&driver->list, &i2c_client_drivers);
74 up(&i2c_client_driver_list_lock);
75
76 return 0;
77}
78EXPORT_SYMBOL(wis_i2c_add_driver);
79
80void wis_i2c_del_driver(found_proc found_proc)
81{
82 struct wis_i2c_client_driver *driver, *next;
83
84 down(&i2c_client_driver_list_lock);
85 list_for_each_entry_safe(driver, next, &i2c_client_drivers, list)
86 if (driver->found_proc == found_proc) {
87 list_del(&driver->list);
88 kfree(driver);
89 }
90 up(&i2c_client_driver_list_lock);
91}
92EXPORT_SYMBOL(wis_i2c_del_driver);
93
94/* The main go7007 driver calls this to instantiate a client by driver
95 * ID and bus address, which are both stored in the board info table */
96int wis_i2c_probe_device(struct i2c_adapter *adapter,
97 unsigned int id, int addr)
98{
99 struct wis_i2c_client_driver *driver;
100 int found = 0;
101
102 if (addr < 0 || addr > 0x7f)
103 return -1;
104 down(&i2c_client_driver_list_lock);
105 list_for_each_entry(driver, &i2c_client_drivers, list)
106 if (driver->id == id) {
107 if (driver->found_proc(adapter, addr, 0) == 0)
108 found = 1;
109 break;
110 }
111 up(&i2c_client_driver_list_lock);
112 return found;
113}
114
115/********************* Driver for on-board I2C adapter *********************/ 34/********************* Driver for on-board I2C adapter *********************/
116 35
117/* #define GO7007_I2C_DEBUG */ 36/* #define GO7007_I2C_DEBUG */
@@ -287,9 +206,7 @@ static struct i2c_algorithm go7007_algo = {
287 206
288static struct i2c_adapter go7007_adap_templ = { 207static struct i2c_adapter go7007_adap_templ = {
289 .owner = THIS_MODULE, 208 .owner = THIS_MODULE,
290 .class = I2C_CLASS_TV_ANALOG,
291 .name = "WIS GO7007SB", 209 .name = "WIS GO7007SB",
292 .id = I2C_ALGO_GO7007,
293 .algo = &go7007_algo, 210 .algo = &go7007_algo,
294}; 211};
295 212
diff --git a/drivers/staging/go7007/go7007-priv.h b/drivers/staging/go7007/go7007-priv.h
index 372f1f1c09b2..178d18119faa 100644
--- a/drivers/staging/go7007/go7007-priv.h
+++ b/drivers/staging/go7007/go7007-priv.h
@@ -87,6 +87,7 @@ struct go7007_board_info {
87 int audio_main_div; 87 int audio_main_div;
88 int num_i2c_devs; 88 int num_i2c_devs;
89 struct { 89 struct {
90 const char *type;
90 int id; 91 int id;
91 int addr; 92 int addr;
92 } i2c_devs[4]; 93 } i2c_devs[4];
diff --git a/drivers/staging/go7007/go7007-usb.c b/drivers/staging/go7007/go7007-usb.c
index 83eec920c7d3..aa4a9e0b9954 100644
--- a/drivers/staging/go7007/go7007-usb.c
+++ b/drivers/staging/go7007/go7007-usb.c
@@ -91,6 +91,7 @@ static struct go7007_usb_board board_matrix_ii = {
91 .num_i2c_devs = 1, 91 .num_i2c_devs = 1,
92 .i2c_devs = { 92 .i2c_devs = {
93 { 93 {
94 .type = "wis_saa7115",
94 .id = I2C_DRIVERID_WIS_SAA7115, 95 .id = I2C_DRIVERID_WIS_SAA7115,
95 .addr = 0x20, 96 .addr = 0x20,
96 }, 97 },
@@ -127,6 +128,7 @@ static struct go7007_usb_board board_matrix_reload = {
127 .num_i2c_devs = 1, 128 .num_i2c_devs = 1,
128 .i2c_devs = { 129 .i2c_devs = {
129 { 130 {
131 .type = "wis_saa7113",
130 .id = I2C_DRIVERID_WIS_SAA7113, 132 .id = I2C_DRIVERID_WIS_SAA7113,
131 .addr = 0x25, 133 .addr = 0x25,
132 }, 134 },
@@ -164,6 +166,7 @@ static struct go7007_usb_board board_star_trek = {
164 .num_i2c_devs = 1, 166 .num_i2c_devs = 1,
165 .i2c_devs = { 167 .i2c_devs = {
166 { 168 {
169 .type = "wis_saa7115",
167 .id = I2C_DRIVERID_WIS_SAA7115, 170 .id = I2C_DRIVERID_WIS_SAA7115,
168 .addr = 0x20, 171 .addr = 0x20,
169 }, 172 },
@@ -209,14 +212,17 @@ static struct go7007_usb_board board_px_tv402u = {
209 .num_i2c_devs = 3, 212 .num_i2c_devs = 3,
210 .i2c_devs = { 213 .i2c_devs = {
211 { 214 {
215 .type = "wis_saa7115",
212 .id = I2C_DRIVERID_WIS_SAA7115, 216 .id = I2C_DRIVERID_WIS_SAA7115,
213 .addr = 0x20, 217 .addr = 0x20,
214 }, 218 },
215 { 219 {
220 .type = "wis_uda1342",
216 .id = I2C_DRIVERID_WIS_UDA1342, 221 .id = I2C_DRIVERID_WIS_UDA1342,
217 .addr = 0x1a, 222 .addr = 0x1a,
218 }, 223 },
219 { 224 {
225 .type = "wis_sony_tuner",
220 .id = I2C_DRIVERID_WIS_SONY_TUNER, 226 .id = I2C_DRIVERID_WIS_SONY_TUNER,
221 .addr = 0x60, 227 .addr = 0x60,
222 }, 228 },
@@ -264,6 +270,7 @@ static struct go7007_usb_board board_xmen = {
264 .num_i2c_devs = 1, 270 .num_i2c_devs = 1,
265 .i2c_devs = { 271 .i2c_devs = {
266 { 272 {
273 .type = "wis_ov7640",
267 .id = I2C_DRIVERID_WIS_OV7640, 274 .id = I2C_DRIVERID_WIS_OV7640,
268 .addr = 0x21, 275 .addr = 0x21,
269 }, 276 },
@@ -296,6 +303,7 @@ static struct go7007_usb_board board_matrix_revolution = {
296 .num_i2c_devs = 1, 303 .num_i2c_devs = 1,
297 .i2c_devs = { 304 .i2c_devs = {
298 { 305 {
306 .type = "wis_tw9903",
299 .id = I2C_DRIVERID_WIS_TW9903, 307 .id = I2C_DRIVERID_WIS_TW9903,
300 .addr = 0x44, 308 .addr = 0x44,
301 }, 309 },
@@ -385,6 +393,7 @@ static struct go7007_usb_board board_adlink_mpg24 = {
385 .num_i2c_devs = 1, 393 .num_i2c_devs = 1,
386 .i2c_devs = { 394 .i2c_devs = {
387 { 395 {
396 .type = "wis_twTW2804",
388 .id = I2C_DRIVERID_WIS_TW2804, 397 .id = I2C_DRIVERID_WIS_TW2804,
389 .addr = 0x00, /* yes, really */ 398 .addr = 0x00, /* yes, really */
390 }, 399 },
@@ -415,8 +424,9 @@ static struct go7007_usb_board board_sensoray_2250 = {
415 .num_i2c_devs = 1, 424 .num_i2c_devs = 1,
416 .i2c_devs = { 425 .i2c_devs = {
417 { 426 {
427 .type = "s2250_board",
418 .id = I2C_DRIVERID_S2250, 428 .id = I2C_DRIVERID_S2250,
419 .addr = 0x34, 429 .addr = 0x43,
420 }, 430 },
421 }, 431 },
422 .num_inputs = 2, 432 .num_inputs = 2,
@@ -943,9 +953,7 @@ static struct i2c_algorithm go7007_usb_algo = {
943 953
944static struct i2c_adapter go7007_usb_adap_templ = { 954static struct i2c_adapter go7007_usb_adap_templ = {
945 .owner = THIS_MODULE, 955 .owner = THIS_MODULE,
946 .class = I2C_CLASS_TV_ANALOG,
947 .name = "WIS GO7007SB EZ-USB", 956 .name = "WIS GO7007SB EZ-USB",
948 .id = I2C_ALGO_GO7007_USB,
949 .algo = &go7007_usb_algo, 957 .algo = &go7007_usb_algo,
950}; 958};
951 959
diff --git a/drivers/staging/go7007/s2250-board.c b/drivers/staging/go7007/s2250-board.c
index d333ea2cd774..1706fbf06847 100644
--- a/drivers/staging/go7007/s2250-board.c
+++ b/drivers/staging/go7007/s2250-board.c
@@ -28,7 +28,6 @@ extern int s2250loader_init(void);
28extern void s2250loader_cleanup(void); 28extern void s2250loader_cleanup(void);
29 29
30#define TLV320_ADDRESS 0x34 30#define TLV320_ADDRESS 0x34
31#define S2250_VIDDEC 0x86
32#define VPX322_ADDR_ANALOGCONTROL1 0x02 31#define VPX322_ADDR_ANALOGCONTROL1 0x02
33#define VPX322_ADDR_BRIGHTNESS0 0x0127 32#define VPX322_ADDR_BRIGHTNESS0 0x0127
34#define VPX322_ADDR_BRIGHTNESS1 0x0131 33#define VPX322_ADDR_BRIGHTNESS1 0x0131
@@ -123,6 +122,7 @@ struct s2250 {
123 int hue; 122 int hue;
124 int reg12b_val; 123 int reg12b_val;
125 int audio_input; 124 int audio_input;
125 struct i2c_client *audio;
126}; 126};
127 127
128/* from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/ 128/* from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/
@@ -452,16 +452,15 @@ static int s2250_command(struct i2c_client *client,
452 { 452 {
453 struct v4l2_audio *audio = arg; 453 struct v4l2_audio *audio = arg;
454 454
455 client->addr = TLV320_ADDRESS;
456 switch (audio->index) { 455 switch (audio->index) {
457 case 0: 456 case 0:
458 write_reg(client, 0x08, 0x02); /* Line In */ 457 write_reg(dec->audio, 0x08, 0x02); /* Line In */
459 break; 458 break;
460 case 1: 459 case 1:
461 write_reg(client, 0x08, 0x04); /* Mic */ 460 write_reg(dec->audio, 0x08, 0x04); /* Mic */
462 break; 461 break;
463 case 2: 462 case 2:
464 write_reg(client, 0x08, 0x05); /* Mic Boost */ 463 write_reg(dec->audio, 0x08, 0x05); /* Mic Boost */
465 break; 464 break;
466 default: 465 default:
467 return -EINVAL; 466 return -EINVAL;
@@ -477,31 +476,23 @@ static int s2250_command(struct i2c_client *client,
477 return 0; 476 return 0;
478} 477}
479 478
480static struct i2c_driver s2250_driver; 479static int s2250_probe(struct i2c_client *client,
481 480 const struct i2c_device_id *id)
482static struct i2c_client s2250_client_templ = {
483 .name = "Sensoray 2250",
484 .driver = &s2250_driver,
485};
486
487static int s2250_detect(struct i2c_adapter *adapter, int addr, int kind)
488{ 481{
489 struct i2c_client *client; 482 struct i2c_client *audio;
483 struct i2c_adapter *adapter = client->adapter;
490 struct s2250 *dec; 484 struct s2250 *dec;
491 u8 *data; 485 u8 *data;
492 struct go7007 *go = i2c_get_adapdata(adapter); 486 struct go7007 *go = i2c_get_adapdata(adapter);
493 struct go7007_usb *usb = go->hpi_context; 487 struct go7007_usb *usb = go->hpi_context;
494 488
495 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); 489 audio = i2c_new_dummy(adapter, TLV320_ADDRESS >> 1);
496 if (client == NULL) 490 if (audio == NULL)
497 return -ENOMEM; 491 return -ENOMEM;
498 memcpy(client, &s2250_client_templ,
499 sizeof(s2250_client_templ));
500 client->adapter = adapter;
501 492
502 dec = kmalloc(sizeof(struct s2250), GFP_KERNEL); 493 dec = kmalloc(sizeof(struct s2250), GFP_KERNEL);
503 if (dec == NULL) { 494 if (dec == NULL) {
504 kfree(client); 495 i2c_unregister_device(audio);
505 return -ENOMEM; 496 return -ENOMEM;
506 } 497 }
507 498
@@ -510,7 +501,7 @@ static int s2250_detect(struct i2c_adapter *adapter, int addr, int kind)
510 dec->contrast = 50; 501 dec->contrast = 50;
511 dec->saturation = 50; 502 dec->saturation = 50;
512 dec->hue = 0; 503 dec->hue = 0;
513 client->addr = TLV320_ADDRESS; 504 dec->audio = audio;
514 i2c_set_clientdata(client, dec); 505 i2c_set_clientdata(client, dec);
515 506
516 printk(KERN_DEBUG 507 printk(KERN_DEBUG
@@ -518,28 +509,25 @@ static int s2250_detect(struct i2c_adapter *adapter, int addr, int kind)
518 adapter->name); 509 adapter->name);
519 510
520 /* initialize the audio */ 511 /* initialize the audio */
521 client->addr = TLV320_ADDRESS; 512 if (write_regs(audio, aud_regs) < 0) {
522 if (write_regs(client, aud_regs) < 0) {
523 printk(KERN_ERR 513 printk(KERN_ERR
524 "s2250: error initializing audio\n"); 514 "s2250: error initializing audio\n");
525 kfree(client); 515 i2c_unregister_device(audio);
526 kfree(dec); 516 kfree(dec);
527 return 0; 517 return 0;
528 } 518 }
529 client->addr = S2250_VIDDEC;
530 i2c_set_clientdata(client, dec);
531 519
532 if (write_regs(client, vid_regs) < 0) { 520 if (write_regs(client, vid_regs) < 0) {
533 printk(KERN_ERR 521 printk(KERN_ERR
534 "s2250: error initializing decoder\n"); 522 "s2250: error initializing decoder\n");
535 kfree(client); 523 i2c_unregister_device(audio);
536 kfree(dec); 524 kfree(dec);
537 return 0; 525 return 0;
538 } 526 }
539 if (write_regs_fp(client, vid_regs_fp) < 0) { 527 if (write_regs_fp(client, vid_regs_fp) < 0) {
540 printk(KERN_ERR 528 printk(KERN_ERR
541 "s2250: error initializing decoder\n"); 529 "s2250: error initializing decoder\n");
542 kfree(client); 530 i2c_unregister_device(audio);
543 kfree(dec); 531 kfree(dec);
544 return 0; 532 return 0;
545 } 533 }
@@ -575,32 +563,33 @@ static int s2250_detect(struct i2c_adapter *adapter, int addr, int kind)
575 up(&usb->i2c_lock); 563 up(&usb->i2c_lock);
576 } 564 }
577 565
578 i2c_attach_client(client);
579 printk("s2250: initialized successfully\n"); 566 printk("s2250: initialized successfully\n");
580 return 0; 567 return 0;
581} 568}
582 569
583static int s2250_detach(struct i2c_client *client) 570static int s2250_remove(struct i2c_client *client)
584{ 571{
585 struct s2250 *dec = i2c_get_clientdata(client); 572 struct s2250 *dec = i2c_get_clientdata(client);
586 int r;
587
588 r = i2c_detach_client(client);
589 if (r < 0)
590 return r;
591 573
592 kfree(client); 574 i2c_set_clientdata(client, NULL);
575 i2c_unregister_device(dec->audio);
593 kfree(dec); 576 kfree(dec);
594 return 0; 577 return 0;
595} 578}
596 579
580static struct i2c_device_id s2250_id[] = {
581 { "s2250_board", 0 },
582 { }
583};
584
597static struct i2c_driver s2250_driver = { 585static struct i2c_driver s2250_driver = {
598 .driver = { 586 .driver = {
599 .name = "Sensoray 2250 board driver", 587 .name = "Sensoray 2250 board driver",
600 }, 588 },
601 .id = I2C_DRIVERID_S2250, 589 .probe = s2250_probe,
602 .detach_client = s2250_detach, 590 .remove = s2250_remove,
603 .command = s2250_command, 591 .command = s2250_command,
592 .id_table = s2250_id,
604}; 593};
605 594
606static int __init s2250_init(void) 595static int __init s2250_init(void)
@@ -613,13 +602,13 @@ static int __init s2250_init(void)
613 602
614 r = i2c_add_driver(&s2250_driver); 603 r = i2c_add_driver(&s2250_driver);
615 if (r < 0) 604 if (r < 0)
616 return r; 605 s2250loader_cleanup();
617 return wis_i2c_add_driver(s2250_driver.id, s2250_detect); 606
607 return r;
618} 608}
619 609
620static void __exit s2250_cleanup(void) 610static void __exit s2250_cleanup(void)
621{ 611{
622 wis_i2c_del_driver(s2250_detect);
623 i2c_del_driver(&s2250_driver); 612 i2c_del_driver(&s2250_driver);
624 613
625 s2250loader_cleanup(); 614 s2250loader_cleanup();
diff --git a/drivers/staging/go7007/wis-i2c.h b/drivers/staging/go7007/wis-i2c.h
index 431f41dd3966..3c2b9be455df 100644
--- a/drivers/staging/go7007/wis-i2c.h
+++ b/drivers/staging/go7007/wis-i2c.h
@@ -24,21 +24,12 @@
24#define I2C_DRIVERID_WIS_OV7640 0xf0f5 24#define I2C_DRIVERID_WIS_OV7640 0xf0f5
25#define I2C_DRIVERID_WIS_TW2804 0xf0f6 25#define I2C_DRIVERID_WIS_TW2804 0xf0f6
26#define I2C_DRIVERID_S2250 0xf0f7 26#define I2C_DRIVERID_S2250 0xf0f7
27#define I2C_ALGO_GO7007 0xf00000
28#define I2C_ALGO_GO7007_USB 0xf10000
29 27
30/* Flag to indicate that the client needs to be accessed with SCCB semantics */ 28/* Flag to indicate that the client needs to be accessed with SCCB semantics */
31/* We re-use the I2C_M_TEN value so the flag passes through the masks in the 29/* We re-use the I2C_M_TEN value so the flag passes through the masks in the
32 * core I2C code. Major kludge, but the I2C layer ain't exactly flexible. */ 30 * core I2C code. Major kludge, but the I2C layer ain't exactly flexible. */
33#define I2C_CLIENT_SCCB 0x10 31#define I2C_CLIENT_SCCB 0x10
34 32
35typedef int (*found_proc) (struct i2c_adapter *, int, int);
36int wis_i2c_add_driver(unsigned int id, found_proc found_proc);
37void wis_i2c_del_driver(found_proc found_proc);
38
39int wis_i2c_probe_device(struct i2c_adapter *adapter,
40 unsigned int id, int addr);
41
42/* Definitions for new video decoder commands */ 33/* Definitions for new video decoder commands */
43 34
44struct video_decoder_resolution { 35struct video_decoder_resolution {
diff --git a/drivers/staging/go7007/wis-ov7640.c b/drivers/staging/go7007/wis-ov7640.c
index 2f9efca04606..04d6d3a498a3 100644
--- a/drivers/staging/go7007/wis-ov7640.c
+++ b/drivers/staging/go7007/wis-ov7640.c
@@ -50,76 +50,54 @@ static int write_regs(struct i2c_client *client, u8 *regs)
50 return 0; 50 return 0;
51} 51}
52 52
53static struct i2c_driver wis_ov7640_driver; 53static int wis_ov7640_probe(struct i2c_client *client,
54 54 const struct i2c_device_id *id)
55static struct i2c_client wis_ov7640_client_templ = {
56 .name = "OV7640 (WIS)",
57 .driver = &wis_ov7640_driver,
58};
59
60static int wis_ov7640_detect(struct i2c_adapter *adapter, int addr, int kind)
61{ 55{
62 struct i2c_client *client; 56 struct i2c_adapter *adapter = client->adapter;
63 57
64 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 58 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
65 return 0; 59 return -ENODEV;
66 60
67 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
68 if (client == NULL)
69 return -ENOMEM;
70 memcpy(client, &wis_ov7640_client_templ,
71 sizeof(wis_ov7640_client_templ));
72 client->adapter = adapter;
73 client->addr = addr;
74 client->flags = I2C_CLIENT_SCCB; 61 client->flags = I2C_CLIENT_SCCB;
75 62
76 printk(KERN_DEBUG 63 printk(KERN_DEBUG
77 "wis-ov7640: initializing OV7640 at address %d on %s\n", 64 "wis-ov7640: initializing OV7640 at address %d on %s\n",
78 addr, adapter->name); 65 client->addr, adapter->name);
79 66
80 if (write_regs(client, initial_registers) < 0) { 67 if (write_regs(client, initial_registers) < 0) {
81 printk(KERN_ERR "wis-ov7640: error initializing OV7640\n"); 68 printk(KERN_ERR "wis-ov7640: error initializing OV7640\n");
82 kfree(client); 69 return -ENODEV;
83 return 0;
84 } 70 }
85 71
86 i2c_attach_client(client);
87 return 0; 72 return 0;
88} 73}
89 74
90static int wis_ov7640_detach(struct i2c_client *client) 75static int wis_ov7640_remove(struct i2c_client *client)
91{ 76{
92 int r;
93
94 r = i2c_detach_client(client);
95 if (r < 0)
96 return r;
97
98 kfree(client);
99 return 0; 77 return 0;
100} 78}
101 79
80static struct i2c_device_id wis_ov7640_id[] = {
81 { "wis_ov7640", 0 },
82 { }
83};
84
102static struct i2c_driver wis_ov7640_driver = { 85static struct i2c_driver wis_ov7640_driver = {
103 .driver = { 86 .driver = {
104 .name = "WIS OV7640 I2C driver", 87 .name = "WIS OV7640 I2C driver",
105 }, 88 },
106 .id = I2C_DRIVERID_WIS_OV7640, 89 .probe = wis_ov7640_probe,
107 .detach_client = wis_ov7640_detach, 90 .remove = wis_ov7640_remove,
91 .id_table = wis_ov7640_id,
108}; 92};
109 93
110static int __init wis_ov7640_init(void) 94static int __init wis_ov7640_init(void)
111{ 95{
112 int r; 96 return i2c_add_driver(&wis_ov7640_driver);
113
114 r = i2c_add_driver(&wis_ov7640_driver);
115 if (r < 0)
116 return r;
117 return wis_i2c_add_driver(wis_ov7640_driver.id, wis_ov7640_detect);
118} 97}
119 98
120static void __exit wis_ov7640_cleanup(void) 99static void __exit wis_ov7640_cleanup(void)
121{ 100{
122 wis_i2c_del_driver(wis_ov7640_detect);
123 i2c_del_driver(&wis_ov7640_driver); 101 i2c_del_driver(&wis_ov7640_driver);
124} 102}
125 103
diff --git a/drivers/staging/go7007/wis-saa7113.c b/drivers/staging/go7007/wis-saa7113.c
index 11689723945e..9ab893bd204e 100644
--- a/drivers/staging/go7007/wis-saa7113.c
+++ b/drivers/staging/go7007/wis-saa7113.c
@@ -261,34 +261,19 @@ static int wis_saa7113_command(struct i2c_client *client,
261 return 0; 261 return 0;
262} 262}
263 263
264static struct i2c_driver wis_saa7113_driver; 264static int wis_saa7113_probe(struct i2c_client *client,
265 265 const struct i2c_device_id *id)
266static struct i2c_client wis_saa7113_client_templ = {
267 .name = "SAA7113 (WIS)",
268 .driver = &wis_saa7113_driver,
269};
270
271static int wis_saa7113_detect(struct i2c_adapter *adapter, int addr, int kind)
272{ 266{
273 struct i2c_client *client; 267 struct i2c_adapter *adapter = client->adapter;
274 struct wis_saa7113 *dec; 268 struct wis_saa7113 *dec;
275 269
276 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 270 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
277 return 0; 271 return -ENODEV;
278
279 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
280 if (client == NULL)
281 return -ENOMEM;
282 memcpy(client, &wis_saa7113_client_templ,
283 sizeof(wis_saa7113_client_templ));
284 client->adapter = adapter;
285 client->addr = addr;
286 272
287 dec = kmalloc(sizeof(struct wis_saa7113), GFP_KERNEL); 273 dec = kmalloc(sizeof(struct wis_saa7113), GFP_KERNEL);
288 if (dec == NULL) { 274 if (dec == NULL)
289 kfree(client);
290 return -ENOMEM; 275 return -ENOMEM;
291 } 276
292 dec->norm = V4L2_STD_NTSC; 277 dec->norm = V4L2_STD_NTSC;
293 dec->brightness = 128; 278 dec->brightness = 128;
294 dec->contrast = 71; 279 dec->contrast = 71;
@@ -298,56 +283,49 @@ static int wis_saa7113_detect(struct i2c_adapter *adapter, int addr, int kind)
298 283
299 printk(KERN_DEBUG 284 printk(KERN_DEBUG
300 "wis-saa7113: initializing SAA7113 at address %d on %s\n", 285 "wis-saa7113: initializing SAA7113 at address %d on %s\n",
301 addr, adapter->name); 286 client->addr, adapter->name);
302 287
303 if (write_regs(client, initial_registers) < 0) { 288 if (write_regs(client, initial_registers) < 0) {
304 printk(KERN_ERR 289 printk(KERN_ERR
305 "wis-saa7113: error initializing SAA7113\n"); 290 "wis-saa7113: error initializing SAA7113\n");
306 kfree(client);
307 kfree(dec); 291 kfree(dec);
308 return 0; 292 return -ENODEV;
309 } 293 }
310 294
311 i2c_attach_client(client);
312 return 0; 295 return 0;
313} 296}
314 297
315static int wis_saa7113_detach(struct i2c_client *client) 298static int wis_saa7113_remove(struct i2c_client *client)
316{ 299{
317 struct wis_saa7113 *dec = i2c_get_clientdata(client); 300 struct wis_saa7113 *dec = i2c_get_clientdata(client);
318 int r;
319
320 r = i2c_detach_client(client);
321 if (r < 0)
322 return r;
323 301
324 kfree(client); 302 i2c_set_clientdata(client, NULL);
325 kfree(dec); 303 kfree(dec);
326 return 0; 304 return 0;
327} 305}
328 306
307static struct i2c_device_id wis_saa7113_id[] = {
308 { "wis_saa7113", 0 },
309 { }
310};
311
329static struct i2c_driver wis_saa7113_driver = { 312static struct i2c_driver wis_saa7113_driver = {
330 .driver = { 313 .driver = {
331 .name = "WIS SAA7113 I2C driver", 314 .name = "WIS SAA7113 I2C driver",
332 }, 315 },
333 .id = I2C_DRIVERID_WIS_SAA7113, 316 .probe = wis_saa7113_probe,
334 .detach_client = wis_saa7113_detach, 317 .remove = wis_saa7113_remove,
335 .command = wis_saa7113_command, 318 .command = wis_saa7113_command,
319 .id_table = wis_saa7113_id,
336}; 320};
337 321
338static int __init wis_saa7113_init(void) 322static int __init wis_saa7113_init(void)
339{ 323{
340 int r; 324 return i2c_add_driver(&wis_saa7113_driver);
341
342 r = i2c_add_driver(&wis_saa7113_driver);
343 if (r < 0)
344 return r;
345 return wis_i2c_add_driver(wis_saa7113_driver.id, wis_saa7113_detect);
346} 325}
347 326
348static void __exit wis_saa7113_cleanup(void) 327static void __exit wis_saa7113_cleanup(void)
349{ 328{
350 wis_i2c_del_driver(wis_saa7113_detect);
351 i2c_del_driver(&wis_saa7113_driver); 329 i2c_del_driver(&wis_saa7113_driver);
352} 330}
353 331
diff --git a/drivers/staging/go7007/wis-saa7115.c b/drivers/staging/go7007/wis-saa7115.c
index 59417a7174d7..8687ad2de761 100644
--- a/drivers/staging/go7007/wis-saa7115.c
+++ b/drivers/staging/go7007/wis-saa7115.c
@@ -394,34 +394,19 @@ static int wis_saa7115_command(struct i2c_client *client,
394 return 0; 394 return 0;
395} 395}
396 396
397static struct i2c_driver wis_saa7115_driver; 397static int wis_saa7115_probe(struct i2c_client *client,
398 398 const struct i2c_device_id *id)
399static struct i2c_client wis_saa7115_client_templ = {
400 .name = "SAA7115 (WIS)",
401 .driver = &wis_saa7115_driver,
402};
403
404static int wis_saa7115_detect(struct i2c_adapter *adapter, int addr, int kind)
405{ 399{
406 struct i2c_client *client; 400 struct i2c_adapter *adapter = client->adapter;
407 struct wis_saa7115 *dec; 401 struct wis_saa7115 *dec;
408 402
409 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 403 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
410 return 0; 404 return -ENODEV;
411
412 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
413 if (client == NULL)
414 return -ENOMEM;
415 memcpy(client, &wis_saa7115_client_templ,
416 sizeof(wis_saa7115_client_templ));
417 client->adapter = adapter;
418 client->addr = addr;
419 405
420 dec = kmalloc(sizeof(struct wis_saa7115), GFP_KERNEL); 406 dec = kmalloc(sizeof(struct wis_saa7115), GFP_KERNEL);
421 if (dec == NULL) { 407 if (dec == NULL)
422 kfree(client);
423 return -ENOMEM; 408 return -ENOMEM;
424 } 409
425 dec->norm = V4L2_STD_NTSC; 410 dec->norm = V4L2_STD_NTSC;
426 dec->brightness = 128; 411 dec->brightness = 128;
427 dec->contrast = 64; 412 dec->contrast = 64;
@@ -431,56 +416,49 @@ static int wis_saa7115_detect(struct i2c_adapter *adapter, int addr, int kind)
431 416
432 printk(KERN_DEBUG 417 printk(KERN_DEBUG
433 "wis-saa7115: initializing SAA7115 at address %d on %s\n", 418 "wis-saa7115: initializing SAA7115 at address %d on %s\n",
434 addr, adapter->name); 419 client->addr, adapter->name);
435 420
436 if (write_regs(client, initial_registers) < 0) { 421 if (write_regs(client, initial_registers) < 0) {
437 printk(KERN_ERR 422 printk(KERN_ERR
438 "wis-saa7115: error initializing SAA7115\n"); 423 "wis-saa7115: error initializing SAA7115\n");
439 kfree(client);
440 kfree(dec); 424 kfree(dec);
441 return 0; 425 return -ENODEV;
442 } 426 }
443 427
444 i2c_attach_client(client);
445 return 0; 428 return 0;
446} 429}
447 430
448static int wis_saa7115_detach(struct i2c_client *client) 431static int wis_saa7115_remove(struct i2c_client *client)
449{ 432{
450 struct wis_saa7115 *dec = i2c_get_clientdata(client); 433 struct wis_saa7115 *dec = i2c_get_clientdata(client);
451 int r;
452
453 r = i2c_detach_client(client);
454 if (r < 0)
455 return r;
456 434
457 kfree(client); 435 i2c_set_clientdata(client, NULL);
458 kfree(dec); 436 kfree(dec);
459 return 0; 437 return 0;
460} 438}
461 439
440static struct i2c_device_id wis_saa7115_id[] = {
441 { "wis_saa7115", 0 },
442 { }
443};
444
462static struct i2c_driver wis_saa7115_driver = { 445static struct i2c_driver wis_saa7115_driver = {
463 .driver = { 446 .driver = {
464 .name = "WIS SAA7115 I2C driver", 447 .name = "WIS SAA7115 I2C driver",
465 }, 448 },
466 .id = I2C_DRIVERID_WIS_SAA7115, 449 .probe = wis_saa7115_probe,
467 .detach_client = wis_saa7115_detach, 450 .remove = wis_saa7115_remove,
468 .command = wis_saa7115_command, 451 .command = wis_saa7115_command,
452 .id_table = wis_saa7115_id,
469}; 453};
470 454
471static int __init wis_saa7115_init(void) 455static int __init wis_saa7115_init(void)
472{ 456{
473 int r; 457 return i2c_add_driver(&wis_saa7115_driver);
474
475 r = i2c_add_driver(&wis_saa7115_driver);
476 if (r < 0)
477 return r;
478 return wis_i2c_add_driver(wis_saa7115_driver.id, wis_saa7115_detect);
479} 458}
480 459
481static void __exit wis_saa7115_cleanup(void) 460static void __exit wis_saa7115_cleanup(void)
482{ 461{
483 wis_i2c_del_driver(wis_saa7115_detect);
484 i2c_del_driver(&wis_saa7115_driver); 462 i2c_del_driver(&wis_saa7115_driver);
485} 463}
486 464
diff --git a/drivers/staging/go7007/wis-sony-tuner.c b/drivers/staging/go7007/wis-sony-tuner.c
index 58fddb122372..c965c601ac90 100644
--- a/drivers/staging/go7007/wis-sony-tuner.c
+++ b/drivers/staging/go7007/wis-sony-tuner.c
@@ -386,6 +386,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
386 struct wis_sony_tuner *t = i2c_get_clientdata(client); 386 struct wis_sony_tuner *t = i2c_get_clientdata(client);
387 387
388 switch (cmd) { 388 switch (cmd) {
389#if 0
389#ifdef TUNER_SET_TYPE_ADDR 390#ifdef TUNER_SET_TYPE_ADDR
390 case TUNER_SET_TYPE_ADDR: 391 case TUNER_SET_TYPE_ADDR:
391 { 392 {
@@ -463,6 +464,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
463 t->type, sony_tuners[t->type - 200].name); 464 t->type, sony_tuners[t->type - 200].name);
464 break; 465 break;
465 } 466 }
467#endif
466 case VIDIOC_G_FREQUENCY: 468 case VIDIOC_G_FREQUENCY:
467 { 469 {
468 struct v4l2_frequency *f = arg; 470 struct v4l2_frequency *f = arg;
@@ -651,35 +653,19 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
651 return 0; 653 return 0;
652} 654}
653 655
654static struct i2c_driver wis_sony_tuner_driver; 656static int wis_sony_tuner_probe(struct i2c_client *client,
655 657 const struct i2c_device_id *id)
656static struct i2c_client wis_sony_tuner_client_templ = {
657 .name = "Sony TV Tuner (WIS)",
658 .driver = &wis_sony_tuner_driver,
659};
660
661static int wis_sony_tuner_detect(struct i2c_adapter *adapter,
662 int addr, int kind)
663{ 658{
664 struct i2c_client *client; 659 struct i2c_adapter *adapter = client->adapter;
665 struct wis_sony_tuner *t; 660 struct wis_sony_tuner *t;
666 661
667 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) 662 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
668 return 0; 663 return -ENODEV;
669
670 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
671 if (client == NULL)
672 return -ENOMEM;
673 memcpy(client, &wis_sony_tuner_client_templ,
674 sizeof(wis_sony_tuner_client_templ));
675 client->adapter = adapter;
676 client->addr = addr;
677 664
678 t = kmalloc(sizeof(struct wis_sony_tuner), GFP_KERNEL); 665 t = kmalloc(sizeof(struct wis_sony_tuner), GFP_KERNEL);
679 if (t == NULL) { 666 if (t == NULL)
680 kfree(client);
681 return -ENOMEM; 667 return -ENOMEM;
682 } 668
683 t->type = -1; 669 t->type = -1;
684 t->freq = 0; 670 t->freq = 0;
685 t->mpxmode = 0; 671 t->mpxmode = 0;
@@ -688,50 +674,42 @@ static int wis_sony_tuner_detect(struct i2c_adapter *adapter,
688 674
689 printk(KERN_DEBUG 675 printk(KERN_DEBUG
690 "wis-sony-tuner: initializing tuner at address %d on %s\n", 676 "wis-sony-tuner: initializing tuner at address %d on %s\n",
691 addr, adapter->name); 677 client->addr, adapter->name);
692
693 i2c_attach_client(client);
694 678
695 return 0; 679 return 0;
696} 680}
697 681
698static int wis_sony_tuner_detach(struct i2c_client *client) 682static int wis_sony_tuner_remove(struct i2c_client *client)
699{ 683{
700 struct wis_sony_tuner *t = i2c_get_clientdata(client); 684 struct wis_sony_tuner *t = i2c_get_clientdata(client);
701 int r;
702
703 r = i2c_detach_client(client);
704 if (r < 0)
705 return r;
706 685
686 i2c_set_clientdata(client, NULL);
707 kfree(t); 687 kfree(t);
708 kfree(client);
709 return 0; 688 return 0;
710} 689}
711 690
691static struct i2c_device_id wis_sony_tuner_id[] = {
692 { "wis_sony_tuner", 0 },
693 { }
694};
695
712static struct i2c_driver wis_sony_tuner_driver = { 696static struct i2c_driver wis_sony_tuner_driver = {
713 .driver = { 697 .driver = {
714 .name = "WIS Sony TV Tuner I2C driver", 698 .name = "WIS Sony TV Tuner I2C driver",
715 }, 699 },
716 .id = I2C_DRIVERID_WIS_SONY_TUNER, 700 .probe = wis_sony_tuner_probe,
717 .detach_client = wis_sony_tuner_detach, 701 .remove = wis_sony_tuner_remove,
718 .command = tuner_command, 702 .command = tuner_command,
703 .id_table = wis_sony_tuner_id,
719}; 704};
720 705
721static int __init wis_sony_tuner_init(void) 706static int __init wis_sony_tuner_init(void)
722{ 707{
723 int r; 708 return i2c_add_driver(&wis_sony_tuner_driver);
724
725 r = i2c_add_driver(&wis_sony_tuner_driver);
726 if (r < 0)
727 return r;
728 return wis_i2c_add_driver(wis_sony_tuner_driver.id,
729 wis_sony_tuner_detect);
730} 709}
731 710
732static void __exit wis_sony_tuner_cleanup(void) 711static void __exit wis_sony_tuner_cleanup(void)
733{ 712{
734 wis_i2c_del_driver(wis_sony_tuner_detect);
735 i2c_del_driver(&wis_sony_tuner_driver); 713 i2c_del_driver(&wis_sony_tuner_driver);
736} 714}
737 715
diff --git a/drivers/staging/go7007/wis-tw2804.c b/drivers/staging/go7007/wis-tw2804.c
index 57b8f2b1caa3..e15794a2a0ae 100644
--- a/drivers/staging/go7007/wis-tw2804.c
+++ b/drivers/staging/go7007/wis-tw2804.c
@@ -291,34 +291,19 @@ static int wis_tw2804_command(struct i2c_client *client,
291 return 0; 291 return 0;
292} 292}
293 293
294static struct i2c_driver wis_tw2804_driver; 294static int wis_tw2804_probe(struct i2c_client *client,
295 295 const struct i2c_device_id *id)
296static struct i2c_client wis_tw2804_client_templ = {
297 .name = "TW2804 (WIS)",
298 .driver = &wis_tw2804_driver,
299};
300
301static int wis_tw2804_detect(struct i2c_adapter *adapter, int addr, int kind)
302{ 296{
303 struct i2c_client *client; 297 struct i2c_adapter *adapter = client->adapter;
304 struct wis_tw2804 *dec; 298 struct wis_tw2804 *dec;
305 299
306 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 300 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
307 return 0; 301 return -ENODEV;
308
309 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
310 if (client == NULL)
311 return -ENOMEM;
312 memcpy(client, &wis_tw2804_client_templ,
313 sizeof(wis_tw2804_client_templ));
314 client->adapter = adapter;
315 client->addr = addr;
316 302
317 dec = kmalloc(sizeof(struct wis_tw2804), GFP_KERNEL); 303 dec = kmalloc(sizeof(struct wis_tw2804), GFP_KERNEL);
318 if (dec == NULL) { 304 if (dec == NULL)
319 kfree(client);
320 return -ENOMEM; 305 return -ENOMEM;
321 } 306
322 dec->channel = -1; 307 dec->channel = -1;
323 dec->norm = V4L2_STD_NTSC; 308 dec->norm = V4L2_STD_NTSC;
324 dec->brightness = 128; 309 dec->brightness = 128;
@@ -328,48 +313,42 @@ static int wis_tw2804_detect(struct i2c_adapter *adapter, int addr, int kind)
328 i2c_set_clientdata(client, dec); 313 i2c_set_clientdata(client, dec);
329 314
330 printk(KERN_DEBUG "wis-tw2804: creating TW2804 at address %d on %s\n", 315 printk(KERN_DEBUG "wis-tw2804: creating TW2804 at address %d on %s\n",
331 addr, adapter->name); 316 client->addr, adapter->name);
332 317
333 i2c_attach_client(client);
334 return 0; 318 return 0;
335} 319}
336 320
337static int wis_tw2804_detach(struct i2c_client *client) 321static int wis_tw2804_remove(struct i2c_client *client)
338{ 322{
339 struct wis_tw2804 *dec = i2c_get_clientdata(client); 323 struct wis_tw2804 *dec = i2c_get_clientdata(client);
340 int r;
341
342 r = i2c_detach_client(client);
343 if (r < 0)
344 return r;
345 324
346 kfree(client); 325 i2c_set_clientdata(client, NULL);
347 kfree(dec); 326 kfree(dec);
348 return 0; 327 return 0;
349} 328}
350 329
330static struct i2c_device_id wis_tw2804_id[] = {
331 { "wis_tw2804", 0 },
332 { }
333};
334
351static struct i2c_driver wis_tw2804_driver = { 335static struct i2c_driver wis_tw2804_driver = {
352 .driver = { 336 .driver = {
353 .name = "WIS TW2804 I2C driver", 337 .name = "WIS TW2804 I2C driver",
354 }, 338 },
355 .id = I2C_DRIVERID_WIS_TW2804, 339 .probe = wis_tw2804_probe,
356 .detach_client = wis_tw2804_detach, 340 .remove = wis_tw2804_remove,
357 .command = wis_tw2804_command, 341 .command = wis_tw2804_command,
342 .id_table = wis_tw2804_id,
358}; 343};
359 344
360static int __init wis_tw2804_init(void) 345static int __init wis_tw2804_init(void)
361{ 346{
362 int r; 347 return i2c_add_driver(&wis_tw2804_driver);
363
364 r = i2c_add_driver(&wis_tw2804_driver);
365 if (r < 0)
366 return r;
367 return wis_i2c_add_driver(wis_tw2804_driver.id, wis_tw2804_detect);
368} 348}
369 349
370static void __exit wis_tw2804_cleanup(void) 350static void __exit wis_tw2804_cleanup(void)
371{ 351{
372 wis_i2c_del_driver(wis_tw2804_detect);
373 i2c_del_driver(&wis_tw2804_driver); 352 i2c_del_driver(&wis_tw2804_driver);
374} 353}
375 354
diff --git a/drivers/staging/go7007/wis-tw9903.c b/drivers/staging/go7007/wis-tw9903.c
index 40627b282cb4..6c3427bb6f4c 100644
--- a/drivers/staging/go7007/wis-tw9903.c
+++ b/drivers/staging/go7007/wis-tw9903.c
@@ -267,34 +267,19 @@ static int wis_tw9903_command(struct i2c_client *client,
267 return 0; 267 return 0;
268} 268}
269 269
270static struct i2c_driver wis_tw9903_driver; 270static int wis_tw9903_probe(struct i2c_client *client,
271 271 const struct i2c_device_id *id)
272static struct i2c_client wis_tw9903_client_templ = {
273 .name = "TW9903 (WIS)",
274 .driver = &wis_tw9903_driver,
275};
276
277static int wis_tw9903_detect(struct i2c_adapter *adapter, int addr, int kind)
278{ 272{
279 struct i2c_client *client; 273 struct i2c_adapter *adapter = client->adapter;
280 struct wis_tw9903 *dec; 274 struct wis_tw9903 *dec;
281 275
282 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 276 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
283 return 0; 277 return -ENODEV;
284
285 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
286 if (client == NULL)
287 return -ENOMEM;
288 memcpy(client, &wis_tw9903_client_templ,
289 sizeof(wis_tw9903_client_templ));
290 client->adapter = adapter;
291 client->addr = addr;
292 278
293 dec = kmalloc(sizeof(struct wis_tw9903), GFP_KERNEL); 279 dec = kmalloc(sizeof(struct wis_tw9903), GFP_KERNEL);
294 if (dec == NULL) { 280 if (dec == NULL)
295 kfree(client);
296 return -ENOMEM; 281 return -ENOMEM;
297 } 282
298 dec->norm = V4L2_STD_NTSC; 283 dec->norm = V4L2_STD_NTSC;
299 dec->brightness = 0; 284 dec->brightness = 0;
300 dec->contrast = 0x60; 285 dec->contrast = 0x60;
@@ -303,55 +288,48 @@ static int wis_tw9903_detect(struct i2c_adapter *adapter, int addr, int kind)
303 288
304 printk(KERN_DEBUG 289 printk(KERN_DEBUG
305 "wis-tw9903: initializing TW9903 at address %d on %s\n", 290 "wis-tw9903: initializing TW9903 at address %d on %s\n",
306 addr, adapter->name); 291 client->addr, adapter->name);
307 292
308 if (write_regs(client, initial_registers) < 0) { 293 if (write_regs(client, initial_registers) < 0) {
309 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n"); 294 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n");
310 kfree(client);
311 kfree(dec); 295 kfree(dec);
312 return 0; 296 return -ENODEV;
313 } 297 }
314 298
315 i2c_attach_client(client);
316 return 0; 299 return 0;
317} 300}
318 301
319static int wis_tw9903_detach(struct i2c_client *client) 302static int wis_tw9903_remove(struct i2c_client *client)
320{ 303{
321 struct wis_tw9903 *dec = i2c_get_clientdata(client); 304 struct wis_tw9903 *dec = i2c_get_clientdata(client);
322 int r;
323
324 r = i2c_detach_client(client);
325 if (r < 0)
326 return r;
327 305
328 kfree(client); 306 i2c_set_clientdata(client, NULL);
329 kfree(dec); 307 kfree(dec);
330 return 0; 308 return 0;
331} 309}
332 310
311static struct i2c_device_id wis_tw9903_id[] = {
312 { "wis_tw9903", 0 },
313 { }
314};
315
333static struct i2c_driver wis_tw9903_driver = { 316static struct i2c_driver wis_tw9903_driver = {
334 .driver = { 317 .driver = {
335 .name = "WIS TW9903 I2C driver", 318 .name = "WIS TW9903 I2C driver",
336 }, 319 },
337 .id = I2C_DRIVERID_WIS_TW9903, 320 .probe = wis_tw9903_probe,
338 .detach_client = wis_tw9903_detach, 321 .remove = wis_tw9903_remove,
339 .command = wis_tw9903_command, 322 .command = wis_tw9903_command,
323 .id_table = wis_tw9903_id,
340}; 324};
341 325
342static int __init wis_tw9903_init(void) 326static int __init wis_tw9903_init(void)
343{ 327{
344 int r; 328 return i2c_add_driver(&wis_tw9903_driver);
345
346 r = i2c_add_driver(&wis_tw9903_driver);
347 if (r < 0)
348 return r;
349 return wis_i2c_add_driver(wis_tw9903_driver.id, wis_tw9903_detect);
350} 329}
351 330
352static void __exit wis_tw9903_cleanup(void) 331static void __exit wis_tw9903_cleanup(void)
353{ 332{
354 wis_i2c_del_driver(wis_tw9903_detect);
355 i2c_del_driver(&wis_tw9903_driver); 333 i2c_del_driver(&wis_tw9903_driver);
356} 334}
357 335
diff --git a/drivers/staging/go7007/wis-uda1342.c b/drivers/staging/go7007/wis-uda1342.c
index 555645c0cc1a..739c7ae8913f 100644
--- a/drivers/staging/go7007/wis-uda1342.c
+++ b/drivers/staging/go7007/wis-uda1342.c
@@ -59,73 +59,51 @@ static int wis_uda1342_command(struct i2c_client *client,
59 return 0; 59 return 0;
60} 60}
61 61
62static struct i2c_driver wis_uda1342_driver; 62static int wis_uda1342_probe(struct i2c_client *client,
63 63 const struct i2c_device_id *id)
64static struct i2c_client wis_uda1342_client_templ = {
65 .name = "UDA1342 (WIS)",
66 .driver = &wis_uda1342_driver,
67};
68
69static int wis_uda1342_detect(struct i2c_adapter *adapter, int addr, int kind)
70{ 64{
71 struct i2c_client *client; 65 struct i2c_adapter *adapter = client->adapter;
72 66
73 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) 67 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
74 return 0; 68 return -ENODEV;
75
76 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
77 if (client == NULL)
78 return -ENOMEM;
79 memcpy(client, &wis_uda1342_client_templ,
80 sizeof(wis_uda1342_client_templ));
81 client->adapter = adapter;
82 client->addr = addr;
83 69
84 printk(KERN_DEBUG 70 printk(KERN_DEBUG
85 "wis-uda1342: initializing UDA1342 at address %d on %s\n", 71 "wis-uda1342: initializing UDA1342 at address %d on %s\n",
86 addr, adapter->name); 72 client->addr, adapter->name);
87 73
88 write_reg(client, 0x00, 0x8000); /* reset registers */ 74 write_reg(client, 0x00, 0x8000); /* reset registers */
89 write_reg(client, 0x00, 0x1241); /* select input 1 */ 75 write_reg(client, 0x00, 0x1241); /* select input 1 */
90 76
91 i2c_attach_client(client);
92 return 0; 77 return 0;
93} 78}
94 79
95static int wis_uda1342_detach(struct i2c_client *client) 80static int wis_uda1342_remove(struct i2c_client *client)
96{ 81{
97 int r;
98
99 r = i2c_detach_client(client);
100 if (r < 0)
101 return r;
102
103 kfree(client);
104 return 0; 82 return 0;
105} 83}
106 84
85static struct i2c_device_id wis_uda1342_id[] = {
86 { "wis_uda1342", 0 },
87 { }
88};
89
107static struct i2c_driver wis_uda1342_driver = { 90static struct i2c_driver wis_uda1342_driver = {
108 .driver = { 91 .driver = {
109 .name = "WIS UDA1342 I2C driver", 92 .name = "WIS UDA1342 I2C driver",
110 }, 93 },
111 .id = I2C_DRIVERID_WIS_UDA1342, 94 .probe = wis_uda1342_probe,
112 .detach_client = wis_uda1342_detach, 95 .remove = wis_uda1342_remove,
113 .command = wis_uda1342_command, 96 .command = wis_uda1342_command,
97 .id_table = wis_uda1342_id,
114}; 98};
115 99
116static int __init wis_uda1342_init(void) 100static int __init wis_uda1342_init(void)
117{ 101{
118 int r; 102 return i2c_add_driver(&wis_uda1342_driver);
119
120 r = i2c_add_driver(&wis_uda1342_driver);
121 if (r < 0)
122 return r;
123 return wis_i2c_add_driver(wis_uda1342_driver.id, wis_uda1342_detect);
124} 103}
125 104
126static void __exit wis_uda1342_cleanup(void) 105static void __exit wis_uda1342_cleanup(void)
127{ 106{
128 wis_i2c_del_driver(wis_uda1342_detect);
129 i2c_del_driver(&wis_uda1342_driver); 107 i2c_del_driver(&wis_uda1342_driver);
130} 108}
131 109
diff --git a/drivers/staging/line6/audio.c b/drivers/staging/line6/audio.c
index 3aa946899ced..e2ac8d60f8c2 100644
--- a/drivers/staging/line6/audio.c
+++ b/drivers/staging/line6/audio.c
@@ -27,11 +27,12 @@ int line6_init_audio(struct usb_line6 *line6)
27{ 27{
28 static int dev; 28 static int dev;
29 struct snd_card *card; 29 struct snd_card *card;
30 int err;
30 31
31 card = snd_card_new(line6_index[dev], line6_id[dev], THIS_MODULE, 0); 32 err = snd_card_create(line6_index[dev], line6_id[dev], THIS_MODULE, 0,
32 33 &card);
33 if (card == NULL) 34 if (err < 0)
34 return -ENOMEM; 35 return err;
35 36
36 line6->card = card; 37 line6->card = card;
37 38
diff --git a/drivers/staging/otus/usbdrv.c b/drivers/staging/otus/usbdrv.c
index 565a839589f5..540cbbb826f9 100644
--- a/drivers/staging/otus/usbdrv.c
+++ b/drivers/staging/otus/usbdrv.c
@@ -822,6 +822,21 @@ int zfLnxVapXmitFrame(struct sk_buff *skb, struct net_device *dev)
822 return 0; 822 return 0;
823} 823}
824 824
825static const struct net_device_ops vap_netdev_ops = {
826 .ndo_open = zfLnxVapOpen,
827 .ndo_stop = zfLnxVapClose,
828 .ndo_start_xmit = zfLnxVapXmitFrame,
829 .ndo_get_stats = usbdrv_get_stats,
830 .ndo_change_mtu = usbdrv_change_mtu,
831 .ndo_validate_addr = eth_validate_addr,
832 .ndo_set_mac_address = eth_mac_addr,
833#ifdef ZM_HOSTAPD_SUPPORT
834 .ndo_do_ioctl = usbdrv_ioctl,
835#else
836 .ndo_do_ioctl = NULL,
837#endif
838};
839
825int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId) 840int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId)
826{ 841{
827 /* Allocate net device structure */ 842 /* Allocate net device structure */
@@ -846,16 +861,7 @@ int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId)
846 vap[vapId].dev->ml_priv = parentDev->ml_priv; 861 vap[vapId].dev->ml_priv = parentDev->ml_priv;
847 862
848 //dev->hard_start_xmit = &zd1212_wds_xmit_frame; 863 //dev->hard_start_xmit = &zd1212_wds_xmit_frame;
849 vap[vapId].dev->hard_start_xmit = &zfLnxVapXmitFrame; 864 vap[vapId].dev->netdev_ops = &vap_netdev_ops;
850 vap[vapId].dev->open = &zfLnxVapOpen;
851 vap[vapId].dev->stop = &zfLnxVapClose;
852 vap[vapId].dev->get_stats = &usbdrv_get_stats;
853 vap[vapId].dev->change_mtu = &usbdrv_change_mtu;
854#ifdef ZM_HOSTAPD_SUPPORT
855 vap[vapId].dev->do_ioctl = usbdrv_ioctl;
856#else
857 vap[vapId].dev->do_ioctl = NULL;
858#endif
859 vap[vapId].dev->destructor = free_netdev; 865 vap[vapId].dev->destructor = free_netdev;
860 866
861 vap[vapId].dev->tx_queue_len = 0; 867 vap[vapId].dev->tx_queue_len = 0;
@@ -1068,6 +1074,18 @@ void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp)
1068 usb_unlink_urb(macp->RegInUrb); 1074 usb_unlink_urb(macp->RegInUrb);
1069} 1075}
1070 1076
1077static const struct net_device_ops otus_netdev_ops = {
1078 .ndo_open = usbdrv_open,
1079 .ndo_stop = usbdrv_close,
1080 .ndo_start_xmit = usbdrv_xmit_frame,
1081 .ndo_change_mtu = usbdrv_change_mtu,
1082 .ndo_get_stats = usbdrv_get_stats,
1083 .ndo_set_multicast_list = usbdrv_set_multi,
1084 .ndo_set_mac_address = usbdrv_set_mac,
1085 .ndo_do_ioctl = usbdrv_ioctl,
1086 .ndo_validate_addr = eth_validate_addr,
1087};
1088
1071u8_t zfLnxInitSetup(struct net_device *dev, struct usbdrv_private *macp) 1089u8_t zfLnxInitSetup(struct net_device *dev, struct usbdrv_private *macp)
1072{ 1090{
1073 //unsigned char addr[6]; 1091 //unsigned char addr[6];
@@ -1092,14 +1110,7 @@ u8_t zfLnxInitSetup(struct net_device *dev, struct usbdrv_private *macp)
1092 dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def; 1110 dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def;
1093#endif 1111#endif
1094 1112
1095 dev->open = usbdrv_open; 1113 dev->netdev_ops = &otus_netdev_ops;
1096 dev->hard_start_xmit = usbdrv_xmit_frame;
1097 dev->stop = usbdrv_close;
1098 dev->change_mtu = &usbdrv_change_mtu;
1099 dev->get_stats = usbdrv_get_stats;
1100 dev->set_multicast_list = usbdrv_set_multi;
1101 dev->set_mac_address = usbdrv_set_mac;
1102 dev->do_ioctl = usbdrv_ioctl;
1103 1114
1104 dev->flags |= IFF_MULTICAST; 1115 dev->flags |= IFF_MULTICAST;
1105 1116
diff --git a/drivers/staging/otus/zdusb.c b/drivers/staging/otus/zdusb.c
index 78f1d2224fa1..2a6d937ba5e8 100644
--- a/drivers/staging/otus/zdusb.c
+++ b/drivers/staging/otus/zdusb.c
@@ -48,7 +48,8 @@ static const char driver_name[] = "Otus";
48static struct usb_device_id zd1221_ids [] = { 48static struct usb_device_id zd1221_ids [] = {
49 { USB_DEVICE(VENDOR_ATHR, PRODUCT_AR9170) }, 49 { USB_DEVICE(VENDOR_ATHR, PRODUCT_AR9170) },
50 { USB_DEVICE(VENDOR_DLINK, PRODUCT_DWA160A) }, 50 { USB_DEVICE(VENDOR_DLINK, PRODUCT_DWA160A) },
51 { USB_DEVICE(0x0846, 0x9010) }, 51 { USB_DEVICE(VENDOR_NETGEAR, PRODUCT_WNDA3100) },
52 { USB_DEVICE(VENDOR_NETGEAR, PRODUCT_WN111v2) },
52 { } /* Terminating entry */ 53 { } /* Terminating entry */
53}; 54};
54 55
diff --git a/drivers/staging/otus/zdusb.h b/drivers/staging/otus/zdusb.h
index 656dc212ade5..9f8ab2e96169 100644
--- a/drivers/staging/otus/zdusb.h
+++ b/drivers/staging/otus/zdusb.h
@@ -40,4 +40,8 @@
40#define VENDOR_DLINK 0x07D1 //Dlink 40#define VENDOR_DLINK 0x07D1 //Dlink
41#define PRODUCT_DWA160A 0x3C10 41#define PRODUCT_DWA160A 0x3C10
42 42
43#define VENDOR_NETGEAR 0x0846 /* NetGear */
44#define PRODUCT_WNDA3100 0x9010
45#define PRODUCT_WN111v2 0x9001
46
43#endif 47#endif
diff --git a/drivers/staging/pohmelfs/config.c b/drivers/staging/pohmelfs/config.c
index 3e67da9ea381..a6eaa42fb669 100644
--- a/drivers/staging/pohmelfs/config.c
+++ b/drivers/staging/pohmelfs/config.c
@@ -81,6 +81,45 @@ static struct pohmelfs_config_group *pohmelfs_find_create_config_group(unsigned
81 return g; 81 return g;
82} 82}
83 83
84static inline void pohmelfs_insert_config_entry(struct pohmelfs_sb *psb, struct pohmelfs_config *dst)
85{
86 struct pohmelfs_config *tmp;
87
88 INIT_LIST_HEAD(&dst->config_entry);
89
90 list_for_each_entry(tmp, &psb->state_list, config_entry) {
91 if (dst->state.ctl.prio > tmp->state.ctl.prio)
92 list_add_tail(&dst->config_entry, &tmp->config_entry);
93 }
94 if (list_empty(&dst->config_entry))
95 list_add_tail(&dst->config_entry, &psb->state_list);
96}
97
98static int pohmelfs_move_config_entry(struct pohmelfs_sb *psb,
99 struct pohmelfs_config *dst, struct pohmelfs_config *new)
100{
101 if ((dst->state.ctl.prio == new->state.ctl.prio) &&
102 (dst->state.ctl.perm == new->state.ctl.perm))
103 return 0;
104
105 dprintk("%s: dst: prio: %d, perm: %x, new: prio: %d, perm: %d.\n",
106 __func__, dst->state.ctl.prio, dst->state.ctl.perm,
107 new->state.ctl.prio, new->state.ctl.perm);
108 dst->state.ctl.prio = new->state.ctl.prio;
109 dst->state.ctl.perm = new->state.ctl.perm;
110
111 list_del_init(&dst->config_entry);
112 pohmelfs_insert_config_entry(psb, dst);
113 return 0;
114}
115
116/*
117 * pohmelfs_copy_config() is used to copy new state configs from the
118 * config group (controlled by the netlink messages) into the superblock.
119 * This happens either at startup time where no transactions can access
120 * the list of the configs (and thus list of the network states), or at
121 * run-time, where it is protected by the psb->state_lock.
122 */
84int pohmelfs_copy_config(struct pohmelfs_sb *psb) 123int pohmelfs_copy_config(struct pohmelfs_sb *psb)
85{ 124{
86 struct pohmelfs_config_group *g; 125 struct pohmelfs_config_group *g;
@@ -103,7 +142,9 @@ int pohmelfs_copy_config(struct pohmelfs_sb *psb)
103 err = 0; 142 err = 0;
104 list_for_each_entry(dst, &psb->state_list, config_entry) { 143 list_for_each_entry(dst, &psb->state_list, config_entry) {
105 if (pohmelfs_config_eql(&dst->state.ctl, &c->state.ctl)) { 144 if (pohmelfs_config_eql(&dst->state.ctl, &c->state.ctl)) {
106 err = -EEXIST; 145 err = pohmelfs_move_config_entry(psb, dst, c);
146 if (!err)
147 err = -EEXIST;
107 break; 148 break;
108 } 149 }
109 } 150 }
@@ -119,7 +160,7 @@ int pohmelfs_copy_config(struct pohmelfs_sb *psb)
119 160
120 memcpy(&dst->state.ctl, &c->state.ctl, sizeof(struct pohmelfs_ctl)); 161 memcpy(&dst->state.ctl, &c->state.ctl, sizeof(struct pohmelfs_ctl));
121 162
122 list_add_tail(&dst->config_entry, &psb->state_list); 163 pohmelfs_insert_config_entry(psb, dst);
123 164
124 err = pohmelfs_state_init_one(psb, dst); 165 err = pohmelfs_state_init_one(psb, dst);
125 if (err) { 166 if (err) {
@@ -248,6 +289,13 @@ out_unlock:
248 return err; 289 return err;
249} 290}
250 291
292static int pohmelfs_modify_config(struct pohmelfs_ctl *old, struct pohmelfs_ctl *new)
293{
294 old->perm = new->perm;
295 old->prio = new->prio;
296 return 0;
297}
298
251static int pohmelfs_cn_ctl(struct cn_msg *msg, int action) 299static int pohmelfs_cn_ctl(struct cn_msg *msg, int action)
252{ 300{
253 struct pohmelfs_config_group *g; 301 struct pohmelfs_config_group *g;
@@ -278,6 +326,9 @@ static int pohmelfs_cn_ctl(struct cn_msg *msg, int action)
278 g->num_entry--; 326 g->num_entry--;
279 kfree(c); 327 kfree(c);
280 goto out_unlock; 328 goto out_unlock;
329 } else if (action == POHMELFS_FLAGS_MODIFY) {
330 err = pohmelfs_modify_config(sc, ctl);
331 goto out_unlock;
281 } else { 332 } else {
282 err = -EEXIST; 333 err = -EEXIST;
283 goto out_unlock; 334 goto out_unlock;
@@ -296,6 +347,7 @@ static int pohmelfs_cn_ctl(struct cn_msg *msg, int action)
296 } 347 }
297 memcpy(&c->state.ctl, ctl, sizeof(struct pohmelfs_ctl)); 348 memcpy(&c->state.ctl, ctl, sizeof(struct pohmelfs_ctl));
298 g->num_entry++; 349 g->num_entry++;
350
299 list_add_tail(&c->config_entry, &g->config_list); 351 list_add_tail(&c->config_entry, &g->config_list);
300 352
301out_unlock: 353out_unlock:
@@ -401,10 +453,9 @@ static void pohmelfs_cn_callback(void *data)
401 453
402 switch (msg->flags) { 454 switch (msg->flags) {
403 case POHMELFS_FLAGS_ADD: 455 case POHMELFS_FLAGS_ADD:
404 err = pohmelfs_cn_ctl(msg, POHMELFS_FLAGS_ADD);
405 break;
406 case POHMELFS_FLAGS_DEL: 456 case POHMELFS_FLAGS_DEL:
407 err = pohmelfs_cn_ctl(msg, POHMELFS_FLAGS_DEL); 457 case POHMELFS_FLAGS_MODIFY:
458 err = pohmelfs_cn_ctl(msg, msg->flags);
408 break; 459 break;
409 case POHMELFS_FLAGS_SHOW: 460 case POHMELFS_FLAGS_SHOW:
410 err = pohmelfs_cn_disp(msg); 461 err = pohmelfs_cn_disp(msg);
diff --git a/drivers/staging/pohmelfs/dir.c b/drivers/staging/pohmelfs/dir.c
index 7a41183a32e1..b5799842fb84 100644
--- a/drivers/staging/pohmelfs/dir.c
+++ b/drivers/staging/pohmelfs/dir.c
@@ -328,7 +328,7 @@ static int pohmelfs_sync_remote_dir(struct pohmelfs_inode *pi)
328{ 328{
329 struct inode *inode = &pi->vfs_inode; 329 struct inode *inode = &pi->vfs_inode;
330 struct pohmelfs_sb *psb = POHMELFS_SB(inode->i_sb); 330 struct pohmelfs_sb *psb = POHMELFS_SB(inode->i_sb);
331 long ret = msecs_to_jiffies(25000); 331 long ret = psb->wait_on_page_timeout;
332 int err; 332 int err;
333 333
334 dprintk("%s: dir: %llu, state: %lx: remote_synced: %d.\n", 334 dprintk("%s: dir: %llu, state: %lx: remote_synced: %d.\n",
@@ -389,11 +389,11 @@ static int pohmelfs_readdir(struct file *file, void *dirent, filldir_t filldir)
389 dprintk("%s: parent: %llu, fpos: %llu, hash: %08lx.\n", 389 dprintk("%s: parent: %llu, fpos: %llu, hash: %08lx.\n",
390 __func__, pi->ino, (u64)file->f_pos, 390 __func__, pi->ino, (u64)file->f_pos,
391 (unsigned long)file->private_data); 391 (unsigned long)file->private_data);
392 392#if 0
393 err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK); 393 err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK);
394 if (err) 394 if (err)
395 return err; 395 return err;
396 396#endif
397 err = pohmelfs_sync_remote_dir(pi); 397 err = pohmelfs_sync_remote_dir(pi);
398 if (err) 398 if (err)
399 return err; 399 return err;
@@ -513,10 +513,6 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
513 513
514 need_lock = pohmelfs_need_lock(parent, lock_type); 514 need_lock = pohmelfs_need_lock(parent, lock_type);
515 515
516 err = pohmelfs_data_lock(parent, 0, ~0, lock_type);
517 if (err)
518 goto out;
519
520 str.hash = jhash(dentry->d_name.name, dentry->d_name.len, 0); 516 str.hash = jhash(dentry->d_name.name, dentry->d_name.len, 0);
521 517
522 mutex_lock(&parent->offset_lock); 518 mutex_lock(&parent->offset_lock);
@@ -525,8 +521,8 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
525 ino = n->ino; 521 ino = n->ino;
526 mutex_unlock(&parent->offset_lock); 522 mutex_unlock(&parent->offset_lock);
527 523
528 dprintk("%s: 1 ino: %lu, inode: %p, name: '%s', hash: %x, parent_state: %lx.\n", 524 dprintk("%s: start ino: %lu, inode: %p, name: '%s', hash: %x, parent_state: %lx, need_lock: %d.\n",
529 __func__, ino, inode, str.name, str.hash, parent->state); 525 __func__, ino, inode, str.name, str.hash, parent->state, need_lock);
530 526
531 if (ino) { 527 if (ino) {
532 inode = ilookup(dir->i_sb, ino); 528 inode = ilookup(dir->i_sb, ino);
@@ -534,7 +530,7 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
534 goto out; 530 goto out;
535 } 531 }
536 532
537 dprintk("%s: dir: %p, dir_ino: %llu, name: '%s', len: %u, dir_state: %lx, ino: %lu.\n", 533 dprintk("%s: no inode dir: %p, dir_ino: %llu, name: '%s', len: %u, dir_state: %lx, ino: %lu.\n",
538 __func__, dir, parent->ino, 534 __func__, dir, parent->ino,
539 str.name, str.len, parent->state, ino); 535 str.name, str.len, parent->state, ino);
540 536
@@ -543,6 +539,10 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
543 goto out; 539 goto out;
544 } 540 }
545 541
542 err = pohmelfs_data_lock(parent, 0, ~0, lock_type);
543 if (err)
544 goto out;
545
546 err = pohmelfs_lookup_single(parent, &str, ino); 546 err = pohmelfs_lookup_single(parent, &str, ino);
547 if (err) 547 if (err)
548 goto out; 548 goto out;
@@ -557,10 +557,10 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
557 557
558 if (ino) { 558 if (ino) {
559 inode = ilookup(dir->i_sb, ino); 559 inode = ilookup(dir->i_sb, ino);
560 printk("%s: second lookup ino: %lu, inode: %p, name: '%s', hash: %x.\n", 560 dprintk("%s: second lookup ino: %lu, inode: %p, name: '%s', hash: %x.\n",
561 __func__, ino, inode, str.name, str.hash); 561 __func__, ino, inode, str.name, str.hash);
562 if (!inode) { 562 if (!inode) {
563 printk("%s: No inode for ino: %lu, name: '%s', hash: %x.\n", 563 dprintk("%s: No inode for ino: %lu, name: '%s', hash: %x.\n",
564 __func__, ino, str.name, str.hash); 564 __func__, ino, str.name, str.hash);
565 //return NULL; 565 //return NULL;
566 return ERR_PTR(-EACCES); 566 return ERR_PTR(-EACCES);
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index 5bf16504cd6f..b2eaf9047266 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -1169,16 +1169,17 @@ err_out_put:
1169static int pohmelfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 1169static int pohmelfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
1170{ 1170{
1171 struct inode *inode = dentry->d_inode; 1171 struct inode *inode = dentry->d_inode;
1172#if 0
1172 struct pohmelfs_inode *pi = POHMELFS_I(inode); 1173 struct pohmelfs_inode *pi = POHMELFS_I(inode);
1173 int err; 1174 int err;
1174 1175
1175 err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK); 1176 err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK);
1176 if (err) 1177 if (err)
1177 return err; 1178 return err;
1178
1179 dprintk("%s: ino: %llu, mode: %o, uid: %u, gid: %u, size: %llu.\n", 1179 dprintk("%s: ino: %llu, mode: %o, uid: %u, gid: %u, size: %llu.\n",
1180 __func__, pi->ino, inode->i_mode, inode->i_uid, 1180 __func__, pi->ino, inode->i_mode, inode->i_uid,
1181 inode->i_gid, inode->i_size); 1181 inode->i_gid, inode->i_size);
1182#endif
1182 1183
1183 generic_fillattr(inode, stat); 1184 generic_fillattr(inode, stat);
1184 return 0; 1185 return 0;
@@ -1342,14 +1343,6 @@ static void pohmelfs_put_super(struct super_block *sb)
1342 1343
1343 kfree(psb); 1344 kfree(psb);
1344 sb->s_fs_info = NULL; 1345 sb->s_fs_info = NULL;
1345
1346 pohmelfs_ftrans_exit();
1347}
1348
1349static int pohmelfs_remount(struct super_block *sb, int *flags, char *data)
1350{
1351 *flags |= MS_RDONLY;
1352 return 0;
1353} 1346}
1354 1347
1355static int pohmelfs_statfs(struct dentry *dentry, struct kstatfs *buf) 1348static int pohmelfs_statfs(struct dentry *dentry, struct kstatfs *buf)
@@ -1394,42 +1387,33 @@ static int pohmelfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
1394 return 0; 1387 return 0;
1395} 1388}
1396 1389
1397static const struct super_operations pohmelfs_sb_ops = {
1398 .alloc_inode = pohmelfs_alloc_inode,
1399 .destroy_inode = pohmelfs_destroy_inode,
1400 .drop_inode = pohmelfs_drop_inode,
1401 .write_inode = pohmelfs_write_inode,
1402 .put_super = pohmelfs_put_super,
1403 .remount_fs = pohmelfs_remount,
1404 .statfs = pohmelfs_statfs,
1405 .show_options = pohmelfs_show_options,
1406};
1407
1408enum { 1390enum {
1409 pohmelfs_opt_idx, 1391 pohmelfs_opt_idx,
1392 pohmelfs_opt_crypto_thread_num,
1393 pohmelfs_opt_trans_max_pages,
1394 pohmelfs_opt_crypto_fail_unsupported,
1395
1396 /* Remountable options */
1410 pohmelfs_opt_trans_scan_timeout, 1397 pohmelfs_opt_trans_scan_timeout,
1411 pohmelfs_opt_drop_scan_timeout, 1398 pohmelfs_opt_drop_scan_timeout,
1412 pohmelfs_opt_wait_on_page_timeout, 1399 pohmelfs_opt_wait_on_page_timeout,
1413 pohmelfs_opt_trans_retries, 1400 pohmelfs_opt_trans_retries,
1414 pohmelfs_opt_crypto_thread_num,
1415 pohmelfs_opt_trans_max_pages,
1416 pohmelfs_opt_crypto_fail_unsupported,
1417 pohmelfs_opt_mcache_timeout, 1401 pohmelfs_opt_mcache_timeout,
1418}; 1402};
1419 1403
1420static struct match_token pohmelfs_tokens[] = { 1404static struct match_token pohmelfs_tokens[] = {
1421 {pohmelfs_opt_idx, "idx=%u"}, 1405 {pohmelfs_opt_idx, "idx=%u"},
1406 {pohmelfs_opt_crypto_thread_num, "crypto_thread_num=%u"},
1407 {pohmelfs_opt_trans_max_pages, "trans_max_pages=%u"},
1408 {pohmelfs_opt_crypto_fail_unsupported, "crypto_fail_unsupported"},
1422 {pohmelfs_opt_trans_scan_timeout, "trans_scan_timeout=%u"}, 1409 {pohmelfs_opt_trans_scan_timeout, "trans_scan_timeout=%u"},
1423 {pohmelfs_opt_drop_scan_timeout, "drop_scan_timeout=%u"}, 1410 {pohmelfs_opt_drop_scan_timeout, "drop_scan_timeout=%u"},
1424 {pohmelfs_opt_wait_on_page_timeout, "wait_on_page_timeout=%u"}, 1411 {pohmelfs_opt_wait_on_page_timeout, "wait_on_page_timeout=%u"},
1425 {pohmelfs_opt_trans_retries, "trans_retries=%u"}, 1412 {pohmelfs_opt_trans_retries, "trans_retries=%u"},
1426 {pohmelfs_opt_crypto_thread_num, "crypto_thread_num=%u"},
1427 {pohmelfs_opt_trans_max_pages, "trans_max_pages=%u"},
1428 {pohmelfs_opt_crypto_fail_unsupported, "crypto_fail_unsupported"},
1429 {pohmelfs_opt_mcache_timeout, "mcache_timeout=%u"}, 1413 {pohmelfs_opt_mcache_timeout, "mcache_timeout=%u"},
1430}; 1414};
1431 1415
1432static int pohmelfs_parse_options(char *options, struct pohmelfs_sb *psb) 1416static int pohmelfs_parse_options(char *options, struct pohmelfs_sb *psb, int remount)
1433{ 1417{
1434 char *p; 1418 char *p;
1435 substring_t args[MAX_OPT_ARGS]; 1419 substring_t args[MAX_OPT_ARGS];
@@ -1449,6 +1433,9 @@ static int pohmelfs_parse_options(char *options, struct pohmelfs_sb *psb)
1449 if (err) 1433 if (err)
1450 return err; 1434 return err;
1451 1435
1436 if (remount && token <= pohmelfs_opt_crypto_fail_unsupported)
1437 continue;
1438
1452 switch (token) { 1439 switch (token) {
1453 case pohmelfs_opt_idx: 1440 case pohmelfs_opt_idx:
1454 psb->idx = option; 1441 psb->idx = option;
@@ -1485,6 +1472,25 @@ static int pohmelfs_parse_options(char *options, struct pohmelfs_sb *psb)
1485 return 0; 1472 return 0;
1486} 1473}
1487 1474
1475static int pohmelfs_remount(struct super_block *sb, int *flags, char *data)
1476{
1477 int err;
1478 struct pohmelfs_sb *psb = POHMELFS_SB(sb);
1479 unsigned long old_sb_flags = sb->s_flags;
1480
1481 err = pohmelfs_parse_options(data, psb, 1);
1482 if (err)
1483 goto err_out_restore;
1484
1485 if (!(*flags & MS_RDONLY))
1486 sb->s_flags &= ~MS_RDONLY;
1487 return 0;
1488
1489err_out_restore:
1490 sb->s_flags = old_sb_flags;
1491 return err;
1492}
1493
1488static void pohmelfs_flush_inode(struct pohmelfs_inode *pi, unsigned int count) 1494static void pohmelfs_flush_inode(struct pohmelfs_inode *pi, unsigned int count)
1489{ 1495{
1490 struct inode *inode = &pi->vfs_inode; 1496 struct inode *inode = &pi->vfs_inode;
@@ -1753,6 +1759,57 @@ err_out_exit:
1753 return err; 1759 return err;
1754} 1760}
1755 1761
1762static int pohmelfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
1763{
1764 struct netfs_state *st;
1765 struct pohmelfs_ctl *ctl;
1766 struct pohmelfs_sb *psb = POHMELFS_SB(mnt->mnt_sb);
1767 struct pohmelfs_config *c;
1768
1769 mutex_lock(&psb->state_lock);
1770
1771 seq_printf(m, "\nidx addr(:port) socket_type protocol active priority permissions\n");
1772
1773 list_for_each_entry(c, &psb->state_list, config_entry) {
1774 st = &c->state;
1775 ctl = &st->ctl;
1776
1777 seq_printf(m, "%u ", ctl->idx);
1778 if (ctl->addr.sa_family == AF_INET) {
1779 struct sockaddr_in *sin = (struct sockaddr_in *)&st->ctl.addr;
1780 //seq_printf(m, "%pi4:%u", &sin->sin_addr.s_addr, ntohs(sin->sin_port));
1781 seq_printf(m, "%u.%u.%u.%u:%u", NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
1782 } else if (ctl->addr.sa_family == AF_INET6) {
1783 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&st->ctl.addr;
1784 seq_printf(m, "%pi6:%u", &sin->sin6_addr, ntohs(sin->sin6_port));
1785 } else {
1786 unsigned int i;
1787 for (i=0; i<ctl->addrlen; ++i)
1788 seq_printf(m, "%02x.", ctl->addr.addr[i]);
1789 }
1790
1791 seq_printf(m, " %u %u %d %u %x\n",
1792 ctl->type, ctl->proto,
1793 st->socket != NULL,
1794 ctl->prio, ctl->perm);
1795 }
1796 mutex_unlock(&psb->state_lock);
1797
1798 return 0;
1799}
1800
1801static const struct super_operations pohmelfs_sb_ops = {
1802 .alloc_inode = pohmelfs_alloc_inode,
1803 .destroy_inode = pohmelfs_destroy_inode,
1804 .drop_inode = pohmelfs_drop_inode,
1805 .write_inode = pohmelfs_write_inode,
1806 .put_super = pohmelfs_put_super,
1807 .remount_fs = pohmelfs_remount,
1808 .statfs = pohmelfs_statfs,
1809 .show_options = pohmelfs_show_options,
1810 .show_stats = pohmelfs_show_stats,
1811};
1812
1756/* 1813/*
1757 * Allocate private superblock and create root dir. 1814 * Allocate private superblock and create root dir.
1758 */ 1815 */
@@ -1764,8 +1821,6 @@ static int pohmelfs_fill_super(struct super_block *sb, void *data, int silent)
1764 struct pohmelfs_inode *npi; 1821 struct pohmelfs_inode *npi;
1765 struct qstr str; 1822 struct qstr str;
1766 1823
1767 pohmelfs_ftrans_init();
1768
1769 psb = kzalloc(sizeof(struct pohmelfs_sb), GFP_KERNEL); 1824 psb = kzalloc(sizeof(struct pohmelfs_sb), GFP_KERNEL);
1770 if (!psb) 1825 if (!psb)
1771 goto err_out_exit; 1826 goto err_out_exit;
@@ -1816,7 +1871,7 @@ static int pohmelfs_fill_super(struct super_block *sb, void *data, int silent)
1816 mutex_init(&psb->state_lock); 1871 mutex_init(&psb->state_lock);
1817 INIT_LIST_HEAD(&psb->state_list); 1872 INIT_LIST_HEAD(&psb->state_list);
1818 1873
1819 err = pohmelfs_parse_options((char *) data, psb); 1874 err = pohmelfs_parse_options((char *) data, psb, 0);
1820 if (err) 1875 if (err)
1821 goto err_out_free_sb; 1876 goto err_out_free_sb;
1822 1877
@@ -1845,6 +1900,8 @@ static int pohmelfs_fill_super(struct super_block *sb, void *data, int silent)
1845 err = PTR_ERR(npi); 1900 err = PTR_ERR(npi);
1846 goto err_out_crypto_exit; 1901 goto err_out_crypto_exit;
1847 } 1902 }
1903 set_bit(NETFS_INODE_REMOTE_SYNCED, &npi->state);
1904 clear_bit(NETFS_INODE_OWNED, &npi->state);
1848 1905
1849 root = &npi->vfs_inode; 1906 root = &npi->vfs_inode;
1850 1907
@@ -1887,11 +1944,29 @@ static int pohmelfs_get_sb(struct file_system_type *fs_type,
1887 mnt); 1944 mnt);
1888} 1945}
1889 1946
1947/*
1948 * We need this to sync all inodes earlier, since when writeback
1949 * is invoked from the umount/mntput path dcache is already shrunk,
1950 * see generic_shutdown_super(), and no inodes can access the path.
1951 */
1952static void pohmelfs_kill_super(struct super_block *sb)
1953{
1954 struct writeback_control wbc = {
1955 .sync_mode = WB_SYNC_ALL,
1956 .range_start = 0,
1957 .range_end = LLONG_MAX,
1958 .nr_to_write = LONG_MAX,
1959 };
1960 generic_sync_sb_inodes(sb, &wbc);
1961
1962 kill_anon_super(sb);
1963}
1964
1890static struct file_system_type pohmel_fs_type = { 1965static struct file_system_type pohmel_fs_type = {
1891 .owner = THIS_MODULE, 1966 .owner = THIS_MODULE,
1892 .name = "pohmel", 1967 .name = "pohmel",
1893 .get_sb = pohmelfs_get_sb, 1968 .get_sb = pohmelfs_get_sb,
1894 .kill_sb = kill_anon_super, 1969 .kill_sb = pohmelfs_kill_super,
1895}; 1970};
1896 1971
1897/* 1972/*
diff --git a/drivers/staging/pohmelfs/lock.c b/drivers/staging/pohmelfs/lock.c
index ad4a18559bdd..22fef18cae90 100644
--- a/drivers/staging/pohmelfs/lock.c
+++ b/drivers/staging/pohmelfs/lock.c
@@ -41,7 +41,8 @@ static int pohmelfs_send_lock_trans(struct pohmelfs_inode *pi,
41 path_len = err; 41 path_len = err;
42 42
43 err = -ENOMEM; 43 err = -ENOMEM;
44 t = netfs_trans_alloc(psb, path_len + sizeof(struct netfs_lock) + isize, 0, 0); 44 t = netfs_trans_alloc(psb, path_len + sizeof(struct netfs_lock) + isize,
45 NETFS_TRANS_SINGLE_DST, 0);
45 if (!t) 46 if (!t)
46 goto err_out_exit; 47 goto err_out_exit;
47 48
diff --git a/drivers/staging/pohmelfs/net.c b/drivers/staging/pohmelfs/net.c
index c9b8540c1efe..11ecac026ca7 100644
--- a/drivers/staging/pohmelfs/net.c
+++ b/drivers/staging/pohmelfs/net.c
@@ -26,55 +26,6 @@
26 26
27#include "netfs.h" 27#include "netfs.h"
28 28
29static int pohmelfs_ftrans_size = 10240;
30static u32 *pohmelfs_ftrans;
31
32int pohmelfs_ftrans_init(void)
33{
34 pohmelfs_ftrans = vmalloc(pohmelfs_ftrans_size * 4);
35 if (!pohmelfs_ftrans)
36 return -ENOMEM;
37
38 return 0;
39}
40
41void pohmelfs_ftrans_exit(void)
42{
43 vfree(pohmelfs_ftrans);
44}
45
46void pohmelfs_ftrans_clean(u64 id)
47{
48 if (pohmelfs_ftrans) {
49 u32 i = id & 0xffffffff;
50 int idx = i % pohmelfs_ftrans_size;
51
52 pohmelfs_ftrans[idx] = 0;
53 }
54}
55
56void pohmelfs_ftrans_update(u64 id)
57{
58 if (pohmelfs_ftrans) {
59 u32 i = id & 0xffffffff;
60 int idx = i % pohmelfs_ftrans_size;
61
62 pohmelfs_ftrans[idx] = i;
63 }
64}
65
66int pohmelfs_ftrans_check(u64 id)
67{
68 if (pohmelfs_ftrans) {
69 u32 i = id & 0xffffffff;
70 int idx = i % pohmelfs_ftrans_size;
71
72 return (pohmelfs_ftrans[idx] == i);
73 }
74
75 return -1;
76}
77
78/* 29/*
79 * Async machinery lives here. 30 * Async machinery lives here.
80 * All commands being sent to server do _not_ require sync reply, 31 * All commands being sent to server do _not_ require sync reply,
@@ -450,8 +401,24 @@ static int pohmelfs_readdir_response(struct netfs_state *st)
450 if (err != -EEXIST) 401 if (err != -EEXIST)
451 goto err_out_put; 402 goto err_out_put;
452 } else { 403 } else {
404 struct dentry *dentry, *alias, *pd;
405
453 set_bit(NETFS_INODE_REMOTE_SYNCED, &npi->state); 406 set_bit(NETFS_INODE_REMOTE_SYNCED, &npi->state);
454 clear_bit(NETFS_INODE_OWNED, &npi->state); 407 clear_bit(NETFS_INODE_OWNED, &npi->state);
408
409 pd = d_find_alias(&parent->vfs_inode);
410 if (pd) {
411 str.hash = full_name_hash(str.name, str.len);
412 dentry = d_alloc(pd, &str);
413 if (dentry) {
414 alias = d_materialise_unique(dentry, &npi->vfs_inode);
415 if (alias)
416 dput(dentry);
417 }
418
419 dput(dentry);
420 dput(pd);
421 }
455 } 422 }
456 } 423 }
457out: 424out:
@@ -638,15 +605,12 @@ static int pohmelfs_transaction_response(struct netfs_state *st)
638 if (dst) { 605 if (dst) {
639 netfs_trans_remove_nolock(dst, st); 606 netfs_trans_remove_nolock(dst, st);
640 t = dst->trans; 607 t = dst->trans;
641
642 pohmelfs_ftrans_update(cmd->start);
643 } 608 }
644 mutex_unlock(&st->trans_lock); 609 mutex_unlock(&st->trans_lock);
645 610
646 if (!t) { 611 if (!t) {
647 int check = pohmelfs_ftrans_check(cmd->start); 612 printk("%s: failed to find transaction: start: %llu: id: %llu, size: %u, ext: %u.\n",
648 printk("%s: failed to find transaction: start: %llu: id: %llu, size: %u, ext: %u, double: %d.\n", 613 __func__, cmd->start, cmd->id, cmd->size, cmd->ext);
649 __func__, cmd->start, cmd->id, cmd->size, cmd->ext, check);
650 err = -EINVAL; 614 err = -EINVAL;
651 goto out; 615 goto out;
652 } 616 }
diff --git a/drivers/staging/pohmelfs/netfs.h b/drivers/staging/pohmelfs/netfs.h
index 2ff21ae5bb12..c78cfcb042fb 100644
--- a/drivers/staging/pohmelfs/netfs.h
+++ b/drivers/staging/pohmelfs/netfs.h
@@ -87,6 +87,7 @@ enum {
87 POHMELFS_FLAGS_DEL, /* Network state control message for DEL */ 87 POHMELFS_FLAGS_DEL, /* Network state control message for DEL */
88 POHMELFS_FLAGS_SHOW, /* Network state control message for SHOW */ 88 POHMELFS_FLAGS_SHOW, /* Network state control message for SHOW */
89 POHMELFS_FLAGS_CRYPTO, /* Crypto data control message */ 89 POHMELFS_FLAGS_CRYPTO, /* Crypto data control message */
90 POHMELFS_FLAGS_MODIFY, /* Network state modification message */
90}; 91};
91 92
92/* 93/*
@@ -116,16 +117,20 @@ struct pohmelfs_crypto
116 unsigned char data[0]; /* Algorithm string, key and IV */ 117 unsigned char data[0]; /* Algorithm string, key and IV */
117}; 118};
118 119
120#define POHMELFS_IO_PERM_READ (1<<0)
121#define POHMELFS_IO_PERM_WRITE (1<<1)
122
119/* 123/*
120 * Configuration command used to create table of different remote servers. 124 * Configuration command used to create table of different remote servers.
121 */ 125 */
122struct pohmelfs_ctl 126struct pohmelfs_ctl
123{ 127{
124 unsigned int idx; /* Config index */ 128 __u32 idx; /* Config index */
125 unsigned int type; /* Socket type */ 129 __u32 type; /* Socket type */
126 unsigned int proto; /* Socket protocol */ 130 __u32 proto; /* Socket protocol */
127 unsigned int addrlen; /* Size of the address */ 131 __u16 addrlen; /* Size of the address */
128 unsigned short unused; /* Align structure by 4 bytes */ 132 __u16 perm; /* IO permission */
133 __u16 prio; /* IO priority */
129 struct saddr addr; /* Remote server address */ 134 struct saddr addr; /* Remote server address */
130}; 135};
131 136
@@ -921,12 +926,6 @@ static inline void pohmelfs_mcache_put(struct pohmelfs_sb *psb,
921 pohmelfs_mcache_free(psb, m); 926 pohmelfs_mcache_free(psb, m);
922} 927}
923 928
924int pohmelfs_ftrans_init(void);
925void pohmelfs_ftrans_exit(void);
926void pohmelfs_ftrans_update(u64 id);
927int pohmelfs_ftrans_check(u64 id);
928void pohmelfs_ftrans_clean(u64 id);
929
930#endif /* __KERNEL__*/ 929#endif /* __KERNEL__*/
931 930
932#endif /* __NETFS_H */ 931#endif /* __NETFS_H */
diff --git a/drivers/staging/pohmelfs/trans.c b/drivers/staging/pohmelfs/trans.c
index bcb59425a21c..fef5f9bd6920 100644
--- a/drivers/staging/pohmelfs/trans.c
+++ b/drivers/staging/pohmelfs/trans.c
@@ -456,34 +456,25 @@ int netfs_trans_finish_send(struct netfs_trans *t, struct pohmelfs_sb *psb)
456 __func__, t, t->gen, t->iovec.iov_len, t->page_num, psb->active_state); 456 __func__, t, t->gen, t->iovec.iov_len, t->page_num, psb->active_state);
457#endif 457#endif
458 mutex_lock(&psb->state_lock); 458 mutex_lock(&psb->state_lock);
459 list_for_each_entry(c, &psb->state_list, config_entry) {
460 st = &c->state;
459 461
460 if ((t->flags & NETFS_TRANS_SINGLE_DST) && psb->active_state) { 462 if (t->flags & NETFS_TRANS_SINGLE_DST) {
461 st = &psb->active_state->state; 463 if (!(st->ctl.perm & POHMELFS_IO_PERM_READ))
462 464 continue;
463 err = -EPIPE; 465 } else {
464 if (netfs_state_poll(st) & POLLOUT) { 466 if (!(st->ctl.perm & POHMELFS_IO_PERM_WRITE))
465 err = netfs_trans_push_dst(t, st); 467 continue;
466 if (!err) {
467 err = netfs_trans_send(t, st);
468 if (err) {
469 netfs_trans_drop_last(t, st);
470 } else {
471 pohmelfs_switch_active(psb);
472 goto out;
473 }
474 }
475 } 468 }
476 pohmelfs_switch_active(psb);
477 }
478 469
479 list_for_each_entry(c, &psb->state_list, config_entry) { 470 if (psb->active_state && (psb->active_state->state.ctl.prio >= st->ctl.prio))
480 st = &c->state; 471 st = &psb->active_state->state;
481 472
482 err = netfs_trans_push(t, st); 473 err = netfs_trans_push(t, st);
483 if (!err && (t->flags & NETFS_TRANS_SINGLE_DST)) 474 if (!err && (t->flags & NETFS_TRANS_SINGLE_DST))
484 break; 475 break;
485 } 476 }
486out: 477
487 mutex_unlock(&psb->state_lock); 478 mutex_unlock(&psb->state_lock);
488#if 0 479#if 0
489 dprintk("%s: fully sent t: %p, gen: %u, size: %u, page_num: %u, err: %d.\n", 480 dprintk("%s: fully sent t: %p, gen: %u, size: %u, page_num: %u, err: %d.\n",
@@ -501,8 +492,6 @@ int netfs_trans_finish(struct netfs_trans *t, struct pohmelfs_sb *psb)
501 492
502 t->gen = atomic_inc_return(&psb->trans_gen); 493 t->gen = atomic_inc_return(&psb->trans_gen);
503 494
504 pohmelfs_ftrans_clean(t->gen);
505
506 cmd->size = t->iovec.iov_len - sizeof(struct netfs_cmd) + 495 cmd->size = t->iovec.iov_len - sizeof(struct netfs_cmd) +
507 t->attached_size + t->attached_pages * sizeof(struct netfs_cmd); 496 t->attached_size + t->attached_pages * sizeof(struct netfs_cmd);
508 cmd->cmd = NETFS_TRANS; 497 cmd->cmd = NETFS_TRANS;
diff --git a/drivers/staging/rt2860/rt_main_dev.c b/drivers/staging/rt2860/rt_main_dev.c
index cf17bcdd7333..6c4396f0903b 100644
--- a/drivers/staging/rt2860/rt_main_dev.c
+++ b/drivers/staging/rt2860/rt_main_dev.c
@@ -722,6 +722,20 @@ err:
722 return (-1); 722 return (-1);
723} /* End of rt28xx_open */ 723} /* End of rt28xx_open */
724 724
725static const struct net_device_ops rt2860_netdev_ops = {
726 .ndo_open = MainVirtualIF_open,
727 .ndo_stop = MainVirtualIF_close,
728 .ndo_do_ioctl = rt28xx_ioctl,
729 .ndo_get_stats = RT28xx_get_ether_stats,
730 .ndo_validate_addr = NULL,
731 .ndo_set_mac_address = eth_mac_addr,
732 .ndo_change_mtu = eth_change_mtu,
733#ifdef IKANOS_VX_1X0
734 .ndo_start_xmit = IKANOS_DataFramesTx,
735#else
736 .ndo_start_xmit = rt28xx_send_packets,
737#endif
738};
725 739
726/* Must not be called for mdev and apdev */ 740/* Must not be called for mdev and apdev */
727static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd) 741static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd)
@@ -733,11 +747,6 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
733 747
734 748
735 //ether_setup(dev); 749 //ether_setup(dev);
736 dev->hard_start_xmit = rt28xx_send_packets;
737
738#ifdef IKANOS_VX_1X0
739 dev->hard_start_xmit = IKANOS_DataFramesTx;
740#endif // IKANOS_VX_1X0 //
741 750
742#ifdef CONFIG_STA_SUPPORT 751#ifdef CONFIG_STA_SUPPORT
743#if WIRELESS_EXT >= 12 752#if WIRELESS_EXT >= 12
@@ -760,12 +769,8 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
760#if WIRELESS_EXT < 21 769#if WIRELESS_EXT < 21
761 dev->get_wireless_stats = rt28xx_get_wireless_stats; 770 dev->get_wireless_stats = rt28xx_get_wireless_stats;
762#endif 771#endif
763 dev->get_stats = RT28xx_get_ether_stats;
764 dev->open = MainVirtualIF_open; //rt28xx_open;
765 dev->stop = MainVirtualIF_close; //rt28xx_close;
766 dev->priv_flags = INT_MAIN; 772 dev->priv_flags = INT_MAIN;
767 dev->do_ioctl = rt28xx_ioctl; 773 dev->netdev_ops = &rt2860_netdev_ops;
768 dev->validate_addr = NULL;
769 // find available device name 774 // find available device name
770 for (i = 0; i < 8; i++) 775 for (i = 0; i < 8; i++)
771 { 776 {
diff --git a/drivers/staging/rt2870/rt2870.h b/drivers/staging/rt2870/rt2870.h
index 5dd15aac9ce7..a42caa370808 100644
--- a/drivers/staging/rt2870/rt2870.h
+++ b/drivers/staging/rt2870/rt2870.h
@@ -96,6 +96,7 @@
96 {USB_DEVICE(0x0DF6,0x002B)}, /* Sitecom */ \ 96 {USB_DEVICE(0x0DF6,0x002B)}, /* Sitecom */ \
97 {USB_DEVICE(0x0DF6,0x002C)}, /* Sitecom */ \ 97 {USB_DEVICE(0x0DF6,0x002C)}, /* Sitecom */ \
98 {USB_DEVICE(0x0DF6,0x002D)}, /* Sitecom */ \ 98 {USB_DEVICE(0x0DF6,0x002D)}, /* Sitecom */ \
99 {USB_DEVICE(0x0DF6,0x0039)}, /* Sitecom */ \
99 {USB_DEVICE(0x14B2,0x3C06)}, /* Conceptronic */ \ 100 {USB_DEVICE(0x14B2,0x3C06)}, /* Conceptronic */ \
100 {USB_DEVICE(0x14B2,0x3C28)}, /* Conceptronic */ \ 101 {USB_DEVICE(0x14B2,0x3C28)}, /* Conceptronic */ \
101 {USB_DEVICE(0x2019,0xED06)}, /* Planex Communications, Inc. */ \ 102 {USB_DEVICE(0x2019,0xED06)}, /* Planex Communications, Inc. */ \
diff --git a/drivers/staging/rt2870/rt_main_dev.c b/drivers/staging/rt2870/rt_main_dev.c
index 313ecea0bfa8..48ad41136d0f 100644
--- a/drivers/staging/rt2870/rt_main_dev.c
+++ b/drivers/staging/rt2870/rt_main_dev.c
@@ -855,6 +855,20 @@ err:
855 return (-1); 855 return (-1);
856} /* End of rt28xx_open */ 856} /* End of rt28xx_open */
857 857
858static const struct net_device_ops rt2870_netdev_ops = {
859 .ndo_open = MainVirtualIF_open,
860 .ndo_stop = MainVirtualIF_close,
861 .ndo_do_ioctl = rt28xx_ioctl,
862 .ndo_get_stats = RT28xx_get_ether_stats,
863 .ndo_validate_addr = NULL,
864 .ndo_set_mac_address = eth_mac_addr,
865 .ndo_change_mtu = eth_change_mtu,
866#ifdef IKANOS_VX_1X0
867 .ndo_start_xmit = IKANOS_DataFramesTx,
868#else
869 .ndo_start_xmit = rt28xx_send_packets,
870#endif
871};
858 872
859/* Must not be called for mdev and apdev */ 873/* Must not be called for mdev and apdev */
860static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd) 874static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd)
@@ -866,12 +880,6 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
866 880
867 881
868 //ether_setup(dev); 882 //ether_setup(dev);
869 dev->hard_start_xmit = rt28xx_send_packets;
870
871#ifdef IKANOS_VX_1X0
872 dev->hard_start_xmit = IKANOS_DataFramesTx;
873#endif // IKANOS_VX_1X0 //
874
875// dev->set_multicast_list = ieee80211_set_multicast_list; 883// dev->set_multicast_list = ieee80211_set_multicast_list;
876// dev->change_mtu = ieee80211_change_mtu; 884// dev->change_mtu = ieee80211_change_mtu;
877#ifdef CONFIG_STA_SUPPORT 885#ifdef CONFIG_STA_SUPPORT
@@ -895,16 +903,10 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
895#if WIRELESS_EXT < 21 903#if WIRELESS_EXT < 21
896 dev->get_wireless_stats = rt28xx_get_wireless_stats; 904 dev->get_wireless_stats = rt28xx_get_wireless_stats;
897#endif 905#endif
898 dev->get_stats = RT28xx_get_ether_stats;
899 dev->open = MainVirtualIF_open; //rt28xx_open;
900 dev->stop = MainVirtualIF_close; //rt28xx_close;
901// dev->uninit = ieee80211_if_reinit; 906// dev->uninit = ieee80211_if_reinit;
902// dev->destructor = ieee80211_if_free; 907// dev->destructor = ieee80211_if_free;
903 dev->priv_flags = INT_MAIN; 908 dev->priv_flags = INT_MAIN;
904 dev->do_ioctl = rt28xx_ioctl; 909 dev->netdev_ops = &rt2870_netdev_ops;
905#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
906 dev->validate_addr = NULL;
907#endif
908 // find available device name 910 // find available device name
909 for (i = 0; i < 8; i++) 911 for (i = 0; i < 8; i++)
910 { 912 {
diff --git a/drivers/staging/rt3070/rt_main_dev.c b/drivers/staging/rt3070/rt_main_dev.c
index c000646286e6..81f769cf1096 100644
--- a/drivers/staging/rt3070/rt_main_dev.c
+++ b/drivers/staging/rt3070/rt_main_dev.c
@@ -436,7 +436,6 @@ static int rt28xx_init(IN struct net_device *net_dev)
436// OID_SET_HT_PHYMODE SetHT; 436// OID_SET_HT_PHYMODE SetHT;
437// WPDMA_GLO_CFG_STRUC GloCfg; 437// WPDMA_GLO_CFG_STRUC GloCfg;
438 UINT32 MacCsr0 = 0; 438 UINT32 MacCsr0 = 0;
439 UINT32 MacValue = 0;
440 439
441#ifdef RT2870 440#ifdef RT2870
442#ifdef INF_AMAZON_SE 441#ifdef INF_AMAZON_SE
@@ -849,6 +848,20 @@ err:
849 return (-1); 848 return (-1);
850} /* End of rt28xx_open */ 849} /* End of rt28xx_open */
851 850
851static const struct net_device_ops rt3070_netdev_ops = {
852 .ndo_open = MainVirtualIF_open,
853 .ndo_stop = MainVirtualIF_close,
854 .ndo_do_ioctl = rt28xx_ioctl,
855 .ndo_get_stats = RT28xx_get_ether_stats,
856 .ndo_validate_addr = NULL,
857 .ndo_set_mac_address = eth_mac_addr,
858 .ndo_change_mtu = eth_change_mtu,
859#ifdef IKANOS_VX_1X0
860 .ndo_start_xmit = IKANOS_DataFramesTx,
861#else
862 .ndo_start_xmit = rt28xx_send_packets,
863#endif
864};
852 865
853/* Must not be called for mdev and apdev */ 866/* Must not be called for mdev and apdev */
854static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd) 867static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER pAd)
@@ -860,12 +873,6 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
860 873
861 874
862 //ether_setup(dev); 875 //ether_setup(dev);
863 dev->hard_start_xmit = rt28xx_send_packets;
864
865#ifdef IKANOS_VX_1X0
866 dev->hard_start_xmit = IKANOS_DataFramesTx;
867#endif // IKANOS_VX_1X0 //
868
869// dev->set_multicast_list = ieee80211_set_multicast_list; 876// dev->set_multicast_list = ieee80211_set_multicast_list;
870// dev->change_mtu = ieee80211_change_mtu; 877// dev->change_mtu = ieee80211_change_mtu;
871#ifdef CONFIG_STA_SUPPORT 878#ifdef CONFIG_STA_SUPPORT
@@ -889,16 +896,10 @@ static NDIS_STATUS rt_ieee80211_if_setup(struct net_device *dev, PRTMP_ADAPTER p
889#if WIRELESS_EXT < 21 896#if WIRELESS_EXT < 21
890 dev->get_wireless_stats = rt28xx_get_wireless_stats; 897 dev->get_wireless_stats = rt28xx_get_wireless_stats;
891#endif 898#endif
892 dev->get_stats = RT28xx_get_ether_stats;
893 dev->open = MainVirtualIF_open; //rt28xx_open;
894 dev->stop = MainVirtualIF_close; //rt28xx_close;
895// dev->uninit = ieee80211_if_reinit; 899// dev->uninit = ieee80211_if_reinit;
896// dev->destructor = ieee80211_if_free; 900// dev->destructor = ieee80211_if_free;
897 dev->priv_flags = INT_MAIN; 901 dev->priv_flags = INT_MAIN;
898 dev->do_ioctl = rt28xx_ioctl; 902 dev->netdev_ops = &rt3070_netdev_ops;
899#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
900 dev->validate_addr = NULL;
901#endif
902 // find available device name 903 // find available device name
903 for (i = 0; i < 8; i++) 904 for (i = 0; i < 8; i++)
904 { 905 {
diff --git a/drivers/staging/slicoss/README b/drivers/staging/slicoss/README
index 2d5b1127ce51..70f49099c065 100644
--- a/drivers/staging/slicoss/README
+++ b/drivers/staging/slicoss/README
@@ -10,7 +10,36 @@ TODO:
10 - move firmware loading to request_firmware() 10 - move firmware loading to request_firmware()
11 - remove direct memory access of structures 11 - remove direct memory access of structures
12 - any remaining sparse and checkpatch.pl warnings 12 - any remaining sparse and checkpatch.pl warnings
13 - any netdev recommended changes 13
14 - use net_device_ops
15 - use dev->stats rather than adapter->stats
16 - don't cast netdev_priv it is already void
17 - use compare_ether_addr
18 - GET RID OF MACROS
19 - work on all architectures
20 - without CONFIG_X86_64 confusion
21 - do 64 bit correctly
22 - don't depend on order of union
23 - get rid of ASSERT(), use BUG() instead but only where necessary
24 looks like most aren't really useful
25 - no new SIOCDEVPRIVATE ioctl allowed
26 - don't use module_param for configuring interrupt mitigation
27 use ethtool instead
28 - reorder code to elminate use of forward declarations
29 - don't keep private linked list of drivers.
30 - remove all the gratiutous debug infrastructure
31 - use PCI_DEVICE()
32 - do ethtool correctly using ethtool_ops
33 - NAPI?
34 - wasted overhead of extra stats
35 - state variables for things that are
36 easily availble and shouldn't be kept in card structure, cardnum, ...
37 slotnumber, events, ...
38 - get rid of slic_spinlock wrapper
39 - volatile == bad design => bad code
40 - locking too fine grained, not designed just throw more locks
41 at problem
42
14 43
15Please send patches to: 44Please send patches to:
16 Greg Kroah-Hartman <gregkh@suse.de> 45 Greg Kroah-Hartman <gregkh@suse.de>
diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c
index 948156348478..6f5d0bff4358 100644
--- a/drivers/staging/slicoss/slicoss.c
+++ b/drivers/staging/slicoss/slicoss.c
@@ -345,6 +345,19 @@ static void slic_init_adapter(struct net_device *netdev,
345 return; 345 return;
346} 346}
347 347
348static const struct net_device_ops slic_netdev_ops = {
349 .ndo_open = slic_entry_open,
350 .ndo_stop = slic_entry_halt,
351 .ndo_start_xmit = slic_xmit_start,
352 .ndo_do_ioctl = slic_ioctl,
353 .ndo_set_mac_address = slic_mac_set_address,
354 .ndo_get_stats = slic_get_stats,
355 .ndo_set_multicast_list = slic_mcast_set_list,
356 .ndo_validate_addr = eth_validate_addr,
357 .ndo_set_mac_address = eth_mac_addr,
358 .ndo_change_mtu = eth_change_mtu,
359};
360
348static int __devinit slic_entry_probe(struct pci_dev *pcidev, 361static int __devinit slic_entry_probe(struct pci_dev *pcidev,
349 const struct pci_device_id *pci_tbl_entry) 362 const struct pci_device_id *pci_tbl_entry)
350{ 363{
@@ -442,13 +455,7 @@ static int __devinit slic_entry_probe(struct pci_dev *pcidev,
442 455
443 netdev->base_addr = (unsigned long)adapter->memorybase; 456 netdev->base_addr = (unsigned long)adapter->memorybase;
444 netdev->irq = adapter->irq; 457 netdev->irq = adapter->irq;
445 netdev->open = slic_entry_open; 458 netdev->netdev_ops = &slic_netdev_ops;
446 netdev->stop = slic_entry_halt;
447 netdev->hard_start_xmit = slic_xmit_start;
448 netdev->do_ioctl = slic_ioctl;
449 netdev->set_mac_address = slic_mac_set_address;
450 netdev->get_stats = slic_get_stats;
451 netdev->set_multicast_list = slic_mcast_set_list;
452 459
453 slic_debug_adapter_create(adapter); 460 slic_debug_adapter_create(adapter);
454 461
@@ -1260,7 +1267,7 @@ static int slic_mcast_add_list(struct adapter *adapter, char *address)
1260 } 1267 }
1261 1268
1262 /* Doesn't already exist. Allocate a structure to hold it */ 1269 /* Doesn't already exist. Allocate a structure to hold it */
1263 mcaddr = kmalloc(sizeof(struct mcast_address), GFP_KERNEL); 1270 mcaddr = kmalloc(sizeof(struct mcast_address), GFP_ATOMIC);
1264 if (mcaddr == NULL) 1271 if (mcaddr == NULL)
1265 return 1; 1272 return 1;
1266 1273
@@ -2284,7 +2291,7 @@ static u32 slic_card_locate(struct adapter *adapter)
2284 } 2291 }
2285 if (!physcard) { 2292 if (!physcard) {
2286 /* no structure allocated for this physical card yet */ 2293 /* no structure allocated for this physical card yet */
2287 physcard = kzalloc(sizeof(struct physcard), GFP_KERNEL); 2294 physcard = kzalloc(sizeof(struct physcard), GFP_ATOMIC);
2288 ASSERT(physcard); 2295 ASSERT(physcard);
2289 2296
2290 physcard->next = slic_global.phys_card; 2297 physcard->next = slic_global.phys_card;
diff --git a/drivers/staging/stlc45xx/Kconfig b/drivers/staging/stlc45xx/Kconfig
index 8d3f46f190e8..947fb75a9c68 100644
--- a/drivers/staging/stlc45xx/Kconfig
+++ b/drivers/staging/stlc45xx/Kconfig
@@ -1,6 +1,6 @@
1config STLC45XX 1config STLC45XX
2 tristate "stlc4550/4560 support" 2 tristate "stlc4550/4560 support"
3 depends on MAC80211 && WLAN_80211 && SPI_MASTER 3 depends on MAC80211 && WLAN_80211 && SPI_MASTER && GENERIC_HARDIRQS
4 ---help--- 4 ---help---
5 This is a driver for stlc4550 and stlc4560 chipsets. 5 This is a driver for stlc4550 and stlc4560 chipsets.
6 6
diff --git a/drivers/staging/sxg/sxg.c b/drivers/staging/sxg/sxg.c
index 891f6e334672..076b3f7d39eb 100644
--- a/drivers/staging/sxg/sxg.c
+++ b/drivers/staging/sxg/sxg.c
@@ -322,6 +322,8 @@ int sxg_add_msi_isr(struct adapter_t *adapter)
322 int ret,i; 322 int ret,i;
323 323
324 if (!adapter->intrregistered) { 324 if (!adapter->intrregistered) {
325 spin_unlock_irqrestore(&sxg_global.driver_lock,
326 sxg_global.flags);
325 for (i=0; i<adapter->nr_msix_entries; i++) { 327 for (i=0; i<adapter->nr_msix_entries; i++) {
326 ret = request_irq (adapter->msi_entries[i].vector, 328 ret = request_irq (adapter->msi_entries[i].vector,
327 sxg_isr, 329 sxg_isr,
@@ -329,6 +331,8 @@ int sxg_add_msi_isr(struct adapter_t *adapter)
329 adapter->netdev->name, 331 adapter->netdev->name,
330 adapter->netdev); 332 adapter->netdev);
331 if (ret) { 333 if (ret) {
334 spin_lock_irqsave(&sxg_global.driver_lock,
335 sxg_global.flags);
332 DBG_ERROR("sxg: MSI-X request_irq (%s) " 336 DBG_ERROR("sxg: MSI-X request_irq (%s) "
333 "FAILED [%x]\n", adapter->netdev->name, 337 "FAILED [%x]\n", adapter->netdev->name,
334 ret); 338 ret);
@@ -336,6 +340,7 @@ int sxg_add_msi_isr(struct adapter_t *adapter)
336 } 340 }
337 } 341 }
338 } 342 }
343 spin_lock_irqsave(&sxg_global.driver_lock, sxg_global.flags);
339 adapter->msi_enabled = TRUE; 344 adapter->msi_enabled = TRUE;
340 adapter->intrregistered = 1; 345 adapter->intrregistered = 1;
341 adapter->IntRegistered = TRUE; 346 adapter->IntRegistered = TRUE;
@@ -896,6 +901,22 @@ static inline int sxg_read_config(struct adapter_t *adapter)
896 return status; 901 return status;
897} 902}
898 903
904static const struct net_device_ops sxg_netdev_ops = {
905 .ndo_open = sxg_entry_open,
906 .ndo_stop = sxg_entry_halt,
907 .ndo_start_xmit = sxg_send_packets,
908 .ndo_do_ioctl = sxg_ioctl,
909 .ndo_change_mtu = sxg_change_mtu,
910 .ndo_get_stats = sxg_get_stats,
911 .ndo_set_multicast_list = sxg_mcast_set_list,
912 .ndo_validate_addr = eth_validate_addr,
913#if XXXTODO
914 .ndo_set_mac_address = sxg_mac_set_address,
915#else
916 .ndo_set_mac_address = eth_mac_addr,
917#endif
918};
919
899static int sxg_entry_probe(struct pci_dev *pcidev, 920static int sxg_entry_probe(struct pci_dev *pcidev,
900 const struct pci_device_id *pci_tbl_entry) 921 const struct pci_device_id *pci_tbl_entry)
901{ 922{
@@ -1095,16 +1116,7 @@ static int sxg_entry_probe(struct pci_dev *pcidev,
1095 1116
1096 netdev->base_addr = (unsigned long)adapter->base_addr; 1117 netdev->base_addr = (unsigned long)adapter->base_addr;
1097 netdev->irq = adapter->irq; 1118 netdev->irq = adapter->irq;
1098 netdev->open = sxg_entry_open; 1119 netdev->netdev_ops = &sxg_netdev_ops;
1099 netdev->stop = sxg_entry_halt;
1100 netdev->hard_start_xmit = sxg_send_packets;
1101 netdev->do_ioctl = sxg_ioctl;
1102 netdev->change_mtu = sxg_change_mtu;
1103#if XXXTODO
1104 netdev->set_mac_address = sxg_mac_set_address;
1105#endif
1106 netdev->get_stats = sxg_get_stats;
1107 netdev->set_multicast_list = sxg_mcast_set_list;
1108 SET_ETHTOOL_OPS(netdev, &sxg_nic_ethtool_ops); 1120 SET_ETHTOOL_OPS(netdev, &sxg_nic_ethtool_ops);
1109 netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 1121 netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
1110 err = sxg_set_interrupt_capability(adapter); 1122 err = sxg_set_interrupt_capability(adapter);
@@ -2247,6 +2259,8 @@ static int sxg_entry_open(struct net_device *dev)
2247 DBG_ERROR("sxg: %s EXIT\n", __func__); 2259 DBG_ERROR("sxg: %s EXIT\n", __func__);
2248 2260
2249 spin_unlock_irqrestore(&sxg_global.driver_lock, sxg_global.flags); 2261 spin_unlock_irqrestore(&sxg_global.driver_lock, sxg_global.flags);
2262 mod_timer(&adapter->watchdog_timer, jiffies);
2263
2250 return STATUS_SUCCESS; 2264 return STATUS_SUCCESS;
2251} 2265}
2252 2266
@@ -2568,6 +2582,7 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2568 u64 phys_addr; 2582 u64 phys_addr;
2569 unsigned long flags; 2583 unsigned long flags;
2570 unsigned long queue_id=0; 2584 unsigned long queue_id=0;
2585 int offload_cksum = 0;
2571 2586
2572 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "DumbSgl", 2587 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "DumbSgl",
2573 pSgl, SxgSgl, 0, 0); 2588 pSgl, SxgSgl, 0, 0);
@@ -2606,7 +2621,11 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2606 struct iphdr *ip; 2621 struct iphdr *ip;
2607 2622
2608 ip = ip_hdr(skb); 2623 ip = ip_hdr(skb);
2609 if ((ip->protocol == IPPROTO_TCP)&&(DataLength >= sizeof( 2624 if (ip->protocol == IPPROTO_TCP)
2625 offload_cksum = 1;
2626 if (!offload_cksum || !tcp_hdr(skb))
2627 queue_id = 0;
2628 else if (offload_cksum && (DataLength >= sizeof(
2610 struct tcphdr))){ 2629 struct tcphdr))){
2611 queue_id = ((ntohs(tcp_hdr(skb)->dest) == ISCSI_PORT) ? 2630 queue_id = ((ntohs(tcp_hdr(skb)->dest) == ISCSI_PORT) ?
2612 (ntohs (tcp_hdr(skb)->source) & 2631 (ntohs (tcp_hdr(skb)->source) &
@@ -2615,8 +2634,11 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2615 SXG_LARGE_SEND_QUEUE_MASK)); 2634 SXG_LARGE_SEND_QUEUE_MASK));
2616 } 2635 }
2617 } else if (skb->protocol == htons(ETH_P_IPV6)) { 2636 } else if (skb->protocol == htons(ETH_P_IPV6)) {
2618 if ((ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) && (DataLength >= 2637 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
2619 sizeof(struct tcphdr)) ) { 2638 offload_cksum = 1;
2639 if (!offload_cksum || !tcp_hdr(skb))
2640 queue_id = 0;
2641 else if (offload_cksum && (DataLength>=sizeof(struct tcphdr))){
2620 queue_id = ((ntohs(tcp_hdr(skb)->dest) == ISCSI_PORT) ? 2642 queue_id = ((ntohs(tcp_hdr(skb)->dest) == ISCSI_PORT) ?
2621 (ntohs (tcp_hdr(skb)->source) & 2643 (ntohs (tcp_hdr(skb)->source) &
2622 SXG_LARGE_SEND_QUEUE_MASK): 2644 SXG_LARGE_SEND_QUEUE_MASK):
@@ -2645,23 +2667,38 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2645 } 2667 }
2646 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "DumbCmd", 2668 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "DumbCmd",
2647 XmtCmd, XmtRingInfo->Head, XmtRingInfo->Tail, 0); 2669 XmtCmd, XmtRingInfo->Head, XmtRingInfo->Tail, 0);
2648 /* Update stats */ 2670 memset(XmtCmd, '\0', sizeof(*XmtCmd));
2649 adapter->stats.tx_packets++; 2671 XmtCmd->SgEntries = 1;
2650 adapter->stats.tx_bytes += DataLength; 2672 XmtCmd->Flags = 0;
2651#if XXXTODO /* Stats stuff */ 2673 if (skb->ip_summed == CHECKSUM_PARTIAL) {
2652 if (SXG_MULTICAST_PACKET(EtherHdr)) { 2674 /*
2653 if (SXG_BROADCAST_PACKET(EtherHdr)) { 2675 * We need to set the Checkum in IP header to 0. This is
2654 adapter->Stats.DumbXmtBcastPkts++; 2676 * required by hardware.
2655 adapter->Stats.DumbXmtBcastBytes += DataLength; 2677 */
2678 if (offload_cksum) {
2679 ip_hdr(skb)->check = 0x0;
2680 XmtCmd->CsumFlags.Flags |= SXG_SLOWCMD_CSUM_IP;
2681 XmtCmd->CsumFlags.Flags |= SXG_SLOWCMD_CSUM_TCP;
2682 /*
2683 * Dont know if length will require a change in
2684 * case of VLAN
2685 */
2686 XmtCmd->CsumFlags.MacLen = ETH_HLEN;
2687 XmtCmd->CsumFlags.IpHl = skb_network_header_len(skb) >>
2688 SXG_NW_HDR_LEN_SHIFT;
2656 } else { 2689 } else {
2657 adapter->Stats.DumbXmtMcastPkts++; 2690 if (skb_checksum_help(skb)){
2658 adapter->Stats.DumbXmtMcastBytes += DataLength; 2691 printk(KERN_EMERG "Dropped UDP packet for"
2692 " incorrect checksum calculation\n");
2693 if (XmtCmd)
2694 SXG_ABORT_CMD(XmtRingInfo);
2695 spin_unlock_irqrestore(&adapter->XmtZeroLock,
2696 flags);
2697 return STATUS_SUCCESS;
2698 }
2659 } 2699 }
2660 } else {
2661 adapter->Stats.DumbXmtUcastPkts++;
2662 adapter->Stats.DumbXmtUcastBytes += DataLength;
2663 } 2700 }
2664#endif 2701
2665 /* 2702 /*
2666 * Fill in the command 2703 * Fill in the command
2667 * Copy out the first SGE to the command and adjust for offset 2704 * Copy out the first SGE to the command and adjust for offset
@@ -2679,31 +2716,17 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2679 (SXG_INVALID_SGL(phys_addr,skb->data_len))) 2716 (SXG_INVALID_SGL(phys_addr,skb->data_len)))
2680 { 2717 {
2681 spin_unlock_irqrestore(&adapter->XmtZeroLock, flags); 2718 spin_unlock_irqrestore(&adapter->XmtZeroLock, flags);
2719 if (XmtCmd)
2720 SXG_ABORT_CMD(XmtRingInfo);
2682 /* Silently drop this packet */ 2721 /* Silently drop this packet */
2683 printk(KERN_EMERG"Dropped a packet for 64k boundary problem\n"); 2722 printk(KERN_EMERG"Dropped a packet for 64k boundary problem\n");
2684 return STATUS_SUCCESS; 2723 return STATUS_SUCCESS;
2685 } 2724 }
2686 memset(XmtCmd, '\0', sizeof(*XmtCmd));
2687 XmtCmd->Buffer.FirstSgeAddress = phys_addr; 2725 XmtCmd->Buffer.FirstSgeAddress = phys_addr;
2688 XmtCmd->Buffer.FirstSgeLength = DataLength; 2726 XmtCmd->Buffer.FirstSgeLength = DataLength;
2689 XmtCmd->Buffer.SgeOffset = 0; 2727 XmtCmd->Buffer.SgeOffset = 0;
2690 XmtCmd->Buffer.TotalLength = DataLength; 2728 XmtCmd->Buffer.TotalLength = DataLength;
2691 XmtCmd->SgEntries = 1;
2692 XmtCmd->Flags = 0;
2693 2729
2694 if (skb->ip_summed == CHECKSUM_PARTIAL) {
2695 /*
2696 * We need to set the Checkum in IP header to 0. This is
2697 * required by hardware.
2698 */
2699 ip_hdr(skb)->check = 0x0;
2700 XmtCmd->CsumFlags.Flags |= SXG_SLOWCMD_CSUM_IP;
2701 XmtCmd->CsumFlags.Flags |= SXG_SLOWCMD_CSUM_TCP;
2702 /* Dont know if length will require a change in case of VLAN */
2703 XmtCmd->CsumFlags.MacLen = ETH_HLEN;
2704 XmtCmd->CsumFlags.IpHl = skb_network_header_len(skb) >>
2705 SXG_NW_HDR_LEN_SHIFT;
2706 }
2707 /* 2730 /*
2708 * Advance transmit cmd descripter by 1. 2731 * Advance transmit cmd descripter by 1.
2709 * NOTE - See comments in SxgTcpOutput where we write 2732 * NOTE - See comments in SxgTcpOutput where we write
@@ -2715,6 +2738,24 @@ static int sxg_dumb_sgl(struct sxg_x64_sgl *pSgl,
2715 ASSERT((queue_id & ~SXG_LARGE_SEND_QUEUE_MASK) == 0); 2738 ASSERT((queue_id & ~SXG_LARGE_SEND_QUEUE_MASK) == 0);
2716 WRITE_REG(adapter->UcodeRegs[0].XmtCmd, ((queue_id << 16) | 1), TRUE); 2739 WRITE_REG(adapter->UcodeRegs[0].XmtCmd, ((queue_id << 16) | 1), TRUE);
2717 adapter->Stats.XmtQLen++; /* Stats within lock */ 2740 adapter->Stats.XmtQLen++; /* Stats within lock */
2741 /* Update stats */
2742 adapter->stats.tx_packets++;
2743 adapter->stats.tx_bytes += DataLength;
2744#if XXXTODO /* Stats stuff */
2745 if (SXG_MULTICAST_PACKET(EtherHdr)) {
2746 if (SXG_BROADCAST_PACKET(EtherHdr)) {
2747 adapter->Stats.DumbXmtBcastPkts++;
2748 adapter->Stats.DumbXmtBcastBytes += DataLength;
2749 } else {
2750 adapter->Stats.DumbXmtMcastPkts++;
2751 adapter->Stats.DumbXmtMcastBytes += DataLength;
2752 }
2753 } else {
2754 adapter->Stats.DumbXmtUcastPkts++;
2755 adapter->Stats.DumbXmtUcastBytes += DataLength;
2756 }
2757#endif
2758
2718 spin_unlock_irqrestore(&adapter->XmtZeroLock, flags); 2759 spin_unlock_irqrestore(&adapter->XmtZeroLock, flags);
2719 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "XDumSgl2", 2760 SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "XDumSgl2",
2720 XmtCmd, pSgl, SxgSgl, 0); 2761 XmtCmd, pSgl, SxgSgl, 0);
diff --git a/drivers/staging/uc2322/aten2011.c b/drivers/staging/uc2322/aten2011.c
index 85b705453066..9c62f787cc9c 100644
--- a/drivers/staging/uc2322/aten2011.c
+++ b/drivers/staging/uc2322/aten2011.c
@@ -603,10 +603,9 @@ static void ATEN2011_bulk_out_data_callback(struct urb *urb)
603 603
604 tty = tty_port_tty_get(&ATEN2011_port->port->port); 604 tty = tty_port_tty_get(&ATEN2011_port->port->port);
605 605
606 if (tty && ATEN2011_port->open) { 606 if (tty && ATEN2011_port->open)
607 /* tell the tty driver that something has changed */ 607 /* tell the tty driver that something has changed */
608 wake_up_interruptible(&tty->write_wait); 608 tty_wakeup(tty);
609 }
610 609
611 /* schedule_work(&ATEN2011_port->port->work); */ 610 /* schedule_work(&ATEN2011_port->port->work); */
612 tty_kref_put(tty); 611 tty_kref_put(tty);
@@ -825,12 +824,6 @@ static int ATEN2011_open(struct tty_struct *tty, struct usb_serial_port *port,
825 status = 0; 824 status = 0;
826 status = set_reg_sync(port, ATEN2011_port->ControlRegOffset, Data); 825 status = set_reg_sync(port, ATEN2011_port->ControlRegOffset, Data);
827 826
828 /* force low_latency on so that our tty_push actually forces *
829 * the data through,otherwise it is scheduled, and with *
830 * high data rates (like with OHCI) data can get lost. */
831
832 if (tty)
833 tty->low_latency = 1;
834 /* 827 /*
835 * Check to see if we've set up our endpoint info yet 828 * Check to see if we've set up our endpoint info yet
836 * (can't set it up in ATEN2011_startup as the structures 829 * (can't set it up in ATEN2011_startup as the structures
@@ -1473,22 +1466,7 @@ static void ATEN2011_set_termios(struct tty_struct *tty,
1473 1466
1474 cflag = tty->termios->c_cflag; 1467 cflag = tty->termios->c_cflag;
1475 1468
1476 if (!cflag) { 1469 dbg("%s - cflag %08x iflag %08x", __func__,
1477 dbg("%s %s", __func__, "cflag is NULL");
1478 return;
1479 }
1480
1481 /* check that they really want us to change something */
1482 if (old_termios) {
1483 if ((cflag == old_termios->c_cflag) &&
1484 (RELEVANT_IFLAG(tty->termios->c_iflag) ==
1485 RELEVANT_IFLAG(old_termios->c_iflag))) {
1486 dbg("%s", "Nothing to change");
1487 return;
1488 }
1489 }
1490
1491 dbg("%s - clfag %08x iflag %08x", __func__,
1492 tty->termios->c_cflag, RELEVANT_IFLAG(tty->termios->c_iflag)); 1470 tty->termios->c_cflag, RELEVANT_IFLAG(tty->termios->c_iflag));
1493 1471
1494 if (old_termios) { 1472 if (old_termios) {
diff --git a/drivers/staging/wlan-ng/p80211netdev.c b/drivers/staging/wlan-ng/p80211netdev.c
index b2a606a36936..393e4df70dfd 100644
--- a/drivers/staging/wlan-ng/p80211netdev.c
+++ b/drivers/staging/wlan-ng/p80211netdev.c
@@ -711,6 +711,20 @@ static int wlan_change_mtu(netdevice_t *dev, int new_mtu)
711 return 0; 711 return 0;
712} 712}
713 713
714static const struct net_device_ops p80211_netdev_ops = {
715 .ndo_init = p80211knetdev_init,
716 .ndo_open = p80211knetdev_open,
717 .ndo_stop = p80211knetdev_stop,
718 .ndo_get_stats = p80211knetdev_get_stats,
719 .ndo_start_xmit = p80211knetdev_hard_start_xmit,
720 .ndo_set_multicast_list = p80211knetdev_set_multicast_list,
721 .ndo_do_ioctl = p80211knetdev_do_ioctl,
722 .ndo_set_mac_address = p80211knetdev_set_mac_address,
723 .ndo_tx_timeout = p80211knetdev_tx_timeout,
724 .ndo_change_mtu = wlan_change_mtu,
725 .ndo_validate_addr = eth_validate_addr,
726};
727
714/*---------------------------------------------------------------- 728/*----------------------------------------------------------------
715* wlan_setup 729* wlan_setup
716* 730*
@@ -756,11 +770,7 @@ int wlan_setup(wlandevice_t *wlandev)
756 } else { 770 } else {
757 wlandev->netdev = dev; 771 wlandev->netdev = dev;
758 dev->ml_priv = wlandev; 772 dev->ml_priv = wlandev;
759 dev->hard_start_xmit = p80211knetdev_hard_start_xmit; 773 dev->netdev_ops = &p80211_netdev_ops;
760 dev->get_stats = p80211knetdev_get_stats;
761 dev->init = p80211knetdev_init;
762 dev->open = p80211knetdev_open;
763 dev->stop = p80211knetdev_stop;
764 774
765 mutex_init(&wlandev->ioctl_lock); 775 mutex_init(&wlandev->ioctl_lock);
766 /* block ioctls until fully initialised. Don't forget to call 776 /* block ioctls until fully initialised. Don't forget to call
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-07 02:33:46 -0500