parport: daisy: use new parport device model

static DEFINE_SPINLOCK(topology_lock);

static int numdevs;

static bool daisy_init_done;

/* Forward-declaration of lower-level functions. */

static int mux_present(struct parport *port);

	return extra;

}

static int daisy_drv_probe(struct pardevice *par_dev)

{

	struct device_driver *drv = par_dev->dev.driver;

	if (strcmp(drv->name, "daisy_drv"))

		return -ENODEV;

	if (strcmp(par_dev->name, daisy_dev_name))

		return -ENODEV;

	return 0;

}

static struct parport_driver daisy_driver = {

	.name = "daisy_drv",

	.probe = daisy_drv_probe,

	.devmodel = true,

};

/* Discover the IEEE1284.3 topology on a port -- muxes and daisy chains.

 * Return value is number of devices actually detected. */

int parport_daisy_init(struct parport *port)

	int i;

	int last_try = 0;

	if (!daisy_init_done) {

		/*

		 * flag should be marked true first as

		 * parport_register_driver() might try to load the low

		 * level driver which will lead to announcing new ports

		 * and which will again come back here at

		 * parport_daisy_init()

		 */

		daisy_init_done = true;

		i = parport_register_driver(&daisy_driver);

		if (i) {

			pr_err("daisy registration failed\n");

			daisy_init_done = false;

			return i;

		}

	}

again:

	/* Because this is called before any other devices exist,

	 * we don't have to claim exclusive access.  */

struct pardevice *parport_open(int devnum, const char *name)

{

	struct daisydev *p = topology;

	struct pardev_cb par_cb;

	struct parport *port;

	struct pardevice *dev;

	int daisy;

	memset(&par_cb, 0, sizeof(par_cb));

	spin_lock(&topology_lock);

	while (p && p->devnum != devnum)

		p = p->next;

	port = parport_get_port(p->port);

	spin_unlock(&topology_lock);

	dev = parport_register_device(port, name, NULL, NULL, NULL, 0, NULL);

	dev = parport_register_dev_model(port, name, &par_cb, devnum);

	parport_put_port(port);

	if (!dev)

		return NULL;