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

Commit 11305c3e authored by Stefan Richter's avatar Stefan Richter
Browse files

ieee1394: nodemgr clean up class iterators 



Remove useless pointer type casts.
Remove unnecessary hi->host indirection where only host is used.
Remove an unnecessary WARN_ON.
Change a few names.

Signed-off-by: default avatarStefan Richter <stefanr@s5r6.in-berlin.de>
parent d98562d1

drivers/ieee1394/nodemgr.c

+81 −97
Original line number Diff line number Diff line
@@ -154,7 +154,7 @@ struct host_info { 


static int nodemgr_bus_match(struct device * dev, struct device_driver * drv);

static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env);

static void nodemgr_resume_ne(struct node_entry *ne);

static void nodemgr_reactivate_ne(struct node_entry *ne);

static void nodemgr_remove_ne(struct node_entry *ne);

static struct node_entry *find_entry_by_guid(u64 guid);
@@ -734,10 +734,10 @@ static int nodemgr_bus_match(struct device * dev, struct device_driver * drv) 


static DEFINE_MUTEX(nodemgr_serialize_remove_uds);



static int __match_ne(struct device *dev, void *data)

static int match_ne(struct device *dev, void *data)

{

	struct unit_directory *ud;

	struct node_entry *ne = (struct node_entry *)data;

	struct node_entry *ne = data;



	ud = container_of(dev, struct unit_directory, unit_dev);

	return ud->ne == ne;
@@ -754,8 +754,7 @@ static void nodemgr_remove_uds(struct node_entry *ne) 
	 */

	mutex_lock(&nodemgr_serialize_remove_uds);

	for (;;) {

		dev = class_find_device(&nodemgr_ud_class, NULL, ne,

					__match_ne);

		dev = class_find_device(&nodemgr_ud_class, NULL, ne, match_ne);

		if (!dev)

			break;

		ud = container_of(dev, struct unit_directory, unit_dev);
@@ -785,7 +784,7 @@ static void nodemgr_remove_ne(struct node_entry *ne) 
	put_device(dev);

}



static int __nodemgr_remove_host_dev(struct device *dev, void *data)

static int remove_host_dev(struct device *dev, void *data)

{

	if (dev->bus == &ieee1394_bus_type)

		nodemgr_remove_ne(container_of(dev, struct node_entry,
@@ -795,7 +794,7 @@ static int __nodemgr_remove_host_dev(struct device *dev, void *data) 


static void nodemgr_remove_host_dev(struct device *dev)

{

	WARN_ON(device_for_each_child(dev, NULL, __nodemgr_remove_host_dev));

	device_for_each_child(dev, NULL, remove_host_dev);

	sysfs_remove_link(&dev->kobj, "irm_id");

	sysfs_remove_link(&dev->kobj, "busmgr_id");

	sysfs_remove_link(&dev->kobj, "host_id");
@@ -830,11 +829,10 @@ static void nodemgr_update_bus_options(struct node_entry *ne) 
}





static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr *csr,

					      struct host_info *hi, nodeid_t nodeid,

					      unsigned int generation)

static struct node_entry *nodemgr_create_node(octlet_t guid,

				struct csr1212_csr *csr, struct hpsb_host *host,

				nodeid_t nodeid, unsigned int generation)

{

	struct hpsb_host *host = hi->host;

	struct node_entry *ne;



	ne = kzalloc(sizeof(*ne), GFP_KERNEL);
@@ -888,10 +886,10 @@ static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr 
	return NULL;

}



static int __match_ne_guid(struct device *dev, void *data)

static int match_ne_guid(struct device *dev, void *data)

{

	struct node_entry *ne;

	u64 *guid = (u64 *)data;

	u64 *guid = data;



	ne = container_of(dev, struct node_entry, node_dev);

	return ne->guid == *guid;
@@ -902,8 +900,7 @@ static struct node_entry *find_entry_by_guid(u64 guid) 
	struct device *dev;

	struct node_entry *ne;



	dev = class_find_device(&nodemgr_ne_class, NULL, &guid,

				__match_ne_guid);

	dev = class_find_device(&nodemgr_ne_class, NULL, &guid, match_ne_guid);

	if (!dev)

		return NULL;

	ne = container_of(dev, struct node_entry, node_dev);
@@ -912,21 +909,21 @@ static struct node_entry *find_entry_by_guid(u64 guid) 
	return ne;

}



struct match_nodeid_param {

struct match_nodeid_parameter {

	struct hpsb_host *host;

	nodeid_t nodeid;

};



static int __match_ne_nodeid(struct device *dev, void *data)

static int match_ne_nodeid(struct device *dev, void *data)

{

	int found = 0;

	struct node_entry *ne;

	struct match_nodeid_param *param = (struct match_nodeid_param *)data;

	struct match_nodeid_parameter *p = data;



	if (!dev)

		goto ret;

	ne = container_of(dev, struct node_entry, node_dev);

	if (ne->host == param->host && ne->nodeid == param->nodeid)

	if (ne->host == p->host && ne->nodeid == p->nodeid)

		found = 1;

ret:

	return found;
@@ -937,13 +934,12 @@ static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host, 
{

	struct device *dev;

	struct node_entry *ne;

	struct match_nodeid_param param;

	struct match_nodeid_parameter p;



	param.host = host;

	param.nodeid = nodeid;

	p.host = host;

	p.nodeid = nodeid;



	dev = class_find_device(&nodemgr_ne_class, NULL, &param,

				__match_ne_nodeid);

	dev = class_find_device(&nodemgr_ne_class, NULL, &p, match_ne_nodeid);

	if (!dev)

		return NULL;

	ne = container_of(dev, struct node_entry, node_dev);
@@ -990,7 +986,7 @@ static void nodemgr_register_device(struct node_entry *ne, 
 * immediate unit directories looking for software_id and

 * software_version entries, in order to get driver autoloading working. */

static struct unit_directory *nodemgr_process_unit_directory

	(struct host_info *hi, struct node_entry *ne, struct csr1212_keyval *ud_kv,

	(struct node_entry *ne, struct csr1212_keyval *ud_kv,

	 unsigned int *id, struct unit_directory *parent)

{

	struct unit_directory *ud;
@@ -1083,7 +1079,7 @@ static struct unit_directory *nodemgr_process_unit_directory 
					nodemgr_register_device(ne, ud, &ne->device);

				

				/* process the child unit */

				ud_child = nodemgr_process_unit_directory(hi, ne, kv, id, ud);

				ud_child = nodemgr_process_unit_directory(ne, kv, id, ud);



				if (ud_child == NULL)

					break;
@@ -1137,7 +1133,7 @@ static struct unit_directory *nodemgr_process_unit_directory 
}





static void nodemgr_process_root_directory(struct host_info *hi, struct node_entry *ne)

static void nodemgr_process_root_directory(struct node_entry *ne)

{

	unsigned int ud_id = 0;

	struct csr1212_dentry *dentry;
@@ -1157,7 +1153,7 @@ static void nodemgr_process_root_directory(struct host_info *hi, struct node_ent 
			break;



		case CSR1212_KV_ID_UNIT:

			nodemgr_process_unit_directory(hi, ne, kv, &ud_id, NULL);

			nodemgr_process_unit_directory(ne, kv, &ud_id, NULL);

			break;



		case CSR1212_KV_ID_DESCRIPTOR:
@@ -1273,8 +1269,7 @@ void hpsb_unregister_protocol(struct hpsb_protocol_driver *driver) 
 * the to take whatever actions required.

 */

static void nodemgr_update_node(struct node_entry *ne, struct csr1212_csr *csr,

				struct host_info *hi, nodeid_t nodeid,

				unsigned int generation)

				nodeid_t nodeid, unsigned int generation)

{

	if (ne->nodeid != nodeid) {

		HPSB_DEBUG("Node changed: " NODE_BUS_FMT " -> " NODE_BUS_FMT,
@@ -1306,7 +1301,7 @@ static void nodemgr_update_node(struct node_entry *ne, struct csr1212_csr *csr, 
	}



	if (ne->in_limbo)

		nodemgr_resume_ne(ne);

		nodemgr_reactivate_ne(ne);



	/* Mark the node current */

	ne->generation = generation;
@@ -1314,10 +1309,9 @@ static void nodemgr_update_node(struct node_entry *ne, struct csr1212_csr *csr, 






static void nodemgr_node_scan_one(struct host_info *hi,

static void nodemgr_node_scan_one(struct hpsb_host *host,

				  nodeid_t nodeid, int generation)

{

	struct hpsb_host *host = hi->host;

	struct node_entry *ne;

	octlet_t guid;

	struct csr1212_csr *csr;
@@ -1373,16 +1367,15 @@ static void nodemgr_node_scan_one(struct host_info *hi, 
	}



	if (!ne)

		nodemgr_create_node(guid, csr, hi, nodeid, generation);

		nodemgr_create_node(guid, csr, host, nodeid, generation);

	else

		nodemgr_update_node(ne, csr, hi, nodeid, generation);

		nodemgr_update_node(ne, csr, nodeid, generation);

}





static void nodemgr_node_scan(struct host_info *hi, int generation)

static void nodemgr_node_scan(struct hpsb_host *host, int generation)

{

	int count;

	struct hpsb_host *host = hi->host;

	struct selfid *sid = (struct selfid *)host->topology_map;

	nodeid_t nodeid = LOCAL_BUS;
@@ -1395,15 +1388,15 @@ static void nodemgr_node_scan(struct host_info *hi, int generation) 
			nodeid++;

			continue;

		}

		nodemgr_node_scan_one(hi, nodeid++, generation);

		nodemgr_node_scan_one(host, nodeid++, generation);

	}

}



static int __nodemgr_driver_suspend(struct device *dev, void *data)

static int pause_ne(struct device *dev, void *data)

{

	struct unit_directory *ud;

	struct device_driver *drv;

	struct node_entry *ne = (struct node_entry *)data;

	struct node_entry *ne = data;

	int error;



	ud = container_of(dev, struct unit_directory, unit_dev);
@@ -1425,11 +1418,23 @@ static int __nodemgr_driver_suspend(struct device *dev, void *data) 
	return 0;

}



static int __nodemgr_driver_resume(struct device *dev, void *data)

static void nodemgr_pause_ne(struct node_entry *ne)

{

	HPSB_DEBUG("Node suspended: ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",

		   NODE_BUS_ARGS(ne->host, ne->nodeid),

		   (unsigned long long)ne->guid);



	ne->in_limbo = 1;

	WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));



	class_for_each_device(&nodemgr_ud_class, NULL, ne, pause_ne);

}



static int reactivate_ne(struct device *dev, void *data)

{

	struct unit_directory *ud;

	struct device_driver *drv;

	struct node_entry *ne = (struct node_entry *)data;

	struct node_entry *ne = data;



	ud = container_of(dev, struct unit_directory, unit_dev);

	if (ud->ne == ne) {
@@ -1447,37 +1452,23 @@ static int __nodemgr_driver_resume(struct device *dev, void *data) 
	return 0;

}



static void nodemgr_suspend_ne(struct node_entry *ne)

{

	HPSB_DEBUG("Node suspended: ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",

		   NODE_BUS_ARGS(ne->host, ne->nodeid),

		   (unsigned long long)ne->guid);



	ne->in_limbo = 1;

	WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));



	class_for_each_device(&nodemgr_ud_class, NULL, ne,

			      __nodemgr_driver_suspend);

}





static void nodemgr_resume_ne(struct node_entry *ne)

static void nodemgr_reactivate_ne(struct node_entry *ne)

{

	ne->in_limbo = 0;

	device_remove_file(&ne->device, &dev_attr_ne_in_limbo);



	class_for_each_device(&nodemgr_ud_class, NULL, ne,

			      __nodemgr_driver_resume);

	class_for_each_device(&nodemgr_ud_class, NULL, ne, reactivate_ne);

	HPSB_DEBUG("Node resumed: ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",

		   NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);

		   NODE_BUS_ARGS(ne->host, ne->nodeid),

		   (unsigned long long)ne->guid);

}



static int __nodemgr_update_pdrv(struct device *dev, void *data)

static int update_pdrv(struct device *dev, void *data)

{

	struct unit_directory *ud;

	struct device_driver *drv;

	struct hpsb_protocol_driver *pdrv;

	struct node_entry *ne = (struct node_entry *)data;

	struct node_entry *ne = data;

	int error;



	ud = container_of(dev, struct unit_directory, unit_dev);
@@ -1503,8 +1494,7 @@ static int __nodemgr_update_pdrv(struct device *dev, void *data) 


static void nodemgr_update_pdrv(struct node_entry *ne)

{

	class_for_each_device(&nodemgr_ud_class, NULL, ne,

			      __nodemgr_update_pdrv);

	class_for_each_device(&nodemgr_ud_class, NULL, ne, update_pdrv);

}
@@ -1535,11 +1525,12 @@ static void nodemgr_irm_write_bc(struct node_entry *ne, int generation) 
}





static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int generation)

static void nodemgr_probe_ne(struct hpsb_host *host, struct node_entry *ne,

			     int generation)

{

	struct device *dev;



	if (ne->host != hi->host || ne->in_limbo)

	if (ne->host != host || ne->in_limbo)

		return;



	dev = get_device(&ne->device);
@@ -1554,40 +1545,40 @@ static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int ge 
	 * down to the drivers. Otherwise, this is a dead node and we

	 * suspend it. */

	if (ne->needs_probe)

		nodemgr_process_root_directory(hi, ne);

		nodemgr_process_root_directory(ne);

	else if (ne->generation == generation)

		nodemgr_update_pdrv(ne);

	else

		nodemgr_suspend_ne(ne);

		nodemgr_pause_ne(ne);



	put_device(dev);

}



struct probe_param {

	struct host_info *hi;

struct node_probe_parameter {

	struct hpsb_host *host;

	int generation;

	bool probe_now;

};



static int node_probe(struct device *dev, void *data)

{

	struct probe_param *p = data;

	struct node_probe_parameter *p = data;

	struct node_entry *ne;



	if (p->generation != get_hpsb_generation(p->hi->host))

	if (p->generation != get_hpsb_generation(p->host))

		return -EAGAIN;



	ne = container_of(dev, struct node_entry, node_dev);

	if (ne->needs_probe == p->probe_now)

		nodemgr_probe_ne(p->hi, ne, p->generation);

		nodemgr_probe_ne(p->host, ne, p->generation);

	return 0;

}



static void nodemgr_node_probe(struct host_info *hi, int generation)

static void nodemgr_node_probe(struct hpsb_host *host, int generation)

{

	struct probe_param p;

	struct node_probe_parameter p;



	p.hi = hi;

	p.host = host;

	p.generation = generation;

	/*

	 * Do some processing of the nodes we've probed. This pulls them
@@ -1730,10 +1721,9 @@ static int nodemgr_check_irm_capability(struct hpsb_host *host, int cycles) 
	return 1;

}



static int nodemgr_host_thread(void *__hi)

static int nodemgr_host_thread(void *data)

{

	struct host_info *hi = (struct host_info *)__hi;

	struct hpsb_host *host = hi->host;

	struct hpsb_host *host = data;

	unsigned int g, generation = 0;

	int i, reset_cycles = 0;
@@ -1787,11 +1777,11 @@ static int nodemgr_host_thread(void *__hi) 
		 * entries. This does not do the sysfs stuff, since that

		 * would trigger uevents and such, which is a bad idea at

		 * this point. */

		nodemgr_node_scan(hi, generation);

		nodemgr_node_scan(host, generation);



		/* This actually does the full probe, with sysfs

		 * registration. */

		nodemgr_node_probe(hi, generation);

		nodemgr_node_probe(host, generation);



		/* Update some of our sysfs symlinks */

		nodemgr_update_host_dev_links(host);
@@ -1801,22 +1791,20 @@ static int nodemgr_host_thread(void *__hi) 
	return 0;

}



struct host_iter_param {

struct per_host_parameter {

	void *data;

	int (*cb)(struct hpsb_host *, void *);

};



static int __nodemgr_for_each_host(struct device *dev, void *data)

static int per_host(struct device *dev, void *data)

{

	struct hpsb_host *host;

	struct host_iter_param *hip = (struct host_iter_param *)data;

	int error = 0;

	struct per_host_parameter *p = data;



	host = container_of(dev, struct hpsb_host, host_dev);

	error = hip->cb(host, hip->data);



	return error;

	return p->cb(host, p->data);

}



/**

 * nodemgr_for_each_host - call a function for each IEEE 1394 host

 * @data: an address to supply to the callback
@@ -1831,15 +1819,11 @@ static int __nodemgr_for_each_host(struct device *dev, void *data) 
 */

int nodemgr_for_each_host(void *data, int (*cb)(struct hpsb_host *, void *))

{

	struct host_iter_param hip;

	int error;

	struct per_host_parameter p;



	hip.cb = cb;

	hip.data = data;

	error = class_for_each_device(&hpsb_host_class, NULL, &hip,

				      __nodemgr_for_each_host);



	return error;

	p.cb = cb;

	p.data = data;

	return class_for_each_device(&hpsb_host_class, NULL, &p, per_host);

}



/* The following two convenience functions use a struct node_entry
@@ -1893,7 +1877,7 @@ static void nodemgr_add_host(struct hpsb_host *host) 
		return;

	}

	hi->host = host;

	hi->thread = kthread_run(nodemgr_host_thread, hi, "knodemgrd_%d",

	hi->thread = kthread_run(nodemgr_host_thread, host, "knodemgrd_%d",

				 host->id);

	if (IS_ERR(hi->thread)) {

		HPSB_ERR("NodeMgr: cannot start thread for host %d", host->id);