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

Commit b728ddde authored by Vitaly Lubart's avatar Vitaly Lubart Committed by Greg Kroah-Hartman
Browse files

mei: Convert to use DEFINE_SHOW_ATTRIBUTE macro 



Use DEFINE_SHOW_ATTRIBUTE macro to simplify the code.

Signed-off-by: default avatarVitaly Lubart <vitaly.lubart@intel.com>
Signed-off-by: default avatarTomas Winkler <tomas.winkler@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent a188339c

drivers/misc/mei/debugfs.c

+52 −132
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/debugfs.h>

#include <linux/seq_file.h>



#include <linux/mei.h>
@@ -15,43 +16,28 @@ 
#include "client.h"

#include "hw.h"



static ssize_t mei_dbgfs_read_meclients(struct file *fp, char __user *ubuf,

					size_t cnt, loff_t *ppos)

static int mei_dbgfs_meclients_show(struct seq_file *m, void *unused)

{

	struct mei_device *dev = fp->private_data;

	struct mei_device *dev = m->private;

	struct mei_me_client *me_cl;

	size_t bufsz = 1;

	char *buf;

	int i = 0;

	int pos = 0;

	int ret;



#define HDR \

"  |id|fix|         UUID                       |con|msg len|sb|refc|\n"

	if (!dev)

		return -ENODEV;



	down_read(&dev->me_clients_rwsem);

	list_for_each_entry(me_cl, &dev->me_clients, list)

		bufsz++;



	bufsz *= sizeof(HDR) + 1;

	buf = kzalloc(bufsz, GFP_KERNEL);

	if (!buf) {

		up_read(&dev->me_clients_rwsem);

		return -ENOMEM;

	}



	pos += scnprintf(buf + pos, bufsz - pos, HDR);

#undef HDR

	seq_puts(m, "  |id|fix|         UUID                       |con|msg len|sb|refc|\n");



	/*  if the driver is not enabled the list won't be consistent */

	if (dev->dev_state != MEI_DEV_ENABLED)

		goto out;



	list_for_each_entry(me_cl, &dev->me_clients, list) {

		if (!mei_me_cl_get(me_cl))

			continue;



		if (mei_me_cl_get(me_cl)) {

			pos += scnprintf(buf + pos, bufsz - pos,

				"%2d|%2d|%3d|%pUl|%3d|%7d|%2d|%4d|\n",

		seq_printf(m, "%2d|%2d|%3d|%pUl|%3d|%7d|%2d|%4d|\n",

			   i++, me_cl->client_id,

			   me_cl->props.fixed_address,

			   &me_cl->props.protocol_name,
@@ -59,60 +45,27 @@ static ssize_t mei_dbgfs_read_meclients(struct file *fp, char __user *ubuf, 
			   me_cl->props.max_msg_length,

			   me_cl->props.single_recv_buf,

			   kref_read(&me_cl->refcnt));



		mei_me_cl_put(me_cl);

	}

	}



out:

	up_read(&dev->me_clients_rwsem);

	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);

	kfree(buf);

	return ret;

	return 0;

}

DEFINE_SHOW_ATTRIBUTE(mei_dbgfs_meclients);



static const struct file_operations mei_dbgfs_fops_meclients = {

	.open = simple_open,

	.read = mei_dbgfs_read_meclients,

	.llseek = generic_file_llseek,

};



static ssize_t mei_dbgfs_read_active(struct file *fp, char __user *ubuf,

					size_t cnt, loff_t *ppos)

static int mei_dbgfs_active_show(struct seq_file *m, void *unused)

{

	struct mei_device *dev = fp->private_data;

	struct mei_device *dev = m->private;

	struct mei_cl *cl;

	size_t bufsz = 1;

	char *buf;

	int i = 0;

	int pos = 0;

	int ret;



#define HDR "   |me|host|state|rd|wr|wrq\n"



	if (!dev)

		return -ENODEV;



	mutex_lock(&dev->device_lock);



	/*

	 * if the driver is not enabled the list won't be consistent,

	 * we output empty table

	 */

	if (dev->dev_state == MEI_DEV_ENABLED)

		list_for_each_entry(cl, &dev->file_list, link)

			bufsz++;



	bufsz *= sizeof(HDR) + 1;



	buf = kzalloc(bufsz, GFP_KERNEL);

	if  (!buf) {

		mutex_unlock(&dev->device_lock);

		return -ENOMEM;

	}



	pos += scnprintf(buf + pos, bufsz - pos, HDR);

#undef HDR

	seq_puts(m, "   |me|host|state|rd|wr|wrq\n");



	/*  if the driver is not enabled the list won't be consistent */

	if (dev->dev_state != MEI_DEV_ENABLED)
@@ -120,8 +73,7 @@ static ssize_t mei_dbgfs_read_active(struct file *fp, char __user *ubuf, 


	list_for_each_entry(cl, &dev->file_list, link) {



		pos += scnprintf(buf + pos, bufsz - pos,

			"%3d|%2d|%4d|%5d|%2d|%2d|%3u\n",

		seq_printf(m, "%3d|%2d|%4d|%5d|%2d|%2d|%3u\n",

			   i, mei_cl_me_id(cl), cl->host_client_id, cl->state,

			   !list_empty(&cl->rd_completed), cl->writing_state,

			   cl->tx_cb_queued);
@@ -129,67 +81,36 @@ static ssize_t mei_dbgfs_read_active(struct file *fp, char __user *ubuf, 
	}

out:

	mutex_unlock(&dev->device_lock);

	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);

	kfree(buf);

	return ret;

	return 0;

}

DEFINE_SHOW_ATTRIBUTE(mei_dbgfs_active);



static const struct file_operations mei_dbgfs_fops_active = {

	.open = simple_open,

	.read = mei_dbgfs_read_active,

	.llseek = generic_file_llseek,

};



static ssize_t mei_dbgfs_read_devstate(struct file *fp, char __user *ubuf,

					size_t cnt, loff_t *ppos)

static int mei_dbgfs_devstate_show(struct seq_file *m, void *unused)

{

	struct mei_device *dev = fp->private_data;

	const size_t bufsz = 1024;

	char *buf = kzalloc(bufsz, GFP_KERNEL);

	int pos = 0;

	int ret;

	struct mei_device *dev = m->private;



	if  (!buf)

		return -ENOMEM;



	pos += scnprintf(buf + pos, bufsz - pos, "dev: %s\n",

			mei_dev_state_str(dev->dev_state));

	pos += scnprintf(buf + pos, bufsz - pos, "hbm: %s\n",

			mei_hbm_state_str(dev->hbm_state));

	seq_printf(m, "dev: %s\n", mei_dev_state_str(dev->dev_state));

	seq_printf(m, "hbm: %s\n", mei_hbm_state_str(dev->hbm_state));



	if (dev->hbm_state >= MEI_HBM_ENUM_CLIENTS &&

	    dev->hbm_state <= MEI_HBM_STARTED) {

		pos += scnprintf(buf + pos, bufsz - pos, "hbm features:\n");

		pos += scnprintf(buf + pos, bufsz - pos, "\tPG: %01d\n",

				 dev->hbm_f_pg_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tDC: %01d\n",

				 dev->hbm_f_dc_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tIE: %01d\n",

				 dev->hbm_f_ie_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tDOT: %01d\n",

				 dev->hbm_f_dot_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tEV: %01d\n",

				 dev->hbm_f_ev_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tFA: %01d\n",

				 dev->hbm_f_fa_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tOS: %01d\n",

				 dev->hbm_f_os_supported);

		pos += scnprintf(buf + pos, bufsz - pos, "\tDR: %01d\n",

				 dev->hbm_f_dr_supported);

	}



	pos += scnprintf(buf + pos, bufsz - pos, "pg:  %s, %s\n",

		seq_puts(m, "hbm features:\n");

		seq_printf(m, "\tPG: %01d\n", dev->hbm_f_pg_supported);

		seq_printf(m, "\tDC: %01d\n", dev->hbm_f_dc_supported);

		seq_printf(m, "\tIE: %01d\n", dev->hbm_f_ie_supported);

		seq_printf(m, "\tDOT: %01d\n", dev->hbm_f_dot_supported);

		seq_printf(m, "\tEV: %01d\n", dev->hbm_f_ev_supported);

		seq_printf(m, "\tFA: %01d\n", dev->hbm_f_fa_supported);

		seq_printf(m, "\tOS: %01d\n", dev->hbm_f_os_supported);

		seq_printf(m, "\tDR: %01d\n", dev->hbm_f_dr_supported);

	}



	seq_printf(m, "pg:  %s, %s\n",

		   mei_pg_is_enabled(dev) ? "ENABLED" : "DISABLED",

		   mei_pg_state_str(mei_pg_state(dev)));

	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);

	kfree(buf);

	return ret;

	return 0;

}

static const struct file_operations mei_dbgfs_fops_devstate = {

	.open = simple_open,

	.read = mei_dbgfs_read_devstate,

	.llseek = generic_file_llseek,

};

DEFINE_SHOW_ATTRIBUTE(mei_dbgfs_devstate);



static ssize_t mei_dbgfs_write_allow_fa(struct file *file,

					const char __user *user_buf,
@@ -208,7 +129,7 @@ static ssize_t mei_dbgfs_write_allow_fa(struct file *file, 
	return ret;

}



static const struct file_operations mei_dbgfs_fops_allow_fa = {

static const struct file_operations mei_dbgfs_allow_fa_fops = {

	.open = simple_open,

	.read = debugfs_read_file_bool,

	.write = mei_dbgfs_write_allow_fa,
@@ -247,26 +168,26 @@ int mei_dbgfs_register(struct mei_device *dev, const char *name) 
	dev->dbgfs_dir = dir;



	f = debugfs_create_file("meclients", S_IRUSR, dir,

				dev, &mei_dbgfs_fops_meclients);

				dev, &mei_dbgfs_meclients_fops);

	if (!f) {

		dev_err(dev->dev, "meclients: registration failed\n");

		goto err;

	}

	f = debugfs_create_file("active", S_IRUSR, dir,

				dev, &mei_dbgfs_fops_active);

				dev, &mei_dbgfs_active_fops);

	if (!f) {

		dev_err(dev->dev, "active: registration failed\n");

		goto err;

	}

	f = debugfs_create_file("devstate", S_IRUSR, dir,

				dev, &mei_dbgfs_fops_devstate);

				dev, &mei_dbgfs_devstate_fops);

	if (!f) {

		dev_err(dev->dev, "devstate: registration failed\n");

		goto err;

	}

	f = debugfs_create_file("allow_fixed_address", S_IRUSR | S_IWUSR, dir,

				&dev->allow_fixed_address,

				&mei_dbgfs_fops_allow_fa);

				&mei_dbgfs_allow_fa_fops);

	if (!f) {

		dev_err(dev->dev, "allow_fixed_address: registration failed\n");

		goto err;
@@ -276,4 +197,3 @@ int mei_dbgfs_register(struct mei_device *dev, const char *name) 
	mei_dbgfs_deregister(dev);

	return -ENODEV;

}