source: trunk/target/linux/octeon/patches-2.6.30/016-octeon_hw_rng.patch @ 19513

Last change on this file since 19513 was 19513, checked in by florian, 6 years ago

[octeon] move generic config and patches directory to be 2.6.30 specific

File size: 10.0 KB
  • arch/mips/cavium-octeon/setup.c

    From: David Daney <ddaney@caviumnetworks.com>
    Date: Thu, 20 Aug 2009 21:10:22 +0000 (-0700)
    Subject: MIPS: Octeon:  Add hardware RNG platform device.
    X-Git-Tag: linux-2.6.32-rc1~34
    X-Git-Url: http://www.linux-mips.org/git?p=linux.git;a=commitdiff_plain;h=c691b963;hp=a68577bc6ce2b5e422cdb7a993b1c07cc410e02a
    
    MIPS: Octeon:  Add hardware RNG platform device.
    
    Add a platform device for the Octeon Random Number Generator (RNG).
    
    Signed-off-by: David Daney <ddaney@caviumnetworks.com>
    Acked-by: Herbert Xu <herbert@gondor.apana.org.au>
    Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
    ---
    
    old new  
    3232#include <asm/time.h> 
    3333 
    3434#include <asm/octeon/octeon.h> 
     35#include <asm/octeon/cvmx-rnm-defs.h> 
    3536 
    3637#ifdef CONFIG_CAVIUM_DECODE_RSL 
    3738extern void cvmx_interrupt_rsl_decode(void); 
     
    925926        return ret; 
    926927} 
    927928device_initcall(octeon_cf_device_init); 
     929 
     930/* Octeon Random Number Generator.  */ 
     931static int __init octeon_rng_device_init(void) 
     932{ 
     933        struct platform_device *pd; 
     934        int ret = 0; 
     935 
     936        struct resource rng_resources[] = { 
     937                { 
     938                        .flags  = IORESOURCE_MEM, 
     939                        .start  = XKPHYS_TO_PHYS(CVMX_RNM_CTL_STATUS), 
     940                        .end    = XKPHYS_TO_PHYS(CVMX_RNM_CTL_STATUS) + 0xf 
     941                }, { 
     942                        .flags  = IORESOURCE_MEM, 
     943                        .start  = cvmx_build_io_address(8, 0), 
     944                        .end    = cvmx_build_io_address(8, 0) + 0x7 
     945                } 
     946        }; 
     947 
     948        pd = platform_device_alloc("octeon_rng", -1); 
     949        if (!pd) { 
     950                ret = -ENOMEM; 
     951                goto out; 
     952        } 
     953 
     954        ret = platform_device_add_resources(pd, rng_resources, 
     955                                            ARRAY_SIZE(rng_resources)); 
     956        if (ret) 
     957                goto fail; 
     958 
     959        ret = platform_device_add(pd); 
     960        if (ret) 
     961                goto fail; 
     962 
     963        return ret; 
     964fail: 
     965        platform_device_put(pd); 
     966 
     967out: 
     968        return ret; 
     969} 
     970device_initcall(octeon_rng_device_init); 
  • new file linux-2.6.30.8/arch/mips/include/asm/octeon/cvmx-rnm-defs.h

    - +  
     1/***********************license start*************** 
     2 * Author: Cavium Networks 
     3 * 
     4 * Contact: support@caviumnetworks.com 
     5 * This file is part of the OCTEON SDK 
     6 * 
     7 * Copyright (c) 2003-2008 Cavium Networks 
     8 * 
     9 * This file is free software; you can redistribute it and/or modify 
     10 * it under the terms of the GNU General Public License, Version 2, as 
     11 * published by the Free Software Foundation. 
     12 * 
     13 * This file is distributed in the hope that it will be useful, but 
     14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 
     15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 
     16 * NONINFRINGEMENT.  See the GNU General Public License for more 
     17 * details. 
     18 * 
     19 * You should have received a copy of the GNU General Public License 
     20 * along with this file; if not, write to the Free Software 
     21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 
     22 * or visit http://www.gnu.org/licenses/. 
     23 * 
     24 * This file may also be available under a different license from Cavium. 
     25 * Contact Cavium Networks for more information 
     26 ***********************license end**************************************/ 
     27 
     28#ifndef __CVMX_RNM_DEFS_H__ 
     29#define __CVMX_RNM_DEFS_H__ 
     30 
     31#include <linux/types.h> 
     32 
     33#define CVMX_RNM_BIST_STATUS \ 
     34         CVMX_ADD_IO_SEG(0x0001180040000008ull) 
     35#define CVMX_RNM_CTL_STATUS \ 
     36         CVMX_ADD_IO_SEG(0x0001180040000000ull) 
     37 
     38union cvmx_rnm_bist_status { 
     39        uint64_t u64; 
     40        struct cvmx_rnm_bist_status_s { 
     41                uint64_t reserved_2_63:62; 
     42                uint64_t rrc:1; 
     43                uint64_t mem:1; 
     44        } s; 
     45        struct cvmx_rnm_bist_status_s cn30xx; 
     46        struct cvmx_rnm_bist_status_s cn31xx; 
     47        struct cvmx_rnm_bist_status_s cn38xx; 
     48        struct cvmx_rnm_bist_status_s cn38xxp2; 
     49        struct cvmx_rnm_bist_status_s cn50xx; 
     50        struct cvmx_rnm_bist_status_s cn52xx; 
     51        struct cvmx_rnm_bist_status_s cn52xxp1; 
     52        struct cvmx_rnm_bist_status_s cn56xx; 
     53        struct cvmx_rnm_bist_status_s cn56xxp1; 
     54        struct cvmx_rnm_bist_status_s cn58xx; 
     55        struct cvmx_rnm_bist_status_s cn58xxp1; 
     56}; 
     57 
     58union cvmx_rnm_ctl_status { 
     59        uint64_t u64; 
     60        struct cvmx_rnm_ctl_status_s { 
     61                uint64_t reserved_9_63:55; 
     62                uint64_t ent_sel:4; 
     63                uint64_t exp_ent:1; 
     64                uint64_t rng_rst:1; 
     65                uint64_t rnm_rst:1; 
     66                uint64_t rng_en:1; 
     67                uint64_t ent_en:1; 
     68        } s; 
     69        struct cvmx_rnm_ctl_status_cn30xx { 
     70                uint64_t reserved_4_63:60; 
     71                uint64_t rng_rst:1; 
     72                uint64_t rnm_rst:1; 
     73                uint64_t rng_en:1; 
     74                uint64_t ent_en:1; 
     75        } cn30xx; 
     76        struct cvmx_rnm_ctl_status_cn30xx cn31xx; 
     77        struct cvmx_rnm_ctl_status_cn30xx cn38xx; 
     78        struct cvmx_rnm_ctl_status_cn30xx cn38xxp2; 
     79        struct cvmx_rnm_ctl_status_s cn50xx; 
     80        struct cvmx_rnm_ctl_status_s cn52xx; 
     81        struct cvmx_rnm_ctl_status_s cn52xxp1; 
     82        struct cvmx_rnm_ctl_status_s cn56xx; 
     83        struct cvmx_rnm_ctl_status_s cn56xxp1; 
     84        struct cvmx_rnm_ctl_status_s cn58xx; 
     85        struct cvmx_rnm_ctl_status_s cn58xxp1; 
     86}; 
     87 
     88#endif 
  • drivers/char/hw_random/Kconfig

    old new  
    126126 
    127127          If unsure, say Y. 
    128128 
     129config HW_RANDOM_OCTEON 
     130        tristate "Octeon Random Number Generator support" 
     131        depends on HW_RANDOM && CPU_CAVIUM_OCTEON 
     132        default HW_RANDOM 
     133        ---help--- 
     134          This driver provides kernel-side support for the Random Number 
     135          Generator hardware found on Octeon processors. 
     136 
     137          To compile this driver as a module, choose M here: the 
     138          module will be called octeon-rng. 
     139 
     140          If unsure, say Y. 
     141 
    129142config HW_RANDOM_PASEMI 
    130143        tristate "PA Semi HW Random Number Generator support" 
    131144        depends on HW_RANDOM && PPC_PASEMI 
  • drivers/char/hw_random/Makefile

    old new  
    1515obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o 
    1616obj-$(CONFIG_HW_RANDOM_PASEMI) += pasemi-rng.o 
    1717obj-$(CONFIG_HW_RANDOM_VIRTIO) += virtio-rng.o 
     18obj-$(CONFIG_HW_RANDOM_OCTEON) += octeon-rng.o 
  • new file linux-2.6.30.8/drivers/char/hw_random/octeon-rng.c

    - +  
     1/* 
     2 * Hardware Random Number Generator support for Cavium Networks 
     3 * Octeon processor family. 
     4 * 
     5 * This file is subject to the terms and conditions of the GNU General Public 
     6 * License.  See the file "COPYING" in the main directory of this archive 
     7 * for more details. 
     8 * 
     9 * Copyright (C) 2009 Cavium Networks 
     10 */ 
     11 
     12#include <linux/module.h> 
     13#include <linux/init.h> 
     14#include <linux/platform_device.h> 
     15#include <linux/device.h> 
     16#include <linux/hw_random.h> 
     17#include <linux/io.h> 
     18 
     19#include <asm/octeon/octeon.h> 
     20#include <asm/octeon/cvmx-rnm-defs.h> 
     21 
     22struct octeon_rng { 
     23        struct hwrng ops; 
     24        void __iomem *control_status; 
     25        void __iomem *result; 
     26}; 
     27 
     28static int octeon_rng_init(struct hwrng *rng) 
     29{ 
     30        union cvmx_rnm_ctl_status ctl; 
     31        struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); 
     32 
     33        ctl.u64 = 0; 
     34        ctl.s.ent_en = 1; /* Enable the entropy source.  */ 
     35        ctl.s.rng_en = 1; /* Enable the RNG hardware.  */ 
     36        cvmx_write_csr((u64)p->control_status, ctl.u64); 
     37        return 0; 
     38} 
     39 
     40static void octeon_rng_cleanup(struct hwrng *rng) 
     41{ 
     42        union cvmx_rnm_ctl_status ctl; 
     43        struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); 
     44 
     45        ctl.u64 = 0; 
     46        /* Disable everything.  */ 
     47        cvmx_write_csr((u64)p->control_status, ctl.u64); 
     48} 
     49 
     50static int octeon_rng_data_read(struct hwrng *rng, u32 *data) 
     51{ 
     52        struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); 
     53 
     54        *data = cvmx_read64_uint32((u64)p->result); 
     55        return sizeof(u32); 
     56} 
     57 
     58static int __devinit octeon_rng_probe(struct platform_device *pdev) 
     59{ 
     60        struct resource *res_ports; 
     61        struct resource *res_result; 
     62        struct octeon_rng *rng; 
     63        int ret; 
     64        struct hwrng ops = { 
     65                .name = "octeon", 
     66                .init = octeon_rng_init, 
     67                .cleanup = octeon_rng_cleanup, 
     68                .data_read = octeon_rng_data_read 
     69        }; 
     70 
     71        rng = devm_kzalloc(&pdev->dev, sizeof(*rng), GFP_KERNEL); 
     72        if (!rng) 
     73                return -ENOMEM; 
     74 
     75        res_ports = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     76        if (!res_ports) 
     77                goto err_ports; 
     78 
     79        res_result = platform_get_resource(pdev, IORESOURCE_MEM, 1); 
     80        if (!res_result) 
     81                goto err_ports; 
     82 
     83 
     84        rng->control_status = devm_ioremap_nocache(&pdev->dev, 
     85                                                   res_ports->start, 
     86                                                   sizeof(u64)); 
     87        if (!rng->control_status) 
     88                goto err_ports; 
     89 
     90        rng->result = devm_ioremap_nocache(&pdev->dev, 
     91                                           res_result->start, 
     92                                           sizeof(u64)); 
     93        if (!rng->result) 
     94                goto err_r; 
     95 
     96        rng->ops = ops; 
     97 
     98        dev_set_drvdata(&pdev->dev, &rng->ops); 
     99        ret = hwrng_register(&rng->ops); 
     100        if (ret) 
     101                goto err; 
     102 
     103        dev_info(&pdev->dev, "Octeon Random Number Generator\n"); 
     104 
     105        return 0; 
     106err: 
     107        devm_iounmap(&pdev->dev, rng->control_status); 
     108err_r: 
     109        devm_iounmap(&pdev->dev, rng->result); 
     110err_ports: 
     111        devm_kfree(&pdev->dev, rng); 
     112        return -ENOENT; 
     113} 
     114 
     115static int __exit octeon_rng_remove(struct platform_device *pdev) 
     116{ 
     117        struct hwrng *rng = dev_get_drvdata(&pdev->dev); 
     118 
     119        hwrng_unregister(rng); 
     120 
     121        return 0; 
     122} 
     123 
     124static struct platform_driver octeon_rng_driver = { 
     125        .driver = { 
     126                .name           = "octeon_rng", 
     127                .owner          = THIS_MODULE, 
     128        }, 
     129        .probe          = octeon_rng_probe, 
     130        .remove         = __exit_p(octeon_rng_remove), 
     131}; 
     132 
     133static int __init octeon_rng_mod_init(void) 
     134{ 
     135        return platform_driver_register(&octeon_rng_driver); 
     136} 
     137 
     138static void __exit octeon_rng_mod_exit(void) 
     139{ 
     140        platform_driver_unregister(&octeon_rng_driver); 
     141} 
     142 
     143module_init(octeon_rng_mod_init); 
     144module_exit(octeon_rng_mod_exit); 
     145 
     146MODULE_AUTHOR("David Daney"); 
     147MODULE_LICENSE("GPL"); 
Note: See TracBrowser for help on using the repository browser.