#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 <linux/kdev_t.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/list.h>
+#include <linux/device.h>
+
+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;
+ struct dev_ops *di_ops;
+ struct cdev *di_cdev;
+ struct class *di_class;
+ major_t di_major;
+ minor_t di_minor;
+ dev_t di_dev;
+ unsigned di_minors;
+ 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);
+} 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 MINOR
+#define getmajor MAJOR
+
+#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 flag, struct module *mod);
+extern void __ddi_remove_minor_node(dev_info_t *dip, char *name);
+extern int __mod_install(struct modlinkage *modlp);
+extern int __mod_remove(struct modlinkage *modlp);
+
+static __inline__ void ddi_report_dev(dev_info_t *d) { }
+static __inline__ void ddi_prop_remove_all(dev_info_t *dip) { }
+
+static __inline__ major_t
+ddi_driver_major(dev_info_t *di)
+{
+ return getminor(di->di_dev);
+}
+
+static __inline__ int
+ddi_create_minor_node(dev_info_t *di, char *name, int spec_type,
+ minor_t minor_num, char *node_type, int flag)
+{
+ return __ddi_create_minor_node(di, name, spec_type, minor_num,
+ node_type, flag, THIS_MODULE);
+
+}
+
+#undef mod_install
+#undef mod_remove
+
+#define ddi_remove_minor_node __ddi_remove_minor_node
+#define mod_install __mod_install
+#define mod_remove __mod_remove
+
#endif /* SPL_SUNDDI_H */
--- /dev/null
+#include <sys/sysmacros.h>
+#include <sys/sunddi.h>
+#include "config.h"
+
+static spinlock_t dev_info_lock = SPIN_LOCK_UNLOCKED;
+static LIST_HEAD(dev_info_list);
+
+static struct dev_info *
+get_dev_info(dev_t dev)
+{
+ struct dev_info *di;
+
+ spin_lock(&dev_info_lock);
+
+ list_for_each_entry(di, &dev_info_list, di_list)
+ if (di->di_dev == dev)
+ goto out;
+
+ di = NULL;
+out:
+ spin_unlock(&dev_info_lock);
+ return di;
+}
+
+static int
+mod_generic_ioctl(struct inode *ino, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct dev_info *di;
+ int rc, flag = 0, rvalp = 0;
+ cred_t *cr = NULL;
+
+ di = get_dev_info(MKDEV(imajor(ino), iminor(ino)));
+ if (di == NULL)
+ return EINVAL;
+
+ rc = di->di_ops->devo_cb_ops->cb_ioctl(di->di_dev,
+ (int)cmd,(intptr_t)arg,
+ flag, cr, &rvalp);
+ return rc;
+}
+
+int
+__ddi_create_minor_node(dev_info_t *di, char *name, int spec_type,
+ minor_t minor_num, char *node_type,
+ int flag, struct module *mod)
+{
+ struct cdev *cdev;
+ struct dev_ops *dev_ops;
+ struct cb_ops *cb_ops;
+ struct file_operations *fops;
+ int rc;
+
+ BUG_ON(spec_type != S_IFCHR);
+ BUG_ON(minor_num < di->di_minors);
+ BUG_ON(strcmp(node_type, DDI_PSEUDO));
+ BUG_ON(flag != 0);
+
+ fops = kmalloc(sizeof(struct file_operations), GFP_KERNEL);
+ if (fops == NULL)
+ return DDI_FAILURE;
+
+ cdev = cdev_alloc();
+ if (cdev == NULL) {
+ kfree(fops);
+ return DDI_FAILURE;
+ }
+
+ cdev->ops = fops;
+
+ mutex_enter(&di->di_lock);
+ dev_ops = di->di_ops;
+ BUG_ON(dev_ops == NULL);
+ cb_ops = di->di_ops->devo_cb_ops;
+ BUG_ON(cb_ops == NULL);
+
+ /* Setup the fops to cb_ops mapping */
+ fops->owner = mod;
+ if (cb_ops->cb_ioctl)
+ fops->ioctl = mod_generic_ioctl;
+
+#if 0
+ if (cb_ops->cb_open)
+ fops->open = mod_generic_open;
+
+ if (cb_ops->cb_close)
+ fops->release = mod_generic_close;
+
+ if (cb_ops->cb_read)
+ fops->read = mod_generic_read;
+
+ if (cb_ops->cb_write)
+ fops->write = mod_generic_write;
+#endif
+ /* XXX: Currently unsupported operations */
+ BUG_ON(cb_ops->cb_open != NULL);
+ BUG_ON(cb_ops->cb_close != NULL);
+ BUG_ON(cb_ops->cb_read != NULL);
+ BUG_ON(cb_ops->cb_write != NULL);
+ BUG_ON(cb_ops->cb_strategy != NULL);
+ BUG_ON(cb_ops->cb_print != NULL);
+ BUG_ON(cb_ops->cb_dump != NULL);
+ BUG_ON(cb_ops->cb_devmap != NULL);
+ BUG_ON(cb_ops->cb_mmap != NULL);
+ BUG_ON(cb_ops->cb_segmap != NULL);
+ BUG_ON(cb_ops->cb_chpoll != NULL);
+ BUG_ON(cb_ops->cb_prop_op != NULL);
+ BUG_ON(cb_ops->cb_str != NULL);
+ BUG_ON(cb_ops->cb_aread != NULL);
+ BUG_ON(cb_ops->cb_awrite != NULL);
+
+ di->di_minor = minor_num;
+ di->di_dev = MKDEV(di->di_major, di->di_minor);
+
+ rc = cdev_add(cdev, di->di_dev, 1);
+ if (rc) {
+ printk("spl: Error adding cdev, %d\n", rc);
+ kfree(fops);
+ cdev_del(cdev);
+ mutex_exit(&di->di_lock);
+ return DDI_FAILURE;
+ }
+
+ di->di_class = class_create(THIS_MODULE, name);
+ if (IS_ERR(di->di_class)) {
+ rc = PTR_ERR(di->di_class);
+ printk("spl: Error creating %s class, %d\n", name, rc);
+ kfree(fops);
+ cdev_del(di->di_cdev);
+ mutex_exit(&di->di_lock);
+ return DDI_FAILURE;
+ }
+
+ class_device_create(di->di_class, NULL, di->di_dev,
+ NULL, "%s%d", name, di->di_minor);
+
+ di->di_cdev = cdev;
+
+ spin_lock(&dev_info_lock);
+ list_add(&di->di_list, &dev_info_list);
+ spin_unlock(&dev_info_lock);
+
+ mutex_exit(&di->di_lock);
+
+ return DDI_SUCCESS;
+}
+EXPORT_SYMBOL(__ddi_create_minor_node);
+
+static void
+___ddi_remove_minor_node(dev_info_t *di, char *name)
+{
+ class_device_destroy(di->di_class, di->di_dev);
+ class_destroy(di->di_class);
+ cdev_del(di->di_cdev);
+
+ spin_lock(&dev_info_lock);
+ list_del(&di->di_list);
+ spin_unlock(&dev_info_lock);
+}
+
+void
+__ddi_remove_minor_node(dev_info_t *di, char *name)
+{
+ mutex_enter(&di->di_lock);
+ ___ddi_remove_minor_node(di, name);
+ mutex_exit(&di->di_lock);
+}
+EXPORT_SYMBOL(ddi_remove_minor_node);
+
+#if 0
+static int
+mod_generic_open(struct inode *, struct file *)
+{
+ open(dev_t *devp, int flag, int otyp, cred_t *credp);
+}
+
+static int
+mod_generic_close(struct inode *, struct file *)
+{
+ close(dev_t dev, int flag, int otyp, cred_t *credp);
+}
+
+static ssize_t
+mod_generic_read(struct file *, char __user *, size_t, loff_t *)
+{
+ read(dev_t dev, struct uio *uiop, cred_t *credp);
+}
+
+static ssize_t
+mod_generic_write(struct file *, const char __user *, size_t, loff_t *)
+{
+ write(dev_t dev, struct uio *uiop, cred_t *credp);
+}
+#endif
+
+static struct dev_info *
+dev_info_alloc(major_t major, minor_t minors, struct dev_ops *ops) {
+ struct dev_info *di;
+
+ di = kmalloc(sizeof(struct dev_info), GFP_KERNEL);
+ if (di == NULL)
+ return NULL;
+
+ mutex_init(&di->di_lock, NULL, MUTEX_DEFAULT, NULL);
+ INIT_LIST_HEAD(&di->di_list);
+ di->di_ops = ops;
+ di->di_class = NULL;
+ di->di_cdev = NULL;
+ di->di_major = major;
+ di->di_minor = 0;
+ di->di_minors = minors;
+ di->di_dev = 0;
+
+ return di;
+}
+
+static void
+dev_info_free(struct dev_info *di)
+{
+ mutex_enter(&di->di_lock);
+ __ddi_remove_minor_node(di, NULL);
+ mutex_exit(&di->di_lock);
+ mutex_destroy(&di->di_lock);
+ kfree(di);
+}
+
+int
+__mod_install(struct modlinkage *modlp)
+{
+ struct modldrv *drv = modlp->ml_modldrv;
+ struct dev_info *di;
+ int rc;
+
+ di = dev_info_alloc(modlp->ml_major, modlp->ml_minors,
+ drv->drv_dev_ops);
+ if (di == NULL)
+ return ENOMEM;
+
+ /* XXX: Really we need to be calling devo_probe if it's available
+ * and then calling devo_attach for each device discovered. However
+ * for now we just call it once and let the app sort it out.
+ */
+ rc = drv->drv_dev_ops->devo_attach(di, DDI_ATTACH);
+ if (rc != DDI_SUCCESS) {
+ dev_info_free(di);
+ return rc;
+ }
+
+ drv->drv_dev_info = di;
+
+ return DDI_SUCCESS;
+}
+EXPORT_SYMBOL(__mod_install);
+
+int
+__mod_remove(struct modlinkage *modlp)
+{
+ struct modldrv *drv = modlp->ml_modldrv;
+ struct dev_info *di = drv->drv_dev_info;
+ int rc;
+
+ rc = drv->drv_dev_ops->devo_detach(di, DDI_DETACH);
+ if (rc != DDI_SUCCESS)
+ return rc;
+
+ dev_info_free(di);
+ drv->drv_dev_info = NULL;
+
+ return DDI_SUCCESS;
+}
+EXPORT_SYMBOL(__mod_remove);
+
+int
+ldi_ident_from_mod(struct modlinkage *modlp, ldi_ident_t *lip)
+{
+ ldi_ident_t li;
+
+ BUG_ON(modlp == NULL || lip == NULL);
+
+ li = kmalloc(sizeof(struct ldi_ident), GFP_KERNEL);
+ if (li == NULL)
+ return ENOMEM;
+
+ li->li_dev = MKDEV(modlp->ml_major, 0);
+ *lip = li;
+
+ return 0;
+}
+EXPORT_SYMBOL(ldi_ident_from_mod);
+
+void
+ldi_ident_release(ldi_ident_t lip)
+{
+ BUG_ON(lip == NULL);
+ kfree(lip);
+}
+EXPORT_SYMBOL(ldi_ident_release);
projects / spl / commitdiff