freebsd compat. layer: split device structure to handle for miibus devices, added a new network_device.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21094 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/libs/compat/freebsd_network/compat.c

@@ -36,8 +36,9 @@ pci_module_info *gPci;
 uint32_t
 pci_read_config(device_t dev, int offset, int size)
 {
-	uint32_t value = gPci->read_pci_config(dev->pci_info.bus,
+	uint32_t value = gPci->read_pci_config(NETDEV(dev)->pci_info.bus,
-		dev->pci_info.device, dev->pci_info.function, offset, size);
+		NETDEV(dev)->pci_info.device, NETDEV(dev)->pci_info.function,
+		offset, size);
 	TRACE_PCI(dev, "pci_read_config(%i, %i) = 0x%lx\n", offset, size, value);
 	return value;
 }
@@ -48,8 +49,9 @@ pci_write_config(device_t dev, int offset, uint32_t value, int size)
 {
 	TRACE_PCI(dev, "pci_write_config(%i, 0x%lx, %i)\n", offset, value, size);
 
-	gPci->write_pci_config(dev->pci_info.bus, dev->pci_info.device,
+	gPci->write_pci_config(NETDEV(dev)->pci_info.bus,
-		dev->pci_info.function, offset, size, value);
+		NETDEV(dev)->pci_info.device, NETDEV(dev)->pci_info.function,
+		offset, size, value);
 }
 
 
@@ -164,14 +166,10 @@ driver_vprintf(const char *format, va_list vl)
 int
 device_printf(device_t dev, const char *format, ...)
 {
-	char devDesc[32];
 	va_list vl;
 
-	snprintf(devDesc, sizeof(devDesc), "%i:%i:%i", (int)dev->pci_info.bus,
-		(int)dev->pci_info.device, (int)dev->pci_info.function);
-
 	va_start(vl, format);
-	driver_vprintf_etc(devDesc, format, vl);
+	driver_vprintf_etc(dev->dev_name, format, vl);
 	va_end(vl);
 	return 0;
 }
@@ -192,6 +190,23 @@ device_set_desc_copy(device_t dev, const char *desc)
 }
 
 
+const char *
+device_get_desc(device_t dev)
+{
+	return dev->description;
+}
+
+
+void
+device_sprintf_name(device_t dev, const char *format, ...)
+{
+	va_list vl;
+	va_start(vl, format);
+	vsnprintf(dev->dev_name, sizeof(dev->dev_name), format, vl);
+	va_end(vl);
+}
+
+
 const char *
 device_get_name(device_t dev)
 {

src/libs/compat/freebsd_network/compat/sys/bus.h

@@ -93,6 +93,7 @@ void *device_get_softc(device_t dev);
 int device_printf(device_t dev, const char *, ...) __printflike(2, 3);
 void device_set_desc(device_t dev, const char *desc);
 void device_set_desc_copy(device_t dev, const char *desc);
+const char *device_get_desc(device_t dev);
 
 device_t device_add_child(device_t dev, const char *name, int unit);
 int device_delete_child(device_t dev, device_t child);

src/libs/compat/freebsd_network/compat/sys/haiku-module.h

@@ -52,32 +52,41 @@ status_t _fbsd_init_driver(driver_t *);
 void _fbsd_uninit_driver(driver_t *);
 
 extern const char gDriverName[];
+driver_t *__haiku_get_miibus_driver(void);
 
 /* we define the driver methods with HAIKU_FBSD_DRIVER_GLUE to
  * force the rest of the stuff to be linked back with the driver.
  * While gcc 2.95 packs everything from the static library onto
  * the final binary, gcc 4.x rightfuly doesn't. */
 
-#define HAIKU_FBSD_DRIVER_GLUE(publicname, name, busname) \
+#define HAIKU_FBSD_DRIVER_GLUE(publicname, name, busname)				\
-	extern char *gDevNameList[]; \
+	extern const char *gDevNameList[];									\
-	extern device_hooks gDeviceHooks; \
+	extern device_hooks gDeviceHooks;									\
-	extern driver_t *DRIVER_MODULE_NAME(name, busname); \
+	extern driver_t *DRIVER_MODULE_NAME(name, busname);					\
-	const char gDriverName[] = #publicname; \
+	const char gDriverName[] = #publicname;								\
-	int32 api_version = B_CUR_DRIVER_API_VERSION; \
+	int32 api_version = B_CUR_DRIVER_API_VERSION;						\
-	status_t init_hardware() \
+	status_t init_hardware()											\
-	{ \
+	{																	\
-		return _fbsd_init_hardware(DRIVER_MODULE_NAME(name, busname)); \
+		return _fbsd_init_hardware(DRIVER_MODULE_NAME(name, busname));	\
-	} \
+	}																	\
-	status_t init_driver() \
+	status_t init_driver()												\
-	{ \
+	{																	\
-		return _fbsd_init_driver(DRIVER_MODULE_NAME(name, busname)); \
+		return _fbsd_init_driver(DRIVER_MODULE_NAME(name, busname));	\
-	} \
+	}																	\
-	void uninit_driver() \
+	void uninit_driver()												\
-	{ \
+		{ _fbsd_uninit_driver(DRIVER_MODULE_NAME(name, busname)); }		\
-		_fbsd_uninit_driver(DRIVER_MODULE_NAME(name, busname)); \
+	const char **publish_devices()										\
-	} \
+		{ return gDevNameList; }										\
-	const char **publish_devices() { return (const char **)gDevNameList; } \
+	device_hooks *find_device(const char *name)							\
-	device_hooks *find_device(const char *name) { return &gDeviceHooks; }
+		{ return &gDeviceHooks; }
+
+#define HAIKU_FBSD_MII_DRIVER(name)						\
+	driver_t *__haiku_get_miibus_driver(device_t dev)	\
+		{ return DRIVER_MODULE_NAME(name, miibus); }
+
+#define HAIKU_NO_FBSD_MII_DRIVER()						\
+	driver_t *__haiku_get_miibus_driver(device_t dev)	\
+		{ return NULL; }
 
 extern spinlock __haiku_intr_spinlock;
 extern int __haiku_disable_interrupts(device_t dev);

src/libs/compat/freebsd_network/device.c

@@ -26,8 +26,8 @@
 #define MAX_DEVICES		8
 
 
-device_t gDevices[MAX_DEVICES];
+struct network_device *gDevices[MAX_DEVICES];
-char *gDevNameList[MAX_DEVICES + 1];
+const char *gDevNameList[MAX_DEVICES + 1];
 
 
 static device_probe_t  *sDeviceProbe;
@@ -36,28 +36,47 @@ static device_detach_t *sDeviceDetach;
 
 
 static device_t
+init_device(device_t dev, driver_t *driver)
+{
+	dev->driver = driver;
+	dev->softc = malloc(driver->softc_size);
+	if (dev->softc == NULL)
+		return NULL;
+
+	return dev;
+}
+
+
+static void
+uninit_device(device_t dev)
+{
+	if (dev->flags & DEVICE_DESC_ALLOCED)
+		free((char *)dev->description);
+	free(dev->softc);
+}
+
+
+static struct network_device *
 allocate_device(driver_t *driver)
 {
 	char semName[64];
 
-	device_t dev = (device_t)malloc(sizeof(struct device));
+	struct network_device *dev = malloc(sizeof(struct network_device));
 	if (dev == NULL)
 		return NULL;
 
 	memset(dev, 0, sizeof(struct device));
 
-	snprintf(semName, sizeof(semName), "%s rcv", gDriverName);
+	if (init_device(DEVNET(dev), driver) == NULL) {
-
-	dev->softc_size = driver->softc_size;
-	dev->softc = malloc(driver->softc_size);
-	if (dev->softc == NULL) {
 		free(dev);
 		return NULL;
 	}
 
+	snprintf(semName, sizeof(semName), "%s rcv", gDriverName);
+
 	dev->receive_sem = create_sem(0, semName);
 	if (dev->receive_sem < 0) {
-		free(dev->softc);
+		uninit_device(DEVNET(dev));
 		free(dev);
 		return NULL;
 	}
@@ -71,13 +90,11 @@ allocate_device(driver_t *driver)
 
 
 static void
-free_device(device_t dev)
+free_device(struct network_device *dev)
 {
 	delete_sem(dev->receive_sem);
 	ifq_uninit(&dev->receive_queue);
-	free(dev->softc);
+	uninit_device(DEVNET(dev));
-	if (dev->flags & DEVICE_DESC_ALLOCED)
-		free((char *)dev->description);
 	free(dev);
 }
 
@@ -100,8 +117,8 @@ _resolve_method(driver_t *driver, const char *name)
 static status_t
 compat_open(const char *name, uint32 flags, void **cookie)
 {
+	struct network_device *dev;
 	status_t status;
-	device_t dev;
 	int i;
 
 	driver_printf("compat_open(%s, 0x%lx)\n", name, flags);
@@ -124,11 +141,11 @@ compat_open(const char *name, uint32 flags, void **cookie)
 		return B_BUSY;
 
 	/* some drivers expect the softc to be zero'ed out */
-	memset(dev->softc, 0, dev->softc_size);
+	memset(dev->base.softc, 0, dev->base.driver->softc_size);
 
-	status = sDeviceAttach(dev);
+	status = sDeviceAttach(DEVNET(dev));
 	if (status != 0)
-		dev->flags = 0;
+		atomic_and(&dev->open, 0);
 
 	driver_printf(" ... status = 0x%ld\n", status);
 
@@ -155,11 +172,11 @@ compat_open(const char *name, uint32 flags, void **cookie)
 static status_t
 compat_close(void *cookie)
 {
-	device_t dev = cookie;
+	struct network_device *dev = cookie;
 
-	device_printf(dev, "compat_close()\n");
+	device_printf(DEVNET(dev), "compat_close()\n");
 
-	atomic_or(&dev->flags, DEVICE_CLOSED);
+	atomic_or(&DEVNET(dev)->flags, DEVICE_CLOSED);
 
 	/* do we need a memory barrier in read() or is the atomic_or
 	 * (and the implicit 'lock') enough? */
@@ -173,11 +190,11 @@ compat_close(void *cookie)
 static status_t
 compat_free(void *cookie)
 {
-	device_t dev = cookie;
+	struct network_device *dev = cookie;
 
-	device_printf(dev, "compat_free()\n");
+	device_printf(DEVNET(dev), "compat_free()\n");
 
-	sDeviceDetach(dev);
+	sDeviceDetach(DEVNET(dev));
 
 	/* XXX empty out the send queue */
 
@@ -191,24 +208,24 @@ compat_free(void *cookie)
 static status_t
 compat_read(void *cookie, off_t position, void *buf, size_t *numBytes)
 {
+	struct network_device *dev = cookie;
 	uint32 semFlags = B_CAN_INTERRUPT;
-	device_t dev = cookie;
 	status_t status;
 	struct mbuf *mb;
 	size_t len;
 
-	driver_printf("compat_read(%p, %lld, %p, [%lu])\n", cookie, position, buf,
+	device_printf(DEVNET(dev), "compat_read(%lld, %p, [%lu])\n", position, buf,
 		*numBytes);
 
-	if (dev->flags & DEVICE_CLOSED)
+	if (DEVNET(dev)->flags & DEVICE_CLOSED)
 		return B_INTERRUPTED;
 
-	if (dev->flags & DEVICE_NON_BLOCK)
+	if (DEVNET(dev)->flags & DEVICE_NON_BLOCK)
 		semFlags |= B_RELATIVE_TIMEOUT;
 
 	do {
 		status = acquire_sem_etc(dev->receive_sem, 1, semFlags, 0);
-		if (dev->flags & DEVICE_CLOSED)
+		if (DEVNET(dev)->flags & DEVICE_CLOSED)
 			return B_INTERRUPTED;
 
 		if (status == B_WOULD_BLOCK) {
@@ -242,10 +259,10 @@ static status_t
 compat_write(void *cookie, off_t position, const void *buffer,
 	size_t *numBytes)
 {
-	device_t dev = cookie;
+	struct network_device *dev = cookie;
 	struct mbuf *mb;
 
-	driver_printf("compat_write(%p, %lld, %p, [%lu])\n", cookie, position,
+	device_printf(DEVNET(dev), "compat_write(%lld, %p, [%lu])\n", position,
 		buffer, *numBytes);
 
 	mb = m_getcl(0, MT_DATA, 0);
@@ -264,7 +281,7 @@ compat_write(void *cookie, off_t position, const void *buffer,
 static status_t
 compat_control(void *cookie, uint32 op, void *arg, size_t len)
 {
-	device_t dev = cookie;
+	struct network_device *dev = cookie;
 	struct ifnet *ifp = dev->ifp;
 
 	switch (op) {
@@ -282,9 +299,9 @@ compat_control(void *cookie, uint32 op, void *arg, size_t len)
 			if (user_memcpy(&value, arg, sizeof(int32)) < B_OK)
 				return B_BAD_ADDRESS;
 			if (value)
-				dev->flags |= DEVICE_NON_BLOCK;
+				DEVNET(dev)->flags |= DEVICE_NON_BLOCK;
 			else
-				dev->flags &= ~DEVICE_NON_BLOCK;
+				DEVNET(dev)->flags &= ~DEVICE_NON_BLOCK;
 			return B_OK;
 		}
 
@@ -378,7 +395,7 @@ device_hooks gDeviceHooks = {
 status_t
 _fbsd_init_hardware(driver_t *driver)
 {
-	struct device fakeDevice;
+	struct network_device fakeDevice;
 	device_probe_t *probe;
 	int i;
 
@@ -397,12 +414,12 @@ _fbsd_init_hardware(driver_t *driver)
 
 	for (i = 0; gPci->get_nth_pci_info(i, &fakeDevice.pci_info) == B_OK; i++) {
 		int result;
-		result = probe(&fakeDevice);
+		result = probe(DEVNET(&fakeDevice));
 		if (result >= 0) {
 			dprintf("%s, found %s at %d\n", gDriverName,
-				fakeDevice.description, i);
+				device_get_desc(DEVNET(&fakeDevice)), i);
-			if (fakeDevice.flags & DEVICE_DESC_ALLOCED)
+			if (DEVNET(&fakeDevice)->flags & DEVICE_DESC_ALLOCED)
-				free((char *)fakeDevice.description);
+				free((char *)DEVNET(&fakeDevice)->description);
 			put_module(B_PCI_MODULE_NAME);
 			return B_OK;
 		}
@@ -420,7 +437,7 @@ _fbsd_init_driver(driver_t *driver)
 {
 	int i, ncards = 0;
 	status_t status;
-	device_t dev;
+	struct network_device *dev;
 
 	dprintf("%s: init_driver(%p)\n", gDriverName, driver);
 
@@ -460,14 +477,15 @@ _fbsd_init_driver(driver_t *driver)
 
 	for (i = 0; dev != NULL
 			&& gPci->get_nth_pci_info(i, &dev->pci_info) == B_OK; i++) {
-		if (sDeviceProbe(dev) >= 0) {
+		device_t base = DEVNET(dev);
-			snprintf(dev->dev_name, sizeof(dev->dev_name), "net/%s/%i",
+
-				gDriverName, ncards);
+		if (sDeviceProbe(base) >= 0) {
-			dprintf("%s, adding %s @%d -> /dev/%s\n", gDriverName, dev->description,
+			device_sprintf_name(base, "net/%s/%i", gDriverName, ncards);
-				i, dev->dev_name);
+			dprintf("%s, adding %s @%d -> /dev/%s\n", gDriverName,
+				device_get_desc(base), i, device_get_name(base));
 
 			gDevices[ncards] = dev;
-			gDevNameList[ncards] = dev->dev_name;
+			gDevNameList[ncards] = device_get_name(base);
 
 			ncards++;
 			if (ncards < MAX_DEVICES)

src/libs/compat/freebsd_network/device.h

@@ -25,27 +25,39 @@
 struct ifnet;
 
 struct device {
-	pci_info		pci_info;
 	char			dev_name[128];
 
-	int32			open;
+	driver_t		*driver;
+
 	int32			flags;
 
+	int				unit;
+	char			nameunit[64];
+	const char *	description;
+	void *			softc;
+};
+
+
+struct network_device {
+	struct device base;
+
+	pci_info		pci_info;
+
+	int32			open;
+
 	struct ifqueue	receive_queue;
 	sem_id			receive_sem;
 
 	sem_id			link_state_sem;
 
 	struct ifnet *	ifp;
-
-	int				unit;
-	char			nameunit[64];
-	const char *	description;
-	void *			softc;
-	size_t			softc_size;
 };
 
 
+#define DEVNET(dev)		((device_t)(&(dev)->base))
+#define NETDEV(base)	((struct network_device *)(base))
+
+
 enum {
 	DEVICE_OPEN			= 1 << 0,
 	DEVICE_CLOSED		= 1 << 1,
@@ -80,16 +92,20 @@ void uninit_taskqueues(void);
 void init_bounce_pages(void);
 void uninit_bounce_pages(void);
 
-void driver_printf(const char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
+void driver_printf(const char *format, ...)
+	__attribute__ ((format (__printf__, 1, 2)));
 void driver_vprintf(const char *format, va_list vl);
 
+void device_sprintf_name(device_t dev, const char *format, ...)
+	__attribute__ ((format (__printf__, 2, 3)));
+
 void ifq_init(struct ifqueue *ifq, const char *name);
 void ifq_uninit(struct ifqueue *ifq);
 
 extern struct net_stack_module_info *gStack;
 extern pci_module_info *gPci;
 
-extern char *gDevNameList[];
+extern const char *gDevNameList[];
-extern struct device *gDevices[];
+extern struct network_device *gDevices[];
 
 #endif

src/libs/compat/freebsd_network/if.c

@@ -67,8 +67,8 @@ if_initname(struct ifnet *ifp, const char *name, int unit)
 	if (gDevNameList[i] == NULL)
 		panic("unknown interface");
 
-	ifp->if_dev = gDevices[i];
+	ifp->if_dev = DEVNET(gDevices[i]);
-	ifp->if_dev->ifp = ifp;
+	gDevices[i]->ifp = ifp;
 }
 
 
@@ -146,7 +146,8 @@ if_link_state_change(struct ifnet *ifp, int link_state)
 
 	ifp->if_link_state = link_state;
 
-	release_sem_etc(ifp->if_dev->link_state_sem, 1, B_DO_NOT_RESCHEDULE);
+	release_sem_etc(NETDEV(ifp->if_dev)->link_state_sem, 1,
+		B_DO_NOT_RESCHEDULE);
 }
 
 
@@ -269,8 +270,8 @@ ether_input(struct ifnet *ifp, struct mbuf *m)
 {
 	device_t dev = ifp->if_dev;
 
-	IF_ENQUEUE(&dev->receive_queue, m);
+	IF_ENQUEUE(&NETDEV(dev)->receive_queue, m);
-	release_sem_etc(dev->receive_sem, 1, B_DO_NOT_RESCHEDULE);
+	release_sem_etc(NETDEV(dev)->receive_sem, 1, B_DO_NOT_RESCHEDULE);
 }