obt9700_relay

dingzerong

1. #include <linux/module.h>
   
2. #include <linux/fs.h>
   
3. #include <linux/delay.h>
   
4. #include <linux/interrupt.h>
   
5. #include <linux/cdev.h>
   
6. #include <linux/input.h>
   
7. 
   
8. #include <asm/uaccess.h>
   
9. #include <asm/arch/hardware.h>
   
10. #include <asm/io.h>
    
11. 
    
12. #include <asm/arch/w90x900_reg.h>
    
13. 
    
14. #define RELAY_MAJOR            (81)
    
15. #define DEV_NAME            "relay"
    
16. #define RELAY_DEVICE_NUMBER        MKDEV(RELAY_MAJOR, 0)
    
17. 
    
18. #define SPEAKER_CTRL            (0x00)
    
19. /* the speaker is on when arg is a non-zero value */
    
20. 
    
21. #define RELAY1_CTRL            (0x01)
    
22. /* the relay1 is on when arg is a non-zero value */
    
23. 
    
24. #define RELAY2_CTRL            (0x02)
    
25. /* the relay2 is on when arg is a non-zero value */
    
26. 
    
27. #define RELAY3_CTRL            (0x03)
    
28. /* the relay3 is on when arg is a non-zero value */
    
29. 
    
30. #define RELAY4_CTRL            (0x04)
    
31. /* the relay4 is on when arg is a non-zero value */
    
32. 
    
33. /*
    
34. hardware definitions.
    
35.     SPEAKER        <=>        GPIO E13
    
36.     RELAY1        <=>        GPIO E7
    
37.     RELAY2        <=>        GPIO E6
    
38.     RELAY3        <=>        GPIO D4
    
39.     RELAY4        <=>        GPIO D8
    
40. 
    
41.     ALARM_1        <=>        GPIO G2
    
42.     ALARM_2        <=>        GPIO G3
    
43. */
    
44. 
    
45. struct obt9700relay_dev_t
    
46. {
    
47.     struct cdev        cdev_;
    
48.     struct input_dev *    input;
    
49. 
    
50.     struct tasklet_struct    tasklet_alarm;
    
51.     unsigned char         alarmvalue;
    
52. } obt9700relay_dev;
    
53. 
    
54. static int obt9700_relay_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
    
55. {
    
56.     switch (cmd)
    
57.     {
    
58.         case SPEAKER_CTRL:
    
59.             if (arg)
    
60.             {
    
61.                 outl(inl(REG_GPIOE_DATAOUT) | (1 << 13), REG_GPIOE_DATAOUT); /*pull up SPEAKER (GPIO E13)*/
    
62.             }
    
63.             else
    
64.             {
    
65.                 outl(inl(REG_GPIOE_DATAOUT) & ~(1 << 13), REG_GPIOE_DATAOUT); /*pull down SPEAKER (GPIO E13)*/
    
66.             };
    
67.             return 0;
    
68.             break;
    
69. 
    
70.         case RELAY1_CTRL:
    
71.             if (arg)
    
72.             {
    
73.                 outl(inl(REG_GPIOE_DATAOUT) | (1 << 7), REG_GPIOE_DATAOUT); /*pull up RELAY1 (GPIO E7)*/
    
74.             }
    
75.             else
    
76.             {
    
77.                 outl(inl(REG_GPIOE_DATAOUT) & ~(1 << 7), REG_GPIOE_DATAOUT); /*pull down RELAY1 (GPIO E7)*/
    
78.             };
    
79.             return 0;
    
80.             break;
    
81. 
    
82.         case RELAY2_CTRL:
    
83.             if (arg)
    
84.             {
    
85.                 outl(inl(REG_GPIOE_DATAOUT) | (1 << 6), REG_GPIOE_DATAOUT); /*pull up RELAY2 (GPIO E6)*/
    
86.             }
    
87.             else
    
88.             {
    
89.                 outl(inl(REG_GPIOE_DATAOUT) & ~(1 << 6), REG_GPIOE_DATAOUT); /*pull down RELAY2 (GPIO E6)*/
    
90.             };
    
91.             return 0;
    
92.             break;
    
93. 
    
94.         case RELAY3_CTRL:
    
95.             if (arg)
    
96.             {
    
97.                 outl(inl(REG_GPIOD_DATAOUT) | (1 << 4), REG_GPIOD_DATAOUT); /*pull up RELAY3 (GPIO D4)*/
    
98.             }
    
99.             else
    
100.             {
     
101.                 outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 4), REG_GPIOD_DATAOUT); /*pull down RELAY3 (GPIO D4)*/
     
102.             };
     
103.             return 0;
     
104.             break;
     
105. 
     
106.         case RELAY4_CTRL:
     
107.             if (arg)
     
108.             {
     
109.                 outl(inl(REG_GPIOD_DATAOUT) | (1 << 8), REG_GPIOD_DATAOUT); /*pull up RELAY4 (GPIO D8)*/
     
110.             }
     
111.             else
     
112.             {
     
113.                 outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 8), REG_GPIOD_DATAOUT); /*pull down RELAY4 (GPIO D8)*/
     
114.             };
     
115.             return 0;
     
116.             break;
     
117.     };
     
118. 
     
119.     return -EINVAL;
     
120. }
     
121. 
     
122. struct file_operations obt9700_relay_fops =
     
123. {
     
124.     owner:      THIS_MODULE,
     
125.     ioctl:     obt9700_relay_ioctl,
     
126. };
     
127. 
     
128. static void alarm_tasklet(unsigned long arg)
     
129. {
     
130.     input_report_key(obt9700relay_dev.input, obt9700relay_dev.alarmvalue, 1);
     
131.     input_report_key(obt9700relay_dev.input, obt9700relay_dev.alarmvalue, 0);
     
132.     input_sync(obt9700relay_dev.input);
     
133. };
     
134. 
     
135. static irqreturn_t relay_irq(int irq, void *devid, struct pt_regs *regs)
     
136. {
     
137.     register long value_;
     
138.     register unsigned char key_;
     
139.     if (!(inl(REG_AIC_GASR) & (1 << 2)))
     
140.         return IRQ_NONE;
     
141.     
     
142.     value_ = inl(REG_GPIOG_DATAIN);
     
143.     key_ = 0;
     
144. 
     
145.     /* ALARM_1    <=>    GPIO G2 */
     
146.     if (value_ & (1 << 2)) key_ |= (1 << 0);
     
147. 
     
148.     /* ALARM_2    <=>    GPIO G3 */
     
149.     if (value_ & (1 << 3)) key_ |= (1 << 1);
     
150. 
     
151.     obt9700relay_dev.alarmvalue = key_;
     
152.     tasklet_schedule(&obt9700relay_dev.tasklet_alarm);
     
153. 
     
154.     outl(1, REG_AIC_GSCR); /* complete irq */
     
155.     outl(~0, REG_AIC_EOSCR); /* complete irq */
     
156. 
     
157.     return IRQ_HANDLED;
     
158. }
     
159. 
     
160. static int __init obt9700_relay_init(void)
     
161. {
     
162.     int ret;
     
163. 
     
164.     cdev_init(&obt9700relay_dev.cdev_, &obt9700_relay_fops);
     
165.     obt9700relay_dev.cdev_.owner = THIS_MODULE;
     
166. 
     
167.     if ((ret = register_chrdev_region(RELAY_DEVICE_NUMBER, 1, DEV_NAME)) < 0)
     
168.         return ret;
     
169. 
     
170.     if ((ret = cdev_add(&obt9700relay_dev.cdev_, RELAY_DEVICE_NUMBER, 1)) != 0)
     
171.         return ret;
     
172. 
     
173.     /* configure input_event */
     
174.     if (!(obt9700relay_dev.input = input_allocate_device()))
     
175.     {
     
176.         printk("Obt9700 relay: allocate memory failed!\n");
     
177.         return -ENOMEM;
     
178.     }
     
179.     
     
180.     obt9700relay_dev.input->name = "Obt9700Relay";
     
181.     obt9700relay_dev.input->phys = "input/event1";
     
182.     obt9700relay_dev.input->id.bustype = BUS_HOST;
     
183.     obt9700relay_dev.input->id.vendor = 0x0005;
     
184.     obt9700relay_dev.input->id.product = 0x0002;
     
185.     obt9700relay_dev.input->id.version = 0x0100;
     
186. 
     
187.     obt9700relay_dev.input->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_SYN);
     
188.         
     
189.     set_bit(0x01, obt9700relay_dev.input->keybit);
     
190.     set_bit(0x02, obt9700relay_dev.input->keybit);
     
191. 
     
192.     input_register_device(obt9700relay_dev.input);
     
193. 
     
194.     /* initialize the tasklet */
     
195.     tasklet_init(&obt9700relay_dev.tasklet_alarm, alarm_tasklet, 0);
     
196. 
     
197.     /* config the io pins(D4, D8) as output */
     
198.     outl(inl(REG_MFSEL) & ~0x00f0, REG_MFSEL);        /* configure GPIOD to IO function. */
     
199.     outl(inl(REG_GPIOD_DIR) | 0x0110, REG_GPIOD_DIR);    /* configure output pins. */
     
200.     outl(inl(REG_GPIODPE) | 0x0110, REG_GPIODPE);        /* configure pins as pullup. */
     
201. 
     
202.     /* config the io pins(E6, E7, E13) as output */
     
203.     outl(inl(REG_MFSEL) & ~0x3c00, REG_MFSEL);        /* configure GPIOE to IO function. */
     
204.     outl(inl(REG_GPIOE_DIR) | 0x20c0, REG_GPIOE_DIR);    /* configure output pins. */
     
205.     outl(inl(REG_GPIOEPE) | 0x20c0, REG_GPIOEPE);        /* configure pins as pullup. */
     
206. 
     
207.     /* config the io pins(G2 G3) as input */
     
208.     outl(inl(REG_MFSEL) & ~0x00030000, REG_MFSEL);        /* configure GPIOG to IO function. */
     
209.     outl(inl(REG_GPIOG_DIR) & ~0x000c, REG_GPIOG_DIR);    /* configure input pins. */
     
210. 
     
211.     /* configure the nIRQ[2] to fall, enable */
     
212.     outl(inl(REG_GPIOH_DIR) & ~(1 << 2), REG_GPIOH_DIR); /* configure GPIOH as input pin */
     
213. 
     
214.     outl(inl(REG_MFSEL) | (1 << 24), REG_MFSEL);    /* configure GPIOH to nIRQ[2:0] mode*/
     
215. 
     
216.     outl(((inl(REG_AIC_IRQSC) & (~0x30)) | (2)), REG_AIC_IRQSC); /* negative edge (fall pluse)*/
     
217. 
     
218.     outl(inl(REG_AIC_GEN) | (1 << 2), REG_AIC_GEN); /* enable nIRQ[2]*/
     
219. 
     
220.     /* request ext int0 down interrupt */
     
221.     ret = request_irq(IRQ_GROUP0, relay_irq, SA_SHIRQ | SA_INTERRUPT, DEV_NAME, &obt9700relay_dev);
     
222.     if (ret)
     
223.     {
     
224.         printk("Relay on obt9700 board driver: unable to grab Ext2 interrupt: %d\n", ret);
     
225.         goto fail;
     
226.     }
     
227. 
     
228.     printk("Relay on obt9700 board driver started successfully!\n");
     
229. 
     
230. fail:
     
231.     input_free_device(obt9700relay_dev.input);
     
232.     return(0);
     
233. }
     
234. 
     
235. static void __exit obt9700_relay_exit(void)
     
236. {
     
237.     free_irq(IRQ_GROUP0, &obt9700relay_dev);
     
238. 
     
239.     input_unregister_device(obt9700relay_dev.input);
     
240. 
     
241.     input_free_device(obt9700relay_dev.input);
     
242. 
     
243.     cdev_del(&obt9700relay_dev.cdev_);
     
244. 
     
245.     unregister_chrdev_region(RELAY_DEVICE_NUMBER, 1);
     
246. }
     
247. 
     
248. module_init(relay_init);
     
249. module_exit(relay_exit);
     
250. 
     
251. MODULE_AUTHOR("Adem");
     
252. MODULE_DESCRIPTION("Relay driver on board");
     
253. MODULE_LICENSE("GPL");