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
40struct 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
60struct class *smd_pkt_classp;
61static dev_t smd_pkt_number;
62
63static int msm_smd_pkt_debug_enable;
64module_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
90static 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
111static 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;
127wait_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
176static 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
218static 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
236static 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
266static 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
278static 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
290static 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	}
328out:
329	mutex_unlock(&smd_pkt_devp->ch_lock);
330	return r;
331}
332
333static 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
351static 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
360static 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
425clean_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);
439unreg_chardev:
440	unregister_chrdev_region(MAJOR(smd_pkt_number), NUM_SMD_PKT_PORTS);
441	return r;
442}
443module_init(smd_pkt_init);
444
445static 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}
462module_exit(smd_pkt_cleanup);
463
464MODULE_DESCRIPTION("MSM Shared Memory Packet Port");
465MODULE_LICENSE("GPL v2");
466