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