[linux-2.6-block.git] / drivers / nubus / bus.c

// SPDX-License-Identifier: GPL-2.0
//
// Bus implementation for the NuBus subsystem.
//
// Copyright (C) 2017 Finn Thain

#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/list.h>
#include <linux/nubus.h>
#include <linux/seq_file.h>
#include <linux/slab.h>

#define to_nubus_board(d)       container_of(d, struct nubus_board, dev)
#define to_nubus_driver(d)      container_of(d, struct nubus_driver, driver)

static int nubus_bus_match(struct device *dev, struct device_driver *driver)
{
	return 1;
}

static int nubus_device_probe(struct device *dev)
{
	struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
	int err = -ENODEV;

	if (ndrv->probe)
		err = ndrv->probe(to_nubus_board(dev));
	return err;
}

static int nubus_device_remove(struct device *dev)
{
	struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
	int err = -ENODEV;

	if (dev->driver && ndrv->remove)
		err = ndrv->remove(to_nubus_board(dev));
	return err;
}

struct bus_type nubus_bus_type = {
	.name		= "nubus",
	.match		= nubus_bus_match,
	.probe		= nubus_device_probe,
	.remove		= nubus_device_remove,
};
EXPORT_SYMBOL(nubus_bus_type);

int nubus_driver_register(struct nubus_driver *ndrv)
{
	ndrv->driver.bus = &nubus_bus_type;
	return driver_register(&ndrv->driver);
}
EXPORT_SYMBOL(nubus_driver_register);

void nubus_driver_unregister(struct nubus_driver *ndrv)
{
	driver_unregister(&ndrv->driver);
}
EXPORT_SYMBOL(nubus_driver_unregister);

static struct device nubus_parent = {
	.init_name	= "nubus",
};

static int __init nubus_bus_register(void)
{
	return bus_register(&nubus_bus_type);
}
postcore_initcall(nubus_bus_register);

int __init nubus_parent_device_register(void)
{
	return device_register(&nubus_parent);
}

static void nubus_device_release(struct device *dev)
{
	struct nubus_board *board = to_nubus_board(dev);
	struct nubus_rsrc *fres, *tmp;

	list_for_each_entry_safe(fres, tmp, &nubus_func_rsrcs, list)
		if (fres->board == board) {
			list_del(&fres->list);
			kfree(fres);
		}
	kfree(board);
}

int nubus_device_register(struct nubus_board *board)
{
	board->dev.parent = &nubus_parent;
	board->dev.release = nubus_device_release;
	board->dev.bus = &nubus_bus_type;
	dev_set_name(&board->dev, "slot.%X", board->slot);
	board->dev.dma_mask = &board->dev.coherent_dma_mask;
	dma_set_mask(&board->dev, DMA_BIT_MASK(32));
	return device_register(&board->dev);
}

static int nubus_print_device_name_fn(struct device *dev, void *data)
{
	struct nubus_board *board = to_nubus_board(dev);
	struct seq_file *m = data;

	seq_printf(m, "Slot %X: %s\n", board->slot, board->name);
	return 0;
}

int nubus_proc_show(struct seq_file *m, void *data)
{
	return bus_for_each_dev(&nubus_bus_type, NULL, m,
				nubus_print_device_name_fn);
}
Commit	Line	Data
7f86c765 FT	1	// SPDX-License-Identifier: GPL-2.0
	2	//
	3	// Bus implementation for the NuBus subsystem.
	4	//
	5	// Copyright (C) 2017 Finn Thain
	6
	7	#include <linux/device.h>
a8c5cb99	8	#include <linux/dma-mapping.h>
7f86c765 FT	9	#include <linux/list.h>
	10	#include <linux/nubus.h>
	11	#include <linux/seq_file.h>
	12	#include <linux/slab.h>
	13
	14	#define to_nubus_board(d) container_of(d, struct nubus_board, dev)
	15	#define to_nubus_driver(d) container_of(d, struct nubus_driver, driver)
	16
	17	static int nubus_bus_match(struct device dev, struct device_driver driver)
	18	{
	19	return 1;
	20	}
	21
	22	static int nubus_device_probe(struct device *dev)
	23	{
	24	struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
	25	int err = -ENODEV;
	26
	27	if (ndrv->probe)
	28	err = ndrv->probe(to_nubus_board(dev));
	29	return err;
	30	}
	31
	32	static int nubus_device_remove(struct device *dev)
	33	{
	34	struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
	35	int err = -ENODEV;
	36
	37	if (dev->driver && ndrv->remove)
	38	err = ndrv->remove(to_nubus_board(dev));
	39	return err;
	40	}
	41
	42	struct bus_type nubus_bus_type = {
	43	.name = "nubus",
	44	.match = nubus_bus_match,
	45	.probe = nubus_device_probe,
	46	.remove = nubus_device_remove,
	47	};
	48	EXPORT_SYMBOL(nubus_bus_type);
	49
	50	int nubus_driver_register(struct nubus_driver *ndrv)
	51	{
	52	ndrv->driver.bus = &nubus_bus_type;
	53	return driver_register(&ndrv->driver);
	54	}
	55	EXPORT_SYMBOL(nubus_driver_register);
	56
	57	void nubus_driver_unregister(struct nubus_driver *ndrv)
	58	{
	59	driver_unregister(&ndrv->driver);
	60	}
	61	EXPORT_SYMBOL(nubus_driver_unregister);
	62
	63	static struct device nubus_parent = {
	64	.init_name = "nubus",
	65	};
	66
bdeeed09	67	static int __init nubus_bus_register(void)
7f86c765	68	{
bdeeed09 FT	69	return bus_register(&nubus_bus_type);
	70	}
	71	postcore_initcall(nubus_bus_register);
7f86c765	72
bdeeed09 FT	73	int __init nubus_parent_device_register(void)
	74	{
	75	return device_register(&nubus_parent);
7f86c765 FT	76	}
	77
	78	static void nubus_device_release(struct device *dev)
	79	{
	80	struct nubus_board *board = to_nubus_board(dev);
	81	struct nubus_rsrc fres, tmp;
	82
	83	list_for_each_entry_safe(fres, tmp, &nubus_func_rsrcs, list)
	84	if (fres->board == board) {
	85	list_del(&fres->list);
	86	kfree(fres);
	87	}
	88	kfree(board);
	89	}
	90
	91	int nubus_device_register(struct nubus_board *board)
	92	{
	93	board->dev.parent = &nubus_parent;
	94	board->dev.release = nubus_device_release;
	95	board->dev.bus = &nubus_bus_type;
	96	dev_set_name(&board->dev, "slot.%X", board->slot);
a8c5cb99 FT	97	board->dev.dma_mask = &board->dev.coherent_dma_mask;
a8c5cb99 FT	98	dma_set_mask(&board->dev, DMA_BIT_MASK(32));
7f86c765 FT	99	return device_register(&board->dev);
	100	}
	101
	102	static int nubus_print_device_name_fn(struct device dev, void data)
	103	{
	104	struct nubus_board *board = to_nubus_board(dev);
	105	struct seq_file *m = data;
	106
	107	seq_printf(m, "Slot %X: %s\n", board->slot, board->name);
	108	return 0;
	109	}
	110
	111	int nubus_proc_show(struct seq_file m, void data)
	112	{
	113	return bus_for_each_dev(&nubus_bus_type, NULL, m,
	114	nubus_print_device_name_fn);
	115	}