85eb47a4607b8adeaa8aac1ba136a823507ef883
[linux-3.10.git] / drivers / misc / tegra-cec / tegra_cec.c
1 /*
2  * drivers/misc/tegra-cec/tegra_cec.c
3  *
4  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/err.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <linux/slab.h>
25 #include <linux/io.h>
26 #include <linux/clk.h>
27 #include <linux/delay.h>
28 #include <linux/workqueue.h>
29 #include <linux/ktime.h>
30 #include <linux/wait.h>
31 #include <linux/sched.h>
32 #include <linux/fs.h>
33 #include <linux/uaccess.h>
34
35 #include <linux/platform_device.h>
36 #include <linux/miscdevice.h>
37 #include <linux/clk/tegra.h>
38
39 #include "tegra_cec.h"
40
41
42 int tegra_cec_open(struct inode *inode, struct file *file)
43 {
44         struct miscdevice *miscdev = file->private_data;
45         struct tegra_cec *cec = container_of(miscdev,
46                 struct tegra_cec, misc_dev);
47         dev_dbg(cec->dev, "%s\n", __func__);
48         file->private_data = cec;
49
50         return 0;
51 }
52
53 int tegra_cec_release(struct inode *inode, struct file *file)
54 {
55         struct tegra_cec *cec = file->private_data;
56
57         dev_dbg(cec->dev, "%s\n", __func__);
58
59         return 0;
60 }
61
62 ssize_t tegra_cec_write(struct file *file, const char __user *buffer,
63         size_t count, loff_t *ppos)
64 {
65         struct tegra_cec *cec = file->private_data;
66         unsigned long write_buff;
67
68         count = 4;
69
70         if (copy_from_user(&write_buff, buffer, count))
71                 return -EFAULT;
72
73         writel((TEGRA_CEC_INT_MASK_TX_REGISTER_EMPTY |
74                 TEGRA_CEC_INT_MASK_TX_REGISTER_UNDERRUN |
75             TEGRA_CEC_INT_MASK_TX_FRAME_OR_BLOCK_NAKD |
76             TEGRA_CEC_INT_MASK_TX_ARBITRATION_FAILED |
77             TEGRA_CEC_INT_MASK_TX_BUS_ANOMALY_DETECTED |
78             TEGRA_CEC_INT_MASK_RX_REGISTER_FULL |
79             TEGRA_CEC_INT_MASK_RX_REGISTER_OVERRUN),
80             cec->cec_base + TEGRA_CEC_INT_MASK);
81
82         wait_event_interruptible(cec->tx_waitq, cec->tx_wake == 1);
83         writel(write_buff, cec->cec_base + TEGRA_CEC_TX_REGISTER);
84         cec->tx_wake = 0;
85
86         writel((TEGRA_CEC_INT_MASK_TX_REGISTER_UNDERRUN |
87                 TEGRA_CEC_INT_MASK_TX_FRAME_OR_BLOCK_NAKD |
88             TEGRA_CEC_INT_MASK_TX_ARBITRATION_FAILED |
89             TEGRA_CEC_INT_MASK_TX_BUS_ANOMALY_DETECTED |
90             TEGRA_CEC_INT_MASK_RX_REGISTER_FULL |
91             TEGRA_CEC_INT_MASK_RX_REGISTER_OVERRUN),
92             cec->cec_base + TEGRA_CEC_INT_MASK);
93
94         write_buff = 0x00;
95         return count;
96 }
97
98 ssize_t tegra_cec_read(struct file *file, char  __user *buffer,
99         size_t count, loff_t *ppos)
100 {
101         struct tegra_cec *cec = file->private_data;
102         count = 2;
103
104         if (cec->rx_wake == 0)
105                 if (file->f_flags & O_NONBLOCK)
106                         return -EAGAIN;
107
108         wait_event_interruptible(cec->rx_waitq, cec->rx_wake == 1);
109
110         if (copy_to_user(buffer, &(cec->rx_buffer), count))
111                 return -EFAULT;
112
113         cec->rx_buffer = 0x0;
114         cec->rx_wake = 0;
115         return count;
116 }
117
118 static irqreturn_t tegra_cec_irq_handler(int irq, void *data)
119 {
120         struct device *dev = data;
121         struct tegra_cec *cec = dev_get_drvdata(dev);
122         unsigned long status;
123
124         status = readl(cec->cec_base + TEGRA_CEC_INT_STAT);
125
126         if (!status)
127                 return IRQ_HANDLED;
128
129         if ((status & TEGRA_CEC_INT_STAT_RX_REGISTER_OVERRUN) ||
130                 (status & TEGRA_CEC_INT_STAT_RX_BUS_ANOMALY_DETECTED) ||
131                 (status & TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED) ||
132                 (status & TEGRA_CEC_INT_STAT_RX_BUS_ERROR_DETECTED)) {
133                 writel((TEGRA_CEC_INT_STAT_RX_REGISTER_OVERRUN |
134                         TEGRA_CEC_INT_STAT_RX_BUS_ANOMALY_DETECTED |
135                         TEGRA_CEC_INT_STAT_RX_START_BIT_DETECTED |
136                         TEGRA_CEC_INT_STAT_RX_BUS_ERROR_DETECTED),
137                         cec->cec_base + TEGRA_CEC_INT_STAT);
138         } else if (status & TEGRA_CEC_INT_STAT_RX_REGISTER_FULL) {
139                 writel((TEGRA_CEC_INT_STAT_RX_REGISTER_FULL),
140                         cec->cec_base + TEGRA_CEC_INT_STAT);
141                 cec->rx_buffer = readw(cec->cec_base + TEGRA_CEC_RX_REGISTER);
142                 cec->rx_wake = 1;
143                 wake_up_interruptible(&cec->rx_waitq);
144         } else if ((status & TEGRA_CEC_INT_STAT_TX_REGISTER_UNDERRUN) ||
145                 (status & TEGRA_CEC_INT_STAT_TX_FRAME_OR_BLOCK_NAKD) ||
146                 (status & TEGRA_CEC_INT_STAT_TX_ARBITRATION_FAILED) ||
147                 (status & TEGRA_CEC_INT_STAT_TX_BUS_ANOMALY_DETECTED)) {
148                 writel((TEGRA_CEC_INT_STAT_TX_REGISTER_UNDERRUN |
149                         TEGRA_CEC_INT_STAT_TX_FRAME_OR_BLOCK_NAKD |
150                         TEGRA_CEC_INT_STAT_TX_REGISTER_EMPTY |
151                         TEGRA_CEC_INT_STAT_TX_ARBITRATION_FAILED |
152                         TEGRA_CEC_INT_STAT_TX_BUS_ANOMALY_DETECTED),
153                         cec->cec_base + TEGRA_CEC_INT_STAT);
154         } else if (status & TEGRA_CEC_INT_STAT_TX_REGISTER_EMPTY) {
155                 cec->tx_wake = 1;
156                 wake_up_interruptible(&cec->tx_waitq);
157                 writel((TEGRA_CEC_INT_STAT_TX_REGISTER_EMPTY),
158                    cec->cec_base + TEGRA_CEC_INT_STAT);
159         } else if (status & TEGRA_CEC_INT_STAT_TX_FRAME_TRANSMITTED) {
160                 writel((TEGRA_CEC_INT_STAT_TX_FRAME_TRANSMITTED),
161                    cec->cec_base + TEGRA_CEC_INT_STAT);
162         }
163
164         return IRQ_HANDLED;
165 }
166
167 static const struct file_operations tegra_cec_fops = {
168         .owner = THIS_MODULE,
169         .open = tegra_cec_open,
170         .release = tegra_cec_release,
171         .read = tegra_cec_read,
172         .write = tegra_cec_write,
173 };
174
175 static void tegra_cec_init(struct tegra_cec *cec)
176 {
177
178         writel(0x00, cec->cec_base + TEGRA_CEC_HW_CONTROL);
179         writel(0x00, cec->cec_base + TEGRA_CEC_INT_MASK);
180         writel(0xffffffff, cec->cec_base + TEGRA_CEC_INT_STAT);
181         msleep(1000);
182
183         writel(0x00, cec->cec_base + TEGRA_CEC_SW_CONTROL);
184
185         writel(((TEGRA_CEC_LOGICAL_ADDR<<TEGRA_CEC_HW_CONTROL_RX_LOGICAL_ADDRS_MASK)&
186            (~TEGRA_CEC_HW_CONTROL_RX_SNOOP) &
187            (~TEGRA_CEC_HW_CONTROL_RX_NAK_MODE) &
188            (~TEGRA_CEC_HW_CONTROL_TX_NAK_MODE) &
189            (~TEGRA_CEC_HW_CONTROL_FAST_SIM_MODE)) |
190            (TEGRA_CEC_HW_CONTROL_TX_RX_MODE),
191            cec->cec_base + TEGRA_CEC_HW_CONTROL);
192
193         writel(0x00, cec->cec_base + TEGRA_CEC_INPUT_FILTER);
194
195         writel((0x7a << TEGRA_CEC_RX_TIMING_0_RX_START_BIT_MAX_LO_TIME_MASK) |
196            (0x6d << TEGRA_CEC_RX_TIMING_0_RX_START_BIT_MIN_LO_TIME_MASK) |
197            (0x93 << TEGRA_CEC_RX_TIMING_0_RX_START_BIT_MAX_DURATION_MASK) |
198            (0x86 << TEGRA_CEC_RX_TIMING_0_RX_START_BIT_MIN_DURATION_MASK),
199            cec->cec_base + TEGRA_CEC_RX_TIMING_0);
200
201         writel((0x35 << TEGRA_CEC_RX_TIMING_1_RX_DATA_BIT_MAX_LO_TIME_MASK) |
202            (0x21 << TEGRA_CEC_RX_TIMING_1_RX_DATA_BIT_SAMPLE_TIME_MASK) |
203            (0x56 << TEGRA_CEC_RX_TIMING_1_RX_DATA_BIT_MAX_DURATION_MASK) |
204            (0x40 << TEGRA_CEC_RX_TIMING_1_RX_DATA_BIT_MIN_DURATION_MASK),
205            cec->cec_base + TEGRA_CEC_RX_TIMING_1);
206
207         writel((0x50 << TEGRA_CEC_RX_TIMING_2_RX_END_OF_BLOCK_TIME_MASK),
208            cec->cec_base + TEGRA_CEC_RX_TIMING_2);
209
210         writel((0x74 << TEGRA_CEC_TX_TIMING_0_TX_START_BIT_LO_TIME_MASK) |
211            (0x8d << TEGRA_CEC_TX_TIMING_0_TX_START_BIT_DURATION_MASK) |
212            (0x08 << TEGRA_CEC_TX_TIMING_0_TX_BUS_XITION_TIME_MASK) |
213            (0x71 << TEGRA_CEC_TX_TIMING_0_TX_BUS_ERROR_LO_TIME_MASK),
214            cec->cec_base + TEGRA_CEC_TX_TIMING_0);
215
216         writel((0x2f << TEGRA_CEC_TX_TIMING_1_TX_LO_DATA_BIT_LO_TIME_MASK) |
217            (0x13 << TEGRA_CEC_TX_TIMING_1_TX_HI_DATA_BIT_LO_TIME_MASK) |
218            (0x4b << TEGRA_CEC_TX_TIMING_1_TX_DATA_BIT_DURATION_MASK) |
219            (0x21 << TEGRA_CEC_TX_TIMING_1_TX_ACK_NAK_BIT_SAMPLE_TIME_MASK),
220            cec->cec_base + TEGRA_CEC_TX_TIMING_1);
221
222         writel((0x07 << TEGRA_CEC_TX_TIMING_2_BUS_IDLE_TIME_ADDITIONAL_FRAME_MASK) |
223            (0x05 << TEGRA_CEC_TX_TIMING_2_TX_BUS_IDLE_TIME_NEW_FRAME_MASK) |
224            (0x03 << TEGRA_CEC_TX_TIMING_2_TX_BUS_IDLE_TIME_RETRY_FRAME_MASK),
225            cec->cec_base + TEGRA_CEC_TX_TIMING_2);
226
227         writel((TEGRA_CEC_INT_MASK_TX_REGISTER_UNDERRUN |
228             TEGRA_CEC_INT_MASK_TX_FRAME_OR_BLOCK_NAKD |
229             TEGRA_CEC_INT_MASK_TX_ARBITRATION_FAILED |
230             TEGRA_CEC_INT_MASK_TX_BUS_ANOMALY_DETECTED |
231             TEGRA_CEC_INT_MASK_RX_REGISTER_FULL |
232             TEGRA_CEC_INT_MASK_RX_REGISTER_OVERRUN),
233            cec->cec_base + TEGRA_CEC_INT_MASK);
234 }
235
236 static int tegra_cec_probe(struct platform_device *pdev)
237 {
238         struct tegra_cec *cec;
239         struct resource *res;
240         int ret = 0;
241
242         cec = devm_kzalloc(&pdev->dev, sizeof(struct tegra_cec), GFP_KERNEL);
243
244         if (!cec)
245                 return -ENOMEM;
246
247         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
248
249         if (!res) {
250                 dev_err(&pdev->dev,
251                     "Unable to allocate resources for device.\n");
252                 ret = -EBUSY;
253                 goto cec_error;
254         }
255
256         if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
257                 pdev->name)) {
258                 dev_err(&pdev->dev,
259                         "Unable to request mem region for device.\n");
260                 ret = -EBUSY;
261                 goto cec_error;
262         }
263
264         cec->tegra_cec_irq = platform_get_irq(pdev, 0);
265
266         if (cec->tegra_cec_irq <= 0) {
267                 ret = -EBUSY;
268                 goto cec_error;
269         }
270
271         cec->cec_base = devm_ioremap_nocache(&pdev->dev, res->start,
272                 resource_size(res));
273
274         if (!cec->cec_base) {
275                 dev_err(&pdev->dev, "Unable to grab IOs for device.\n");
276                 ret = -EBUSY;
277                 goto cec_error;
278         }
279
280         cec->clk = clk_get(&pdev->dev, "cec");
281
282         if (IS_ERR_OR_NULL(cec->clk)) {
283                 dev_err(&pdev->dev, "can't get clock for CEC\n");
284                 ret = -ENOENT;
285                 goto clk_error;
286         }
287
288         clk_enable(cec->clk);
289
290         /* set context info. */
291         cec->dev = &pdev->dev;
292         cec->rx_wake = 0;
293         cec->tx_wake = 0;
294         init_waitqueue_head(&cec->rx_waitq);
295         init_waitqueue_head(&cec->tx_waitq);
296
297         platform_set_drvdata(pdev, cec);
298         /* clear out the hardware. */
299
300         tegra_cec_init(cec);
301
302         device_init_wakeup(&pdev->dev, 1);
303
304         cec->misc_dev.minor = MISC_DYNAMIC_MINOR;
305         cec->misc_dev.name = TEGRA_CEC_NAME;
306         cec->misc_dev.fops = &tegra_cec_fops;
307         cec->misc_dev.parent = &pdev->dev;
308
309         if (misc_register(&cec->misc_dev)) {
310                 printk(KERN_WARNING "Couldn't register device , %s.\n", TEGRA_CEC_NAME);
311                 goto cec_error;
312         }
313
314         ret = devm_request_irq(&pdev->dev, cec->tegra_cec_irq,
315                 tegra_cec_irq_handler, IRQF_DISABLED, "cec_irq", &pdev->dev);
316
317         if (ret) {
318                 dev_err(&pdev->dev,
319                         "Unable to request interrupt for device (err=%d).\n", ret);
320                 goto cec_error;
321         }
322
323         dev_notice(&pdev->dev, "probed\n");
324
325         return 0;
326
327 cec_error:
328         clk_disable(cec->clk);
329         clk_put(cec->clk);
330 clk_error:
331         return ret;
332 }
333
334 static int tegra_cec_remove(struct platform_device *pdev)
335 {
336         struct tegra_cec *cec = platform_get_drvdata(pdev);
337
338         clk_disable(cec->clk);
339         clk_put(cec->clk);
340
341         misc_deregister(&cec->misc_dev);
342
343         return 0;
344 }
345
346 #ifdef CONFIG_PM
347 static int tegra_cec_suspend(struct platform_device *pdev, pm_message_t state)
348 {
349         struct tegra_cec *cec = platform_get_drvdata(pdev);
350
351         clk_disable(cec->clk);
352
353         return 0;
354 }
355
356 static int tegra_cec_resume(struct platform_device *pdev)
357 {
358
359         struct tegra_cec *cec = platform_get_drvdata(pdev);
360         clk_enable(cec->clk);
361         tegra_cec_init(cec);
362         return 0;
363 }
364 #endif
365
366 static struct platform_driver tegra_cec_driver = {
367         .driver = {
368                 .name = TEGRA_CEC_NAME,
369                 .owner = THIS_MODULE,
370         },
371         .probe = tegra_cec_probe,
372         .remove = tegra_cec_remove,
373
374 #ifdef CONFIG_PM
375         .suspend = tegra_cec_suspend,
376         .resume = tegra_cec_resume,
377 #endif
378 };
379
380 module_platform_driver(tegra_cec_driver);