kobject: convert hvcs to use kref, not kobject

 * rescanning partner information upon a user's request.

 *

 * Each vty-server, prior to being exposed to this driver is reference counted

 * using the 2.6 Linux kernel kobject construct.  This kobject is also used by

 * the vio bus to provide a vio device sysfs entry that this driver attaches

 * device specific attributes to, including partner information.  The vio bus

 * framework also provides a sysfs entry for each vio driver.  The hvcs driver

 * provides driver attributes in this entry.

 * using the 2.6 Linux kernel kref construct.

 *

 * For direction on installation and usage of this driver please reference

 * Documentation/powerpc/hvcs.txt.

#include <linux/init.h>

#include <linux/interrupt.h>

#include <linux/kernel.h>

#include <linux/kobject.h>

#include <linux/kref.h>

#include <linux/kthread.h>

#include <linux/list.h>

#include <linux/major.h>

	int chars_in_buffer;

	/*

	 * Any variable below the kobject is valid before a tty is connected and

	 * Any variable below the kref is valid before a tty is connected and

	 * stays valid after the tty is disconnected.  These shouldn't be

	 * whacked until the koject refcount reaches zero though some entries

	 * may be changed via sysfs initiatives.

	 */

	struct kobject kobj; /* ref count & hvcs_struct lifetime */

	struct kref kref; /* ref count & hvcs_struct lifetime */

	int connected; /* is the vty-server currently connected to a vty? */

	uint32_t p_unit_address; /* partner unit address */

	uint32_t p_partition_ID; /* partner partition ID */

	struct vio_dev *vdev;

};

/* Required to back map a kobject to its containing object */

#define from_kobj(kobj) container_of(kobj, struct hvcs_struct, kobj)

/* Required to back map a kref to its containing object */

#define from_kref(k) container_of(k, struct hvcs_struct, kref)

static struct list_head hvcs_structs = LIST_HEAD_INIT(hvcs_structs);

static DEFINE_SPINLOCK(hvcs_structs_lock);

static int hvcs_enable_device(struct hvcs_struct *hvcsd,

		uint32_t unit_address, unsigned int irq, struct vio_dev *dev);

static void destroy_hvcs_struct(struct kobject *kobj);

static int hvcs_open(struct tty_struct *tty, struct file *filp);

static void hvcs_close(struct tty_struct *tty, struct file *filp);

static void hvcs_hangup(struct tty_struct * tty);

		hvcs_index_list[index] = -1;

}

/* callback when the kboject ref count reaches zero */

static void destroy_hvcs_struct(struct kobject *kobj)

/* callback when the kref ref count reaches zero */

static void destroy_hvcs_struct(struct kref *kref)

{

	struct hvcs_struct *hvcsd = from_kobj(kobj);

	struct hvcs_struct *hvcsd = from_kref(kref);

	struct vio_dev *vdev;

	unsigned long flags;

	kfree(hvcsd);

}

static struct kobj_type hvcs_kobj_type = {

	.release = destroy_hvcs_struct,

};

static int hvcs_get_index(void)

{

	int i;

	spin_lock_init(&hvcsd->lock);

	/* Automatically incs the refcount the first time */

	kobject_init(&hvcsd->kobj);

	/* Set up the callback for terminating the hvcs_struct's life */

	hvcsd->kobj.ktype = &hvcs_kobj_type;

	kref_init(&hvcsd->kref);

	hvcsd->vdev = dev;

	dev->dev.driver_data = hvcsd;

{

	struct hvcs_struct *hvcsd = dev->dev.driver_data;

	unsigned long flags;

	struct kobject *kobjp;

	struct tty_struct *tty;

	if (!hvcsd)

	tty = hvcsd->tty;

	kobjp = &hvcsd->kobj;

	spin_unlock_irqrestore(&hvcsd->lock, flags);

	/*

	 * Let the last holder of this object cause it to be removed, which

	 * would probably be tty_hangup below.

	 */

	kobject_put (kobjp);

	kref_put(&hvcsd->kref, destroy_hvcs_struct);

	/*

	 * The hangup is a scheduled function which will auto chain call

}

/*

 * This always increments the kobject ref count if the call is successful.

 * This always increments the kref ref count if the call is successful.

 * Please remember to dec when you are done with the instance.

 *

 * NOTICE: Do NOT hold either the hvcs_struct.lock or hvcs_structs_lock when

		list_for_each_entry(hvcsd, &hvcs_structs, next) {

			spin_lock_irqsave(&hvcsd->lock, flags);

			if (hvcsd->index == index) {

				kobject_get(&hvcsd->kobj);

				kref_get(&hvcsd->kref);

				spin_unlock_irqrestore(&hvcsd->lock, flags);

				spin_unlock(&hvcs_structs_lock);

				return hvcsd;

	unsigned int irq;

	struct vio_dev *vdev;

	unsigned long unit_address;

	struct kobject *kobjp;

	if (tty->driver_data)

		goto fast_open;

	/*

	 * Is there a vty-server that shares the same index?

	 * This function increments the kobject index.

	 * This function increments the kref index.

	 */

	if (!(hvcsd = hvcs_get_by_index(tty->index))) {

		printk(KERN_WARNING "HVCS: open failed, no device associated"

	 * and will grab the spinlock and free the connection if it fails.

	 */

	if (((rc = hvcs_enable_device(hvcsd, unit_address, irq, vdev)))) {

		kobject_put(&hvcsd->kobj);

		kref_put(&hvcsd->kref, destroy_hvcs_struct);

		printk(KERN_WARNING "HVCS: enable device failed.\n");

		return rc;

	}

	hvcsd = tty->driver_data;

	spin_lock_irqsave(&hvcsd->lock, flags);

	if (!kobject_get(&hvcsd->kobj)) {

		spin_unlock_irqrestore(&hvcsd->lock, flags);

		printk(KERN_ERR "HVCS: Kobject of open"

			" hvcs doesn't exist.\n");

		return -EFAULT; /* Is this the right return value? */

	}

	kref_get(&hvcsd->kref);

	hvcsd->open_count++;

	hvcsd->todo_mask |= HVCS_SCHED_READ;

	spin_unlock_irqrestore(&hvcsd->lock, flags);

open_success:

	hvcs_kick();

	return 0;

error_release:

	kobjp = &hvcsd->kobj;

	spin_unlock_irqrestore(&hvcsd->lock, flags);

	kobject_put(&hvcsd->kobj);

	kref_put(&hvcsd->kref, destroy_hvcs_struct);

	printk(KERN_WARNING "HVCS: partner connect failed.\n");

	return retval;

{

	struct hvcs_struct *hvcsd;

	unsigned long flags;

	struct kobject *kobjp;

	int irq = NO_IRQ;

	/*

	hvcsd = tty->driver_data;

	spin_lock_irqsave(&hvcsd->lock, flags);

	kobjp = &hvcsd->kobj;

	if (--hvcsd->open_count == 0) {

		vio_disable_interrupts(hvcsd->vdev);

		tty->driver_data = NULL;

		free_irq(irq, hvcsd);

		kobject_put(kobjp);

		kref_put(&hvcsd->kref, destroy_hvcs_struct);

		return;

	} else if (hvcsd->open_count < 0) {

		printk(KERN_ERR "HVCS: vty-server@%X open_count: %d"

	}

	spin_unlock_irqrestore(&hvcsd->lock, flags);

	kobject_put(kobjp);

	kref_put(&hvcsd->kref, destroy_hvcs_struct);

}

static void hvcs_hangup(struct tty_struct * tty)

	struct hvcs_struct *hvcsd = tty->driver_data;

	unsigned long flags;

	int temp_open_count;

	struct kobject *kobjp;

	int irq = NO_IRQ;

	spin_lock_irqsave(&hvcsd->lock, flags);

	/* Preserve this so that we know how many kobject refs to put */

	/* Preserve this so that we know how many kref refs to put */

	temp_open_count = hvcsd->open_count;

	/*

	 * Don't kobject put inside the spinlock because the destruction

	 * Don't kref put inside the spinlock because the destruction

	 * callback may use the spinlock and it may get called before the

	 * spinlock has been released.  Get a pointer to the kobject and

	 * kobject_put on that after releasing the spinlock.

	 * spinlock has been released.

	 */

	kobjp = &hvcsd->kobj;

	vio_disable_interrupts(hvcsd->vdev);

	hvcsd->todo_mask = 0;

	free_irq(irq, hvcsd);

	/*

	 * We need to kobject_put() for every open_count we have since the

	 * We need to kref_put() for every open_count we have since the

	 * tty_hangup() function doesn't invoke a close per open connection on a

	 * non-console device.

	 */

		 * NOTE:  If this hangup was signaled from user space then the

		 * final put will never happen.

		 */

		kobject_put(kobjp);

		kref_put(&hvcsd->kref, destroy_hvcs_struct);

	}

}