ad7888 linux driver

/* 

        ADCCONVERT.c : 

                Generate ADC signals from SPI ports, as the A/D control signals. 

 

        Author:  Aaron Fu 

        2008-10-14 

*/  

  

#include <linux/module.h>  

#include <linux/moduleparam.h>  

#include <linux/init.h>  

  

#include <linux/kernel.h>   

#include <linux/slab.h>       /* kmalloc */  

#include <linux/fs.h>     /* struect file inode */  

#include <linux/errno.h>  /* error codes */  

#include <linux/types.h>  /* size_t */  

#include <linux/proc_fs.h>    /* proc_fs */  

#include <linux/fcntl.h>  /* O_ACCMODE */  

#include <linux/seq_file.h> /* seq_file */  

#include <linux/cdev.h>       /* register char device */  

  

#include <asm/system.h>       /* cli(), *_flags */  

#include <asm/uaccess.h>  /* copy_*_user */  

#include <asm/delay.h>        /* udelay */  

#include <asm/io.h>           /* ioremap...*/  

  

#include "adconvert.h"      /* local definitions */  

  

int adc_major   = ADC_MAJOR;  

int adc_minor   = 0;  

int adc_nr_devs = ADC_NR_DEVS;  

  

static int      adcopen;  

struct cdev     *adc_cdev;  

  

module_param( adc_major, int, S_IRUGO );  

module_param( adc_minor, int, S_IRUGO );  

module_param( adc_nr_devs, int, S_IRUGO );  

  

MODULE_LICENSE( "Aaron Fu" );  

MODULE_DESCRIPTION( "Iconic Shanghai Co.,LTD." );  

MODULE_AUTHOR( "GPL" );  

  

void adc_address_map(void){  

    r_SPSTA0    =   ioremap( rSPSTA0, 0x00000004 );  

      

    r_SPPRE0    =   ioremap( rSPPRE0, 0x00000004 );         // rSPPRE0  

    r_SPCON0    =   ioremap( rSPCON0, 0x00000004 );         // rSPCON0  

    r_SPTDAT0   =   ioremap( rSPTDAT0, 0x00000004 );        // rSPTDAT0  

    r_SPRDAT0   =   ioremap( rSPRDAT0, 0x00000004 );  

      

    r_GPECON    =   ioremap( rGPECON, 0x00000004 );     //rGPECON  

    r_GPEUP     =   ioremap( rGPEUP, 0x00000004 );          // rGPEUP  

      

    r_GPHCON    =   ioremap( rGPHCON, 0x00000004 );     // rGPHCON  

    r_GPHUP     =   ioremap( rGPHUP, 0x00000004 );          // rGPHUP  

    r_GPHDAT    =   ioremap( rGPHDAT, 0x00000004 );     //rGPHDAT  

}  

  

void adc_cancel_add_map( void ){  

    iounmap( r_SPSTA0 );  

    iounmap( r_SPPRE0 );  

    iounmap( r_SPCON0 );  

    iounmap( r_SPTDAT0 );  

    iounmap( r_SPRDAT0 );  

    iounmap( r_GPECON );  

    iounmap( r_GPEUP );  

    iounmap( r_GPHCON );  

    iounmap( r_GPHUP );  

    iounmap( r_GPHDAT );  

}  

  

static void adc_spi_init( void ){  

    int i;  

      

    /* 

    rSPPRE0 = 0x32; 

    rSPCON0 = 0x1e; 

    for( i = 0; i < 10; i++ ) 

        rSPTDAT0 = 0xff;     

    

    rGPECON |= 0x0a800000; 

    rGPECON &= ( ~0x05400000 ); 

    rGPEUP |= 0x3800; 

    //GPH5----->CS 

    rGPHCON |= 0x0400; 

    rGPHCON &= ( ~0x0800 ); 

    rGPHUP &= ( ~0x20 ); 

    rGPHDAT |= 0x20;*/  

      

    iowrite32( ioread32( r_SPSTA0 ) | 0x01, r_SPSTA0 );  

      

    iowrite32( 0x4, r_SPPRE0 );  

    iowrite32( 0x1e, r_SPCON0 );  

     

    for( i = 0; i < 10; i++ ){  

        iowrite32( 0xff, r_SPTDAT0 );  

    }  

  

    //for( i = 0; i < 10; i++ ){  

        iowrite32( 0x00, r_SPRDAT0 );  

    //}  

     

    iowrite32( ioread32( r_GPECON ) | 0x0a800000, r_GPECON );  

    iowrite32( ioread32( r_GPECON ) & ( ~0x05400000 ), r_GPECON );  

    iowrite32( ioread32( r_GPEUP ) | 0x3800, r_GPEUP );  

      

    iowrite32( ioread32( r_GPHCON ) | 0x0400, r_GPHCON );  

    iowrite32( ioread32( r_GPHCON ) & ( ~0x0800 ), r_GPHCON );  

    iowrite32( ioread32( r_GPHUP ) & ( ~0x20 ), r_GPHUP );  

    iowrite32( ioread32( r_GPHDAT ) | ( 0x20 ), r_GPHDAT );  

}  

      

static struct file_operations adc_fops = {        /* driver info  */  

    .owner      =       THIS_MODULE,  

    .open       =       adc_open,  

    .read       =       adc_read,  

    .write      =       adc_write,  

    .release    =       adc_release,  

};  

  

  

static ssize_t adc_write( struct file *file, const char __user *buf, size_t count, loff_t *offset ){  

    int ret = 0;  

    int i = 0;  

      

    printk( "write count value = %d\n", count );  

    dbuf = kmalloc( count * sizeof( unsigned char ), GFP_KERNEL);  

    if ( dbuf == NULL ){  

        printk( KERN_WARNING "write: dbuf alloc memory fail\n" );  

        return -1;  

    }  

    memset( dbuf, 0, count *sizeof( unsigned char ) );  

  

    copy_from_user( dbuf, buf, count );  

    printk( "**************  write bufx = %x  *******************\n", buf );      

    printk( "*************   write bufs = %s  *******************\n", buf );  

    for( i = 0; i < count; i++ ){  

        ADCTxdata[i] = dbuf[i];  

        printk( "write adctx value [%d] = %c\n", i, ADCTxdata[i] );  

    }  

      

    kfree( dbuf );  

  

    return ret;  

}  

    

static ssize_t adc_read( struct file *file, char __user *buf, size_t count, loff_t *offset ){  

    int i = 0;  

    int ret = 0;  

      

    iowrite32( ioread32( r_SPCON0 ) | 0x1, r_SPCON0 );  

    adc_convert();  

    adc_convert();  

    printk( "\n\n" );  

    printk( "read count value = %d\n", count );  

      

    dbuf = kmalloc( count * sizeof( unsigned char ), GFP_KERNEL );  

    if ( dbuf == NULL ){  

        printk( KERN_WARNING "read: dbuf alloc memory fail\n" );  

        return -1;  

    }  

    memset( dbuf, 0, count * sizeof( unsigned char ) );  

      

    for( i = 0; i < count; i++ ){  

        dbuf[i] = ADCRxdata[i];  

        printk( "read adctx value [%d] = %c\n", i, ADCTxdata[i] );  

    }  

    printk( "\n" );  

      

    copy_to_user( buf, dbuf, count);  

    printk( "**************  read bufx = %x  ************************\n", buf );  

    printk( "**************  read bufs = %s  ************************\n", buf );  

    kfree( dbuf );  

  

    return ret;  

}  

  

void adc_convert( void ){  

    /*rGPHDAT &= ( ~0x20 ); 

    adc_tx_data( ADCTxdata[0] ); 

    // ADCRXdata[0] = rSPRDATO; 

    ADCRxdata[0] = r_SPRDAT0; 

    adc_tx_data( 0xff ); 

    // ADCRXdata[1] = rSPRDATO; 

    ADCRxdata[1] = r_SPRDAT0; 

    rGPHDAT |= 0x20;*/  

      

    iowrite32( ioread32( r_GPHDAT ) & ( 0x20 ), r_GPHDAT );  

      

    adc_tx_data( ADCTxdata[0] );  

    ADCRxdata[0] = r_SPRDAT0;  

    adc_tx_data( 0xff );  

    ADCRxdata[1] = r_SPRDAT0;  

    iowrite32( ioread32( r_GPHDAT ) | ( 0x20 ), r_GPHDAT );  

}  

  

static void adc_tx_data( unsigned char data ){  

    iowrite32( ioread32( r_SPSTA0 ) | 0x01, r_SPSTA0 );  

    spi_poll_done();  

    //rSPTDAT0 = data;  

    iowrite32( data, r_SPTDAT0 );  

    spi_poll_done();  

}  

  

void spi_poll_done( void ){  

    //while ( !( rSPSTA0 & 0x01 ) )  

    while ( !( ioread32( r_SPSTA0 ) & 0x01 ) )  

        ;  

}  

  

int adc_release( struct inode *inode, struct file *filp ){  

    adcopen--;  

    module_put( THIS_MODULE );  

      

    return 0 ;  

}  

  

int adc_init_module( void ){  

    int     result;  

    dev_t   dev = 0;  

      

    if ( adc_major ){  

        dev = MKDEV( adc_major, adc_minor );  

        result = register_chrdev_region( dev, adc_nr_devs, "adc" );  

    }else{  

        result = alloc_chrdev_region( &dev, adc_minor, adc_nr_devs, "adc" );  

        adc_major = MAJOR( dev );  

    }  

      

    adc_cdev = cdev_alloc();  

    if ( adc_cdev == NULL ){  

        return -1;  

    }  

      

    if ( result < 0 ){  

        printk( KERN_WARNING "adc: can't get major %d\n", adc_major );  

        return result;  

    }  

    printk( KERN_INFO "adc: this major is %d\n", adc_major );  

      

    adcopen = 0;  

    adc_cdev->ops = &adc_fops;  

    cdev_init( adc_cdev, &adc_fops );  

    cdev_add( adc_cdev, dev, 1 );  

  

    adc_address_map();  

    adc_spi_init();  

  

    printk( KERN_INFO "***    adc_init() finished    *** \n" );  

  

    return 0;  

}  

  

static int adc_open( struct inode *inode, struct file *filp ){  

    if ( adcopen == 0 )  

        adcopen++;  

    else{  

        printk( KERN_ALERT "Another process open the char device\n" );  

        return -1;  

    }  

      

    try_module_get( THIS_MODULE );  

      

    return 0;  

}  

  

void adc_cleanup_module( void ){  

    dev_t   devno;  

      

    adc_cancel_add_map();  

      

    devno = MKDEV( adc_major, adc_minor );  

    unregister_chrdev_region( devno, adc_nr_devs );  

    cdev_del( adc_cdev );  

}  

  

module_init( adc_init_module );  

module_exit( adc_cleanup_module );