正文

ad7888 linux driver

IP云
IP云V管理员/1 阅读
06/16
小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

  1. /*
  2. ADCCONVERT.c :
  3. Generate ADC signals from SPI ports, as the A/D control signals.
  4. Author:  Aaron Fu
  5. 2008-10-14
  6. */
  7. #include <linux/module.h>
  8. #include <linux/moduleparam.h>
  9. #include <linux/init.h>
  10. #include <linux/kernel.h>
  11. #include <linux/slab.h>       /* kmalloc */
  12. #include <linux/fs.h>     /* struect file inode */
  13. #include <linux/errno.h>  /* error codes */
  14. #include <linux/types.h>  /* size_t */
  15. #include <linux/proc_fs.h>    /* proc_fs */
  16. #include <linux/fcntl.h>  /* O_ACCMODE */
  17. #include <linux/seq_file.h> /* seq_file */
  18. #include <linux/cdev.h>       /* register char device */
  19. #include <asm/system.h>       /* cli(), *_flags */
  20. #include <asm/uaccess.h>  /* copy_*_user */
  21. #include <asm/delay.h>        /* udelay */
  22. #include <asm/io.h>           /* ioremap...*/
  23. #include "adconvert.h"      /* local definitions */
  24. int adc_major   = ADC_MAJOR;
  25. int adc_minor   = 0;
  26. int adc_nr_devs = ADC_NR_DEVS;
  27. static int      adcopen;
  28. struct cdev     *adc_cdev;
  29. module_param( adc_major, int, S_IRUGO );
  30. module_param( adc_minor, int, S_IRUGO );
  31. module_param( adc_nr_devs, int, S_IRUGO );
  32. MODULE_LICENSE( "Aaron Fu" );
  33. MODULE_DESCRIPTION( "Iconic Shanghai Co.,LTD." );
  34. MODULE_AUTHOR( "GPL" );
  35. void adc_address_map(void){
  36. r_SPSTA0    =   ioremap( rSPSTA0, 0x00000004 );
  37. r_SPPRE0    =   ioremap( rSPPRE0, 0x00000004 );         // rSPPRE0
  38. r_SPCON0    =   ioremap( rSPCON0, 0x00000004 );         // rSPCON0
  39. r_SPTDAT0   =   ioremap( rSPTDAT0, 0x00000004 );        // rSPTDAT0
  40. r_SPRDAT0   =   ioremap( rSPRDAT0, 0x00000004 );
  41. r_GPECON    =   ioremap( rGPECON, 0x00000004 );     //rGPECON
  42. r_GPEUP     =   ioremap( rGPEUP, 0x00000004 );          // rGPEUP
  43. r_GPHCON    =   ioremap( rGPHCON, 0x00000004 );     // rGPHCON
  44. r_GPHUP     =   ioremap( rGPHUP, 0x00000004 );          // rGPHUP
  45. r_GPHDAT    =   ioremap( rGPHDAT, 0x00000004 );     //rGPHDAT
  46. }
  47. void adc_cancel_add_map( void ){
  48. iounmap( r_SPSTA0 );
  49. iounmap( r_SPPRE0 );
  50. iounmap( r_SPCON0 );
  51. iounmap( r_SPTDAT0 );
  52. iounmap( r_SPRDAT0 );
  53. iounmap( r_GPECON );
  54. iounmap( r_GPEUP );
  55. iounmap( r_GPHCON );
  56. iounmap( r_GPHUP );
  57. iounmap( r_GPHDAT );
  58. }
  59. static void adc_spi_init( void ){
  60. int i;
  61. /*
  62. rSPPRE0 = 0x32;
  63. rSPCON0 = 0x1e;
  64. for( i = 0; i < 10; i++ )
  65. rSPTDAT0 = 0xff;
  66. rGPECON |= 0x0a800000;
  67. rGPECON &= ( ~0x05400000 );
  68. rGPEUP |= 0x3800;
  69. //GPH5----->CS
  70. rGPHCON |= 0x0400;
  71. rGPHCON &= ( ~0x0800 );
  72. rGPHUP &= ( ~0x20 );
  73. rGPHDAT |= 0x20;*/
  74. iowrite32( ioread32( r_SPSTA0 ) | 0x01, r_SPSTA0 );
  75. iowrite32( 0x4, r_SPPRE0 );
  76. iowrite32( 0x1e, r_SPCON0 );
  77. for( i = 0; i < 10; i++ ){
  78. iowrite32( 0xff, r_SPTDAT0 );
  79. }
  80. //for( i = 0; i < 10; i++ ){
  81. iowrite32( 0x00, r_SPRDAT0 );
  82. //}
  83. iowrite32( ioread32( r_GPECON ) | 0x0a800000, r_GPECON );
  84. iowrite32( ioread32( r_GPECON ) & ( ~0x05400000 ), r_GPECON );
  85. iowrite32( ioread32( r_GPEUP ) | 0x3800, r_GPEUP );
  86. iowrite32( ioread32( r_GPHCON ) | 0x0400, r_GPHCON );
  87. iowrite32( ioread32( r_GPHCON ) & ( ~0x0800 ), r_GPHCON );
  88. iowrite32( ioread32( r_GPHUP ) & ( ~0x20 ), r_GPHUP );
  89. iowrite32( ioread32( r_GPHDAT ) | ( 0x20 ), r_GPHDAT );
  90. }
  91. static struct file_operations adc_fops = {        /* driver info  */
  92. .owner      =       THIS_MODULE,
  93. .open       =       adc_open,
  94. .read       =       adc_read,
  95. .write      =       adc_write,
  96. .release    =       adc_release,
  97. };
  98. static ssize_t adc_write( struct file *file, const char __user *buf, size_t count, loff_t *offset ){
  99. int ret = 0;
  100. int i = 0;
  101. printk( "write count value = %d\n", count );
  102. dbuf = kmalloc( count * sizeof( unsigned char ), GFP_KERNEL);
  103. if ( dbuf == NULL ){
  104. printk( KERN_WARNING "write: dbuf alloc memory fail\n" );
  105. return -1;
  106. }
  107. memset( dbuf, 0, count *sizeof( unsigned char ) );
  108. copy_from_user( dbuf, buf, count );
  109. printk( "**************  write bufx = %x  *******************\n", buf );
  110. printk( "*************   write bufs = %s  *******************\n", buf );
  111. for( i = 0; i < count; i++ ){
  112. ADCTxdata[i] = dbuf[i];
  113. printk( "write adctx value [%d] = %c\n", i, ADCTxdata[i] );
  114. }
  115. kfree( dbuf );
  116. return ret;
  117. }
  118. static ssize_t adc_read( struct file *file, char __user *buf, size_t count, loff_t *offset ){
  119. int i = 0;
  120. int ret = 0;
  121. iowrite32( ioread32( r_SPCON0 ) | 0x1, r_SPCON0 );
  122. adc_convert();
  123. adc_convert();
  124. printk( "\n\n" );
  125. printk( "read count value = %d\n", count );
  126. dbuf = kmalloc( count * sizeof( unsigned char ), GFP_KERNEL );
  127. if ( dbuf == NULL ){
  128. printk( KERN_WARNING "read: dbuf alloc memory fail\n" );
  129. return -1;
  130. }
  131. memset( dbuf, 0, count * sizeof( unsigned char ) );
  132. for( i = 0; i < count; i++ ){
  133. dbuf[i] = ADCRxdata[i];
  134. printk( "read adctx value [%d] = %c\n", i, ADCTxdata[i] );
  135. }
  136. printk( "\n" );
  137. copy_to_user( buf, dbuf, count);
  138. printk( "**************  read bufx = %x  ************************\n", buf );
  139. printk( "**************  read bufs = %s  ************************\n", buf );
  140. kfree( dbuf );
  141. return ret;
  142. }
  143. void adc_convert( void ){
  144. /*rGPHDAT &= ( ~0x20 );
  145. adc_tx_data( ADCTxdata[0] );
  146. // ADCRXdata[0] = rSPRDATO;
  147. ADCRxdata[0] = r_SPRDAT0;
  148. adc_tx_data( 0xff );
  149. // ADCRXdata[1] = rSPRDATO;
  150. ADCRxdata[1] = r_SPRDAT0;
  151. rGPHDAT |= 0x20;*/
  152. iowrite32( ioread32( r_GPHDAT ) & ( 0x20 ), r_GPHDAT );
  153. adc_tx_data( ADCTxdata[0] );
  154. ADCRxdata[0] = r_SPRDAT0;
  155. adc_tx_data( 0xff );
  156. ADCRxdata[1] = r_SPRDAT0;
  157. iowrite32( ioread32( r_GPHDAT ) | ( 0x20 ), r_GPHDAT );
  158. }
  159. static void adc_tx_data( unsigned char data ){
  160. iowrite32( ioread32( r_SPSTA0 ) | 0x01, r_SPSTA0 );
  161. spi_poll_done();
  162. //rSPTDAT0 = data;
  163. iowrite32( data, r_SPTDAT0 );
  164. spi_poll_done();
  165. }
  166. void spi_poll_done( void ){
  167. //while ( !( rSPSTA0 & 0x01 ) )
  168. while ( !( ioread32( r_SPSTA0 ) & 0x01 ) )
  169. ;
  170. }
  171. int adc_release( struct inode *inode, struct file *filp ){
  172. adcopen--;
  173. module_put( THIS_MODULE );
  174. return 0 ;
  175. }
  176. int adc_init_module( void ){
  177. int     result;
  178. dev_t   dev = 0;
  179. if ( adc_major ){
  180. dev = MKDEV( adc_major, adc_minor );
  181. result = register_chrdev_region( dev, adc_nr_devs, "adc" );
  182. }else{
  183. result = alloc_chrdev_region( &dev, adc_minor, adc_nr_devs, "adc" );
  184. adc_major = MAJOR( dev );
  185. }
  186. adc_cdev = cdev_alloc();
  187. if ( adc_cdev == NULL ){
  188. return -1;
  189. }
  190. if ( result < 0 ){
  191. printk( KERN_WARNING "adc: can't get major %d\n", adc_major );
  192. return result;
  193. }
  194. printk( KERN_INFO "adc: this major is %d\n", adc_major );
  195. adcopen = 0;
  196. adc_cdev->ops = &adc_fops;
  197. cdev_init( adc_cdev, &adc_fops );
  198. cdev_add( adc_cdev, dev, 1 );
  199. adc_address_map();
  200. adc_spi_init();
  201. printk( KERN_INFO "***    adc_init() finished    *** \n" );
  202. return 0;
  203. }
  204. static int adc_open( struct inode *inode, struct file *filp ){
  205. if ( adcopen == 0 )
  206. adcopen++;
  207. else{
  208. printk( KERN_ALERT "Another process open the char device\n" );
  209. return -1;
  210. }
  211. try_module_get( THIS_MODULE );
  212. return 0;
  213. }
  214. void adc_cleanup_module( void ){
  215. dev_t   devno;
  216. adc_cancel_add_map();
  217. devno = MKDEV( adc_major, adc_minor );
  218. unregister_chrdev_region( devno, adc_nr_devs );
  219. cdev_del( adc_cdev );
  220. }
  221. module_init( adc_init_module );
  222. module_exit( adc_cleanup_module );