ad7888 linux driver

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 );