[mirror_spl.git] / include / sys / sunddi.h

/*
 *  This file is part of the SPL: Solaris Porting Layer.
 *
 *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
 *  Produced at Lawrence Livermore National Laboratory
 *  Written by:
 *          Brian Behlendorf <behlendorf1@llnl.gov>,
 *          Herb Wartens <wartens2@llnl.gov>,
 *          Jim Garlick <garlick@llnl.gov>
 *  UCRL-CODE-235197
 *
 *  This is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */

#ifndef _SPL_SUNDDI_H
#define _SPL_SUNDDI_H

#include <sys/cred.h>
#include <sys/uio.h>
#include <sys/sunldi.h>
#include <sys/mutex.h>
#include <sys/u8_textprep.h>
#include <sys/vnode.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <spl-device.h>

#define DDI_MAX_NAME_LEN	32

typedef int ddi_devid_t;

typedef enum {
	DDI_INFO_DEVT2DEVINFO	= 0,
	DDI_INFO_DEVT2INSTANCE	= 1
} ddi_info_cmd_t;

typedef enum {
	DDI_ATTACH		= 0,
	DDI_RESUME		= 1,
	DDI_PM_RESUME		= 2
} ddi_attach_cmd_t;

typedef enum {
	DDI_DETACH		= 0,
	DDI_SUSPEND		= 1,
	DDI_PM_SUSPEND		= 2,
	DDI_HOTPLUG_DETACH	= 3
} ddi_detach_cmd_t;

typedef enum {
	DDI_RESET_FORCE = 0
} ddi_reset_cmd_t;

typedef enum {
	PROP_LEN		= 0,
	PROP_LEN_AND_VAL_BUF	= 1,
	PROP_LEN_AND_VAL_ALLOC	= 2,
	PROP_EXISTS		= 3
} ddi_prop_op_t;

typedef void *devmap_cookie_t;
typedef struct as {
       uchar_t  a_flags;
} as_t;

typedef struct pollhead {
	struct polldat *ph_list;
} pollhead_t;

typedef struct dev_info {
	kmutex_t di_lock;
	char di_name[DDI_MAX_NAME_LEN];
	struct dev_ops *di_ops;
	struct cdev *di_cdev;
	spl_class *di_class;
	spl_device *di_device;
	major_t	di_major;
	minor_t di_minor;
	dev_t di_dev;
	unsigned di_minors;
	int di_flags;
	struct list_head di_list;
} dev_info_t;

typedef struct cb_ops {
	int (*cb_open)(dev_t *devp, int flag, int otyp, cred_t *credp);
	int (*cb_close)(dev_t dev, int flag, int otyp, cred_t *credp);
	int (*cb_strategy)(void *bp);
	int (*cb_print)(dev_t dev, char *str);
	int (*cb_dump)(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
	int (*cb_read)(dev_t dev, struct uio *uiop, cred_t *credp);
	int (*cb_write)(dev_t dev, struct uio *uiop, cred_t *credp);
	int (*cb_ioctl)(dev_t dev, int cmd, intptr_t arg, int mode,
	                cred_t *credp, int *rvalp);
	int (*cb_devmap)(dev_t dev, devmap_cookie_t dhp, offset_t off,
	                 size_t len, size_t *maplen, uint_t model);
	int (*cb_mmap)(dev_t dev, off_t off, int prot);
	int (*cb_segmap)(dev_t dev, off_t off, struct as *asp,
	                 caddr_t *addrp, off_t len, unsigned int prot,
	                 unsigned int maxprot, unsigned int flags,
	                 cred_t *credp);
	int (*cb_chpoll)(dev_t dev, short events, int anyyet,
	                 short *reventsp, struct pollhead **phpp);
	int (*cb_prop_op)(dev_t dev, dev_info_t *dip,
	                  ddi_prop_op_t prop_op, int mod_flags,
	                  char *name, caddr_t valuep, int *length);
	struct streamtab *cb_str;
	int cb_flag;
	int cb_rev;
	int (*cb_aread)(dev_t dev, struct aio_req *aio, cred_t *credp);
	int (*cb_awrite)(dev_t dev, struct aio_req *aio, cred_t *credp);
} cb_ops_t;

typedef struct dev_ops {
	int devo_rev;
	int devo_refcnt;

	int (*devo_getinfo)(dev_info_t *dip,
	                    ddi_info_cmd_t infocmd, void *arg, void **result);
	int (*devo_identify)(dev_info_t *dip);
	int (*devo_probe)(dev_info_t *dip);
	int (*devo_attach)(dev_info_t *dip, ddi_attach_cmd_t cmd);
	int (*devo_detach)(dev_info_t *dip, ddi_detach_cmd_t cmd);
	int (*devo_reset)(dev_info_t *dip, ddi_reset_cmd_t cmd);

	struct cb_ops *devo_cb_ops;
	struct bus_ops *devo_bus_ops;
	int (*devo_power)(dev_info_t *dip, int component, int level);
	int (*devo_quiesce)(dev_info_t *dip);
} dev_ops_t;

typedef struct mod_ops {
	int (*modm_install)(void);
	int (*modm_remove)(void);
	int (*modm_info)(void);
} mod_ops_t;

typedef struct modldrv {
	struct mod_ops *drv_modops;
	char *drv_linkinfo;
	struct dev_ops *drv_dev_ops;
	struct dev_info *drv_dev_info;
} modldrv_t;

#define	MODREV_1			1

#define	D_NEW				0x000
#define D_MP				0x020
#define	D_64BIT				0x200

#define	DEVO_REV			3
#define	CB_REV				1

#define	DDI_SUCCESS			0
#define	DDI_FAILURE			-1

#define	DDI_PSEUDO			"ddi_pseudo"

#define nodev				NULL
#define nochpoll			NULL
#define nulldev				NULL
#define mod_driverops			NULL
#define ddi_prop_op			NULL

#define getminor(x)			(x)
#define getmajor(x)			(x)
#define ddi_driver_major(di)		getmajor(di->di_dev)

#define	DDI_DEV_T_NONE			((dev_t)-1)
#define	DDI_DEV_T_ANY			((dev_t)-2)
#define	DDI_MAJOR_T_UNKNOWN		((major_t)0)

#define	DDI_PROP_DONTPASS		0x0001
#define	DDI_PROP_CANSLEEP		0x0002

#define	GLOBAL_DEV			0x02
#define	NODEBOUND_DEV			0x04
#define	NODESPECIFIC_DEV		0x06
#define	ENUMERATED_DEV			0x08

#define ddi_prop_lookup_string(x1,x2,x3,x4,x5)	(*x5 = NULL)
#define ddi_prop_free(x)			(void)0
#define ddi_root_node()				(void)0

#define mod_install(x)			0
#define mod_remove(x)			0

extern int __ddi_create_minor_node(dev_info_t *dip, char *name, int spec_type,
                                   minor_t minor_num, char *node_type,
				   int flags, struct module *mod);
extern void __ddi_remove_minor_node(dev_info_t *dip, char *name);
extern int ddi_quiesce_not_needed(dev_info_t *dip);
extern int __mod_install(struct modlinkage *modlp);
extern int __mod_remove(struct modlinkage *modlp);
extern int __mod_mknod(char *name, char *type, int major, int minor);

extern int ddi_strtoul(const char *, char **, int, unsigned long *);
extern int ddi_strtol(const char *, char **, int, long *);
extern int ddi_strtoull(const char *, char **, int, unsigned long long *);
extern int ddi_strtoll(const char *, char **, int, long long *);

static __inline__ void ddi_report_dev(dev_info_t *d) { }
static __inline__ void ddi_prop_remove_all(dev_info_t *dip) { }

static __inline__ void
ddi_remove_minor_node(dev_info_t *di, char *name)
{
#ifdef HAVE_GPL_ONLY_SYMBOLS
	/* Cleanup udev (GPL-only symbols required).  This is performed as
	 * part of an inline function to ensure that these symbols are not
	 * linked against the SPL which is GPL'ed.  But instead they are
	 * linked against the package building against the SPL to ensure
	 * its license allows linking with GPL-only symbols. */
	if (di->di_class) {
		spl_device_destroy(di->di_class, di->di_device, di->di_dev);
		spl_class_destroy(di->di_class);
		di->di_class = NULL;
		di->di_dev = 0;
	}
#else
	/* When we do not have access to the GPL-only device interfaces we
	 * are forced to do something crude.  We unlink the special device
	 * file in /dev/ ourselves from within the kernel.  On the upside we
	 * are already providing this functionality for Solaris, and it is
	 * easy to leverage the Solaris API to perform the unlink. */
	if (strlen(di->di_name) > 0)
		vn_remove(di->di_name, UIO_SYSSPACE, RMFILE);

#endif /* HAVE_GPL_ONLY_SYMBOLS */

	__ddi_remove_minor_node(di, name);
}

static __inline__ int
ddi_create_minor_node(dev_info_t *di, char *name, int spec_type,
                      minor_t minor_num, char *node_type, int flags)
{
	int rc;

	rc = __ddi_create_minor_node(di, name, spec_type, minor_num,
	                             node_type, flags, THIS_MODULE);
	if (rc)
		return rc;

#ifdef HAVE_GPL_ONLY_SYMBOLS
	/* Setup udev (GPL-only symbols required).  This is performed as
	 * part of an inline function to ensure that these symbols are not
	 * linked against the SPL which is GPL'ed.  But instead they are
	 * linked against the package building against the SPL to ensure
	 * its license allows linking with GPL-only symbols. */
	di->di_class = spl_class_create(THIS_MODULE, name);
	if (IS_ERR(di->di_class)) {
		rc = PTR_ERR(di->di_class);
		di->di_class = NULL;
		ddi_remove_minor_node(di, name);
		CERROR("Error creating %s class, %d\n", name, rc);
		return DDI_FAILURE;
	}

	/* Do not append a 0 to devices with minor nums of 0 */
	di->di_device = spl_device_create(di->di_class, NULL, di->di_dev, NULL,
					  (di->di_minor == 0) ? "%s" : "%s%d",
					  name, di->di_minor);
#else
	/* When we do not have access to the GPL-only device interfaces we
	 * are forced to do something horible.  We use a user mode helper to
	 * create the special device file in /dev/.  By futher extending the
	 * Solaris vnode implementation we could potentially do a vn_create()
	 * from within the kernel but that's still a hack. */
	if (name) {
		rc = __mod_mknod(di->di_name, "c", di->di_major, di->di_minor);
		if (rc) {
			CERROR("Error mknod %s, %d\n", di->di_name, rc);
			ddi_remove_minor_node(di, name);
		}
	}

#endif /* HAVE_GPL_ONLY_SYMBOLS */

	return rc;
}

#undef mod_install
#undef mod_remove

#define mod_install			__mod_install
#define mod_remove			__mod_remove

#endif /* SPL_SUNDDI_H */
Commit	Line	Data
715f6251	1	/*
	2	* This file is part of the SPL: Solaris Porting Layer.
	3	*
	4	* Copyright (c) 2008 Lawrence Livermore National Security, LLC.
	5	* Produced at Lawrence Livermore National Laboratory
	6	* Written by:
	7	* Brian Behlendorf <behlendorf1@llnl.gov>,
	8	* Herb Wartens <wartens2@llnl.gov>,
	9	* Jim Garlick <garlick@llnl.gov>
	10	* UCRL-CODE-235197
	11	*
	12	* This is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	25	*/
	26
23f28c4f	27	#ifndef _SPL_SUNDDI_H
	28	#define _SPL_SUNDDI_H
	29
4e62fd41	30	#include <sys/cred.h>
	31	#include <sys/uio.h>
	32	#include <sys/sunldi.h>
	33	#include <sys/mutex.h>
b53c565e	34	#include <sys/u8_textprep.h>
36b313da	35	#include <sys/vnode.h>
4e62fd41	36	#include <linux/kdev_t.h>
	37	#include <linux/fs.h>
	38	#include <linux/cdev.h>
	39	#include <linux/list.h>
46c685d0	40	#include <spl-device.h>
4e62fd41	41
36b313da BB	42	#define DDI_MAX_NAME_LEN 32
36b313da BB	43
4e62fd41	44	typedef int ddi_devid_t;
	45
	46	typedef enum {
	47	DDI_INFO_DEVT2DEVINFO = 0,
	48	DDI_INFO_DEVT2INSTANCE = 1
	49	} ddi_info_cmd_t;
	50
	51	typedef enum {
	52	DDI_ATTACH = 0,
	53	DDI_RESUME = 1,
	54	DDI_PM_RESUME = 2
	55	} ddi_attach_cmd_t;
	56
	57	typedef enum {
	58	DDI_DETACH = 0,
	59	DDI_SUSPEND = 1,
	60	DDI_PM_SUSPEND = 2,
	61	DDI_HOTPLUG_DETACH = 3
	62	} ddi_detach_cmd_t;
	63
	64	typedef enum {
	65	DDI_RESET_FORCE = 0
	66	} ddi_reset_cmd_t;
	67
	68	typedef enum {
	69	PROP_LEN = 0,
	70	PROP_LEN_AND_VAL_BUF = 1,
	71	PROP_LEN_AND_VAL_ALLOC = 2,
	72	PROP_EXISTS = 3
	73	} ddi_prop_op_t;
	74
	75	typedef void *devmap_cookie_t;
	76	typedef struct as {
	77	uchar_t a_flags;
	78	} as_t;
	79
	80	typedef struct pollhead {
	81	struct polldat *ph_list;
	82	} pollhead_t;
	83
	84	typedef struct dev_info {
	85	kmutex_t di_lock;
36b313da	86	char di_name[DDI_MAX_NAME_LEN];
4e62fd41	87	struct dev_ops *di_ops;
4e62fd41	88	struct cdev *di_cdev;
46c685d0	89	spl_class *di_class;
25557fd8	90	spl_device *di_device;
4e62fd41	91	major_t di_major;
	92	minor_t di_minor;
	93	dev_t di_dev;
	94	unsigned di_minors;
6a1c3d41	95	int di_flags;
4e62fd41	96	struct list_head di_list;
	97	} dev_info_t;
	98
	99	typedef struct cb_ops {
	100	int (cb_open)(dev_t devp, int flag, int otyp, cred_t *credp);
	101	int (cb_close)(dev_t dev, int flag, int otyp, cred_t credp);
	102	int (cb_strategy)(void bp);
	103	int (cb_print)(dev_t dev, char str);
	104	int (*cb_dump)(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
	105	int (cb_read)(dev_t dev, struct uio uiop, cred_t *credp);
	106	int (cb_write)(dev_t dev, struct uio uiop, cred_t *credp);
	107	int (*cb_ioctl)(dev_t dev, int cmd, intptr_t arg, int mode,
	108	cred_t credp, int rvalp);
	109	int (*cb_devmap)(dev_t dev, devmap_cookie_t dhp, offset_t off,
	110	size_t len, size_t *maplen, uint_t model);
	111	int (*cb_mmap)(dev_t dev, off_t off, int prot);
	112	int (cb_segmap)(dev_t dev, off_t off, struct as asp,
	113	caddr_t *addrp, off_t len, unsigned int prot,
	114	unsigned int maxprot, unsigned int flags,
	115	cred_t *credp);
	116	int (*cb_chpoll)(dev_t dev, short events, int anyyet,
	117	short reventsp, struct pollhead *phpp);
	118	int (cb_prop_op)(dev_t dev, dev_info_t dip,
	119	ddi_prop_op_t prop_op, int mod_flags,
	120	char name, caddr_t valuep, int length);
	121	struct streamtab *cb_str;
	122	int cb_flag;
	123	int cb_rev;
	124	int (cb_aread)(dev_t dev, struct aio_req aio, cred_t *credp);
	125	int (cb_awrite)(dev_t dev, struct aio_req aio, cred_t *credp);
	126	} cb_ops_t;
	127
	128	typedef struct dev_ops {
	129	int devo_rev;
	130	int devo_refcnt;
	131
	132	int (devo_getinfo)(dev_info_t dip,
	133	ddi_info_cmd_t infocmd, void arg, void *result);
	134	int (devo_identify)(dev_info_t dip);
	135	int (devo_probe)(dev_info_t dip);
	136	int (devo_attach)(dev_info_t dip, ddi_attach_cmd_t cmd);
	137	int (devo_detach)(dev_info_t dip, ddi_detach_cmd_t cmd);
	138	int (devo_reset)(dev_info_t dip, ddi_reset_cmd_t cmd);
	139
	140	struct cb_ops *devo_cb_ops;
	141	struct bus_ops *devo_bus_ops;
	142	int (devo_power)(dev_info_t dip, int component, int level);
d83ba26e	143	int (devo_quiesce)(dev_info_t dip);
4e62fd41	144	} dev_ops_t;
	145
	146	typedef struct mod_ops {
	147	int (*modm_install)(void);
	148	int (*modm_remove)(void);
	149	int (*modm_info)(void);
	150	} mod_ops_t;
	151
	152	typedef struct modldrv {
	153	struct mod_ops *drv_modops;
	154	char *drv_linkinfo;
	155	struct dev_ops *drv_dev_ops;
	156	struct dev_info *drv_dev_info;
	157	} modldrv_t;
	158
	159	#define MODREV_1 1
	160
	161	#define D_NEW 0x000
	162	#define D_MP 0x020
	163	#define D_64BIT 0x200
	164
	165	#define DEVO_REV 3
	166	#define CB_REV 1
	167
	168	#define DDI_SUCCESS 0
	169	#define DDI_FAILURE -1
	170
	171	#define DDI_PSEUDO "ddi_pseudo"
	172
	173	#define nodev NULL
	174	#define nochpoll NULL
	175	#define nulldev NULL
	176	#define mod_driverops NULL
	177	#define ddi_prop_op NULL
	178
b831734a	179	#define getminor(x) (x)
	180	#define getmajor(x) (x)
	181	#define ddi_driver_major(di) getmajor(di->di_dev)
4e62fd41	182
6ab69573	183	#define DDI_DEV_T_NONE ((dev_t)-1)
	184	#define DDI_DEV_T_ANY ((dev_t)-2)
	185	#define DDI_MAJOR_T_UNKNOWN ((major_t)0)
	186
	187	#define DDI_PROP_DONTPASS 0x0001
	188	#define DDI_PROP_CANSLEEP 0x0002
	189
6a1c3d41	190	#define GLOBAL_DEV 0x02
	191	#define NODEBOUND_DEV 0x04
	192	#define NODESPECIFIC_DEV 0x06
	193	#define ENUMERATED_DEV 0x08
	194
6ab69573	195	#define ddi_prop_lookup_string(x1,x2,x3,x4,x5) (*x5 = NULL)
	196	#define ddi_prop_free(x) (void)0
	197	#define ddi_root_node() (void)0
	198
4e62fd41	199	#define mod_install(x) 0
	200	#define mod_remove(x) 0
	201
	202	extern int __ddi_create_minor_node(dev_info_t dip, char name, int spec_type,
	203	minor_t minor_num, char *node_type,
6a1c3d41	204	int flags, struct module *mod);
4e62fd41	205	extern void __ddi_remove_minor_node(dev_info_t dip, char name);
d83ba26e	206	extern int ddi_quiesce_not_needed(dev_info_t *dip);
4e62fd41	207	extern int __mod_install(struct modlinkage *modlp);
4e62fd41	208	extern int __mod_remove(struct modlinkage *modlp);
36b313da	209	extern int __mod_mknod(char name, char type, int major, int minor);
4e62fd41	210
2ee63a54 BB	211	extern int ddi_strtoul(const char , char , int, unsigned long );
	212	extern int ddi_strtol(const char , char , int, long );
	213	extern int ddi_strtoull(const char , char , int, unsigned long long );
	214	extern int ddi_strtoll(const char , char , int, long long );
	215
4e62fd41	216	static __inline__ void ddi_report_dev(dev_info_t *d) { }
	217	static __inline__ void ddi_prop_remove_all(dev_info_t *dip) { }
	218
6a1c3d41	219	static __inline__ void
	220	ddi_remove_minor_node(dev_info_t di, char name)
	221	{
	222	#ifdef HAVE_GPL_ONLY_SYMBOLS
	223	/* Cleanup udev (GPL-only symbols required). This is performed as
	224	* part of an inline function to ensure that these symbols are not
	225	* linked against the SPL which is GPL'ed. But instead they are
	226	* linked against the package building against the SPL to ensure
	227	* its license allows linking with GPL-only symbols. */
	228	if (di->di_class) {
	229	spl_device_destroy(di->di_class, di->di_device, di->di_dev);
	230	spl_class_destroy(di->di_class);
	231	di->di_class = NULL;
	232	di->di_dev = 0;
	233	}
36b313da BB	234	#else
	235	/* When we do not have access to the GPL-only device interfaces we
	236	* are forced to do something crude. We unlink the special device
	237	* file in /dev/ ourselves from within the kernel. On the upside we
	238	* are already providing this functionality for Solaris, and it is
	239	* easy to leverage the Solaris API to perform the unlink. */
	240	if (strlen(di->di_name) > 0)
	241	vn_remove(di->di_name, UIO_SYSSPACE, RMFILE);
	242
	243	#endif /* HAVE_GPL_ONLY_SYMBOLS */
6a1c3d41	244
	245	__ddi_remove_minor_node(di, name);
	246	}
	247
4e62fd41	248	static __inline__ int
4e62fd41	249	ddi_create_minor_node(dev_info_t di, char name, int spec_type,
6a1c3d41	250	minor_t minor_num, char *node_type, int flags)
4e62fd41	251	{
6a1c3d41	252	int rc;
	253
	254	rc = __ddi_create_minor_node(di, name, spec_type, minor_num,
	255	node_type, flags, THIS_MODULE);
	256	if (rc)
	257	return rc;
	258
	259	#ifdef HAVE_GPL_ONLY_SYMBOLS
	260	/* Setup udev (GPL-only symbols required). This is performed as
	261	* part of an inline function to ensure that these symbols are not
	262	* linked against the SPL which is GPL'ed. But instead they are
	263	* linked against the package building against the SPL to ensure
	264	* its license allows linking with GPL-only symbols. */
	265	di->di_class = spl_class_create(THIS_MODULE, name);
	266	if (IS_ERR(di->di_class)) {
	267	rc = PTR_ERR(di->di_class);
	268	di->di_class = NULL;
	269	ddi_remove_minor_node(di, name);
	270	CERROR("Error creating %s class, %d\n", name, rc);
36b313da	271	return DDI_FAILURE;
6a1c3d41	272	}
	273
	274	/* Do not append a 0 to devices with minor nums of 0 */
	275	di->di_device = spl_device_create(di->di_class, NULL, di->di_dev, NULL,
	276	(di->di_minor == 0) ? "%s" : "%s%d",
	277	name, di->di_minor);
36b313da BB	278	#else
	279	/* When we do not have access to the GPL-only device interfaces we
	280	* are forced to do something horible. We use a user mode helper to
	281	* create the special device file in /dev/. By futher extending the
	282	* Solaris vnode implementation we could potentially do a vn_create()
	283	* from within the kernel but that's still a hack. */
	284	if (name) {
	285	rc = __mod_mknod(di->di_name, "c", di->di_major, di->di_minor);
	286	if (rc) {
	287	CERROR("Error mknod %s, %d\n", di->di_name, rc);
	288	ddi_remove_minor_node(di, name);
	289	}
	290	}
	291
	292	#endif /* HAVE_GPL_ONLY_SYMBOLS */
6a1c3d41	293
6a1c3d41	294	return rc;
4e62fd41	295	}
	296
	297	#undef mod_install
	298	#undef mod_remove
	299
4e62fd41	300	#define mod_install __mod_install
	301	#define mod_remove __mod_remove
	302
23f28c4f	303	#endif /* SPL_SUNDDI_H */