/*
 *  linux/fs/devices.c
 *
 * (C) 1993 Matthias Urlichs -- collected common code and tables.
 * 
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Added kerneld support: Jacques Gelinas and Bjorn Ekwall
 *  (changed to kmod)
 */

#include <linux/config.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/time.h>
#include <linux/stat.h>
#include <linux/fcntl.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/devfs_fs_kernel.h>
#ifdef CONFIG_KMOD
#include <linux/kmod.h>

#include <linux/tty.h>

/* serial module kmod load support */
struct tty_driver *get_tty_driver(kdev_t device);
#define isa_tty_dev(ma) (ma == TTY_MAJOR || ma == TTYAUX_MAJOR)
#define need_serial(ma,mi) (get_tty_driver(mk_kdev(ma,mi)) == NULL)
#endif

struct device_struct {
        const char * name;
        struct file_operations * fops;
};

static rwlock_t chrdevs_lock = RW_LOCK_UNLOCKED;
static struct device_struct chrdevs[MAX_CHRDEV];

extern int get_blkdev_list(char *);

int get_device_list(char * page)
{
        int i;
        int len;

        len = sprintf(page, "Character devices:\n");
        read_lock(&chrdevs_lock);
        for (i = 0; i < MAX_CHRDEV ; i++) {
                if (chrdevs[i].fops) {
                        len += sprintf(page+len, "%3d %s\n", i, chrdevs[i].name);
                }
        }
        read_unlock(&chrdevs_lock);
        len += get_blkdev_list(page+len);
        return len;
}

/*
        Return the function table of a device.
        Load the driver if needed.
        Increment the reference count of module in question.
*/
static struct file_operations * get_chrfops(unsigned int major, unsigned int minor)
{
        struct file_operations *ret = NULL;

        if (!major || major >= MAX_CHRDEV)
                return NULL;

        read_lock(&chrdevs_lock);
        ret = fops_get(chrdevs[major].fops);
        read_unlock(&chrdevs_lock);
#ifdef CONFIG_KMOD
        if (ret && isa_tty_dev(major)) {
                lock_kernel();
                if (need_serial(major,minor)) {
                        /* Force request_module anyway, but what for? */
                        fops_put(ret);
                        ret = NULL;
                }
                unlock_kernel();
        }
        if (!ret) {
                char name[20];
                sprintf(name, "char-major-%d", major);
                request_module(name);

                read_lock(&chrdevs_lock);
                ret = fops_get(chrdevs[major].fops);
                read_unlock(&chrdevs_lock);
        }
#endif
        return ret;
}

int register_chrdev(unsigned int major, const char * name, struct file_operations *fops)
{
        if (devfs_only())
                return 0;
        if (major == 0) {
                write_lock(&chrdevs_lock);
                for (major = MAX_CHRDEV-1; major > 0; major--) {
                        if (chrdevs[major].fops == NULL) {
                                chrdevs[major].name = name;
                                chrdevs[major].fops = fops;
                                write_unlock(&chrdevs_lock);
                                return major;
                        }
                }
                write_unlock(&chrdevs_lock);
                return -EBUSY;
        }
        if (major >= MAX_CHRDEV)
                return -EINVAL;
        write_lock(&chrdevs_lock);
        if (chrdevs[major].fops && chrdevs[major].fops != fops) {
                write_unlock(&chrdevs_lock);
                return -EBUSY;
        }
        chrdevs[major].name = name;
        chrdevs[major].fops = fops;
        write_unlock(&chrdevs_lock);
        return 0;
}

int unregister_chrdev(unsigned int major, const char * name)
{
        if (devfs_only())
                return 0;
        if (major >= MAX_CHRDEV)
                return -EINVAL;
        write_lock(&chrdevs_lock);
        if (!chrdevs[major].fops || strcmp(chrdevs[major].name, name)) {
                write_unlock(&chrdevs_lock);
                return -EINVAL;
        }
        chrdevs[major].name = NULL;
        chrdevs[major].fops = NULL;
        write_unlock(&chrdevs_lock);
        return 0;
}

/*
 * Called every time a character special file is opened
 */
int chrdev_open(struct inode * inode, struct file * filp)
{
        int ret = -ENODEV;

        filp->f_op = get_chrfops(major(inode->i_rdev), minor(inode->i_rdev));
        if (filp->f_op) {
                ret = 0;
                if (filp->f_op->open != NULL) {
                        lock_kernel();
                        ret = filp->f_op->open(inode,filp);
                        unlock_kernel();
                }
        }
        return ret;
}

/*
 * Dummy default file-operations: the only thing this does
 * is contain the open that then fills in the correct operations
 * depending on the special file...
 */
static struct file_operations def_chr_fops = {
        .open           = chrdev_open,
};

/*
 * Print device name (in decimal, hexadecimal or symbolic)
 * Note: returns pointer to static data!
 */
const char * kdevname(kdev_t dev)
{
        static char buffer[32];
        sprintf(buffer, "%02x:%02x", major(dev), minor(dev));
        return buffer;
}

const char * cdevname(kdev_t dev)
{
        static char buffer[32];
        const char * name = chrdevs[major(dev)].name;

        if (!name)
                name = "unknown-char";
        sprintf(buffer, "%s(%d,%d)", name, major(dev), minor(dev));
        return buffer;
}
  
static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
{
        return -ENXIO;
}

static struct file_operations bad_sock_fops = {
        .open           = sock_no_open
};

void init_special_inode(struct inode *inode, umode_t mode, int rdev)
{
        inode->i_mode = mode;
        if (S_ISCHR(mode)) {
                inode->i_fop = &def_chr_fops;
                inode->i_rdev = to_kdev_t(rdev);
                inode->i_cdev = cdget(rdev);
        } else if (S_ISBLK(mode)) {
                inode->i_fop = &def_blk_fops;
                inode->i_rdev = to_kdev_t(rdev);
        } else if (S_ISFIFO(mode))
                inode->i_fop = &def_fifo_fops;
        else if (S_ISSOCK(mode))
                inode->i_fop = &bad_sock_fops;
        else
                printk(KERN_DEBUG "init_special_inode: bogus imode (%o)\n", mode);
}