Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * STi Mailbox
0004  *
0005  * Copyright (C) 2015 ST Microelectronics
0006  *
0007  * Author: Lee Jones <lee.jones@linaro.org> for ST Microelectronics
0008  *
0009  * Based on the original driver written by;
0010  *   Alexandre Torgue, Olivier Lebreton and Loic Pallardy
0011  */
0012 
0013 #include <linux/err.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/io.h>
0016 #include <linux/kernel.h>
0017 #include <linux/mailbox_controller.h>
0018 #include <linux/module.h>
0019 #include <linux/of.h>
0020 #include <linux/of_device.h>
0021 #include <linux/platform_device.h>
0022 #include <linux/slab.h>
0023 
0024 #include "mailbox.h"
0025 
0026 #define STI_MBOX_INST_MAX   4      /* RAM saving: Max supported instances */
0027 #define STI_MBOX_CHAN_MAX   20     /* RAM saving: Max supported channels  */
0028 
0029 #define STI_IRQ_VAL_OFFSET  0x04   /* Read interrupt status               */
0030 #define STI_IRQ_SET_OFFSET  0x24   /* Generate a Tx channel interrupt     */
0031 #define STI_IRQ_CLR_OFFSET  0x44   /* Clear pending Rx interrupts         */
0032 #define STI_ENA_VAL_OFFSET  0x64   /* Read enable status              */
0033 #define STI_ENA_SET_OFFSET  0x84   /* Enable a channel            */
0034 #define STI_ENA_CLR_OFFSET  0xa4   /* Disable a channel           */
0035 
0036 #define MBOX_BASE(mdev, inst)   ((mdev)->base + ((inst) * 4))
0037 
0038 /**
0039  * struct sti_mbox_device - STi Mailbox device data
0040  *
0041  * @dev:    Device to which it is attached
0042  * @mbox:   Representation of a communication channel controller
0043  * @base:   Base address of the register mapping region
0044  * @name:   Name of the mailbox
0045  * @enabled:    Local copy of enabled channels
0046  * @lock:   Mutex protecting enabled status
0047  *
0048  * An IP Mailbox is currently composed of 4 instances
0049  * Each instance is currently composed of 32 channels
0050  * This means that we have 128 channels per Mailbox
0051  * A channel an be used for TX or RX
0052  */
0053 struct sti_mbox_device {
0054     struct device       *dev;
0055     struct mbox_controller  *mbox;
0056     void __iomem        *base;
0057     const char      *name;
0058     u32         enabled[STI_MBOX_INST_MAX];
0059     spinlock_t      lock;
0060 };
0061 
0062 /**
0063  * struct sti_mbox_pdata - STi Mailbox platform specific configuration
0064  *
0065  * @num_inst:   Maximum number of instances in one HW Mailbox
0066  * @num_chan:   Maximum number of channel per instance
0067  */
0068 struct sti_mbox_pdata {
0069     unsigned int        num_inst;
0070     unsigned int        num_chan;
0071 };
0072 
0073 /**
0074  * struct sti_channel - STi Mailbox allocated channel information
0075  *
0076  * @mdev:   Pointer to parent Mailbox device
0077  * @instance:   Instance number channel resides in
0078  * @channel:    Channel number pertaining to this container
0079  */
0080 struct sti_channel {
0081     struct sti_mbox_device  *mdev;
0082     unsigned int        instance;
0083     unsigned int        channel;
0084 };
0085 
0086 static inline bool sti_mbox_channel_is_enabled(struct mbox_chan *chan)
0087 {
0088     struct sti_channel *chan_info = chan->con_priv;
0089     struct sti_mbox_device *mdev = chan_info->mdev;
0090     unsigned int instance = chan_info->instance;
0091     unsigned int channel = chan_info->channel;
0092 
0093     return mdev->enabled[instance] & BIT(channel);
0094 }
0095 
0096 static inline
0097 struct mbox_chan *sti_mbox_to_channel(struct mbox_controller *mbox,
0098                       unsigned int instance,
0099                       unsigned int channel)
0100 {
0101     struct sti_channel *chan_info;
0102     int i;
0103 
0104     for (i = 0; i < mbox->num_chans; i++) {
0105         chan_info = mbox->chans[i].con_priv;
0106         if (chan_info &&
0107             chan_info->instance == instance &&
0108             chan_info->channel == channel)
0109             return &mbox->chans[i];
0110     }
0111 
0112     dev_err(mbox->dev,
0113         "Channel not registered: instance: %d channel: %d\n",
0114         instance, channel);
0115 
0116     return NULL;
0117 }
0118 
0119 static void sti_mbox_enable_channel(struct mbox_chan *chan)
0120 {
0121     struct sti_channel *chan_info = chan->con_priv;
0122     struct sti_mbox_device *mdev = chan_info->mdev;
0123     unsigned int instance = chan_info->instance;
0124     unsigned int channel = chan_info->channel;
0125     unsigned long flags;
0126     void __iomem *base = MBOX_BASE(mdev, instance);
0127 
0128     spin_lock_irqsave(&mdev->lock, flags);
0129     mdev->enabled[instance] |= BIT(channel);
0130     writel_relaxed(BIT(channel), base + STI_ENA_SET_OFFSET);
0131     spin_unlock_irqrestore(&mdev->lock, flags);
0132 }
0133 
0134 static void sti_mbox_disable_channel(struct mbox_chan *chan)
0135 {
0136     struct sti_channel *chan_info = chan->con_priv;
0137     struct sti_mbox_device *mdev = chan_info->mdev;
0138     unsigned int instance = chan_info->instance;
0139     unsigned int channel = chan_info->channel;
0140     unsigned long flags;
0141     void __iomem *base = MBOX_BASE(mdev, instance);
0142 
0143     spin_lock_irqsave(&mdev->lock, flags);
0144     mdev->enabled[instance] &= ~BIT(channel);
0145     writel_relaxed(BIT(channel), base + STI_ENA_CLR_OFFSET);
0146     spin_unlock_irqrestore(&mdev->lock, flags);
0147 }
0148 
0149 static void sti_mbox_clear_irq(struct mbox_chan *chan)
0150 {
0151     struct sti_channel *chan_info = chan->con_priv;
0152     struct sti_mbox_device *mdev = chan_info->mdev;
0153     unsigned int instance = chan_info->instance;
0154     unsigned int channel = chan_info->channel;
0155     void __iomem *base = MBOX_BASE(mdev, instance);
0156 
0157     writel_relaxed(BIT(channel), base + STI_IRQ_CLR_OFFSET);
0158 }
0159 
0160 static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device *mdev,
0161                          unsigned int instance)
0162 {
0163     struct mbox_controller *mbox = mdev->mbox;
0164     struct mbox_chan *chan = NULL;
0165     unsigned int channel;
0166     unsigned long bits;
0167     void __iomem *base = MBOX_BASE(mdev, instance);
0168 
0169     bits = readl_relaxed(base + STI_IRQ_VAL_OFFSET);
0170     if (!bits)
0171         /* No IRQs fired in specified instance */
0172         return NULL;
0173 
0174     /* An IRQ has fired, find the associated channel */
0175     for (channel = 0; bits; channel++) {
0176         if (!test_and_clear_bit(channel, &bits))
0177             continue;
0178 
0179         chan = sti_mbox_to_channel(mbox, instance, channel);
0180         if (chan) {
0181             dev_dbg(mbox->dev,
0182                 "IRQ fired on instance: %d channel: %d\n",
0183                 instance, channel);
0184             break;
0185         }
0186     }
0187 
0188     return chan;
0189 }
0190 
0191 static irqreturn_t sti_mbox_thread_handler(int irq, void *data)
0192 {
0193     struct sti_mbox_device *mdev = data;
0194     struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
0195     struct mbox_chan *chan;
0196     unsigned int instance;
0197 
0198     for (instance = 0; instance < pdata->num_inst; instance++) {
0199 keep_looking:
0200         chan = sti_mbox_irq_to_channel(mdev, instance);
0201         if (!chan)
0202             continue;
0203 
0204         mbox_chan_received_data(chan, NULL);
0205         sti_mbox_clear_irq(chan);
0206         sti_mbox_enable_channel(chan);
0207         goto keep_looking;
0208     }
0209 
0210     return IRQ_HANDLED;
0211 }
0212 
0213 static irqreturn_t sti_mbox_irq_handler(int irq, void *data)
0214 {
0215     struct sti_mbox_device *mdev = data;
0216     struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
0217     struct sti_channel *chan_info;
0218     struct mbox_chan *chan;
0219     unsigned int instance;
0220     int ret = IRQ_NONE;
0221 
0222     for (instance = 0; instance < pdata->num_inst; instance++) {
0223         chan = sti_mbox_irq_to_channel(mdev, instance);
0224         if (!chan)
0225             continue;
0226         chan_info = chan->con_priv;
0227 
0228         if (!sti_mbox_channel_is_enabled(chan)) {
0229             dev_warn(mdev->dev,
0230                  "Unexpected IRQ: %s\n"
0231                  "  instance: %d: channel: %d [enabled: %x]\n",
0232                  mdev->name, chan_info->instance,
0233                  chan_info->channel, mdev->enabled[instance]);
0234 
0235             /* Only handle IRQ if no other valid IRQs were found */
0236             if (ret == IRQ_NONE)
0237                 ret = IRQ_HANDLED;
0238             continue;
0239         }
0240 
0241         sti_mbox_disable_channel(chan);
0242         ret = IRQ_WAKE_THREAD;
0243     }
0244 
0245     if (ret == IRQ_NONE)
0246         dev_err(mdev->dev, "Spurious IRQ - was a channel requested?\n");
0247 
0248     return ret;
0249 }
0250 
0251 static bool sti_mbox_tx_is_ready(struct mbox_chan *chan)
0252 {
0253     struct sti_channel *chan_info = chan->con_priv;
0254     struct sti_mbox_device *mdev = chan_info->mdev;
0255     unsigned int instance = chan_info->instance;
0256     unsigned int channel = chan_info->channel;
0257     void __iomem *base = MBOX_BASE(mdev, instance);
0258 
0259     if (!(readl_relaxed(base + STI_ENA_VAL_OFFSET) & BIT(channel))) {
0260         dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d disabled\n",
0261             mdev->name, instance, channel);
0262         return false;
0263     }
0264 
0265     if (readl_relaxed(base + STI_IRQ_VAL_OFFSET) & BIT(channel)) {
0266         dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d not ready\n",
0267             mdev->name, instance, channel);
0268         return false;
0269     }
0270 
0271     return true;
0272 }
0273 
0274 static int sti_mbox_send_data(struct mbox_chan *chan, void *data)
0275 {
0276     struct sti_channel *chan_info = chan->con_priv;
0277     struct sti_mbox_device *mdev = chan_info->mdev;
0278     unsigned int instance = chan_info->instance;
0279     unsigned int channel = chan_info->channel;
0280     void __iomem *base = MBOX_BASE(mdev, instance);
0281 
0282     /* Send event to co-processor */
0283     writel_relaxed(BIT(channel), base + STI_IRQ_SET_OFFSET);
0284 
0285     dev_dbg(mdev->dev,
0286         "Sent via Mailbox %s: instance: %d channel: %d\n",
0287         mdev->name, instance, channel);
0288 
0289     return 0;
0290 }
0291 
0292 static int sti_mbox_startup_chan(struct mbox_chan *chan)
0293 {
0294     sti_mbox_clear_irq(chan);
0295     sti_mbox_enable_channel(chan);
0296 
0297     return 0;
0298 }
0299 
0300 static void sti_mbox_shutdown_chan(struct mbox_chan *chan)
0301 {
0302     struct sti_channel *chan_info = chan->con_priv;
0303     struct mbox_controller *mbox = chan_info->mdev->mbox;
0304     int i;
0305 
0306     for (i = 0; i < mbox->num_chans; i++)
0307         if (chan == &mbox->chans[i])
0308             break;
0309 
0310     if (mbox->num_chans == i) {
0311         dev_warn(mbox->dev, "Request to free non-existent channel\n");
0312         return;
0313     }
0314 
0315     /* Reset channel */
0316     sti_mbox_disable_channel(chan);
0317     sti_mbox_clear_irq(chan);
0318     chan->con_priv = NULL;
0319 }
0320 
0321 static struct mbox_chan *sti_mbox_xlate(struct mbox_controller *mbox,
0322                     const struct of_phandle_args *spec)
0323 {
0324     struct sti_mbox_device *mdev = dev_get_drvdata(mbox->dev);
0325     struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
0326     struct sti_channel *chan_info;
0327     struct mbox_chan *chan = NULL;
0328     unsigned int instance  = spec->args[0];
0329     unsigned int channel   = spec->args[1];
0330     int i;
0331 
0332     /* Bounds checking */
0333     if (instance >= pdata->num_inst || channel  >= pdata->num_chan) {
0334         dev_err(mbox->dev,
0335             "Invalid channel requested instance: %d channel: %d\n",
0336             instance, channel);
0337         return ERR_PTR(-EINVAL);
0338     }
0339 
0340     for (i = 0; i < mbox->num_chans; i++) {
0341         chan_info = mbox->chans[i].con_priv;
0342 
0343         /* Is requested channel free? */
0344         if (chan_info &&
0345             mbox->dev == chan_info->mdev->dev &&
0346             instance == chan_info->instance &&
0347             channel == chan_info->channel) {
0348 
0349             dev_err(mbox->dev, "Channel in use\n");
0350             return ERR_PTR(-EBUSY);
0351         }
0352 
0353         /*
0354          * Find the first free slot, then continue checking
0355          * to see if requested channel is in use
0356          */
0357         if (!chan && !chan_info)
0358             chan = &mbox->chans[i];
0359     }
0360 
0361     if (!chan) {
0362         dev_err(mbox->dev, "No free channels left\n");
0363         return ERR_PTR(-EBUSY);
0364     }
0365 
0366     chan_info = devm_kzalloc(mbox->dev, sizeof(*chan_info), GFP_KERNEL);
0367     if (!chan_info)
0368         return ERR_PTR(-ENOMEM);
0369 
0370     chan_info->mdev     = mdev;
0371     chan_info->instance = instance;
0372     chan_info->channel  = channel;
0373 
0374     chan->con_priv = chan_info;
0375 
0376     dev_info(mbox->dev,
0377          "Mbox: %s: Created channel: instance: %d channel: %d\n",
0378          mdev->name, instance, channel);
0379 
0380     return chan;
0381 }
0382 
0383 static const struct mbox_chan_ops sti_mbox_ops = {
0384     .startup    = sti_mbox_startup_chan,
0385     .shutdown   = sti_mbox_shutdown_chan,
0386     .send_data  = sti_mbox_send_data,
0387     .last_tx_done   = sti_mbox_tx_is_ready,
0388 };
0389 
0390 static const struct sti_mbox_pdata mbox_stih407_pdata = {
0391     .num_inst   = 4,
0392     .num_chan   = 32,
0393 };
0394 
0395 static const struct of_device_id sti_mailbox_match[] = {
0396     {
0397         .compatible = "st,stih407-mailbox",
0398         .data = (void *)&mbox_stih407_pdata
0399     },
0400     { }
0401 };
0402 MODULE_DEVICE_TABLE(of, sti_mailbox_match);
0403 
0404 static int sti_mbox_probe(struct platform_device *pdev)
0405 {
0406     const struct of_device_id *match;
0407     struct mbox_controller *mbox;
0408     struct sti_mbox_device *mdev;
0409     struct device_node *np = pdev->dev.of_node;
0410     struct mbox_chan *chans;
0411     int irq;
0412     int ret;
0413 
0414     match = of_match_device(sti_mailbox_match, &pdev->dev);
0415     if (!match) {
0416         dev_err(&pdev->dev, "No configuration found\n");
0417         return -ENODEV;
0418     }
0419     pdev->dev.platform_data = (struct sti_mbox_pdata *) match->data;
0420 
0421     mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL);
0422     if (!mdev)
0423         return -ENOMEM;
0424 
0425     platform_set_drvdata(pdev, mdev);
0426 
0427     mdev->base = devm_platform_ioremap_resource(pdev, 0);
0428     if (IS_ERR(mdev->base))
0429         return PTR_ERR(mdev->base);
0430 
0431     ret = of_property_read_string(np, "mbox-name", &mdev->name);
0432     if (ret)
0433         mdev->name = np->full_name;
0434 
0435     mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL);
0436     if (!mbox)
0437         return -ENOMEM;
0438 
0439     chans = devm_kcalloc(&pdev->dev,
0440                  STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL);
0441     if (!chans)
0442         return -ENOMEM;
0443 
0444     mdev->dev       = &pdev->dev;
0445     mdev->mbox      = mbox;
0446 
0447     spin_lock_init(&mdev->lock);
0448 
0449     /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */
0450     mbox->txdone_irq    = false;
0451     mbox->txdone_poll   = true;
0452     mbox->txpoll_period = 100;
0453     mbox->ops       = &sti_mbox_ops;
0454     mbox->dev       = mdev->dev;
0455     mbox->of_xlate      = sti_mbox_xlate;
0456     mbox->chans     = chans;
0457     mbox->num_chans     = STI_MBOX_CHAN_MAX;
0458 
0459     ret = devm_mbox_controller_register(&pdev->dev, mbox);
0460     if (ret)
0461         return ret;
0462 
0463     /* It's okay for Tx Mailboxes to not supply IRQs */
0464     irq = platform_get_irq(pdev, 0);
0465     if (irq < 0) {
0466         dev_info(&pdev->dev,
0467              "%s: Registered Tx only Mailbox\n", mdev->name);
0468         return 0;
0469     }
0470 
0471     ret = devm_request_threaded_irq(&pdev->dev, irq,
0472                     sti_mbox_irq_handler,
0473                     sti_mbox_thread_handler,
0474                     IRQF_ONESHOT, mdev->name, mdev);
0475     if (ret) {
0476         dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq);
0477         return -EINVAL;
0478     }
0479 
0480     dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name);
0481 
0482     return 0;
0483 }
0484 
0485 static struct platform_driver sti_mbox_driver = {
0486     .probe = sti_mbox_probe,
0487     .driver = {
0488         .name = "sti-mailbox",
0489         .of_match_table = sti_mailbox_match,
0490     },
0491 };
0492 module_platform_driver(sti_mbox_driver);
0493 
0494 MODULE_LICENSE("GPL");
0495 MODULE_DESCRIPTION("STMicroelectronics Mailbox Controller");
0496 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org");
0497 MODULE_ALIAS("platform:mailbox-sti");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!