Subversion Repositories or1k

/*

        Hardware driver for the AMD 768/8111 Random Number Generator (RNG)

        (c) Copyright 2001 Red Hat Inc <alan@redhat.com>

        (c) Copyright 2002,2003 Andi Kleen, SuSE Labs

        derived from

        Hardware driver for Intel i810 Random Number Generator (RNG)

        Copyright 2000,2001 Jeff Garzik <jgarzik@pobox.com>

        Copyright 2000,2001 Philipp Rumpf <prumpf@mandrakesoft.com>

        Please read Documentation/i810_rng.txt for details on use.

        ----------------------------------------------------------

        This software may be used and distributed according to the terms

        of the GNU General Public License, incorporated herein by reference.

 */

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/pci.h>

#include <linux/interrupt.h>

#include <linux/spinlock.h>

#include <linux/random.h>

#include <linux/miscdevice.h>

#include <linux/smp_lock.h>

#include <linux/mm.h>

#include <linux/delay.h>

#include <asm/io.h>

#include <asm/uaccess.h>

/*

 * core module and version information

 */

#define RNG_VERSION "0.1.0"

#define RNG_MODULE_NAME "amd768_rng"

#define RNG_DRIVER_NAME   RNG_MODULE_NAME " hardware driver " RNG_VERSION

#define PFX RNG_MODULE_NAME ": "

/*

 * debugging macros

 */

#undef RNG_DEBUG /* define to enable copious debugging info */

#ifdef RNG_DEBUG

/* note: prints function name for you */

#define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)

#else

#define DPRINTK(fmt, args...)

#endif

#undef RNG_NDEBUG        /* define to disable lightweight runtime checks */

#ifdef RNG_NDEBUG

#define assert(expr)

#else

#define assert(expr) \

        if(!(expr)) {                                   \

        printk( "Assertion failed! %s,%s,%s,line=%d\n", \

        #expr,__FILE__,__FUNCTION__,__LINE__);          \

        }

#endif

#define RNG_MISCDEV_MINOR               183 /* official */

/*

 * various RNG status variables.  they are globals

 * as we only support a single RNG device

 */

static u32 pmbase;                      /* PMxx I/O base */

static struct semaphore rng_open_sem;   /* Semaphore for serializing rng_open/release */

/*

 * inlined helper functions for accessing RNG registers

 */

static inline int rng_data_present (void)

{

        return inl(pmbase+0xF4) & 1;

}

static inline int rng_data_read (void)

{

        return inl(pmbase+0xF0);

}

static int rng_dev_open (struct inode *inode, struct file *filp)

{

        if ((filp->f_mode & FMODE_READ) == 0)

                return -EINVAL;

        if (filp->f_mode & FMODE_WRITE)

                return -EINVAL;

        /* wait for device to become free */

        if (filp->f_flags & O_NONBLOCK) {

                if (down_trylock (&rng_open_sem))

                        return -EAGAIN;

        } else {

                if (down_interruptible (&rng_open_sem))

                        return -ERESTARTSYS;

        }

        return 0;

}

static int rng_dev_release (struct inode *inode, struct file *filp)

{

        up(&rng_open_sem);

        return 0;

}

static ssize_t rng_dev_read (struct file *filp, char *buf, size_t size,

                             loff_t * offp)

{

        static spinlock_t rng_lock = SPIN_LOCK_UNLOCKED;

        int have_data;

        u32 data = 0;

        ssize_t ret = 0;

        while (size) {

                spin_lock(&rng_lock);

                have_data = 0;

                if (rng_data_present()) {

                        data = rng_data_read();

                        have_data = 4;

                }

                spin_unlock (&rng_lock);

                while (have_data > 0) {

                        if (put_user((u8)data, buf++)) {

                                ret = ret ? : -EFAULT;

                                break;

                        }

                        size--;

                        ret++;

                        have_data--;

                        data>>=8;

                }

                if (filp->f_flags & O_NONBLOCK)

                        return ret ? : -EAGAIN;

                if(current->need_resched)

                {

                        current->state = TASK_INTERRUPTIBLE;

                        schedule_timeout(1);

                }

                else

                        udelay(200);    /* FIXME: We could poll for 250uS ?? */

                if (signal_pending (current))

                        return ret ? : -ERESTARTSYS;

        }

        return ret;

}

static struct file_operations rng_chrdev_ops = {

        owner:          THIS_MODULE,

        open:           rng_dev_open,

        release:        rng_dev_release,

        read:           rng_dev_read,

};

static struct miscdevice rng_miscdev = {

        RNG_MISCDEV_MINOR,

        RNG_MODULE_NAME,

        &rng_chrdev_ops,

};

/*

 * rng_init_one - look for and attempt to init a single RNG

 */

static int __init rng_init_one (struct pci_dev *dev)

{

        int rc;

        u8 rnen;

        DPRINTK ("ENTER\n");

        rc = misc_register (&rng_miscdev);

        if (rc) {

                printk (KERN_ERR PFX "cannot register misc device\n");

                DPRINTK ("EXIT, returning %d\n", rc);

                goto err_out;

        }

        pci_read_config_dword(dev, 0x58, &pmbase);

        pmbase&=0x0000FF00;

        if(pmbase == 0)

        {

                printk (KERN_ERR PFX "power management base not set\n");

                DPRINTK ("EXIT, returning %d\n", rc);

                goto err_out_free_miscdev;

        }

        pci_read_config_byte(dev, 0x40, &rnen);

        rnen|=(1<<7);   /* RNG on */

        pci_write_config_byte(dev, 0x40, rnen);

        pci_read_config_byte(dev, 0x41, &rnen);

        rnen|=(1<<7);   /* PMIO enable */

        pci_write_config_byte(dev, 0x41, rnen);

        printk(KERN_INFO PFX "AMD768 system management I/O registers at 0x%X.\n", pmbase);

        DPRINTK ("EXIT, returning 0\n");

        return 0;

err_out_free_miscdev:

        misc_deregister (&rng_miscdev);

err_out:

        return rc;

}

/*

 * Data for PCI driver interface

 *

 * This data only exists for exporting the supported

 * PCI ids via MODULE_DEVICE_TABLE.  We do not actually

 * register a pci_driver, because someone else might one day

 * want to register another driver on the same PCI id.

 */

static struct pci_device_id rng_pci_tbl[] __initdata = {

        { 0x1022, 0x7443, PCI_ANY_ID, PCI_ANY_ID, },

        { 0x1022, 0x746b, PCI_ANY_ID, PCI_ANY_ID, },

        { 0, },

};

MODULE_DEVICE_TABLE (pci, rng_pci_tbl);

MODULE_AUTHOR("Alan Cox, Jeff Garzik, Philipp Rumpf, Matt Sottek, Andi Kleen");

MODULE_DESCRIPTION("AMD 768/8111 Random Number Generator (RNG) driver");

MODULE_LICENSE("GPL");

/*

 * rng_init - initialize RNG module

 */

static int __init rng_init (void)

{

        int rc;

        struct pci_dev *pdev;

        DPRINTK ("ENTER\n");

        init_MUTEX (&rng_open_sem);

        pci_for_each_dev(pdev) {

                if (pci_match_device (rng_pci_tbl, pdev) != NULL)

                        goto match;

        }

        DPRINTK ("EXIT, returning -ENODEV\n");

        return -ENODEV;

match:

        rc = rng_init_one (pdev);

        if (rc)

                return rc;

        printk (KERN_INFO RNG_DRIVER_NAME " loaded\n");

        DPRINTK ("EXIT, returning 0\n");

        return 0;

}

/*

 * rng_init - shutdown RNG module

 */

static void __exit rng_cleanup (void)

{

        DPRINTK ("ENTER\n");

        misc_deregister (&rng_miscdev);

        DPRINTK ("EXIT\n");

}

module_init (rng_init);

module_exit (rng_cleanup);