Merge tag 'iommu-v4.15-rc1' of git://github.com/awilliam/linux-vfio
[sfrench/cifs-2.6.git] / drivers / mailbox / mailbox-test.c
1 /*
2  * Copyright (C) 2015 ST Microelectronics
3  *
4  * Author: Lee Jones <lee.jones@linaro.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11
12 #include <linux/debugfs.h>
13 #include <linux/err.h>
14 #include <linux/fs.h>
15 #include <linux/io.h>
16 #include <linux/kernel.h>
17 #include <linux/mailbox_client.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/platform_device.h>
21 #include <linux/poll.h>
22 #include <linux/slab.h>
23 #include <linux/uaccess.h>
24 #include <linux/sched/signal.h>
25
26 #define MBOX_MAX_SIG_LEN        8
27 #define MBOX_MAX_MSG_LEN        128
28 #define MBOX_BYTES_PER_LINE     16
29 #define MBOX_HEXDUMP_LINE_LEN   ((MBOX_BYTES_PER_LINE * 4) + 2)
30 #define MBOX_HEXDUMP_MAX_LEN    (MBOX_HEXDUMP_LINE_LEN *                \
31                                  (MBOX_MAX_MSG_LEN / MBOX_BYTES_PER_LINE))
32
33 static struct dentry *root_debugfs_dir;
34
35 struct mbox_test_device {
36         struct device           *dev;
37         void __iomem            *tx_mmio;
38         void __iomem            *rx_mmio;
39         struct mbox_chan        *tx_channel;
40         struct mbox_chan        *rx_channel;
41         char                    *rx_buffer;
42         char                    *signal;
43         char                    *message;
44         spinlock_t              lock;
45         wait_queue_head_t       waitq;
46         struct fasync_struct    *async_queue;
47 };
48
49 static ssize_t mbox_test_signal_write(struct file *filp,
50                                        const char __user *userbuf,
51                                        size_t count, loff_t *ppos)
52 {
53         struct mbox_test_device *tdev = filp->private_data;
54
55         if (!tdev->tx_channel) {
56                 dev_err(tdev->dev, "Channel cannot do Tx\n");
57                 return -EINVAL;
58         }
59
60         if (count > MBOX_MAX_SIG_LEN) {
61                 dev_err(tdev->dev,
62                         "Signal length %zd greater than max allowed %d\n",
63                         count, MBOX_MAX_SIG_LEN);
64                 return -EINVAL;
65         }
66
67         /* Only allocate memory if we need to */
68         if (!tdev->signal) {
69                 tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL);
70                 if (!tdev->signal)
71                         return -ENOMEM;
72         }
73
74         if (copy_from_user(tdev->signal, userbuf, count)) {
75                 kfree(tdev->signal);
76                 tdev->signal = NULL;
77                 return -EFAULT;
78         }
79
80         return count;
81 }
82
83 static const struct file_operations mbox_test_signal_ops = {
84         .write  = mbox_test_signal_write,
85         .open   = simple_open,
86         .llseek = generic_file_llseek,
87 };
88
89 static int mbox_test_message_fasync(int fd, struct file *filp, int on)
90 {
91         struct mbox_test_device *tdev = filp->private_data;
92
93         return fasync_helper(fd, filp, on, &tdev->async_queue);
94 }
95
96 static ssize_t mbox_test_message_write(struct file *filp,
97                                        const char __user *userbuf,
98                                        size_t count, loff_t *ppos)
99 {
100         struct mbox_test_device *tdev = filp->private_data;
101         void *data;
102         int ret;
103
104         if (!tdev->tx_channel) {
105                 dev_err(tdev->dev, "Channel cannot do Tx\n");
106                 return -EINVAL;
107         }
108
109         if (count > MBOX_MAX_MSG_LEN) {
110                 dev_err(tdev->dev,
111                         "Message length %zd greater than max allowed %d\n",
112                         count, MBOX_MAX_MSG_LEN);
113                 return -EINVAL;
114         }
115
116         tdev->message = kzalloc(MBOX_MAX_MSG_LEN, GFP_KERNEL);
117         if (!tdev->message)
118                 return -ENOMEM;
119
120         ret = copy_from_user(tdev->message, userbuf, count);
121         if (ret) {
122                 ret = -EFAULT;
123                 goto out;
124         }
125
126         /*
127          * A separate signal is only of use if there is
128          * MMIO to subsequently pass the message through
129          */
130         if (tdev->tx_mmio && tdev->signal) {
131                 print_hex_dump_bytes("Client: Sending: Signal: ", DUMP_PREFIX_ADDRESS,
132                                      tdev->signal, MBOX_MAX_SIG_LEN);
133
134                 data = tdev->signal;
135         } else
136                 data = tdev->message;
137
138         print_hex_dump_bytes("Client: Sending: Message: ", DUMP_PREFIX_ADDRESS,
139                              tdev->message, MBOX_MAX_MSG_LEN);
140
141         ret = mbox_send_message(tdev->tx_channel, data);
142         if (ret < 0)
143                 dev_err(tdev->dev, "Failed to send message via mailbox\n");
144
145 out:
146         kfree(tdev->signal);
147         kfree(tdev->message);
148         tdev->signal = NULL;
149
150         return ret < 0 ? ret : count;
151 }
152
153 static bool mbox_test_message_data_ready(struct mbox_test_device *tdev)
154 {
155         unsigned char data;
156         unsigned long flags;
157
158         spin_lock_irqsave(&tdev->lock, flags);
159         data = tdev->rx_buffer[0];
160         spin_unlock_irqrestore(&tdev->lock, flags);
161
162         if (data != '\0')
163                 return true;
164         return false;
165 }
166
167 static ssize_t mbox_test_message_read(struct file *filp, char __user *userbuf,
168                                       size_t count, loff_t *ppos)
169 {
170         struct mbox_test_device *tdev = filp->private_data;
171         unsigned long flags;
172         char *touser, *ptr;
173         int l = 0;
174         int ret;
175
176         DECLARE_WAITQUEUE(wait, current);
177
178         touser = kzalloc(MBOX_HEXDUMP_MAX_LEN + 1, GFP_KERNEL);
179         if (!touser)
180                 return -ENOMEM;
181
182         if (!tdev->rx_channel) {
183                 ret = snprintf(touser, 20, "<NO RX CAPABILITY>\n");
184                 ret = simple_read_from_buffer(userbuf, count, ppos,
185                                               touser, ret);
186                 goto kfree_err;
187         }
188
189         add_wait_queue(&tdev->waitq, &wait);
190
191         do {
192                 __set_current_state(TASK_INTERRUPTIBLE);
193
194                 if (mbox_test_message_data_ready(tdev))
195                         break;
196
197                 if (filp->f_flags & O_NONBLOCK) {
198                         ret = -EAGAIN;
199                         goto waitq_err;
200                 }
201
202                 if (signal_pending(current)) {
203                         ret = -ERESTARTSYS;
204                         goto waitq_err;
205                 }
206                 schedule();
207
208         } while (1);
209
210         spin_lock_irqsave(&tdev->lock, flags);
211
212         ptr = tdev->rx_buffer;
213         while (l < MBOX_HEXDUMP_MAX_LEN) {
214                 hex_dump_to_buffer(ptr,
215                                    MBOX_BYTES_PER_LINE,
216                                    MBOX_BYTES_PER_LINE, 1, touser + l,
217                                    MBOX_HEXDUMP_LINE_LEN, true);
218
219                 ptr += MBOX_BYTES_PER_LINE;
220                 l += MBOX_HEXDUMP_LINE_LEN;
221                 *(touser + (l - 1)) = '\n';
222         }
223         *(touser + l) = '\0';
224
225         memset(tdev->rx_buffer, 0, MBOX_MAX_MSG_LEN);
226
227         spin_unlock_irqrestore(&tdev->lock, flags);
228
229         ret = simple_read_from_buffer(userbuf, count, ppos, touser, MBOX_HEXDUMP_MAX_LEN);
230 waitq_err:
231         __set_current_state(TASK_RUNNING);
232         remove_wait_queue(&tdev->waitq, &wait);
233 kfree_err:
234         kfree(touser);
235         return ret;
236 }
237
238 static unsigned int
239 mbox_test_message_poll(struct file *filp, struct poll_table_struct *wait)
240 {
241         struct mbox_test_device *tdev = filp->private_data;
242
243         poll_wait(filp, &tdev->waitq, wait);
244
245         if (mbox_test_message_data_ready(tdev))
246                 return POLLIN | POLLRDNORM;
247         return 0;
248 }
249
250 static const struct file_operations mbox_test_message_ops = {
251         .write  = mbox_test_message_write,
252         .read   = mbox_test_message_read,
253         .fasync = mbox_test_message_fasync,
254         .poll   = mbox_test_message_poll,
255         .open   = simple_open,
256         .llseek = generic_file_llseek,
257 };
258
259 static int mbox_test_add_debugfs(struct platform_device *pdev,
260                                  struct mbox_test_device *tdev)
261 {
262         if (!debugfs_initialized())
263                 return 0;
264
265         root_debugfs_dir = debugfs_create_dir("mailbox", NULL);
266         if (!root_debugfs_dir) {
267                 dev_err(&pdev->dev, "Failed to create Mailbox debugfs\n");
268                 return -EINVAL;
269         }
270
271         debugfs_create_file("message", 0600, root_debugfs_dir,
272                             tdev, &mbox_test_message_ops);
273
274         debugfs_create_file("signal", 0200, root_debugfs_dir,
275                             tdev, &mbox_test_signal_ops);
276
277         return 0;
278 }
279
280 static void mbox_test_receive_message(struct mbox_client *client, void *message)
281 {
282         struct mbox_test_device *tdev = dev_get_drvdata(client->dev);
283         unsigned long flags;
284
285         spin_lock_irqsave(&tdev->lock, flags);
286         if (tdev->rx_mmio) {
287                 memcpy_fromio(tdev->rx_buffer, tdev->rx_mmio, MBOX_MAX_MSG_LEN);
288                 print_hex_dump_bytes("Client: Received [MMIO]: ", DUMP_PREFIX_ADDRESS,
289                                      tdev->rx_buffer, MBOX_MAX_MSG_LEN);
290         } else if (message) {
291                 print_hex_dump_bytes("Client: Received [API]: ", DUMP_PREFIX_ADDRESS,
292                                      message, MBOX_MAX_MSG_LEN);
293                 memcpy(tdev->rx_buffer, message, MBOX_MAX_MSG_LEN);
294         }
295         spin_unlock_irqrestore(&tdev->lock, flags);
296
297         wake_up_interruptible(&tdev->waitq);
298
299         kill_fasync(&tdev->async_queue, SIGIO, POLL_IN);
300 }
301
302 static void mbox_test_prepare_message(struct mbox_client *client, void *message)
303 {
304         struct mbox_test_device *tdev = dev_get_drvdata(client->dev);
305
306         if (tdev->tx_mmio) {
307                 if (tdev->signal)
308                         memcpy_toio(tdev->tx_mmio, tdev->message, MBOX_MAX_MSG_LEN);
309                 else
310                         memcpy_toio(tdev->tx_mmio, message, MBOX_MAX_MSG_LEN);
311         }
312 }
313
314 static void mbox_test_message_sent(struct mbox_client *client,
315                                    void *message, int r)
316 {
317         if (r)
318                 dev_warn(client->dev,
319                          "Client: Message could not be sent: %d\n", r);
320         else
321                 dev_info(client->dev,
322                          "Client: Message sent\n");
323 }
324
325 static struct mbox_chan *
326 mbox_test_request_channel(struct platform_device *pdev, const char *name)
327 {
328         struct mbox_client *client;
329         struct mbox_chan *channel;
330
331         client = devm_kzalloc(&pdev->dev, sizeof(*client), GFP_KERNEL);
332         if (!client)
333                 return ERR_PTR(-ENOMEM);
334
335         client->dev             = &pdev->dev;
336         client->rx_callback     = mbox_test_receive_message;
337         client->tx_prepare      = mbox_test_prepare_message;
338         client->tx_done         = mbox_test_message_sent;
339         client->tx_block        = true;
340         client->knows_txdone    = false;
341         client->tx_tout         = 500;
342
343         channel = mbox_request_channel_byname(client, name);
344         if (IS_ERR(channel)) {
345                 dev_warn(&pdev->dev, "Failed to request %s channel\n", name);
346                 return NULL;
347         }
348
349         return channel;
350 }
351
352 static int mbox_test_probe(struct platform_device *pdev)
353 {
354         struct mbox_test_device *tdev;
355         struct resource *res;
356         resource_size_t size;
357         int ret;
358
359         tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL);
360         if (!tdev)
361                 return -ENOMEM;
362
363         /* It's okay for MMIO to be NULL */
364         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
365         size = resource_size(res);
366         tdev->tx_mmio = devm_ioremap_resource(&pdev->dev, res);
367         if (PTR_ERR(tdev->tx_mmio) == -EBUSY)
368                 /* if reserved area in SRAM, try just ioremap */
369                 tdev->tx_mmio = devm_ioremap(&pdev->dev, res->start, size);
370         else if (IS_ERR(tdev->tx_mmio))
371                 tdev->tx_mmio = NULL;
372
373         /* If specified, second reg entry is Rx MMIO */
374         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
375         size = resource_size(res);
376         tdev->rx_mmio = devm_ioremap_resource(&pdev->dev, res);
377         if (PTR_ERR(tdev->rx_mmio) == -EBUSY)
378                 tdev->rx_mmio = devm_ioremap(&pdev->dev, res->start, size);
379         else if (IS_ERR(tdev->rx_mmio))
380                 tdev->rx_mmio = tdev->tx_mmio;
381
382         tdev->tx_channel = mbox_test_request_channel(pdev, "tx");
383         tdev->rx_channel = mbox_test_request_channel(pdev, "rx");
384
385         if (!tdev->tx_channel && !tdev->rx_channel)
386                 return -EPROBE_DEFER;
387
388         /* If Rx is not specified but has Rx MMIO, then Rx = Tx */
389         if (!tdev->rx_channel && (tdev->rx_mmio != tdev->tx_mmio))
390                 tdev->rx_channel = tdev->tx_channel;
391
392         tdev->dev = &pdev->dev;
393         platform_set_drvdata(pdev, tdev);
394
395         spin_lock_init(&tdev->lock);
396
397         if (tdev->rx_channel) {
398                 tdev->rx_buffer = devm_kzalloc(&pdev->dev,
399                                                MBOX_MAX_MSG_LEN, GFP_KERNEL);
400                 if (!tdev->rx_buffer)
401                         return -ENOMEM;
402         }
403
404         ret = mbox_test_add_debugfs(pdev, tdev);
405         if (ret)
406                 return ret;
407
408         init_waitqueue_head(&tdev->waitq);
409         dev_info(&pdev->dev, "Successfully registered\n");
410
411         return 0;
412 }
413
414 static int mbox_test_remove(struct platform_device *pdev)
415 {
416         struct mbox_test_device *tdev = platform_get_drvdata(pdev);
417
418         debugfs_remove_recursive(root_debugfs_dir);
419
420         if (tdev->tx_channel)
421                 mbox_free_channel(tdev->tx_channel);
422         if (tdev->rx_channel)
423                 mbox_free_channel(tdev->rx_channel);
424
425         return 0;
426 }
427
428 static const struct of_device_id mbox_test_match[] = {
429         { .compatible = "mailbox-test" },
430         {},
431 };
432 MODULE_DEVICE_TABLE(of, mbox_test_match);
433
434 static struct platform_driver mbox_test_driver = {
435         .driver = {
436                 .name = "mailbox_test",
437                 .of_match_table = mbox_test_match,
438         },
439         .probe  = mbox_test_probe,
440         .remove = mbox_test_remove,
441 };
442 module_platform_driver(mbox_test_driver);
443
444 MODULE_DESCRIPTION("Generic Mailbox Testing Facility");
445 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org");
446 MODULE_LICENSE("GPL v2");