tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge master.kernel.org:/home/rmk/linux-2.6-mmc

Linus Torvalds a2b421fe ba027def

+20 -18
unified split
+14 -13
drivers/mfd/ucb1x00-core.c
··· 24 24 #include <linux/errno.h> 25 25 #include <linux/interrupt.h> 26 26 #include <linux/device.h> 27 + #include <linux/mutex.h> 27 28 28 29 #include <asm/dma.h> 29 30 #include <asm/hardware.h> 30 31 31 32 #include "ucb1x00.h" 32 33 33 - static DECLARE_MUTEX(ucb1x00_sem); 34 + static DEFINE_MUTEX(ucb1x00_mutex); 34 35 static LIST_HEAD(ucb1x00_drivers); 35 36 static LIST_HEAD(ucb1x00_devices); 36 37 ··· 522 521 goto err_irq; 523 522 524 523 INIT_LIST_HEAD(&ucb->devs); 525 - down(&ucb1x00_sem); 524 + mutex_lock(&ucb1x00_mutex); 526 525 list_add(&ucb->node, &ucb1x00_devices); 527 526 list_for_each_entry(drv, &ucb1x00_drivers, node) { 528 527 ucb1x00_add_dev(ucb, drv); 529 528 } 530 - up(&ucb1x00_sem); 529 + mutex_unlock(&ucb1x00_mutex); 531 530 goto out; 532 531 533 532 err_irq: ··· 545 544 struct ucb1x00 *ucb = mcp_get_drvdata(mcp); 546 545 struct list_head *l, *n; 547 546 548 - down(&ucb1x00_sem); 547 + mutex_lock(&ucb1x00_mutex); 549 548 list_del(&ucb->node); 550 549 list_for_each_safe(l, n, &ucb->devs) { 551 550 struct ucb1x00_dev *dev = list_entry(l, struct ucb1x00_dev, dev_node); 552 551 ucb1x00_remove_dev(dev); 553 552 } 554 - up(&ucb1x00_sem); 553 + mutex_unlock(&ucb1x00_mutex); 555 554 556 555 free_irq(ucb->irq, ucb); 557 556 class_device_unregister(&ucb->cdev); ··· 562 561 struct ucb1x00 *ucb; 563 562 564 563 INIT_LIST_HEAD(&drv->devs); 565 - down(&ucb1x00_sem); 564 + mutex_lock(&ucb1x00_mutex); 566 565 list_add(&drv->node, &ucb1x00_drivers); 567 566 list_for_each_entry(ucb, &ucb1x00_devices, node) { 568 567 ucb1x00_add_dev(ucb, drv); 569 568 } 570 - up(&ucb1x00_sem); 569 + mutex_unlock(&ucb1x00_mutex); 571 570 return 0; 572 571 } 573 572 ··· 575 574 { 576 575 struct list_head *n, *l; 577 576 578 - down(&ucb1x00_sem); 577 + mutex_lock(&ucb1x00_mutex); 579 578 list_del(&drv->node); 580 579 list_for_each_safe(l, n, &drv->devs) { 581 580 struct ucb1x00_dev *dev = list_entry(l, struct ucb1x00_dev, drv_node); 582 581 ucb1x00_remove_dev(dev); 583 582 } 584 - up(&ucb1x00_sem); 583 + mutex_unlock(&ucb1x00_mutex); 585 584 } 586 585 587 586 static int ucb1x00_suspend(struct mcp *mcp, pm_message_t state) ··· 589 588 struct ucb1x00 *ucb = mcp_get_drvdata(mcp); 590 589 struct ucb1x00_dev *dev; 591 590 592 - down(&ucb1x00_sem); 591 + mutex_lock(&ucb1x00_mutex); 593 592 list_for_each_entry(dev, &ucb->devs, dev_node) { 594 593 if (dev->drv->suspend) 595 594 dev->drv->suspend(dev, state); 596 595 } 597 - up(&ucb1x00_sem); 596 + mutex_unlock(&ucb1x00_mutex); 598 597 return 0; 599 598 } 600 599 ··· 603 602 struct ucb1x00 *ucb = mcp_get_drvdata(mcp); 604 603 struct ucb1x00_dev *dev; 605 604 606 - down(&ucb1x00_sem); 605 + mutex_lock(&ucb1x00_mutex); 607 606 list_for_each_entry(dev, &ucb->devs, dev_node) { 608 607 if (dev->drv->resume) 609 608 dev->drv->resume(dev); 610 609 } 611 - up(&ucb1x00_sem); 610 + mutex_unlock(&ucb1x00_mutex); 612 611 return 0; 613 612 } 614 613
+6 -5
drivers/mmc/mmc_block.c
··· 28 28 #include <linux/kdev_t.h> 29 29 #include <linux/blkdev.h> 30 30 #include <linux/devfs_fs_kernel.h> 31 + #include <linux/mutex.h> 31 32 32 33 #include <linux/mmc/card.h> 33 34 #include <linux/mmc/protocol.h> ··· 58 57 unsigned int read_only; 59 58 }; 60 59 61 - static DECLARE_MUTEX(open_lock); 60 + static DEFINE_MUTEX(open_lock); 62 61 63 62 static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk) 64 63 { 65 64 struct mmc_blk_data *md; 66 65 67 - down(&open_lock); 66 + mutex_lock(&open_lock); 68 67 md = disk->private_data; 69 68 if (md && md->usage == 0) 70 69 md = NULL; 71 70 if (md) 72 71 md->usage++; 73 - up(&open_lock); 72 + mutex_unlock(&open_lock); 74 73 75 74 return md; 76 75 } 77 76 78 77 static void mmc_blk_put(struct mmc_blk_data *md) 79 78 { 80 - down(&open_lock); 79 + mutex_lock(&open_lock); 81 80 md->usage--; 82 81 if (md->usage == 0) { 83 82 put_disk(md->disk); 84 83 mmc_cleanup_queue(&md->queue); 85 84 kfree(md); 86 85 } 87 - up(&open_lock); 86 + mutex_unlock(&open_lock); 88 87 } 89 88 90 89 static int mmc_blk_open(struct inode *inode, struct file *filp)