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 bool mbox_data_ready; 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 struct dentry *root_debugfs_dir; 48 }; 49 50 static ssize_t mbox_test_signal_write(struct file *filp, 51 const char __user *userbuf, 52 size_t count, loff_t *ppos) 53 { 54 struct mbox_test_device *tdev = filp->private_data; 55 56 if (!tdev->tx_channel) { 57 dev_err(tdev->dev, "Channel cannot do Tx\n"); 58 return -EINVAL; 59 } 60 61 if (count > MBOX_MAX_SIG_LEN) { 62 dev_err(tdev->dev, 63 "Signal length %zd greater than max allowed %d\n", 64 count, MBOX_MAX_SIG_LEN); 65 return -EINVAL; 66 } 67 68 /* Only allocate memory if we need to */ 69 if (!tdev->signal) { 70 tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL); 71 if (!tdev->signal) 72 return -ENOMEM; 73 } 74 75 if (copy_from_user(tdev->signal, userbuf, count)) { 76 kfree(tdev->signal); 77 tdev->signal = NULL; 78 return -EFAULT; 79 } 80 81 return count; 82 } 83 84 static const struct file_operations mbox_test_signal_ops = { 85 .write = mbox_test_signal_write, 86 .open = simple_open, 87 .llseek = generic_file_llseek, 88 }; 89 90 static int mbox_test_message_fasync(int fd, struct file *filp, int on) 91 { 92 struct mbox_test_device *tdev = filp->private_data; 93 94 return fasync_helper(fd, filp, on, &tdev->async_queue); 95 } 96 97 static ssize_t mbox_test_message_write(struct file *filp, 98 const char __user *userbuf, 99 size_t count, loff_t *ppos) 100 { 101 struct mbox_test_device *tdev = filp->private_data; 102 void *data; 103 int ret; 104 105 if (!tdev->tx_channel) { 106 dev_err(tdev->dev, "Channel cannot do Tx\n"); 107 return -EINVAL; 108 } 109 110 if (count > MBOX_MAX_MSG_LEN) { 111 dev_err(tdev->dev, 112 "Message length %zd greater than max allowed %d\n", 113 count, MBOX_MAX_MSG_LEN); 114 return -EINVAL; 115 } 116 117 tdev->message = kzalloc(MBOX_MAX_MSG_LEN, GFP_KERNEL); 118 if (!tdev->message) 119 return -ENOMEM; 120 121 ret = copy_from_user(tdev->message, userbuf, count); 122 if (ret) { 123 ret = -EFAULT; 124 goto out; 125 } 126 127 /* 128 * A separate signal is only of use if there is 129 * MMIO to subsequently pass the message through 130 */ 131 if (tdev->tx_mmio && tdev->signal) { 132 print_hex_dump_bytes("Client: Sending: Signal: ", DUMP_PREFIX_ADDRESS, 133 tdev->signal, MBOX_MAX_SIG_LEN); 134 135 data = tdev->signal; 136 } else 137 data = tdev->message; 138 139 print_hex_dump_bytes("Client: Sending: Message: ", DUMP_PREFIX_ADDRESS, 140 tdev->message, MBOX_MAX_MSG_LEN); 141 142 ret = mbox_send_message(tdev->tx_channel, data); 143 if (ret < 0) 144 dev_err(tdev->dev, "Failed to send message via mailbox\n"); 145 146 out: 147 kfree(tdev->signal); 148 kfree(tdev->message); 149 tdev->signal = NULL; 150 151 return ret < 0 ? ret : count; 152 } 153 154 static bool mbox_test_message_data_ready(struct mbox_test_device *tdev) 155 { 156 bool data_ready; 157 unsigned long flags; 158 159 spin_lock_irqsave(&tdev->lock, flags); 160 data_ready = mbox_data_ready; 161 spin_unlock_irqrestore(&tdev->lock, flags); 162 163 return data_ready; 164 } 165 166 static ssize_t mbox_test_message_read(struct file *filp, char __user *userbuf, 167 size_t count, loff_t *ppos) 168 { 169 struct mbox_test_device *tdev = filp->private_data; 170 unsigned long flags; 171 char *touser, *ptr; 172 int l = 0; 173 int ret; 174 175 DECLARE_WAITQUEUE(wait, current); 176 177 touser = kzalloc(MBOX_HEXDUMP_MAX_LEN + 1, GFP_KERNEL); 178 if (!touser) 179 return -ENOMEM; 180 181 if (!tdev->rx_channel) { 182 ret = snprintf(touser, 20, "<NO RX CAPABILITY>\n"); 183 ret = simple_read_from_buffer(userbuf, count, ppos, 184 touser, ret); 185 goto kfree_err; 186 } 187 188 add_wait_queue(&tdev->waitq, &wait); 189 190 do { 191 __set_current_state(TASK_INTERRUPTIBLE); 192 193 if (mbox_test_message_data_ready(tdev)) 194 break; 195 196 if (filp->f_flags & O_NONBLOCK) { 197 ret = -EAGAIN; 198 goto waitq_err; 199 } 200 201 if (signal_pending(current)) { 202 ret = -ERESTARTSYS; 203 goto waitq_err; 204 } 205 schedule(); 206 207 } while (1); 208 209 spin_lock_irqsave(&tdev->lock, flags); 210 211 ptr = tdev->rx_buffer; 212 while (l < MBOX_HEXDUMP_MAX_LEN) { 213 hex_dump_to_buffer(ptr, 214 MBOX_BYTES_PER_LINE, 215 MBOX_BYTES_PER_LINE, 1, touser + l, 216 MBOX_HEXDUMP_LINE_LEN, true); 217 218 ptr += MBOX_BYTES_PER_LINE; 219 l += MBOX_HEXDUMP_LINE_LEN; 220 *(touser + (l - 1)) = '\n'; 221 } 222 *(touser + l) = '\0'; 223 224 memset(tdev->rx_buffer, 0, MBOX_MAX_MSG_LEN); 225 mbox_data_ready = false; 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 __poll_t 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 EPOLLIN | EPOLLRDNORM; 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 tdev->root_debugfs_dir = debugfs_create_dir(dev_name(&pdev->dev), NULL); 266 if (!tdev->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, tdev->root_debugfs_dir, 272 tdev, &mbox_test_message_ops); 273 274 debugfs_create_file("signal", 0200, tdev->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 mbox_data_ready = true; 296 spin_unlock_irqrestore(&tdev->lock, flags); 297 298 wake_up_interruptible(&tdev->waitq); 299 300 kill_fasync(&tdev->async_queue, SIGIO, POLL_IN); 301 } 302 303 static void mbox_test_prepare_message(struct mbox_client *client, void *message) 304 { 305 struct mbox_test_device *tdev = dev_get_drvdata(client->dev); 306 307 if (tdev->tx_mmio) { 308 if (tdev->signal) 309 memcpy_toio(tdev->tx_mmio, tdev->message, MBOX_MAX_MSG_LEN); 310 else 311 memcpy_toio(tdev->tx_mmio, message, MBOX_MAX_MSG_LEN); 312 } 313 } 314 315 static void mbox_test_message_sent(struct mbox_client *client, 316 void *message, int r) 317 { 318 if (r) 319 dev_warn(client->dev, 320 "Client: Message could not be sent: %d\n", r); 321 else 322 dev_info(client->dev, 323 "Client: Message sent\n"); 324 } 325 326 static struct mbox_chan * 327 mbox_test_request_channel(struct platform_device *pdev, const char *name) 328 { 329 struct mbox_client *client; 330 struct mbox_chan *channel; 331 332 client = devm_kzalloc(&pdev->dev, sizeof(*client), GFP_KERNEL); 333 if (!client) 334 return ERR_PTR(-ENOMEM); 335 336 client->dev = &pdev->dev; 337 client->rx_callback = mbox_test_receive_message; 338 client->tx_prepare = mbox_test_prepare_message; 339 client->tx_done = mbox_test_message_sent; 340 client->tx_block = true; 341 client->knows_txdone = false; 342 client->tx_tout = 500; 343 344 channel = mbox_request_channel_byname(client, name); 345 if (IS_ERR(channel)) { 346 dev_warn(&pdev->dev, "Failed to request %s channel\n", name); 347 return NULL; 348 } 349 350 return channel; 351 } 352 353 static int mbox_test_probe(struct platform_device *pdev) 354 { 355 struct mbox_test_device *tdev; 356 struct resource *res; 357 resource_size_t size; 358 int ret; 359 360 tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL); 361 if (!tdev) 362 return -ENOMEM; 363 364 /* It's okay for MMIO to be NULL */ 365 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 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 size = resource_size(res); 370 tdev->tx_mmio = devm_ioremap(&pdev->dev, res->start, size); 371 } else if (IS_ERR(tdev->tx_mmio)) { 372 tdev->tx_mmio = NULL; 373 } 374 375 /* If specified, second reg entry is Rx MMIO */ 376 res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 377 tdev->rx_mmio = devm_ioremap_resource(&pdev->dev, res); 378 if (PTR_ERR(tdev->rx_mmio) == -EBUSY) { 379 size = resource_size(res); 380 tdev->rx_mmio = devm_ioremap(&pdev->dev, res->start, size); 381 } else if (IS_ERR(tdev->rx_mmio)) { 382 tdev->rx_mmio = tdev->tx_mmio; 383 } 384 385 tdev->tx_channel = mbox_test_request_channel(pdev, "tx"); 386 tdev->rx_channel = mbox_test_request_channel(pdev, "rx"); 387 388 if (!tdev->tx_channel && !tdev->rx_channel) 389 return -EPROBE_DEFER; 390 391 /* If Rx is not specified but has Rx MMIO, then Rx = Tx */ 392 if (!tdev->rx_channel && (tdev->rx_mmio != tdev->tx_mmio)) 393 tdev->rx_channel = tdev->tx_channel; 394 395 tdev->dev = &pdev->dev; 396 platform_set_drvdata(pdev, tdev); 397 398 spin_lock_init(&tdev->lock); 399 400 if (tdev->rx_channel) { 401 tdev->rx_buffer = devm_kzalloc(&pdev->dev, 402 MBOX_MAX_MSG_LEN, GFP_KERNEL); 403 if (!tdev->rx_buffer) 404 return -ENOMEM; 405 } 406 407 ret = mbox_test_add_debugfs(pdev, tdev); 408 if (ret) 409 return ret; 410 411 init_waitqueue_head(&tdev->waitq); 412 dev_info(&pdev->dev, "Successfully registered\n"); 413 414 return 0; 415 } 416 417 static int mbox_test_remove(struct platform_device *pdev) 418 { 419 struct mbox_test_device *tdev = platform_get_drvdata(pdev); 420 421 debugfs_remove_recursive(tdev->root_debugfs_dir); 422 423 if (tdev->tx_channel) 424 mbox_free_channel(tdev->tx_channel); 425 if (tdev->rx_channel) 426 mbox_free_channel(tdev->rx_channel); 427 428 return 0; 429 } 430 431 static const struct of_device_id mbox_test_match[] = { 432 { .compatible = "mailbox-test" }, 433 {}, 434 }; 435 MODULE_DEVICE_TABLE(of, mbox_test_match); 436 437 static struct platform_driver mbox_test_driver = { 438 .driver = { 439 .name = "mailbox_test", 440 .of_match_table = mbox_test_match, 441 }, 442 .probe = mbox_test_probe, 443 .remove = mbox_test_remove, 444 }; 445 module_platform_driver(mbox_test_driver); 446 447 MODULE_DESCRIPTION("Generic Mailbox Testing Facility"); 448 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org"); 449 MODULE_LICENSE("GPL v2"); 450