ipmi: Remove the proc interface (163475eb) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/char/ipmi/Kconfig

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -22,14 +22,6 @@ config IPMI_DMI_DECODE

	if IPMI_HANDLER		if IPMI_HANDLER

	config IPMI_PROC_INTERFACE
	bool 'Provide an interface for IPMI stats in /proc (deprecated)'
	depends on PROC_FS
	default y
	help
	Do not use this any more, use sysfs for this info. It will be
	removed in future kernel versions.

	config IPMI_PANIC_EVENT		config IPMI_PANIC_EVENT
	bool 'Generate a panic event to all BMCs on a panic'		bool 'Generate a panic event to all BMCs on a panic'
	help		help

drivers/char/ipmi/ipmi_msghandler.c

+0 −264

Original line number	Original line	Diff line number	Diff line
	@@ -131,10 +131,6 @@ module_param_cb(panic_op, &panic_op_ops, NULL, 0600);
	MODULE_PARM_DESC(panic_op, "Sets if the IPMI driver will attempt to store panic information in the event log in the event of a panic. Set to 'none' for no, 'event' for a single event, or 'string' for a generic event and the panic string in IPMI OEM events.");		MODULE_PARM_DESC(panic_op, "Sets if the IPMI driver will attempt to store panic information in the event log in the event of a panic. Set to 'none' for no, 'event' for a single event, or 'string' for a generic event and the panic string in IPMI OEM events.");


	#ifdef CONFIG_IPMI_PROC_INTERFACE
	static struct proc_dir_entry *proc_ipmi_root;
	#endif /* CONFIG_IPMI_PROC_INTERFACE */

	#define MAX_EVENTS_IN_QUEUE 25		#define MAX_EVENTS_IN_QUEUE 25

	/* Remain in auto-maintenance mode for this amount of time (in ms). */		/* Remain in auto-maintenance mode for this amount of time (in ms). */
	@@ -315,13 +311,6 @@ struct ipmi_my_addrinfo {
	unsigned char lun;		unsigned char lun;
	};		};

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	struct ipmi_proc_entry {
	char *name;
	struct ipmi_proc_entry *next;
	};
	#endif

	/*		/*
	* Note that the product id, manufacturer id, guid, and device id are		* Note that the product id, manufacturer id, guid, and device id are
	* immutable in this structure, so dyn_mutex is not required for		* immutable in this structure, so dyn_mutex is not required for
	@@ -492,15 +481,6 @@ struct ipmi_smi {
	const struct ipmi_smi_handlers *handlers;		const struct ipmi_smi_handlers *handlers;
	void *send_info;		void *send_info;

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	/* A list of proc entries for this interface. */
	struct mutex proc_entry_lock;
	struct ipmi_proc_entry *proc_entries;

	struct proc_dir_entry *proc_dir;
	char proc_dir_name[10];
	#endif

	/* Driver-model device for the system interface. */		/* Driver-model device for the system interface. */
	struct device *si_dev;		struct device *si_dev;

	@@ -2515,216 +2495,6 @@ static int bmc_get_device_id(struct ipmi_smi intf, struct bmc_device bmc,
	return __bmc_get_device_id(intf, bmc, id, guid_set, guid, -1);		return __bmc_get_device_id(intf, bmc, id, guid_set, guid, -1);
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	static int smi_ipmb_proc_show(struct seq_file m, void v)
	{
	struct ipmi_smi *intf = m->private;
	int i;

	seq_printf(m, "%x", intf->addrinfo[0].address);
	for (i = 1; i < IPMI_MAX_CHANNELS; i++)
	seq_printf(m, " %x", intf->addrinfo[i].address);
	seq_putc(m, '\n');

	return 0;
	}

	static int smi_ipmb_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_ipmb_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_ipmb_proc_ops = {
	.open = smi_ipmb_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static int smi_version_proc_show(struct seq_file m, void v)
	{
	struct ipmi_smi *intf = m->private;
	struct ipmi_device_id id;
	int rv;

	rv = bmc_get_device_id(intf, NULL, &id, NULL, NULL);
	if (rv)
	return rv;

	seq_printf(m, "%u.%u\n",
	ipmi_version_major(&id),
	ipmi_version_minor(&id));

	return 0;
	}

	static int smi_version_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_version_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_version_proc_ops = {
	.open = smi_version_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static int smi_stats_proc_show(struct seq_file m, void v)
	{
	struct ipmi_smi *intf = m->private;

	seq_printf(m, "sent_invalid_commands: %u\n",
	ipmi_get_stat(intf, sent_invalid_commands));
	seq_printf(m, "sent_local_commands: %u\n",
	ipmi_get_stat(intf, sent_local_commands));
	seq_printf(m, "handled_local_responses: %u\n",
	ipmi_get_stat(intf, handled_local_responses));
	seq_printf(m, "unhandled_local_responses: %u\n",
	ipmi_get_stat(intf, unhandled_local_responses));
	seq_printf(m, "sent_ipmb_commands: %u\n",
	ipmi_get_stat(intf, sent_ipmb_commands));
	seq_printf(m, "sent_ipmb_command_errs: %u\n",
	ipmi_get_stat(intf, sent_ipmb_command_errs));
	seq_printf(m, "retransmitted_ipmb_commands: %u\n",
	ipmi_get_stat(intf, retransmitted_ipmb_commands));
	seq_printf(m, "timed_out_ipmb_commands: %u\n",
	ipmi_get_stat(intf, timed_out_ipmb_commands));
	seq_printf(m, "timed_out_ipmb_broadcasts: %u\n",
	ipmi_get_stat(intf, timed_out_ipmb_broadcasts));
	seq_printf(m, "sent_ipmb_responses: %u\n",
	ipmi_get_stat(intf, sent_ipmb_responses));
	seq_printf(m, "handled_ipmb_responses: %u\n",
	ipmi_get_stat(intf, handled_ipmb_responses));
	seq_printf(m, "invalid_ipmb_responses: %u\n",
	ipmi_get_stat(intf, invalid_ipmb_responses));
	seq_printf(m, "unhandled_ipmb_responses: %u\n",
	ipmi_get_stat(intf, unhandled_ipmb_responses));
	seq_printf(m, "sent_lan_commands: %u\n",
	ipmi_get_stat(intf, sent_lan_commands));
	seq_printf(m, "sent_lan_command_errs: %u\n",
	ipmi_get_stat(intf, sent_lan_command_errs));
	seq_printf(m, "retransmitted_lan_commands: %u\n",
	ipmi_get_stat(intf, retransmitted_lan_commands));
	seq_printf(m, "timed_out_lan_commands: %u\n",
	ipmi_get_stat(intf, timed_out_lan_commands));
	seq_printf(m, "sent_lan_responses: %u\n",
	ipmi_get_stat(intf, sent_lan_responses));
	seq_printf(m, "handled_lan_responses: %u\n",
	ipmi_get_stat(intf, handled_lan_responses));
	seq_printf(m, "invalid_lan_responses: %u\n",
	ipmi_get_stat(intf, invalid_lan_responses));
	seq_printf(m, "unhandled_lan_responses: %u\n",
	ipmi_get_stat(intf, unhandled_lan_responses));
	seq_printf(m, "handled_commands: %u\n",
	ipmi_get_stat(intf, handled_commands));
	seq_printf(m, "invalid_commands: %u\n",
	ipmi_get_stat(intf, invalid_commands));
	seq_printf(m, "unhandled_commands: %u\n",
	ipmi_get_stat(intf, unhandled_commands));
	seq_printf(m, "invalid_events: %u\n",
	ipmi_get_stat(intf, invalid_events));
	seq_printf(m, "events: %u\n",
	ipmi_get_stat(intf, events));
	seq_printf(m, "failed rexmit LAN msgs: %u\n",
	ipmi_get_stat(intf, dropped_rexmit_lan_commands));
	seq_printf(m, "failed rexmit IPMB msgs: %u\n",
	ipmi_get_stat(intf, dropped_rexmit_ipmb_commands));
	return 0;
	}

	static int smi_stats_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_stats_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_stats_proc_ops = {
	.open = smi_stats_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	int ipmi_smi_add_proc_entry(struct ipmi_smi smi, char name,
	const struct file_operations *proc_ops,
	void *data)
	{
	int rv = 0;
	struct proc_dir_entry *file;
	struct ipmi_proc_entry *entry;

	/* Create a list element. */
	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry)
	return -ENOMEM;
	entry->name = kstrdup(name, GFP_KERNEL);
	if (!entry->name) {
	kfree(entry);
	return -ENOMEM;
	}

	file = proc_create_data(name, 0, smi->proc_dir, proc_ops, data);
	if (!file) {
	kfree(entry->name);
	kfree(entry);
	rv = -ENOMEM;
	} else {
	mutex_lock(&smi->proc_entry_lock);
	/* Stick it on the list. */
	entry->next = smi->proc_entries;
	smi->proc_entries = entry;
	mutex_unlock(&smi->proc_entry_lock);
	}

	return rv;
	}
	EXPORT_SYMBOL(ipmi_smi_add_proc_entry);

	static int add_proc_entries(struct ipmi_smi *smi, int num)
	{
	int rv = 0;

	sprintf(smi->proc_dir_name, "%d", num);
	smi->proc_dir = proc_mkdir(smi->proc_dir_name, proc_ipmi_root);
	if (!smi->proc_dir)
	rv = -ENOMEM;

	if (rv == 0)
	rv = ipmi_smi_add_proc_entry(smi, "stats",
	&smi_stats_proc_ops,
	smi);

	if (rv == 0)
	rv = ipmi_smi_add_proc_entry(smi, "ipmb",
	&smi_ipmb_proc_ops,
	smi);

	if (rv == 0)
	rv = ipmi_smi_add_proc_entry(smi, "version",
	&smi_version_proc_ops,
	smi);

	return rv;
	}

	static void remove_proc_entries(struct ipmi_smi *smi)
	{
	struct ipmi_proc_entry *entry;

	mutex_lock(&smi->proc_entry_lock);
	while (smi->proc_entries) {
	entry = smi->proc_entries;
	smi->proc_entries = entry->next;

	remove_proc_entry(entry->name, smi->proc_dir);
	kfree(entry->name);
	kfree(entry);
	}
	mutex_unlock(&smi->proc_entry_lock);
	remove_proc_entry(smi->proc_dir_name, proc_ipmi_root);
	}
	#endif /* CONFIG_IPMI_PROC_INTERFACE */

	static ssize_t device_id_show(struct device *dev,		static ssize_t device_id_show(struct device *dev,
	struct device_attribute *attr,		struct device_attribute *attr,
	char *buf)		char *buf)
	@@ -3564,9 +3334,6 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
	intf->seq_table[j].seqid = 0;		intf->seq_table[j].seqid = 0;
	}		}
	intf->curr_seq = 0;		intf->curr_seq = 0;
	#ifdef CONFIG_IPMI_PROC_INTERFACE
	mutex_init(&intf->proc_entry_lock);
	#endif
	spin_lock_init(&intf->waiting_rcv_msgs_lock);		spin_lock_init(&intf->waiting_rcv_msgs_lock);
	INIT_LIST_HEAD(&intf->waiting_rcv_msgs);		INIT_LIST_HEAD(&intf->waiting_rcv_msgs);
	tasklet_init(&intf->recv_tasklet,		tasklet_init(&intf->recv_tasklet,
	@@ -3588,10 +3355,6 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
	for (i = 0; i < IPMI_NUM_STATS; i++)		for (i = 0; i < IPMI_NUM_STATS; i++)
	atomic_set(&intf->stats[i], 0);		atomic_set(&intf->stats[i], 0);

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	intf->proc_dir = NULL;
	#endif

	mutex_lock(&ipmi_interfaces_mutex);		mutex_lock(&ipmi_interfaces_mutex);
	/* Look for a hole in the numbers. */		/* Look for a hole in the numbers. */
	i = 0;		i = 0;
	@@ -3622,20 +3385,10 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
	mutex_lock(&intf->bmc_reg_mutex);		mutex_lock(&intf->bmc_reg_mutex);
	rv = __scan_channels(intf, &id);		rv = __scan_channels(intf, &id);
	mutex_unlock(&intf->bmc_reg_mutex);		mutex_unlock(&intf->bmc_reg_mutex);
	if (rv)
	goto out;

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	rv = add_proc_entries(intf, i);
	#endif

	out:		out:
	if (rv) {		if (rv) {
	ipmi_bmc_unregister(intf);		ipmi_bmc_unregister(intf);
	#ifdef CONFIG_IPMI_PROC_INTERFACE
	if (intf->proc_dir)
	remove_proc_entries(intf);
	#endif
	list_del_rcu(&intf->link);		list_del_rcu(&intf->link);
	mutex_unlock(&ipmi_interfaces_mutex);		mutex_unlock(&ipmi_interfaces_mutex);
	synchronize_srcu(&ipmi_interfaces_srcu);		synchronize_srcu(&ipmi_interfaces_srcu);
	@@ -3748,9 +3501,6 @@ void ipmi_unregister_smi(struct ipmi_smi *intf)

	cleanup_smi_msgs(intf);		cleanup_smi_msgs(intf);

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	remove_proc_entries(intf);
	#endif
	ipmi_bmc_unregister(intf);		ipmi_bmc_unregister(intf);

	cleanup_srcu_struct(&intf->users_srcu);		cleanup_srcu_struct(&intf->users_srcu);
	@@ -5277,16 +5027,6 @@ static int ipmi_init_msghandler(void)

	pr_info("ipmi message handler version " IPMI_DRIVER_VERSION "\n");		pr_info("ipmi message handler version " IPMI_DRIVER_VERSION "\n");

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	proc_ipmi_root = proc_mkdir("ipmi", NULL);
	if (!proc_ipmi_root) {
	pr_err(PFX "Unable to create IPMI proc dir");
	driver_unregister(&ipmidriver.driver);
	return -ENOMEM;
	}

	#endif /* CONFIG_IPMI_PROC_INTERFACE */

	timer_setup(&ipmi_timer, ipmi_timeout, 0);		timer_setup(&ipmi_timer, ipmi_timeout, 0);
	mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);		mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);

	@@ -5325,10 +5065,6 @@ static void __exit cleanup_ipmi(void)
	atomic_inc(&stop_operation);		atomic_inc(&stop_operation);
	del_timer_sync(&ipmi_timer);		del_timer_sync(&ipmi_timer);

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	proc_remove(proc_ipmi_root);
	#endif /* CONFIG_IPMI_PROC_INTERFACE */

	driver_unregister(&ipmidriver.driver);		driver_unregister(&ipmidriver.driver);

	initialized = 0;		initialized = 0;

drivers/char/ipmi/ipmi_si_intf.c

+0 −125

Original line number	Original line	Diff line number	Diff line
	@@ -1588,102 +1588,6 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
	return rv;		return rv;
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	static int smi_type_proc_show(struct seq_file m, void v)
	{
	struct smi_info *smi = m->private;

	seq_printf(m, "%s\n", si_to_str[smi->io.si_type]);

	return 0;
	}

	static int smi_type_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_type_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_type_proc_ops = {
	.open = smi_type_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static int smi_si_stats_proc_show(struct seq_file m, void v)
	{
	struct smi_info *smi = m->private;

	seq_printf(m, "interrupts_enabled: %d\n",
	smi->io.irq && !smi->interrupt_disabled);
	seq_printf(m, "short_timeouts: %u\n",
	smi_get_stat(smi, short_timeouts));
	seq_printf(m, "long_timeouts: %u\n",
	smi_get_stat(smi, long_timeouts));
	seq_printf(m, "idles: %u\n",
	smi_get_stat(smi, idles));
	seq_printf(m, "interrupts: %u\n",
	smi_get_stat(smi, interrupts));
	seq_printf(m, "attentions: %u\n",
	smi_get_stat(smi, attentions));
	seq_printf(m, "flag_fetches: %u\n",
	smi_get_stat(smi, flag_fetches));
	seq_printf(m, "hosed_count: %u\n",
	smi_get_stat(smi, hosed_count));
	seq_printf(m, "complete_transactions: %u\n",
	smi_get_stat(smi, complete_transactions));
	seq_printf(m, "events: %u\n",
	smi_get_stat(smi, events));
	seq_printf(m, "watchdog_pretimeouts: %u\n",
	smi_get_stat(smi, watchdog_pretimeouts));
	seq_printf(m, "incoming_messages: %u\n",
	smi_get_stat(smi, incoming_messages));
	return 0;
	}

	static int smi_si_stats_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_si_stats_proc_ops = {
	.open = smi_si_stats_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static int smi_params_proc_show(struct seq_file m, void v)
	{
	struct smi_info *smi = m->private;

	seq_printf(m,
	"%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
	si_to_str[smi->io.si_type],
	addr_space_to_str[smi->io.addr_type],
	smi->io.addr_data,
	smi->io.regspacing,
	smi->io.regsize,
	smi->io.regshift,
	smi->io.irq,
	smi->io.slave_addr);

	return 0;
	}

	static int smi_params_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_params_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_params_proc_ops = {
	.open = smi_params_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};
	#endif

	#define IPMI_SI_ATTR(name) \		#define IPMI_SI_ATTR(name) \
	static ssize_t ipmi_##name##_show(struct device *dev, \		static ssize_t ipmi_##name##_show(struct device *dev, \
	struct device_attribute *attr, \		struct device_attribute *attr, \
	@@ -2172,35 +2076,6 @@ static int try_smi_init(struct smi_info *new_smi)
	goto out_err;		goto out_err;
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
	&smi_type_proc_ops,
	new_smi);
	if (rv) {
	dev_err(new_smi->io.dev,
	"Unable to create proc entry: %d\n", rv);
	goto out_err;
	}

	rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
	&smi_si_stats_proc_ops,
	new_smi);
	if (rv) {
	dev_err(new_smi->io.dev,
	"Unable to create proc entry: %d\n", rv);
	goto out_err;
	}

	rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
	&smi_params_proc_ops,
	new_smi);
	if (rv) {
	dev_err(new_smi->io.dev,
	"Unable to create proc entry: %d\n", rv);
	goto out_err;
	}
	#endif

	/* Don't increment till we know we have succeeded. */		/* Don't increment till we know we have succeeded. */
	smi_num++;		smi_num++;

drivers/char/ipmi/ipmi_ssif.c

+0 −89

Original line number	Original line	Diff line number	Diff line
	@@ -1316,72 +1316,6 @@ static int ssif_detect(struct i2c_client client, struct i2c_board_info info)
	return rv;		return rv;
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	static int smi_type_proc_show(struct seq_file m, void v)
	{
	seq_puts(m, "ssif\n");

	return 0;
	}

	static int smi_type_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_type_proc_show, inode->i_private);
	}

	static const struct file_operations smi_type_proc_ops = {
	.open = smi_type_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static int smi_stats_proc_show(struct seq_file m, void v)
	{
	struct ssif_info *ssif_info = m->private;

	seq_printf(m, "sent_messages: %u\n",
	ssif_get_stat(ssif_info, sent_messages));
	seq_printf(m, "sent_messages_parts: %u\n",
	ssif_get_stat(ssif_info, sent_messages_parts));
	seq_printf(m, "send_retries: %u\n",
	ssif_get_stat(ssif_info, send_retries));
	seq_printf(m, "send_errors: %u\n",
	ssif_get_stat(ssif_info, send_errors));
	seq_printf(m, "received_messages: %u\n",
	ssif_get_stat(ssif_info, received_messages));
	seq_printf(m, "received_message_parts: %u\n",
	ssif_get_stat(ssif_info, received_message_parts));
	seq_printf(m, "receive_retries: %u\n",
	ssif_get_stat(ssif_info, receive_retries));
	seq_printf(m, "receive_errors: %u\n",
	ssif_get_stat(ssif_info, receive_errors));
	seq_printf(m, "flag_fetches: %u\n",
	ssif_get_stat(ssif_info, flag_fetches));
	seq_printf(m, "hosed: %u\n",
	ssif_get_stat(ssif_info, hosed));
	seq_printf(m, "events: %u\n",
	ssif_get_stat(ssif_info, events));
	seq_printf(m, "watchdog_pretimeouts: %u\n",
	ssif_get_stat(ssif_info, watchdog_pretimeouts));
	seq_printf(m, "alerts: %u\n",
	ssif_get_stat(ssif_info, alerts));
	return 0;
	}

	static int smi_stats_proc_open(struct inode inode, struct file file)
	{
	return single_open(file, smi_stats_proc_show, PDE_DATA(inode));
	}

	static const struct file_operations smi_stats_proc_ops = {
	.open = smi_stats_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};
	#endif

	static int strcmp_nospace(char s1, char s2)		static int strcmp_nospace(char s1, char s2)
	{		{
	while (s1 && s2) {		while (s1 && s2) {
	@@ -1712,24 +1646,6 @@ static int ssif_probe(struct i2c_client client, const struct i2c_device_id id)
	goto out_remove_attr;		goto out_remove_attr;
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	rv = ipmi_smi_add_proc_entry(ssif_info->intf, "type",
	&smi_type_proc_ops,
	ssif_info);
	if (rv) {
	pr_err(PFX "Unable to create proc entry: %d\n", rv);
	goto out_err_unreg;
	}

	rv = ipmi_smi_add_proc_entry(ssif_info->intf, "ssif_stats",
	&smi_stats_proc_ops,
	ssif_info);
	if (rv) {
	pr_err(PFX "Unable to create proc entry: %d\n", rv);
	goto out_err_unreg;
	}
	#endif

	out:		out:
	if (rv) {		if (rv) {
	/*		/*
	@@ -1747,11 +1663,6 @@ static int ssif_probe(struct i2c_client client, const struct i2c_device_id id)
	kfree(resp);		kfree(resp);
	return rv;		return rv;

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	out_err_unreg:
	ipmi_unregister_smi(ssif_info->intf);
	#endif

	out_remove_attr:		out_remove_attr:
	device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);		device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);
	dev_set_drvdata(&ssif_info->client->dev, NULL);		dev_set_drvdata(&ssif_info->client->dev, NULL);

include/linux/ipmi_smi.h

+0 −11

Original line number	Original line	Diff line number	Diff line
	@@ -240,15 +240,4 @@ static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
	msg->done(msg);		msg->done(msg);
	}		}

	#ifdef CONFIG_IPMI_PROC_INTERFACE
	/*
	* Allow the lower layer to add things to the proc filesystem
	* directory for this interface. Note that the entry will
	* automatically be dstroyed when the interface is destroyed.
	*/
	int ipmi_smi_add_proc_entry(struct ipmi_smi smi, char name,
	const struct file_operations *proc_ops,
	void *data);
	#endif

	#endif /* __LINUX_IPMI_SMI_H */		#endif /* __LINUX_IPMI_SMI_H */