From: shanlong.li Date: Mon, 25 Apr 2022 11:29:36 +0000 (-0700) Subject: mailbox:starfive: use clk/rst API. X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2f5efd0235b4543672f8fba52e903480ed72de73;p=platform%2Fkernel%2Flinux-starfive.git mailbox:starfive: use clk/rst API. 1) use clk/rst api 2) fix coding style. Signed-off-by: shanlong.li --- diff --git a/drivers/mailbox/starfive_mailbox-test.c b/drivers/mailbox/starfive_mailbox-test.c index 765eb98..860f18d 100644 --- a/drivers/mailbox/starfive_mailbox-test.c +++ b/drivers/mailbox/starfive_mailbox-test.c @@ -21,389 +21,396 @@ #include -#define MBOX_MAX_SIG_LEN 8 -#define MBOX_MAX_MSG_LEN 16 -#define MBOX_BYTES_PER_LINE 16 -#define MBOX_HEXDUMP_LINE_LEN ((MBOX_BYTES_PER_LINE * 4) + 2) -#define MBOX_HEXDUMP_MAX_LEN (MBOX_HEXDUMP_LINE_LEN * (MBOX_MAX_MSG_LEN / MBOX_BYTES_PER_LINE)) +#define MBOX_MAX_SIG_LEN 8 +#define MBOX_MAX_MSG_LEN 16 +#define MBOX_BYTES_PER_LINE 16 +#define MBOX_HEXDUMP_LINE_LEN ((MBOX_BYTES_PER_LINE * 4) + 2) +#define MBOX_HEXDUMP_MAX_LEN (MBOX_HEXDUMP_LINE_LEN * (MBOX_MAX_MSG_LEN / MBOX_BYTES_PER_LINE)) static bool mbox_data_ready; struct mbox_test_device { - struct device *dev; - void __iomem *tx_mmio; - void __iomem *rx_mmio; - struct mbox_chan *tx_channel; - struct mbox_chan *rx_channel; - char *rx_buffer; - char *signal; - char *message; - spinlock_t lock; - wait_queue_head_t waitq; - struct fasync_struct *async_queue; - struct dentry *root_debugfs_dir; + struct device *dev; + void __iomem *tx_mmio; + void __iomem *rx_mmio; + struct mbox_chan *tx_channel; + struct mbox_chan *rx_channel; + char *rx_buffer; + char *signal; + char *message; + spinlock_t lock; + wait_queue_head_t waitq; + struct fasync_struct *async_queue; + struct dentry *root_debugfs_dir; }; static ssize_t mbox_test_signal_write(struct file *filp, - const char __user *userbuf, - size_t count, loff_t *ppos){ - struct mbox_test_device *tdev = filp->private_data; - - if (!tdev->tx_channel) { - dev_err(tdev->dev, "Channel cannot do Tx\n"); - return -EINVAL; - } - - if (count > MBOX_MAX_SIG_LEN) { - dev_err(tdev->dev, - "Signal length %zd greater than max allowed %d\n", - count, MBOX_MAX_SIG_LEN); - return -EINVAL; - } - - /* Only allocate memory if we need to */ - if (!tdev->signal) { - tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL); - if (!tdev->signal) - return -ENOMEM; - } - - if (copy_from_user(tdev->signal, userbuf, count)) { - kfree(tdev->signal); - tdev->signal = NULL; - return -EFAULT; - } - - return count; + const char __user *userbuf, + size_t count, loff_t *ppos) +{ + struct mbox_test_device *tdev = filp->private_data; + + if (!tdev->tx_channel) { + dev_err(tdev->dev, "Channel cannot do Tx\n"); + return -EINVAL; + } + + if (count > MBOX_MAX_SIG_LEN) { + dev_err(tdev->dev, + "Signal length %zd greater than max allowed %d\n", + count, MBOX_MAX_SIG_LEN); + return -EINVAL; + } + + /* Only allocate memory if we need to */ + if (!tdev->signal) { + tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL); + if (!tdev->signal) + return -ENOMEM; + } + + if (copy_from_user(tdev->signal, userbuf, count)) { + kfree(tdev->signal); + tdev->signal = NULL; + return -EFAULT; + } + + return count; } static const struct file_operations mbox_test_signal_ops = { - .write = mbox_test_signal_write, - .open = simple_open, - .llseek = generic_file_llseek, + .write = mbox_test_signal_write, + .open = simple_open, + .llseek = generic_file_llseek, }; -static int mbox_test_message_fasync(int fd, struct file *filp, int on){ - struct mbox_test_device *tdev = filp->private_data; +static int mbox_test_message_fasync(int fd, struct file *filp, int on) +{ + struct mbox_test_device *tdev = filp->private_data; - return fasync_helper(fd, filp, on, &tdev->async_queue); + return fasync_helper(fd, filp, on, &tdev->async_queue); } static ssize_t mbox_test_message_write(struct file *filp, - const char __user *userbuf, - size_t count, loff_t *ppos){ - struct mbox_test_device *tdev = filp->private_data; - void *data; - int ret; - - if (!tdev->tx_channel) { - dev_err(tdev->dev, "Channel cannot do Tx\n"); - return -EINVAL; - } - - if (count > MBOX_MAX_MSG_LEN) { - dev_err(tdev->dev, - "Message length %zd greater than max allowed %d\n", - count, MBOX_MAX_MSG_LEN); - return -EINVAL; - } - - tdev->message = kzalloc(MBOX_MAX_MSG_LEN, GFP_KERNEL); - if (!tdev->message) - return -ENOMEM; - - ret = copy_from_user(tdev->message, userbuf, count); - if (ret) { - ret = -EFAULT; - goto out; - } - - /* - * A separate signal is only of use if there is - * MMIO to subsequently pass the message through - */ - if (tdev->tx_mmio && tdev->signal) { - print_hex_dump_bytes("Client: Sending: Signal: ", DUMP_PREFIX_ADDRESS, - tdev->signal, MBOX_MAX_SIG_LEN); - - data = tdev->signal; - } else - data = tdev->message; - - print_hex_dump_bytes("Client: Sending: Message: ", DUMP_PREFIX_ADDRESS, - tdev->message, MBOX_MAX_MSG_LEN); - - ret = mbox_send_message(tdev->tx_channel, data); - mbox_chan_txdone(tdev->tx_channel,ret); - if (ret < 0) - dev_err(tdev->dev, "Failed to send message via mailbox\n"); + const char __user *userbuf, + size_t count, loff_t *ppos) +{ + struct mbox_test_device *tdev = filp->private_data; + void *data; + int ret; + + if (!tdev->tx_channel) { + dev_err(tdev->dev, "Channel cannot do Tx\n"); + return -EINVAL; + } + + if (count > MBOX_MAX_MSG_LEN) { + dev_err(tdev->dev, + "Message length %zd greater than max allowed %d\n", + count, MBOX_MAX_MSG_LEN); + return -EINVAL; + } + + tdev->message = kzalloc(MBOX_MAX_MSG_LEN, GFP_KERNEL); + if (!tdev->message) + return -ENOMEM; + + ret = copy_from_user(tdev->message, userbuf, count); + if (ret) { + ret = -EFAULT; + goto out; + } + + if (tdev->tx_mmio && tdev->signal) { + print_hex_dump_bytes("Client: Sending: Signal: ", DUMP_PREFIX_ADDRESS, + tdev->signal, MBOX_MAX_SIG_LEN); + + data = tdev->signal; + } else + data = tdev->message; + + print_hex_dump_bytes("Client: Sending: Message: ", DUMP_PREFIX_ADDRESS, + tdev->message, MBOX_MAX_MSG_LEN); + + ret = mbox_send_message(tdev->tx_channel, data); + mbox_chan_txdone(tdev->tx_channel, ret); + if (ret < 0) + dev_err(tdev->dev, "Failed to send message via mailbox\n"); out: - kfree(tdev->signal); - kfree(tdev->message); - tdev->signal = NULL; + kfree(tdev->signal); + kfree(tdev->message); + tdev->signal = NULL; - return ret < 0 ? ret : count; + return ret < 0 ? ret : count; } -static bool mbox_test_message_data_ready(struct mbox_test_device *tdev){ - bool data_ready; - unsigned long flags; +static bool mbox_test_message_data_ready(struct mbox_test_device *tdev) +{ + bool data_ready; + unsigned long flags; - spin_lock_irqsave(&tdev->lock, flags); - data_ready = mbox_data_ready; - spin_unlock_irqrestore(&tdev->lock, flags); + spin_lock_irqsave(&tdev->lock, flags); + data_ready = mbox_data_ready; + spin_unlock_irqrestore(&tdev->lock, flags); - return data_ready; + return data_ready; } static ssize_t mbox_test_message_read(struct file *filp, char __user *userbuf, - size_t count, loff_t *ppos){ - struct mbox_test_device *tdev = filp->private_data; - unsigned long flags; - char *touser, *ptr; - int l = 0; - int ret; + size_t count, loff_t *ppos) +{ + struct mbox_test_device *tdev = filp->private_data; + unsigned long flags; + char *touser, *ptr; + int ret; - touser = kzalloc(MBOX_HEXDUMP_MAX_LEN + 1, GFP_KERNEL); - if (!touser) - return -ENOMEM; + touser = kzalloc(MBOX_HEXDUMP_MAX_LEN + 1, GFP_KERNEL); + if (!touser) + return -ENOMEM; - if (!tdev->rx_channel) { - ret = snprintf(touser, 20, "\n"); - ret = simple_read_from_buffer(userbuf, count, ppos, - touser, ret); - goto kfree_err; - } + if (!tdev->rx_channel) { + ret = snprintf(touser, 20, "\n"); + ret = simple_read_from_buffer(userbuf, count, ppos, + touser, ret); + goto kfree_err; + } - do { - if (mbox_test_message_data_ready(tdev)) - break; + do { + if (mbox_test_message_data_ready(tdev)) + break; - if (filp->f_flags & O_NONBLOCK) { - ret = -EAGAIN; - goto waitq_err; - } + if (filp->f_flags & O_NONBLOCK) { + ret = -EAGAIN; + goto waitq_err; + } - if (signal_pending(current)) { - ret = -ERESTARTSYS; - goto waitq_err; - } - schedule(); + if (signal_pending(current)) { + ret = -ERESTARTSYS; + goto waitq_err; + } + schedule(); - } while (1); + } while (1); - spin_lock_irqsave(&tdev->lock, flags); + spin_lock_irqsave(&tdev->lock, flags); - ptr = tdev->rx_buffer; + ptr = tdev->rx_buffer; - mbox_data_ready = false; + mbox_data_ready = false; - spin_unlock_irqrestore(&tdev->lock, flags); - if (copy_to_user((void __user *)userbuf,ptr,4)) - ret = -EFAULT; + spin_unlock_irqrestore(&tdev->lock, flags); + if (copy_to_user((void __user *)userbuf, ptr, 4)) + ret = -EFAULT; waitq_err: - __set_current_state(TASK_RUNNING); + __set_current_state(TASK_RUNNING); kfree_err: - kfree(touser); - return ret; + kfree(touser); + return ret; } static __poll_t -mbox_test_message_poll(struct file *filp, struct poll_table_struct *wait){ - struct mbox_test_device *tdev = filp->private_data; +mbox_test_message_poll(struct file *filp, struct poll_table_struct *wait) +{ + struct mbox_test_device *tdev = filp->private_data; - poll_wait(filp, &tdev->waitq, wait); + poll_wait(filp, &tdev->waitq, wait); - if (mbox_test_message_data_ready(tdev)) - return EPOLLIN | EPOLLRDNORM; - return 0; + if (mbox_test_message_data_ready(tdev)) + return EPOLLIN | EPOLLRDNORM; + return 0; } static const struct file_operations mbox_test_message_ops = { - .write = mbox_test_message_write, - .read = mbox_test_message_read, - .fasync = mbox_test_message_fasync, - .poll = mbox_test_message_poll, - .open = simple_open, - .llseek = generic_file_llseek, + .write = mbox_test_message_write, + .read = mbox_test_message_read, + .fasync = mbox_test_message_fasync, + .poll = mbox_test_message_poll, + .open = simple_open, + .llseek = generic_file_llseek, }; static int mbox_test_add_debugfs(struct platform_device *pdev, - struct mbox_test_device *tdev){ - if (!debugfs_initialized()) - return 0; + struct mbox_test_device *tdev) +{ + if (!debugfs_initialized()) + return 0; - tdev->root_debugfs_dir = debugfs_create_dir(dev_name(&pdev->dev), NULL); - if (!tdev->root_debugfs_dir) { - dev_err(&pdev->dev, "Failed to create Mailbox debugfs\n"); - return -EINVAL; - } + tdev->root_debugfs_dir = debugfs_create_dir(dev_name(&pdev->dev), NULL); + if (!tdev->root_debugfs_dir) { + dev_err(&pdev->dev, "Failed to create Mailbox debugfs\n"); + return -EINVAL; + } - debugfs_create_file("message", 0600, tdev->root_debugfs_dir, - tdev, &mbox_test_message_ops); + debugfs_create_file("message", 0600, tdev->root_debugfs_dir, + tdev, &mbox_test_message_ops); - debugfs_create_file("signal", 0200, tdev->root_debugfs_dir, - tdev, &mbox_test_signal_ops); + debugfs_create_file("signal", 0200, tdev->root_debugfs_dir, + tdev, &mbox_test_signal_ops); - return 0; + return 0; } -static void mbox_test_receive_message(struct mbox_client *client, void *message){ - struct mbox_test_device *tdev = dev_get_drvdata(client->dev); - unsigned long flags; - - spin_lock_irqsave(&tdev->lock, flags); - if (tdev->rx_mmio) { - memcpy_fromio(tdev->rx_buffer, tdev->rx_mmio, MBOX_MAX_MSG_LEN); - print_hex_dump_bytes("Client: Received [MMIO]: ", DUMP_PREFIX_ADDRESS, - tdev->rx_buffer, MBOX_MAX_MSG_LEN); - } else if (message) { - print_hex_dump_bytes("Client: Received [API]: ", DUMP_PREFIX_ADDRESS, - message, MBOX_MAX_MSG_LEN); - memcpy(tdev->rx_buffer, message, MBOX_MAX_MSG_LEN); - } - mbox_data_ready = true; - spin_unlock_irqrestore(&tdev->lock, flags); +static void mbox_test_receive_message(struct mbox_client *client, void *message) +{ + struct mbox_test_device *tdev = dev_get_drvdata(client->dev); + unsigned long flags; + + spin_lock_irqsave(&tdev->lock, flags); + if (tdev->rx_mmio) { + memcpy_fromio(tdev->rx_buffer, tdev->rx_mmio, MBOX_MAX_MSG_LEN); + print_hex_dump_bytes("Client: Received [MMIO]: ", DUMP_PREFIX_ADDRESS, + tdev->rx_buffer, MBOX_MAX_MSG_LEN); + } else if (message) { + print_hex_dump_bytes("Client: Received [API]: ", DUMP_PREFIX_ADDRESS, + message, MBOX_MAX_MSG_LEN); + memcpy(tdev->rx_buffer, message, MBOX_MAX_MSG_LEN); + } + mbox_data_ready = true; + spin_unlock_irqrestore(&tdev->lock, flags); } -static void mbox_test_prepare_message(struct mbox_client *client, void *message){ - struct mbox_test_device *tdev = dev_get_drvdata(client->dev); +static void mbox_test_prepare_message(struct mbox_client *client, void *message) +{ + struct mbox_test_device *tdev = dev_get_drvdata(client->dev); - if (tdev->tx_mmio) { - if (tdev->signal) - memcpy_toio(tdev->tx_mmio, tdev->message, MBOX_MAX_MSG_LEN); - else - memcpy_toio(tdev->tx_mmio, message, MBOX_MAX_MSG_LEN); - } + if (tdev->tx_mmio) { + if (tdev->signal) + memcpy_toio(tdev->tx_mmio, tdev->message, MBOX_MAX_MSG_LEN); + else + memcpy_toio(tdev->tx_mmio, message, MBOX_MAX_MSG_LEN); + } } static void mbox_test_message_sent(struct mbox_client *client, - void *message, int r){ - if (r) - dev_warn(client->dev, - "Client: Message could not be sent: %d\n", r); - else - dev_info(client->dev, - "Client: Message sent\n"); + void *message, int r) +{ + if (r) + dev_warn(client->dev, + "Client: Message could not be sent: %d\n", r); + else + dev_info(client->dev, + "Client: Message sent\n"); } static struct mbox_chan * -mbox_test_request_channel(struct platform_device *pdev, const char *name){ - struct mbox_client *client; - struct mbox_chan *channel; - - client = devm_kzalloc(&pdev->dev, sizeof(*client), GFP_KERNEL); - if (!client) - return ERR_PTR(-ENOMEM); - - client->dev = &pdev->dev; - client->rx_callback = mbox_test_receive_message; - client->tx_prepare = mbox_test_prepare_message; - client->tx_done = mbox_test_message_sent; - client->tx_block = false; - client->knows_txdone = false; - client->tx_tout = 500; - - channel = mbox_request_channel_byname(client, name); - if (IS_ERR(channel)) { - dev_warn(&pdev->dev, "Failed to request %s channel\n", name); - return NULL; - } - - return channel; +mbox_test_request_channel(struct platform_device *pdev, const char *name) +{ + struct mbox_client *client; + struct mbox_chan *channel; + + client = devm_kzalloc(&pdev->dev, sizeof(*client), GFP_KERNEL); + if (!client) + return ERR_PTR(-ENOMEM); + + client->dev = &pdev->dev; + client->rx_callback = mbox_test_receive_message; + client->tx_prepare = mbox_test_prepare_message; + client->tx_done = mbox_test_message_sent; + client->tx_block = false; + client->knows_txdone = false; + client->tx_tout = 500; + + channel = mbox_request_channel_byname(client, name); + if (IS_ERR(channel)) { + dev_warn(&pdev->dev, "Failed to request %s channel\n", name); + return NULL; + } + + return channel; } -static int mbox_test_probe(struct platform_device *pdev){ - struct mbox_test_device *tdev; - struct resource *res; - resource_size_t size; - int ret; - - tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL); - if (!tdev) - return -ENOMEM; - - /* It's okay for MMIO to be NULL */ - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - tdev->tx_mmio = devm_ioremap_resource(&pdev->dev, res); - if (PTR_ERR(tdev->tx_mmio) == -EBUSY) { - /* if reserved area in SRAM, try just ioremap */ - size = resource_size(res); - tdev->tx_mmio = devm_ioremap(&pdev->dev, res->start, size); - } else if (IS_ERR(tdev->tx_mmio)) { - tdev->tx_mmio = NULL; - } - - /* If specified, second reg entry is Rx MMIO */ - res = platform_get_resource(pdev, IORESOURCE_MEM, 1); - tdev->rx_mmio = devm_ioremap_resource(&pdev->dev, res); - if (PTR_ERR(tdev->rx_mmio) == -EBUSY) { - size = resource_size(res); - tdev->rx_mmio = devm_ioremap(&pdev->dev, res->start, size); - } else if (IS_ERR(tdev->rx_mmio)) { - tdev->rx_mmio = tdev->tx_mmio; - } - - tdev->tx_channel = mbox_test_request_channel(pdev, "tx"); - tdev->rx_channel = mbox_test_request_channel(pdev, "rx"); - - if (!tdev->tx_channel && !tdev->rx_channel) - return -EPROBE_DEFER; - - /* If Rx is not specified but has Rx MMIO, then Rx = Tx */ - if (!tdev->rx_channel && (tdev->rx_mmio != tdev->tx_mmio)) - tdev->rx_channel = tdev->tx_channel; - - tdev->dev = &pdev->dev; - platform_set_drvdata(pdev, tdev); - - spin_lock_init(&tdev->lock); - - if (tdev->rx_channel) - { - tdev->rx_buffer = devm_kzalloc(&pdev->dev, - MBOX_MAX_MSG_LEN, GFP_KERNEL); - if (!tdev->rx_buffer) - return -ENOMEM; - } - - ret = mbox_test_add_debugfs(pdev, tdev); - if (ret) - return ret; - - dev_info(&pdev->dev, "Successfully registered\n"); - - return 0; +static int mbox_test_probe(struct platform_device *pdev) +{ + struct mbox_test_device *tdev; + struct resource *res; + resource_size_t size; + int ret; + + tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL); + if (!tdev) + return -ENOMEM; + + /* It's okay for MMIO to be NULL */ + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + tdev->tx_mmio = devm_ioremap_resource(&pdev->dev, res); + if (PTR_ERR(tdev->tx_mmio) == -EBUSY) { + /* if reserved area in SRAM, try just ioremap */ + size = resource_size(res); + tdev->tx_mmio = devm_ioremap(&pdev->dev, res->start, size); + } else if (IS_ERR(tdev->tx_mmio)) { + tdev->tx_mmio = NULL; + } + + /* If specified, second reg entry is Rx MMIO */ + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + tdev->rx_mmio = devm_ioremap_resource(&pdev->dev, res); + if (PTR_ERR(tdev->rx_mmio) == -EBUSY) { + size = resource_size(res); + tdev->rx_mmio = devm_ioremap(&pdev->dev, res->start, size); + } else if (IS_ERR(tdev->rx_mmio)) { + tdev->rx_mmio = tdev->tx_mmio; + } + + tdev->tx_channel = mbox_test_request_channel(pdev, "tx"); + tdev->rx_channel = mbox_test_request_channel(pdev, "rx"); + + if (!tdev->tx_channel && !tdev->rx_channel) + return -EPROBE_DEFER; + + /* If Rx is not specified but has Rx MMIO, then Rx = Tx */ + if (!tdev->rx_channel && (tdev->rx_mmio != tdev->tx_mmio)) + tdev->rx_channel = tdev->tx_channel; + + tdev->dev = &pdev->dev; + platform_set_drvdata(pdev, tdev); + + spin_lock_init(&tdev->lock); + + if (tdev->rx_channel) { + tdev->rx_buffer = devm_kzalloc(&pdev->dev, + MBOX_MAX_MSG_LEN, GFP_KERNEL); + if (!tdev->rx_buffer) + return -ENOMEM; + } + + ret = mbox_test_add_debugfs(pdev, tdev); + if (ret) + return ret; + + dev_info(&pdev->dev, "Successfully registered\n"); + + return 0; } -static int mbox_test_remove(struct platform_device *pdev){ - struct mbox_test_device *tdev = platform_get_drvdata(pdev); +static int mbox_test_remove(struct platform_device *pdev) +{ + struct mbox_test_device *tdev = platform_get_drvdata(pdev); - debugfs_remove_recursive(tdev->root_debugfs_dir); + debugfs_remove_recursive(tdev->root_debugfs_dir); - if (tdev->tx_channel) - mbox_free_channel(tdev->tx_channel); - if (tdev->rx_channel) - mbox_free_channel(tdev->rx_channel); + if (tdev->tx_channel) + mbox_free_channel(tdev->tx_channel); + if (tdev->rx_channel) + mbox_free_channel(tdev->rx_channel); - return 0; + return 0; } static const struct of_device_id mbox_test_match[] = { - { .compatible = "starfive,mailbox-test" }, - {}, + { .compatible = "starfive,mailbox-test" }, + {}, }; MODULE_DEVICE_TABLE(of, mbox_test_match); static struct platform_driver mbox_test_driver = { - .driver = { - .name = "mailbox_test", - .of_match_table = mbox_test_match, - }, - .probe = mbox_test_probe, - .remove = mbox_test_remove, + .driver = { + .name = "mailbox_test", + .of_match_table = mbox_test_match, + }, + .probe = mbox_test_probe, + .remove = mbox_test_remove, }; module_platform_driver(mbox_test_driver); diff --git a/drivers/mailbox/starfive_mailbox.c b/drivers/mailbox/starfive_mailbox.c index e2884a1..d8081c4 100644 --- a/drivers/mailbox/starfive_mailbox.c +++ b/drivers/mailbox/starfive_mailbox.c @@ -1,7 +1,6 @@ +// SPDX-License-Identifier: GPL-2.0 /*********************************Copyright (c)********************************************* ** - ** - ** **-------------------------------file info------------------------------------------------- ** Vrsions: V1.0 ** Filename: starfive_mailbox.c @@ -13,7 +12,7 @@ ** Name: shanlong.li ** Versions: V1.0 ** Date: 2021/06/07 - ** Description: + ** Description: ** ** ---------------------------------------------------------------------------------------- ******************************************************************************************/ @@ -29,73 +28,38 @@ #include #include #include +#include +#include #include "mailbox.h" -#define MBOX_CHAN_MAX 4 - -#define MBOX_BASE(mbox, ch) ((mbox)->base + ((ch) * 0x10)) -#define MBOX_IRQ_REG 0x00 -#define MBOX_SET_REG 0x04 -#define MBOX_CLR_REG 0x08 -#define MBOX_CMD_REG 0x0c -#define MBC_PEND_SMRY 0x100 - -static int mbox_init = 1; -module_param(mbox_init, int, 0644); -MODULE_PARM_DESC(mbox_init, "mbox_init on command."); - -static void saif_clear_rst (void __iomem* addr,void __iomem* addr_status,uint32_t mask){ - uint32_t tmp; - tmp = readl(addr); - tmp &= ~mask; - writel(tmp,addr); - do{ - tmp = readl(addr_status); - }while((tmp&mask)!=mask); -} - -static void saif_set_reg(void __iomem* addr,uint32_t data,uint32_t shift,uint32_t mask){ - uint32_t tmp; - tmp = readl(addr); - tmp &= ~mask; - tmp |= (data<base + ((ch) * 0x10)) +#define MBOX_IRQ_REG 0x00 +#define MBOX_SET_REG 0x04 +#define MBOX_CLR_REG 0x08 +#define MBOX_CMD_REG 0x0c +#define MBC_PEND_SMRY 0x100 + +typedef enum { + MAILBOX_CORE_U7 = 0, + MAILBOX_CORE_HIFI4, + MAILBOX_CORE_E2, + MAILBOX_CORE_RSVD0, + MAILBOX_CORE_NUM, } mailbox_core_t; struct mailbox_irq_name_c{ - int id; - char name[16]; + int id; + char name[16]; }; static const struct mailbox_irq_name_c irq_peer_name[MBOX_CHAN_MAX] = { - {MAILBOX_CORE_U7, "u74_core"}, - {MAILBOX_CORE_HIFI4, "hifi4_core"}, - {MAILBOX_CORE_E2, "e24_core"}, - {MAILBOX_CORE_RSVD0, "" }, + {MAILBOX_CORE_U7, "u74_core"}, + {MAILBOX_CORE_HIFI4, "hifi4_core"}, + {MAILBOX_CORE_E2, "e24_core"}, + {MAILBOX_CORE_RSVD0, "" }, }; /** @@ -109,8 +73,8 @@ static const struct mailbox_irq_name_c irq_peer_name[MBOX_CHAN_MAX] = { * @core_id: id for remote processor */ struct starfive_chan_info { - unsigned int dst_irq; - mailbox_core_t core_id; + unsigned int dst_irq; + mailbox_core_t core_id; }; /** @@ -126,210 +90,227 @@ struct starfive_chan_info { * @controller: Representation of a communication channel controller */ struct starfive_mbox { - struct device *dev; - void __iomem *base; - struct mbox_chan chan[MBOX_CHAN_MAX]; - struct starfive_chan_info mchan[MBOX_CHAN_MAX]; - struct mbox_controller controller; + struct device *dev; + void __iomem *base; + struct mbox_chan chan[MBOX_CHAN_MAX]; + struct starfive_chan_info mchan[MBOX_CHAN_MAX]; + struct mbox_controller controller; + struct clk *clk; + struct reset_control *rst_rresetn; }; -static struct starfive_mbox *to_starfive_mbox(struct mbox_controller *mbox){ - return container_of(mbox, struct starfive_mbox, controller); +static struct starfive_mbox *to_starfive_mbox(struct mbox_controller *mbox) +{ + return container_of(mbox, struct starfive_mbox, controller); } static struct mbox_chan * starfive_of_mbox_index_xlate(struct mbox_controller *mbox, - const struct of_phandle_args *sp){ - int ind = sp->args[0]; - int core_id = sp->args[1]; + const struct of_phandle_args *sp) +{ + struct starfive_mbox *sbox; - if (ind >= mbox->num_chans || core_id >= MAILBOX_CORE_NUM) - return ERR_PTR(-EINVAL); + int ind = sp->args[0]; + int core_id = sp->args[1]; - struct starfive_mbox *sbox = to_starfive_mbox(mbox); - sbox->mchan[ind].core_id = core_id; + if (ind >= mbox->num_chans || core_id >= MAILBOX_CORE_NUM) + return ERR_PTR(-EINVAL); - return &mbox->chans[ind]; -} + sbox = to_starfive_mbox(mbox); -static irqreturn_t starfive_rx_irq_handler(int irq, void *p){ - struct mbox_chan *chan = p; - unsigned long ch = (unsigned long)chan->con_priv; - struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); - void __iomem *base = MBOX_BASE(mbox, ch); - u32 val; + sbox->mchan[ind].core_id = core_id; - val = readl(base + MBOX_CMD_REG); - if (!val) - return IRQ_NONE; + return &mbox->chans[ind]; +} - mbox_chan_received_data(chan, (void *)&val); - writel(val, base + MBOX_CLR_REG); - return IRQ_HANDLED; +static irqreturn_t starfive_rx_irq_handler(int irq, void *p) +{ + struct mbox_chan *chan = p; + unsigned long ch = (unsigned long)chan->con_priv; + struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); + void __iomem *base = MBOX_BASE(mbox, ch); + u32 val; + + val = readl(base + MBOX_CMD_REG); + if (!val) + return IRQ_NONE; + + mbox_chan_received_data(chan, (void *)&val); + writel(val, base + MBOX_CLR_REG); + return IRQ_HANDLED; } -static int starfive_mbox_check_state(struct mbox_chan *chan){ - unsigned long ch = (unsigned long)chan->con_priv; - struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); - void __iomem *base = MBOX_BASE(mbox, ch); - long ret = 0; - - /* Mailbox is idle so directly bail out */ - if (readl(mbox->base + MBC_PEND_SMRY) & BIT(ch)) - return -EBUSY; - - /* Ensure channel is released */ -// writel(0x0, base + MBOX_IRQ_REG); -// writel(0x0, base + MBOX_CLR_REG); - - if(mbox->mchan[ch].dst_irq > 0){ - dev_dbg(mbox->dev, "%s: host IRQ = %d, ch:%d",__func__, mbox->mchan[ch].dst_irq,ch); - ret = devm_request_irq(mbox->dev, mbox->mchan[ch].dst_irq, starfive_rx_irq_handler, - IRQF_SHARED, irq_peer_name[ch].name, chan); - if (ret < 0) { - dev_err(mbox->dev, "request_irq %d failed\n", mbox->mchan[ch].dst_irq); - } - } - - return ret; +static int starfive_mbox_check_state(struct mbox_chan *chan) +{ + unsigned long ch = (unsigned long)chan->con_priv; + struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); + long ret = 0; + + /* Mailbox is idle so directly bail out */ + if (readl(mbox->base + MBC_PEND_SMRY) & BIT(ch)) + return -EBUSY; + + if (mbox->mchan[ch].dst_irq > 0) { + dev_dbg(mbox->dev, "%s: host IRQ = %d, ch:%ld", __func__, mbox->mchan[ch].dst_irq, ch); + ret = devm_request_irq(mbox->dev, mbox->mchan[ch].dst_irq, starfive_rx_irq_handler, + IRQF_SHARED, irq_peer_name[ch].name, chan); + if (ret < 0) + dev_err(mbox->dev, "request_irq %d failed\n", mbox->mchan[ch].dst_irq); + } + + return ret; } -static int starfive_mbox_startup(struct mbox_chan *chan){ - return starfive_mbox_check_state(chan); +static int starfive_mbox_startup(struct mbox_chan *chan) +{ + return starfive_mbox_check_state(chan); } -static void starfive_mbox_shutdown(struct mbox_chan *chan){ - struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); - unsigned long ch = (unsigned long)chan->con_priv; - void __iomem *base = MBOX_BASE(mbox, ch); - - writel(0x0, base + MBOX_IRQ_REG); - writel(0x0, base + MBOX_CLR_REG); - - if(mbox->mchan[ch].dst_irq > 0){ - devm_free_irq(mbox->dev,mbox->mchan[ch].dst_irq, chan); - } +static void starfive_mbox_shutdown(struct mbox_chan *chan) +{ + struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); + unsigned long ch = (unsigned long)chan->con_priv; + void __iomem *base = MBOX_BASE(mbox, ch); + + writel(0x0, base + MBOX_IRQ_REG); + writel(0x0, base + MBOX_CLR_REG); + + if (mbox->mchan[ch].dst_irq > 0) + devm_free_irq(mbox->dev, mbox->mchan[ch].dst_irq, chan); } -static int starfive_mbox_send_data(struct mbox_chan *chan, void *msg){ - unsigned long ch = (unsigned long)chan->con_priv; - struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); - struct starfive_chan_info *mchan = &mbox->mchan[ch]; - void __iomem *base = MBOX_BASE(mbox, ch); - u32 *buf = msg; - - /* Ensure channel is released */ - if (readl(mbox->base + MBC_PEND_SMRY) & BIT(ch)){ - pr_debug("%s:%d. busy\n",__func__,__LINE__); - return -EBUSY; - } - - /* Clear mask for destination interrupt */ - writel(BIT(mchan->core_id), base + MBOX_IRQ_REG); - - /* Fill message data */ - writel(*buf, base + MBOX_SET_REG); - return 0; +static int starfive_mbox_send_data(struct mbox_chan *chan, void *msg) +{ + unsigned long ch = (unsigned long)chan->con_priv; + struct starfive_mbox *mbox = to_starfive_mbox(chan->mbox); + struct starfive_chan_info *mchan = &mbox->mchan[ch]; + void __iomem *base = MBOX_BASE(mbox, ch); + u32 *buf = msg; + + /* Ensure channel is released */ + if (readl(mbox->base + MBC_PEND_SMRY) & BIT(ch)) { + pr_debug("%s:%d. busy\n", __func__, __LINE__); + return -EBUSY; + } + + /* Clear mask for destination interrupt */ + writel(BIT(mchan->core_id), base + MBOX_IRQ_REG); + + /* Fill message data */ + writel(*buf, base + MBOX_SET_REG); + return 0; } static struct mbox_chan_ops starfive_mbox_ops = { - .startup = starfive_mbox_startup, - .send_data = starfive_mbox_send_data, - .shutdown = starfive_mbox_shutdown, + .startup = starfive_mbox_startup, + .send_data = starfive_mbox_send_data, + .shutdown = starfive_mbox_shutdown, }; static const struct of_device_id starfive_mbox_of_match[] = { - { .compatible = "starfive,mail_box", }, - {}, + { .compatible = "starfive,mail_box",}, + {}, }; MODULE_DEVICE_TABLE(of, starfive_mbox_of_match); -void __iomem *clk_apb_ctrl_addr; -void starfive_mailbox_init(void){ - clk_apb_ctrl_addr = ioremap(0x13020000, 0x1000); - - pr_debug("%s:.\n",__func__); - _ENABLE_CLOCK_CLK_U0_MAILBOX_CLK_APB_(clk_apb_ctrl_addr); - _CLEAR_RESET_RSTGEN_RSTN_U0_MAILBOX_PRESETN_(clk_apb_ctrl_addr); +void starfive_mailbox_init(struct starfive_mbox *mbox) +{ + mbox->clk = devm_clk_get_optional(mbox->dev, "clk_apb"); + if (IS_ERR(mbox->clk)) { + dev_err(mbox->dev, "failed to get mailbox\n"); + return; + } + + mbox->rst_rresetn = devm_reset_control_get_exclusive(mbox->dev, "mbx_rre"); + if (IS_ERR(mbox->rst_rresetn)) { + dev_err(mbox->dev, "failed to get mailbox reset\n"); + return; + } + + clk_prepare_enable(mbox->clk); + reset_control_deassert(mbox->rst_rresetn); } -static int starfive_mbox_probe(struct platform_device *pdev){ - struct device *dev = &pdev->dev; - struct starfive_mbox *mbox; - struct mbox_chan *chan; - struct resource *res; - unsigned long ch; - int err; - - mbox = devm_kzalloc(dev, sizeof(*mbox), GFP_KERNEL); - if (!mbox) - return -ENOMEM; - - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - mbox->base = devm_ioremap_resource(dev, res); - - if (IS_ERR(mbox->base)) - return PTR_ERR(mbox->base); - - if(mbox_init) - starfive_mailbox_init(); - - mbox->dev = dev; - mbox->controller.dev = dev; - mbox->controller.chans = mbox->chan; - mbox->controller.num_chans = MBOX_CHAN_MAX; - mbox->controller.ops = &starfive_mbox_ops; - mbox->controller.of_xlate = starfive_of_mbox_index_xlate; - mbox->controller.txdone_irq = true; - mbox->controller.txdone_poll = false; - - /* Initialize mailbox channel data */ - chan = mbox->chan; - for(ch = 0;ch < MBOX_CHAN_MAX;ch++){ - mbox->mchan[ch].dst_irq = 0; - mbox->mchan[ch].core_id = (mailbox_core_t)ch; - chan[ch].con_priv = (void *)ch; - } - mbox->mchan[MAILBOX_CORE_HIFI4].dst_irq = platform_get_irq(pdev, 0); - mbox->mchan[MAILBOX_CORE_E2].dst_irq = platform_get_irq(pdev, 1); - - err = mbox_controller_register(&mbox->controller); - if (err) { - dev_err(dev, "Failed to register mailbox %d\n", err); - return err; - } - - platform_set_drvdata(pdev, mbox); - dev_info(dev, "Mailbox enabled\n"); - return 0; +static int starfive_mbox_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct starfive_mbox *mbox; + struct mbox_chan *chan; + struct resource *res; + unsigned long ch; + int err; + + mbox = devm_kzalloc(dev, sizeof(*mbox), GFP_KERNEL); + if (!mbox) + return -ENOMEM; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + mbox->base = devm_ioremap_resource(dev, res); + mbox->dev = dev; + + if (IS_ERR(mbox->base)) + return PTR_ERR(mbox->base); + + starfive_mailbox_init(mbox); + + mbox->controller.dev = dev; + mbox->controller.chans = mbox->chan; + mbox->controller.num_chans = MBOX_CHAN_MAX; + mbox->controller.ops = &starfive_mbox_ops; + mbox->controller.of_xlate = starfive_of_mbox_index_xlate; + mbox->controller.txdone_irq = true; + mbox->controller.txdone_poll = false; + + /* Initialize mailbox channel data */ + chan = mbox->chan; + for (ch = 0; ch < MBOX_CHAN_MAX; ch++) { + mbox->mchan[ch].dst_irq = 0; + mbox->mchan[ch].core_id = (mailbox_core_t)ch; + chan[ch].con_priv = (void *)ch; + } + mbox->mchan[MAILBOX_CORE_HIFI4].dst_irq = platform_get_irq(pdev, 0); + mbox->mchan[MAILBOX_CORE_E2].dst_irq = platform_get_irq(pdev, 1); + + err = mbox_controller_register(&mbox->controller); + if (err) { + dev_err(dev, "Failed to register mailbox %d\n", err); + return err; + } + + platform_set_drvdata(pdev, mbox); + dev_info(dev, "Mailbox enabled\n"); + return 0; } -static int starfive_mbox_remove(struct platform_device *pdev){ - struct starfive_mbox *mbox = platform_get_drvdata(pdev); +static int starfive_mbox_remove(struct platform_device *pdev) +{ + struct starfive_mbox *mbox = platform_get_drvdata(pdev); + + mbox_controller_unregister(&mbox->controller); + devm_clk_put(mbox->dev, mbox->clk); - mbox_controller_unregister(&mbox->controller); - if(clk_apb_ctrl_addr) - iounmap(clk_apb_ctrl_addr); - return 0; + return 0; } static struct platform_driver starfive_mbox_driver = { - .probe = starfive_mbox_probe, - .remove = starfive_mbox_remove, - .driver = { - .name = "mailbox", - .of_match_table = starfive_mbox_of_match, - }, + .probe = starfive_mbox_probe, + .remove = starfive_mbox_remove, + .driver = { + .name = "mailbox", + .of_match_table = starfive_mbox_of_match, + }, }; -static int __init starfive_mbox_init(void){ - return platform_driver_register(&starfive_mbox_driver); +static int __init starfive_mbox_init(void) +{ + return platform_driver_register(&starfive_mbox_driver); } core_initcall(starfive_mbox_init); -static void __exit starfive_mbox_exit(void){ - platform_driver_unregister(&starfive_mbox_driver); +static void __exit starfive_mbox_exit(void) +{ + platform_driver_unregister(&starfive_mbox_driver); } module_exit(starfive_mbox_exit);