media: tegra: enable a clock for VIP in APB MISC register
[linux-2.6.git] / drivers / char / msm_smd_pkt.c
1 /* Copyright (c) 2008-2010, Code Aurora Forum. All rights reserved.
2  *
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 and
5  * only version 2 as published by the Free Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15  * 02110-1301, USA.
16  *
17  */
18 /*
19  * SMD Packet Driver -- Provides userspace interface to SMD packet ports.
20  */
21
22 #include <linux/slab.h>
23 #include <linux/cdev.h>
24 #include <linux/module.h>
25 #include <linux/fs.h>
26 #include <linux/device.h>
27 #include <linux/sched.h>
28 #include <linux/mutex.h>
29 #include <linux/delay.h>
30 #include <linux/uaccess.h>
31 #include <linux/workqueue.h>
32 #include <linux/poll.h>
33
34 #include <mach/msm_smd.h>
35
36 #define NUM_SMD_PKT_PORTS 9
37 #define DEVICE_NAME "smdpkt"
38 #define MAX_BUF_SIZE 2048
39
40 struct smd_pkt_dev {
41         struct cdev cdev;
42         struct device *devicep;
43
44         struct smd_channel *ch;
45         int open_count;
46         struct mutex ch_lock;
47         struct mutex rx_lock;
48         struct mutex tx_lock;
49         wait_queue_head_t ch_read_wait_queue;
50         wait_queue_head_t ch_opened_wait_queue;
51
52         int i;
53
54         unsigned char tx_buf[MAX_BUF_SIZE];
55         unsigned char rx_buf[MAX_BUF_SIZE];
56         int remote_open;
57
58 } *smd_pkt_devp[NUM_SMD_PKT_PORTS];
59
60 struct class *smd_pkt_classp;
61 static dev_t smd_pkt_number;
62
63 static int msm_smd_pkt_debug_enable;
64 module_param_named(debug_enable, msm_smd_pkt_debug_enable,
65                    int, S_IRUGO | S_IWUSR | S_IWGRP);
66
67 #ifdef DEBUG
68 #define D_DUMP_BUFFER(prestr, cnt, buf) do {                    \
69                 int i;                                          \
70                 if (msm_smd_pkt_debug_enable) {                 \
71                         pr_debug("%s", prestr);                 \
72                         for (i = 0; i < cnt; i++)               \
73                                 pr_debug("%.2x", buf[i]);       \
74                         pr_debug("\n");                         \
75                 }                                               \
76         } while (0)
77 #else
78 #define D_DUMP_BUFFER(prestr, cnt, buf) do {} while (0)
79 #endif
80
81 #ifdef DEBUG
82 #define DBG(x...) do {                  \
83         if (msm_smd_pkt_debug_enable)   \
84                 pr_debug(x);            \
85         } while (0)
86 #else
87 #define DBG(x...) do {} while (0)
88 #endif
89
90 static void check_and_wakeup_reader(struct smd_pkt_dev *smd_pkt_devp)
91 {
92         int sz;
93
94         if (!smd_pkt_devp || !smd_pkt_devp->ch)
95                 return;
96
97         sz = smd_cur_packet_size(smd_pkt_devp->ch);
98         if (sz == 0) {
99                 DBG("no packet\n");
100                 return;
101         }
102         if (sz > smd_read_avail(smd_pkt_devp->ch)) {
103                 DBG("incomplete packet\n");
104                 return;
105         }
106
107         DBG("waking up reader\n");
108         wake_up_interruptible(&smd_pkt_devp->ch_read_wait_queue);
109 }
110
111 static int smd_pkt_read(struct file *file, char __user *buf,
112                         size_t count, loff_t *ppos)
113 {
114         int r, bytes_read;
115         struct smd_pkt_dev *smd_pkt_devp;
116         struct smd_channel *chl;
117
118         DBG("read %d bytes\n", count);
119         if (count > MAX_BUF_SIZE)
120                 return -EINVAL;
121
122         smd_pkt_devp = file->private_data;
123         if (!smd_pkt_devp || !smd_pkt_devp->ch)
124                 return -EINVAL;
125
126         chl = smd_pkt_devp->ch;
127 wait_for_packet:
128         r = wait_event_interruptible(smd_pkt_devp->ch_read_wait_queue,
129                                      (smd_cur_packet_size(chl) > 0 &&
130                                       smd_read_avail(chl) >=
131                                       smd_cur_packet_size(chl)));
132
133         if (r < 0) {
134                 if (r != -ERESTARTSYS)
135                         pr_err("wait returned %d\n", r);
136                 return r;
137         }
138
139         mutex_lock(&smd_pkt_devp->rx_lock);
140
141         bytes_read = smd_cur_packet_size(smd_pkt_devp->ch);
142         if (bytes_read == 0 ||
143             bytes_read < smd_read_avail(smd_pkt_devp->ch)) {
144                 mutex_unlock(&smd_pkt_devp->rx_lock);
145                 DBG("Nothing to read\n");
146                 goto wait_for_packet;
147         }
148
149         if (bytes_read > count) {
150                 mutex_unlock(&smd_pkt_devp->rx_lock);
151                 pr_info("packet size %d > buffer size %d", bytes_read, count);
152                 return -EINVAL;
153         }
154
155         r = smd_read(smd_pkt_devp->ch, smd_pkt_devp->rx_buf, bytes_read);
156         if (r != bytes_read) {
157                 mutex_unlock(&smd_pkt_devp->rx_lock);
158                 pr_err("smd_read failed to read %d bytes: %d\n", bytes_read, r);
159                 return -EIO;
160         }
161
162         D_DUMP_BUFFER("read: ", bytes_read, smd_pkt_devp->rx_buf);
163         r = copy_to_user(buf, smd_pkt_devp->rx_buf, bytes_read);
164         mutex_unlock(&smd_pkt_devp->rx_lock);
165         if (r) {
166                 pr_err("copy_to_user failed %d\n", r);
167                 return -EFAULT;
168         }
169
170         DBG("read complete %d bytes\n", bytes_read);
171         check_and_wakeup_reader(smd_pkt_devp);
172
173         return bytes_read;
174 }
175
176 static int smd_pkt_write(struct file *file, const char __user *buf,
177                          size_t count, loff_t *ppos)
178 {
179         int r;
180         struct smd_pkt_dev *smd_pkt_devp;
181
182         if (count > MAX_BUF_SIZE)
183                 return -EINVAL;
184
185         DBG("writting %d bytes\n", count);
186
187         smd_pkt_devp = file->private_data;
188         if (!smd_pkt_devp || !smd_pkt_devp->ch)
189                 return -EINVAL;
190
191         mutex_lock(&smd_pkt_devp->tx_lock);
192         if (smd_write_avail(smd_pkt_devp->ch) < count) {
193                 mutex_unlock(&smd_pkt_devp->tx_lock);
194                 DBG("Not enough space to write\n");
195                 return -ENOMEM;
196         }
197
198         D_DUMP_BUFFER("write: ", count, buf);
199         r = copy_from_user(smd_pkt_devp->tx_buf, buf, count);
200         if (r) {
201                 mutex_unlock(&smd_pkt_devp->tx_lock);
202                 pr_err("copy_from_user failed %d\n", r);
203                 return -EFAULT;
204         }
205
206         r = smd_write(smd_pkt_devp->ch, smd_pkt_devp->tx_buf, count);
207         if (r != count) {
208                 mutex_unlock(&smd_pkt_devp->tx_lock);
209                 pr_err("smd_write failed to write %d bytes: %d.\n", count, r);
210                 return -EIO;
211         }
212         mutex_unlock(&smd_pkt_devp->tx_lock);
213
214         DBG("wrote %d bytes\n", count);
215         return count;
216 }
217
218 static unsigned int smd_pkt_poll(struct file *file, poll_table *wait)
219 {
220         struct smd_pkt_dev *smd_pkt_devp;
221         unsigned int mask = 0;
222
223         smd_pkt_devp = file->private_data;
224         if (!smd_pkt_devp)
225                 return POLLERR;
226
227         DBG("poll waiting\n");
228         poll_wait(file, &smd_pkt_devp->ch_read_wait_queue, wait);
229         if (smd_read_avail(smd_pkt_devp->ch))
230                 mask |= POLLIN | POLLRDNORM;
231
232         DBG("poll return\n");
233         return mask;
234 }
235
236 static void smd_pkt_ch_notify(void *priv, unsigned event)
237 {
238         struct smd_pkt_dev *smd_pkt_devp = priv;
239
240         if (smd_pkt_devp->ch == 0)
241                 return;
242
243         switch (event) {
244         case SMD_EVENT_DATA:
245                 DBG("data\n");
246                 check_and_wakeup_reader(smd_pkt_devp);
247                 break;
248
249         case SMD_EVENT_OPEN:
250                 DBG("remote open\n");
251                 smd_pkt_devp->remote_open = 1;
252                 wake_up_interruptible(&smd_pkt_devp->ch_opened_wait_queue);
253                 break;
254
255         case SMD_EVENT_CLOSE:
256                 smd_pkt_devp->remote_open = 0;
257                 pr_info("remote closed\n");
258                 break;
259
260         default:
261                 pr_err("unknown event %d\n", event);
262                 break;
263         }
264 }
265
266 static char *smd_pkt_dev_name[] = {
267         "smdcntl0",
268         "smdcntl1",
269         "smdcntl2",
270         "smdcntl3",
271         "smdcntl4",
272         "smdcntl5",
273         "smdcntl6",
274         "smdcntl7",
275         "smd22",
276 };
277
278 static char *smd_ch_name[] = {
279         "DATA5_CNTL",
280         "DATA6_CNTL",
281         "DATA7_CNTL",
282         "DATA8_CNTL",
283         "DATA9_CNTL",
284         "DATA12_CNTL",
285         "DATA13_CNTL",
286         "DATA14_CNTL",
287         "DATA22",
288 };
289
290 static int smd_pkt_open(struct inode *inode, struct file *file)
291 {
292         int r = 0;
293         struct smd_pkt_dev *smd_pkt_devp;
294
295         smd_pkt_devp = container_of(inode->i_cdev, struct smd_pkt_dev, cdev);
296         if (!smd_pkt_devp)
297                 return -EINVAL;
298
299         file->private_data = smd_pkt_devp;
300
301         mutex_lock(&smd_pkt_devp->ch_lock);
302         if (smd_pkt_devp->open_count == 0) {
303                 r = smd_open(smd_ch_name[smd_pkt_devp->i],
304                              &smd_pkt_devp->ch, smd_pkt_devp,
305                              smd_pkt_ch_notify);
306                 if (r < 0) {
307                         pr_err("smd_open failed for %s, %d\n",
308                                smd_ch_name[smd_pkt_devp->i], r);
309                         goto out;
310                 }
311
312                 r = wait_event_interruptible_timeout(
313                                 smd_pkt_devp->ch_opened_wait_queue,
314                                 smd_pkt_devp->remote_open,
315                                 msecs_to_jiffies(2 * HZ));
316                 if (r == 0)
317                         r = -ETIMEDOUT;
318
319                 if (r < 0) {
320                         pr_err("wait returned %d\n", r);
321                         smd_close(smd_pkt_devp->ch);
322                         smd_pkt_devp->ch = 0;
323                 } else {
324                         smd_pkt_devp->open_count++;
325                         r = 0;
326                 }
327         }
328 out:
329         mutex_unlock(&smd_pkt_devp->ch_lock);
330         return r;
331 }
332
333 static int smd_pkt_release(struct inode *inode, struct file *file)
334 {
335         int r = 0;
336         struct smd_pkt_dev *smd_pkt_devp = file->private_data;
337
338         if (!smd_pkt_devp)
339                 return -EINVAL;
340
341         mutex_lock(&smd_pkt_devp->ch_lock);
342         if (--smd_pkt_devp->open_count == 0) {
343                 r = smd_close(smd_pkt_devp->ch);
344                 smd_pkt_devp->ch = 0;
345         }
346         mutex_unlock(&smd_pkt_devp->ch_lock);
347
348         return r;
349 }
350
351 static const struct file_operations smd_pkt_fops = {
352         .owner = THIS_MODULE,
353         .open = smd_pkt_open,
354         .release = smd_pkt_release,
355         .read = smd_pkt_read,
356         .write = smd_pkt_write,
357         .poll = smd_pkt_poll,
358 };
359
360 static int __init smd_pkt_init(void)
361 {
362         int i;
363         int r;
364
365         r = alloc_chrdev_region(&smd_pkt_number, 0,
366                                 NUM_SMD_PKT_PORTS, DEVICE_NAME);
367         if (r) {
368                 pr_err("alloc_chrdev_region() failed %d\n", r);
369                 return r;
370         }
371
372         smd_pkt_classp = class_create(THIS_MODULE, DEVICE_NAME);
373         if (IS_ERR(smd_pkt_classp)) {
374                 r = PTR_ERR(smd_pkt_classp);
375                 pr_err("class_create() failed %d\n", r);
376                 goto unreg_chardev;
377         }
378
379         for (i = 0; i < NUM_SMD_PKT_PORTS; ++i) {
380                 smd_pkt_devp[i] = kzalloc(sizeof(struct smd_pkt_dev),
381                                           GFP_KERNEL);
382                 if (!smd_pkt_devp[i]) {
383                         pr_err("kmalloc() failed\n");
384                         goto clean_cdevs;
385                 }
386
387                 smd_pkt_devp[i]->i = i;
388
389                 init_waitqueue_head(&smd_pkt_devp[i]->ch_read_wait_queue);
390                 smd_pkt_devp[i]->remote_open = 0;
391                 init_waitqueue_head(&smd_pkt_devp[i]->ch_opened_wait_queue);
392
393                 mutex_init(&smd_pkt_devp[i]->ch_lock);
394                 mutex_init(&smd_pkt_devp[i]->rx_lock);
395                 mutex_init(&smd_pkt_devp[i]->tx_lock);
396
397                 cdev_init(&smd_pkt_devp[i]->cdev, &smd_pkt_fops);
398                 smd_pkt_devp[i]->cdev.owner = THIS_MODULE;
399
400                 r = cdev_add(&smd_pkt_devp[i]->cdev,
401                              (smd_pkt_number + i), 1);
402                 if (r) {
403                         pr_err("cdev_add() failed %d\n", r);
404                         kfree(smd_pkt_devp[i]);
405                         goto clean_cdevs;
406                 }
407
408                 smd_pkt_devp[i]->devicep =
409                         device_create(smd_pkt_classp, NULL,
410                                       (smd_pkt_number + i), NULL,
411                                       smd_pkt_dev_name[i]);
412                 if (IS_ERR(smd_pkt_devp[i]->devicep)) {
413                         r = PTR_ERR(smd_pkt_devp[i]->devicep);
414                         pr_err("device_create() failed %d\n", r);
415                         cdev_del(&smd_pkt_devp[i]->cdev);
416                         kfree(smd_pkt_devp[i]);
417                         goto clean_cdevs;
418                 }
419
420         }
421
422         pr_info("SMD Packet Port Driver Initialized.\n");
423         return 0;
424
425 clean_cdevs:
426         if (i > 0) {
427                 while (--i >= 0) {
428                         mutex_destroy(&smd_pkt_devp[i]->ch_lock);
429                         mutex_destroy(&smd_pkt_devp[i]->rx_lock);
430                         mutex_destroy(&smd_pkt_devp[i]->tx_lock);
431                         cdev_del(&smd_pkt_devp[i]->cdev);
432                         kfree(smd_pkt_devp[i]);
433                         device_destroy(smd_pkt_classp,
434                                        MKDEV(MAJOR(smd_pkt_number), i));
435                 }
436         }
437
438         class_destroy(smd_pkt_classp);
439 unreg_chardev:
440         unregister_chrdev_region(MAJOR(smd_pkt_number), NUM_SMD_PKT_PORTS);
441         return r;
442 }
443 module_init(smd_pkt_init);
444
445 static void __exit smd_pkt_cleanup(void)
446 {
447         int i;
448
449         for (i = 0; i < NUM_SMD_PKT_PORTS; ++i) {
450                 mutex_destroy(&smd_pkt_devp[i]->ch_lock);
451                 mutex_destroy(&smd_pkt_devp[i]->rx_lock);
452                 mutex_destroy(&smd_pkt_devp[i]->tx_lock);
453                 cdev_del(&smd_pkt_devp[i]->cdev);
454                 kfree(smd_pkt_devp[i]);
455                 device_destroy(smd_pkt_classp,
456                                MKDEV(MAJOR(smd_pkt_number), i));
457         }
458
459         class_destroy(smd_pkt_classp);
460         unregister_chrdev_region(MAJOR(smd_pkt_number), NUM_SMD_PKT_PORTS);
461 }
462 module_exit(smd_pkt_cleanup);
463
464 MODULE_DESCRIPTION("MSM Shared Memory Packet Port");
465 MODULE_LICENSE("GPL v2");