Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2e83fc4d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'powerpc-next' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc 

* 'powerpc-next' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc:
  [POWERPC] Assign PDE->data before gluing PDE into /proc tree
  [POWERPC] devres: Add devm_ioremap_prot()
  [POWERPC] macintosh: ADB driver: adb_handler_sem semaphore to mutex
  [POWERPC] macintosh: windfarm_smu_sat: semaphore to mutex
  [POWERPC] macintosh: therm_pm72: driver_lock semaphore to mutex
parents 17aa7e03 9185ef67

arch/powerpc/lib/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -23,3 +23,4 @@ obj-$(CONFIG_SMP) += locks.o 
endif



obj-$(CONFIG_PPC_LIB_RHEAP) += rheap.o

obj-$(CONFIG_HAS_IOMEM)	+= devres.o

arch/powerpc/lib/devres.c

0 → 100644
+42 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2008 Freescale Semiconductor, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 2 of the License, or (at your option) any later version.

 */



#include <linux/device.h>	/* devres_*(), devm_ioremap_release() */

#include <linux/io.h>		/* ioremap_flags() */

#include <linux/module.h>	/* EXPORT_SYMBOL() */



/**

 * devm_ioremap_prot - Managed ioremap_flags()

 * @dev: Generic device to remap IO address for

 * @offset: BUS offset to map

 * @size: Size of map

 * @flags: Page flags

 *

 * Managed ioremap_prot().  Map is automatically unmapped on driver

 * detach.

 */

void __iomem *devm_ioremap_prot(struct device *dev, resource_size_t offset,

				 size_t size, unsigned long flags)

{

	void __iomem **ptr, *addr;



	ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);

	if (!ptr)

		return NULL;



	addr = ioremap_flags(offset, size, flags);

	if (addr) {

		*ptr = addr;

		devres_add(dev, ptr);

	} else

		devres_free(ptr);



	return addr;

}

EXPORT_SYMBOL(devm_ioremap_prot);

arch/powerpc/platforms/pseries/scanlog.c

+2 −17
Original line number Diff line number Diff line
@@ -55,11 +55,6 @@ static ssize_t scanlog_read(struct file *file, char __user *buf, 
        dp = PDE(inode);

 	data = (unsigned int *)dp->data;



	if (!data) {

		printk(KERN_ERR "scanlog: read failed no data\n");

		return -EIO;

	}



	if (count > RTAS_DATA_BUF_SIZE)

		count = RTAS_DATA_BUF_SIZE;
@@ -146,11 +141,6 @@ static int scanlog_open(struct inode * inode, struct file * file) 
	struct proc_dir_entry *dp = PDE(inode);

	unsigned int *data = (unsigned int *)dp->data;



	if (!data) {

		printk(KERN_ERR "scanlog: open failed no data\n");

		return -EIO;

	}



	if (data[0] != 0) {

		/* This imperfect test stops a second copy of the

		 * data (or a reset while data is being copied)
@@ -168,10 +158,6 @@ static int scanlog_release(struct inode * inode, struct file * file) 
	struct proc_dir_entry *dp = PDE(inode);

	unsigned int *data = (unsigned int *)dp->data;



	if (!data) {

		printk(KERN_ERR "scanlog: release failed no data\n");

		return -EIO;

	}

	data[0] = 0;



	return 0;
@@ -200,12 +186,11 @@ static int __init scanlog_init(void) 
	if (!data)

		goto err;



	ent = proc_create("ppc64/rtas/scan-log-dump", S_IRUSR, NULL,

			  &scanlog_fops);

	ent = proc_create_data("ppc64/rtas/scan-log-dump", S_IRUSR, NULL,

			       &scanlog_fops, data);

	if (!ent)

		goto err;



	ent->data = data;

	proc_ppc64_scan_log_dump = ent;



	return 0;

drivers/macintosh/adb.c

+15 −15
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ 
#include <linux/device.h>

#include <linux/kthread.h>

#include <linux/platform_device.h>

#include <linux/semaphore.h>

#include <linux/mutex.h>



#include <asm/uaccess.h>

#ifdef CONFIG_PPC
@@ -102,7 +102,7 @@ static struct adb_handler { 
} adb_handler[16];



/*

 * The adb_handler_sem mutex protects all accesses to the original_address

 * The adb_handler_mutex mutex protects all accesses to the original_address

 * and handler_id fields of adb_handler[i] for all i, and changes to the

 * handler field.

 * Accesses to the handler field are protected by the adb_handler_lock
@@ -110,7 +110,7 @@ static struct adb_handler { 
 * time adb_unregister returns, we know that the old handler isn't being

 * called.

 */

static DECLARE_MUTEX(adb_handler_sem);

static DEFINE_MUTEX(adb_handler_mutex);

static DEFINE_RWLOCK(adb_handler_lock);



#if 0
@@ -355,7 +355,7 @@ do_adb_reset_bus(void) 
		msleep(500);

	}



	down(&adb_handler_sem);

	mutex_lock(&adb_handler_mutex);

	write_lock_irq(&adb_handler_lock);

	memset(adb_handler, 0, sizeof(adb_handler));

	write_unlock_irq(&adb_handler_lock);
@@ -376,7 +376,7 @@ do_adb_reset_bus(void) 
		if (adb_controller->autopoll)

			adb_controller->autopoll(autopoll_devs);

	}

	up(&adb_handler_sem);

	mutex_unlock(&adb_handler_mutex);



	blocking_notifier_call_chain(&adb_client_list,

		ADB_MSG_POST_RESET, NULL);
@@ -454,7 +454,7 @@ adb_register(int default_id, int handler_id, struct adb_ids *ids, 
{

	int i;



	down(&adb_handler_sem);

	mutex_lock(&adb_handler_mutex);

	ids->nids = 0;

	for (i = 1; i < 16; i++) {

		if ((adb_handler[i].original_address == default_id) &&
@@ -472,7 +472,7 @@ adb_register(int default_id, int handler_id, struct adb_ids *ids, 
			ids->id[ids->nids++] = i;

		}

	}

	up(&adb_handler_sem);

	mutex_unlock(&adb_handler_mutex);

	return ids->nids;

}
@@ -481,7 +481,7 @@ adb_unregister(int index) 
{

	int ret = -ENODEV;



	down(&adb_handler_sem);

	mutex_lock(&adb_handler_mutex);

	write_lock_irq(&adb_handler_lock);

	if (adb_handler[index].handler) {

		while(adb_handler[index].busy) {
@@ -493,7 +493,7 @@ adb_unregister(int index) 
		adb_handler[index].handler = NULL;

	}

	write_unlock_irq(&adb_handler_lock);

	up(&adb_handler_sem);

	mutex_unlock(&adb_handler_mutex);

	return ret;

}
@@ -557,19 +557,19 @@ adb_try_handler_change(int address, int new_id) 
{

	int ret;



	down(&adb_handler_sem);

	mutex_lock(&adb_handler_mutex);

	ret = try_handler_change(address, new_id);

	up(&adb_handler_sem);

	mutex_unlock(&adb_handler_mutex);

	return ret;

}



int

adb_get_infos(int address, int *original_address, int *handler_id)

{

	down(&adb_handler_sem);

	mutex_lock(&adb_handler_mutex);

	*original_address = adb_handler[address].original_address;

	*handler_id = adb_handler[address].handler_id;

	up(&adb_handler_sem);

	mutex_unlock(&adb_handler_mutex);



	return (*original_address != 0);

}
@@ -628,10 +628,10 @@ do_adb_query(struct adb_request *req) 
	case ADB_QUERY_GETDEVINFO:

		if (req->nbytes < 3)

			break;

		down(&adb_handler_sem);

		mutex_lock(&adb_handler_mutex);

		req->reply[0] = adb_handler[req->data[2]].original_address;

		req->reply[1] = adb_handler[req->data[2]].handler_id;

		up(&adb_handler_sem);

		mutex_unlock(&adb_handler_mutex);

		req->complete = 1;

		req->reply_len = 2;

		adb_write_done(req);

drivers/macintosh/therm_pm72.c

+16 −15
Original line number Diff line number Diff line
@@ -122,6 +122,7 @@ 
#include <linux/kmod.h>

#include <linux/i2c.h>

#include <linux/kthread.h>

#include <linux/mutex.h>

#include <asm/prom.h>

#include <asm/machdep.h>

#include <asm/io.h>
@@ -169,7 +170,7 @@ static int rackmac; 
static s32				dimm_output_clamp;

static int 				fcu_rpm_shift;

static int				fcu_tickle_ticks;

static DECLARE_MUTEX(driver_lock);

static DEFINE_MUTEX(driver_lock);



/*

 * We have 3 types of CPU PID control. One is "split" old style control
@@ -729,9 +730,9 @@ static void fetch_cpu_pumps_minmax(void) 
static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf)	\

{								\

	ssize_t r;						\

	down(&driver_lock);					\

	mutex_lock(&driver_lock);					\

	r = sprintf(buf, "%d.%03d", FIX32TOPRINT(data));	\

	up(&driver_lock);					\

	mutex_unlock(&driver_lock);					\

	return r;						\

}

#define BUILD_SHOW_FUNC_INT(name, data)				\
@@ -1803,11 +1804,11 @@ static int main_control_loop(void *x) 
{

	DBG("main_control_loop started\n");



	down(&driver_lock);

	mutex_lock(&driver_lock);



	if (start_fcu() < 0) {

		printk(KERN_ERR "kfand: failed to start FCU\n");

		up(&driver_lock);

		mutex_unlock(&driver_lock);

		goto out;

	}
@@ -1822,14 +1823,14 @@ static int main_control_loop(void *x) 


	fcu_tickle_ticks = FCU_TICKLE_TICKS;



	up(&driver_lock);

	mutex_unlock(&driver_lock);



	while (state == state_attached) {

		unsigned long elapsed, start;



		start = jiffies;



		down(&driver_lock);

		mutex_lock(&driver_lock);



		/* Tickle the FCU just in case */

		if (--fcu_tickle_ticks < 0) {
@@ -1861,7 +1862,7 @@ static int main_control_loop(void *x) 
			do_monitor_slots(&slots_state);

		else

			do_monitor_drives(&drives_state);

		up(&driver_lock);

		mutex_unlock(&driver_lock);



		if (critical_state == 1) {

			printk(KERN_WARNING "Temperature control detected a critical condition\n");
@@ -2019,13 +2020,13 @@ static void detach_fcu(void) 
 */

static int therm_pm72_attach(struct i2c_adapter *adapter)

{

	down(&driver_lock);

	mutex_lock(&driver_lock);



	/* Check state */

	if (state == state_detached)

		state = state_attaching;

	if (state != state_attaching) {

		up(&driver_lock);

		mutex_unlock(&driver_lock);

		return 0;

	}
@@ -2054,7 +2055,7 @@ static int therm_pm72_attach(struct i2c_adapter *adapter) 
		state = state_attached;

		start_control_loops();

	}

	up(&driver_lock);

	mutex_unlock(&driver_lock);



	return 0;

}
@@ -2065,16 +2066,16 @@ static int therm_pm72_attach(struct i2c_adapter *adapter) 
 */

static int therm_pm72_detach(struct i2c_adapter *adapter)

{

	down(&driver_lock);

	mutex_lock(&driver_lock);



	if (state != state_detached)

		state = state_detaching;



	/* Stop control loops if any */

	DBG("stopping control loops\n");

	up(&driver_lock);

	mutex_unlock(&driver_lock);

	stop_control_loops();

	down(&driver_lock);

	mutex_lock(&driver_lock);



	if (u3_0 != NULL && !strcmp(adapter->name, "u3 0")) {

		DBG("lost U3-0, disposing control loops\n");
@@ -2090,7 +2091,7 @@ static int therm_pm72_detach(struct i2c_adapter *adapter) 
	if (u3_0 == NULL && u3_1 == NULL)

		state = state_detached;



	up(&driver_lock);

	mutex_unlock(&driver_lock);



	return 0;

}